@super-protocol/swarm-contracts-sdk 0.0.1-beta.1

package/dist/cjs/certificates/generator.js

@@ -0,0 +1,262 @@
+"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 ONE_HOUR_MS = 60 * 60 * 1000; // 1 hour in milliseconds
+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: subjectPublicKey, privateKey: signerPrivateKey } = await CertificateGenerator.getCryptoKeys(params);
+        const signingAlgorithm = subjectPublicKey.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 (params.ocspExtension) {
+            const { ocspUrl, issuerCertUrl } = params.ocspExtension;
+            extensions.push(new x509_1.AuthorityInfoAccessExtension({
+                ocsp: [ocspUrl],
+                ...(issuerCertUrl ? { caIssuers: [issuerCertUrl] } : {}),
+            }));
+        }
+        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));
+        const signerPublicKey = await CryptoKeysTransformer_js_1.CryptoKeysTransformer.cryptoPublicFromCryptoPrivate(signerPrivateKey);
+        extensions.push(...[
+            await x509_1.AuthorityKeyIdentifierExtension.create(signerPublicKey),
+            await x509_1.SubjectKeyIdentifierExtension.create(subjectPublicKey),
+        ]);
+        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(Date.now() - ONE_HOUR_MS), //1 hour ago to avoid clock skew issues between servers
+            notAfter: params.notAfter,
+            publicKey: subjectPublicKey,
+            signingKey: signerPrivateKey,
+            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']);
+        const authorityKeyIdentifierExt = cert.extensions.find((ext) => ext instanceof x509_1.AuthorityKeyIdentifierExtension);
+        const authorityKeyIdentifier = authorityKeyIdentifierExt?.keyId;
+        const subjectKeyIdentifierExt = cert.extensions.find((ext) => ext instanceof x509_1.SubjectKeyIdentifierExtension);
+        const subjectKeyIdentifier = subjectKeyIdentifierExt?.keyId;
+        return {
+            serialNumberHex: cert.serialNumber,
+            publicKey,
+            subject: cert.subject,
+            issuer: cert.issuer,
+            notBefore: cert.notBefore,
+            notAfter: cert.notAfter,
+            dnsNames: CertificateGenerator.extractDnsNamesFromExtensions(cert.extensions),
+            authorityKeyIdentifier,
+            subjectKeyIdentifier,
+            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, '');
+        let serial = BigInt('0x' + uuid) % MAX_X509_SERIAL;
+        // Ensure the serial number is positive in ASN1
+        // 89abcdefABCDEF - set of all hex symbols that have 1 as first bit
+        const serialHex = serial.toString(16);
+        if (serialHex[0] && '89abcdefABCDEF'.includes(serialHex[0])) {
+            serial = serial >> 1n;
+        }
+        return serial.toString(16);
+    }
+    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":"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"}

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import * as pkijs from 'pkijs';
+import { AlgorithmObj, CertWithKeyIdentifiers, ValidateCertChainResult } from './types.js';
+import './setup-crypto.js';
+export declare class CertificatesHelper {
+    private static downloadedCertificateCache;
+    static derToPem(data: ArrayBuffer, type?: string): string;
+    static pemToDer(certPem: string): Uint8Array;
+    static splitPemCerts(certs: string): string[];
+    static getDomain(certPem: string): string | undefined;
+    static getExtensionValue(certParam: string | pkijs.Certificate, oid: string): Buffer | undefined;
+    static extractCAFromChain(certsPem: string): {
+        certs: string;
+        ca: string;
+    };
+    static getIssuer(certWithKeyIdent: CertWithKeyIdentifiers, potentialIssuersWithKeyIdent: CertWithKeyIdentifiers[]): CertWithKeyIdentifiers | undefined;
+    static pemChainToDer(certsPem: string): Uint8Array[];
+    static derChainToPem(certsDer: Uint8Array[]): string;
+    static downloadCertWithCache(url: string): Promise<Buffer>;
+    static buildChain(leaf: pkijs.Certificate | CertWithKeyIdentifiers, potentialIssuers: pkijs.Certificate[] | CertWithKeyIdentifiers[]): CertWithKeyIdentifiers[];
+    static sortCertsFromLeafToRoot(certsPem: string | string[] | pkijs.Certificate[] | CertWithKeyIdentifiers[]): CertWithKeyIdentifiers[];
+    static getCertPublicKeyAlgorithm(certPem: string): AlgorithmObj;
+    static getCsrPublicKeyAlgorithm(csrPem: string): AlgorithmObj;
+    static validateCertChain(certsPem: string | string[], caPem: string | string[], options?: {
+        offline?: boolean;
+    }): Promise<ValidateCertChainResult>;
+    static toPkiCerts(certs: string | string[]): pkijs.Certificate[];
+    static addKeyIdentifiersToCerts(certs: Array<pkijs.Certificate | CertWithKeyIdentifiers>): CertWithKeyIdentifiers[];
+}

