ghinfe 0.6.0 → 0.6.2

package/src/nfe/services/NFeService.js

@@ -1,196 +1,196 @@
-import { NFeXmlService } from './NFeXmlService.js';
-import { NFeSignService } from './NFeSignService.js';
-import { NFeSoapService } from './NFeSoapService.js';
-import { NFeEventoService } from './NFeEventoService.js';
-import { GhinfeError } from '../../errors/GhinfeError.js';
-import { gerarChaveAcesso, validarChaveAcesso } from '../../utils/chave.utils.js';
-import { SefazEndpointResolver } from '../../sefaz/SefazEndpointResolver.js';
-
-/**
- * @param {{
- *   mock?: boolean,
- *   uf?: string,
- *   ambiente?: number,
- *   sefazEndpoint?: string,
- *   sefazEventoEndpoint?: string,
- *   mockScenario?: string,
- *   mockEventoScenario?: string,
- * }} options
- */
-function buildSoapOptions(options) {
-  if (options.mock ?? true) {
-    return {
-      mock: true,
-      endpoint: options.sefazEndpoint,
-      eventoEndpoint: options.sefazEventoEndpoint,
-      mockScenario: options.mockScenario,
-      mockEventoScenario: options.mockEventoScenario,
-    };
-  }
-
-  if (options.sefazEndpoint) {
-    return {
-      mock: false,
-      endpoint: options.sefazEndpoint,
-      eventoEndpoint: options.sefazEventoEndpoint,
-    };
-  }
-
-  if (options.uf) {
-    const urls = SefazEndpointResolver.paraNFe(options.uf, options.ambiente ?? 2);
-    return { mock: false, endpoint: urls.endpoint, eventoEndpoint: urls.eventoEndpoint };
-  }
-
-  return { mock: true };
-}
-
-/**
- * Orquestrador principal da NF-e — une geração, assinatura e envio.
- */
-export class NFeService {
-  /**
-   * @param {{
-   *   mock?: boolean,
-   *   uf?: string,
-   *   ambiente?: number,
-   *   sefazEndpoint?: string,
-   *   sefazEventoEndpoint?: string,
-   *   mockScenario?: string,
-   *   mockEventoScenario?: string,
-   *   validarXsd?: boolean,
-   * }} [options]
-   */
-  constructor(options = {}) {
-    this.options = options;
-    const soapOptions = buildSoapOptions(options);
-
-    this.xmlService = new NFeXmlService({ validarXsd: options.validarXsd });
-    this.signService = new NFeSignService();
-    this.soapService = new NFeSoapService(soapOptions);
-    this.eventoService = new NFeEventoService(soapOptions);
-  }
-
-  /** Resolve endpoints SEFAZ para a UF do documento. */
-  configurarUf(uf, ambiente = 2) {
-    const urls = SefazEndpointResolver.paraNFe(uf, ambiente);
-    this.soapService.endpoint = urls.endpoint;
-    this.soapService.eventoEndpoint = urls.eventoEndpoint;
-    this.soapService.mock = false;
-    this.eventoService.soapService.endpoint = urls.endpoint;
-    this.eventoService.soapService.eventoEndpoint = urls.eventoEndpoint;
-    this.eventoService.soapService.mock = false;
-    return urls;
-  }
-
-  /** @param {Parameters<typeof gerarChaveAcesso>[0]} params */
-  gerarChaveAcesso(params) {
-    return gerarChaveAcesso(params);
-  }
-
-  /** @param {import('../types/NFeDocument.js').NFeDocument} documento */
-  resolverDocumento(documento) {
-    if (documento.chaveAcesso) {
-      if (!validarChaveAcesso(documento.chaveAcesso)) {
-        throw new GhinfeError('chaveAcesso com dígito verificador inválido', 'CHAVE_DV_INVALIDO');
-      }
-      return documento;
-    }
-
-    const chaveAcesso = gerarChaveAcesso({
-      uf: documento.ide.uf,
-      cnpj: documento.emitente.cnpj,
-      modelo: '55',
-      serie: documento.ide.serie ?? 1,
-      numero: documento.ide.numero,
-      tipoEmissao: documento.ide.tipoEmissao ?? 1,
-    });
-
-    return { ...documento, chaveAcesso };
-  }
-
-  async emitir(documento, certificado, idLote) {
-    const doc = this.resolverDocumento(documento);
-
-    if (!this.soapService.mock && this.options.uf === undefined && !this.options.sefazEndpoint) {
-      this.configurarUf(doc.ide.uf, doc.ambiente ?? 2);
-    }
-
-    const xml = this.xmlService.gerarXml(doc);
-    const xmlAssinado = this.signService.assinar(xml, certificado.pfx, certificado.senha);
-    const retorno = await this.soapService.autorizar(xmlAssinado, doc.chaveAcesso, idLote);
-
-    return { chaveAcesso: doc.chaveAcesso, xmlGerado: xml, xmlAssinado, retorno };
-  }
-
-  gerarXml(documento, options = {}) {
-    const doc = this.resolverDocumento(documento);
-    return this.xmlService.gerarXml(doc, options);
-  }
-
-  gerarXmlAssinado(documento, certificado) {
-    const doc = this.resolverDocumento(documento);
-    const xml = this.xmlService.gerarXml(doc);
-    return this.signService.assinar(xml, certificado.pfx, certificado.senha);
-  }
-
-  async enviar(xmlAssinado, chaveAcesso) {
-    return this.soapService.autorizar(xmlAssinado, chaveAcesso);
-  }
-
-  validarXsd(xml, options = {}) {
-    return this.xmlService.validarXml(xml, options);
-  }
-
-  async cancelar(dados, certificado) {
-    return this.eventoService.cancelar(dados, certificado);
-  }
-
-  async cartaCorrecao(dados, certificado) {
-    return this.eventoService.cartaCorrecao(dados, certificado);
-  }
-
-  gerarXmlCancelamento(dados) {
-    return this.eventoService.gerarXmlCancelamento(dados);
-  }
-
-  gerarXmlCartaCorrecao(dados) {
-    return this.eventoService.gerarXmlCartaCorrecao(dados);
-  }
-
-  async enviarEventoMock(xmlEvento, chaveAcesso, tpEvento) {
-    return this.eventoService.enviar(xmlEvento, chaveAcesso, tpEvento);
-  }
-
-  /**
-   * Consulta status do webservice SEFAZ (NfeStatusServico4).
-   * @param {string} [uf]
-   * @param {number} [ambiente]
-   */
-  async consultarStatus(uf, ambiente) {
-    const ufConsulta = uf ?? this.options.uf;
-    if (!ufConsulta) {
-      throw new GhinfeError('UF é obrigatória para consultar status SEFAZ', 'STATUS_UF_REQUIRED');
-    }
-    return this.soapService.consultarStatus(ufConsulta, ambiente ?? this.options.ambiente ?? 2);
-  }
-
-  toPersistencePayload(resultado) {
-    if (!resultado.retorno.autorizado) {
-      throw new GhinfeError('Não é possível persistir NF-e não autorizada', 'NFE_NOT_AUTHORIZED', resultado.retorno);
-    }
-
-    return {
-      chave_acesso: resultado.chaveAcesso,
-      xml_nfe: resultado.xmlAssinado,
-      xml_protocolo: resultado.retorno.xmlProtocolo,
-      protocolo: resultado.retorno.protocolo,
-      status: resultado.retorno.cStat,
-      motivo: resultado.retorno.xMotivo,
-      autorizado_em: new Date(),
-    };
-  }
-
-  toEventoPersistencePayload(resultado) {
-    return this.eventoService.toPersistencePayload(resultado);
-  }
-}
+import { NFeXmlService } from './NFeXmlService.js';
+import { NFeSignService } from './NFeSignService.js';
+import { NFeSoapService } from './NFeSoapService.js';
+import { NFeEventoService } from './NFeEventoService.js';
+import { GhinfeError } from '../../errors/GhinfeError.js';
+import { gerarChaveAcesso, validarChaveAcesso } from '../../utils/chave.utils.js';
+import { SefazEndpointResolver } from '../../sefaz/SefazEndpointResolver.js';
+
+/**
+ * @param {{
+ *   mock?: boolean,
+ *   uf?: string,
+ *   ambiente?: number,
+ *   sefazEndpoint?: string,
+ *   sefazEventoEndpoint?: string,
+ *   mockScenario?: string,
+ *   mockEventoScenario?: string,
+ * }} options
+ */
+function buildSoapOptions(options) {
+  if (options.mock ?? true) {
+    return {
+      mock: true,
+      endpoint: options.sefazEndpoint,
+      eventoEndpoint: options.sefazEventoEndpoint,
+      mockScenario: options.mockScenario,
+      mockEventoScenario: options.mockEventoScenario,
+    };
+  }
+
+  if (options.sefazEndpoint) {
+    return {
+      mock: false,
+      endpoint: options.sefazEndpoint,
+      eventoEndpoint: options.sefazEventoEndpoint,
+    };
+  }
+
+  if (options.uf) {
+    const urls = SefazEndpointResolver.paraNFe(options.uf, options.ambiente ?? 2);
+    return { mock: false, endpoint: urls.endpoint, eventoEndpoint: urls.eventoEndpoint };
+  }
+
+  return { mock: true };
+}
+
+/**
+ * Orquestrador principal da NF-e — une geração, assinatura e envio.
+ */
+export class NFeService {
+  /**
+   * @param {{
+   *   mock?: boolean,
+   *   uf?: string,
+   *   ambiente?: number,
+   *   sefazEndpoint?: string,
+   *   sefazEventoEndpoint?: string,
+   *   mockScenario?: string,
+   *   mockEventoScenario?: string,
+   *   validarXsd?: boolean,
+   * }} [options]
+   */
+  constructor(options = {}) {
+    this.options = options;
+    const soapOptions = buildSoapOptions(options);
+
+    this.xmlService = new NFeXmlService({ validarXsd: options.validarXsd });
+    this.signService = new NFeSignService();
+    this.soapService = new NFeSoapService(soapOptions);
+    this.eventoService = new NFeEventoService(soapOptions);
+  }
+
+  /** Resolve endpoints SEFAZ para a UF do documento. */
+  configurarUf(uf, ambiente = 2) {
+    const urls = SefazEndpointResolver.paraNFe(uf, ambiente);
+    this.soapService.endpoint = urls.endpoint;
+    this.soapService.eventoEndpoint = urls.eventoEndpoint;
+    this.soapService.mock = false;
+    this.eventoService.soapService.endpoint = urls.endpoint;
+    this.eventoService.soapService.eventoEndpoint = urls.eventoEndpoint;
+    this.eventoService.soapService.mock = false;
+    return urls;
+  }
+
+  /** @param {Parameters<typeof gerarChaveAcesso>[0]} params */
+  gerarChaveAcesso(params) {
+    return gerarChaveAcesso(params);
+  }
+
+  /** @param {import('../types/NFeDocument.js').NFeDocument} documento */
+  resolverDocumento(documento) {
+    if (documento.chaveAcesso) {
+      if (!validarChaveAcesso(documento.chaveAcesso)) {
+        throw new GhinfeError('chaveAcesso com dígito verificador inválido', 'CHAVE_DV_INVALIDO');
+      }
+      return documento;
+    }
+
+    const chaveAcesso = gerarChaveAcesso({
+      uf: documento.ide.uf,
+      cnpj: documento.emitente.cnpj,
+      modelo: '55',
+      serie: documento.ide.serie ?? 1,
+      numero: documento.ide.numero,
+      tipoEmissao: documento.ide.tipoEmissao ?? 1,
+    });
+
+    return { ...documento, chaveAcesso };
+  }
+
+  async emitir(documento, certificado, idLote) {
+    const doc = this.resolverDocumento(documento);
+
+    if (!this.soapService.mock && this.options.uf === undefined && !this.options.sefazEndpoint) {
+      this.configurarUf(doc.ide.uf, doc.ambiente ?? 2);
+    }
+
+    const xml = this.xmlService.gerarXml(doc);
+    const xmlAssinado = this.signService.assinar(xml, certificado.pfx, certificado.senha);
+    const retorno = await this.soapService.autorizar(xmlAssinado, doc.chaveAcesso, idLote);
+
+    return { chaveAcesso: doc.chaveAcesso, xmlGerado: xml, xmlAssinado, retorno };
+  }
+
+  gerarXml(documento, options = {}) {
+    const doc = this.resolverDocumento(documento);
+    return this.xmlService.gerarXml(doc, options);
+  }
+
+  gerarXmlAssinado(documento, certificado) {
+    const doc = this.resolverDocumento(documento);
+    const xml = this.xmlService.gerarXml(doc);
+    return this.signService.assinar(xml, certificado.pfx, certificado.senha);
+  }
+
+  async enviar(xmlAssinado, chaveAcesso) {
+    return this.soapService.autorizar(xmlAssinado, chaveAcesso);
+  }
+
+  validarXsd(xml, options = {}) {
+    return this.xmlService.validarXml(xml, options);
+  }
+
+  async cancelar(dados, certificado) {
+    return this.eventoService.cancelar(dados, certificado);
+  }
+
+  async cartaCorrecao(dados, certificado) {
+    return this.eventoService.cartaCorrecao(dados, certificado);
+  }
+
+  gerarXmlCancelamento(dados) {
+    return this.eventoService.gerarXmlCancelamento(dados);
+  }
+
+  gerarXmlCartaCorrecao(dados) {
+    return this.eventoService.gerarXmlCartaCorrecao(dados);
+  }
+
+  async enviarEventoMock(xmlEvento, chaveAcesso, tpEvento) {
+    return this.eventoService.enviar(xmlEvento, chaveAcesso, tpEvento);
+  }
+
+  /**
+   * Consulta status do webservice SEFAZ (NfeStatusServico4).
+   * @param {string} [uf]
+   * @param {number} [ambiente]
+   */
+  async consultarStatus(uf, ambiente) {
+    const ufConsulta = uf ?? this.options.uf;
+    if (!ufConsulta) {
+      throw new GhinfeError('UF é obrigatória para consultar status SEFAZ', 'STATUS_UF_REQUIRED');
+    }
+    return this.soapService.consultarStatus(ufConsulta, ambiente ?? this.options.ambiente ?? 2);
+  }
+
+  toPersistencePayload(resultado) {
+    if (!resultado.retorno.autorizado) {
+      throw new GhinfeError('Não é possível persistir NF-e não autorizada', 'NFE_NOT_AUTHORIZED', resultado.retorno);
+    }
+
+    return {
+      chave_acesso: resultado.chaveAcesso,
+      xml_nfe: resultado.xmlAssinado,
+      xml_protocolo: resultado.retorno.xmlProtocolo,
+      protocolo: resultado.retorno.protocolo,
+      status: resultado.retorno.cStat,
+      motivo: resultado.retorno.xMotivo,
+      autorizado_em: new Date(),
+    };
+  }
+
+  toEventoPersistencePayload(resultado) {
+    return this.eventoService.toPersistencePayload(resultado);
+  }
+}

