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

package/dist/challengeProvider/challengeNvidiaCCHelper.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { ChallengeType, NvidiaCCToken, NvidiaEvidence, Log } from '@super-protocol/pki-common';
+import { NvidiaVerifierMode } from '../challengeValidator/validatorConfig';
+export interface NvidiaChallengeOptions {
+    verifier?: NvidiaVerifierMode;
+    challengeType?: ChallengeType;
+}
+export declare class ChallengeNvidiaCCHelper {
+    private static getNvidiaToken;
+    /**
+     * Reports how the GPUs can reach each other's memory.
+     *
+     * PCIe and unidentified peer paths are reported as unverified metadata;
+     * the verifier only permits that state on an untrusted network. Whether
+     * NVLink requires a separate NVSwitch token is determined from the LS10
+     * count returned by getGPUTopology(): Hopper exposes attestable LS10
+     * switches, while Blackwell does not.
+     *
+     * @returns the metadata status to bind to the TEE challenge
+     * @throws if NVML cannot be queried
+     */
+    private static getGpuInterconnectStatus;
+    static isLocalEvidence(value: NvidiaCCToken | NvidiaEvidence): value is NvidiaEvidence;
+    static canonicalEvidenceBinding(evidence: NvidiaEvidence): string;
+    static getEvidenceHash(evidence: NvidiaEvidence): Buffer;
+    static assertLocalVerifierAllowsChallenge(verifier: NvidiaVerifierMode | undefined, challengeType: ChallengeType | undefined): void;
+    static getTokenHash(token: NvidiaCCToken): Buffer;
+    static getTokenAndCombinedChallengeData(baseUserData: Buffer, logger?: Log, options?: NvidiaChallengeOptions): Promise<{
+        nvidiaTokens: NvidiaCCToken | undefined;
+        nvidiaEvidence: NvidiaEvidence | undefined;
+        challengeData: Buffer;
+    }>;
+}