package/dist/cjs/certificates/helper.js

@@ -0,0 +1,216 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificatesHelper = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const axios_1 = __importDefault(require("axios"));
+const node_forge_1 = __importDefault(require("node-forge"));
+const pkijs = __importStar(require("pkijs"));
+const x509_1 = require("@peculiar/x509");
+const memory_js_1 = require("../utils/cache/memory.js");
+const ocsp_js_1 = require("./ocsp.js");
+const crl_js_1 = require("./crl.js");
+require("./setup-crypto.js");
+const pki_common_1 = require("@super-protocol/pki-common");
+const oidsForOcspCheck = [
+    pki_common_1.OID_CUSTOM_EXTENSION_CHALLENGE_ID,
+    pki_common_1.OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID,
+    pki_common_1.OID_CUSTOM_EXTENSION_NVIDIA_INFO_GPU,
+    pki_common_1.OID_CUSTOM_EXTENSION_CHALLENGE_CERTIFICATE_ID,
+];
+class CertificatesHelper {
+    static downloadedCertificateCache = (0, memory_js_1.createMemoryCache)();
+    static derToPem(data, type = 'CERTIFICATE') {
+        return node_forge_1.default.pem.encode({
+            contentDomain: null,
+            dekInfo: null,
+            headers: [],
+            procType: null,
+            type,
+            body: Buffer.from(data).toString('binary'),
+        });
+    }
+    static pemToDer(certPem) {
+        return Buffer.from(node_forge_1.default.pki.pemToDer(certPem).bytes(), 'binary');
+    }
+    static splitPemCerts(certs) {
+        const pemRegex = /(-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----)/g;
+        return certs.match(pemRegex) || [];
+    }
+    static getDomain(certPem) {
+        const cert = node_forge_1.default.pki.certificateFromPem(certPem);
+        return cert.subject.attributes.find((attribute) => attribute.name === 'commonName')
+            ?.value;
+    }
+    static getExtensionValue(certParam, oid) {
+        const cert = typeof certParam === 'string'
+            ? pkijs.Certificate.fromBER(CertificatesHelper.pemToDer(certParam))
+            : certParam;
+        const extension = cert.extensions?.find((ext) => ext.extnID === oid);
+        return extension && Buffer.from(extension.extnValue.valueBlock.toBER());
+    }
+    static extractCAFromChain(certsPem) {
+        const certs = CertificatesHelper.toPkiCerts(certsPem);
+        const splitCerts = lodash_1.default.partition(certs, (cert) => !cert.issuer.isEqual(cert.subject));
+        const toPemChain = (certs) => certs.map((cert) => CertificatesHelper.derToPem(cert.toSchema().toBER())).join('\n');
+        return {
+            certs: toPemChain(splitCerts[0]),
+            ca: toPemChain(splitCerts[1]),
+        };
+    }
+    static getIssuer(certWithKeyIdent, potentialIssuersWithKeyIdent) {
+        return potentialIssuersWithKeyIdent.find((potentialIssuer) => (certWithKeyIdent?.authorityKeyIdentifier && potentialIssuer.subjectKeyIdentifier
+            ? certWithKeyIdent.authorityKeyIdentifier.isEqual(potentialIssuer.subjectKeyIdentifier)
+            : certWithKeyIdent?.cert.issuer.isEqual(potentialIssuer.cert.subject)) &&
+            !certWithKeyIdent?.cert.subject.isEqual(certWithKeyIdent?.cert.issuer));
+    }
+    static pemChainToDer(certsPem) {
+        const certs = CertificatesHelper.splitPemCerts(certsPem);
+        return certs.map((certPem) => CertificatesHelper.pemToDer(certPem));
+    }
+    static derChainToPem(certsDer) {
+        return certsDer
+            .map((cert) => CertificatesHelper.derToPem(cert))
+            .join('')
+            .trim();
+    }
+    static async downloadCertWithCache(url) {
+        const responseData = await CertificatesHelper.downloadedCertificateCache.wrap(url, async () => {
+            const response = await (0, axios_1.default)(url, {
+                responseType: 'arraybuffer',
+            });
+            return response?.data;
+        }, {
+            ttl: 5 * 60 * 1000, //5 min
+        });
+        return responseData;
+    }
+    static buildChain(leaf, potentialIssuers) {
+        const chain = CertificatesHelper.addKeyIdentifiersToCerts([leaf]);
+        const potentialIssuersWithKeyIdentifiers = CertificatesHelper.addKeyIdentifiersToCerts(potentialIssuers);
+        let currentCert = chain[0];
+        do {
+            currentCert = CertificatesHelper.getIssuer(currentCert, potentialIssuersWithKeyIdentifiers);
+            if (currentCert) {
+                chain.push(currentCert);
+            }
+        } while (currentCert);
+        return chain;
+    }
+    static sortCertsFromLeafToRoot(certsPem) {
+        const allCerts = typeof certsPem === 'string' || certsPem.every((cert) => typeof cert === 'string')
+            ? CertificatesHelper.toPkiCerts(certsPem)
+            : certsPem;
+        const certsWithKeyIdentifiers = CertificatesHelper.addKeyIdentifiersToCerts(allCerts);
+        const leafs = certsWithKeyIdentifiers.filter((certToCheck) => !certsWithKeyIdentifiers.some((certsToCheckWith) => certToCheck.subjectKeyIdentifier && certsToCheckWith.authorityKeyIdentifier
+            ? certToCheck.subjectKeyIdentifier.isEqual(certsToCheckWith.authorityKeyIdentifier)
+            : certToCheck.cert.subject.isEqual(certsToCheckWith.cert.issuer)));
+        const chains = leafs
+            .map((leaf) => CertificatesHelper.buildChain(leaf.cert, allCerts))
+            .sort((one, two) => two.length - one.length);
+        return chains.flat();
+    }
+    static getCertPublicKeyAlgorithm(certPem) {
+        const cert = new x509_1.X509Certificate(certPem);
+        const publicKey = cert.publicKey;
+        return publicKey.algorithm;
+    }
+    static getCsrPublicKeyAlgorithm(csrPem) {
+        const csr = new x509_1.Pkcs10CertificateRequest(csrPem);
+        const publicKey = csr.publicKey;
+        return publicKey.algorithm;
+    }
+    static async validateCertChain(certsPem, caPem, options = {}) {
+        const { offline } = options;
+        // reverse() is needed because pkijs expects certificates to be ordered from root to leaf
+        const sortedCertsWithKeyIdent = CertificatesHelper.sortCertsFromLeafToRoot(certsPem).reverse();
+        const sortedCerts = sortedCertsWithKeyIdent.map((certWithKeyIdent) => certWithKeyIdent.cert);
+        const ca = CertificatesHelper.toPkiCerts(caPem);
+        try {
+            const crls = offline ? [] : await crl_js_1.CRLHelper.getCRLFromCerts(sortedCerts);
+            const ocspBaseResponses = offline
+                ? []
+                : await ocsp_js_1.OCSPHelper.getOCSPResponseFromCerts(sortedCertsWithKeyIdent, CertificatesHelper.addKeyIdentifiersToCerts(ca), oidsForOcspCheck);
+            const chainEngine = new pkijs.CertificateChainValidationEngine({
+                certs: sortedCerts,
+                trustedCerts: ca,
+                ocsps: ocspBaseResponses,
+                crls,
+            });
+            const verifyResult = await chainEngine.verify();
+            if (!verifyResult.result) {
+                return {
+                    isValid: false,
+                    errorMessage: verifyResult.resultMessage,
+                };
+            }
+            /**
+             * When verifying a certificate chain, chainEngine.verify() attempts to find a valid
+             * certification path using the provided certificates. It may ignore certificates that
+             * don't belong to the valid chain.
+             *
+             * This check ensures that all certificates we initially provided were actually used
+             * in the valid certification path that CertificateChainValidationEngine constructed.
+             * If any certificate was ignored/not used, we throw an error.
+             */
+            const isEachCertVerified = sortedCerts.every((cert) => verifyResult.certificatePath?.find((verifiedCert) => verifiedCert.serialNumber.isEqual(cert.serialNumber)));
+            if (!isEachCertVerified) {
+                throw new Error('Some of certificates do not belong to chain');
+            }
+            return {
+                isValid: true,
+            };
+        }
+        catch (err) {
+            return {
+                isValid: false,
+                errorMessage: err.message,
+            };
+        }
+    }
+    static toPkiCerts(certs) {
+        const certsArray = Array.isArray(certs) ? certs : CertificatesHelper.splitPemCerts(certs);
+        return certsArray.map((certPem) => pkijs.Certificate.fromBER(CertificatesHelper.pemToDer(certPem)));
+    }
+    static addKeyIdentifiersToCerts(certs) {
+        return certs.map((cert) => {
+            if ('cert' in cert) {
+                return cert;
+            }
+            const authorityKeyIdentifierExt = cert.extensions?.find((ext) => ext.extnID === node_forge_1.default.pki.oids['authorityKeyIdentifier'])?.parsedValue;
+            const subjectKeyIdentifierExt = cert.extensions?.find((ext) => ext.extnID === node_forge_1.default.pki.oids['subjectKeyIdentifier'])?.parsedValue;
+            return {
+                cert,
+                authorityKeyIdentifier: authorityKeyIdentifierExt?.keyIdentifier,
+                subjectKeyIdentifier: subjectKeyIdentifierExt,
+            };
+        });
+    }
+}
+exports.CertificatesHelper = CertificatesHelper;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helper.js","sourceRoot":"","sources":["../../../src/certificates/helper.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+export * from './helper.js';
+export * from './types.js';
+export * from './serializer.js';
+export * from './generator.js';
+export * from './ocsp.js';

