@super-protocol/addons-tee 2.0.0 → 2.0.1

package/dist/sgx-native-module/pki.service.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PkiService = exports.ECPCurve = exports.CertificateFormat = exports.CertificateKeyType = void 0;
+const { CryptoPrimitives } = require("../../bindings/sgx-native/build/Release/sgx_native.node");
+var CertificateKeyType;
+(function (CertificateKeyType) {
+    CertificateKeyType["RSA"] = "RSA";
+    CertificateKeyType["ECP"] = "ECP";
+})(CertificateKeyType || (exports.CertificateKeyType = CertificateKeyType = {}));
+var CertificateFormat;
+(function (CertificateFormat) {
+    CertificateFormat["PEM"] = "PEM";
+    CertificateFormat["DER"] = "DER";
+})(CertificateFormat || (exports.CertificateFormat = CertificateFormat = {}));
+var ECPCurve;
+(function (ECPCurve) {
+    ECPCurve["SECP192R1"] = "SECP192R1"; /*!< Domain parameters for the 192-bit curve defined by FIPS 186-4 and SEC1. */
+    ECPCurve["SECP224R1"] = "SECP224R1"; /*!< Domain parameters for the 224-bit curve defined by FIPS 186-4 and SEC1. */
+    ECPCurve["SECP256R1"] = "SECP256R1"; /*!< Domain parameters for the 256-bit curve defined by FIPS 186-4 and SEC1. */
+    ECPCurve["SECP384R1"] = "SECP384R1"; /*!< Domain parameters for the 384-bit curve defined by FIPS 186-4 and SEC1. */
+    ECPCurve["SECP521R1"] = "SECP521R1"; /*!< Domain parameters for the 521-bit curve defined by FIPS 186-4 and SEC1. */
+    ECPCurve["BP256R1"] = "BP256R1"; /*!< Domain parameters for 256-bit Brainpool curve. */
+    ECPCurve["BP384R1"] = "BP384R1"; /*!< Domain parameters for 384-bit Brainpool curve. */
+    ECPCurve["BP512R1"] = "BP512R1"; /*!< Domain parameters for 512-bit Brainpool curve. */
+    // @TODO: MBEDTLS NOT SUPPORT EXRPORT CURVE25519 = "CURVE25519", /*!< Domain parameters for Curve25519. */
+    ECPCurve["SECP192K1"] = "SECP192K1"; /*!< Domain parameters for 192-bit "Koblitz" curve. */
+    ECPCurve["SECP224K1"] = "SECP224K1"; /*!< Domain parameters for 224-bit "Koblitz" curve. */
+    ECPCurve["SECP256K1"] = "SECP256K1"; /*!< Domain parameters for 256-bit "Koblitz" curve. */
+    // @TODO: MBEDTLS NOT SUPPORT EXRPORT    CURVE448 = "CURVE448",     /*!< Domain parameters for Curve448. */
+})(ECPCurve || (exports.ECPCurve = ECPCurve = {}));
+class PkiService {
+    constructor() {
+        this.cryptoPrimitives = new CryptoPrimitives();
+    }
+    async generateTlsCertificate(params = {}) {
+        const subject = {
+            commonName: params.subject?.commonName ?? "localhost",
+            countryName: params.subject?.countryName ?? "US",
+            state: params.subject?.state ?? "New York",
+            localityName: params.subject?.localityName ?? "New York",
+            organizationName: params.subject?.organizationName ?? "SuperProtocol",
+            organizationUnit: params.subject?.organizationUnit ?? "TEE",
+        };
+        const format = params.format ?? CertificateFormat.PEM;
+        const keyType = params.keyType ?? CertificateKeyType.RSA;
+        let rsaKeyBits;
+        let ecpCurve;
+        if (keyType === CertificateKeyType.RSA) {
+            rsaKeyBits = params.rsaKeyBits ?? 3072;
+        }
+        else if (keyType === CertificateKeyType.ECP) {
+            ecpCurve = params.ecpCurve ?? ECPCurve.SECP384R1;
+        }
+        const withQuote = params.withQuote ?? false;
+        const serialNumber = params.serialNumber ?? "01";
+        const days = params.days ?? 365;
+        const dnsNames = params.dnsNames ?? [];
+        const ips = params.ips ?? [];
+        return this.cryptoPrimitives.GenerateTlsCertificate({
+            format,
+            subject,
+            keyType,
+            withQuote,
+            rsaKeyBits,
+            ecpCurve,
+            serialNumber,
+            days,
+            dnsNames,
+            ips,
+        });
+    }
+}
+exports.PkiService = PkiService;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { StorageAccess } from "@super-protocol/sdk-js";
+import { Transform } from "stream";
+import { SNPReport } from "../proto/AmdSevSnp";
+interface VMCommon {
+    kernelHash: Buffer;
+    initrdHash: Buffer | undefined;
+    ovmfHash: Buffer;
+}
+interface VMConfig extends VMCommon {
+    ovmfBucket: string;
+    ovmfPrefix: string;
+    ovmfFilename: string;
+}
+interface VMMeasure extends VMCommon {
+    ovmfFilePath: string;
+}
+export interface SNPMrEnclaveCalculatorArgs {
+    cacheFolder?: string;
+    rmPrevCache?: boolean;
+    vmRepoOwner?: string;
+    vmRepo?: string;
+    releaseAsset?: string;
+    downloadAssetRetryInterval?: number;
+    downloadAssetRetryMax?: number;
+    storageAccess?: StorageAccess;
+    cacheRecordsTTL?: number;
+}
+export declare class SNPMrEnclaveCalculator {
+    private readonly cacheFolder;
+    private readonly vmRepoOwner;
+    private readonly vmRepo;
+    private readonly releaseAsset;
+    private readonly axiosInstance;
+    private readonly retryInterval;
+    private readonly retryMax;
+    private readonly storageAccess;
+    private readonly vmInfoCache;
+    private readonly defaultCredentials;
+    constructor(config: SNPMrEnclaveCalculatorArgs);
+    /**
+     * 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
+     */
+    getSingleCoreMrEnclave(report: SNPReport): Promise<Buffer>;
+    protected downloadAsset(assetUrl: string): Promise<Buffer>;
+    protected extractVMData(data: Buffer): VMConfig;
+    protected static calcHashStream(alg?: string): {
+        process: Transform;
+        get: () => Buffer;
+    };
+    protected static fileExist(filePath: string): Promise<boolean>;
+    protected getAssetUrl(build: string): Promise<string>;
+    protected downloadVM(build: string): Promise<VMMeasure>;
+    protected downloadOvmf(vmFiles: VMConfig, ovmfPath: string): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,322 @@
+"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 typebox_1 = require("@sinclair/typebox");
+const value_1 = require("@sinclair/typebox/value");
+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");
+const helpers_1 = require("./helpers");
+const amd_sev_snp_napi_rs_1 = require("../../bindings/amd-sev-snp-napi-rs/");
+const VMJsonSchema = typebox_1.Type.Object({
+    kernel: typebox_1.Type.Object({ sha256: typebox_1.Type.String() }),
+    initrd: typebox_1.Type.Optional(typebox_1.Type.Object({ sha256: typebox_1.Type.String() })),
+    bios_amd: typebox_1.Type.Optional(typebox_1.Type.Object({
+        sha256: typebox_1.Type.String(),
+        bucket: typebox_1.Type.String(),
+        prefix: typebox_1.Type.String(),
+        filename: typebox_1.Type.String(),
+    })),
+    bios: typebox_1.Type.Optional(typebox_1.Type.Object({
+        sha256: typebox_1.Type.String(),
+        bucket: typebox_1.Type.String(),
+        prefix: typebox_1.Type.String(),
+        filename: typebox_1.Type.String(),
+    })),
+});
+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 = {
+            storageType: dto_js_1.StorageType.S3,
+            credentials: {
+                endpoint: "https://gateway.storjshare.io",
+                accessKeyId: "jxekrow2wxmjps6pr2jv22hamtha",
+                secretKey: "jztnpl532njcljtdolnpbszq66lgqmwmgkbh747342hwc72grkohi",
+                // prefix and bucket can be any, as it will be filled later
+                bucket: "",
+                prefix: "",
+            },
+        };
+        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;
+        this.storageAccess = config.storageAccess ?? this.defaultCredentials;
+        const cacheRecordsTTL = config.cacheRecordsTTL ?? 5 * 60 * 1000;
+        if (rmPrevCache) {
+            (0, helpers_1.gramineCompatibleRmDir)(this.cacheFolder);
+        }
+        if (!fs.existsSync(this.cacheFolder)) {
+            fs.mkdirSync(this.cacheFolder, { recursive: true });
+        }
+        this.vmInfoCache = new VMConfigCache(cacheRecordsTTL);
+    }
+    /**
+     * 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(Buffer.from(report.rawReport));
+        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: Buffer.from(report.cmdLineHash),
+            vcpuSig: report.cpuSig,
+            vcpuCount: report.cores,
+            vmpl: await (0, amd_sev_snp_napi_rs_1.getReportVmpl)(Buffer.from(report.rawReport)),
+            policy: await (0, amd_sev_snp_napi_rs_1.getReportPolicy)(Buffer.from(report.rawReport)),
+        });
+        if (!mrEnclave.equals(expectedMrEnclave))
+            throw new Error(`Expected mrEnclave does not match the calculated one.\n` +
+                `mrEnclave: ${mrEnclave.toString("hex")}\n` +
+                `expectedMrEnclave: ${expectedMrEnclave.toString("hex")}\n` +
+                `report.build: ${report.build}\n` +
+                `vmMeasure: ${JSON.stringify(vmMeasure)}`);
+        const singleCoreMrEnclave = await sev_snp_1.SevSNP.calcSnpMrEnclave({
+            ovmfPath: vmMeasure.ovmfFilePath,
+            kernelHash: vmMeasure.kernelHash,
+            initrdHash: vmMeasure.initrdHash,
+            cmdLineHash: Buffer.from(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 vmRaw = data.toString("utf-8");
+        const parsed = JSON.parse(vmRaw);
+        const { isValid } = (0, sdk_js_1.validateBySchema)(parsed, VMJsonSchema);
+        if (!isValid) {
+            const validationErrors = Array.from(value_1.Value.Errors(VMJsonSchema, parsed));
+            const details = validationErrors.map((e) => e.message).join(", ");
+            throw new Error(`Failed to validate VM JSON:${details ? `: ${details}` : ""}`);
+        }
+        const vm = parsed;
+        const kernelHash = vm.kernel.sha256;
+        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, fs.constants.F_OK);
+            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);
+        if (!asset) {
+            throw new Error(`Failed to find asset named ${this.releaseAsset} for build ${build}.`);
+        }
+        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,
+            ovmfHash: vmFiles.ovmfHash,
+        };
+    }
+    async downloadOvmf(vmFiles, ovmfPath) {
+        const access = {
+            ...this.storageAccess,
+            credentials: {
+                ...this.storageAccess.credentials,
+                bucket: vmFiles.ovmfBucket,
+                prefix: vmFiles.ovmfPrefix.endsWith("/") ? vmFiles.ovmfPrefix : `${vmFiles.ovmfPrefix}/`,
+            },
+        };
+        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-schema.d.ts

@@ -0,0 +1,22 @@
+import { Static, TLiteral } from "@sinclair/typebox";
+import { ImportantSecurityFields } from "../../bindings/amd-sev-snp-napi-rs";
+export declare const CommonPolicyKeyName = "Common";
+export declare const importantFieldNames: (keyof ImportantSecurityFields)[];
+export declare enum RuleOperator {
+    Le = "le",
+    Eq = "eq",
+    Ge = "ge"
+}
+declare const PolicyRuleSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TUnion<[TLiteral<string>, ...TLiteral<string>[]]>;
+    operator: import("@sinclair/typebox").TUnion<TLiteral<RuleOperator>[]>;
+    value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TBoolean]>;
+}>;
+export declare const PolicySetSchema: import("@sinclair/typebox").TObject<{
+    [x: string]: any;
+}>;
+export type PolicySet = Static<typeof PolicySetSchema>;
+export type PolicyRule = Static<typeof PolicyRuleSchema> & {
+    name: keyof ImportantSecurityFields;
+};
+export {};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicySetSchema = exports.RuleOperator = exports.importantFieldNames = exports.CommonPolicyKeyName = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const amd_sev_snp_napi_rs_1 = require("../../bindings/amd-sev-snp-napi-rs");
+exports.CommonPolicyKeyName = "Common";
+exports.importantFieldNames = Object.keys(amd_sev_snp_napi_rs_1.IMPORTANT_SECURITY_FIELDS_DUMMY);
+const importantFieldLiterals = exports.importantFieldNames.map((k) => typebox_1.Type.Literal(k));
+var RuleOperator;
+(function (RuleOperator) {
+    RuleOperator["Le"] = "le";
+    RuleOperator["Eq"] = "eq";
+    RuleOperator["Ge"] = "ge";
+})(RuleOperator || (exports.RuleOperator = RuleOperator = {}));
+const PolicyRuleSchema = typebox_1.Type.Object({
+    name: typebox_1.Type.Union(importantFieldLiterals),
+    operator: typebox_1.Type.Union(Object.values(RuleOperator).map((op) => typebox_1.Type.Literal(op))),
+    value: typebox_1.Type.Union([typebox_1.Type.Number(), typebox_1.Type.Boolean()]),
+});
+exports.PolicySetSchema = typebox_1.Type.Partial(typebox_1.Type.Object(Object.fromEntries([
+    ...Object.values(amd_sev_snp_napi_rs_1.WellKnownSnpCodeNames).map((key) => [key, typebox_1.Type.Array(PolicyRuleSchema)]),
+    [exports.CommonPolicyKeyName, typebox_1.Type.Array(PolicyRuleSchema)],
+])), { additionalProperties: false });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V2LXNucC1zY2hlbWEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2d4LW5hdGl2ZS1tb2R1bGUvc2V2LXNucC1zY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0NBQTJEO0FBQzNELDRFQUk0QztBQUUvQixRQUFBLG1CQUFtQixHQUFHLFFBQVEsQ0FBQztBQUUvQixRQUFBLG1CQUFtQixHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMscURBQStCLENBQXNDLENBQUM7QUFFckgsTUFBTSxzQkFBc0IsR0FBRywyQkFBbUIsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLGNBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBRzVFLENBQUM7QUFFRixJQUFZLFlBSVg7QUFKRCxXQUFZLFlBQVk7SUFDcEIseUJBQVMsQ0FBQTtJQUNULHlCQUFTLENBQUE7SUFDVCx5QkFBUyxDQUFBO0FBQ2IsQ0FBQyxFQUpXLFlBQVksNEJBQVosWUFBWSxRQUl2QjtBQUVELE1BQU0sZ0JBQWdCLEdBQUcsY0FBSSxDQUFDLE1BQU0sQ0FBQztJQUNqQyxJQUFJLEVBQUUsY0FBSSxDQUFDLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQztJQUN4QyxRQUFRLEVBQUUsY0FBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsY0FBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQy9FLEtBQUssRUFBRSxjQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsY0FBSSxDQUFDLE1BQU0sRUFBRSxFQUFFLGNBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO0NBQ3JELENBQUMsQ0FBQztBQUVVLFFBQUEsZUFBZSxHQUFHLGNBQUksQ0FBQyxPQUFPLENBQ3ZDLGNBQUksQ0FBQyxNQUFNLENBQ1AsTUFBTSxDQUFDLFdBQVcsQ0FBQztJQUNmLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQywyQ0FBcUIsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLEVBQUUsY0FBSSxDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7SUFDekYsQ0FBQywyQkFBbUIsRUFBRSxjQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLENBQUM7Q0FDdEQsQ0FBQyxDQUNMLEVBQ0QsRUFBRSxvQkFBb0IsRUFBRSxLQUFLLEVBQUUsQ0FDbEMsQ0FBQyJ9

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

@@ -0,0 +1,127 @@
+/// <reference types="node" />
+import { CpuInfo, ImportantSecurityFields, WellKnownSnpCodeNames } from "../../bindings/amd-sev-snp-napi-rs/";
+import { SnpCert, SevSnpCertificateFormat, SNPReport, SNPReportWithChain } from "../proto/AmdSevSnp";
+import { PolicySet } from "./sev-snp-schema";
+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 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
+     * @param vmpl - Optional VMPL value to pass to the firmware when requesting a report (default: 0)
+     */
+    static generateSNPReport(userData: Buffer, vmpl?: number): 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?: SevSnpCertificateFormat;
+        httpTimeoutMs?: number;
+    }): 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?: SevSnpCertificateFormat;
+    }): 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;
+        tmpDirTemplate?: 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;
+    static getReportImportantSecurityFields(report: Buffer): Promise<ImportantSecurityFields>;
+    static getReportCpuInfo(report: Buffer): Promise<CpuInfo>;
+    static getCpuGeneration(cpuInfo: CpuInfo): Promise<WellKnownSnpCodeNames>;
+    /**
+     * Parse and validate policy
+     * @param input - Raw policy as json-text or object
+     */
+    static parsePolicySet(input: string | Record<string, unknown>): PolicySet;
+    private static checkRule;
+    /**
+     * Verify SNP report against a PolicySet.
+     * Throws an error if any rule fails.
+     * @param report - SNPReport
+     * @param policySet - PolicySet containing rules
+     */
+    static verifyPolicy(report: Buffer, policySet: PolicySet): Promise<void>;
+}