@super-protocol/pki-attestation-engine 0.0.0-nvidia-local-verifier

package/dist/challengeProvider/challengeProviderToken.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeProviderToken = void 0;
+const pki_common_1 = require("@super-protocol/pki-common");
+class ChallengeProviderToken {
+    token;
+    logger;
+    constructor(token, logger) {
+        this.token = token;
+        this.logger = logger;
+    }
+    async generateChallenge(userData, networkID) {
+        return {
+            type: pki_common_1.ChallengeType.Token,
+            userDataBase64: userData.toString('base64'),
+            token: this.token,
+            networkID,
+        };
+    }
+}
+exports.ChallengeProviderToken = ChallengeProviderToken;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlUHJvdmlkZXJUb2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGFsbGVuZ2VQcm92aWRlci9jaGFsbGVuZ2VQcm92aWRlclRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLDJEQUEyRTtBQUUzRSxNQUFhLHNCQUFzQjtJQUVWO0lBQ0Q7SUFGcEIsWUFDcUIsS0FBYSxFQUNkLE1BQVk7UUFEWCxVQUFLLEdBQUwsS0FBSyxDQUFRO1FBQ2QsV0FBTSxHQUFOLE1BQU0sQ0FBTTtJQUM3QixDQUFDO0lBQ0osS0FBSyxDQUFDLGlCQUFpQixDQUNuQixRQUFnQixFQUNoQixTQUFrQjtRQUVsQixPQUFPO1lBQ0gsSUFBSSxFQUFFLDBCQUFhLENBQUMsS0FBSztZQUN6QixjQUFjLEVBQUUsUUFBUSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUM7WUFDM0MsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLO1lBQ2pCLFNBQVM7U0FDWixDQUFDO0lBQ04sQ0FBQztDQUNKO0FBaEJELHdEQWdCQyJ9

package/dist/challengeProvider/challengeProviderUntrusted.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { ChallengeProvider } from './challengeProvider';
+import { Challenge, Log } from '@super-protocol/pki-common';
+export declare class ChallengeProviderUntrusted implements ChallengeProvider {
+    private readonly deviceId;
+    readonly logger?: Log | undefined;
+    constructor(deviceId: Buffer, logger?: Log | undefined);
+    generateChallenge(userData: Buffer, networkID?: string): Promise<Challenge>;
+}

package/dist/challengeProvider/challengeProviderUntrusted.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeProviderUntrusted = void 0;
+const pki_common_1 = require("@super-protocol/pki-common");
+class ChallengeProviderUntrusted {
+    deviceId;
+    logger;
+    constructor(deviceId, logger) {
+        this.deviceId = deviceId;
+        this.logger = logger;
+    }
+    async generateChallenge(userData, networkID) {
+        return {
+            type: pki_common_1.ChallengeType.Untrusted,
+            userDataBase64: userData.toString('base64'),
+            idBase64: this.deviceId.toString('base64'),
+            networkID,
+        };
+    }
+}
+exports.ChallengeProviderUntrusted = ChallengeProviderUntrusted;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlUHJvdmlkZXJVbnRydXN0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhbGxlbmdlUHJvdmlkZXIvY2hhbGxlbmdlUHJvdmlkZXJVbnRydXN0ZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsMkRBQTJFO0FBRTNFLE1BQWEsMEJBQTBCO0lBRWQ7SUFDRDtJQUZwQixZQUNxQixRQUFnQixFQUNqQixNQUFZO1FBRFgsYUFBUSxHQUFSLFFBQVEsQ0FBUTtRQUNqQixXQUFNLEdBQU4sTUFBTSxDQUFNO0lBQzdCLENBQUM7SUFFSixLQUFLLENBQUMsaUJBQWlCLENBQ25CLFFBQWdCLEVBQ2hCLFNBQWtCO1FBRWxCLE9BQU87WUFDSCxJQUFJLEVBQUUsMEJBQWEsQ0FBQyxTQUFTO1lBQzdCLGNBQWMsRUFBRSxRQUFRLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQztZQUMzQyxRQUFRLEVBQUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO1lBQzFDLFNBQVM7U0FDWixDQUFDO0lBQ04sQ0FBQztDQUNKO0FBakJELGdFQWlCQyJ9

