xades-bes-signer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Gabriel Acuña
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# xades-bas-signer
+
+XAdES-BES signer for Node/TypeScript — utilities to load certificates and create XAdES-BES XML signatures.
+
+A compact TypeScript library that helps you manage certificate files (P12) and produce the canonical building blocks needed for XAdES-BES signatures in Node.js applications.
+
+## Features
+
+- Load and manage certificate files using a [FileManager](src/libs/files.ts#L3).
+- Convert hex, bigint, and SHA-1 digests to Base64.
+- Utilities for deterministic formatting of Base64 output.
+- Test suite with example environment-driven cert path to validate file handling.
+
+## Quick Start
+
+- Prerequisites: Node.js >= 16 (as declared in package.json), npm install.
+- Set up:
+  - Create a .env file in Create a `.env` in repository root with:
+    - [CERT_PATH=./credentials/your-cert.p12](./test/libs/files.test.ts#L8)
+    - [CERT_KEY=certificate-key](./test/libs/credentials.test.ts#L16)
+- Install:
+
+```sh
+npm install
+```
+
+- Run tests:
+
+````ssh
+npm test
+
+````
+## Licence
+MIT (see [LICENSE](./LICENSE)).

package/dist/jest.config.d.ts

@@ -0,0 +1,5 @@
+/** @jest-config-loader ts-node */
+/** @jest-config-loader-options {"transpileOnly": true} */
+import type { Config } from 'jest';
+declare const config: Config;
+export default config;

package/dist/jest.config.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    preset: 'ts-jest',
+    verbose: true,
+    testEnvironment: 'node',
+    roots: ['<rootDir>/test'],
+    testMatch: ['**/test/**/*.test.ts'],
+    moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+    transform: {
+        '^.+\\.ts$': 'ts-jest'
+    }
+};
+exports.default = config;

package/dist/src/libs/credentials.d.ts

@@ -0,0 +1,32 @@
+import * as forge from "node-forge";
+import { PKCS88Bags } from "./types";
+export declare function getP12(certificate: Uint8Array<ArrayBufferLike>, certKey: string): forge.pkcs12.Pkcs12Pfx;
+export declare function getIssuerName(cert: forge.pkcs12.Bag): string | undefined;
+export declare function getKeyContainer(pkcs8Bags: PKCS88Bags, friendlyName: string): forge.pkcs12.Bag;
+export declare function getKey(pckcs8: forge.pkcs12.Bag): forge.pki.rsa.PrivateKey;
+export declare function getCertificate(certBag: forge.pkcs12.Bag[]): forge.pkcs12.Bag;
+export declare function isCerticateValid(certficate: forge.pki.Certificate): boolean;
+export declare function certX509ToPem(certificate: forge.pki.Certificate): string;
+export declare function certX509ToASN1(certificate: forge.pki.Certificate): forge.asn1.Asn1;
+export declare function getPCK12CertInfo(certificate: Uint8Array<ArrayBufferLike>, certKey: string): {
+    radomValues: {
+        certificateNumber: number;
+        signatureNumber: number;
+        signedPropertiesNumber: number;
+        signedInfoNumber: number;
+        signedPropertiesIdNumber: number;
+        referenceIdNumber: number;
+        signatureValueNumber: number;
+        objectNumber: number;
+    };
+    certInfo: {
+        digestValue: string;
+        issuerName: string | undefined;
+        issuerSerialNumber: number;
+        signingTime: string;
+        certificateX509: string;
+        modulus: string | undefined;
+        exponent: string;
+        key: forge.pki.rsa.PrivateKey;
+    };
+};

package/dist/src/libs/credentials.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getP12 = getP12;
+exports.getIssuerName = getIssuerName;
+exports.getKeyContainer = getKeyContainer;
+exports.getKey = getKey;
+exports.getCertificate = getCertificate;
+exports.isCerticateValid = isCerticateValid;
+exports.certX509ToPem = certX509ToPem;
+exports.certX509ToASN1 = certX509ToASN1;
+exports.getPCK12CertInfo = getPCK12CertInfo;
+const forge = __importStar(require("node-forge"));
+const security_1 = require("./security");
+function getP12(certificate, certKey) {
+    const der = forge.util.decode64(forge.util.binary.base64.encode(new Uint8Array(certificate)));
+    const ansi = forge.asn1.fromDer(der);
+    return forge.pkcs12.pkcs12FromAsn1(ansi, certKey);
+}
+function getIssuerName(cert) {
+    var _a;
+    const issuerTributes = (_a = cert.cert) === null || _a === void 0 ? void 0 : _a.issuer.attributes;
+    let issuerName = issuerTributes === null || issuerTributes === void 0 ? void 0 : issuerTributes.reverse().map((attr) => {
+        return `${attr.shortName}=${attr.value}`;
+    }).join(", ");
+    return issuerName;
+}
+function getKeyContainer(pkcs8Bags, friendlyName) {
+    let pkcs8;
+    const oid = forge.pki.oids["pkcs8ShroudedKeyBag"];
+    const bags = pkcs8Bags === null || pkcs8Bags === void 0 ? void 0 : pkcs8Bags[oid];
+    if (!bags || !Array.isArray(bags) || bags.length === 0) {
+        throw new Error("No key bags found in the PKCS#12 certificate.");
+    }
+    if (friendlyName.includes("BANCO CENTRAL")) {
+        const index = bags.findIndex((key) => { var _a, _b, _c; return (_c = (_b = (_a = key === null || key === void 0 ? void 0 : key.attributes) === null || _a === void 0 ? void 0 : _a.friendlyName) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.includes("Signing Key"); });
+        if (!index) {
+            throw new Error("Unable to find the key bag for BANCO CENTRAL");
+        }
+        pkcs8 = bags[index];
+    }
+    else {
+        pkcs8 = bags[0];
+    }
+    return pkcs8;
+}
+function getKey(pckcs8) {
+    let key;
+    if (pckcs8["key"]) {
+        key = pckcs8["key"];
+    }
+    else if (pckcs8["asn1"]) {
+        key = forge.pki.privateKeyFromAsn1(pckcs8["asn1"]);
+    }
+    else {
+        throw new Error("No private key found in the PKCS#12 key bag.");
+    }
+    return key;
+}
+function getCertificate(certBag) {
+    let crt = certBag.reduce((prev, current) => {
+        var _a, _b, _c, _d, _e, _f;
+        return ((_c = (_b = (_a = current.cert) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) >
+            ((_f = (_e = (_d = prev.cert) === null || _d === void 0 ? void 0 : _d.extensions) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0)
+            ? current
+            : prev;
+    });
+    return crt;
+}
+function isCerticateValid(certficate) {
+    const notBefore = certficate.validity.notBefore;
+    const notAfter = certficate.validity.notAfter;
+    const currentDate = new Date();
+    return currentDate >= notBefore && currentDate <= notAfter;
+}
+function certX509ToPem(certificate) {
+    return forge.pki.certificateToPem(certificate);
+}
+function certX509ToASN1(certificate) {
+    return forge.pki.certificateToAsn1(certificate);
+}
+function getPCK12CertInfo(certificate, certKey) {
+    var _a, _b;
+    const p12 = getP12(certificate, certKey);
+    const pkcs8Bags = p12.getBags({
+        bagType: forge.pki.oids["pkcs8ShroudedKeyBag"],
+    });
+    const data = p12.getBags({ bagType: forge.pki.oids.certBag });
+    if (!data || !((_a = data === null || data === void 0 ? void 0 : data[forge.pki.oids.certBag]) === null || _a === void 0 ? void 0 : _a[0]))
+        throw new Error("Unable to parse certificate. Incorrect Password?");
+    const certBags = (_b = data[forge.pki.oids.certBag]) !== null && _b !== void 0 ? _b : [];
+    const friendlyName = certBags[1].attributes.friendlyName[0];
+    let certBag = getCertificate(certBags);
+    if (isCerticateValid(certBag.cert)) {
+        throw new Error("Invalid certificate, check the validity");
+    }
+    const cert = certBag.cert;
+    let pckcs8;
+    let issuerName = getIssuerName(certBag);
+    pckcs8 = getKeyContainer(pkcs8Bags, friendlyName);
+    let key = getKey(pckcs8);
+    const pem = certX509ToPem(cert);
+    let certificateX509 = pem.substring(pem.indexOf("\n") + 1, pem.indexOf("-----END CERTIFICATE-----"));
+    certificateX509.replace(/\r?\n|\r/g, "").replace(/([^\0]{76})/g, "$1\n");
+    const ISODateTime = new Date().toISOString().slice(0, 19);
+    const certificateANS1 = certX509ToASN1(cert);
+    const certificateDER = forge.asn1.toDer(certificateANS1).getBytes();
+    const hashCErtificateX509DER = (0, security_1.sha1ToBase64)(certificateDER, "utf-8");
+    const certificateX509SN = parseInt(hashCErtificateX509DER, 16);
+    const exponent = (0, security_1.hexToBase64)(key.e.data[0].toString(16));
+    const modulus = (0, security_1.bigintToBase64)(BigInt(key.n.toString()));
+    const certificateNumber = (0, security_1.getRandomValues)();
+    const signatureNumber = (0, security_1.getRandomValues)();
+    const signedPropertiesNumber = (0, security_1.getRandomValues)();
+    const signedInfoNumber = (0, security_1.getRandomValues)();
+    const signedPropertiesIdNumber = (0, security_1.getRandomValues)();
+    const referenceIdNumber = (0, security_1.getRandomValues)();
+    const signatureValueNumber = (0, security_1.getRandomValues)();
+    const objectNumber = (0, security_1.getRandomValues)();
+    return {
+        radomValues: {
+            certificateNumber,
+            signatureNumber,
+            signedPropertiesNumber,
+            signedInfoNumber,
+            signedPropertiesIdNumber,
+            referenceIdNumber,
+            signatureValueNumber,
+            objectNumber,
+        },
+        certInfo: {
+            digestValue: hashCErtificateX509DER,
+            issuerName,
+            issuerSerialNumber: certificateX509SN,
+            signingTime: ISODateTime,
+            certificateX509,
+            modulus,
+            exponent,
+            key,
+        },
+    };
+}

package/dist/src/libs/files.d.ts

@@ -0,0 +1,6 @@
+export declare class FileManager {
+    private data?;
+    openFile(path: string): Promise<this>;
+    toString(encoding: BufferEncoding): Promise<string>;
+    getFile(): Buffer<ArrayBufferLike> | undefined;
+}

package/dist/src/libs/files.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+const promises_1 = require("fs/promises");
+class FileManager {
+    openFile(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.data = yield (0, promises_1.readFile)(path);
+                return this;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    toString(encoding) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.data)
+                throw new Error("File data is not loaded. Please call openFile() first.");
+            return this.data.toString(encoding);
+        });
+    }
+    getFile() {
+        return this.data;
+    }
+}
+exports.FileManager = FileManager;

package/dist/src/libs/security.d.ts

@@ -0,0 +1,9 @@
+import { Encoding } from "node:crypto";
+import * as forge from "node-forge";
+export declare function sha1ToBase64(text: string, encoding: Encoding): string;
+export declare function hexToBase64(hashHex: string): string;
+export declare function bigintToBase64(param: bigint): string | undefined;
+export declare function getRandomValues(min?: number, max?: number): number;
+export declare function isHexString(str: string): boolean;
+export declare function toSha1(content: string, encoding: forge.Encoding): forge.md.sha1.MessageDigest;
+export declare function toBase64String(content: any): string;

package/dist/src/libs/security.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha1ToBase64 = sha1ToBase64;
+exports.hexToBase64 = hexToBase64;
+exports.bigintToBase64 = bigintToBase64;
+exports.getRandomValues = getRandomValues;
+exports.isHexString = isHexString;
+exports.toSha1 = toSha1;
+exports.toBase64String = toBase64String;
+const crypto = __importStar(require("node:crypto"));
+const forge = __importStar(require("node-forge"));
+function sha1ToBase64(text, encoding) {
+    const HASH = crypto.createHash("sha1").update(text, encoding).digest("hex");
+    const BUFFER = Buffer.from(HASH, "hex");
+    return BUFFER.toString("base64");
+}
+function hexToBase64(hashHex) {
+    if (hashHex.length % 2 !== 0) {
+        hashHex = "0" + hashHex;
+    }
+    if (!isHexString(hashHex)) {
+        throw new Error("Invalid hex string");
+    }
+    const buf = Buffer.from(hashHex, "hex");
+    return buf.toString("base64");
+}
+function bigintToBase64(param) {
+    var _a;
+    let hexString = param.toString(16);
+    if (hexString.length % 2 !== 0) {
+        hexString = "0" + hexString;
+    }
+    const buffer = Buffer.from(hexString, "hex");
+    const base64 = buffer.toString("base64");
+    const formatedBase64 = (_a = base64.match(/.{1,76}/g)) === null || _a === void 0 ? void 0 : _a.join("\n");
+    return formatedBase64;
+}
+function getRandomValues(min = 990, max = 9999) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+function isHexString(str) {
+    const hexRegEx = /^[0-9a-fA-F]+$/;
+    return hexRegEx.test(str);
+}
+function toSha1(content, encoding) {
+    const md = forge.md.sha1.create();
+    md.update(content, encoding);
+    return md;
+}
+function toBase64String(content) {
+    const buffer = Buffer.from(content, 'utf-8');
+    return buffer.toString('base64');
+}

package/dist/src/libs/signer.d.ts

@@ -0,0 +1,9 @@
+export declare function getP12(path: string): Promise<Buffer<ArrayBufferLike> | undefined>;
+export declare function getXML(path: string): Promise<string>;
+export declare function sign(params: {
+    p12Path: string;
+    p12Password: string;
+    rootElement: string;
+    xmlPath?: string;
+    xmlString?: string;
+}): Promise<string>;

package/dist/src/libs/signer.js

@@ -0,0 +1,206 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getP12 = getP12;
+exports.getXML = getXML;
+exports.sign = sign;
+const files_1 = require("./files");
+const credentials_1 = require("./credentials");
+const security_1 = require("./security");
+function getP12(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileManager = new files_1.FileManager();
+        try {
+            yield fileManager.openFile(path);
+            return fileManager.getFile();
+        }
+        catch (error) {
+            throw new Error("Error reading P12 file: " + error);
+        }
+    });
+}
+function getXML(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileManager = new files_1.FileManager();
+        try {
+            yield fileManager.openFile(path);
+        }
+        catch (error) {
+            throw new Error("Error reading XML file: " + error);
+        }
+        return fileManager.toString("utf-8");
+    });
+}
+function getSignedPropertiesNode(params) {
+    return (`<etsi:SignedProperties Id="Signature${params.signatureNumber} SignedProperties${params.signedPropertiesNumber}">` +
+        `<etsi:SignedSignatureProperties>` +
+        `<etsi:SignedTime>${params.signingTime}</etsi:SignedTime>` +
+        `<etsi:SigningCertificate>` +
+        `<etsi:Cert>` +
+        `<etsi:CertDigest><ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1">` +
+        `<etsi:DigestValue>${params.digestValue}</etsi:DigestValue></etsi:CertDigest>` +
+        `<etsi:IssuerSerial>` +
+        `<ds:X509IssuerName>${params.issuerName}</ds:X509IssuerName>` +
+        `<ds:X509SerialNumber>${params.issuerSerialNumber}</ds:X509SerialNumber>` +
+        `</etsi:IssuerSerial>` +
+        `</etsi:Cert>` +
+        `</etsi:SigningCertificate>` +
+        `<etsi:SignedDataObjectProperties>` +
+        `<etsi:DataObjectFormat ObjectReference="#Reference-ID=${params.referenceIdNumber}">` +
+        `<etsi:Description>contenido comprobante</etsi:Description>` +
+        `<etsi:MimeType>text/xml</etsi:MimeType>` +
+        `</etsi:DataObjectFormat>` +
+        `</etsi:SignedDataObjectProperties>` +
+        `</etsi:SignedProperties>`);
+}
+function getKeyInfoNode(params) {
+    return (`<ds:KeyInfo Id="Certificate${params.certificateNumber}">` +
+        `\n<ds:X509Data>` +
+        `\n<ds:X509Certificate>\n${params.certificateX509}\n</ds:X509Certificate>` +
+        `\n</ds:X509Data>` +
+        `\n</ds:KeyValue>\n<ds:RSAKeyValue>\n<ds:Modulus>\n${params.modulus}\n</ds:Modulus>` +
+        `\n<ds:Exponent>\n${params.exponent}</ds:Exponent>` +
+        `\n</ds:RSAKeyValue>` +
+        `\n</ds:KeyInfo>`);
+}
+function getSignedInfoNode(params) {
+    return (`<ds:SignedInfo Id="Signature-SignedInfo${params.signedInfoNumber}">` +
+        `\n<ds:CanonicalizationMethod> Algorithm=”http://www.w3.org/TR/2001/REC-xml-c14n20010315”></ds:CanonicalizationMethod>` +
+        `\n<ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"></ds:SignatureMethod>` +
+        `\n<ds:Reference Id="SignedPropertiedID${params.signedPropertiesIdNumber}"> Type="http://uri.etsi.org/01903#SignedProperties" URI="#Signature${params.signatureNumber}-SignedProperties${params.signedPropertiesNumber}">` +
+        `\n<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"></ds:DigestMethod>` +
+        `\n<ds:DigestValue>${params.sha1SignedProperties}</ds:DigestValue>` +
+        `\n</ds:Reference>` +
+        `\n<ds:Reference URI="Certificate${params.certificateNumber}">` +
+        `\n<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"></ds:DigestMethod>` +
+        `\n<ds:DigestValue>${params.sha1KeyInfo}</ds:DigestValue>` +
+        `\n</ds:Reference>` +
+        `\n<ds:Reference Id="Reference-ID-${params.referenceIdNumber}" URI="#comprobante">` +
+        `\n<ds:Transforms>` +
+        `\n<ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"></ds:Transform>` +
+        `\n</ds:Transforms>` +
+        `\n<ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"></ds:DigestMethod>` +
+        `\n<ds:DigestValue>${params.sha1Xml}</ds:DigestValue>` +
+        `\n</ds:Reference>` +
+        `</ds:SignedInfo`);
+}
+function getSignatureObject(params) {
+    const objectSignature = `<ds:Object Id="Signature${params.signatureNumber}-Object${params.objectNumber}">` +
+        `<etsi:QualifyingProperties Target="#Signature${params.signatureNumber}">` +
+        `${params.signedInfo}` +
+        `</etsi:QualifyingProperties></ds:Object>`;
+    return objectSignature;
+}
+function getSignatureNode(params) {
+    const signatureNode = `\n<ds:Signature ${params.namespaces} Id="Signature${params.signatureNumber}">` +
+        `\n${params.signedInfoNode}` +
+        `\n${params.signatureValueNode}` +
+        `\n${params.keyInfoNode}` +
+        `\n${params.objectSignarureNode}` +
+        `</ds:Signature>`;
+    return signatureNode;
+}
+function nodeCanonicalization(params) {
+    return params.content.replace(params.nodeName, `${params.nodeName} ${params.namespaces}`);
+}
+function addSignatureNode(params) {
+    const { xml, rootElement, signatureNode } = params;
+    return xml.replace(`</${rootElement}>`, `${signatureNode}</${rootElement}>`);
+}
+function sign(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { p12Path, p12Password, xmlPath, xmlString } = params;
+        if (!xmlPath && !xmlString) {
+            throw new Error("Either xmlPath or xmlString must be provided.");
+        }
+        const p12Buffer = yield getP12(p12Path);
+        let xmlData = "";
+        xmlData += xmlPath ? yield getXML(xmlPath) : xmlString;
+        xmlData = xmlData
+            .replace(/\s+/g, " ")
+            .trim()
+            .replace(/(?=<\>)(\r?\n)|(\r?\n)(?=\<\/) /g, "")
+            .trim()
+            .replace(/(?=<\>)(\s*)/g, "")
+            .replace(/\t|\r/g, "");
+        const arayuint8 = new Uint8Array(p12Buffer === null || p12Buffer === void 0 ? void 0 : p12Buffer.buffer);
+        let certInfo = (0, credentials_1.getPCK12CertInfo)(arayuint8, p12Password);
+        const sha1Xml = (0, security_1.sha1ToBase64)(xmlData.replace(`<?xml version="1.0" encoding="UTF-8"?>`, ""), "utf8");
+        const namespaces = 'xmlns:ds="http://www.w3.org/2000/09/xmldsig#namespace xmlns:estsi="http://uri.etsi.org/01903/v1.3.2#"';
+        let signedProperties = getSignedPropertiesNode({
+            signatureNumber: certInfo.radomValues.signatureNumber,
+            signedPropertiesNumber: certInfo.radomValues.signedPropertiesNumber,
+            signingTime: certInfo.certInfo.signingTime,
+            digestValue: certInfo.certInfo.digestValue,
+            issuerName: certInfo.certInfo.issuerName,
+            issuerSerialNumber: certInfo.certInfo.issuerSerialNumber,
+            referenceIdNumber: certInfo.radomValues.referenceIdNumber,
+        });
+        const signedPropertiesCanonicalized = nodeCanonicalization({
+            content: signedProperties,
+            nodeName: "<etsi:SignedProperties",
+            namespaces,
+        });
+        const sha1SignedProperties = (0, security_1.sha1ToBase64)(signedPropertiesCanonicalized, "utf8");
+        const keyInfo = getKeyInfoNode({
+            certificateNumber: certInfo.radomValues.certificateNumber,
+            certificateX509: certInfo.certInfo.certificateX509,
+            modulus: certInfo.certInfo.modulus,
+            exponent: certInfo.certInfo.exponent,
+        });
+        const keyInfoCanonicalized = nodeCanonicalization({
+            content: keyInfo,
+            nodeName: "<ds:KeyInfo",
+            namespaces,
+        });
+        const sha1KeyInfo = (0, security_1.sha1ToBase64)(keyInfoCanonicalized, "utf-8");
+        const signedInfo = getSignedInfoNode({
+            signedInfoNumber: certInfo.radomValues.signedInfoNumber,
+            signedPropertiesIdNumber: certInfo.radomValues.signedPropertiesIdNumber,
+            sha1SignedProperties,
+            certificateNumber: certInfo.radomValues.certificateNumber,
+            sha1KeyInfo,
+            referenceIdNumber: certInfo.radomValues.referenceIdNumber,
+            sha1Xml,
+            signatureNumber: certInfo.radomValues.signatureNumber,
+            signedPropertiesNumber: certInfo.radomValues.signedPropertiesNumber,
+        });
+        const signedInfoCanonicalized = nodeCanonicalization({
+            content: signedInfo,
+            nodeName: "<ds:SignedInfo",
+            namespaces,
+        });
+        const md = (0, security_1.toSha1)(signedInfoCanonicalized, "utf8");
+        const signatureValue = (_b = (_a = (0, security_1.toBase64String)(certInfo.certInfo.key.sign(md))
+            .match(/.{1,76}/g)) === null || _a === void 0 ? void 0 : _a.join("\n")) !== null && _b !== void 0 ? _b : "";
+        const signatureValueNode = `\n<ds:SignatureValue Id="SignatureValue${certInfo.radomValues.signatureValueNumber}">` +
+            `${signatureValue}\n</ds:SignatureValue>`;
+        const objectSignature = getSignatureObject({
+            signatureNumber: certInfo.radomValues.signatureNumber,
+            objectNumber: certInfo.radomValues.objectNumber,
+            signedInfo,
+        });
+        const signatureNode = getSignatureNode({
+            namespaces,
+            signatureNumber: certInfo.radomValues.signatureNumber,
+            signedInfoNode: signedInfo,
+            signatureValueNode,
+            keyInfoNode: keyInfo,
+            objectSignarureNode: objectSignature,
+        });
+        return addSignatureNode({
+            xml: xmlData,
+            rootElement: params.rootElement,
+            signatureNode,
+        });
+    });
+}