package/src/nfe/services/NFeSignService.js

@@ -1,111 +1,127 @@
-import { SignedXml } from 'xml-crypto';
-import { DOMParser } from '@xmldom/xmldom';
-import { loadPfxCertificate } from '../../utils/certificate.utils.js';
-import { GhinfeError } from '../../errors/GhinfeError.js';
-
-/**
- * Serviço de assinatura digital XML-DSig para NF-e (certificado A1 .pfx).
- * Assina o elemento infNFe com algoritmo exigido pela SEFAZ.
- */
-export class NFeSignService {
-  /**
-   * Assina o XML da NF-e usando certificado A1.
-   * @param {string} xmlNFe XML da NF-e sem assinatura
-   * @param {Buffer|string} pfxBuffer Conteúdo do arquivo .pfx
-   * @param {string} pfxPassword Senha do certificado
-   * @returns {string} XML assinado (NFe + Signature)
-   */
-  assinar(xmlNFe, pfxBuffer, pfxPassword) {
-    return this.#assinarElemento(xmlNFe, 'infNFe', pfxBuffer, pfxPassword);
-  }
-
-  /**
-   * Assina XML de evento NF-e (cancelamento, CC-e, etc.).
-   * @param {string} xmlEvento
-   * @param {Buffer|string} pfxBuffer
-   * @param {string} pfxPassword
-   * @returns {string}
-   */
-  assinarEvento(xmlEvento, pfxBuffer, pfxPassword) {
-    return this.#assinarElemento(xmlEvento, 'infEvento', pfxBuffer, pfxPassword);
-  }
-
-  /**
-   * Assina XML de RPS/NFS-e (elemento InfRps — ABRASF e derivados).
-   * @param {string} xmlRps
-   * @param {Buffer|string} pfxBuffer
-   * @param {string} pfxPassword
-   * @returns {string}
-   */
-  assinarRps(xmlRps, pfxBuffer, pfxPassword) {
-    let tag = 'InfRps';
-    if (xmlRps.includes('InfDeclaracaoPrestacaoServico')) tag = 'InfDeclaracaoPrestacaoServico';
-    else if (xmlRps.includes('<infRps') || xmlRps.includes('infRps ')) tag = 'infRps';
-    else if (xmlRps.includes('<InfRps') || xmlRps.includes('InfRps ')) tag = 'InfRps';
-    return this.#assinarElemento(xmlRps, tag, pfxBuffer, pfxPassword);
-  }
-
-  /**
-   * @param {string} xml
-   * @param {string} tagName
-   * @param {Buffer|string} pfxBuffer
-   * @param {string} pfxPassword
-   */
-  #assinarElemento(xml, tagName, pfxBuffer, pfxPassword) {
-    const { privateKeyPem, certificatePem } = loadPfxCertificate(pfxBuffer, pfxPassword);
-
-    const doc = new DOMParser().parseFromString(xml, 'text/xml');
-    const elemento = doc.getElementsByTagName(tagName)[0];
-
-    if (!elemento) {
-      throw new GhinfeError(`Elemento ${tagName} não encontrado no XML`, `SIGN_${tagName}_NOT_FOUND`);
-    }
-
-    const id = elemento.getAttribute('Id');
-    if (!id) {
-      throw new GhinfeError(`Atributo Id do ${tagName} é obrigatório para assinatura`, 'SIGN_MISSING_ID');
-    }
-
-    const signedXml = new SignedXml({
-      privateKey: privateKeyPem,
-      publicCert: certificatePem,
-      signatureAlgorithm: 'http://www.w3.org/2000/09/xmldsig#rsa-sha1',
-      canonicalizationAlgorithm: 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315',
-    });
-
-    signedXml.addReference({
-      xpath: `//*[local-name()='${tagName}']`,
-      transforms: [
-        'http://www.w3.org/2000/09/xmldsig#enveloped-signature',
-        'http://www.w3.org/TR/2001/REC-xml-c14n-20010315',
-      ],
-      digestAlgorithm: 'http://www.w3.org/2000/09/xmldsig#sha1',
-      uri: `#${id}`,
-    });
-
-    signedXml.computeSignature(xml, {
-      location: { reference: `//*[local-name()='${tagName}']`, action: 'after' },
-    });
-
-    return signedXml.getSignedXml();
-  }
-
-  /**
-   * Extrai informações do certificado para validação pré-envio.
-   * @param {Buffer|string} pfxBuffer
-   * @param {string} pfxPassword
-   */
-  obterInfoCertificado(pfxBuffer, pfxPassword) {
-    const { certificate } = loadPfxCertificate(pfxBuffer, pfxPassword);
-    const subject = certificate.subject.attributes
-      .map((attr) => `${attr.shortName}=${attr.value}`)
-      .join(', ');
-
-    return {
-      subject,
-      validoDe: certificate.validity.notBefore,
-      validoAte: certificate.validity.notAfter,
-      serialNumber: certificate.serialNumber,
-    };
-  }
-}
+import { SignedXml } from 'xml-crypto';
+import { DOMParser } from '@xmldom/xmldom';
+import { loadPfxCertificate } from '../../utils/certificate.utils.js';
+import { GhinfeError } from '../../errors/GhinfeError.js';
+
+/**
+ * Serviço de assinatura digital XML-DSig para NF-e (certificado A1 .pfx).
+ * Assina o elemento infNFe com algoritmo exigido pela SEFAZ.
+ */
+export class NFeSignService {
+  /**
+   * Assina o XML da NF-e usando certificado A1.
+   * @param {string} xmlNFe XML da NF-e sem assinatura
+   * @param {Buffer|string} pfxBuffer Conteúdo do arquivo .pfx
+   * @param {string} pfxPassword Senha do certificado
+   * @returns {string} XML assinado (NFe + Signature)
+   */
+  assinar(xmlNFe, pfxBuffer, pfxPassword) {
+    return this.#assinarElemento(xmlNFe, 'infNFe', pfxBuffer, pfxPassword);
+  }
+
+  /**
+   * Assina XML de evento NF-e (cancelamento, CC-e, etc.).
+   * @param {string} xmlEvento
+   * @param {Buffer|string} pfxBuffer
+   * @param {string} pfxPassword
+   * @returns {string}
+   */
+  assinarEvento(xmlEvento, pfxBuffer, pfxPassword) {
+    return this.#assinarElemento(xmlEvento, 'infEvento', pfxBuffer, pfxPassword);
+  }
+
+  /**
+   * Assina XML da DC-e (elemento infDCe). A Signature é anexada como último
+   * filho de DCe, após infDCeSupl, conforme sequência do XSD.
+   * @param {string} xmlDCe
+   * @param {Buffer|string} pfxBuffer
+   * @param {string} pfxPassword
+   * @returns {string}
+   */
+  assinarDCe(xmlDCe, pfxBuffer, pfxPassword) {
+    return this.#assinarElemento(xmlDCe, 'infDCe', pfxBuffer, pfxPassword, {
+      reference: "/*[local-name()='DCe']",
+      action: 'append',
+    });
+  }
+
+  /**
+   * Assina XML de RPS/NFS-e (elemento InfRps — ABRASF e derivados).
+   * @param {string} xmlRps
+   * @param {Buffer|string} pfxBuffer
+   * @param {string} pfxPassword
+   * @returns {string}
+   */
+  assinarRps(xmlRps, pfxBuffer, pfxPassword) {
+    let tag = 'InfRps';
+    if (xmlRps.includes('InfDeclaracaoPrestacaoServico')) tag = 'InfDeclaracaoPrestacaoServico';
+    else if (xmlRps.includes('<infRps') || xmlRps.includes('infRps ')) tag = 'infRps';
+    else if (xmlRps.includes('<InfRps') || xmlRps.includes('InfRps ')) tag = 'InfRps';
+    return this.#assinarElemento(xmlRps, tag, pfxBuffer, pfxPassword);
+  }
+
+  /**
+   * @param {string} xml
+   * @param {string} tagName
+   * @param {Buffer|string} pfxBuffer
+   * @param {string} pfxPassword
+   * @param {{ reference: string, action: 'after'|'append' }} [location] Padrão: logo após o elemento assinado
+   */
+  #assinarElemento(xml, tagName, pfxBuffer, pfxPassword, location) {
+    const { privateKeyPem, certificatePem } = loadPfxCertificate(pfxBuffer, pfxPassword);
+
+    const doc = new DOMParser().parseFromString(xml, 'text/xml');
+    const elemento = doc.getElementsByTagName(tagName)[0];
+
+    if (!elemento) {
+      throw new GhinfeError(`Elemento ${tagName} não encontrado no XML`, `SIGN_${tagName}_NOT_FOUND`);
+    }
+
+    const id = elemento.getAttribute('Id');
+    if (!id) {
+      throw new GhinfeError(`Atributo Id do ${tagName} é obrigatório para assinatura`, 'SIGN_MISSING_ID');
+    }
+
+    const signedXml = new SignedXml({
+      privateKey: privateKeyPem,
+      publicCert: certificatePem,
+      signatureAlgorithm: 'http://www.w3.org/2000/09/xmldsig#rsa-sha1',
+      canonicalizationAlgorithm: 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315',
+    });
+
+    signedXml.addReference({
+      xpath: `//*[local-name()='${tagName}']`,
+      transforms: [
+        'http://www.w3.org/2000/09/xmldsig#enveloped-signature',
+        'http://www.w3.org/TR/2001/REC-xml-c14n-20010315',
+      ],
+      digestAlgorithm: 'http://www.w3.org/2000/09/xmldsig#sha1',
+      uri: `#${id}`,
+    });
+
+    signedXml.computeSignature(xml, {
+      location: location ?? { reference: `//*[local-name()='${tagName}']`, action: 'after' },
+    });
+
+    return signedXml.getSignedXml();
+  }
+
+  /**
+   * Extrai informações do certificado para validação pré-envio.
+   * @param {Buffer|string} pfxBuffer
+   * @param {string} pfxPassword
+   */
+  obterInfoCertificado(pfxBuffer, pfxPassword) {
+    const { certificate } = loadPfxCertificate(pfxBuffer, pfxPassword);
+    const subject = certificate.subject.attributes
+      .map((attr) => `${attr.shortName}=${attr.value}`)
+      .join(', ');
+
+    return {
+      subject,
+      validoDe: certificate.validity.notBefore,
+      validoAte: certificate.validity.notAfter,
+      serialNumber: certificate.serialNumber,
+    };
+  }
+}