@openade/fe/dist/signature.service.js

Fatturazione Elettronica - Electronic Invoicing for Sistema di Interscambio (SDI)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SignatureService = void 0;
const crypto_1 = require("crypto");
const fs_1 = require("fs");
class SignatureService {
    async sign(data, privateKey, algorithm = 'RSA-SHA256') {
        try {
            const digest = (0, crypto_1.createHash)('sha256').update(data).digest('hex');
            const signer = (0, crypto_1.createSign)(algorithm);
            signer.update(data);
            const signature = signer.sign(privateKey, 'hex');
            return {
                signature,
                digest,
                algorithm,
            };
        }
        catch (error) {
            throw new Error(`Failed to sign data: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    async verify(data, signature, publicKey, algorithm = 'RSA-SHA256') {
        try {
            const verifier = (0, crypto_1.createVerify)(algorithm);
            verifier.update(data);
            return verifier.verify(publicKey, signature, 'hex');
        }
        catch (error) {
            throw new Error(`Failed to verify signature: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    async signXml(xmlContent, privateKey, algorithm = 'RSA-SHA256') {
        try {
            const data = Buffer.from(xmlContent, 'utf8');
            const result = await this.sign(data, privateKey, algorithm);
            const signedXml = `<?xml version="1.0" encoding="UTF-8"?>
<SignedDocument>
  <Signature>
    <Algorithm>${result.algorithm}</Algorithm>
    <Digest>${result.digest}</Digest>
    <Value>${result.signature}</Value>
  </Signature>
  <Content><![CDATA[${xmlContent}]]></Content>
</SignedDocument>`;
            return signedXml;
        }
        catch (error) {
            throw new Error(`Failed to sign XML: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    async verifySignedXml(signedXml, publicKey, algorithm = 'RSA-SHA256') {
        try {
            const signatureMatch = signedXml.match(/<Value>([^<]+)<\/Value>/);
            const contentMatch = signedXml.match(/<Content><!\[CDATA\[([\s\S]*?)\]\]><\/Content>/);
            if (!signatureMatch || !contentMatch) {
                return false;
            }
            const signature = signatureMatch[1];
            const content = contentMatch[1];
            const data = Buffer.from(content, 'utf8');
            return await this.verify(data, signature, publicKey, algorithm);
        }
        catch (error) {
            throw new Error(`Failed to verify signed XML: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    loadPrivateKeyFromFile(filePath) {
        try {
            return (0, fs_1.readFileSync)(filePath, 'utf8');
        }
        catch (error) {
            throw new Error(`Failed to load private key from file: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    loadCertificateFromFile(filePath) {
        try {
            return (0, fs_1.readFileSync)(filePath, 'utf8');
        }
        catch (error) {
            throw new Error(`Failed to load certificate from file: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    async getCertificateInfo(_certificate) {
        try {
            return {
                subject: 'CN=Mock Certificate',
                issuer: 'CN=Mock CA',
                validFrom: new Date(),
                validTo: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000),
                serialNumber: '123456789',
            };
        }
        catch (error) {
            throw new Error(`Failed to get certificate info: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
}
exports.SignatureService = SignatureService;
//# sourceMappingURL=signature.service.js.map