@super-protocol/sdk-js 3.12.1-beta.2 → 3.13.0-beta.0

package/dist/cjs/certificates/binary-splitter.d.ts

@@ -0,0 +1,26 @@
+import { CertBinaryItem } from './types.js';
+export declare enum CertificateNonOidParts {
+    SERIAL_NUMBER = "SERIAL_NUMBER",
+    SIGNATURE_ALGORITHM = "SIGNATURE_ALGORITHM",
+    ISSUER = "ISSUER",
+    NOT_BEFORE = "NOT_BEFORE",
+    NOT_AFTER = "NOT_AFTER",
+    SUBJECT = "SUBJECT",
+    SUBJECT_PUBLIC_KEY_INFO = "SUBJECT_PUBLIC_KEY_INFO",
+    SIGNATURE = "SIGNATURE"
+}
+export declare class CertificateBinarySplitter {
+    private parts;
+    private readonly certBinary;
+    private lastPosition;
+    constructor(certDer: ArrayBuffer);
+    split(nonOidParts: CertificateNonOidParts[], oids: string[]): Array<Uint8Array | CertBinaryItem>;
+    private processExtensions;
+    private getElementPositionInParent;
+    private addElement;
+    private addPublicKeyElement;
+    private addSignatureElement;
+    private getElementValueAndPosition;
+    private getValueHex;
+    private addPart;
+}