package/dist/challengeProvider/index.d.ts

@@ -0,0 +1,8 @@
+export * from './challengeProvider';
+export * from './challengeProviderTdx';
+export * from './challengeProviderAzure';
+export * from './challengeProviderUntrusted';
+export * from './challengeProviderSevSnp';
+export * from './challengeNvidiaCCHelper';
+export * from './challengeProviderCertificate';
+export * from './challengeProviderToken';

package/dist/challengeProvider/index.js

@@ -0,0 +1,25 @@
+"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("./challengeProvider"), exports);
+__exportStar(require("./challengeProviderTdx"), exports);
+__exportStar(require("./challengeProviderAzure"), exports);
+__exportStar(require("./challengeProviderUntrusted"), exports);
+__exportStar(require("./challengeProviderSevSnp"), exports);
+__exportStar(require("./challengeNvidiaCCHelper"), exports);
+__exportStar(require("./challengeProviderCertificate"), exports);
+__exportStar(require("./challengeProviderToken"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhbGxlbmdlUHJvdmlkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNEQUFvQztBQUNwQyx5REFBdUM7QUFDdkMsMkRBQXlDO0FBQ3pDLCtEQUE2QztBQUM3Qyw0REFBMEM7QUFDMUMsNERBQTBDO0FBQzFDLGlFQUErQztBQUMvQywyREFBeUMifQ==

package/dist/challengeValidator/challengeValidator.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { Challenge } from '@super-protocol/pki-common';
+export interface SuccessChallengeResult {
+    success: true;
+    validatedUserData: Buffer;
+    validatedId: Buffer;
+    validatedCommonId?: Buffer;
+    validatedSolutionHash?: Buffer;
+}
+export interface UnsuccessfulChallengeResult {
+    success: false;
+    error: string;
+}
+export type ChallengeResult = SuccessChallengeResult | UnsuccessfulChallengeResult;
+export interface ChallengeValidator {
+    validate(challenge: Challenge, publicKeyPem?: string): Promise<ChallengeResult>;
+    initialize?: () => Promise<void>;
+}

package/dist/challengeValidator/challengeValidator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlVmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NoYWxsZW5nZVZhbGlkYXRvci9jaGFsbGVuZ2VWYWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/challengeValidator/challengeValidatorAzure.d.ts

@@ -0,0 +1,29 @@
+import { Challenge, Log, NetworkType } from '@super-protocol/pki-common';
+import { ChallengeResult, ChallengeValidator } from './challengeValidator';
+import { AzureValidationConfig } from './validatorConfig';
+import { AttestationWasmAzure } from './wasmVerificationPolicy';
+export interface ChallengeValidatorAzureOptions {
+    /**
+     * A debug VM offers no confidentiality, so it is accepted only when the
+     * network is explicitly untrusted.
+     */
+    networkType?: NetworkType;
+    config?: AzureValidationConfig;
+    loadAttestationModule?: () => Promise<AttestationWasmAzure>;
+}
+/**
+ * Validates Azure confidential VM evidence (Intel TDX and AMD SEV-SNP) with
+ * @super-protocol/attestation-wasm: the Intel / AMD signature of the hardware
+ * report, the Microsoft vTPM attestation key, the TPM quote and the event log.
+ * Microsoft Azure Attestation is always asked whether the paravisor is a
+ * genuine Azure one; evidence is rejected when MAA is unreachable.
+ *
+ * NOT verified on a live SEV-SNP guest yet.
+ */
+export declare class ChallengeValidatorAzure implements ChallengeValidator {
+    private readonly log;
+    private readonly options;
+    constructor(log: Log, options?: ChallengeValidatorAzureOptions);
+    validate(challenge: Challenge): Promise<ChallengeResult>;
+    private validateEvidence;
+}

package/dist/challengeValidator/challengeValidatorAzure.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeValidatorAzure = void 0;
+const attestation_common_1 = require("@super-protocol/attestation-common");
+const pki_common_1 = require("@super-protocol/pki-common");
+const wasmVerificationPolicy_1 = require("./wasmVerificationPolicy");
+const preservedDynamicImport = new Function('specifier', 'return import(specifier)');
+const defaultLoadAttestationModule = () => preservedDynamicImport('@super-protocol/attestation-wasm/node');
+const EXPECTED_EVIDENCE_TYPE = {
+    [pki_common_1.ChallengeType.TDXAZURE]: attestation_common_1.TeeEvidenceType.TEE_EVIDENCE_TYPE_INTEL_TDX_AZURE,
+    [pki_common_1.ChallengeType.SEVSNPAZURE]: attestation_common_1.TeeEvidenceType.TEE_EVIDENCE_TYPE_AMD_SEV_SNP_AZURE,
+};
+/**
+ * Validates Azure confidential VM evidence (Intel TDX and AMD SEV-SNP) with
+ * @super-protocol/attestation-wasm: the Intel / AMD signature of the hardware
+ * report, the Microsoft vTPM attestation key, the TPM quote and the event log.
+ * Microsoft Azure Attestation is always asked whether the paravisor is a
+ * genuine Azure one; evidence is rejected when MAA is unreachable.
+ *
+ * NOT verified on a live SEV-SNP guest yet.
+ */
+class ChallengeValidatorAzure {
+    log;
+    options;
+    constructor(log, options = {}) {
+        this.log = log;
+        this.options = options;
+    }
+    async validate(challenge) {
+        switch (challenge.type) {
+            case pki_common_1.ChallengeType.TDXAZURE:
+            case pki_common_1.ChallengeType.SEVSNPAZURE:
+                try {
+                    return await this.validateEvidence(challenge.type, Buffer.from(challenge.evidenceBase64, 'base64'));
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: e.message,
+                    };
+                }
+        }
+        throw new Error('Method not implemented.');
+    }
+    async validateEvidence(challengeType, evidence) {
+        const log = this.log.child({
+            validator: 'ChallengeValidatorAzure',
+            challengeType,
+        });
+        const attestation = await (this.options.loadAttestationModule ?? defaultLoadAttestationModule)();
+        const verification = await attestation.verifyTeeEvidence(evidence, (0, wasmVerificationPolicy_1.buildAzureVerifyOptions)(this.options.config));
+        if (verification.evidenceType !== EXPECTED_EVIDENCE_TYPE[challengeType]) {
+            throw new Error(`Evidence type ${verification.evidenceType} does not match challenge type ${challengeType}`);
+        }
+        const { mrEnclave, reportData } = (0, wasmVerificationPolicy_1.checkAzureVerificationResult)(verification, attestation, { networkType: this.options.networkType, log });
+        log.debug('Azure evidence verified', {
+            mrEnclaveHex: mrEnclave.toString('hex'),
+        });
+        return {
+            success: true,
+            validatedUserData: reportData,
+            validatedId: mrEnclave,
+        };
+    }
+}
+exports.ChallengeValidatorAzure = ChallengeValidatorAzure;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/challengeValidator/challengeValidatorCertificate.d.ts

@@ -0,0 +1,9 @@
+import { Challenge } from '@super-protocol/pki-common';
+import { ChallengeResult, ChallengeValidator } from './challengeValidator';
+import { Log } from '@super-protocol/pki-common';
+export declare class ChallengeValidatorCertificate implements ChallengeValidator {
+    private readonly log;
+    constructor(log: Log);
+    validate(challenge: Challenge, publicKeyPem: string): Promise<ChallengeResult>;
+    private verifyUserData;
+}

package/dist/challengeValidator/challengeValidatorCertificate.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeValidatorCertificate = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const pki_common_1 = require("@super-protocol/pki-common");
+const sdk_js_1 = require("@super-protocol/sdk-js");
+class ChallengeValidatorCertificate {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    async validate(challenge, publicKeyPem) {
+        switch (challenge.type) {
+            case pki_common_1.ChallengeType.Certificate:
+                try {
+                    await sdk_js_1.TeeCertificateService.validateTeeCertChainOrFail(challenge.orderCertificate + challenge.orderCABundle);
+                    this.verifyUserData(publicKeyPem, challenge.userDataSignatureBase64, challenge.orderCertificate);
+                    return {
+                        success: true,
+                        validatedUserData: (0, pki_common_1.getPublicKeyPemHash)(publicKeyPem),
+                        validatedId: sdk_js_1.CertificatesHelper.getExtensionValue(challenge.orderCertificate, pki_common_1.OID_CUSTOM_EXTENSION_CHALLENGE_ID) ?? Buffer.alloc(0),
+                        validatedCommonId: sdk_js_1.CertificatesHelper.getExtensionValue(challenge.orderCertificate, pki_common_1.OID_CUSTOM_EXTENSION_CHALLENGE_COMMON_ID),
+                        validatedSolutionHash: sdk_js_1.CertificatesHelper.getExtensionValue(challenge.orderCertificate, sdk_js_1.constants.OID_CUSTOM_EXTENSION_USER_DATA),
+                    };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: e.message,
+                    };
+                }
+        }
+        throw new Error('Method not implemented.');
+    }
+    async verifyUserData(publicKeyPem, signatureBase64, certificatePem) {
+        const cert = await sdk_js_1.CertificateGenerator.checkAndParseCert(certificatePem);
+        const certPublicKeyPem = await sdk_js_1.CryptoKeysTransformer.cryptoKeyToSpkiPem(cert.publicKey);
+        const certPublicKeyKeyObj = crypto_1.default.createPublicKey(certPublicKeyPem);
+        const publicKeyHash = (0, pki_common_1.getPublicKeyPemHash)(publicKeyPem);
+        const isValid = await sdk_js_1.Crypto.verify({
+            data: publicKeyHash,
+            signature: signatureBase64,
+            publicKey: certPublicKeyKeyObj,
+            signatureFormat: 'base64',
+        });
+        if (!isValid) {
+            throw Error('Signature verification failed');
+        }
+    }
+}
+exports.ChallengeValidatorCertificate = ChallengeValidatorCertificate;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/challengeValidator/challengeValidatorNvidia.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { NvtrustWrapperConfig } from './validatorConfig';
+import { Challenge, NetworkType, NvidiaVerification } from '@super-protocol/pki-common';
+import { Log } from '@super-protocol/pki-common';
+export declare class ChallengeValidatorNvidia {
+    private readonly log;
+    private readonly config?;
+    constructor(log: Log, config?: NvtrustWrapperConfig | undefined);
+    validate(challenge: Challenge, userData: Buffer, networkType?: NetworkType): Promise<NvidiaVerification | undefined>;
+}