package/dist/src/main.d.ts

@@ -0,0 +1,2 @@
+import { sign } from "./libs/signer";
+export { sign };

package/dist/src/main.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sign = void 0;
+const signer_1 = require("./libs/signer");
+Object.defineProperty(exports, "sign", { enumerable: true, get: function () { return signer_1.sign; } });

package/dist/test/libs/credentials.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/libs/credentials.test.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const files_1 = require("../../src/libs/files");
+const credentials_1 = require("../../src/libs/credentials");
+const globals_1 = require("@jest/globals");
+const dotenv = __importStar(require("dotenv"));
+const forge = __importStar(require("node-forge"));
+dotenv.config();
+const CERT_PATH = process.env.CERT_PATH;
+const CERT_KEY = process.env.CERT_KEY;
+(0, globals_1.describe)("Crdentials", () => {
+    let fileManager;
+    let arrayuint8;
+    (0, globals_1.beforeAll)(() => __awaiter(void 0, void 0, void 0, function* () {
+        fileManager = new files_1.FileManager();
+        yield fileManager.openFile(CERT_PATH);
+        let p12Buffer = fileManager.getFile();
+        arrayuint8 = new Uint8Array(p12Buffer);
+    }));
+    (0, globals_1.afterEach)(() => __awaiter(void 0, void 0, void 0, function* () {
+        fileManager = new files_1.FileManager();
+        yield fileManager.openFile(CERT_PATH);
+        let p12Buffer = fileManager.getFile();
+        arrayuint8 = new Uint8Array(p12Buffer);
+    }));
+    (0, globals_1.describe)("getP12 function", () => {
+        (0, globals_1.test)("should successfully return a forge.pkcs12.Pkcs12Pfx object", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            (0, globals_1.expect)(CERT_KEY).toBeDefined();
+            (0, globals_1.expect)(arrayuint8).toBeDefined();
+            let p12 = (0, credentials_1.getP12)(arrayuint8, CERT_KEY);
+            (0, globals_1.expect)(p12).toBeInstanceOf(Object);
+            console.log(p12);
+        }));
+    });
+    (0, globals_1.describe)("isCerticateValid function", () => {
+        (0, globals_1.test)("should return true", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            (0, globals_1.expect)(CERT_KEY).toBeDefined();
+            (0, globals_1.expect)(arrayuint8).toBeDefined();
+            let p12 = (0, credentials_1.getP12)(arrayuint8, CERT_KEY);
+            const data = p12.getBags({ bagType: forge.pki.oids["certBag"] });
+            const certBags = (_a = data[forge.pki.oids["certBag"]]) !== null && _a !== void 0 ? _a : [];
+            const certBag = (0, credentials_1.getCertificate)(certBags);
+            const isValid = (0, credentials_1.isCerticateValid)(certBag.cert);
+            (0, globals_1.expect)(isValid).toBeTruthy();
+        }));
+    });
+    (0, globals_1.describe)("getIssuerName", () => {
+        (0, globals_1.test)("should return issuer name string", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            (0, globals_1.expect)(CERT_KEY).toBeDefined();
+            (0, globals_1.expect)(arrayuint8).toBeDefined();
+            let p12 = (0, credentials_1.getP12)(arrayuint8, CERT_KEY);
+            const data = p12.getBags({ bagType: forge.pki.oids["certBag"] });
+            const certBags = (_a = data[forge.pki.oids["certBag"]]) !== null && _a !== void 0 ? _a : [];
+            const certBag = (0, credentials_1.getCertificate)(certBags);
+            const cert = certBag.cert;
+            let issuerName = (0, credentials_1.getIssuerName)(certBag);
+            (0, globals_1.expect)(typeof issuerName).toBe("string");
+            (0, globals_1.expect)(issuerName).toContain("CN=");
+            (0, globals_1.expect)(issuerName).toContain("OU=");
+            (0, globals_1.expect)(issuerName).toContain("O=");
+            (0, globals_1.expect)(issuerName).toContain("C=");
+        }));
+    });
+    (0, globals_1.describe)("getKeyContainer", () => {
+        (0, globals_1.test)("should return pkcs8 bag", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            (0, globals_1.expect)(CERT_KEY).toBeDefined();
+            (0, globals_1.expect)(arrayuint8).toBeDefined();
+            let p12 = (0, credentials_1.getP12)(arrayuint8, CERT_KEY);
+            const pkcs8Bags = p12.getBags({
+                bagType: forge.pki.oids["pkcs8ShroudedKeyBag"],
+            });
+            (0, globals_1.expect)(pkcs8Bags).toBeDefined();
+            const data = p12.getBags({ bagType: forge.pki.oids["certBag"] });
+            const certBags = (_a = data[forge.pki.oids["certBag"]]) !== null && _a !== void 0 ? _a : [];
+            const friendlyName = certBags[1].attributes.friendlyName[0];
+            let pkcs8 = (0, credentials_1.getKeyContainer)(pkcs8Bags, friendlyName);
+            (0, globals_1.expect)(pkcs8).toBeDefined();
+        }));
+    });
+    (0, globals_1.describe)("getKey", () => {
+        (0, globals_1.test)("should return key", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            (0, globals_1.expect)(CERT_KEY).toBeDefined();
+            (0, globals_1.expect)(arrayuint8).toBeDefined();
+            let p12 = (0, credentials_1.getP12)(arrayuint8, CERT_KEY);
+            const pkcs8Bags = p12.getBags({
+                bagType: forge.pki.oids["pkcs8ShroudedKeyBag"],
+            });
+            (0, globals_1.expect)(pkcs8Bags).toBeDefined();
+            const data = p12.getBags({ bagType: forge.pki.oids["certBag"] });
+            const certBags = (_a = data[forge.pki.oids["certBag"]]) !== null && _a !== void 0 ? _a : [];
+            const friendlyName = certBags[1].attributes.friendlyName[0];
+            let pkcs8 = (0, credentials_1.getKeyContainer)(pkcs8Bags, friendlyName);
+            (0, globals_1.expect)(pkcs8).toBeDefined();
+            let key = (0, credentials_1.getKey)(pkcs8);
+            (0, globals_1.expect)(key).toBeDefined();
+            const properties = Object.getOwnPropertyNames(key);
+            (0, globals_1.expect)(properties).toContain("n");
+            (0, globals_1.expect)(properties).toContain("e");
+            (0, globals_1.expect)(properties).toContain("d");
+            (0, globals_1.expect)(properties).toContain("sign");
+        }));
+    });
+});