package/dist/cjs/certificates/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./helper.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./serializer.js"), exports);
+__exportStar(require("./generator.js"), exports);
+__exportStar(require("./ocsp.js"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2VydGlmaWNhdGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBNEI7QUFDNUIsNkNBQTJCO0FBQzNCLGtEQUFnQztBQUNoQyxpREFBK0I7QUFDL0IsNENBQTBCIn0=

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

@@ -0,0 +1,14 @@
+import * as pkijs from 'pkijs';
+import { CertWithKeyIdentifiers, GenerateOcspResponseParams, ParsedOcspRequest } from '../index.js';
+export declare class OCSPHelper {
+    static getOCSPResponseFromCerts(certs: CertWithKeyIdentifiers[], ca: CertWithKeyIdentifiers[], oidsToCheck?: string[]): Promise<pkijs.BasicOCSPResponse[]>;
+    static generateOCSPResponse(params: GenerateOcspResponseParams): Promise<ArrayBuffer>;
+    static parseOCSPRequest(ocspRequestBinary: ArrayBuffer): ParsedOcspRequest;
+    private static canCertSignOCSPResponse;
+    private static getOCSPRequestData;
+    private static getOCSPResponse;
+    private static sendOCSPRequest;
+    private static getNonceForRequest;
+    private static getNonceFromResponse;
+    private static getCertExtensionsToCheck;
+}