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

package/dist/mjs/tee/QuoteParser.js

@@ -0,0 +1,381 @@
+import { Certificate } from '@fidm/x509';
+import * as asn1js from 'asn1js';
+import * as pkijs from 'pkijs';
+import { Buffer as Blob } from 'buffer';
+import { TeeQuoteParserError } from './errors.js';
+import { QuoteType, } from './types.js';
+import { splitChain, Signature } from './helpers.js';
+import * as crypto from 'crypto';
+export class TeeParser {
+    static reportDataHashSize = 32; /* 64 in report, but we need 32 only for sha256 hash */
+    extractRS(cert) {
+        const derSignature = Buffer.from(cert.signatureValue.valueBlock.valueHexView).toString('hex');
+        const parsedSignature = Signature.importFromDER(derSignature);
+        return {
+            r: parsedSignature.r,
+            s: parsedSignature.s,
+            derSignature,
+        };
+    }
+    parsePem(pem) {
+        const cert = Certificate.fromPEM(Buffer.from(pem));
+        const asn1Certificate = asn1js.fromBER(cert.raw);
+        const certificate = new pkijs.Certificate({ schema: asn1Certificate.result });
+        const tbs = certificate.tbsView;
+        const { r, s } = this.extractRS(certificate);
+        const publicKey = cert.publicKey.keyRaw.toString('hex').slice(2);
+        const splitedTbs = Buffer.from(tbs).toString('hex').split(publicKey);
+        const x509PublicKey = '0x' + publicKey;
+        const x509Signature = '0x' + r + s;
+        return {
+            bodyPartOne: '0x' + splitedTbs[0],
+            publicKey: x509PublicKey,
+            bodyPartTwo: '0x' + splitedTbs[1],
+            signature: x509Signature,
+        };
+    }
+    getDataAndAdvance(blob, size) {
+        const buf = Blob.from(blob.data.subarray(0, size));
+        blob.data = Blob.from(blob.data.subarray(size));
+        return buf;
+    }
+    static determineQuoteType(quote) {
+        let type = QuoteType.SGX;
+        if (quote.length < 48) {
+            throw new TeeQuoteParserError('data has invalid length');
+        }
+        const version = Buffer.from(quote).readUInt16LE(0);
+        if (version === 4) {
+            const quoteType = Buffer.from(quote).readUInt32LE(4);
+            if (quoteType === 0x00000081) {
+                type = QuoteType.TDX;
+            }
+            else if (quoteType !== 0x00000000) {
+                throw new TeeQuoteParserError(`Unknown quote type ${quoteType}`);
+            }
+        }
+        else if (version !== 3) {
+            throw new TeeQuoteParserError(`Unknown quote version ${version}`);
+        }
+        return { type, version };
+    }
+    static getMrEnclave(quote) {
+        const teeType = TeeParser.determineQuoteType(quote);
+        switch (teeType.type) {
+            case QuoteType.SGX: {
+                const sgxParser = new TeeSgxParser();
+                const parsedSgxQuote = sgxParser.parseQuote(quote);
+                const parsedReport = sgxParser.parseReport(parsedSgxQuote.report);
+                return parsedReport.mrEnclave;
+            }
+            case QuoteType.TDX: {
+                const tdxParser = new TeeTdxParser();
+                const parsedTdxQuote = tdxParser.parseQuote(quote);
+                const tdBody = tdxParser.parseBody(parsedTdxQuote.tdQuoteBody);
+                const hash = crypto.createHash('sha256');
+                hash.update(tdBody.tdAttributes);
+                hash.update(tdBody.mrTd);
+                hash.update(tdBody.rtmr0);
+                hash.update(tdBody.rtmr1);
+                hash.update(tdBody.rtmr2);
+                hash.update(tdBody.rtmr3);
+                return hash.digest();
+            }
+            default:
+                throw new TeeQuoteParserError(`Unknown quote type`);
+        }
+    }
+}
+export class TeeSgxParser extends TeeParser {
+    static quoteHeaderSize = 48;
+    static pceSvnOffset = 10;
+    static reportSize = 384;
+    static userDataOffset = 28;
+    static userDataSize = 20;
+    static cpuSvnSize = 16;
+    static reportMrEnclaveOffset = 64;
+    static reportMrEnclaveSize = 32;
+    static reportMrSignerOffset = TeeSgxParser.reportMrEnclaveOffset + TeeSgxParser.reportMrEnclaveSize + /* reserved */ 32;
+    static reportMrSignerSize = 32;
+    static reportIsvProdIdOffset = TeeSgxParser.reportMrSignerOffset + TeeSgxParser.reportMrSignerSize + /* reserved */ 96;
+    static reportIsvProdIdSize = 2;
+    static reportIsvSvnOffset = TeeSgxParser.reportIsvProdIdOffset + TeeSgxParser.reportIsvProdIdSize;
+    static reportIsvSvnSize = 2;
+    static reportDataOffset = TeeSgxParser.reportIsvSvnOffset + TeeSgxParser.reportIsvSvnSize + /* reserved */ 60;
+    static reportUserDataSize = 64;
+    static ecdsaP256SignatureSize = 64;
+    static ecdsaP256PublicKeySize = 64;
+    parseQuote(data) {
+        const { quoteHeaderSize, pceSvnOffset, reportSize, userDataOffset, userDataSize, ecdsaP256SignatureSize, ecdsaP256PublicKeySize, } = TeeSgxParser;
+        if (data.length < quoteHeaderSize + reportSize) {
+            throw new TeeQuoteParserError('data has invalid length');
+        }
+        const quoteRemainder = { data: Blob.from(data) };
+        const quoteHeader = this.getDataAndAdvance(quoteRemainder, quoteHeaderSize);
+        const report = this.getDataAndAdvance(quoteRemainder, reportSize);
+        const version = quoteHeader.readUInt16LE(0);
+        const attestationKeyType = quoteHeader.readUInt16LE(2);
+        if (attestationKeyType > 3) {
+            throw new TeeQuoteParserError('quote header has invalid or unsupported attestation key type');
+        }
+        const pceSvn = quoteHeader.readUInt16LE(pceSvnOffset);
+        const userData = quoteHeader.slice(userDataOffset, userDataOffset + userDataSize);
+        const quoteSignatureDateLen = quoteRemainder.data.readUInt32LE(0);
+        quoteRemainder.data = Blob.from(quoteRemainder.data.subarray(4));
+        if (quoteSignatureDateLen != quoteRemainder.data.length) {
+            throw new TeeQuoteParserError(`quoteSignatureDateLen has invalid length: ${quoteRemainder.data.length} instead of ${quoteSignatureDateLen} expected`);
+        }
+        const rawQuoteSignatureDataRemainder = {
+            data: this.getDataAndAdvance(quoteRemainder, quoteSignatureDateLen),
+        };
+        const isvEnclaveReportSignature = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, ecdsaP256SignatureSize);
+        const ecdsaAttestationKey = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, ecdsaP256PublicKeySize);
+        const qeReport = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, reportSize);
+        const qeReportSignature = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, ecdsaP256SignatureSize);
+        const qeAuthenticationDataSize = rawQuoteSignatureDataRemainder.data.readUInt16LE(0);
+        rawQuoteSignatureDataRemainder.data = Blob.from(rawQuoteSignatureDataRemainder.data.subarray(2));
+        if (rawQuoteSignatureDataRemainder.data.length < qeAuthenticationDataSize) {
+            throw new TeeQuoteParserError(`qeAuthenticationDataSize has invalid length: ${rawQuoteSignatureDataRemainder.data.length} instead of ${qeAuthenticationDataSize} expected`);
+        }
+        const qeAuthenticationData = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, qeAuthenticationDataSize);
+        const qeCertificationDataType = rawQuoteSignatureDataRemainder.data.readUInt16LE(0);
+        if (qeCertificationDataType < 1 || qeCertificationDataType > 7) {
+            throw new TeeQuoteParserError(`certificationDataType has invalid value: ${qeCertificationDataType}`);
+        }
+        const certificationDataSize = rawQuoteSignatureDataRemainder.data.readUInt32LE(2);
+        const qeCertificationData = rawQuoteSignatureDataRemainder.data.subarray(2 + 4);
+        if (certificationDataSize != qeCertificationData.length) {
+            throw new TeeQuoteParserError(`certificationDataSize has invalid length: $PqeCertificationData.length} instead of ${certificationDataSize} expected`);
+        }
+        const certsPems = splitChain(qeCertificationData.toString()) || []; // [device, platform, root]
+        const certsData = certsPems.map((pem) => this.parsePem(pem));
+        return {
+            quoteType: QuoteType.SGX,
+            rawHeader: quoteHeader,
+            header: {
+                version,
+                attestationKeyType,
+                pceSvn,
+                userData,
+            },
+            report,
+            isvEnclaveReportSignature,
+            ecdsaAttestationKey,
+            qeReport,
+            qeReportSignature,
+            qeAuthenticationData,
+            qeCertificationDataType,
+            qeCertificationData,
+            certificates: {
+                device: {
+                    pem: certsPems[0],
+                    x509Data: certsData[0],
+                },
+                platform: {
+                    pem: certsPems[1],
+                    x509Data: certsData[1],
+                },
+                root: {
+                    pem: certsPems[2],
+                    x509Data: certsData[2],
+                },
+            },
+        };
+    }
+    parseReport(data) {
+        const { reportSize, cpuSvnSize, reportMrEnclaveOffset, reportMrEnclaveSize, reportMrSignerOffset, reportMrSignerSize, reportIsvProdIdOffset, reportIsvProdIdSize, reportIsvSvnOffset, reportIsvSvnSize, reportDataOffset, reportUserDataSize, reportDataHashSize, } = TeeSgxParser;
+        if (data.length < reportSize) {
+            throw new TeeQuoteParserError('data has invalid length');
+        }
+        const report = Blob.from(data);
+        const cpuSvn = report.slice(0, cpuSvnSize).toString('hex');
+        const mrEnclave = report.slice(reportMrEnclaveOffset, reportMrEnclaveOffset + reportMrEnclaveSize);
+        const mrSigner = report.slice(reportMrSignerOffset, reportMrSignerOffset + reportMrSignerSize);
+        const isvProdId = report
+            .slice(reportIsvProdIdOffset, reportIsvProdIdOffset + reportIsvProdIdSize)
+            .readUInt16LE(0);
+        const isvSvn = report
+            .slice(reportIsvSvnOffset, reportIsvSvnOffset + reportIsvSvnSize)
+            .readUInt16LE(0);
+        const userData = report.slice(reportDataOffset, reportDataOffset + reportUserDataSize);
+        const dataHash = report.slice(reportDataOffset, reportDataOffset + reportDataHashSize);
+        return {
+            cpuSvn,
+            mrEnclave,
+            mrSigner,
+            isvProdId,
+            isvSvn,
+            userData,
+            dataHash,
+        };
+    }
+}
+export class TeeTdxParser extends TeeParser {
+    //High-level quote structure
+    static quoteHeaderSize = 48;
+    static tdQuoteBodySize = 584;
+    static quoteSignatureDataLen = 4;
+    // Header fields
+    static headerVersionSize = 2;
+    static headerAttestationKeyTypeSize = 2;
+    static headerTeeTypeSize = 4;
+    static headerReserved1Size = 2;
+    static headerReserved2Size = 2;
+    static headerQeVendorIdSize = 16;
+    static headerUserDataSize = 20;
+    // Body fiedls
+    static bodyTeeTcbSvnSize = 16;
+    static bodyMrSeamSize = 48;
+    static bodyMrSignerSeamSize = 48;
+    static bodySeamAttributesSize = 8;
+    static bodyTdAttributesSize = 8;
+    static bodyXfamSize = 8;
+    static bodyMrTdSize = 48;
+    static bodyMrConfigIdSize = 48;
+    static bodyMrOwnerSize = 48;
+    static bodyMrOwnerConfigSize = 48;
+    static bodyRtmr0Size = 48;
+    static bodyRtmr1Size = 48;
+    static bodyRtmr2Size = 48;
+    static bodyRtmr3Size = 48;
+    static bodyReportDataSize = 64;
+    // Signature fields
+    static sigQuoteSignatureSize = 64;
+    static sigAttestationKeySize = 64;
+    static sigCertDataTypeSize = 2;
+    static sigCertDataSzSize = 4;
+    static sigQeReportSize = 384;
+    static sigQeReportSignatureSize = 64;
+    static sigQeAuthenticationDataSzSize = 2;
+    static sigSignatureTypeSize = 2;
+    static sigSignatureSzSize = 4;
+    parseQuote(data) {
+        const { quoteHeaderSize, tdQuoteBodySize, quoteSignatureDataLen, sigQuoteSignatureSize, sigAttestationKeySize, sigCertDataTypeSize, sigCertDataSzSize, sigQeReportSize, sigQeReportSignatureSize, sigQeAuthenticationDataSzSize, sigSignatureTypeSize, sigSignatureSzSize, } = TeeTdxParser;
+        const expectedSize = quoteHeaderSize + tdQuoteBodySize + quoteSignatureDataLen;
+        if (data.length < expectedSize) {
+            throw new TeeQuoteParserError(`quote has invalid length ${data.length}, expected not less than ${expectedSize}`);
+        }
+        const quoteRemainder = { data: Blob.from(data) };
+        const rawHeader = this.getDataAndAdvance(quoteRemainder, quoteHeaderSize);
+        const tdQuoteBody = this.getDataAndAdvance(quoteRemainder, tdQuoteBodySize);
+        const signatureLen = this.getDataAndAdvance(quoteRemainder, quoteSignatureDataLen);
+        const certificationDataSize = signatureLen.readUInt32LE(0);
+        const expectedQuoteLen = quoteHeaderSize + tdQuoteBodySize + quoteSignatureDataLen + certificationDataSize;
+        if (data.length < expectedQuoteLen) {
+            throw new TeeQuoteParserError(`quote has invalid length ${data.length}, expected not less than ${expectedQuoteLen}`);
+        }
+        const signature = { data: this.getDataAndAdvance(quoteRemainder, certificationDataSize) };
+        const quoteSignature = this.getDataAndAdvance(signature, sigQuoteSignatureSize);
+        const ecdsaAttestationKey = this.getDataAndAdvance(signature, sigAttestationKeySize);
+        const certDataType = this.getDataAndAdvance(signature, sigCertDataTypeSize).readUint16LE(); //expected 6
+        if (certDataType !== 6)
+            throw new TeeQuoteParserError(`certDataType has invalid value ${certDataType}, expected 6`);
+        const certDataSize = this.getDataAndAdvance(signature, sigCertDataSzSize).readUint32LE();
+        if (signature.data.length < certDataSize)
+            throw new TeeQuoteParserError(`certData has invalid length ${data.length}, expected not less than ${certDataSize}`);
+        const qeReport = this.getDataAndAdvance(signature, sigQeReportSize);
+        const qeReportSignature = this.getDataAndAdvance(signature, sigQeReportSignatureSize);
+        const qeAuthenticationDataSize = this.getDataAndAdvance(signature, sigQeAuthenticationDataSzSize).readUint16LE();
+        if (signature.data.length < qeAuthenticationDataSize)
+            throw new TeeQuoteParserError(`qeAuthenticationData has invalid length ${data.length}, expected not less than ${qeAuthenticationDataSize}`);
+        const qeAuthenticationData = this.getDataAndAdvance(signature, qeAuthenticationDataSize);
+        const qeCertificationDataType = this.getDataAndAdvance(signature, sigSignatureTypeSize).readUint16LE(); //expected 5
+        if (qeCertificationDataType !== 5)
+            throw new TeeQuoteParserError(`signatureType has invalid value ${qeCertificationDataType}, expected 5`);
+        const signatureSize = this.getDataAndAdvance(signature, sigSignatureSzSize).readUint32LE();
+        if (signature.data.length < signatureSize)
+            throw new TeeQuoteParserError(`certChain has invalid length ${data.length}, expected not less than ${signatureSize}`);
+        const qeCertificationData = this.getDataAndAdvance(signature, signatureSize);
+        const certsPems = splitChain(qeCertificationData.toString()) || []; // [device, platform, root]
+        const certsData = certsPems.map((pem) => this.parsePem(pem));
+        return {
+            quoteType: QuoteType.TDX,
+            rawHeader,
+            header: this.parseHeader(rawHeader),
+            tdQuoteBody,
+            quoteSignature,
+            ecdsaAttestationKey,
+            certDataType,
+            qeReport,
+            qeReportSignature,
+            qeAuthenticationData,
+            qeCertificationDataType,
+            qeCertificationData,
+            certificates: {
+                device: {
+                    pem: certsPems[0],
+                    x509Data: certsData[0],
+                },
+                platform: {
+                    pem: certsPems[1],
+                    x509Data: certsData[1],
+                },
+                root: {
+                    pem: certsPems[2],
+                    x509Data: certsData[2],
+                },
+            },
+        };
+    }
+    parseHeader(data) {
+        const { headerVersionSize, headerAttestationKeyTypeSize, headerTeeTypeSize, headerReserved1Size, headerReserved2Size, headerQeVendorIdSize, headerUserDataSize, } = TeeTdxParser;
+        const headerRemainder = { data: Blob.from(data) };
+        const version = this.getDataAndAdvance(headerRemainder, headerVersionSize).readUInt16LE();
+        const attestationKeyType = this.getDataAndAdvance(headerRemainder, headerAttestationKeyTypeSize).readUInt16LE();
+        const teeType = this.getDataAndAdvance(headerRemainder, headerTeeTypeSize).readUInt32LE();
+        const reserved1 = this.getDataAndAdvance(headerRemainder, headerReserved1Size);
+        const reserved2 = this.getDataAndAdvance(headerRemainder, headerReserved2Size);
+        const qeVendorId = this.getDataAndAdvance(headerRemainder, headerQeVendorIdSize);
+        const userData = this.getDataAndAdvance(headerRemainder, headerUserDataSize);
+        return {
+            version,
+            attestationKeyType,
+            teeType,
+            reserved1,
+            reserved2,
+            qeVendorId,
+            userData,
+        };
+    }
+    parseBody(data) {
+        const { bodyTeeTcbSvnSize, bodyMrSeamSize, bodyMrSignerSeamSize, bodySeamAttributesSize, bodyTdAttributesSize, bodyXfamSize, bodyMrTdSize, bodyMrConfigIdSize, bodyMrOwnerSize, bodyMrOwnerConfigSize, bodyRtmr0Size, bodyRtmr1Size, bodyRtmr2Size, bodyRtmr3Size, bodyReportDataSize, reportDataHashSize, } = TeeTdxParser;
+        const bodyRemainder = { data: Blob.from(data) };
+        if (bodyRemainder.data.length !== TeeTdxParser.tdQuoteBodySize)
+            throw new TeeQuoteParserError(`body has invalid length ${bodyRemainder.data.length}, expected ${TeeTdxParser.tdQuoteBodySize}`);
+        const teeTcbSvn = this.getDataAndAdvance(bodyRemainder, bodyTeeTcbSvnSize);
+        const mrSeam = this.getDataAndAdvance(bodyRemainder, bodyMrSeamSize);
+        const mrSignerSeam = this.getDataAndAdvance(bodyRemainder, bodyMrSignerSeamSize);
+        const seamAttributes = this.getDataAndAdvance(bodyRemainder, bodySeamAttributesSize);
+        const tdAttributes = this.getDataAndAdvance(bodyRemainder, bodyTdAttributesSize);
+        const xfam = this.getDataAndAdvance(bodyRemainder, bodyXfamSize);
+        const mrTd = this.getDataAndAdvance(bodyRemainder, bodyMrTdSize);
+        const mrConfigId = this.getDataAndAdvance(bodyRemainder, bodyMrConfigIdSize);
+        const mrOwner = this.getDataAndAdvance(bodyRemainder, bodyMrOwnerSize);
+        const mrOwnerConfig = this.getDataAndAdvance(bodyRemainder, bodyMrOwnerConfigSize);
+        const rtmr0 = this.getDataAndAdvance(bodyRemainder, bodyRtmr0Size);
+        const rtmr1 = this.getDataAndAdvance(bodyRemainder, bodyRtmr1Size);
+        const rtmr2 = this.getDataAndAdvance(bodyRemainder, bodyRtmr2Size);
+        const rtmr3 = this.getDataAndAdvance(bodyRemainder, bodyRtmr3Size);
+        const reportData = this.getDataAndAdvance(bodyRemainder, bodyReportDataSize);
+        const dataHash = reportData.slice(0, reportDataHashSize);
+        return {
+            teeTcbSvn,
+            mrSeam,
+            mrSignerSeam,
+            seamAttributes,
+            tdAttributes,
+            xfam,
+            mrTd,
+            mrConfigId,
+            mrOwner,
+            mrOwnerConfig,
+            rtmr0,
+            rtmr1,
+            rtmr2,
+            rtmr3,
+            reportData,
+            dataHash,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QuoteParser.js","sourceRoot":"","sources":["../../../src/tee/QuoteParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,MAAM,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAQL,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,MAAM,OAAgB,SAAS;IAC7B,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC,CAAC,uDAAuD;IACtF,SAAS,CAAC,IAAuB;QACzC,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC9F,MAAM,eAAe,GAAG,SAAS,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QAE9D,OAAO;YACL,CAAC,EAAE,eAAe,CAAC,CAAC;YACpB,CAAC,EAAE,eAAe,CAAC,CAAC;YACpB,YAAY;SACb,CAAC;IACJ,CAAC;IAES,QAAQ,CAAC,GAAW;QAC5B,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACnD,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC;QAE9E,MAAM,GAAG,GAAG,WAAW,CAAC,OAAO,CAAC;QAEhC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAE7C,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACjE,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACrE,MAAM,aAAa,GAAG,IAAI,GAAG,SAAS,CAAC;QACvC,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QAEnC,OAAO;YACL,WAAW,EAAE,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC;YACjC,SAAS,EAAE,aAAa;YACxB,WAAW,EAAE,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC;YACjC,SAAS,EAAE,aAAa;SACzB,CAAC;IACJ,CAAC;IAES,iBAAiB,CAAC,IAAoB,EAAE,IAAY;QAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAEhD,OAAO,GAAG,CAAC;IACb,CAAC;IAEM,MAAM,CAAC,kBAAkB,CAAC,KAAiB;QAChD,IAAI,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC;QAEzB,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;YACtB,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;QAC3D,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAEnD,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;YAClB,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACrD,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;gBAC7B,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC;YACvB,CAAC;iBAAM,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;gBACpC,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;aAAM,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,OAAO,EAAE,CAAC,CAAC;QACpE,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,YAAY,CAAC,KAAiB;QAC1C,MAAM,OAAO,GAAG,SAAS,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACpD,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;YACrB,KAAK,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;gBACnB,MAAM,SAAS,GAAG,IAAI,YAAY,EAAE,CAAC;gBACrC,MAAM,cAAc,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;gBACnD,MAAM,YAAY,GAAG,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBAElE,OAAO,YAAY,CAAC,SAAS,CAAC;YAChC,CAAC;YACD,KAAK,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;gBACnB,MAAM,SAAS,GAAG,IAAI,YAAY,EAAE,CAAC;gBACrC,MAAM,cAAc,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;gBAC/D,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;gBACzC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACzB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAE1B,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;YACvB,CAAC;YACD;gBACE,MAAM,IAAI,mBAAmB,CAAC,oBAAoB,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;;AAGH,MAAM,OAAO,YAAa,SAAQ,SAAS;IACzC,MAAM,CAAU,eAAe,GAAG,EAAE,CAAC;IACrC,MAAM,CAAU,YAAY,GAAG,EAAE,CAAC;IAClC,MAAM,CAAU,UAAU,GAAG,GAAG,CAAC;IACjC,MAAM,CAAU,cAAc,GAAG,EAAE,CAAC;IACpC,MAAM,CAAU,YAAY,GAAG,EAAE,CAAC;IAClC,MAAM,CAAU,UAAU,GAAG,EAAE,CAAC;IAChC,MAAM,CAAU,qBAAqB,GAAG,EAAE,CAAC;IAC3C,MAAM,CAAU,mBAAmB,GAAG,EAAE,CAAC;IACzC,MAAM,CAAU,oBAAoB,GAClC,YAAY,CAAC,qBAAqB,GAAG,YAAY,CAAC,mBAAmB,GAAG,cAAc,CAAC,EAAE,CAAC;IAC5F,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC;IACxC,MAAM,CAAU,qBAAqB,GACnC,YAAY,CAAC,oBAAoB,GAAG,YAAY,CAAC,kBAAkB,GAAG,cAAc,CAAC,EAAE,CAAC;IAC1F,MAAM,CAAU,mBAAmB,GAAG,CAAC,CAAC;IACxC,MAAM,CAAU,kBAAkB,GAChC,YAAY,CAAC,qBAAqB,GAAG,YAAY,CAAC,mBAAmB,CAAC;IACxE,MAAM,CAAU,gBAAgB,GAAG,CAAC,CAAC;IACrC,MAAM,CAAU,gBAAgB,GAC9B,YAAY,CAAC,kBAAkB,GAAG,YAAY,CAAC,gBAAgB,GAAG,cAAc,CAAC,EAAE,CAAC;IACtF,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC;IACxC,MAAM,CAAU,sBAAsB,GAAG,EAAE,CAAC;IAC5C,MAAM,CAAU,sBAAsB,GAAG,EAAE,CAAC;IAE5C,UAAU,CAAC,IAAgB;QACzB,MAAM,EACJ,eAAe,EACf,YAAY,EACZ,UAAU,EACV,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,GACvB,GAAG,YAAY,CAAC;QAEjB,IAAI,IAAI,CAAC,MAAM,GAAG,eAAe,GAAG,UAAU,EAAE,CAAC;YAC/C,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,cAAc,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;QAElE,MAAM,OAAO,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAE5C,MAAM,kBAAkB,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAEvD,IAAI,kBAAkB,GAAG,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,mBAAmB,CAAC,8DAA8D,CAAC,CAAC;QAChG,CAAC;QAED,MAAM,MAAM,GAAG,WAAW,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;QAEtD,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,cAAc,EAAE,cAAc,GAAG,YAAY,CAAC,CAAC;QAElF,MAAM,qBAAqB,GAAG,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAClE,cAAc,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAEjE,IAAI,qBAAqB,IAAI,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACxD,MAAM,IAAI,mBAAmB,CAC3B,6CAA6C,cAAc,CAAC,IAAI,CAAC,MAAM,eAAe,qBAAqB,WAAW,CACvH,CAAC;QACJ,CAAC;QAED,MAAM,8BAA8B,GAAG;YACrC,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,qBAAqB,CAAC;SACpE,CAAC;QACF,MAAM,yBAAyB,GAAG,IAAI,CAAC,iBAAiB,CACtD,8BAA8B,EAC9B,sBAAsB,CACvB,CAAC;QACF,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAChD,8BAA8B,EAC9B,sBAAsB,CACvB,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,8BAA8B,EAAE,UAAU,CAAC,CAAC;QACpF,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAC9C,8BAA8B,EAC9B,sBAAsB,CACvB,CAAC;QACF,MAAM,wBAAwB,GAAG,8BAA8B,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACrF,8BAA8B,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAC7C,8BAA8B,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAChD,CAAC;QAEF,IAAI,8BAA8B,CAAC,IAAI,CAAC,MAAM,GAAG,wBAAwB,EAAE,CAAC;YAC1E,MAAM,IAAI,mBAAmB,CAC3B,gDAAgD,8BAA8B,CAAC,IAAI,CAAC,MAAM,eAAe,wBAAwB,WAAW,CAC7I,CAAC;QACJ,CAAC;QAED,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,CACjD,8BAA8B,EAC9B,wBAAwB,CACzB,CAAC;QAEF,MAAM,uBAAuB,GAAG,8BAA8B,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAEpF,IAAI,uBAAuB,GAAG,CAAC,IAAI,uBAAuB,GAAG,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,mBAAmB,CAC3B,4CAA4C,uBAAuB,EAAE,CACtE,CAAC;QACJ,CAAC;QAED,MAAM,qBAAqB,GAAG,8BAA8B,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAClF,MAAM,mBAAmB,GAAG,8BAA8B,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAEhF,IAAI,qBAAqB,IAAI,mBAAmB,CAAC,MAAM,EAAE,CAAC;YACxD,MAAM,IAAI,mBAAmB,CAC3B,sFAAsF,qBAAqB,WAAW,CACvH,CAAC;QACJ,CAAC;QAED,MAAM,SAAS,GAAG,UAAU,CAAC,mBAAmB,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,2BAA2B;QAC/F,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;QAE7D,OAAO;YACL,SAAS,EAAE,SAAS,CAAC,GAAG;YACxB,SAAS,EAAE,WAAW;YACtB,MAAM,EAAE;gBACN,OAAO;gBACP,kBAAkB;gBAClB,MAAM;gBACN,QAAQ;aACT;YACD,MAAM;YACN,yBAAyB;YACzB,mBAAmB;YACnB,QAAQ;YACR,iBAAiB;YACjB,oBAAoB;YACpB,uBAAuB;YACvB,mBAAmB;YACnB,YAAY,EAAE;gBACZ,MAAM,EAAE;oBACN,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;oBACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;iBACvB;gBACD,QAAQ,EAAE;oBACR,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;oBACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;iBACvB;gBACD,IAAI,EAAE;oBACJ,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;oBACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;iBACvB;aACF;SACF,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,IAAgB;QAC1B,MAAM,EACJ,UAAU,EACV,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GACnB,GAAG,YAAY,CAAC;QAEjB,IAAI,IAAI,CAAC,MAAM,GAAG,UAAU,EAAE,CAAC;YAC7B,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;QAC3D,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAC5B,qBAAqB,EACrB,qBAAqB,GAAG,mBAAmB,CAC5C,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,kBAAkB,CAAC,CAAC;QAC/F,MAAM,SAAS,GAAG,MAAM;aACrB,KAAK,CAAC,qBAAqB,EAAE,qBAAqB,GAAG,mBAAmB,CAAC;aACzE,YAAY,CAAC,CAAC,CAAC,CAAC;QACnB,MAAM,MAAM,GAAG,MAAM;aAClB,KAAK,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,gBAAgB,CAAC;aAChE,YAAY,CAAC,CAAC,CAAC,CAAC;QACnB,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,kBAAkB,CAAC,CAAC;QACvF,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,kBAAkB,CAAC,CAAC;QAEvF,OAAO;YACL,MAAM;YACN,SAAS;YACT,QAAQ;YACR,SAAS;YACT,MAAM;YACN,QAAQ;YACR,QAAQ;SACT,CAAC;IACJ,CAAC;;AAGH,MAAM,OAAO,YAAa,SAAQ,SAAS;IACzC,4BAA4B;IAC5B,MAAM,CAAU,eAAe,GAAG,EAAE,CAAC;IACrC,MAAM,CAAU,eAAe,GAAG,GAAG,CAAC;IACtC,MAAM,CAAU,qBAAqB,GAAG,CAAC,CAAC;IAE1C,gBAAgB;IAChB,MAAM,CAAU,iBAAiB,GAAG,CAAC,CAAC;IACtC,MAAM,CAAU,4BAA4B,GAAG,CAAC,CAAC;IACjD,MAAM,CAAU,iBAAiB,GAAG,CAAC,CAAC;IACtC,MAAM,CAAU,mBAAmB,GAAG,CAAC,CAAC;IACxC,MAAM,CAAU,mBAAmB,GAAG,CAAC,CAAC;IACxC,MAAM,CAAU,oBAAoB,GAAG,EAAE,CAAC;IAC1C,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC;IAExC,cAAc;IACd,MAAM,CAAU,iBAAiB,GAAG,EAAE,CAAC;IACvC,MAAM,CAAU,cAAc,GAAG,EAAE,CAAC;IACpC,MAAM,CAAU,oBAAoB,GAAG,EAAE,CAAC;IAC1C,MAAM,CAAU,sBAAsB,GAAG,CAAC,CAAC;IAC3C,MAAM,CAAU,oBAAoB,GAAG,CAAC,CAAC;IACzC,MAAM,CAAU,YAAY,GAAG,CAAC,CAAC;IACjC,MAAM,CAAU,YAAY,GAAG,EAAE,CAAC;IAClC,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC;IACxC,MAAM,CAAU,eAAe,GAAG,EAAE,CAAC;IACrC,MAAM,CAAU,qBAAqB,GAAG,EAAE,CAAC;IAC3C,MAAM,CAAU,aAAa,GAAG,EAAE,CAAC;IACnC,MAAM,CAAU,aAAa,GAAG,EAAE,CAAC;IACnC,MAAM,CAAU,aAAa,GAAG,EAAE,CAAC;IACnC,MAAM,CAAU,aAAa,GAAG,EAAE,CAAC;IACnC,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC;IAExC,mBAAmB;IACnB,MAAM,CAAU,qBAAqB,GAAG,EAAE,CAAC;IAC3C,MAAM,CAAU,qBAAqB,GAAG,EAAE,CAAC;IAC3C,MAAM,CAAU,mBAAmB,GAAG,CAAC,CAAC;IACxC,MAAM,CAAU,iBAAiB,GAAG,CAAC,CAAC;IACtC,MAAM,CAAU,eAAe,GAAG,GAAG,CAAC;IACtC,MAAM,CAAU,wBAAwB,GAAG,EAAE,CAAC;IAC9C,MAAM,CAAU,6BAA6B,GAAG,CAAC,CAAC;IAClD,MAAM,CAAU,oBAAoB,GAAG,CAAC,CAAC;IACzC,MAAM,CAAU,kBAAkB,GAAG,CAAC,CAAC;IAEvC,UAAU,CAAC,IAAgB;QACzB,MAAM,EACJ,eAAe,EACf,eAAe,EACf,qBAAqB,EAErB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,wBAAwB,EACxB,6BAA6B,EAC7B,oBAAoB,EACpB,kBAAkB,GACnB,GAAG,YAAY,CAAC;QAEjB,MAAM,YAAY,GAAG,eAAe,GAAG,eAAe,GAAG,qBAAqB,CAAC;QAC/E,IAAI,IAAI,CAAC,MAAM,GAAG,YAAY,EAAE,CAAC;YAC/B,MAAM,IAAI,mBAAmB,CAC3B,4BAA4B,IAAI,CAAC,MAAM,4BAA4B,YAAY,EAAE,CAClF,CAAC;QACJ,CAAC;QAED,MAAM,cAAc,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACjD,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QAC1E,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QAC5E,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAC;QACnF,MAAM,qBAAqB,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAE3D,MAAM,gBAAgB,GACpB,eAAe,GAAG,eAAe,GAAG,qBAAqB,GAAG,qBAAqB,CAAC;QACpF,IAAI,IAAI,CAAC,MAAM,GAAG,gBAAgB,EAAE,CAAC;YACnC,MAAM,IAAI,mBAAmB,CAC3B,4BAA4B,IAAI,CAAC,MAAM,4BAA4B,gBAAgB,EAAE,CACtF,CAAC;QACJ,CAAC;QAED,MAAM,SAAS,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,qBAAqB,CAAC,EAAE,CAAC;QAE1F,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,qBAAqB,CAAC,CAAC;QAChF,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,qBAAqB,CAAC,CAAC;QAErF,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,YAAY;QACxG,IAAI,YAAY,KAAK,CAAC;YACpB,MAAM,IAAI,mBAAmB,CAAC,kCAAkC,YAAY,cAAc,CAAC,CAAC;QAE9F,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC,YAAY,EAAE,CAAC;QAEzF,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,GAAG,YAAY;YACtC,MAAM,IAAI,mBAAmB,CAC3B,+BAA+B,IAAI,CAAC,MAAM,4BAA4B,YAAY,EAAE,CACrF,CAAC;QAEJ,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;QACpE,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,wBAAwB,CAAC,CAAC;QAEtF,MAAM,wBAAwB,GAAG,IAAI,CAAC,iBAAiB,CACrD,SAAS,EACT,6BAA6B,CAC9B,CAAC,YAAY,EAAE,CAAC;QAEjB,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,GAAG,wBAAwB;YAClD,MAAM,IAAI,mBAAmB,CAC3B,2CAA2C,IAAI,CAAC,MAAM,4BAA4B,wBAAwB,EAAE,CAC7G,CAAC;QAEJ,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,wBAAwB,CAAC,CAAC;QAEzF,MAAM,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,CACpD,SAAS,EACT,oBAAoB,CACrB,CAAC,YAAY,EAAE,CAAC,CAAC,YAAY;QAC9B,IAAI,uBAAuB,KAAK,CAAC;YAC/B,MAAM,IAAI,mBAAmB,CAC3B,mCAAmC,uBAAuB,cAAc,CACzE,CAAC;QAEJ,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC,YAAY,EAAE,CAAC;QAE3F,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,GAAG,aAAa;YACvC,MAAM,IAAI,mBAAmB,CAC3B,gCAAgC,IAAI,CAAC,MAAM,4BAA4B,aAAa,EAAE,CACvF,CAAC;QAEJ,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAE7E,MAAM,SAAS,GAAG,UAAU,CAAC,mBAAmB,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,2BAA2B;QAC/F,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;QAE7D,OAAO;YACL,SAAS,EAAE,SAAS,CAAC,GAAG;YACxB,SAAS;YACT,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACnC,WAAW;YACX,cAAc;YACd,mBAAmB;YACnB,YAAY;YACZ,QAAQ;YACR,iBAAiB;YACjB,oBAAoB;YACpB,uBAAuB;YACvB,mBAAmB;YACnB,YAAY,EAAE;gBACZ,MAAM,EAAE;oBACN,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;oBACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;iBACvB;gBACD,QAAQ,EAAE;oBACR,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;oBACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;iBACvB;gBACD,IAAI,EAAE;oBACJ,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;oBACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;iBACvB;aACF;SACF,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,IAAgB;QAC1B,MAAM,EACJ,iBAAiB,EACjB,4BAA4B,EAC5B,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,GACnB,GAAG,YAAY,CAAC;QAEjB,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAElD,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC,YAAY,EAAE,CAAC;QAC1F,MAAM,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,CAC/C,eAAe,EACf,4BAA4B,CAC7B,CAAC,YAAY,EAAE,CAAC;QACjB,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC,YAAY,EAAE,CAAC;QAC1F,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;QAC/E,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;QAC/E,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,oBAAoB,CAAC,CAAC;QACjF,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;QAE7E,OAAO;YACL,OAAO;YACP,kBAAkB;YAClB,OAAO;YACP,SAAS;YACT,SAAS;YACT,UAAU;YACV,QAAQ;SACT,CAAC;IACJ,CAAC;IAED,SAAS,CAAC,IAAgB;QACxB,MAAM,EACJ,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,kBAAkB,GACnB,GAAG,YAAY,CAAC;QAEjB,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAEhD,IAAI,aAAa,CAAC,IAAI,CAAC,MAAM,KAAK,YAAY,CAAC,eAAe;YAC5D,MAAM,IAAI,mBAAmB,CAC3B,2BAA2B,aAAa,CAAC,IAAI,CAAC,MAAM,cAAc,YAAY,CAAC,eAAe,EAAE,CACjG,CAAC;QAEJ,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;QACrE,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;QACjF,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,sBAAsB,CAAC,CAAC;QACrF,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;QACjF,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QACjE,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QACjE,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;QAC7E,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;QACvE,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,qBAAqB,CAAC,CAAC;QACnF,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;QAC7E,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;QACzD,OAAO;YACL,SAAS;YACT,MAAM;YACN,YAAY;YACZ,cAAc;YACd,YAAY;YACZ,IAAI;YACJ,IAAI;YACJ,UAAU;YACV,OAAO;YACP,aAAa;YACb,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;YACL,UAAU;YACV,QAAQ;SACT,CAAC;IACJ,CAAC"}

package/dist/mjs/tee/TeeCertificateService.d.ts

@@ -0,0 +1,20 @@
+export declare enum ValidateTeeCertChainErrorCode {
+    CERT_CHAIN_IS_INVALID = "CERT_CHAIN_IS_INVALID",
+    NOT_ALLOWED_CHALLENGE = "NOT_ALLOWED_CHALLENGE",
+    CHALLENGE_IS_INVALID = "CHALLENGE_IS_INVALID"
+}
+export interface ValidateTeeCertChainResult {
+    isValid: boolean;
+    errorCode?: string;
+    errorMessage?: string;
+}
+export declare class TeeCertificateService {
+    static validateTeeCertChainOrFail(certsPem: string): Promise<void>;
+    static validateTeeCertChain(certsPem: string): Promise<ValidateTeeCertChainResult>;
+    private static validateChallenge;
+    private static validateGpuChallenge;
+    private static validateChallengeSgx;
+    private static validateChallengeId;
+    private static getGpuInfoFromCert;
+    private static validateCertificateWithSubtype;
+}

package/dist/mjs/tee/TeeCertificateService.js

@@ -0,0 +1,139 @@
+import { SUPERPROTOCOL_CA } from '../constants.js';
+import { ChallengeType, OID_CUSTOM_EXTENSION_CHALLENGE_CERTIFICATE_ID, OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID, OID_CUSTOM_EXTENSION_CHALLENGE_ID, OID_CUSTOM_EXTENSION_CHALLENGE_SUBTYPE, OID_CUSTOM_EXTENSION_CHALLENGE_TYPE, OID_CUSTOM_EXTENSION_NVIDIA_INFO_GPU, } from '@super-protocol/pki-common';
+import { TeeSignatureVerifier } from './TeeSignatureVerifier.js';
+import { InvalidSignatureError, NotAllowedChallengeError } from './errors.js';
+import { CertificatesHelper } from '../certificates/index.js';
+import { NvtrustGPUList } from '../proto/Nvtrust.js';
+export var ValidateTeeCertChainErrorCode;
+(function (ValidateTeeCertChainErrorCode) {
+    ValidateTeeCertChainErrorCode["CERT_CHAIN_IS_INVALID"] = "CERT_CHAIN_IS_INVALID";
+    ValidateTeeCertChainErrorCode["NOT_ALLOWED_CHALLENGE"] = "NOT_ALLOWED_CHALLENGE";
+    ValidateTeeCertChainErrorCode["CHALLENGE_IS_INVALID"] = "CHALLENGE_IS_INVALID";
+})(ValidateTeeCertChainErrorCode || (ValidateTeeCertChainErrorCode = {}));
+export class TeeCertificateService {
+    static async validateTeeCertChainOrFail(certsPem) {
+        const result = await TeeCertificateService.validateTeeCertChain(certsPem);
+        if (!result.isValid) {
+            throw new Error(result.errorMessage);
+        }
+    }
+    static async validateTeeCertChain(certsPem) {
+        const { isValid, errorMessage } = await CertificatesHelper.validateCertChain(certsPem, SUPERPROTOCOL_CA);
+        if (!isValid) {
+            return {
+                isValid: false,
+                errorCode: ValidateTeeCertChainErrorCode.CERT_CHAIN_IS_INVALID,
+                errorMessage: `Cert chain is invalid! (${errorMessage})`,
+            };
+        }
+        // ROOT CA doesn't have challenge. but we trust it as it is in SUPERPROTOCOL_CA constant
+        const { certs } = CertificatesHelper.extractCAFromChain(certsPem);
+        const sortedCerts = CertificatesHelper.sortCertsFromLeafToRoot(certs).map((certWithKeyIdent) => certWithKeyIdent.cert);
+        try {
+            await Promise.all(sortedCerts.map((cert) => TeeCertificateService.validateChallenge(cert)));
+            const leafCert = sortedCerts[0];
+            await TeeCertificateService.validateGpuChallenge(leafCert);
+        }
+        catch (err) {
+            return {
+                isValid: false,
+                errorCode: err instanceof NotAllowedChallengeError
+                    ? ValidateTeeCertChainErrorCode.NOT_ALLOWED_CHALLENGE
+                    : ValidateTeeCertChainErrorCode.CHALLENGE_IS_INVALID,
+                errorMessage: `Challenge is not valid! (${err.message})`,
+            };
+        }
+        return { isValid: true };
+    }
+    static async validateChallenge(cert) {
+        const challengeType = CertificatesHelper.getExtensionValue(cert, OID_CUSTOM_EXTENSION_CHALLENGE_TYPE)?.toString('binary');
+        if (challengeType === ChallengeType.Untrusted) {
+            throw new NotAllowedChallengeError(`Cert chain has cert with Untrusted challenge`);
+        }
+        switch (challengeType) {
+            case ChallengeType.SGXDCAP:
+                TeeCertificateService.validateChallengeSgx(cert);
+                break;
+            case ChallengeType.TDX:
+            case ChallengeType.SEVSNP:
+                await TeeCertificateService.validateChallengeId(cert, challengeType);
+                break;
+            case ChallengeType.Certificate:
+            case ChallengeType.Token:
+                await TeeCertificateService.validateCertificateWithSubtype(cert, challengeType);
+                break;
+            default:
+                throw new NotAllowedChallengeError(`Challenge type ${challengeType || `[none]`} is missing or not allowed!`);
+        }
+    }
+    static validateGpuChallenge(cert) {
+        const gpusInfo = TeeCertificateService.getGpuInfoFromCert(cert);
+        const gpusInDebugMode = gpusInfo.filter((gpu) => gpu.dbgStat);
+        if (gpusInDebugMode.length) {
+            throw new Error(`The certificate contains information about GPU that is running in debug mode: ${JSON.stringify(gpusInDebugMode)}`);
+        }
+    }
+    static validateChallengeSgx(cert) {
+        const mrSignerBinaryString = CertificatesHelper.getExtensionValue(cert, OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID);
+        if (!mrSignerBinaryString) {
+            throw new Error(`SGX challenge signature is wrong!`);
+        }
+        try {
+            TeeSignatureVerifier.validateSignatureSgx(mrSignerBinaryString);
+        }
+        catch (err) {
+            throw new Error(`SGX challenge signature is wrong!`);
+        }
+    }
+    static async validateChallengeId(cert, challengeType) {
+        const oid = challengeType === ChallengeType.Certificate
+            ? OID_CUSTOM_EXTENSION_CHALLENGE_CERTIFICATE_ID
+            : OID_CUSTOM_EXTENSION_CHALLENGE_ID;
+        const mrEnclaveBinaryString = CertificatesHelper.getExtensionValue(cert, oid);
+        if (!mrEnclaveBinaryString) {
+            throw new Error(`Challenge id is missing in certificate!`);
+        }
+        try {
+            await TeeSignatureVerifier.validateSignature(mrEnclaveBinaryString, challengeType);
+        }
+        catch (err) {
+            const message = `${challengeType} signature is invalid!`;
+            if (err instanceof InvalidSignatureError) {
+                throw new Error(`${message} ${err.message}`);
+            }
+            throw new Error(message);
+        }
+    }
+    static getGpuInfoFromCert(cert) {
+        let gpusInfo = { gpus: [] };
+        const gpusInfoRaw = CertificatesHelper.getExtensionValue(cert, OID_CUSTOM_EXTENSION_NVIDIA_INFO_GPU);
+        if (gpusInfoRaw) {
+            try {
+                gpusInfo = NvtrustGPUList.decode(gpusInfoRaw);
+            }
+            catch (err) {
+                const message = 'Failed to decode GPU info';
+                if (err instanceof Error) {
+                    throw new Error(`${message} ${err.message}`);
+                }
+                throw new Error(message);
+            }
+        }
+        return gpusInfo.gpus;
+    }
+    static async validateCertificateWithSubtype(cert, challengeType) {
+        if (challengeType === ChallengeType.Certificate) {
+            await TeeCertificateService.validateChallengeId(cert, ChallengeType.Certificate);
+        }
+        const subType = CertificatesHelper.getExtensionValue(cert, OID_CUSTOM_EXTENSION_CHALLENGE_SUBTYPE)?.toString('binary');
+        switch (subType) {
+            case ChallengeType.TDX:
+            case ChallengeType.SEVSNP:
+                await TeeCertificateService.validateChallengeId(cert, subType);
+                break;
+            default:
+                throw new Error(`Unsupported subtype: ${subType}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/tee/TeeSignatureVerifier.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { BinaryType, GetSignatureOptions } from './types.js';
+import { ChallengeType } from '@super-protocol/pki-common';
+export type GetMrEnclaveSignatureFn = (mrEnclave: Buffer, challengeType: ChallengeType) => Promise<Buffer>;
+export type CheckSignatureOptions = {
+    getMrEnclaveSignature: GetMrEnclaveSignatureFn;
+};
+export declare const SignatureFolderMap: Partial<Record<ChallengeType, string>>;
+export declare class TeeSignatureVerifier {
+    /**
+     * Validates tee signature for SGX
+     * @param mrSigner - Buffer
+     * @throws Error If signature validation fails
+     */
+    static validateSignatureSgx(mrSigner: BinaryType): void;
+    /**
+     * Validates TDX and SEV-SNP TEE signature by verifying the MRENCLAVE
+     * @param mrEnclave - Binary measurement of the TEE environment to verify
+     * @param options - Configuration for signature validation, including getMrEnclaveSignature callback
+     * @throws Error If signature validation fails or signature cannot be retrieved
+     */
+    static validateSignature(mrEnclave: BinaryType, challengeType: ChallengeType, options?: CheckSignatureOptions): Promise<void>;
+    static getSignature(mrEnclave: Buffer, challengeType: ChallengeType, options?: GetSignatureOptions): Promise<Buffer>;
+}