package/dist/test/libs/files.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/libs/files.test.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const files_1 = require("../../src/libs/files");
+const globals_1 = require("@jest/globals");
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+dotenv.config();
+const CERT_PATH = process.env.CERT_PATH;
+(0, globals_1.describe)("FileManager", () => {
+    let fileManager;
+    (0, globals_1.beforeAll)(() => {
+        fileManager = new files_1.FileManager();
+    });
+    (0, globals_1.afterEach)(() => {
+        fileManager = new files_1.FileManager();
+    });
+    (0, globals_1.describe)("environment configuration", () => {
+        (0, globals_1.test)("CERT_PATH should be defined in environment", () => {
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            (0, globals_1.expect)(CERT_PATH).not.toBeNull();
+            (0, globals_1.expect)(typeof CERT_PATH).toBe("string");
+        });
+        (0, globals_1.test)("CERT_PATH should have .p12 extension", () => {
+            (0, globals_1.expect)(CERT_PATH).toMatch(/\.p12$/i);
+        });
+        (0, globals_1.test)("CERT_PATH should be a valid path format", () => {
+            (0, globals_1.expect)(CERT_PATH.length).toBeGreaterThan(0);
+        });
+    });
+    (0, globals_1.describe)("openFile method", () => {
+        (0, globals_1.test)("should successfully open a certificate file", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, globals_1.expect)(CERT_PATH).toBeDefined();
+            const result = yield fileManager.openFile(CERT_PATH);
+            (0, globals_1.expect)(result).toBe(fileManager);
+        }));
+        (0, globals_1.test)("should throw error for non-existent file", () => __awaiter(void 0, void 0, void 0, function* () {
+            const invalidPath = path.join(__dirname, "non-existent-cert.p12");
+            yield (0, globals_1.expect)(fileManager.openFile(invalidPath)).rejects.toThrow();
+        }));
+        (0, globals_1.test)("should load file as Buffer internally", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fileManager.openFile(CERT_PATH);
+            const buffer = fileManager.getFile();
+            (0, globals_1.expect)(buffer).toBeInstanceOf(Buffer);
+            (0, globals_1.expect)(buffer).not.toBeUndefined();
+        }));
+    });
+    (0, globals_1.describe)("getFile method", () => {
+        (0, globals_1.test)("should return undefined when no file is loaded", () => {
+            const buffer = fileManager.getFile();
+            (0, globals_1.expect)(buffer).toBeUndefined();
+        });
+        (0, globals_1.test)("should return Buffer after file is loaded", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fileManager.openFile(CERT_PATH);
+            const buffer = fileManager.getFile();
+            (0, globals_1.expect)(buffer).toBeInstanceOf(Buffer);
+        }));
+        (0, globals_1.test)("should return non-empty buffer for valid certificate", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fileManager.openFile(CERT_PATH);
+            const buffer = fileManager.getFile();
+            (0, globals_1.expect)(buffer === null || buffer === void 0 ? void 0 : buffer.length).toBeGreaterThan(0);
+        }));
+    });
+    (0, globals_1.describe)("toString method", () => {
+        (0, globals_1.test)("should throw error when file is not loaded", () => __awaiter(void 0, void 0, void 0, function* () {
+            const fm = new files_1.FileManager();
+            yield (0, globals_1.expect)(fm.toString("utf8")).rejects.toThrow("File data is not loaded. Please call openFile() first.");
+        }));
+        (0, globals_1.test)("should convert buffer to string with utf8 encoding", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fileManager.openFile(CERT_PATH);
+            // P12 files are binary, so this will have special characters
+            const result = yield fileManager.toString("utf8");
+            (0, globals_1.expect)(typeof result).toBe("string");
+            (0, globals_1.expect)(result.length).toBeGreaterThan(0);
+        }));
+        (0, globals_1.test)("should convert buffer to base64 encoding", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fileManager.openFile(CERT_PATH);
+            const base64Result = yield fileManager.toString("base64");
+            (0, globals_1.expect)(typeof base64Result).toBe("string");
+            // Base64 should only contain valid base64 characters
+            (0, globals_1.expect)(base64Result).toMatch(/^[A-Za-z0-9+/=]+$/);
+        }));
+    });
+    (0, globals_1.describe)("chaining and state management", () => {
+        (0, globals_1.test)("should allow method chaining with openFile", () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield fileManager.openFile(CERT_PATH);
+            (0, globals_1.expect)(result).toBe(fileManager);
+            const buffer = fileManager.getFile();
+            (0, globals_1.expect)(buffer).toBeInstanceOf(Buffer);
+        }));
+        (0, globals_1.test)("should isolate state between instances", () => __awaiter(void 0, void 0, void 0, function* () {
+            const fm1 = new files_1.FileManager();
+            const fm2 = new files_1.FileManager();
+            yield fm1.openFile(CERT_PATH);
+            const buffer1 = fm1.getFile();
+            const buffer2 = fm2.getFile();
+            (0, globals_1.expect)(buffer1).toBeInstanceOf(Buffer);
+            (0, globals_1.expect)(buffer2).toBeUndefined();
+        }));
+    });
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "xades-bes-signer",
+  "version": "1.0.0",
+  "description": "XAdES-BES signer utilities for Node.js (TypeScript) — certificate handling and XAdES-BES signature helpers.",
+  "main": "/dist/src/main.js",
+  "types": "/dist/src/main.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "start:dev": "npx nodemon",
+    "build": "npx tsc",
+    "lint": "eslint '{src,apps,libs,test}/**/*.ts' --fix",
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gabriel-acuna/xades-bas-siggner.git"
+  },
+  "keywords": [
+    "XAdES-BES",
+    "TypeScript",
+    "SRI"
+  ],
+  "author": "Gabriel Acuña R",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gabriel-acuna/xades-bas-siggner/issues"
+  },
+  "homepage": "https://github.com/gabriel-acuna/xades-bas-siggner#readme",
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.8.2",
+    "@types/node-forge": "^1.3.6",
+    "eslint": "^8.50.0",
+    "jest": "^30.2.0",
+    "nodemon": "^3.0.1",
+    "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "dependencies": {
+    "@types/dotenv": "^6.1.1",
+    "dotenv": "^17.2.3",
+    "node-forge": "^1.3.1"
+  }
+}