package/dist/challengeValidator/challengeValidatorNvidia.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeValidatorNvidia = void 0;
+const sp_nvtrust_wrapper_1 = require("@super-protocol/sp-nvtrust-wrapper");
+const pki_common_1 = require("@super-protocol/pki-common");
+const challengeProvider_1 = require("../challengeProvider");
+class ChallengeValidatorNvidia {
+    log;
+    config;
+    constructor(log, config) {
+        this.log = log;
+        this.config = config;
+    }
+    async validate(challenge, userData, networkType) {
+        const log = this.log.child({
+            validator: 'ChallengeValidatorNvidia',
+        });
+        const hasNvidiaToken = (0, pki_common_1.hasChallengeNvidiaToken)(challenge);
+        const hasNvidiaEvidence = (0, pki_common_1.hasChallengeNvidiaEvidence)(challenge);
+        const verifier = this.config?.verifier ?? 'remote';
+        if (hasNvidiaToken && hasNvidiaEvidence) {
+            throw new Error('NVIDIA challenge cannot contain both a token and evidence');
+        }
+        challengeProvider_1.ChallengeNvidiaCCHelper.assertLocalVerifierAllowsChallenge(verifier, challenge.type);
+        log.debug(`Challenge NVIDIA token present: ${hasNvidiaToken}, evidence present: ${hasNvidiaEvidence}, verifier: ${verifier}`);
+        if (!hasNvidiaToken && !hasNvidiaEvidence) {
+            log.debug('NVIDIA validation skipped: challenge does not contain NVIDIA token or evidence');
+            return;
+        }
+        if (verifier === 'local' && !hasNvidiaEvidence) {
+            throw new Error('NVIDIA local verifier requires evidence and rejects an NRAS token');
+        }
+        if (verifier === 'remote' && !hasNvidiaToken) {
+            throw new Error('NVIDIA remote verifier requires an NRAS token and rejects evidence');
+        }
+        log.debug(`NVIDIA validation started for networkType=${networkType ?? 'undefined'}`);
+        const tokenHash = (0, pki_common_1.hasChallengeNvidiaEvidence)(challenge)
+            ? challengeProvider_1.ChallengeNvidiaCCHelper.getEvidenceHash(challenge.nvidiaEvidence)
+            : (0, pki_common_1.hasChallengeNvidiaToken)(challenge)
+                ? challengeProvider_1.ChallengeNvidiaCCHelper.getTokenHash(challenge.nvidiaTokens)
+                : undefined;
+        if (!tokenHash) {
+            throw new Error('NVIDIA challenge payload is missing');
+        }
+        if (userData.length < 64) {
+            throw new Error('userData must be at least 64 bytes');
+        }
+        const expectedHash = userData.slice(32, 64);
+        const tokenHashHex = tokenHash.toString('hex');
+        const expectedHashHex = expectedHash.toString('hex');
+        log.debug(`NVIDIA tokenHash: ${tokenHashHex}, expectedHash: ${expectedHashHex}`);
+        if (tokenHashHex !== expectedHashHex) {
+            throw new Error('Nvidia hash included in the challenge does not match the hash of the nvidia token specified in the request');
+        }
+        log.info('NVIDIA validation passed: token hash matches attested userData hash');
+        const nvtrusWrapper = new sp_nvtrust_wrapper_1.NvtrustWrapper(this.config?.tmp ?? '/tmp/nvtrust-tmp', this.config?.timeout ?? 60000);
+        const localVerifier = nvtrusWrapper;
+        let nvidiaTokenValidationResult = {
+            success: false,
+        };
+        try {
+            let gpuToken;
+            let nvswitchToken;
+            let gpuInterconnectStatus;
+            const attestationMode = verifier === 'local' ? 2 : 1;
+            if ((0, pki_common_1.hasChallengeNvidiaEvidence)(challenge)) {
+                const evidence = challenge.nvidiaEvidence;
+                gpuInterconnectStatus = evidence.gpuInterconnectStatus;
+                const attested = await localVerifier.attestEvidence({
+                    device: sp_nvtrust_wrapper_1.NvidiaDeviceType.GPU,
+                    nonce: evidence.nonce,
+                    evidenceJson: evidence.gpuEvidence,
+                    rimUrl: this.config?.rimUrl ?? '',
+                    ocspUrl: this.config?.ocspUrl ?? '',
+                    policy: sp_nvtrust_wrapper_1.defaultGPUpolicy,
+                    ppcieMode: false,
+                });
+                gpuToken = attested.jwt;
+                if (gpuInterconnectStatus ===
+                    sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_VERIFIED) {
+                    if (!evidence.nvswitchEvidence) {
+                        throw new Error('Verified NVIDIA NVLink switch interconnect requires switch evidence');
+                    }
+                    const switchAttested = await localVerifier.attestEvidence({
+                        device: sp_nvtrust_wrapper_1.NvidiaDeviceType.SWITCH,
+                        nonce: evidence.nonce,
+                        evidenceJson: evidence.nvswitchEvidence,
+                        rimUrl: this.config?.rimUrl ?? '',
+                        ocspUrl: this.config?.ocspUrl ?? '',
+                        policy: sp_nvtrust_wrapper_1.defaultNVSwitchPolicy,
+                        ppcieMode: false,
+                    });
+                    nvswitchToken = switchAttested.jwt;
+                }
+                nvidiaTokenValidationResult = { success: true };
+                log.info('NVIDIA validation passed: local verifier accepted the evidence');
+            }
+            else {
+                if (!(0, pki_common_1.hasChallengeNvidiaToken)(challenge)) {
+                    throw new Error('NVIDIA remote verifier requires an NRAS token');
+                }
+                gpuToken = challenge.nvidiaTokens.gpuToken;
+                nvswitchToken = challenge.nvidiaTokens.nvswitchToken;
+                gpuInterconnectStatus =
+                    challenge.nvidiaTokens.gpuInterconnectStatus;
+                nvidiaTokenValidationResult = await nvtrusWrapper.validateToken({
+                    device: sp_nvtrust_wrapper_1.NvidiaDeviceType.GPU,
+                    policy: sp_nvtrust_wrapper_1.defaultGPUpolicy,
+                    token: { jwt: gpuToken },
+                });
+                if (nvidiaTokenValidationResult.success !== true) {
+                    throw new Error('Failed to verify Nvidia GPU token: validateToken returned success=false');
+                }
+                log.info('NVIDIA validation passed: nvtrust token verification succeeded');
+            }
+            const gpusInfo = sp_nvtrust_wrapper_1.NvtrustWrapper.extractGPUInfoFromToken({
+                jwt: gpuToken,
+            });
+            const gpuCount = gpusInfo.gpus.length;
+            if (gpuCount === 0) {
+                throw new Error('Validated NVIDIA GPU token does not contain any GPU claims');
+            }
+            const hasGpuInterconnectStatus = gpuInterconnectStatus !== undefined;
+            const hasNVSwitchToken = nvswitchToken !== undefined;
+            if (gpuCount === 1) {
+                if (hasGpuInterconnectStatus || hasNVSwitchToken) {
+                    throw new Error('NVIDIA GPU interconnect status and NVSwitch token must be omitted for a single GPU');
+                }
+            }
+            else if (!hasGpuInterconnectStatus) {
+                throw new Error('NVIDIA GPU interconnect status is required when the validated GPU token contains multiple GPUs');
+            }
+            if (gpuInterconnectStatus !==
+                sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_VERIFIED &&
+                hasNVSwitchToken) {
+                throw new Error('NVIDIA NVSwitch token is only allowed for a verified NVLink switch interconnect');
+            }
+            switch (gpuInterconnectStatus) {
+                case undefined:
+                    break;
+                case sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_DISCONNECTED:
+                    log.info('Multiple disconnected NVIDIA GPUs were reported by TEE-bound interconnect metadata');
+                    break;
+                case sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_DIRECT_UNVERIFIED:
+                    if (networkType !== 'untrusted') {
+                        throw new Error('Unverified direct NVIDIA GPU interconnect is only allowed on an untrusted network');
+                    }
+                    log.warn('Allowing unverified direct NVIDIA GPU interconnect on an untrusted network');
+                    break;
+                case sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_NOT_APPLICABLE:
+                    // TODO(NVIDIA NVLink attestation): Revisit this branch if NVIDIA
+                    // introduces or requires separate NVLink/NVSwitch attestation for
+                    // Blackwell. NOT_APPLICABLE currently has no switch token and relies
+                    // on the validated GPU token plus TEE-bound interconnect metadata.
+                    log.info('Separate NVIDIA NVSwitch attestation is not applicable to this NVLink topology');
+                    break;
+                case sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_VERIFIED:
+                    if (!nvswitchToken) {
+                        throw new Error('Verified NVIDIA NVLink switch interconnect requires a non-empty NVSwitch token');
+                    }
+                    break;
+                default:
+                    throw new Error(`Unknown NVIDIA GPU interconnect status: ${gpuInterconnectStatus}`);
+            }
+            if (gpuInterconnectStatus ===
+                sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_VERIFIED) {
+                if (verifier !== 'local') {
+                    nvidiaTokenValidationResult =
+                        await nvtrusWrapper.validateToken({
+                            device: sp_nvtrust_wrapper_1.NvidiaDeviceType.SWITCH,
+                            policy: sp_nvtrust_wrapper_1.defaultNVSwitchPolicy,
+                            token: { jwt: nvswitchToken },
+                        });
+                    if (nvidiaTokenValidationResult.success !== true) {
+                        throw new Error('Failed to verify Nvidia NVSwitch token: validateToken returned success=false');
+                    }
+                    log.info('NVIDIA NVSwitch validation passed: nvtrust token verification succeeded');
+                }
+                const switchesInfo = sp_nvtrust_wrapper_1.NvtrustWrapper.extractNVSwitchInfoFromToken({
+                    jwt: nvswitchToken,
+                });
+                if (switchesInfo.length === 0) {
+                    throw new Error('Validated NVIDIA NVSwitch token does not contain any switch claims');
+                }
+                if (networkType === 'trusted') {
+                    const insecureSwitchNumbers = switchesInfo
+                        .map((nvSwitch, index) => ({
+                        nvSwitch,
+                        switchNumber: index + 1,
+                    }))
+                        .filter(({ nvSwitch }) => !nvSwitch.secureBoot || nvSwitch.debugEnabled)
+                        .map(({ switchNumber }) => switchNumber);
+                    if (insecureSwitchNumbers.length > 0) {
+                        throw new Error(`Trusted network requires secure boot and disabled debug mode on every NVIDIA NVSwitch. Invalid switch(es): ${insecureSwitchNumbers.join(', ')}`);
+                    }
+                    log.info(`NVIDIA trusted policy check passed: secure boot is enabled and debug mode is disabled on all ${switchesInfo.length} NVSwitch(es)`);
+                }
+            }
+            if (networkType === 'trusted') {
+                const debugGpuNumbers = gpusInfo.gpus
+                    .map((gpu, index) => ({ gpu, gpuNumber: index + 1 }))
+                    .filter(({ gpu }) => gpu.dbgStat === true)
+                    .map(({ gpuNumber }) => gpuNumber);
+                const hasDebugEnabledGpu = debugGpuNumbers.length > 0;
+                if (hasDebugEnabledGpu) {
+                    const debugGpuNumbersText = debugGpuNumbers.join(', ');
+                    throw new Error(`Trusted network does not allow NVIDIA GPUs with dbgStat=true. Debug enabled on GPU(s): ${debugGpuNumbersText}`);
+                }
+                log.info(`NVIDIA trusted policy check passed: dbgStat=false on all ${gpusInfo.gpus.length} GPU(s)`);
+            }
+            else {
+                log.info(`NVIDIA trusted-only GPU debug policy check skipped for networkType=${networkType ?? 'undefined'}`);
+            }
+            return {
+                gpuToken,
+                ...(nvswitchToken !== undefined ? { nvswitchToken } : {}),
+                ...(gpuInterconnectStatus !== undefined
+                    ? { gpuInterconnectStatus }
+                    : {}),
+                attestationMode,
+            };
+        }
+        catch (error) {
+            if (error instanceof sp_nvtrust_wrapper_1.NvtrustWrapperCallError) {
+                log.error(`NvtrustWrapperCallError: ${error.message}`);
+                if (error.traceback?.trim()) {
+                    log.debug(`Traceback:\n${error.traceback}`);
+                }
+                const logEntries = Object.entries(error.logs ?? {});
+                if (logEntries.length > 0) {
+                    log.debug('Logs from nvtrust wrapper:');
+                    for (const [fileName, logContent] of logEntries) {
+                        log.debug(`--- ${fileName} ---`);
+                        log.debug(String(logContent));
+                    }
+                }
+            }
+            else {
+                log.error(`Error during NVIDIA token validation: ${error}`);
+            }
+            throw error;
+        }
+    }
+}
+exports.ChallengeValidatorNvidia = ChallengeValidatorNvidia;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"challengeValidatorNvidia.js","sourceRoot":"","sources":["../../src/challengeValidator/challengeValidatorNvidia.ts"],"names":[],"mappings":"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"}

package/dist/challengeValidator/challengeValidatorSevSnp.d.ts

@@ -0,0 +1,13 @@
+import { Challenge, Log } from '@super-protocol/pki-common';
+import { ChallengeResult, ChallengeValidator } from './challengeValidator';
+import { SevValidationConfig } from './validatorConfig';
+export declare class ChallengeValidatorSevSnp implements ChallengeValidator {
+    private readonly log;
+    private measureInstance;
+    private readonly sevTmp;
+    private static instance;
+    private readonly securityPolicy;
+    static getInstance(log: Log, config?: SevValidationConfig): ChallengeValidatorSevSnp;
+    private constructor();
+    validate(challenge: Challenge): Promise<ChallengeResult>;
+}