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

package/dist/mjs/certificates/ocsp.js

@@ -0,0 +1,290 @@
+import _ from 'lodash';
+import forge from 'node-forge';
+import * as pkijs from 'pkijs';
+import * as asn1js from 'asn1js';
+import axios from 'axios';
+import { CertID, OCSPRequest, Request, TBSRequest } from '@peculiar/asn1-ocsp';
+import { OctetString, AsnSerializer, AsnParser } from '@peculiar/asn1-schema';
+import { AlgorithmIdentifier, Extensions, Extension } from '@peculiar/asn1-x509';
+import { OID_AUTHORITY_INFORMATION_ACCESS_EXTENSION, OID_OCSP_ACCESS_METHOD, OID_OCSP_ISSUER_ACCESS_METHOD, } from '../constants.js';
+import { CertificatesHelper } from './helper.js';
+import { CryptoKeysTransformer, OcspCertStatus, constants, helpers, } from '../index.js';
+import { ExtendedKeyUsage } from '@peculiar/x509';
+import { tryWithInterval } from '../utils/helpers/tryWithInterval.js';
+const DEFAULT_REVOCATION_DATE = new Date('1970-01-01T00:00:00Z');
+export class OCSPHelper {
+    static async getOCSPResponseFromCerts(certs, ca, oidsToCheck = []) {
+        const ocspRequestsData = certs
+            .map(OCSPHelper.getOCSPRequestData)
+            .filter(Boolean);
+        if (!ocspRequestsData.length) {
+            return [];
+        }
+        const groupByOcspUrl = _.groupBy(ocspRequestsData, 'ocspUrl');
+        const getOcspResponseParams = Object.entries(groupByOcspUrl).map(([ocspUrl, certParams]) => ({
+            ocspUrl,
+            certsWithIssuer: certParams.map(({ certWithKeyIdent, issuerCertUrl }) => ({
+                cert: certWithKeyIdent.cert,
+                issuerCertUrl,
+                issuerCert: CertificatesHelper.getIssuer(certWithKeyIdent, [...certs, ...ca])?.cert,
+            })),
+            ca: ca.map((certWithKeyIdent) => certWithKeyIdent.cert),
+            oidsToCheck,
+        }));
+        const ocspResponseResults = await Promise.allSettled(getOcspResponseParams.map((params) => OCSPHelper.getOCSPResponse(params)));
+        const rejectedOCSPResponses = ocspResponseResults
+            .filter(helpers.isRejected)
+            .map((result) => result.reason);
+        if (rejectedOCSPResponses.length) {
+            throw new Error(`Can't get valid OCSP responses for some of certificates (reasons=${rejectedOCSPResponses.join(';\n')})`);
+        }
+        return ocspResponseResults.filter(helpers.isFulfilled).map((result) => result.value);
+    }
+    static async generateOCSPResponse(params) {
+        const ocspBasicResp = new pkijs.BasicOCSPResponse();
+        const { issuerPem: issuerCertPem, caCertsPem, certs, privateKey, nonce } = params;
+        const { certs: issuerCertsPem } = CertificatesHelper.extractCAFromChain(`${issuerCertPem}\n${caCertsPem || ''}`);
+        const issuerCert = CertificatesHelper.toPkiCerts(issuerCertPem)[0];
+        ocspBasicResp.tbsResponseData.responderID = issuerCert.subject;
+        ocspBasicResp.tbsResponseData.producedAt = new Date();
+        ocspBasicResp.certs = CertificatesHelper.toPkiCerts(issuerCertsPem);
+        for (const certData of certs) {
+            const { serialNumber, status, issuerKeyHash, issuerNameHash, hashAlgorithm, revocationDate } = certData;
+            const certID = new pkijs.CertID({
+                hashAlgorithm: new pkijs.AlgorithmIdentifier({
+                    algorithmId: hashAlgorithm,
+                    algorithmParams: new asn1js.Null(),
+                }),
+                issuerNameHash: new asn1js.OctetString({ valueHex: issuerNameHash }),
+                issuerKeyHash: new asn1js.OctetString({ valueHex: issuerKeyHash }),
+                serialNumber: new asn1js.Integer({ valueHex: serialNumber }),
+            });
+            const response = new pkijs.SingleResponse({
+                certID,
+            });
+            switch (status) {
+                case OcspCertStatus.OK:
+                case OcspCertStatus.Unknown:
+                    response.certStatus = new asn1js.Primitive({
+                        idBlock: {
+                            tagClass: 3,
+                            tagNumber: status,
+                        },
+                    });
+                    break;
+                case OcspCertStatus.Revoked:
+                    response.certStatus = new asn1js.Constructed({
+                        idBlock: {
+                            tagClass: 3,
+                            tagNumber: status,
+                            isConstructed: true,
+                        },
+                        value: [
+                            new asn1js.GeneralizedTime({
+                                valueDate: revocationDate || DEFAULT_REVOCATION_DATE,
+                            }),
+                        ],
+                    });
+                    break;
+                default:
+                    throw new Error(`Unknown OCSP certificate status: ${status}`);
+            }
+            response.thisUpdate = new Date();
+            ocspBasicResp.tbsResponseData.responses.push(response);
+        }
+        if (nonce) {
+            ocspBasicResp.tbsResponseData.responseExtensions = [
+                new pkijs.Extension({
+                    extnID: constants.OID_OCSP_NONCE,
+                    extnValue: nonce,
+                }),
+            ];
+        }
+        const privateCryptoKey = await CryptoKeysTransformer.pkcs8PemToCryptoKey(privateKey);
+        await ocspBasicResp.sign(privateCryptoKey, 'SHA-256');
+        const ocspBasicRespRaw = ocspBasicResp.toSchema().toBER(false);
+        const ocspResp = new pkijs.OCSPResponse({
+            responseStatus: new asn1js.Enumerated({ value: 0 }), // success
+            responseBytes: new pkijs.ResponseBytes({
+                responseType: pkijs.id_PKIX_OCSP_Basic,
+                response: new asn1js.OctetString({ valueHex: ocspBasicRespRaw }),
+            }),
+        });
+        return ocspResp.toSchema().toBER();
+    }
+    static parseOCSPRequest(ocspRequestBinary) {
+        const ocspRequest = AsnParser.parse(ocspRequestBinary, OCSPRequest);
+        const certRequests = ocspRequest.tbsRequest.requestList.map((request) => {
+            const reqCert = {
+                hashAlgorithm: request.reqCert.hashAlgorithm.algorithm,
+                issuerNameHash: Buffer.from(request.reqCert.issuerNameHash.buffer),
+                issuerKeyHash: Buffer.from(request.reqCert.issuerKeyHash.buffer),
+                serialNumber: request.reqCert.serialNumber,
+            };
+            const extensionsToCheck = request.singleRequestExtensions?.map((ext) => ({
+                oid: ext.extnID,
+                value: Buffer.from(ext.extnValue.buffer),
+            })) || [];
+            return { ...reqCert, extensionsToCheck };
+        });
+        const nonceExtension = ocspRequest.tbsRequest.requestExtensions?.find((ext) => ext.extnID === constants.OID_OCSP_NONCE);
+        const nonce = nonceExtension && nonceExtension.extnValue.buffer;
+        return { certRequests, nonce };
+    }
+    static canCertSignOCSPResponse(cert, certsWithIssuer) {
+        if (certsWithIssuer.length &&
+            certsWithIssuer.every((certWithIssuer) => cert.toString() === certWithIssuer.issuerCert?.toString())) {
+            return true;
+        }
+        const extKeysUsage = cert.extensions?.find((ext) => ext.extnID === forge.pki.oids['extKeyUsage']);
+        if (!extKeysUsage) {
+            return false;
+        }
+        return Boolean(extKeysUsage.parsedValue.keyPurposes.find((usage) => usage === ExtendedKeyUsage.ocspSigning));
+    }
+    static getOCSPRequestData(certWithKeyIdent) {
+        const authorityExtension = CertificatesHelper.getExtensionValue(certWithKeyIdent.cert, OID_AUTHORITY_INFORMATION_ACCESS_EXTENSION);
+        if (!authorityExtension) {
+            return;
+        }
+        const extensionValue = pkijs.ExtensionValueFactory.fromBER(OID_AUTHORITY_INFORMATION_ACCESS_EXTENSION, authorityExtension);
+        const ocspUrl = extensionValue.accessDescriptions.find((desc) => desc.accessMethod === OID_OCSP_ACCESS_METHOD)?.accessLocation.value;
+        const issuerCertUrl = extensionValue.accessDescriptions.find((desc) => desc.accessMethod === OID_OCSP_ISSUER_ACCESS_METHOD)?.accessLocation.value;
+        if (!ocspUrl) {
+            return;
+        }
+        return { ocspUrl, issuerCertUrl, certWithKeyIdent };
+    }
+    static async getOCSPResponse(params) {
+        const { ocspUrl, certsWithIssuer, ca, oidsToCheck } = params;
+        const requestList = [];
+        const issuerCertificates = [];
+        const addIssuerCertIfNotExists = (cert) => {
+            if (!issuerCertificates.some((c) => c.subject.isEqual(cert.subject))) {
+                issuerCertificates.push(cert);
+            }
+        };
+        for (const certWithIssuer of certsWithIssuer) {
+            if (!certWithIssuer.issuerCert && certWithIssuer.issuerCertUrl) {
+                const issuerCertRaw = await CertificatesHelper.downloadCertWithCache(certWithIssuer.issuerCertUrl);
+                certWithIssuer.issuerCert = pkijs.Certificate.fromBER(issuerCertRaw);
+            }
+            if (!certWithIssuer.issuerCert) {
+                throw new Error(`No issuer certificate found for OCSP request for ${certWithIssuer.cert.subject}`);
+            }
+            addIssuerCertIfNotExists(certWithIssuer.issuerCert);
+            addIssuerCertIfNotExists(certWithIssuer.cert);
+            const certID = new pkijs.CertID();
+            await certID.createForCertificate(certWithIssuer.cert, {
+                hashAlgorithm: 'SHA-1',
+                issuerCertificate: certWithIssuer.issuerCert,
+            });
+            const request = new Request({
+                reqCert: new CertID({
+                    hashAlgorithm: new AlgorithmIdentifier({
+                        algorithm: certID.hashAlgorithm.algorithmId,
+                    }),
+                    issuerNameHash: new OctetString().fromASN(certID.issuerNameHash),
+                    issuerKeyHash: new OctetString().fromASN(certID.issuerKeyHash),
+                    serialNumber: certID.serialNumber.valueBlock.valueHex,
+                }),
+            });
+            const extensionsToCheck = OCSPHelper.getCertExtensionsToCheck(certWithIssuer.cert, oidsToCheck);
+            if (extensionsToCheck.length) {
+                request.singleRequestExtensions = new Extensions(extensionsToCheck.map((ext) => new Extension({ extnID: ext.oid, extnValue: new OctetString(ext.value) })));
+            }
+            requestList.push(request);
+        }
+        const reqNonce = OCSPHelper.getNonceForRequest();
+        const ocspReq = new OCSPRequest({
+            tbsRequest: new TBSRequest({
+                requestList,
+                requestExtensions: new Extensions([
+                    new Extension({
+                        extnID: constants.OID_OCSP_NONCE,
+                        extnValue: new OctetString(reqNonce),
+                    }),
+                ]),
+            }),
+        });
+        const ocspBasicResp = await OCSPHelper.sendOCSPRequest(ocspUrl, ocspReq);
+        const respNonce = await OCSPHelper.getNonceFromResponse(ocspBasicResp);
+        if (respNonce && Buffer.compare(reqNonce, respNonce) !== 0) {
+            throw new Error(`OCSP nonces from request and response do not match`);
+        }
+        if (!ocspBasicResp.certs?.length) {
+            ocspBasicResp.certs = issuerCertificates;
+        }
+        const certsWithKeyIdentifier = await Promise.all(ocspBasicResp.certs.map(async (cert) => {
+            let keyIdentifier = cert.extensions
+                ?.find((ext) => ext.extnID === forge.pki.oids['subjectKeyIdentifier'])
+                ?.parsedValue.valueBlock.toBER();
+            if (!keyIdentifier) {
+                keyIdentifier = await cert.getKeyHash();
+            }
+            return {
+                cert,
+                keyIdentifier: Buffer.from(keyIdentifier),
+            };
+        }));
+        const signers = certsWithKeyIdentifier.filter(({ cert, keyIdentifier }) => cert.subject.isEqual(ocspBasicResp.tbsResponseData.responderID) ||
+            (ocspBasicResp.tbsResponseData?.responderID?.valueBlock &&
+                Buffer.compare(keyIdentifier, Buffer.from(ocspBasicResp.tbsResponseData?.responderID?.valueBlock?.toBER())) === 0));
+        if (!signers.length) {
+            throw new Error('No OCSP signer certificate found');
+        }
+        if (signers.length > 1) {
+            throw new Error('Prohibited attempt to replace OCSP signer');
+        }
+        const signerChain = CertificatesHelper.buildChain(signers[0], [
+            ...ocspBasicResp.certs,
+            ...issuerCertificates,
+        ]);
+        ocspBasicResp.certs = signerChain.map((certWithKeyIdentifiers) => certWithKeyIdentifiers.cert);
+        const isSignerValid = OCSPHelper.canCertSignOCSPResponse(signers[0].cert, params.certsWithIssuer);
+        if (!isSignerValid) {
+            throw new Error('OCSP signer certificate does not have the OCSP signing extended key usage');
+        }
+        const isValid = await ocspBasicResp.verify({ trustedCerts: ca });
+        if (!isValid) {
+            throw new Error('OCSP response verification failed');
+        }
+        return ocspBasicResp;
+    }
+    static async sendOCSPRequest(ocspUrl, ocspReq) {
+        const ocspResponse = await tryWithInterval({
+            handler: async () => await axios(ocspUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/ocsp-request',
+                },
+                responseType: 'arraybuffer',
+                data: AsnSerializer.serialize(ocspReq),
+            }),
+            retryInterval: 1000,
+            retryMax: 3,
+        });
+        const ocspRespSimpl = pkijs.OCSPResponse.fromBER(ocspResponse.data);
+        if (!ocspRespSimpl.responseBytes) {
+            throw new Error('"No "ResponseBytes" in the OCSP Response - nothing to verify');
+        }
+        const ocspBasicResp = pkijs.BasicOCSPResponse.fromBER(ocspRespSimpl.responseBytes.response.valueBlock.valueHexView);
+        return ocspBasicResp;
+    }
+    static getNonceForRequest() {
+        return pkijs.getRandomValues(new Uint8Array(32));
+    }
+    static getNonceFromResponse(ocspBasicResp) {
+        const nonceExtension = ocspBasicResp.tbsResponseData?.responseExtensions?.find((extension) => extension.extnID === constants.OID_OCSP_NONCE);
+        return nonceExtension && Buffer.from(nonceExtension.extnValue.valueBlock.valueHex);
+    }
+    static getCertExtensionsToCheck(cert, oidsToCheck) {
+        return oidsToCheck
+            .map((oid) => {
+            const value = CertificatesHelper.getExtensionValue(cert, oid);
+            return { oid, value };
+        })
+            .filter((ext) => Boolean(ext.value));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ocsp.js","sourceRoot":"","sources":["../../../src/certificates/ocsp.ts"],"names":[],"mappings":"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"}

package/dist/mjs/certificates/serializer.d.ts

@@ -0,0 +1,13 @@
+import { BufferedChunkedX509Cert } from './types.js';
+import { ChunkedX509Cert } from '@super-protocol/dto-js';
+export declare const BLOCKCHAIN_CERT_TBS_PARTS: string[];
+export declare class CertificateSerializer {
+    static serializeCertChain(certChainPem: string): string;
+    static deserializeCertChain(input: string): string;
+    static isSerializedCertChain(certChainBase64: string): boolean;
+    static serializeForBlockchain(certPem: string): ChunkedX509Cert;
+    static deserializeFromBlockchain(blockchainCert: ChunkedX509Cert): string;
+    private static removeLeadingZerosIfNeeded;
+    private static getPart;
+    static chunkedToBufferedChunkedX509Cert(blockchainCert: ChunkedX509Cert): BufferedChunkedX509Cert;
+}

package/dist/mjs/certificates/serializer.js

@@ -0,0 +1,135 @@
+import forge from 'node-forge';
+import _ from 'lodash';
+import { CertificateBinarySplitter, CertificateNonOidParts } from './binary-splitter.js';
+import { CertificatesHelper } from './helper.js';
+import { OID_CUSTOM_EXTENSION_USER_DATA } from '../constants.js';
+import { OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID, OID_CUSTOM_EXTENSION_CHALLENGE_ID, } from '@super-protocol/pki-common';
+import { fromBlockchainHex, fromBlockchainHexOptional, toBlockchainHex } from '../utils/helper.js';
+const CERTS_CHAIN_DELIMITER = ';';
+const CERTS_SERIALIZATION_PREFIX = 'certs:';
+export const BLOCKCHAIN_CERT_TBS_PARTS = [
+    'serialNumber',
+    'expirationDate',
+    'publicKey',
+    'ca',
+    'userData',
+    'mrEnclave',
+    'mrSigner',
+];
+export class CertificateSerializer {
+    static serializeCertChain(certChainPem) {
+        const certsDer = CertificatesHelper.pemChainToDer(certChainPem);
+        return `${CERTS_SERIALIZATION_PREFIX}${certsDer.map((cert) => Buffer.from(cert).toString('base64')).join(CERTS_CHAIN_DELIMITER)}`;
+    }
+    static deserializeCertChain(input) {
+        if (!input.startsWith(CERTS_SERIALIZATION_PREFIX)) {
+            throw new Error(`Missing prefix "${CERTS_SERIALIZATION_PREFIX}" in input`);
+        }
+        const certsDer = input
+            .split(CERTS_SERIALIZATION_PREFIX)[1]
+            ?.split(CERTS_CHAIN_DELIMITER)
+            ?.map((cert) => Buffer.from(cert, 'base64'));
+        return CertificatesHelper.derChainToPem(certsDer);
+    }
+    static isSerializedCertChain(certChainBase64) {
+        return certChainBase64.startsWith(CERTS_SERIALIZATION_PREFIX);
+    }
+    static serializeForBlockchain(certPem) {
+        const certAlgorithm = CertificatesHelper.getCertPublicKeyAlgorithm(certPem);
+        if (certAlgorithm.name !== 'ECDSA' || certAlgorithm.namedCurve !== 'K-256') {
+            throw new Error(`Unsupported certificate algorithm: ${certAlgorithm.name}${certAlgorithm.namedCurve ? `with curve ${certAlgorithm.namedCurve}` : ''}. Only ECDSA with secp256k1 curve is supported.`);
+        }
+        const certDer = CertificatesHelper.pemToDer(certPem);
+        const parts = new CertificateBinarySplitter(certDer).split([
+            CertificateNonOidParts.SERIAL_NUMBER,
+            CertificateNonOidParts.SIGNATURE,
+            CertificateNonOidParts.NOT_AFTER,
+            CertificateNonOidParts.SUBJECT_PUBLIC_KEY_INFO,
+        ], [
+            forge.pki.oids['basicConstraints'],
+            OID_CUSTOM_EXTENSION_USER_DATA,
+            OID_CUSTOM_EXTENSION_CHALLENGE_ID,
+            OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID,
+        ]);
+        const [nonSerializedParts, serializedParts] = _.partition(parts, (part) => part instanceof Uint8Array);
+        const expirationDate = CertificateSerializer.getPart(serializedParts, 'notAfter');
+        const serial = CertificateSerializer.getPart(serializedParts, 'serialNumber');
+        const publicKey = CertificateSerializer.getPart(serializedParts, 'publicKey');
+        const ca = CertificateSerializer.getPart(serializedParts, forge.pki.oids['basicConstraints']);
+        const userData = CertificateSerializer.getPart(serializedParts, OID_CUSTOM_EXTENSION_USER_DATA, false);
+        const mrEnclave = CertificateSerializer.getPart(serializedParts, OID_CUSTOM_EXTENSION_CHALLENGE_ID, false);
+        const mrSigner = CertificateSerializer.getPart(serializedParts, OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID, false);
+        const signature = CertificateSerializer.getPart(serializedParts, 'signature');
+        if (serializedParts.length !== 0) {
+            throw new Error(`Unexpected serialized parts found in certificate: ${serializedParts.map((part) => part.name || part.oid).join(', ')}`);
+        }
+        return {
+            nonSerializedParts: nonSerializedParts.map(toBlockchainHex),
+            expirationDate: toBlockchainHex(expirationDate.value),
+            ca: toBlockchainHex(ca.value),
+            userData: toBlockchainHex(userData?.value),
+            serialNumber: toBlockchainHex(serial.value),
+            signature: toBlockchainHex(signature.value),
+            publicKey: toBlockchainHex(publicKey.value),
+            mrEnclave: toBlockchainHex(mrEnclave?.value),
+            mrSigner: toBlockchainHex(mrSigner?.value),
+        };
+    }
+    static deserializeFromBlockchain(blockchainCert) {
+        const data = CertificateSerializer.chunkedToBufferedChunkedX509Cert(blockchainCert);
+        const bufferParts = [];
+        bufferParts.push(Buffer.from(data.nonSerializedParts[0]));
+        bufferParts.push(Buffer.from(data.nonSerializedParts[1]));
+        let partIndex = 2;
+        for (const field of BLOCKCHAIN_CERT_TBS_PARTS) {
+            const value = data[field];
+            if (value) {
+                bufferParts.push(Buffer.from(value));
+                if (partIndex < data.nonSerializedParts.length) {
+                    bufferParts.push(Buffer.from(data.nonSerializedParts[partIndex++]));
+                }
+            }
+        }
+        // adding signature part
+        // we need to left exactly one non-serialized part (bytes r and s values)
+        for (; partIndex < data.nonSerializedParts.length - 1; partIndex++) {
+            bufferParts.push(Buffer.from(data.nonSerializedParts[partIndex]));
+        }
+        const rValue = data.signature.slice(0, 32);
+        bufferParts.push(Buffer.from(CertificateSerializer.removeLeadingZerosIfNeeded(rValue)));
+        if (partIndex < data.nonSerializedParts.length) {
+            bufferParts.push(Buffer.from(data.nonSerializedParts[partIndex++]));
+        }
+        const sValue = data.signature.slice(32, 64);
+        bufferParts.push(Buffer.from(CertificateSerializer.removeLeadingZerosIfNeeded(sValue)));
+        const certDer = Buffer.concat(bufferParts);
+        return CertificatesHelper.derToPem(certDer);
+    }
+    static removeLeadingZerosIfNeeded(value) {
+        if (value[0] !== 0 || (value[0] === 0 && value[1] > 127)) {
+            return value;
+        }
+        return value.slice(1);
+    }
+    static getPart(parts, nameOrOid, mandatory = true) {
+        const part = _.remove(parts, (part) => part.name === nameOrOid || part.oid === nameOrOid)[0];
+        if (!part && mandatory) {
+            throw new Error(`Part with name or OID "${nameOrOid}" not found in certificate`);
+        }
+        return part;
+    }
+    static chunkedToBufferedChunkedX509Cert(blockchainCert) {
+        return {
+            nonSerializedParts: blockchainCert.nonSerializedParts.map((part) => fromBlockchainHex(part)),
+            expirationDate: fromBlockchainHex(blockchainCert.expirationDate),
+            ca: fromBlockchainHex(blockchainCert.ca),
+            userData: fromBlockchainHexOptional(blockchainCert.userData),
+            publicKey: fromBlockchainHex(blockchainCert.publicKey),
+            serialNumber: fromBlockchainHex(blockchainCert.serialNumber),
+            mrEnclave: fromBlockchainHexOptional(blockchainCert.mrEnclave),
+            mrSigner: fromBlockchainHexOptional(blockchainCert.mrSigner),
+            signature: fromBlockchainHex(blockchainCert.signature),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serializer.js","sourceRoot":"","sources":["../../../src/certificates/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,CAAC,MAAM,QAAQ,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EACL,wCAAwC,EACxC,iCAAiC,GAClC,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEnG,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,MAAM,0BAA0B,GAAG,QAAQ,CAAC;AAE5C,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,cAAc;IACd,gBAAgB;IAChB,WAAW;IACX,IAAI;IACJ,UAAU;IACV,WAAW;IACX,UAAU;CACX,CAAC;AAEF,MAAM,OAAO,qBAAqB;IAChC,MAAM,CAAC,kBAAkB,CAAC,YAAoB;QAC5C,MAAM,QAAQ,GAAG,kBAAkB,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QAEhE,OAAO,GAAG,0BAA0B,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,EAAE,CAAC;IACpI,CAAC;IAED,MAAM,CAAC,oBAAoB,CAAC,KAAa;QACvC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,0BAA0B,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,mBAAmB,0BAA0B,YAAY,CAAC,CAAC;QAC7E,CAAC;QAED,MAAM,QAAQ,GAAG,KAAK;aACnB,KAAK,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;YACrC,EAAE,KAAK,CAAC,qBAAqB,CAAC;YAC9B,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC/C,OAAO,kBAAkB,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,CAAC,qBAAqB,CAAC,eAAuB;QAClD,OAAO,eAAe,CAAC,UAAU,CAAC,0BAA0B,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,CAAC,sBAAsB,CAAC,OAAe;QAC3C,MAAM,aAAa,GAAG,kBAAkB,CAAC,yBAAyB,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,aAAa,CAAC,IAAI,KAAK,OAAO,IAAI,aAAa,CAAC,UAAU,KAAK,OAAO,EAAE,CAAC;YAC3E,MAAM,IAAI,KAAK,CACb,sCAAsC,aAAa,CAAC,IAAI,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,aAAa,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,iDAAiD,CACrL,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAErD,MAAM,KAAK,GAAG,IAAI,yBAAyB,CAAC,OAAO,CAAC,CAAC,KAAK,CACxD;YACE,sBAAsB,CAAC,aAAa;YACpC,sBAAsB,CAAC,SAAS;YAChC,sBAAsB,CAAC,SAAS;YAChC,sBAAsB,CAAC,uBAAuB;SAC/C,EACD;YACE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC;YAClC,8BAA8B;YAC9B,iCAAiC;YACjC,wCAAwC;SACzC,CACF,CAAC;QAEF,MAAM,CAAC,kBAAkB,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC,SAAS,CACvD,KAAK,EACL,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,YAAY,UAAU,CACD,CAAC;QAEtC,MAAM,cAAc,GAAG,qBAAqB,CAAC,OAAO,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;QAClF,MAAM,MAAM,GAAG,qBAAqB,CAAC,OAAO,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;QAC9E,MAAM,SAAS,GAAG,qBAAqB,CAAC,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;QAC9E,MAAM,EAAE,GAAG,qBAAqB,CAAC,OAAO,CAAC,eAAe,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAC9F,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,CAC5C,eAAe,EACf,8BAA8B,EAC9B,KAAK,CACN,CAAC;QACF,MAAM,SAAS,GAAG,qBAAqB,CAAC,OAAO,CAC7C,eAAe,EACf,iCAAiC,EACjC,KAAK,CACN,CAAC;QACF,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,CAC5C,eAAe,EACf,wCAAwC,EACxC,KAAK,CACN,CAAC;QACF,MAAM,SAAS,GAAG,qBAAqB,CAAC,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;QAE9E,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,qDAAqD,eAAe,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACvH,CAAC;QACJ,CAAC;QAED,OAAO;YACL,kBAAkB,EAAE,kBAAkB,CAAC,GAAG,CAAC,eAAe,CAAC;YAC3D,cAAc,EAAE,eAAe,CAAC,cAAc,CAAC,KAAK,CAAC;YACrD,EAAE,EAAE,eAAe,CAAC,EAAE,CAAC,KAAK,CAAC;YAC7B,QAAQ,EAAE,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC;YAC1C,YAAY,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC;YAC3C,SAAS,EAAE,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC;YAC3C,SAAS,EAAE,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC;YAC3C,SAAS,EAAE,eAAe,CAAC,SAAS,EAAE,KAAK,CAAC;YAC5C,QAAQ,EAAE,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC;SAC3C,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,yBAAyB,CAAC,cAA+B;QAC9D,MAAM,IAAI,GAAG,qBAAqB,CAAC,gCAAgC,CAAC,cAAc,CAAC,CAAC;QAEpF,MAAM,WAAW,GAAa,EAAE,CAAC;QAEjC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1D,IAAI,SAAS,GAAG,CAAC,CAAC;QAElB,KAAK,MAAM,KAAK,IAAI,yBAAyB,EAAE,CAAC;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,KAA0B,CAAC,CAAC;YAC/C,IAAI,KAAK,EAAE,CAAC;gBACV,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAmB,CAAC,CAAC,CAAC;gBACnD,IAAI,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC;oBAC/C,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;gBACtE,CAAC;YACH,CAAC;QACH,CAAC;QAED,wBAAwB;QACxB,yEAAyE;QACzE,OAAO,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC;YACnE,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACpE,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC3C,WAAW,CAAC,IAAI,CACd,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,0BAA0B,CAAC,MAAoB,CAAC,CAAC,CACpF,CAAC;QACF,IAAI,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC;YAC/C,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC5C,WAAW,CAAC,IAAI,CACd,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,0BAA0B,CAAC,MAAoB,CAAC,CAAC,CACpF,CAAC;QAEF,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC3C,OAAO,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAEO,MAAM,CAAC,0BAA0B,CAAC,KAAiB;QACzD,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;YACzD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IAEO,MAAM,CAAC,OAAO,CACpB,KAAuB,EACvB,SAAiB,EACjB,SAAS,GAAG,IAAI;QAEhB,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7F,IAAI,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,0BAA0B,SAAS,4BAA4B,CAAC,CAAC;QACnF,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,gCAAgC,CACrC,cAA+B;QAE/B,OAAO;YACL,kBAAkB,EAAE,cAAc,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAC5F,cAAc,EAAE,iBAAiB,CAAC,cAAc,CAAC,cAAc,CAAC;YAChE,EAAE,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC;YACxC,QAAQ,EAAE,yBAAyB,CAAC,cAAc,CAAC,QAAQ,CAAC;YAC5D,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,SAAS,CAAC;YACtD,YAAY,EAAE,iBAAiB,CAAC,cAAc,CAAC,YAAY,CAAC;YAC5D,SAAS,EAAE,yBAAyB,CAAC,cAAc,CAAC,SAAS,CAAC;YAC9D,QAAQ,EAAE,yBAAyB,CAAC,cAAc,CAAC,QAAQ,CAAC;YAC5D,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,SAAS,CAAC;SACvD,CAAC;IACJ,CAAC;CACF"}

package/dist/mjs/certificates/setup-crypto.d.ts

@@ -0,0 +1,3 @@
+import * as webcrypto from '@peculiar/webcrypto';
+declare const cryptoProvider: webcrypto.Crypto;
+export { cryptoProvider };

package/dist/mjs/certificates/setup-crypto.js

@@ -0,0 +1,22 @@
+import * as x509 from '@peculiar/x509';
+import * as webcrypto from '@peculiar/webcrypto';
+import * as pkijs from 'pkijs';
+const cryptoProvider = new webcrypto.Crypto();
+x509.cryptoProvider.set(cryptoProvider);
+pkijs.setEngine('Node', new pkijs.CryptoEngine({ name: 'Node', crypto: cryptoProvider }));
+pkijs.ECNamedCurves.register('K-256', '1.3.132.0.10', 32);
+const originGetAlgorithmByOIDFn = pkijs.CryptoEngine.prototype.getAlgorithmByOID;
+function getAlgorithmByOID(oid, safety, target) {
+    if (oid === '1.3.132.0.10') {
+        return {
+            name: 'K-256',
+        };
+    }
+    return originGetAlgorithmByOIDFn(oid, safety, target);
+}
+pkijs.CryptoEngine.prototype.getAlgorithmByOID = getAlgorithmByOID;
+x509.PemConverter.isPem = (data) => {
+    return typeof data === 'string' && data.startsWith('-----BEGIN');
+};
+export { cryptoProvider };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXAtY3J5cHRvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NlcnRpZmljYXRlcy9zZXR1cC1jcnlwdG8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLElBQUksTUFBTSxnQkFBZ0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssU0FBUyxNQUFNLHFCQUFxQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRS9CLE1BQU0sY0FBYyxHQUFHLElBQUksU0FBUyxDQUFDLE1BQU0sRUFBRSxDQUFDO0FBRTlDLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0FBRXhDLEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLElBQUksS0FBSyxDQUFDLFlBQVksQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLGNBQWMsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUUxRixLQUFLLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsY0FBYyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBRTFELE1BQU0seUJBQXlCLEdBQUcsS0FBSyxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsaUJBQWlCLENBQUM7QUFDakYsU0FBUyxpQkFBaUIsQ0FBQyxHQUFXLEVBQUUsTUFBZ0IsRUFBRSxNQUFlO0lBQ3ZFLElBQUksR0FBRyxLQUFLLGNBQWMsRUFBRSxDQUFDO1FBQzNCLE9BQU87WUFDTCxJQUFJLEVBQUUsT0FBTztTQUNkLENBQUM7SUFDSixDQUFDO0lBRUQsT0FBTyx5QkFBeUIsQ0FBQyxHQUFHLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ3hELENBQUM7QUFDRCxLQUFLLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxpQkFBaUIsR0FBRyxpQkFBaUIsQ0FBQztBQUVuRSxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssR0FBRyxDQUFDLElBQVksRUFBa0IsRUFBRTtJQUN6RCxPQUFPLE9BQU8sSUFBSSxLQUFLLFFBQVEsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDO0FBQ25FLENBQUMsQ0FBQztBQUVGLE9BQU8sRUFBRSxjQUFjLEVBQUUsQ0FBQyJ9

package/dist/mjs/certificates/types.d.ts

@@ -0,0 +1,122 @@
+/// <reference types="node" />
+import type { Certificate } from 'pkijs';
+export type ValidateCertChainResult = {
+    isValid: boolean;
+    errorMessage?: string;
+};
+export type SignatureAlgorithm = 'RSASSA-PKCS1-SHA256' | 'ECDSA-secp256k1-SHA256' | 'ECDSA-P-256-SHA256';
+export type AlgorithmObj = {
+    name: string;
+    namedCurve?: string;
+    hash?: {
+        name: string;
+    };
+};
+export type CustomExtension = {
+    oid: string;
+    value: Buffer;
+};
+export type CertificatePrincipal = {
+    country?: string;
+    stateName?: string;
+    localityName?: string;
+    organization?: string;
+    organizationalUnit?: string;
+    commonName: string;
+};
+export type PemOrCryptoKeys = {
+    /**
+     * spki format for PEM
+     */
+    publicKey: string | CryptoKey;
+    /**
+     * pkcs8 format for PEM
+     */
+    privateKey: string | CryptoKey;
+};
+export type GenerateCertParams = PemOrCryptoKeys & {
+    subject: CertificatePrincipal | string;
+    issuer: CertificatePrincipal | string;
+    notAfter: Date;
+    dnsNames?: string[];
+    ca?: boolean;
+    ocspSigning?: boolean;
+    ocspExtension?: {
+        ocspUrl: string;
+        issuerCertUrl?: string;
+    };
+    customExtensions?: CustomExtension[];
+};
+export type GenerateCsrParams = PemOrCryptoKeys & {
+    subject: CertificatePrincipal | string;
+    dnsNames?: string[];
+    customExtensions?: CustomExtension[];
+};
+export type ParsedCsr = {
+    publicKey: CryptoKey;
+    subject: string;
+    extensions: CustomExtension[];
+    dnsNames?: string[];
+};
+export type ParsedCert = {
+    serialNumberHex: string;
+    publicKey: CryptoKey;
+    subject: string;
+    issuer: string;
+    notBefore: Date;
+    notAfter: Date;
+    extensions: CustomExtension[];
+    dnsNames?: string[];
+    authorityKeyIdentifier?: string;
+    subjectKeyIdentifier?: string;
+};
+export type BufferedChunkedX509Cert = {
+    nonSerializedParts: Uint8Array[];
+    expirationDate: Uint8Array;
+    ca: Uint8Array;
+    userData?: Uint8Array;
+    serialNumber: Uint8Array;
+    signature: Uint8Array;
+    publicKey: Uint8Array;
+    mrEnclave?: Uint8Array;
+    mrSigner?: Uint8Array;
+};
+export type CertBinaryItem = {
+    name: string;
+    oid?: string;
+    value: Uint8Array;
+};
+export type OcspCertData = {
+    issuerNameHash: ArrayBuffer;
+    issuerKeyHash: ArrayBuffer;
+    serialNumber: ArrayBuffer;
+    extensionsToCheck: CustomExtension[];
+    hashAlgorithm: string;
+};
+export type ParsedOcspRequest = {
+    certRequests: OcspCertData[];
+    nonce?: ArrayBuffer;
+};
+export declare enum OcspCertStatus {
+    OK = 0,
+    Revoked = 1,
+    Unknown = 2
+}
+export type GenerateOcspResponseParams = {
+    issuerPem: string;
+    caCertsPem?: string;
+    certs: Array<Omit<OcspCertData, 'extensionsToCheck'> & {
+        status: OcspCertStatus;
+        revocationDate?: Date;
+    }>;
+    privateKey: string;
+    nonce?: ArrayBuffer;
+};
+export type KeyIdentifier = {
+    isEqual(other: KeyIdentifier): boolean;
+};
+export type CertWithKeyIdentifiers = {
+    cert: Certificate;
+    authorityKeyIdentifier?: KeyIdentifier;
+    subjectKeyIdentifier?: KeyIdentifier;
+};

package/dist/mjs/certificates/types.js

@@ -0,0 +1,7 @@
+export var OcspCertStatus;
+(function (OcspCertStatus) {
+    OcspCertStatus[OcspCertStatus["OK"] = 0] = "OK";
+    OcspCertStatus[OcspCertStatus["Revoked"] = 1] = "Revoked";
+    OcspCertStatus[OcspCertStatus["Unknown"] = 2] = "Unknown";
+})(OcspCertStatus || (OcspCertStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2VydGlmaWNhdGVzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQW9IQSxNQUFNLENBQU4sSUFBWSxjQUlYO0FBSkQsV0FBWSxjQUFjO0lBQ3hCLCtDQUFNLENBQUE7SUFDTix5REFBVyxDQUFBO0lBQ1gseURBQVcsQ0FBQTtBQUNiLENBQUMsRUFKVyxjQUFjLEtBQWQsY0FBYyxRQUl6QiJ9

package/dist/mjs/config.d.ts

@@ -0,0 +1,3 @@
+export declare const config: {
+    TLB_CACHE_SIZE: number;
+};

package/dist/mjs/config.js

@@ -0,0 +1,4 @@
+export const config = {
+    TLB_CACHE_SIZE: 100,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUc7SUFDcEIsY0FBYyxFQUFFLEdBQUc7Q0FDcEIsQ0FBQyJ9