node-sped-nfe 1.0.0

package/utils/schemas/xmldsig-core-schema_v1.01.xsd

@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- ***************************************************-->
+<!-- ***   Schema específico para assinaturas XML    ***-->
+<!-- *** a partir de certificados do padrão (X509)   ***-->
+<!-- *** ICP-Brasil - Projeto Nota Fiscal Eletrônica ***-->
+<!-- ***************************************************-->
+<!-- Schema for XML Signatures-->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" targetNamespace="http://www.w3.org/2000/09/xmldsig#" elementFormDefault="qualified" attributeFormDefault="unqualified" version="0.1">
+	<element name="Signature" type="ds:SignatureType"/>
+	<complexType name="SignatureType">
+		<sequence>
+			<element name="SignedInfo" type="ds:SignedInfoType"/>
+			<element name="SignatureValue" type="ds:SignatureValueType"/>
+			<element name="KeyInfo" type="ds:KeyInfoType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+	</complexType>
+	<complexType name="SignatureValueType">
+		<simpleContent>
+			<extension base="base64Binary">
+				<attribute name="Id" type="ID" use="optional"/>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<complexType name="SignedInfoType">
+		<sequence>
+			<element name="CanonicalizationMethod">
+				<complexType>
+					<attribute name="Algorithm" type="anyURI" use="required" fixed="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+				</complexType>
+			</element>
+			<element name="SignatureMethod">
+				<complexType>
+					<attribute name="Algorithm" type="anyURI" use="required" fixed="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
+				</complexType>
+			</element>
+			<element name="Reference" type="ds:ReferenceType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+	</complexType>
+	<complexType name="ReferenceType">
+		<sequence>
+			<element name="Transforms" type="ds:TransformsType">
+				<!-- Garante a unicidade do atributo -->
+				<unique name="unique_Transf_Alg">
+					<selector xpath="./*"/>
+					<field xpath="@Algorithm"/>
+				</unique>
+			</element>
+			<element name="DigestMethod">
+				<complexType>
+					<attribute name="Algorithm" type="anyURI" use="required" fixed="http://www.w3.org/2000/09/xmldsig#sha1"/>
+				</complexType>
+			</element>
+			<element name="DigestValue" type="ds:DigestValueType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+		<attribute name="URI" use="required">
+			<simpleType>
+				<restriction base="anyURI">
+					<minLength value="2"/>
+				</restriction>
+			</simpleType>
+		</attribute>
+		<attribute name="Type" type="anyURI" use="optional"/>
+	</complexType>
+	<complexType name="TransformsType">
+		<sequence>
+			<element name="Transform" type="ds:TransformType" minOccurs="2" maxOccurs="2"/>
+		</sequence>
+	</complexType>
+	<complexType name="TransformType">
+		<sequence minOccurs="0" maxOccurs="unbounded">
+			<element name="XPath" type="string"/>
+		</sequence>
+		<attribute name="Algorithm" type="ds:TTransformURI" use="required"/>
+	</complexType>
+	<complexType name="KeyInfoType">
+		<sequence>
+			<element name="X509Data" type="ds:X509DataType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+	</complexType>
+	<complexType name="X509DataType">
+		<sequence>
+			<element name="X509Certificate" type="base64Binary"/>
+		</sequence>
+	</complexType>
+	<simpleType name="DigestValueType">
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<simpleType name="TTransformURI">
+		<restriction base="anyURI">
+			<enumeration value="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
+			<enumeration value="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+		</restriction>
+	</simpleType>
+</schema>

package/utils/sefaz.js

@@ -0,0 +1,84 @@
+'use strict'
+import axios from "axios"
+import https from "https"
+
+
+class Instance {
+  constructor(opts) {
+    const { baseURL, ca, cert, key } = opts
+
+    const AgentOptions = Object.assign(
+      {
+        cert: cert,
+        key: key,
+        ca: ca,
+      },
+      { ...opts.httpsOptions }
+    )
+
+    const httpsAgent = new https.Agent(AgentOptions)
+
+    const requestOptions = Object.assign(
+      {
+        baseURL: baseURL,
+        headers: {
+          'User-Agent': `node-nfe/1.0`,
+          'Content-Type': 'application/soap+xml; charset=utf-8',
+        },
+        httpsAgent: httpsAgent,
+        timeout: 60000,
+      },
+      { ...opts.requestOptions }
+    )
+
+    const instance = axios.create({
+      ...requestOptions,
+    })
+
+    this.instance = instance
+  }
+
+  /**
+   * @returns {Promise<{status: number, data: string}>}
+   */
+  async request(config) {
+    try {
+      const response = await this.instance(config)
+
+      const { status, data } = response
+
+      return { status, data }
+    } catch (error) {
+      if (error.response) {
+        const { status, data } = error.response
+
+        return { status, data }
+      } else if (error.request) {
+        if (error.code === 'ECONNABORTED') {
+          const retorno = {
+            status: 504,
+            data: `<error>${error.message || error}</error>`,
+          }
+
+          return retorno
+        }
+
+        const retorno = {
+          status: 502,
+          data: `<error>${error.message || error}</error>`,
+        }
+
+        return retorno
+      } else {
+        const retorno = {
+          status: 500,
+          data: `<error>${error.message || error}</error>`,
+        }
+
+        return retorno
+      }
+    }
+  }
+}
+
+module.exports = Instance