package/dist/cjs/certificates/binary-splitter.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateBinarySplitter = exports.CertificateNonOidParts = void 0;
+const asn1js_1 = require("asn1js");
+var CertificateNonOidParts;
+(function (CertificateNonOidParts) {
+    CertificateNonOidParts["SERIAL_NUMBER"] = "SERIAL_NUMBER";
+    CertificateNonOidParts["SIGNATURE_ALGORITHM"] = "SIGNATURE_ALGORITHM";
+    CertificateNonOidParts["ISSUER"] = "ISSUER";
+    CertificateNonOidParts["NOT_BEFORE"] = "NOT_BEFORE";
+    CertificateNonOidParts["NOT_AFTER"] = "NOT_AFTER";
+    CertificateNonOidParts["SUBJECT"] = "SUBJECT";
+    CertificateNonOidParts["SUBJECT_PUBLIC_KEY_INFO"] = "SUBJECT_PUBLIC_KEY_INFO";
+    CertificateNonOidParts["SIGNATURE"] = "SIGNATURE";
+})(CertificateNonOidParts || (exports.CertificateNonOidParts = CertificateNonOidParts = {}));
+class CertificateBinarySplitter {
+    parts = [];
+    certBinary;
+    lastPosition = 0;
+    constructor(certDer) {
+        this.certBinary = new Uint8Array(certDer);
+    }
+    split(nonOidParts, oids) {
+        this.parts = [];
+        this.lastPosition = 0;
+        try {
+            const asn1 = (0, asn1js_1.fromBER)(this.certBinary);
+            if (asn1.offset === -1) {
+                throw new Error('Error parsing ASN.1 structure');
+            }
+            const certificate = asn1.result;
+            // certificate.valueBlock.value[0] = TBSCertificate
+            // certificate.valueBlock.value[1] = signatureAlgorithm
+            // certificate.valueBlock.value[2] = signature
+            const tbsCertificate = certificate.valueBlock.value[0];
+            const tbsStartPosition = this.getElementPositionInParent(tbsCertificate.toBER());
+            this.addPart(new Uint8Array(this.certBinary.slice(0, tbsStartPosition)));
+            this.lastPosition = tbsStartPosition;
+            const tbsValues = tbsCertificate.valueBlock.value;
+            let tbsIndex = 0;
+            // 1. Version [0] EXPLICIT (optional, default v1)
+            if (tbsValues[tbsIndex].idBlock.tagClass === 3 &&
+                tbsValues[tbsIndex].idBlock.tagNumber === 0) {
+                tbsIndex++; // skip version
+            }
+            // 2. Serial Number (mandatory)
+            const serialNumber = tbsValues[tbsIndex++];
+            if (serialNumber.idBlock.tagNumber !== 2) {
+                throw new Error('Expected serial number (INTEGER)');
+            }
+            if (nonOidParts.includes(CertificateNonOidParts.SERIAL_NUMBER)) {
+                this.addElement({
+                    name: 'serialNumber',
+                    element: serialNumber,
+                    forcePushPrefix: true,
+                });
+            }
+            // 3. Signature Algorithm (mandatory)
+            const signatureAlgorithm = tbsValues[tbsIndex++];
+            if (nonOidParts.includes(CertificateNonOidParts.SIGNATURE_ALGORITHM)) {
+                this.addElement({ name: 'signatureAlgorithm', element: signatureAlgorithm });
+            }
+            // 4. Issuer (mandatory)
+            const issuer = tbsValues[tbsIndex++];
+            if (nonOidParts.includes(CertificateNonOidParts.ISSUER)) {
+                this.addElement({ name: 'issuer', element: issuer });
+            }
+            // 5. Validity (mandatory)
+            const validity = tbsValues[tbsIndex++];
+            const notBefore = validity.valueBlock.value[0];
+            const notAfter = validity.valueBlock.value[1];
+            if (nonOidParts.includes(CertificateNonOidParts.NOT_BEFORE)) {
+                this.addElement({ name: 'notBefore', element: notBefore });
+            }
+            if (nonOidParts.includes(CertificateNonOidParts.NOT_AFTER)) {
+                this.addElement({ name: 'notAfter', element: notAfter });
+            }
+            // 6. Subject
+            const subject = tbsValues[tbsIndex++];
+            if (nonOidParts.includes(CertificateNonOidParts.SUBJECT)) {
+                this.addElement({ name: 'subject', element: subject });
+            }
+            // 7.subjectPublicKeyInfo
+            const subjectPublicKeyInfo = tbsValues[tbsIndex++];
+            const publicKeyBitString = subjectPublicKeyInfo.valueBlock.value[1]; // BIT STRING with public key
+            if (nonOidParts.includes(CertificateNonOidParts.SUBJECT_PUBLIC_KEY_INFO)) {
+                this.addPublicKeyElement(publicKeyBitString);
+            }
+            // 8. issuerUniqueID [1] IMPLICIT (optional, only in v2+)
+            if (tbsIndex < tbsValues.length &&
+                tbsValues[tbsIndex].idBlock.tagClass === 3 &&
+                tbsValues[tbsIndex].idBlock.tagNumber === 1) {
+                tbsIndex++; // skip issuerUniqueID
+            }
+            // 9. subjectUniqueID [2] IMPLICIT (optional, only in v2+)
+            if (tbsIndex < tbsValues.length &&
+                tbsValues[tbsIndex].idBlock.tagClass === 3 &&
+                tbsValues[tbsIndex].idBlock.tagNumber === 2) {
+                tbsIndex++; // skip subjectUniqueID
+            }
+            // 10. Extensions
+            if (tbsIndex < tbsValues.length) {
+                const extensions = tbsValues[tbsIndex];
+                if (extensions.idBlock.tagClass === 3 && extensions.idBlock.tagNumber === 3) {
+                    const extensionsSequence = extensions.valueBlock.value[0];
+                    this.processExtensions(extensionsSequence, oids);
+                }
+            }
+            // 11. signature
+            if (nonOidParts.includes(CertificateNonOidParts.SIGNATURE)) {
+                const signatureAlgorithmId = certificate.valueBlock.value[1];
+                this.addElement({
+                    element: signatureAlgorithmId,
+                    forcePushPrefix: true,
+                    forcePushHeader: true,
+                });
+                const signature = certificate.valueBlock.value[2];
+                this.addSignatureElement(signature);
+            }
+            // Add any remaining part after the last processed element
+            if (this.lastPosition < this.certBinary.length) {
+                this.addPart(new Uint8Array(this.certBinary.slice(this.lastPosition)));
+            }
+            return this.parts;
+        }
+        catch (error) {
+            throw new Error(`Failed to split certificate: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    processExtensions(extensionsSequence, targetOids) {
+        for (const extension of extensionsSequence.valueBlock.value) {
+            const extValues = extension.valueBlock.value;
+            const oid = extValues[0].valueBlock.toString(); // OID as string
+            if (!targetOids.includes(oid)) {
+                continue;
+            }
+            // Find OCTET STRING with extension value
+            let octetString;
+            if (extValues.length === 3) {
+                // OID + critical + OCTET STRING
+                octetString = extValues[2];
+            }
+            else {
+                // OID + OCTET STRING
+                octetString = extValues[1];
+            }
+            this.addElement({ name: 'extension', element: octetString, oid });
+        }
+    }
+    getElementPositionInParent(element, parent) {
+        const elementBytes = new Uint8Array(element);
+        const parentToSearch = parent || this.certBinary;
+        const startPosition = parent ? 0 : this.lastPosition;
+        for (let i = startPosition; i <= parentToSearch.length - elementBytes.length; i++) {
+            let match = true;
+            for (let j = 0; j < elementBytes.length; j++) {
+                if (parentToSearch[i + j] !== elementBytes[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return i;
+            }
+        }
+        throw new Error('Some element not found in certificate binary');
+    }
+    addElement({ name, element, oid, forcePushPrefix, forcePushHeader, }) {
+        const { value, position } = this.getElementValueAndPosition({
+            element,
+            forcePushPrefix,
+            forcePushHeader,
+        });
+        name ? this.addPart({ name, value, oid }) : this.addPart(new Uint8Array(value));
+        this.lastPosition = position + value.byteLength;
+    }
+    addPublicKeyElement(element) {
+        const { value, position } = this.getElementValueAndPosition({ element });
+        // extract first byte 0x04 - uncompressed public key
+        this.addPart(new Uint8Array(value.slice(0, 1)));
+        this.addPart({ name: 'publicKey', value: value.slice(1) });
+        this.lastPosition = position + value.byteLength;
+    }
+    addSignatureElement(element) {
+        const { value, position } = this.getElementValueAndPosition({ element });
+        // Parse the signature as ASN.1 SEQUENCE containing R and S values
+        const signatureAsn1 = (0, asn1js_1.fromBER)(value);
+        const sequence = signatureAsn1.result;
+        const rElement = sequence.valueBlock.value[0];
+        const sElement = sequence.valueBlock.value[1];
+        const rBer = rElement.toBER();
+        const sBer = sElement.toBER();
+        // R value
+        const rPosition = this.getElementPositionInParent(rBer, value);
+        this.addPart(new Uint8Array(value.slice(0, rPosition)));
+        let rValue = this.getValueHex(rElement);
+        if (rValue.byteLength > 32) {
+            rValue = rValue.slice(rValue.byteLength - 32);
+        }
+        const rHeaderLength = rBer.byteLength - rValue.byteLength;
+        if (rHeaderLength > 0) {
+            this.addPart(new Uint8Array(value.slice(rPosition, rPosition + rHeaderLength)));
+        }
+        const rEndPos = rPosition + rBer.byteLength;
+        // S value
+        const sPosition = this.getElementPositionInParent(sBer, value);
+        if (sPosition > rEndPos) {
+            this.addPart(new Uint8Array(value.slice(rEndPos, sPosition)));
+        }
+        let sValue = this.getValueHex(sElement);
+        if (sValue.byteLength > 32) {
+            sValue = sValue.slice(sValue.byteLength - 32);
+        }
+        const sHeaderLength = sBer.byteLength - sValue.byteLength;
+        if (sHeaderLength > 0) {
+            this.addPart(new Uint8Array(value.slice(sPosition, sPosition + sHeaderLength)), true);
+        }
+        const fullSignature = Buffer.concat([Buffer.from(rValue), Buffer.from(sValue)]);
+        this.addPart({ name: 'signature', value: new Uint8Array(fullSignature) });
+        const sEndPos = sPosition + sBer.byteLength;
+        if (sEndPos < value.byteLength) {
+            this.addPart(new Uint8Array(value.slice(sEndPos)));
+        }
+        this.lastPosition = position + value.byteLength;
+    }
+    getElementValueAndPosition({ element, forcePushPrefix = false, forcePushHeader = false, }) {
+        const elementBer = element.toBER();
+        const elementValue = this.getValueHex(element);
+        const elementPosition = this.getElementPositionInParent(elementBer);
+        const valueOffsetInElement = elementBer.byteLength - elementValue.byteLength;
+        const valuePosition = elementPosition + valueOffsetInElement;
+        // Part before element
+        if (this.lastPosition < elementPosition) {
+            this.addPart(new Uint8Array(this.certBinary.slice(this.lastPosition, elementPosition)), forcePushPrefix);
+        }
+        // Element header
+        if (valueOffsetInElement > 0) {
+            this.addPart(new Uint8Array(this.certBinary.slice(elementPosition, valuePosition)), forcePushHeader);
+        }
+        return {
+            value: new Uint8Array(elementValue),
+            position: valuePosition,
+        };
+    }
+    getValueHex(element) {
+        if ('valueHex' in element.valueBlock) {
+            return element.valueBlock.valueHex;
+        }
+        if ('value' in element.valueBlock && Array.isArray(element.valueBlock.value)) {
+            const arrayBuffers = element.valueBlock.value.map((valueItem) => valueItem.toBER());
+            const concatenatedBuffer = arrayBuffers.reduce((acc, current) => Buffer.concat([acc, Buffer.from(current)]), Buffer.alloc(0));
+            return new Uint8Array(concatenatedBuffer).buffer;
+        }
+        throw new Error('Cannot extract valueHex from element');
+    }
+    addPart(part, forcePush = false) {
+        const lastPart = this.parts[this.parts.length - 1];
+        if (part instanceof Uint8Array && lastPart instanceof Uint8Array && !forcePush) {
+            const merged = new Uint8Array(lastPart.length + part.length);
+            merged.set(lastPart, 0);
+            merged.set(part, lastPart.length);
+            this.parts[this.parts.length - 1] = merged;
+            return;
+        }
+        this.parts.push(part);
+    }
+}
+exports.CertificateBinarySplitter = CertificateBinarySplitter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"binary-splitter.js","sourceRoot":"","sources":["../../../src/certificates/binary-splitter.ts"],"names":[],"mappings":"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"}

package/dist/cjs/certificates/generator.d.ts

@@ -0,0 +1,38 @@
+import { GenerateCertParams, GenerateCsrParams, ParsedCert, ParsedCsr, SignatureAlgorithm } from './types.js';
+export declare class CertificateGenerator {
+    /**
+     * Generates certificate based on the provided parameters.
+     * @param params - Parameters for generating the certificate.
+     * @returns The generated certificate in PEM format.
+     */
+    static generateCert(params: GenerateCertParams): Promise<string>;
+    /**
+     * Generates a pair of cryptographic keys based on the specified signature algorithm.
+     * @param signatureAlgorithm - The algorithm to use for key generation.
+     * @returns A promise that resolves to a CryptoKeyPair containing the public and private keys.
+     */
+    static generateKeys(signatureAlgorithm: SignatureAlgorithm): Promise<CryptoKeyPair>;
+    /**
+     * Generates a Certificate Signing Request (CSR) based on the provided parameters.
+     * @param params - Parameters for generating the CSR.
+     * @returns The generated CSR in PEM format.
+     */
+    static generateCsr(params: GenerateCsrParams): Promise<string>;
+    /**
+     * Checks and parses a certificate in PEM format.
+     * @param certPem - The certificate in PEM format.
+     * @returns An object containing the parsed certificate details.
+     */
+    static checkAndParseCert(certPem: string): Promise<ParsedCert>;
+    /**
+     * Checks and parses a Certificate Signing Request (CSR) in PEM format.
+     * @param csrPem - The CSR in PEM format.
+     * @returns An object containing the parsed CSR details.
+     */
+    static checkAndParseCsr(csrPem: string): Promise<ParsedCsr>;
+    private static getCryptoKeys;
+    private static generateSerialNumber;
+    private static getPrincipalInfo;
+    private static getAlgorithm;
+    private static extractDnsNamesFromExtensions;
+}

package/dist/cjs/certificates/generator.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateGenerator = void 0;
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = require("crypto");
+const node_forge_1 = __importDefault(require("node-forge"));
+const x509_1 = require("@peculiar/x509");
+const setup_crypto_js_1 = require("./setup-crypto.js");
+const CryptoKeysTransformer_js_1 = require("../utils/CryptoKeysTransformer.js");
+const helper_js_1 = require("../utils/helper.js");
+const MAX_X509_SERIAL = BigInt('0x' + 'F'.repeat(40));
+const principalAttributeMap = {
+    commonName: 'CN',
+    country: 'C',
+    localityName: 'L',
+    stateName: 'ST',
+    organization: 'O',
+    organizationalUnit: 'OU',
+};
+const notAllowedCertificateCustomExtensions = [...Object.values(node_forge_1.default.pki.oids)];
+class CertificateGenerator {
+    /**
+     * Generates certificate based on the provided parameters.
+     * @param params - Parameters for generating the certificate.
+     * @returns The generated certificate in PEM format.
+     */
+    static async generateCert(params) {
+        const ca = Boolean(params.ca);
+        const { publicKey, privateKey } = await CertificateGenerator.getCryptoKeys(params);
+        const signingAlgorithm = publicKey.algorithm;
+        const extensions = [new x509_1.BasicConstraintsExtension(ca, undefined, true)];
+        const extendedKeyUsageItems = [];
+        if (signingAlgorithm.namedCurve !== 'K-256' && params.dnsNames?.length) {
+            const generalNames = params.dnsNames.map((dnsName) => ({
+                type: ((0, helper_js_1.isIpAddress)(dnsName) ? 'ip' : 'dns'),
+                value: dnsName,
+            }));
+            extensions.push(new x509_1.SubjectAlternativeNameExtension(generalNames));
+            extendedKeyUsageItems.push(...[x509_1.ExtendedKeyUsage.serverAuth, x509_1.ExtendedKeyUsage.clientAuth]);
+        }
+        if (params.ocspSigning) {
+            extendedKeyUsageItems.push(x509_1.ExtendedKeyUsage.ocspSigning);
+        }
+        if (extendedKeyUsageItems.length) {
+            extensions.push(new x509_1.ExtendedKeyUsageExtension(extendedKeyUsageItems, false));
+        }
+        let keyUsageFlags = x509_1.KeyUsageFlags.digitalSignature | x509_1.KeyUsageFlags.keyEncipherment;
+        if (params.ca) {
+            keyUsageFlags |= x509_1.KeyUsageFlags.keyCertSign;
+        }
+        extensions.push(new x509_1.KeyUsagesExtension(keyUsageFlags, true));
+        if (params.customExtensions?.length) {
+            const filteredExtensions = params.customExtensions.filter((ext) => !notAllowedCertificateCustomExtensions.includes(ext.oid));
+            for (const customExtension of filteredExtensions) {
+                if (!customExtension.oid || !customExtension.value) {
+                    throw new Error('Custom extension OID and value are required');
+                }
+                extensions.push(new x509_1.Extension(customExtension.oid, false, customExtension.value));
+            }
+        }
+        const createCertificateParams = {
+            serialNumber: CertificateGenerator.generateSerialNumber(),
+            issuer: CertificateGenerator.getPrincipalInfo(params.issuer),
+            subject: CertificateGenerator.getPrincipalInfo(params.subject),
+            notBefore: new Date(),
+            notAfter: params.notAfter,
+            publicKey,
+            signingKey: privateKey,
+            signingAlgorithm,
+            extensions,
+        };
+        const cert = await x509_1.X509CertificateGenerator.create(createCertificateParams);
+        return cert.toString('pem');
+    }
+    /**
+     * Generates a pair of cryptographic keys based on the specified signature algorithm.
+     * @param signatureAlgorithm - The algorithm to use for key generation.
+     * @returns A promise that resolves to a CryptoKeyPair containing the public and private keys.
+     */
+    static generateKeys(signatureAlgorithm) {
+        const algorithm = CertificateGenerator.getAlgorithm(signatureAlgorithm);
+        return setup_crypto_js_1.cryptoProvider.subtle.generateKey(algorithm, true, ['sign', 'verify']);
+    }
+    /**
+     * Generates a Certificate Signing Request (CSR) based on the provided parameters.
+     * @param params - Parameters for generating the CSR.
+     * @returns The generated CSR in PEM format.
+     */
+    static async generateCsr(params) {
+        const keys = await CertificateGenerator.getCryptoKeys(params);
+        const signingAlgorithm = keys.publicKey.algorithm;
+        signingAlgorithm.hash = { name: 'SHA-256' };
+        const extensions = [];
+        if (signingAlgorithm.namedCurve !== 'K-256' && params.dnsNames?.length) {
+            const generalNames = params.dnsNames.map((dnsName) => ({
+                type: ((0, helper_js_1.isIpAddress)(dnsName) ? 'ip' : 'dns'),
+                value: dnsName,
+            }));
+            extensions.push(new x509_1.SubjectAlternativeNameExtension(generalNames));
+        }
+        if (params.customExtensions?.length) {
+            for (const customExtension of params.customExtensions) {
+                if (!customExtension.oid || !customExtension.value) {
+                    throw new Error(`Some custom extension missed OID or value`);
+                }
+                extensions.push(new x509_1.Extension(customExtension.oid, false, customExtension.value));
+            }
+        }
+        const createCsrParams = {
+            name: CertificateGenerator.getPrincipalInfo(params.subject),
+            keys,
+            signingAlgorithm,
+            extensions,
+        };
+        const csr = await x509_1.Pkcs10CertificateRequestGenerator.create(createCsrParams);
+        return csr.toString('pem');
+    }
+    /**
+     * Checks and parses a certificate in PEM format.
+     * @param certPem - The certificate in PEM format.
+     * @returns An object containing the parsed certificate details.
+     */
+    static async checkAndParseCert(certPem) {
+        const cert = new x509_1.X509Certificate(certPem);
+        if (cert.issuer === cert.subject) {
+            const isValid = await cert.verify();
+            if (!isValid) {
+                throw new Error('Self-signed certificate signature verification failed');
+            }
+        }
+        const publicKey = await setup_crypto_js_1.cryptoProvider.subtle.importKey('spki', cert.publicKey.rawData, Object.assign(cert.signatureAlgorithm, cert.publicKey.algorithm), true, ['verify']);
+        return {
+            serialNumber: cert.serialNumber,
+            publicKey,
+            subject: cert.subject,
+            issuer: cert.issuer,
+            notBefore: cert.notBefore,
+            notAfter: cert.notAfter,
+            dnsNames: CertificateGenerator.extractDnsNamesFromExtensions(cert.extensions),
+            extensions: cert.extensions
+                .filter((ext) => ext.type !== node_forge_1.default.pki.oids['subjectAltName'])
+                .map((ext) => ({
+                oid: ext.type,
+                value: Buffer.from(ext.value),
+            })),
+        };
+    }
+    /**
+     * Checks and parses a Certificate Signing Request (CSR) in PEM format.
+     * @param csrPem - The CSR in PEM format.
+     * @returns An object containing the parsed CSR details.
+     */
+    static async checkAndParseCsr(csrPem) {
+        const csr = new x509_1.Pkcs10CertificateRequest(csrPem);
+        const isValid = await csr.verify();
+        if (!isValid) {
+            throw new Error('CSR signature verification failed');
+        }
+        const publicKey = await setup_crypto_js_1.cryptoProvider.subtle.importKey('spki', csr.publicKey.rawData, Object.assign(csr.signatureAlgorithm, csr.publicKey.algorithm), true, ['verify']);
+        const parsedCsr = {
+            subject: csr.subject,
+            publicKey,
+            dnsNames: CertificateGenerator.extractDnsNamesFromExtensions(csr.extensions),
+            extensions: csr.extensions
+                .filter((ext) => ext.type !== node_forge_1.default.pki.oids['subjectAltName'])
+                .map((ext) => ({
+                oid: ext.type,
+                value: Buffer.from(ext.value),
+            })),
+        };
+        return parsedCsr;
+    }
+    static async getCryptoKeys({ privateKey, publicKey }) {
+        const [pubKey, privKey] = await Promise.all([
+            typeof publicKey === 'string'
+                ? CryptoKeysTransformer_js_1.CryptoKeysTransformer.spkiPemToCryptoKey(publicKey)
+                : publicKey,
+            typeof privateKey === 'string'
+                ? CryptoKeysTransformer_js_1.CryptoKeysTransformer.pkcs8PemToCryptoKey(privateKey)
+                : privateKey,
+        ]);
+        assert_1.default.deepEqual(pubKey.algorithm, privKey.algorithm, 'Both keys must have same algorithm defined');
+        return { publicKey: pubKey, privateKey: privKey };
+    }
+    static generateSerialNumber() {
+        const uuid = (0, crypto_1.randomUUID)().replace(/-/g, '');
+        const serial = BigInt('0x' + uuid) % MAX_X509_SERIAL;
+        return serial.toString();
+    }
+    static getPrincipalInfo(principal) {
+        if (typeof principal === 'string') {
+            return principal;
+        }
+        if (!principal.commonName) {
+            throw new Error('Common name is required');
+        }
+        return Object.entries(principal)
+            .map(([key, value]) => `${principalAttributeMap[key] || key}=${value}`)
+            .join(',');
+    }
+    static getAlgorithm(signatureAlgorithm) {
+        switch (signatureAlgorithm) {
+            case 'RSASSA-PKCS1-SHA256':
+                return {
+                    name: 'RSASSA-PKCS1-v1_5',
+                    hash: 'SHA-256',
+                    publicExponent: new Uint8Array([1, 0, 1]), // 65537
+                    modulusLength: 2048,
+                };
+            case 'ECDSA-P-256-SHA256':
+                return {
+                    name: 'ECDSA',
+                    namedCurve: 'P-256',
+                };
+            case 'ECDSA-secp256k1-SHA256':
+                return {
+                    name: 'ECDSA',
+                    namedCurve: 'K-256',
+                };
+            default:
+                throw new Error(`Unsupported signature algorithm: ${signatureAlgorithm}`);
+        }
+    }
+    static extractDnsNamesFromExtensions(extensions) {
+        const subjectAltNameExt = extensions.find((ext) => ext.type === node_forge_1.default.pki.oids['subjectAltName']);
+        if (!subjectAltNameExt) {
+            return;
+        }
+        const dnsNames = subjectAltNameExt.names.items.map((item) => item.value);
+        return dnsNames;
+    }
+}
+exports.CertificateGenerator = CertificateGenerator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../src/certificates/generator.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAC5B,mCAAoC;AACpC,4DAA+B;AAC/B,yCAgBwB;AAWxB,uDAAmD;AACnD,gFAA0E;AAC1E,kDAAiD;AAEjD,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;AAEtD,MAAM,qBAAqB,GAA2B;IACpD,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,GAAG;IACZ,YAAY,EAAE,GAAG;IACjB,SAAS,EAAE,IAAI;IACf,YAAY,EAAE,GAAG;IACjB,kBAAkB,EAAE,IAAI;CACzB,CAAC;AAEF,MAAM,qCAAqC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,oBAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AAEjF,MAAa,oBAAoB;IAC/B;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,MAA0B;QAClD,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAE9B,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,MAAM,oBAAoB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACnF,MAAM,gBAAgB,GAAG,SAAS,CAAC,SAAyB,CAAC;QAE7D,MAAM,UAAU,GAAgB,CAAC,IAAI,gCAAyB,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;QAErF,MAAM,qBAAqB,GAAuB,EAAE,CAAC;QAErD,IAAI,gBAAgB,CAAC,UAAU,KAAK,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;YACvE,MAAM,YAAY,GAAqB,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBACvE,IAAI,EAAE,CAAC,IAAA,uBAAW,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAoB;gBAC9D,KAAK,EAAE,OAAO;aACf,CAAC,CAAC,CAAC;YACJ,UAAU,CAAC,IAAI,CAAC,IAAI,sCAA+B,CAAC,YAAY,CAAC,CAAC,CAAC;YAEnE,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,uBAAgB,CAAC,UAAU,EAAE,uBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC5F,CAAC;QAED,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;YACvB,qBAAqB,CAAC,IAAI,CAAC,uBAAgB,CAAC,WAAW,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,qBAAqB,CAAC,MAAM,EAAE,CAAC;YACjC,UAAU,CAAC,IAAI,CAAC,IAAI,gCAAyB,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC,CAAC;QAC/E,CAAC;QAED,IAAI,aAAa,GAAG,oBAAa,CAAC,gBAAgB,GAAG,oBAAa,CAAC,eAAe,CAAC;QACnF,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;YACd,aAAa,IAAI,oBAAa,CAAC,WAAW,CAAC;QAC7C,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,IAAI,yBAAkB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;QAE7D,IAAI,MAAM,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC;YACpC,MAAM,kBAAkB,GAAG,MAAM,CAAC,gBAAgB,CAAC,MAAM,CACvD,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,qCAAqC,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAClE,CAAC;YACF,KAAK,MAAM,eAAe,IAAI,kBAAkB,EAAE,CAAC;gBACjD,IAAI,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;oBACnD,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;gBACjE,CAAC;gBACD,UAAU,CAAC,IAAI,CAAC,IAAI,gBAAS,CAAC,eAAe,CAAC,GAAG,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;YACpF,CAAC;QACH,CAAC;QAED,MAAM,uBAAuB,GAAgC;YAC3D,YAAY,EAAE,oBAAoB,CAAC,oBAAoB,EAAE;YACzD,MAAM,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;YAC5D,OAAO,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC;YAC9D,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,SAAS;YACT,UAAU,EAAE,UAAU;YACtB,gBAAgB;YAChB,UAAU;SACX,CAAC;QAEF,MAAM,IAAI,GAAG,MAAM,+BAAwB,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAAC;QAE5E,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,kBAAsC;QACxD,MAAM,SAAS,GAAG,oBAAoB,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC;QACxE,OAAO,gCAAc,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAChF,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,MAAyB;QAChD,MAAM,IAAI,GAAG,MAAM,oBAAoB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAC9D,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,SAAyB,CAAC;QAClE,gBAAgB,CAAC,IAAI,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAE5C,MAAM,UAAU,GAAgB,EAAE,CAAC;QAEnC,IAAI,gBAAgB,CAAC,UAAU,KAAK,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;YACvE,MAAM,YAAY,GAAqB,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBACvE,IAAI,EAAE,CAAC,IAAA,uBAAW,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAoB;gBAC9D,KAAK,EAAE,OAAO;aACf,CAAC,CAAC,CAAC;YACJ,UAAU,CAAC,IAAI,CAAC,IAAI,sCAA+B,CAAC,YAAY,CAAC,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,MAAM,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC;YACpC,KAAK,MAAM,eAAe,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;gBACtD,IAAI,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;oBACnD,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;gBAC/D,CAAC;gBACD,UAAU,CAAC,IAAI,CAAC,IAAI,gBAAS,CAAC,eAAe,CAAC,GAAG,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;YACpF,CAAC;QACH,CAAC;QAED,MAAM,eAAe,GAAyC;YAC5D,IAAI,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC;YAC3D,IAAI;YACJ,gBAAgB;YAChB,UAAU;SACX,CAAC;QAEF,MAAM,GAAG,GAAG,MAAM,wCAAiC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAE5E,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAe;QAC5C,MAAM,IAAI,GAAG,IAAI,sBAAe,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC;YACjC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;YACpC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,gCAAc,CAAC,MAAM,CAAC,SAAS,CACrD,MAAM,EACN,IAAI,CAAC,SAAS,CAAC,OAAO,EACtB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAChE,IAAI,EACJ,CAAC,QAAQ,CAAC,CACX,CAAC;QAEF,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,SAAS;YACT,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,oBAAoB,CAAC,6BAA6B,CAAC,IAAI,CAAC,UAAU,CAAC;YAC7E,UAAU,EAAE,IAAI,CAAC,UAAU;iBACxB,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,oBAAK,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;iBAC9D,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBACb,GAAG,EAAE,GAAG,CAAC,IAAI;gBACb,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;aAC9B,CAAC,CAAC;SACN,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAc;QAC1C,MAAM,GAAG,GAAG,IAAI,+BAAwB,CAAC,MAAM,CAAC,CAAC;QAEjD,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,CAAC;QACnC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,gCAAc,CAAC,MAAM,CAAC,SAAS,CACrD,MAAM,EACN,GAAG,CAAC,SAAS,CAAC,OAAO,EACrB,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,kBAAkB,EAAE,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,EAC9D,IAAI,EACJ,CAAC,QAAQ,CAAC,CACX,CAAC;QAEF,MAAM,SAAS,GAAc;YAC3B,OAAO,EAAE,GAAG,CAAC,OAAO;YACpB,SAAS;YACT,QAAQ,EAAE,oBAAoB,CAAC,6BAA6B,CAAC,GAAG,CAAC,UAAU,CAAC;YAC5E,UAAU,EAAE,GAAG,CAAC,UAAU;iBACvB,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,oBAAK,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;iBAC9D,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBACb,GAAG,EAAE,GAAG,CAAC,IAAI;gBACb,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;aAC9B,CAAC,CAAC;SACN,CAAC;QAEF,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,UAAU,EAAE,SAAS,EAAmB;QAI3E,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC1C,OAAO,SAAS,KAAK,QAAQ;gBAC3B,CAAC,CAAC,gDAAqB,CAAC,kBAAkB,CAAC,SAAS,CAAC;gBACrD,CAAC,CAAC,SAAS;YACb,OAAO,UAAU,KAAK,QAAQ;gBAC5B,CAAC,CAAC,gDAAqB,CAAC,mBAAmB,CAAC,UAAU,CAAC;gBACvD,CAAC,CAAC,UAAU;SACf,CAAC,CAAC;QAEH,gBAAM,CAAC,SAAS,CACd,MAAM,CAAC,SAAS,EAChB,OAAO,CAAC,SAAS,EACjB,4CAA4C,CAC7C,CAAC;QAEF,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;IACpD,CAAC;IAEO,MAAM,CAAC,oBAAoB;QACjC,MAAM,IAAI,GAAG,IAAA,mBAAU,GAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,eAAe,CAAC;QACrD,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,SAAwC;QACtE,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAClC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC;aAC7B,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,qBAAqB,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,KAAK,EAAE,CAAC;aACtE,IAAI,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IAEO,MAAM,CAAC,YAAY,CAAC,kBAA0B;QACpD,QAAQ,kBAAkB,EAAE,CAAC;YAC3B,KAAK,qBAAqB;gBACxB,OAAO;oBACL,IAAI,EAAE,mBAAmB;oBACzB,IAAI,EAAE,SAAS;oBACf,cAAc,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ;oBACnD,aAAa,EAAE,IAAI;iBACpB,CAAC;YACJ,KAAK,oBAAoB;gBACvB,OAAO;oBACL,IAAI,EAAE,OAAO;oBACb,UAAU,EAAE,OAAO;iBACpB,CAAC;YACJ,KAAK,wBAAwB;gBAC3B,OAAO;oBACL,IAAI,EAAE,OAAO;oBACb,UAAU,EAAE,OAAO;iBACpB,CAAC;YACJ;gBACE,MAAM,IAAI,KAAK,CAAC,oCAAoC,kBAAkB,EAAE,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,6BAA6B,CAAC,UAAuB;QAClE,MAAM,iBAAiB,GAAG,UAAU,CAAC,IAAI,CACvC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,oBAAK,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACR,CAAC;QACjD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,iBAAiB,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzE,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF;AAjRD,oDAiRC"}

package/dist/cjs/certificates/helper.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import * as pkijs from 'pkijs';
-import { ValidateCertChainResult } from './types.js';
+import { AlgorithmObj, ValidateCertChainResult } from './types.js';
+import './setup-crypto.js';
 export declare class CertificatesHelper {
     private static downloadedCertificateCache;
-    static derToPem(data: ArrayBuffer): string;
+    static derToPem(data: ArrayBuffer, type?: string): string;
     static pemToDer(certPem: string): Uint8Array;
     static splitPemCerts(certs: string): string[];
     static getDomain(certPem: string): string | undefined;
@@ -16,6 +17,8 @@ export declare class CertificatesHelper {
     static derChainToPem(certsDer: Uint8Array[]): string;
     static downloadCertWithCache(url: string): Promise<Buffer>;
     static sortCertsFromLeafToRoot(certsPem: string | string[]): pkijs.Certificate[];
+    static getCertPublicKeyAlgorithm(certPem: string): AlgorithmObj;
+    static getCsrPublicKeyAlgorithm(csrPem: string): AlgorithmObj;
     static validateCertChain(certsPem: string | string[], caPem: string | string[], options?: {
         offline?: boolean;
     }): Promise<ValidateCertChainResult>;