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

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Asn1Service = void 0;
class Asn1Service {
    async encode(data) {
        if (typeof data === 'string') {
            const hashBuffer = Buffer.from(data, 'hex');
            return this.encodeOctetString(hashBuffer);
        }
        if (Buffer.isBuffer(data)) {
            return this.encodeOctetString(data);
        }
        throw new Error('Unsupported data type for ASN.1 encoding');
    }
    async decode(data) {
        try {
            return this.decodeOctetString(data);
        }
        catch (error) {
            throw new Error(`ASN.1 decoding failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
    encodeOctetString(data) {
        const length = data.length;
        let lengthBytes;
        if (length < 128) {
            lengthBytes = Buffer.from([length]);
        }
        else {
            const lengthBuffer = Buffer.alloc(4);
            lengthBuffer.writeUInt32BE(length, 0);
            let start = 0;
            while (start < 4 && lengthBuffer[start] === 0) {
                start++;
            }
            const actualLength = 4 - start;
            lengthBytes = Buffer.concat([Buffer.from([0x80 | actualLength]), lengthBuffer.slice(start)]);
        }
        return Buffer.concat([
            Buffer.from([0x04]),
            lengthBytes,
            data,
        ]);
    }
    decodeOctetString(data) {
        if (data.length < 2) {
            throw new Error('Invalid ASN.1 data: too short');
        }
        if (data[0] !== 0x04) {
            throw new Error('Invalid ASN.1 data: expected OCTET STRING tag');
        }
        let length;
        let offset = 1;
        if (data[1] < 128) {
            length = data[1];
            offset = 2;
        }
        else {
            const lengthOfLength = data[1] & 0x7f;
            if (lengthOfLength === 0 || lengthOfLength > 4) {
                throw new Error('Invalid ASN.1 data: invalid length encoding');
            }
            length = 0;
            for (let i = 0; i < lengthOfLength; i++) {
                length = (length << 8) | data[offset + i];
            }
            offset += lengthOfLength;
        }
        if (offset + length > data.length) {
            throw new Error('Invalid ASN.1 data: length exceeds buffer');
        }
        return data.slice(offset, offset + length);
    }
    async createTimestampRequest(hash, hashAlgorithm = 'sha256') {
        const requestData = {
            hash,
            hashAlgorithm,
            timestamp: Date.now(),
        };
        return this.encode(JSON.stringify(requestData));
    }
    async parseTimestampResponse(response) {
        try {
            const decoded = await this.decode(response);
            const data = JSON.parse(decoded.toString());
            return {
                timestamp: new Date(data.timestamp).toISOString(),
                accuracy: data.accuracy,
                tsa: data.tsa,
            };
        }
        catch (error) {
            throw new Error(`Timestamp response parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
        }
    }
}
exports.Asn1Service = Asn1Service;
//# sourceMappingURL=asn1.service.js.map