package/dist/challengeProvider/challengeNvidiaCCHelper.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeNvidiaCCHelper = void 0;
+const sp_nvtrust_wrapper_1 = require("@super-protocol/sp-nvtrust-wrapper");
+const pki_common_1 = require("@super-protocol/pki-common");
+const crypto_1 = require("crypto");
+const CLOUD_CHALLENGE_TYPES = new Set([
+    pki_common_1.ChallengeType.TDXGOOGLE,
+    pki_common_1.ChallengeType.TDXAZURE,
+    pki_common_1.ChallengeType.SEVSNPAZURE,
+]);
+class ChallengeNvidiaCCHelper {
+    static async getNvidiaToken(logger, verifier = 'remote') {
+        const log = logger?.child({
+            helper: 'ChallengeNvidiaCCHelper',
+        });
+        try {
+            const wrapper = new sp_nvtrust_wrapper_1.NvtrustWrapper();
+            log?.info('Checking for untrusted GPUs');
+            await wrapper.assertTrustedGpus();
+            log?.info('Untrusted GPUs were not detected');
+            const topology = await wrapper.getGPUTopology();
+            log?.debug('NVIDIA GPU topology detected', {
+                gpuCount: topology.gpuCount,
+                nvswitchCount: topology.nvswitchCount,
+            });
+            if (!topology.gpuCount) {
+                log?.info('Challenge NVIDIA token present: false');
+                log?.info('NVIDIA token retrieval skipped: no GPUs detected in topology');
+                return;
+            }
+            let gpuInterconnectStatus;
+            if (topology.gpuCount > 1) {
+                gpuInterconnectStatus =
+                    await ChallengeNvidiaCCHelper.getGpuInterconnectStatus(wrapper, topology.nvswitchCount, log);
+            }
+            const nonce = sp_nvtrust_wrapper_1.NvtrustWrapper.generateNonce();
+            const needsSwitch = gpuInterconnectStatus ===
+                sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_VERIFIED;
+            if (verifier === 'local') {
+                log?.debug('Collecting NVIDIA GPU evidence', {
+                    gpuCount: topology.gpuCount,
+                });
+                const gpuEvidence = await wrapper.collectEvidence({
+                    device: sp_nvtrust_wrapper_1.NvidiaDeviceType.GPU,
+                    nonce,
+                    ppcieMode: false,
+                });
+                let nvswitchEvidence;
+                if (needsSwitch) {
+                    log?.debug('Collecting NVIDIA NVSwitch evidence', {
+                        nvswitchCount: topology.nvswitchCount,
+                    });
+                    nvswitchEvidence = await wrapper.collectEvidence({
+                        device: sp_nvtrust_wrapper_1.NvidiaDeviceType.SWITCH,
+                        nonce,
+                        ppcieMode: false,
+                    });
+                }
+                log?.info('Challenge NVIDIA evidence present: true');
+                return {
+                    gpuEvidence,
+                    nonce,
+                    ...(gpuInterconnectStatus !== undefined
+                        ? { gpuInterconnectStatus }
+                        : {}),
+                    ...(nvswitchEvidence !== undefined
+                        ? { nvswitchEvidence }
+                        : {}),
+                };
+            }
+            log?.debug('Attempting NVIDIA token retrieval for detected GPUs', {
+                gpuCount: topology.gpuCount,
+            });
+            const gpuTokenRaw = await wrapper.getNvidiaToken({
+                device: sp_nvtrust_wrapper_1.NvidiaDeviceType.GPU,
+                nonce,
+                ppcieMode: false,
+            });
+            let nvswitchToken;
+            if (needsSwitch) {
+                log?.debug('Attempting NVIDIA NVSwitch token retrieval', {
+                    nvswitchCount: topology.nvswitchCount,
+                });
+                const nvswitchTokenRaw = await wrapper.getNvidiaToken({
+                    device: sp_nvtrust_wrapper_1.NvidiaDeviceType.SWITCH,
+                    nonce,
+                    ppcieMode: false,
+                });
+                nvswitchToken = nvswitchTokenRaw.jwt;
+                log?.info('NVIDIA NVSwitch token retrieved successfully', {
+                    nvswitchCount: topology.nvswitchCount,
+                });
+            }
+            log?.info('Challenge NVIDIA token present: true');
+            log?.info('NVIDIA token retrieved successfully', {
+                gpuCount: topology.gpuCount,
+                nvswitchCount: topology.nvswitchCount,
+            });
+            return {
+                gpuToken: gpuTokenRaw.jwt,
+                ...(gpuInterconnectStatus !== undefined
+                    ? { gpuInterconnectStatus }
+                    : {}),
+                ...(nvswitchToken !== undefined ? { nvswitchToken } : {}),
+            };
+        }
+        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 if (error instanceof sp_nvtrust_wrapper_1.UntrustedGpusError) {
+                log?.error('Untrusted GPUs detected', {
+                    errors: error.errors,
+                });
+            }
+            else {
+                log?.error(`Error during NVIDIA token retrieval: ${error}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Reports how the GPUs can reach each other's memory.
+     *
+     * PCIe and unidentified peer paths are reported as unverified metadata;
+     * the verifier only permits that state on an untrusted network. Whether
+     * NVLink requires a separate NVSwitch token is determined from the LS10
+     * count returned by getGPUTopology(): Hopper exposes attestable LS10
+     * switches, while Blackwell does not.
+     *
+     * @returns the metadata status to bind to the TEE challenge
+     * @throws if NVML cannot be queried
+     */
+    static async getGpuInterconnectStatus(wrapper, nvswitchCount, log) {
+        const links = await wrapper.getGpuInterconnect();
+        const describe = (type) => sp_nvtrust_wrapper_1.GpuInterconnectLinkType[type] ?? String(type);
+        const format = (subset) => subset
+            .map((link) => `${link.bdf1} <-> ${link.bdf2}: ${describe(link.type)}`)
+            .join('; ');
+        log?.debug('GPU interconnect checked', {
+            pairs: links.map((link) => ({
+                bdf1: link.bdf1,
+                bdf2: link.bdf2,
+                type: describe(link.type),
+            })),
+        });
+        const connected = links.filter((link) => link.type !==
+            sp_nvtrust_wrapper_1.GpuInterconnectLinkType.GPU_INTERCONNECT_LINK_TYPE_NONE);
+        if (connected.length === 0) {
+            log?.info('GPUs are isolated: no direct interconnect detected');
+            return sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_DISCONNECTED;
+        }
+        const bypassing = connected.filter((link) => link.type !==
+            sp_nvtrust_wrapper_1.GpuInterconnectLinkType.GPU_INTERCONNECT_LINK_TYPE_NVLINK);
+        if (bypassing.length > 0) {
+            const details = format(bypassing);
+            log?.warn('Unverified direct GPU interconnect detected; it is allowed only on an untrusted network', { links: details });
+            return sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_DIRECT_UNVERIFIED;
+        }
+        log?.warn('NVLink interconnect detected', { links: format(connected) });
+        if (nvswitchCount === 0) {
+            log?.warn('No attestable LS10 NVSwitch devices were found; continuing with GPU-only attestation (expected for Blackwell)');
+            return sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_NOT_APPLICABLE;
+        }
+        return sp_nvtrust_wrapper_1.NvidiaGpuInterconnectStatus.NVIDIA_GPU_INTERCONNECT_NVLINK_SWITCH_ATTESTATION_VERIFIED;
+    }
+    static isLocalEvidence(value) {
+        return 'gpuEvidence' in value;
+    }
+    static canonicalEvidenceBinding(evidence) {
+        return JSON.stringify({
+            gpuEvidence: evidence.gpuEvidence,
+            nonce: evidence.nonce,
+            ...(evidence.gpuInterconnectStatus !== undefined
+                ? { gpuInterconnectStatus: evidence.gpuInterconnectStatus }
+                : {}),
+            ...(evidence.nvswitchEvidence !== undefined
+                ? { nvswitchEvidence: evidence.nvswitchEvidence }
+                : {}),
+        });
+    }
+    static getEvidenceHash(evidence) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(ChallengeNvidiaCCHelper.canonicalEvidenceBinding(evidence))
+            .digest();
+    }
+    static assertLocalVerifierAllowsChallenge(verifier, challengeType) {
+        if (verifier === 'local' &&
+            challengeType !== undefined &&
+            CLOUD_CHALLENGE_TYPES.has(challengeType)) {
+            throw new Error(`NVIDIA local verifier does not support ${challengeType}`);
+        }
+    }
+    static getTokenHash(token) {
+        const hash = (0, crypto_1.createHash)('sha256');
+        hash.update(JSON.stringify({
+            gpuToken: token.gpuToken,
+            ...(token.gpuInterconnectStatus !== undefined
+                ? {
+                    gpuInterconnectStatus: token.gpuInterconnectStatus,
+                }
+                : {}),
+            ...(token.nvswitchToken !== undefined
+                ? { nvswitchToken: token.nvswitchToken }
+                : {}),
+        }));
+        return hash.digest();
+    }
+    static async getTokenAndCombinedChallengeData(baseUserData, logger, options) {
+        const log = logger?.child({
+            helper: 'ChallengeNvidiaCCHelper',
+        });
+        const verifier = options?.verifier ?? 'remote';
+        ChallengeNvidiaCCHelper.assertLocalVerifierAllowsChallenge(verifier, options?.challengeType);
+        const material = await ChallengeNvidiaCCHelper.getNvidiaToken(logger, verifier);
+        const nvidiaEvidence = material && ChallengeNvidiaCCHelper.isLocalEvidence(material)
+            ? material
+            : undefined;
+        const nvidiaTokens = material && !ChallengeNvidiaCCHelper.isLocalEvidence(material)
+            ? material
+            : undefined;
+        const nvidiaHash = nvidiaEvidence
+            ? ChallengeNvidiaCCHelper.getEvidenceHash(nvidiaEvidence)
+            : nvidiaTokens &&
+                ChallengeNvidiaCCHelper.getTokenHash(nvidiaTokens);
+        const challengeData = nvidiaHash
+            ? Buffer.concat([baseUserData, nvidiaHash])
+            : baseUserData;
+        if (challengeData.length > 64) {
+            throw new Error('challengeData length exceeds 64 bytes');
+        }
+        log?.debug('Prepared combined challenge data', {
+            baseUserDataLength: baseUserData.length,
+            challengeDataLength: challengeData.length,
+            hasNvidiaToken: Boolean(nvidiaTokens),
+            hasNvidiaEvidence: Boolean(nvidiaEvidence),
+        });
+        return { nvidiaTokens, nvidiaEvidence, challengeData };
+    }
+}
+exports.ChallengeNvidiaCCHelper = ChallengeNvidiaCCHelper;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"challengeNvidiaCCHelper.js","sourceRoot":"","sources":["../../src/challengeProvider/challengeNvidiaCCHelper.ts"],"names":[],"mappings":"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"}

package/dist/challengeProvider/challengeProvider.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Challenge, Log } from '@super-protocol/pki-common';
+export interface ChallengeProvider {
+    logger?: Log;
+    generateChallenge(userData: Buffer, networkID?: string): Promise<Challenge>;
+}

package/dist/challengeProvider/challengeProvider.js

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

package/dist/challengeProvider/challengeProviderAzure.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { ChallengeProvider } from './challengeProvider';
+import { Challenge, ChallengeType, Log } from '@super-protocol/pki-common';
+import { NvidiaVerifierMode } from '../challengeValidator/validatorConfig';
+export declare class ChallengeProviderAzure implements ChallengeProvider {
+    readonly logger: Log | undefined;
+    private readonly challengeType;
+    private readonly nvidiaVerifier?;
+    constructor(logger: Log | undefined, challengeType: ChallengeType.TDXAZURE | ChallengeType.SEVSNPAZURE, nvidiaVerifier?: NvidiaVerifierMode | undefined);
+    generateChallenge(userData: Buffer, networkID?: string): Promise<Challenge>;
+}

package/dist/challengeProvider/challengeProviderAzure.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeProviderAzure = void 0;
+const challengeNvidiaCCHelper_1 = require("./challengeNvidiaCCHelper");
+const pki_common_1 = require("@super-protocol/pki-common");
+class ChallengeProviderAzure {
+    logger;
+    challengeType;
+    nvidiaVerifier;
+    constructor(logger, challengeType, nvidiaVerifier) {
+        this.logger = logger;
+        this.challengeType = challengeType;
+        this.nvidiaVerifier = nvidiaVerifier;
+    }
+    async generateChallenge(userData, networkID) {
+        // This module depends on native library that cannot be compiled for all architectures / operating systems.
+        // That is why we load it dynamically and use only when it's really needed.
+        const { TeeNative } = await Promise.resolve().then(() => __importStar(require('@super-protocol/addons-tee')));
+        const { challengeData, nvidiaTokens, nvidiaEvidence } = await challengeNvidiaCCHelper_1.ChallengeNvidiaCCHelper.getTokenAndCombinedChallengeData(userData, this.logger, {
+            verifier: this.nvidiaVerifier,
+            challengeType: this.challengeType,
+        });
+        const azureCvmService = new TeeNative.AzureCvmService();
+        const evidence = this.challengeType === pki_common_1.ChallengeType.TDXAZURE
+            ? await azureCvmService.generateSerializedTDXAzureEvidence(challengeData)
+            : await azureCvmService.generateSerializedAmdSevSnpAzureEvidence(challengeData);
+        return {
+            type: this.challengeType,
+            evidenceBase64: evidence.toString('base64'),
+            ...(nvidiaTokens ? { nvidiaTokens } : {}),
+            ...(nvidiaEvidence ? { nvidiaEvidence } : {}),
+            networkID,
+        };
+    }
+}
+exports.ChallengeProviderAzure = ChallengeProviderAzure;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlUHJvdmlkZXJBenVyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaGFsbGVuZ2VQcm92aWRlci9jaGFsbGVuZ2VQcm92aWRlckF6dXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsdUVBQW9FO0FBRXBFLDJEQUEyRTtBQUczRSxNQUFhLHNCQUFzQjtJQUVYO0lBQ0M7SUFHQTtJQUxyQixZQUNvQixNQUF1QixFQUN0QixhQUVjLEVBQ2QsY0FBbUM7UUFKcEMsV0FBTSxHQUFOLE1BQU0sQ0FBaUI7UUFDdEIsa0JBQWEsR0FBYixhQUFhLENBRUM7UUFDZCxtQkFBYyxHQUFkLGNBQWMsQ0FBcUI7SUFDckQsQ0FBQztJQUVKLEtBQUssQ0FBQyxpQkFBaUIsQ0FDbkIsUUFBZ0IsRUFDaEIsU0FBa0I7UUFFbEIsMkdBQTJHO1FBQzNHLDJFQUEyRTtRQUMzRSxNQUFNLEVBQUUsU0FBUyxFQUFFLEdBQUcsd0RBQWEsNEJBQTRCLEdBQUMsQ0FBQztRQUVqRSxNQUFNLEVBQUUsYUFBYSxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsR0FDakQsTUFBTSxpREFBdUIsQ0FBQyxnQ0FBZ0MsQ0FDMUQsUUFBUSxFQUNSLElBQUksQ0FBQyxNQUFNLEVBQ1g7WUFDSSxRQUFRLEVBQUUsSUFBSSxDQUFDLGNBQWM7WUFDN0IsYUFBYSxFQUFFLElBQUksQ0FBQyxhQUFhO1NBQ3BDLENBQ0osQ0FBQztRQUVOLE1BQU0sZUFBZSxHQUFHLElBQUksU0FBUyxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBRXhELE1BQU0sUUFBUSxHQUNWLElBQUksQ0FBQyxhQUFhLEtBQUssMEJBQWEsQ0FBQyxRQUFRO1lBQ3pDLENBQUMsQ0FBQyxNQUFNLGVBQWUsQ0FBQyxrQ0FBa0MsQ0FDcEQsYUFBYSxDQUNoQjtZQUNILENBQUMsQ0FBQyxNQUFNLGVBQWUsQ0FBQyx3Q0FBd0MsQ0FDMUQsYUFBYSxDQUNoQixDQUFDO1FBRVosT0FBTztZQUNILElBQUksRUFBRSxJQUFJLENBQUMsYUFBYTtZQUN4QixjQUFjLEVBQUUsUUFBUSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUM7WUFDM0MsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsRUFBRSxZQUFZLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQ3pDLEdBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLEVBQUUsY0FBYyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUM3QyxTQUFTO1NBQ1osQ0FBQztJQUNOLENBQUM7Q0FDSjtBQTlDRCx3REE4Q0MifQ==

package/dist/challengeProvider/challengeProviderCertificate.d.ts

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

package/dist/challengeProvider/challengeProviderCertificate.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeProviderCertificate = void 0;
+const pki_common_1 = require("@super-protocol/pki-common");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+class ChallengeProviderCertificate {
+    orderCertsPath;
+    logger;
+    orderCert;
+    orderCaBundle;
+    orderPrivateKey;
+    initialized = false;
+    constructor(orderCertsPath, logger) {
+        this.orderCertsPath = orderCertsPath;
+        this.logger = logger;
+    }
+    async generateChallenge(userData, networkID) {
+        if (!this.initialized) {
+            try {
+                await this.readOrderCerts();
+                this.initialized = true;
+            }
+            catch (error) {
+                throw new Error(`Error on reading order certificate files: ${error.message}`);
+            }
+        }
+        return {
+            type: pki_common_1.ChallengeType.Certificate,
+            userDataSignatureBase64: this.signUserData(userData),
+            orderCertificate: this.orderCert,
+            orderCABundle: this.orderCaBundle,
+            networkID,
+        };
+    }
+    async readOrderCerts() {
+        this.orderCert = await fs.readFile(path.join(this.orderCertsPath, 'order_cert.crt'), 'utf8');
+        this.orderPrivateKey = await fs.readFile(path.join(this.orderCertsPath, 'order_cert.key'), 'utf8');
+        this.orderCaBundle = await fs.readFile(path.join(this.orderCertsPath, 'order_cert_ca_bundle.crt'), 'utf8');
+    }
+    signUserData(userData) {
+        const privateKeyObj = crypto_1.default.createPrivateKey({
+            key: this.orderPrivateKey,
+            format: 'pem',
+            type: 'pkcs8',
+        });
+        const signer = crypto_1.default.createSign('sha256');
+        signer.update(userData);
+        signer.end();
+        const signature = signer.sign(privateKeyObj);
+        return signature.toString('base64');
+    }
+}
+exports.ChallengeProviderCertificate = ChallengeProviderCertificate;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/challengeProvider/challengeProviderSevSnp.d.ts

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

package/dist/challengeProvider/challengeProviderSevSnp.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeProviderSevSnp = void 0;
+const challengeNvidiaCCHelper_1 = require("./challengeNvidiaCCHelper");
+const pki_common_1 = require("@super-protocol/pki-common");
+class ChallengeProviderSevSnp {
+    logger;
+    nvidiaVerifier;
+    constructor(logger, nvidiaVerifier) {
+        this.logger = logger;
+        this.nvidiaVerifier = nvidiaVerifier;
+    }
+    async generateChallenge(userData, networkID) {
+        // This module depends on native library that cannot be compiled for all architectures / operating systems.
+        // That is why we load it dynamically and use only when it's really needed.
+        const { TeeNative } = await Promise.resolve().then(() => __importStar(require('@super-protocol/addons-tee')));
+        const { challengeData, nvidiaTokens, nvidiaEvidence } = await challengeNvidiaCCHelper_1.ChallengeNvidiaCCHelper.getTokenAndCombinedChallengeData(userData, this.logger, {
+            verifier: this.nvidiaVerifier,
+            challengeType: pki_common_1.ChallengeType.SEVSNP,
+        });
+        const evidence = await TeeNative.SevSNP.generateSerializedAmdSevSnpQemuEvidence(challengeData);
+        return {
+            type: pki_common_1.ChallengeType.SEVSNP,
+            evidenceBase64: evidence.toString('base64'),
+            ...(nvidiaTokens ? { nvidiaTokens } : {}),
+            ...(nvidiaEvidence ? { nvidiaEvidence } : {}),
+            networkID,
+        };
+    }
+}
+exports.ChallengeProviderSevSnp = ChallengeProviderSevSnp;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlUHJvdmlkZXJTZXZTbnAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhbGxlbmdlUHJvdmlkZXIvY2hhbGxlbmdlUHJvdmlkZXJTZXZTbnAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1RUFBb0U7QUFFcEUsMkRBQTJFO0FBRzNFLE1BQWEsdUJBQXVCO0lBRVo7SUFDQztJQUZyQixZQUNvQixNQUFZLEVBQ1gsY0FBbUM7UUFEcEMsV0FBTSxHQUFOLE1BQU0sQ0FBTTtRQUNYLG1CQUFjLEdBQWQsY0FBYyxDQUFxQjtJQUNyRCxDQUFDO0lBRUosS0FBSyxDQUFDLGlCQUFpQixDQUNuQixRQUFnQixFQUNoQixTQUFrQjtRQUVsQiwyR0FBMkc7UUFDM0csMkVBQTJFO1FBQzNFLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyx3REFBYSw0QkFBNEIsR0FBQyxDQUFDO1FBRWpFLE1BQU0sRUFBRSxhQUFhLEVBQUUsWUFBWSxFQUFFLGNBQWMsRUFBRSxHQUNqRCxNQUFNLGlEQUF1QixDQUFDLGdDQUFnQyxDQUMxRCxRQUFRLEVBQ1IsSUFBSSxDQUFDLE1BQU0sRUFDWDtZQUNJLFFBQVEsRUFBRSxJQUFJLENBQUMsY0FBYztZQUM3QixhQUFhLEVBQUUsMEJBQWEsQ0FBQyxNQUFNO1NBQ3RDLENBQ0osQ0FBQztRQUNOLE1BQU0sUUFBUSxHQUNWLE1BQU0sU0FBUyxDQUFDLE1BQU0sQ0FBQyx1Q0FBdUMsQ0FDMUQsYUFBYSxDQUNoQixDQUFDO1FBQ04sT0FBTztZQUNILElBQUksRUFBRSwwQkFBYSxDQUFDLE1BQU07WUFDMUIsY0FBYyxFQUFFLFFBQVEsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO1lBQzNDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLEVBQUUsWUFBWSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUN6QyxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQyxFQUFFLGNBQWMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDN0MsU0FBUztTQUNaLENBQUM7SUFDTixDQUFDO0NBQ0o7QUFuQ0QsMERBbUNDIn0=

package/dist/challengeProvider/challengeProviderTdx.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { ChallengeProvider } from './challengeProvider';
+import { Challenge, ChallengeType, Log } from '@super-protocol/pki-common';
+import { NvidiaVerifierMode } from '../challengeValidator/validatorConfig';
+export declare class ChallengeProviderTdx implements ChallengeProvider {
+    readonly logger?: Log | undefined;
+    private readonly challengeType;
+    private readonly nvidiaVerifier?;
+    constructor(logger?: Log | undefined, challengeType?: ChallengeType.TDX | ChallengeType.TDXGOOGLE, nvidiaVerifier?: NvidiaVerifierMode | undefined);
+    generateChallenge(userData: Buffer, networkID?: string): Promise<Challenge>;
+}

package/dist/challengeProvider/challengeProviderTdx.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeProviderTdx = void 0;
+const challengeNvidiaCCHelper_1 = require("./challengeNvidiaCCHelper");
+const pki_common_1 = require("@super-protocol/pki-common");
+class ChallengeProviderTdx {
+    logger;
+    challengeType;
+    nvidiaVerifier;
+    constructor(logger, challengeType = pki_common_1.ChallengeType.TDX, nvidiaVerifier) {
+        this.logger = logger;
+        this.challengeType = challengeType;
+        this.nvidiaVerifier = nvidiaVerifier;
+    }
+    async generateChallenge(userData, networkID) {
+        // This module depends on native library that cannot be compiled for all architectures / operating systems.
+        // That is why we load it dynamically and use only when it's really needed.
+        const { TeeNative } = await Promise.resolve().then(() => __importStar(require('@super-protocol/addons-tee')));
+        const { challengeData, nvidiaTokens, nvidiaEvidence } = await challengeNvidiaCCHelper_1.ChallengeNvidiaCCHelper.getTokenAndCombinedChallengeData(userData, this.logger, {
+            verifier: this.nvidiaVerifier,
+            challengeType: this.challengeType,
+        });
+        const dcapVerifyService = new TeeNative.DcapQuoteVerifyService();
+        const evidence = this.challengeType === pki_common_1.ChallengeType.TDXGOOGLE
+            ? await dcapVerifyService.generateSerializedTDXGCPEvidence(challengeData)
+            : await dcapVerifyService.generateSerializedTDXQemuEvidence(challengeData);
+        return {
+            type: this.challengeType,
+            evidenceBase64: evidence.toString('base64'),
+            ...(nvidiaTokens ? { nvidiaTokens } : {}),
+            ...(nvidiaEvidence ? { nvidiaEvidence } : {}),
+            networkID,
+        };
+    }
+}
+exports.ChallengeProviderTdx = ChallengeProviderTdx;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlUHJvdmlkZXJUZHguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhbGxlbmdlUHJvdmlkZXIvY2hhbGxlbmdlUHJvdmlkZXJUZHgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1RUFBb0U7QUFFcEUsMkRBQTJFO0FBRzNFLE1BQWEsb0JBQW9CO0lBRVQ7SUFDQztJQUdBO0lBTHJCLFlBQ29CLE1BQVksRUFDWCxnQkFFZSwwQkFBYSxDQUFDLEdBQUcsRUFDaEMsY0FBbUM7UUFKcEMsV0FBTSxHQUFOLE1BQU0sQ0FBTTtRQUNYLGtCQUFhLEdBQWIsYUFBYSxDQUVtQjtRQUNoQyxtQkFBYyxHQUFkLGNBQWMsQ0FBcUI7SUFDckQsQ0FBQztJQUVKLEtBQUssQ0FBQyxpQkFBaUIsQ0FDbkIsUUFBZ0IsRUFDaEIsU0FBa0I7UUFFbEIsMkdBQTJHO1FBQzNHLDJFQUEyRTtRQUMzRSxNQUFNLEVBQUUsU0FBUyxFQUFFLEdBQUcsd0RBQWEsNEJBQTRCLEdBQUMsQ0FBQztRQUVqRSxNQUFNLEVBQUUsYUFBYSxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsR0FDakQsTUFBTSxpREFBdUIsQ0FBQyxnQ0FBZ0MsQ0FDMUQsUUFBUSxFQUNSLElBQUksQ0FBQyxNQUFNLEVBQ1g7WUFDSSxRQUFRLEVBQUUsSUFBSSxDQUFDLGNBQWM7WUFDN0IsYUFBYSxFQUFFLElBQUksQ0FBQyxhQUFhO1NBQ3BDLENBQ0osQ0FBQztRQUVOLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxTQUFTLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztRQUVqRSxNQUFNLFFBQVEsR0FDVixJQUFJLENBQUMsYUFBYSxLQUFLLDBCQUFhLENBQUMsU0FBUztZQUMxQyxDQUFDLENBQUMsTUFBTSxpQkFBaUIsQ0FBQyxnQ0FBZ0MsQ0FDcEQsYUFBYSxDQUNoQjtZQUNILENBQUMsQ0FBQyxNQUFNLGlCQUFpQixDQUFDLGlDQUFpQyxDQUNyRCxhQUFhLENBQ2hCLENBQUM7UUFFWixPQUFPO1lBQ0gsSUFBSSxFQUFFLElBQUksQ0FBQyxhQUFhO1lBQ3hCLGNBQWMsRUFBRSxRQUFRLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQztZQUMzQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxFQUFFLFlBQVksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDekMsR0FBRyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsRUFBRSxjQUFjLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQzdDLFNBQVM7U0FDWixDQUFDO0lBQ04sQ0FBQztDQUNKO0FBOUNELG9EQThDQyJ9

package/dist/challengeProvider/challengeProviderToken.d.ts

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