@eqtylab/explorer 0.0.0

package/src/v-comp-viewer/components/system-did-details.tsx

@@ -0,0 +1,356 @@
+import Details from "@/components/ui/details";
+import { SectionList, SectionInnerTitle } from "@/explorer-component/components/sidebar/SectionList";
+import { VCompSystemInfo, UploadVerification } from "@/v-comp-viewer/utils";
+import CertificateCode from "@/components/ui/certificate-code";
+import CertificateChain from "@/components/ui/certificate-chain";
+import DisplayCode from "@/components/ui/display-code";
+
+interface SystemDidDetailsProps {
+    systemInfo: VCompSystemInfo;
+    vCompVerifyData: UploadVerification | null;
+}
+
+const SystemDidDetails = ({ systemInfo, vCompVerifyData }: SystemDidDetailsProps) => {
+    const showIntelHeading =
+        systemInfo.cpu.measurements.mrtd.value ||
+        systemInfo.cpu.measurements.rtmr0.value ||
+        systemInfo.cpu.measurements.rtmr1.value ||
+        systemInfo.cpu.measurements.rtmr2.value ||
+        systemInfo.cpu.measurements.rootfs.value;
+
+    const showAzureUKI =
+        vCompVerifyData &&
+        (vCompVerifyData.azureUKIPcrLog ||
+            vCompVerifyData.azureUKIKernel ||
+            vCompVerifyData.azureUKICmdLine ||
+            vCompVerifyData.azureUKIRootFSHash ||
+            vCompVerifyData.azureUKIInitRDLate ||
+            vCompVerifyData.azureUKIPcr.value ||
+            vCompVerifyData.azureUKIPcrHash.value);
+
+    const intelData = [
+        {
+            value: showIntelHeading && <SectionInnerTitle title="Intel TDX Measurement" />,
+        },
+        {
+            label: "MRTD",
+            value: (
+                <DisplayCode
+                    value={`sha384:${systemInfo.cpu.measurements.mrtd.value}`}
+                    validated={systemInfo.cpu.measurements.mrtd.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "RTMR 0",
+            value: (
+                <DisplayCode
+                    value={`sha384:${systemInfo.cpu.measurements.rtmr0.value}`}
+                    validated={systemInfo.cpu.measurements.rtmr0.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "RTMR 1",
+            value: (
+                <DisplayCode
+                    value={`sha384:${systemInfo.cpu.measurements.rtmr1.value}`}
+                    validated={systemInfo.cpu.measurements.rtmr1.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "RTMR 2",
+            value: (
+                <DisplayCode
+                    value={`sha384:${systemInfo.cpu.measurements.rtmr2.value}`}
+                    validated={systemInfo.cpu.measurements.rtmr2.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "User data",
+            value: (
+                <DisplayCode
+                    value={`sha256:${systemInfo.cpu.measurements.rootfs.value}`}
+                    validated={systemInfo.cpu.measurements.rootfs.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+    ];
+
+    const cpuAttestationData = [
+        {
+            value: <SectionInnerTitle title="CPU Attestation" />,
+        },
+        {
+            label: "Attestation Report",
+            value: systemInfo.cpu.report.value && (
+                <CertificateCode code={systemInfo.cpu.report.value} validated={systemInfo.cpu.report.validated} />
+            ),
+        },
+        {
+            label: "X509 Chain",
+            value: systemInfo.cpu.certificate.x509 && (
+                <CertificateCode
+                    code={systemInfo.cpu.certificate.x509}
+                    validated={systemInfo.cpu.certificate.validated}
+                />
+            ),
+        },
+        {
+            value: systemInfo.cpu.certificate.chain && (
+                <Details
+                    title="Certificate Chain"
+                    content={<CertificateChain chainItems={systemInfo.cpu.certificate.chain} />}
+                />
+            ),
+        },
+    ];
+
+    const nvidiaData = [
+        {
+            value: <SectionInnerTitle title="NVIDIA Hardware Attestation" />,
+        },
+        {
+            label: "Measurement",
+            value: systemInfo.gpu.reportData && <DisplayCode value={`hash:${systemInfo.gpu.reportData}`} />,
+            offsetTopLabel: true,
+        },
+        {
+            label: "Attestation Report",
+            value: systemInfo.gpu.report.value && (
+                <CertificateCode code={systemInfo.gpu.report.value} validated={systemInfo.gpu.report.validated} />
+            ),
+        },
+        {
+            label: "X509 Chain",
+            value: systemInfo.gpu.certificate.x509.value && (
+                <CertificateCode
+                    code={systemInfo.gpu.certificate.x509.value as unknown as string}
+                    validated={systemInfo.gpu.certificate.x509.validated}
+                />
+            ),
+        },
+    ];
+
+    const gpuCertificateData = [
+        {
+            value: systemInfo.gpu.certificate.chain && (
+                <Details
+                    innerClassName="data-[state=open]:border-none"
+                    title="Certificate Chain"
+                    content={<CertificateChain chainItems={systemInfo.gpu.certificate.chain} />}
+                />
+            ),
+        },
+    ];
+
+    const linuxData = [
+        {
+            value: <SectionInnerTitle title="Linux Unified Kernel Image (UKI)" />,
+        },
+        {
+            label: "PCR Log (Calculated)",
+            value: vCompVerifyData?.azureUKIPcrLog && <CertificateCode code={vCompVerifyData?.azureUKIPcrLog} />,
+        },
+        {
+            label: "Linux Kernel",
+            value: vCompVerifyData?.azureUKIKernel && (
+                <DisplayCode value={`sha384:${vCompVerifyData.azureUKIKernel}`} />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Kernel Argument (Append)",
+            value: vCompVerifyData?.azureUKICmdLine && (
+                <DisplayCode value={`sha384:${vCompVerifyData.azureUKICmdLine}`} />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Root FS Hash",
+            value: vCompVerifyData?.azureUKIRootFSHash && (
+                <DisplayCode value={`sha384:${vCompVerifyData.azureUKIRootFSHash}`} />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Initial RAM Disk",
+            value: vCompVerifyData?.azureUKIInitRDLate && (
+                <DisplayCode value={`sha384:${vCompVerifyData.azureUKIInitRDLate}`} />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Extended PCR 11",
+            value: vCompVerifyData?.azureUKIPcr.value && (
+                <DisplayCode value={`sha384:${vCompVerifyData.azureUKIPcr.value}`} />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Hash for PCR 11",
+            value: vCompVerifyData?.azureUKIPcrHash.value && (
+                <DisplayCode
+                    value={`sha256:${vCompVerifyData.azureUKIPcrHash.value}`}
+                    validated={vCompVerifyData.azureUKIPcrHash.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+    ];
+
+    const azureData = [
+        {
+            value: <SectionInnerTitle title="Azure vTPM Measurement" />,
+        },
+        {
+            label: "Hash of PCR",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`sha384:${systemInfo.azure.tpmPCRHash.value}`}
+                    validated={systemInfo.azure.tpmPCRHash.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Notary Key Hex",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`sha384:${systemInfo.azure.tpmNotaryHex.value}`}
+                    validated={systemInfo.azure.tpmNotaryHex.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Notary Key DID",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`did:key:${systemInfo.azure.tpmNotaryDID.value}`}
+                    validated={systemInfo.azure.tpmNotaryDID.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            value: <SectionInnerTitle title="Azure vTPM Verification" />,
+        },
+        {
+            label: "TPM AK Certificate",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <CertificateCode
+                    code={systemInfo.azure.tpmAKCertificate.value as unknown as string}
+                    validated={systemInfo.azure.tpmAKCertificate.validated}
+                />
+            ),
+        },
+        {
+            label: "vTPM Quote",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <CertificateCode
+                    code={systemInfo.azure.tpmQuote.value as unknown as string}
+                    validated={systemInfo.azure.tpmQuote.validated}
+                />
+            ),
+        },
+        {
+            label: "vTPM Signature",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <CertificateCode
+                    code={systemInfo.azure.tpmQuoteSignature.value as unknown as string}
+                    validated={systemInfo.azure.tpmQuoteSignature.validated}
+                />
+            ),
+        },
+        {
+            label: "vTPM Public Key",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`hex:${systemInfo.azure.azureAKTPMPubKey.value}`}
+                    validated={systemInfo.azure.azureAKTPMPubKey.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            value: <SectionInnerTitle title="Azure Boot Log Verification" />,
+        },
+        {
+            label: "vTPM AK Key",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`hex:${systemInfo.azure.azureTPMAKKey.value}`}
+                    validated={systemInfo.azure.azureTPMAKKey.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Azure Boot Logs",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <CertificateCode code={systemInfo.azure.bootLog.value as unknown as string} />
+            ),
+        },
+        {
+            label: "Azure Boot Log Hash",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`sha256:${systemInfo.azure.bootLogHash.value}`}
+                    validated={systemInfo.azure.bootLogHash.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+    ];
+
+    const amdData = [
+        {
+            value: <SectionInnerTitle title="AMD SEV-SNP Measurement" />,
+        },
+        {
+            label: "Measurement",
+            value: systemInfo.azure.tpmPCRHash.value && (
+                <DisplayCode
+                    value={`hash:${systemInfo.cpu.measurements.amdMeasurement.value}`}
+                    validated={systemInfo.cpu.measurements.amdMeasurement.validated}
+                />
+            ),
+            offsetTopLabel: true,
+        },
+        {
+            label: "Report Data",
+            value: systemInfo.cpu.measurements.amdReportData && (
+                <DisplayCode value={`hash:${systemInfo.cpu.measurements.amdReportData}`} />
+            ),
+            offsetTopLabel: true,
+        },
+    ];
+
+    const data = [
+        ...(systemInfo.cpu.type === "azure" && showAzureUKI ? linuxData : []),
+        ...(systemInfo.cpu.type === "azure" ? azureData : []),
+        ...(systemInfo.cpu.type !== "amd" && showIntelHeading ? intelData : []),
+        ...(systemInfo.cpu.type === "amd" ? amdData : []),
+        ...(systemInfo.cpu.report.value || systemInfo.cpu.certificate.x509 || systemInfo.cpu.certificate.chain
+            ? cpuAttestationData
+            : []),
+        ...(systemInfo.gpu.reportData || systemInfo.gpu.report.value || systemInfo.gpu.certificate.x509.value
+            ? nvidiaData
+            : []),
+        ...(systemInfo.gpu.certificate.chain ? gpuCertificateData : []),
+    ];
+
+    if (!data.length) return null;
+
+    return <Details title="Details" content={<SectionList data={data} className="mt-4 pb-4" />} />;
+};
+
+export default SystemDidDetails;

package/src/v-comp-viewer/useVComp.ts

@@ -0,0 +1,196 @@
+import { useEffect, useRef, useState } from "react";
+import {
+    parse,
+    ParsedManifest,
+    detectUploadsFromFile,
+    UploadsMap,
+    UploadValue,
+    verifyUploads,
+    UploadVerification,
+    UploadKey,
+    Validated,
+} from "./utils";
+
+export interface UseVCompParams {
+    manifestJson: unknown;
+}
+
+export const useVComp = ({ manifestJson }: UseVCompParams) => {
+    const [data, setData] = useState<ParsedManifest | null>(null);
+    const [uploads, setUploads] = useState<UploadsMap>({});
+    const [verify, setVerify] = useState<UploadVerification | null>(null);
+    const initialValidationsRef = useRef<{
+        containers: Record<string, { dockerComposeId: Validated }>;
+        systems: Record<
+            string,
+            {
+                cpu: { mrtd: Validated; rtmr0: Validated; rtmr1: Validated; rtmr2: Validated; rootfs: Validated };
+                azure: { tpmPCRHash: Validated };
+            }
+        >;
+    } | null>(null);
+
+    const resetVComp = () => {
+        setData(null);
+        setUploads({});
+        setVerify(null);
+    };
+
+    useEffect(() => {
+        if (manifestJson) {
+            const parseData = async () => {
+                try {
+                    setUploads({});
+                    setVerify(null);
+
+                    const results = await parse(manifestJson);
+                    // Capture initial validation snapshot for selective resets on upload deletion
+                    initialValidationsRef.current = {
+                        containers: Object.fromEntries(
+                            Object.keys(results.containers).map((didKey) => [
+                                didKey,
+                                { dockerComposeId: results.containers[didKey].dockerComposeId.validated },
+                            ]),
+                        ),
+                        systems: Object.fromEntries(
+                            Object.keys(results.systems).map((didKey) => [
+                                didKey,
+                                {
+                                    cpu: {
+                                        mrtd: results.systems[didKey].cpu.measurements.mrtd.validated,
+                                        rtmr0: results.systems[didKey].cpu.measurements.rtmr0.validated,
+                                        rtmr1: results.systems[didKey].cpu.measurements.rtmr1.validated,
+                                        rtmr2: results.systems[didKey].cpu.measurements.rtmr2.validated,
+                                        rootfs: results.systems[didKey].cpu.measurements.rootfs.validated,
+                                    },
+                                    azure: {
+                                        tpmPCRHash: results.systems[didKey].azure.tpmPCRHash.validated,
+                                    },
+                                },
+                            ]),
+                        ),
+                    };
+                    setData(results);
+                } catch (error) {
+                    console.error("Error parsing manifest", error);
+                    resetVComp();
+                }
+            };
+            parseData();
+        } else {
+            // Clear data when manifestJson is null/undefined
+            resetVComp();
+        }
+    }, [manifestJson]);
+
+    useEffect(() => {
+        const runVerify = async () => {
+            if (!data) return;
+            try {
+                const res = await verifyUploads(uploads, data);
+                setVerify(res);
+            } catch (e) {
+                console.error("Verify Uploads failed", e);
+            }
+        };
+        runVerify();
+    }, [uploads, data]);
+
+    const handleDetectedUploads = (detected: UploadValue[]) => {
+        setUploads((prev) => {
+            const next: UploadsMap = { ...prev };
+            for (const item of detected) {
+                if (item.kind !== "manifest") {
+                    next[item.kind] = item.value as Uint8Array;
+                }
+            }
+            return next;
+        });
+    };
+
+    const onFilesSelected = async (files: FileList | null) => {
+        if (!files) return;
+        const fileArray = Array.from(files);
+        for (const file of fileArray) {
+            try {
+                const detected = await detectUploadsFromFile(file);
+                handleDetectedUploads(detected);
+            } catch (e) {
+                console.error("Failed to process file", file.name, e);
+            }
+        }
+    };
+
+    const handleDeleteUpload = (kind: Exclude<UploadKey, "manifest">) => {
+        // Remove the upload
+        setUploads((prev) => {
+            const next: UploadsMap = { ...prev };
+            delete (next as Record<string, unknown>)[kind];
+            return next;
+        });
+
+        // Reset validations that were impacted by this specific upload back to initial snapshot
+        setData((prev) => {
+            if (!prev || !initialValidationsRef.current) return prev;
+
+            const initial = initialValidationsRef.current;
+
+            switch (kind) {
+                case "compose":
+                    const value1 = { ...prev };
+                    for (const didKey of Object.keys(value1.containers)) {
+                        value1.containers[didKey].dockerComposeId.validated =
+                            initial.containers[didKey].dockerComposeId;
+                    }
+                    return value1;
+
+                case "ovmf":
+                    const value2 = { ...prev };
+                    for (const didKey of Object.keys(value2.systems)) {
+                        value2.systems[didKey].cpu.measurements.mrtd.validated = initial.systems[didKey].cpu.mrtd;
+                        value2.systems[didKey].cpu.measurements.rtmr0.validated = initial.systems[didKey].cpu.rtmr0;
+                    }
+                    return value2;
+
+                case "cmdline":
+                    const value3 = { ...prev };
+                    for (const didKey of Object.keys(value3.systems)) {
+                        value3.systems[didKey].cpu.measurements.rtmr2.validated = initial.systems[didKey].cpu.rtmr2;
+                        value3.systems[didKey].cpu.measurements.rootfs.validated = initial.systems[didKey].cpu.rootfs;
+                    }
+                    return value3;
+
+                case "initrd":
+                    const value4 = { ...prev };
+                    for (const didKey of Object.keys(value4.systems)) {
+                        value4.systems[didKey].cpu.measurements.rtmr1.validated = initial.systems[didKey].cpu.rtmr1;
+                        value4.systems[didKey].cpu.measurements.rtmr2.validated = initial.systems[didKey].cpu.rtmr2;
+                        value4.systems[didKey].cpu.measurements.rootfs.validated = initial.systems[didKey].cpu.rootfs;
+                    }
+                    return value4;
+
+                case "kernel":
+                    const value5 = { ...prev };
+                    for (const didKey of Object.keys(value5.systems)) {
+                        value5.systems[didKey].cpu.measurements.rtmr1.validated = initial.systems[didKey].cpu.rtmr1;
+                        value5.systems[didKey].azure.tpmPCRHash.validated = initial.systems[didKey].azure.tpmPCRHash;
+                    }
+                    return value5;
+
+                default:
+                    return prev;
+            }
+        });
+    };
+
+    return {
+        vCompData: data,
+        uploads,
+        vCompVerifyData: verify,
+        handleDetectedUploads,
+        onFilesSelected,
+        handleDeleteUpload,
+    };
+};
+
+export type UseVCompReturn = ReturnType<typeof useVComp>;