package/utils/tools.js

@@ -0,0 +1,277 @@
+import { XMLParser, XMLBuilder, XMLValidator } from "fast-xml-parser";
+import pem from "pem";
+import https from "https";
+import { spawnSync } from "child_process"
+import tmp from "tmp"
+import crypto from "crypto";
+import { urlServicos } from "./eventos.js"
+import fs from "fs"
+
+
+class Tools {
+    #cert = new Object();
+    #xmlTools = {
+        XMLParser: null,
+        XMLBuilder: null,
+    }
+    #pem = null;
+    #config = null;
+
+    constructor(config = { mod: "", xmllint: 'xmllint' }, certificado = { pfx: "", senha: "" }) {
+        //Configurar certificado
+        this.#config = config;
+        this.#cert = certificado;
+        this.#xmlTools.XMLBuilder = new XMLBuilder({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@",
+            parseTagValue: false,       // Evita conversão automática de valores
+            parseNodeValue: false,      // Mantém valores como strings
+        });
+        this.#xmlTools.XMLParser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@",
+            parseTagValue: false,       // Evita conversão automática de valores
+            parseNodeValue: false,      // Mantém valores como strings
+        });
+    }
+
+    sefazEnviaLote(xml = [], data = { idLote: 1, indSinc: 0, compactar: false }) {
+        return new Promise(async (resvol, reject) => {
+            if (typeof data.idLote == "undefined") data.idLote = 1;
+            if (typeof data.indSinc == "undefined") data.indSinc = 0;
+            if (typeof data.compactar == "undefined") data.compactar = false;
+
+            await this.#certTools();
+            let xmlLote = {
+                "soap:Envelope": {
+                    "@xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                    "@xmlns:xsd": "http://www.w3.org/2001/XMLSchema",
+                    "@xmlns:soap": "http://www.w3.org/2003/05/soap-envelope",
+                    "soap:Body": {
+                        "nfeDadosMsg": {
+                            "@xmlns": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeAutorizacao4",
+                            "enviNFe": {
+                                ...{
+                                    "@xmlns": "http://www.portalfiscal.inf.br/nfe",
+                                    "@versao": "4.00",
+                                    "idLote": data.idLote,
+                                    "indSinc": data.indSinc,
+                                },
+                                ...(await this.xml2json(xml))
+                            }
+                        }
+                    }
+                },
+            }
+            xmlLote = await this.json2xml(xmlLote);
+            fs.writeFileSync("testes/nfe_guara_sign_lote.xml", xmlLote, { encoding: "utf8" });
+            try {
+                const req = https.request(urlServicos[`${this.#config.cUF}`][`mod_${this.#config.mod}`].NFeAutorizacao[(this.#config.tpAmb == 1 ? "producao" : "homologacao")], {
+                    ...{
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/soap+xml; charset=utf-8',
+                            'Content-Length': xmlLote.length,
+                        },
+                        rejectUnauthorized: false
+                    },
+                    ...this.#pem
+                }, (res) => {
+                    let data = '';
+
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+
+                    res.on('end', () => {
+                        resvol(data);
+                    });
+                });
+
+                req.on('error', (erro) => {
+                    reject(erro);
+                });
+                req.write(xmlLote);
+                req.end();
+            } catch (erro) {
+                reject(erro);
+            }
+        })
+    }
+
+    async xmlSign(xml, data = {}) {
+        return new Promise(async (resvol, reject) => {
+            if (data.tag === undefined) data.tag = "infNFe";
+
+            //Obter a tag que ira ser assinada
+            xml = await this.xml2json(xml);
+            let pem = await this.getCertificado();
+            const sign = crypto.createSign('RSA-SHA1'); // Correção: Alterado para RSA-SHA1
+            let signedInfo = {
+                "SignedInfo": {
+                    "@xmlns": "http://www.w3.org/2000/09/xmldsig#",
+                    "CanonicalizationMethod": {
+                        "@Algorithm": "http://www.w3.org/TR/2001/REC-xml-c14n-20010315"
+                    },
+                    "SignatureMethod": {
+                        "@Algorithm": "http://www.w3.org/2000/09/xmldsig#rsa-sha1" // Mantém SHA1
+                    },
+                    "Reference": {
+                        "@URI": `#${xml.NFe.infNFe['@Id']}`,
+                        "Transforms": {
+                            "Transform": [
+                                {
+                                    "@Algorithm": "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
+                                },
+                                {
+                                    "@Algorithm": "http://www.w3.org/TR/2001/REC-xml-c14n-20010315"
+                                },
+                            ]
+                        },
+                        "DigestMethod": {
+                            "@Algorithm": "http://www.w3.org/2000/09/xmldsig#sha1" // Mantém SHA1
+                        },
+                        "DigestValue": crypto.createHash('sha1').update(await this.json2xml({ infNFe: xml.NFe.infNFe }), 'utf8') // Mantém Hash SHA1
+                            .digest('base64')
+
+                    }
+                }
+            }
+            sign.update(await this.json2xml(signedInfo), 'utf8');
+            xml.NFe.Signature = {
+                ...signedInfo,
+                ...{
+                    "SignatureValue": sign.sign(pem.key, 'base64'),
+                    "KeyInfo": {
+                        "X509Data": {
+                            "X509Certificate": pem.cert.replace(/-----BEGIN CERTIFICATE-----/g, '').replace(/-----END CERTIFICATE-----/g, '').replace(/\r\n/g, '')
+                        }
+                    },
+                    "@xmlns": "http://www.w3.org/2000/09/xmldsig#"
+                }
+            }
+            this.json2xml(xml).then(async res => {
+                this.#xmlValido(res);
+                resvol(res);
+            }).catch(err => {
+                reject(err)
+            })
+        })
+    }
+
+    async xml2json(xml) {
+        return new Promise((resvol, reject) => {
+            resvol(this.#xmlTools.XMLParser.parse(xml))
+        })
+    }
+
+    async json2xml(obj) {
+        return new Promise((resvol, reject) => {
+            resvol(this.#xmlTools.XMLBuilder.build(obj))
+        })
+    }
+
+    async getCertificado() {
+        return new Promise(async (resvol, reject) => {
+            await this.#certTools().then(resvol).catch(reject)
+        })
+    }
+
+    //Consulta status sefaz
+    async sefazStatus() {
+        return new Promise(async (resvol, reject) => {
+            await this.#certTools();
+
+            if (typeof this.#config.cUF == "undefined") throw "sefazStatus({...cUF}) -> não definido!";
+            if (typeof this.#config.tpAmb == "undefined") throw "sefazStatus({...tpAmb}) -> não definido!";
+            if (typeof this.#config.mod == "undefined") throw "sefazStatus({...mod}) -> não definido!";
+
+            let xml = {
+                "soap:Envelope": {
+                    "@xmlns:soap": "http://www.w3.org/2003/05/soap-envelope",
+                    "@xmlns:nfe": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4",
+                    "soap:Body": {
+                        "nfe:nfeDadosMsg": {
+                            "consStatServ": {
+                                "@versao": "4.00",
+                                "@xmlns": "http://www.portalfiscal.inf.br/nfe",
+                                "tpAmb": this.#config.tpAmb,
+                                "cUF": this.#config.cUF,
+                                "xServ": "STATUS"
+                            }
+                        }
+                    }
+                }
+            }
+
+            try {
+                let tempBuild = new XMLBuilder({
+                    ignoreAttributes: false,
+                    attributeNamePrefix: "@"
+                });
+                xml = tempBuild.build(xml);
+
+                const req = https.request(urlServicos[`${this.#config.cUF}`][`mod_${this.#config.mod}`].NfeStatusServico[(this.#config.tpAmb == 1 ? "producao" : "homologacao")], {
+                    ...{
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/soap+xml; charset=utf-8',
+                            'Content-Length': xml.length,
+                        },
+                        rejectUnauthorized: false
+                    },
+                    ...this.#pem
+                }, (res) => {
+                    let data = '';
+
+                    res.on('data', (chunk) => {
+                        data += chunk;
+                    });
+
+                    res.on('end', () => {
+                        resvol(data);
+                    });
+                });
+
+                req.on('error', (erro) => {
+                    reject(erro);
+                });
+
+                req.write(xml);
+                req.end();
+            } catch (erro) {
+                reject(erro);
+            }
+        })
+    }
+
+
+    //Validar XML da NFe, somente apos assinar
+    async #xmlValido(xml) {
+        let xmlFile = tmp.fileSync({ mode: 0o644, prefix: 'xml-', postfix: '.xml' });
+        fs.writeFileSync(xmlFile.name, xml, { encoding: "utf8" });
+        let verif = spawnSync(this.#config.xmllint, ['--noout', '--schema', `./utils/schemas/nfe_v4.00.xsd`, xmlFile.name], { encoding: 'utf8' });
+        xmlFile.removeCallback();
+
+        if (verif.errno == -4058) {
+            //xmllint - não instalado ou informado path
+            throw ("Biblioteca xmllint não encontrado!") 
+        } else if (!verif.stderr.includes(".xml validates")) {
+            throw (verif.stderr)
+        }
+        return 1;
+    }
+
+
+    //Extrair dados do certificado pem
+    #certTools() {
+        return new Promise(async (resvol, reject) => {
+            if (this.#pem != null) resvol(this.#pem);
+            pem.readPkcs12(this.#cert.pfx, { p12Password: this.#cert.senha }, (err, myPem) => {
+                this.#pem = myPem;
+                resvol(myPem);
+            });
+        })
+    }
+}
+export { Tools }