@super-protocol/addons-tee 0.8.16 → 0.8.17-beta.2

package/dist/sgx-native-module/sev-snp-mrenclave.js

@@ -0,0 +1,290 @@
+"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.SNPMrEnclaveCalculator = void 0;
+const fs = __importStar(require("fs"));
+const fsAsync = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const sev_snp_1 = require("./sev-snp");
+const axios_1 = __importDefault(require("axios"));
+const sdk_js_1 = require("@super-protocol/sdk-js");
+const dto_js_1 = require("@super-protocol/dto-js");
+const crypto_1 = require("crypto");
+const stream_1 = require("stream");
+class VMConfigCache {
+    constructor(ttl = 5 * 60 * 1000) {
+        this.cache = {};
+        this.ttl = ttl;
+    }
+    set(key, value) {
+        const timestamp = Date.now();
+        this.cache[key] = {
+            value,
+            timestamp,
+        };
+    }
+    get(key, force = false) {
+        const record = this.cache[key];
+        if (record) {
+            if (force === false) {
+                const now = Date.now();
+                if (now - record.timestamp > this.ttl) {
+                    return null;
+                }
+            }
+            return record.value;
+        }
+        return null;
+    }
+    clear() {
+        this.cache = {};
+    }
+}
+class SNPMrEnclaveCalculator {
+    constructor(config) {
+        this.axiosInstance = axios_1.default.create();
+        this.defaultCredentials = {
+            token: "1UXqNMwov41q9TgHmyopNg5q2giQ8aTdh1gjKWKjfbWPFrcrnhenp6QZfd5ukyVnYXDx9Cok6RtnQMMnXmoZPrSUMNGZGF9KuLCzvRNmQYHowX14C2xAxtJeH6VCuNX39ist4bRE9L5VT3k41frDVh3cG1gZvsqh4EaDeaJyV6U4xVaqXqULnSb9PozqU97VVLWhfwdnj6XgUM59Wzq7yo7vn8RxwSyn8H74TEiLNGUPPA3frsYZuoqWQkNzbiYev5ByWeLro1TXo7DogD4WALCKfEmpwHs9j9rsX5WZvvZ13ourTiuZp5vTTZkByB2ibxUJqkSoZSpCNVtmDToNVKkMREVySe",
+        };
+        this.cacheFolder = config.cacheFolder || fs.mkdtempSync(path.join(os.tmpdir(), "snp-mrenclave-cache-"));
+        const rmPrevCache = config.rmPrevCache ?? false;
+        this.vmRepoOwner = config.vmRepoOwner || "Super-Protocol";
+        this.vmRepo = config.vmRepo || "sp-vm";
+        this.releaseAsset = config.releaseAsset || "vm.json";
+        this.retryInterval = config.downloadAssetRetryInterval ?? 1000;
+        this.retryMax = config.downloadAssetRetryMax ?? 3;
+        if ((config.storageCredentials && !config.storageType) || (!config.storageCredentials && config.storageType)) {
+            throw new Error("Both the StorageCredentials and StorageType parameters must either be passed or not passed");
+        }
+        this.storageCredentials = config.storageCredentials ?? this.defaultCredentials;
+        this.storageType = config.storageType ?? dto_js_1.StorageType.StorJ;
+        const cacheRecordsTTL = config.cacheRecordsTTL ?? 5 * 60 * 1000;
+        if (rmPrevCache && fs.existsSync(this.cacheFolder)) {
+            this.clearFileCache();
+        }
+        if (!fs.existsSync(this.cacheFolder)) {
+            fs.mkdirSync(this.cacheFolder, { recursive: true });
+        }
+        this.vmInfoCache = new VMConfigCache(cacheRecordsTTL);
+    }
+    clearFileCache() {
+        fs.rmSync(this.cacheFolder, {
+            recursive: true,
+            force: true,
+        });
+    }
+    /**
+     * The method allows to obtain expected mrenclave if the virtual machine for which the report is
+     * submitted was running on one core and a Milan processor
+     * @param report - @see CalcSnpMrEnclaveParams
+     */
+    async getSingleCoreMrEnclave(report) {
+        const mrEnclave = await sev_snp_1.SevSNP.getMrEnclave(report.report);
+        const vmMeasure = await this.downloadVM(report.build);
+        const expectedMrEnclave = await sev_snp_1.SevSNP.calcSnpMrEnclave({
+            ovmfPath: vmMeasure.ovmfFilePath,
+            kernelHash: vmMeasure.kernelHash,
+            initrdHash: vmMeasure.initrdHash,
+            cmdLineHash: report.cmdLineHash,
+            vcpuSig: report.cpuSig,
+            vcpuCount: report.cores,
+        });
+        if (!mrEnclave.equals(expectedMrEnclave))
+            throw new Error("Expected mrEnclave does not match the calculated one");
+        const singleCoreMrEnclave = await sev_snp_1.SevSNP.calcSnpMrEnclave({
+            ovmfPath: vmMeasure.ovmfFilePath,
+            kernelHash: vmMeasure.kernelHash,
+            initrdHash: vmMeasure.initrdHash,
+            cmdLineHash: report.cmdLineHash,
+            vcpuSig: sev_snp_1.SevSNP.getCpuSig(sev_snp_1.AMD_EPYC_MILAN_CPUINFO),
+            vcpuCount: 1,
+        });
+        return singleCoreMrEnclave;
+    }
+    async downloadAsset(assetUrl) {
+        const { retryInterval, retryMax } = this;
+        const response = await sdk_js_1.helpers.tryWithInterval({
+            checkResult(response) {
+                return { isResultOk: response.status === 200 };
+            },
+            handler: async () => {
+                return this.axiosInstance.get(assetUrl, {
+                    responseType: "arraybuffer",
+                });
+            },
+            checkError(err) {
+                if (axios_1.default.isAxiosError(err) && err.response) {
+                    const status = err.response.status;
+                    return { retryable: status < 400 || status >= 500 || status === 429 };
+                }
+                return { retryable: axios_1.default.isAxiosError(err) };
+            },
+            retryInterval,
+            retryMax,
+        });
+        return response.data;
+    }
+    extractVMData(data) {
+        const vm = JSON.parse(data.toString("utf-8"));
+        const kernelHash = vm.kernel?.sha256;
+        if (!kernelHash) {
+            throw new Error("kernel hash is missing");
+        }
+        const initrdHash = vm.initrd?.sha256;
+        const OVMF = vm.bios_amd || vm.bios;
+        if (!OVMF) {
+            throw new Error("Neither bios_amd nor bios is available");
+        }
+        const { sha256, bucket, prefix, filename } = OVMF;
+        if (!sha256 || !bucket || !prefix || !filename) {
+            throw new Error("Missing one or more required fields in OVMF");
+        }
+        return {
+            kernelHash: Buffer.from(kernelHash, "hex"),
+            initrdHash: initrdHash ? Buffer.from(initrdHash, "hex") : undefined,
+            ovmfHash: Buffer.from(sha256, "hex"),
+            ovmfBucket: bucket,
+            ovmfPrefix: prefix,
+            ovmfFilename: filename,
+        };
+    }
+    static calcHashStream(alg = "sha256") {
+        const hash = (0, crypto_1.createHash)(alg);
+        return {
+            process: new stream_1.Transform({
+                transform: (data, encoding, done) => {
+                    hash.update(data);
+                    done(null, data);
+                },
+            }),
+            get: () => hash.digest(),
+        };
+    }
+    static async fileExist(filePath) {
+        try {
+            await fsAsync.access(filePath);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async getAssetUrl(build) {
+        const { retryInterval, retryMax } = this;
+        const response = await sdk_js_1.helpers.tryWithInterval({
+            checkResult(response) {
+                return { isResultOk: response.status === 200 };
+            },
+            handler: async () => {
+                return this.axiosInstance.get(`https://api.github.com/repos/${this.vmRepoOwner}/${this.vmRepo}/releases/tags/${build}`);
+            },
+            checkError(err) {
+                if (axios_1.default.isAxiosError(err) && err.response) {
+                    const status = err.response.status;
+                    return { retryable: status < 400 || status >= 500 || status === 429 };
+                }
+                return { retryable: axios_1.default.isAxiosError(err) };
+            },
+            retryInterval,
+            retryMax,
+        });
+        const { data } = response;
+        const asset = data.assets.find((asset) => asset.name === this.releaseAsset);
+        return asset.browser_download_url;
+    }
+    async downloadVM(build) {
+        let fromCache = false;
+        let vmFiles;
+        const vmInfo = this.vmInfoCache.get(build);
+        if (vmInfo) {
+            fromCache = true;
+            vmFiles = vmInfo;
+        }
+        else {
+            try {
+                const assetUrl = await this.getAssetUrl(build);
+                const vm = await this.downloadAsset(assetUrl);
+                vmFiles = this.extractVMData(vm);
+            }
+            catch (error) {
+                const vmInfo = this.vmInfoCache.get(build, true);
+                if (vmInfo) {
+                    fromCache = true;
+                    vmFiles = vmInfo;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        const ovmfPath = path.join(this.cacheFolder, `${vmFiles.ovmfHash.toString("hex")}_OVMF.fd`);
+        let fileExistAndCorrect = false;
+        if (await SNPMrEnclaveCalculator.fileExist(ovmfPath)) {
+            const fileStream = fs.createReadStream(ovmfPath);
+            const hash = await sdk_js_1.Crypto.createHash(fileStream, {
+                algo: dto_js_1.HashAlgorithm.SHA256,
+                encoding: dto_js_1.Encoding.hex,
+            });
+            if (vmFiles.ovmfHash.toString("hex") === hash.hash) {
+                fileExistAndCorrect = true;
+            }
+        }
+        if (fileExistAndCorrect !== true) {
+            await this.downloadOvmf(vmFiles, ovmfPath);
+        }
+        if (fromCache !== true) {
+            this.vmInfoCache.set(build, vmFiles);
+        }
+        return {
+            initrdHash: vmFiles.initrdHash,
+            kernelHash: vmFiles.kernelHash,
+            ovmfFilePath: ovmfPath,
+        };
+    }
+    async downloadOvmf(vmFiles, ovmfPath) {
+        const credentials = {
+            ...this.storageCredentials,
+            bucket: vmFiles.ovmfBucket,
+            prefix: vmFiles.ovmfPrefix.endsWith("/") ? vmFiles.ovmfPrefix : `${vmFiles.ovmfPrefix}/`,
+        };
+        const access = {
+            storageType: this.storageType,
+            credentials,
+        };
+        const storageProvider = (0, sdk_js_1.getStorageProvider)(access);
+        const downloaderStream = await storageProvider.downloadFile(vmFiles.ovmfFilename, {});
+        const { process: hashStream, get: getStreamHash } = SNPMrEnclaveCalculator.calcHashStream("sha256");
+        await stream_1.promises.pipeline(downloaderStream, hashStream, fs.createWriteStream(ovmfPath));
+        if (!vmFiles.ovmfHash.equals(getStreamHash())) {
+            throw new Error("The downloaded OVMF-file does not match the expected checksum");
+        }
+    }
+}
+exports.SNPMrEnclaveCalculator = SNPMrEnclaveCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sev-snp-mrenclave.js","sourceRoot":"","sources":["../../src/sgx-native-module/sev-snp-mrenclave.ts"],"names":[],"mappings":"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"}

package/dist/sgx-native-module/sev-snp.d.ts

@@ -0,0 +1,134 @@
+/// <reference types="node" />
+import { CpuInfo } from "../../bindings/amd-sev-snp-napi-rs/";
+import { CertificateFormat } from "./pki.service";
+export declare enum SupportedAmdSevSnpGenerations {
+    Milan = "Milan",
+    Genoa = "Genoa"
+}
+export declare enum SevSNPCertType {
+    ARK = "ARK",
+    ASK = "ASK",
+    VCEK = "VCEK"
+}
+export interface SnpCert {
+    type: SevSNPCertType;
+    cert: Buffer | string;
+    format: CertificateFormat;
+}
+export interface SNPReport {
+    report: Buffer;
+    cpuSig: number;
+    cores: number;
+    cmdLineHash: Buffer;
+    build: string;
+}
+export interface SNPReportWithChain extends SNPReport {
+    certs: SnpCert[];
+}
+export interface CalcSnpMrEnclaveParams {
+    ovmfPath: string;
+    kernelHash: Buffer;
+    initrdHash?: Buffer;
+    cmdLineHash: Buffer;
+    vcpuSig: number;
+    vcpuCount: number;
+    vmpl?: number;
+    policy?: bigint;
+}
+export declare const AMD_EPYC_MILAN_CPUINFO: CpuInfo;
+export declare const EMPTY_INITRD_SHA256_HASH: Buffer;
+export type ArkHashes = {
+    [key: string]: Buffer;
+};
+export declare const ARK_MILAN = "-----BEGIN CERTIFICATE-----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\nAFZEAwoKCQ==\n-----END CERTIFICATE-----";
+export declare const ARK_GENOA = "-----BEGIN CERTIFICATE-----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\n/wMz1R1BHg==\n-----END CERTIFICATE-----";
+export declare function getDefaultArkHashes(): ArkHashes;
+export declare class SevSNP {
+    static serializeSNPReport(report: SNPReportWithChain): Buffer;
+    static deserializeSNPReport(serialized: Buffer): SNPReportWithChain;
+    protected static convertCertToPem(cert: Buffer): string;
+    protected static convertPemToDer(cert: string): Buffer;
+    protected static splitCerts(certsPem: string): string[];
+    protected static readCmdLine(): Promise<string>;
+    /**
+     * Method for generation AMD SEV-SNP Report
+     * @param userData - The data that will be included in the report and will be signed
+     */
+    static generateSNPReport(userData: Buffer): Promise<SNPReport>;
+    /**
+     * Method for fetch certificates from AMD KDS
+     * @param report - report generated by the `generateSNPReport` method
+     * @param options - options for working with HTTP, allows you to configure repetitions and the interval between them,
+     *                  as well as the format of the returned certificates
+     */
+    static getReportChain(report: SNPReport, options?: {
+        retryMax?: number;
+        retryInterval?: number;
+        certFormat?: CertificateFormat;
+    }): Promise<SnpCert[]>;
+    /**
+     * Method for generation AMD SEV-SNP Report and fetching certificates
+     * @param userData - @see generateSNPReport
+     * @param options - @see getReportChain
+     */
+    static generateSNPReportWithChain(userData: Buffer, options?: {
+        retryMax?: number;
+        retryInterval?: number;
+        certFormat?: CertificateFormat;
+    }): Promise<SNPReportWithChain>;
+    protected static runSubProcess(binaryPath: string, args?: string[], options?: {
+        cwd?: string;
+        timeoutMs?: number;
+    }): Promise<{
+        exitCode: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    static getCertHash(cert: SnpCert): Buffer;
+    protected static isValidArk(ARK: SnpCert, trustedHashes: ArkHashes): boolean;
+    /**
+     * AMD SEV-SNP verification method
+     * @param report - report with full certificate chain
+     * @param options - trustedHashes - map of trusted AMD ARK Certificates (CommonName as Key, Sha256 Hash of Der Certificate as Value) - optional
+     *                  timeoutMs - timeout of the utility snpnost in ms
+     *                  snpGuestBinaryPath - path for snpguest util
+     */
+    static verifyReport(report: SNPReportWithChain, options?: {
+        trustedHashes?: ArkHashes;
+        timeoutMs?: number;
+        snpGuestBinaryPath?: string;
+        tmpDir?: string;
+    }): Promise<void>;
+    protected static calcMrEnclave(measure: Buffer, vmpl: number, policy: bigint): Buffer;
+    /**
+     * Method for obtaining mrEnclave from report. MrEnclave includes report measure, report vmpl and report policy
+     * @param report - report without certificates
+     */
+    static getMrEnclave(report: Buffer): Buffer;
+    /**
+     * Method for obtaining reportData. This data was passed when generating the report
+     * @param report - report without certificates
+     */
+    static getReportData(report: Buffer): Promise<Buffer>;
+    /**
+     * Method for obtaining measure. Please do not confuse with mrenclave. Report measure is part of mrEnclave.
+     * @param report - report without certificates
+     */
+    static getReportMeasure(report: Buffer): Promise<Buffer>;
+    protected static calculateFileSha256(filePath: string): Promise<Buffer>;
+    protected static calculateCmdlineHash(cmdLine: string): Buffer;
+    /**
+     * The method allows to get the expected mrEnclave without generating a report
+     * @param params - @see CalcSnpMrEnclaveParams
+     */
+    static calcSnpMrEnclave(params: CalcSnpMrEnclaveParams): Promise<Buffer>;
+    protected static extractBuildFromCmdline(cmdLine: string, paramName?: string): string;
+    /**
+     * Compute the 32-bit CPUID signature from family, model, and stepping.
+     * This computation is described in AMD's CPUID Specification, publication #25481
+     * https://www.amd.com/system/files/TechDocs/25481.pdf
+     * See section: CPUID Fn0000_0001_EAX Family, Model, Stepping Identifiers
+     * @param cpuInfo - Structure containing family, model and stepping @see CpuInfo
+     */
+    static getCpuSig(cpuInfo: CpuInfo): number;
+}