voltage-verify 0.1.0__py3-none-any.whl

voltage_verify/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: MIT
+"""voltage-verify: bind two hardware attestations to the workload you meant to run, and check them."""
+
+__version__ = "0.1.0"

voltage_verify/__main__.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+"""Allow ``python -m voltage_verify ...``, which is what the VM instructions use under sudo."""
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

voltage_verify/attest.py

@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: MIT
+"""The part that runs inside the attested VM, as root.
+
+It reads the manifest the verifier prepared, derives the two commitments, asks the Intel TDX
+guest driver for a quote over ``commitment512`` (through the kernel's configfs TSM
+interface), asks NVIDIA's attestation service for GPU claims over ``commitment256`` (through
+the nv-attestation-sdk), fetches the public collateral needed for offline verification, and
+writes one bundle. It chooses nothing: every hash comes from the manifest.
+"""
+
+from __future__ import annotations
+
+import errno
+import json
+import platform
+import secrets
+import shutil
+import subprocess
+import time
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from . import pcs, tdx
+from .bundle import Bundle
+from .canonical import commitments
+from .manifest import validate_manifest
+
+TSM_REPORT_DIR = Path("/sys/kernel/config/tsm/report")
+NRAS_GPU_URL = "https://nras.attestation.nvidia.com/v3/attest/gpu"
+NRAS_OCSP_URL = "https://ocsp.ndis.nvidia.com/"
+NRAS_RIM_URL = "https://rim.attestation.nvidia.com/v1/rim/"
+NRAS_JWKS_URL = "https://nras.attestation.nvidia.com/.well-known/jwks.json"
+
+
+class AttestError(RuntimeError):
+    """Raised when evidence cannot be produced on this machine."""
+
+
+def tsm_quote(report_data: bytes, attempts: int = 5) -> bytes:
+    """Request a TDX quote through configfs TSM. Retries only on EINVAL (concurrent request)."""
+    if len(report_data) != 64:
+        raise AttestError("report_data must be exactly 64 bytes")
+    if not TSM_REPORT_DIR.is_dir():
+        raise AttestError(f"{TSM_REPORT_DIR} is missing: not a TDX guest, or configfs TSM not mounted (run as root)")
+    for attempt in range(attempts):
+        entry = TSM_REPORT_DIR / f"voltage-verify-{secrets.token_hex(4)}"
+        try:
+            entry.mkdir()
+            (entry / "inblob").write_bytes(report_data)
+            quote = (entry / "outblob").read_bytes()
+            provider = (entry / "provider").read_text().strip() if (entry / "provider").exists() else ""
+            if provider and provider != "tdx_guest":
+                raise AttestError(f"TSM provider is {provider!r}, not tdx_guest")
+            return quote
+        except OSError as err:
+            if err.errno != errno.EINVAL or attempt == attempts - 1:
+                raise AttestError(f"TSM quote request failed: {err}") from err
+            time.sleep(0.05 * (attempt + 1))
+        finally:
+            try:
+                entry.rmdir()
+            except OSError:
+                pass
+    raise AttestError("TSM quote request failed after retries")
+
+
+def gpu_count() -> int:
+    try:
+        import pynvml  # type: ignore
+
+        pynvml.nvmlInit()
+        return int(pynvml.nvmlDeviceGetCount())
+    except Exception:  # noqa: BLE001
+        smi = shutil.which("nvidia-smi")
+        if not smi:
+            return 0
+        out = subprocess.run([smi, "-L"], capture_output=True, text=True, timeout=30, check=False).stdout
+        return sum(1 for line in out.splitlines() if line.startswith("GPU "))
+
+
+def nras_attest(nonce_hex: str, mode: str) -> Any:
+    """Run the nv-attestation-sdk against NRAS with our nonce. Returns the parsed token array."""
+    try:
+        from nv_attestation_sdk import attestation  # type: ignore
+    except ImportError as err:
+        raise AttestError("nv-attestation-sdk is not installed: pip install 'voltage-verify[attest]'") from err
+    client = attestation.Attestation()
+    client.set_name("voltage-verify")
+    client.set_nonce(nonce_hex)
+    client.set_claims_version("2.0")
+    client.add_verifier(
+        attestation.Devices.GPU,
+        attestation.Environment.REMOTE,
+        NRAS_GPU_URL,
+        "",
+        ocsp_url=NRAS_OCSP_URL,
+        rim_url=NRAS_RIM_URL,
+    )
+    if mode == "multi-gpu-ppcie":
+        # On a multi-GPU node in NVIDIA Protected PCIe mode the SDK refuses "standalone"
+        # attestation; ppcie_mode=False means "not standalone" for this SDK version.
+        options = {"ppcie_mode": False}
+        try:
+            evidence = client.get_evidence(options=options)
+        except TypeError:
+            evidence = client.get_evidence(options)
+        try:
+            ok = client.attest(evidence, options=options)
+        except TypeError:
+            ok = client.attest(evidence)
+    else:
+        evidence = client.get_evidence()
+        ok = client.attest(evidence)
+    token = client.get_token()
+    if not token:
+        raise AttestError("NRAS returned no token")
+    parsed = json.loads(token) if isinstance(token, str) else token
+    if not ok:
+        raise AttestError("NRAS attestation did not succeed (token kept for diagnosis): " + json.dumps(parsed)[:300])
+    return parsed
+
+
+def fetch_json(url: str) -> dict[str, Any]:
+    req = urllib.request.Request(url, headers={"User-Agent": pcs.USER_AGENT})
+    with urllib.request.urlopen(req, timeout=30) as resp:  # noqa: S310
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def environment_facts() -> dict[str, Any]:
+    facts: dict[str, Any] = {"kernel": platform.release(), "python": platform.python_version()}
+    smi = shutil.which("nvidia-smi")
+    if smi:
+        for key, args in (("gpus", ["-L"]), ("conf_compute", ["conf-compute", "-q"])):
+            try:
+                run = subprocess.run([smi, *args], capture_output=True, text=True, timeout=30, check=False)
+                facts[key] = run.stdout.strip()
+            except (OSError, subprocess.SubprocessError):
+                pass
+    return facts
+
+
+def run_attest(manifest_path: Path, out_path: Path, mode: str = "auto", with_collateral: bool = True) -> Bundle:
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    validate_manifest(manifest)
+    com = commitments(manifest)
+
+    quote_raw = tsm_quote(com.sha512)
+    quote = tdx.parse_quote(quote_raw)
+    if quote.report.report_data != com.sha512:
+        raise AttestError("the TDX quote does not carry the requested report_data")
+
+    if mode == "auto":
+        mode = "multi-gpu-ppcie" if gpu_count() > 1 else "single-gpu"
+    nras = nras_attest(com.sha256_hex, mode)
+
+    jwks: dict[str, Any] | None = None
+    collateral: dict[str, Any] | None = None
+    if with_collateral:
+        try:
+            jwks = fetch_json(NRAS_JWKS_URL)
+        except Exception as err:  # noqa: BLE001
+            print(f"warning: could not fetch NRAS JWKS for offline verification: {err}")
+        try:
+            pck = tdx.pck_info(quote.pck_leaf)
+            collateral = {"intel": pcs.fetch_collateral(pck.fmspc, pcs.pck_ca_kind(quote)).to_json()}
+        except Exception as err:  # noqa: BLE001
+            print(f"warning: could not fetch Intel collateral for offline verification: {err}")
+
+    bundle = Bundle(
+        manifest=manifest,
+        commitments={"sha256": com.sha256_hex, "sha512": com.sha512_hex},
+        quote=quote.raw,
+        report_data=com.sha512,
+        nvidia_mode=mode,
+        nras=nras,
+        jwks=jwks,
+        collateral=collateral,
+        environment=environment_facts(),
+        created_at=datetime.now(timezone.utc),
+    )
+    bundle.save(out_path)
+    return bundle

voltage_verify/bundle.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: MIT
+"""The evidence bundle: one JSON file that carries everything a verifier needs.
+
+Format ``voltage-verify-bundle/1``::
+
+    {
+      "format": "voltage-verify-bundle/1",
+      "tool": {"name": "voltage-verify", "version": "0.1.0"},
+      "created_at": "2026-09-12T01:02:03+00:00",
+      "manifest": { ... the workload manifest, verbatim ... },
+      "commitments": {"sha256": "<hex>", "sha512": "<hex>"},
+      "tdx": {"quote_b64": "<base64>", "report_data_hex": "<hex>"},
+      "nvidia": {"mode": "single-gpu" | "multi-gpu-ppcie", "nras": [...], "jwks": {...}},
+      "collateral": {"intel": { ... pcs.Collateral ... }},
+      "environment": { ... free-form facts recorded on the VM ... }
+    }
+
+The manifest is the only input a verifier must trust nothing about: every other field is
+either derived from it (commitments), signed by Intel (quote, collateral) or signed by NVIDIA
+(NRAS tokens). The JWKS and Intel collateral are embedded so that verification can run
+offline against the material of the day; an online verification refetches and compares.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+
+FORMAT = "voltage-verify-bundle/1"
+MANIFEST_FORMAT = "voltage-verify-manifest/1"
+
+
+class BundleError(ValueError):
+    """Raised when a bundle file is not usable."""
+
+
+@dataclass
+class Bundle:
+    manifest: dict[str, Any]
+    commitments: dict[str, str]
+    quote: bytes
+    report_data: bytes
+    nvidia_mode: str
+    nras: Any
+    jwks: dict[str, Any] | None
+    collateral: dict[str, Any] | None
+    environment: dict[str, Any] = field(default_factory=dict)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    tool: dict[str, str] = field(default_factory=lambda: {"name": "voltage-verify", "version": __version__})
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "format": FORMAT,
+            "tool": self.tool,
+            "created_at": self.created_at.isoformat(timespec="seconds"),
+            "manifest": self.manifest,
+            "commitments": self.commitments,
+            "tdx": {"quote_b64": base64.b64encode(self.quote).decode("ascii"), "report_data_hex": self.report_data.hex()},
+            "nvidia": {"mode": self.nvidia_mode, "nras": self.nras, "jwks": self.jwks},
+            "collateral": self.collateral,
+            "environment": self.environment,
+        }
+
+    def save(self, path: Path) -> None:
+        path.write_text(json.dumps(self.to_json(), indent=2, sort_keys=True), encoding="utf-8")
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> Bundle:
+        if data.get("format") != FORMAT:
+            raise BundleError(f"unsupported bundle format {data.get('format')!r}")
+        try:
+            created = datetime.fromisoformat(str(data["created_at"]).replace("Z", "+00:00"))
+            return cls(
+                manifest=data["manifest"],
+                commitments=dict(data["commitments"]),
+                quote=base64.b64decode(data["tdx"]["quote_b64"]),
+                report_data=bytes.fromhex(data["tdx"]["report_data_hex"]),
+                nvidia_mode=str(data["nvidia"]["mode"]),
+                nras=data["nvidia"]["nras"],
+                jwks=data["nvidia"].get("jwks"),
+                collateral=data.get("collateral"),
+                environment=dict(data.get("environment") or {}),
+                created_at=created,
+                tool=dict(data.get("tool") or {}),
+            )
+        except (KeyError, TypeError, ValueError) as err:
+            raise BundleError(f"bundle is missing or has a malformed field: {err}") from err
+
+    @classmethod
+    def load(cls, path: Path) -> Bundle:
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError) as err:
+            raise BundleError(f"cannot read {path}: {err}") from err
+        return cls.from_json(data)

voltage_verify/canonical.py

@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: MIT
+"""Canonical serialisation of the workload manifest and the two commitments derived from it.
+
+The manifest is serialised the way RFC 8785 (JSON Canonicalization Scheme) does for the
+value types this tool emits: object keys sorted by code point, no insignificant whitespace,
+UTF-8, no floats. Two parties that hold the same manifest therefore compute byte-identical
+input and, from it, the same commitments:
+
+* ``commitment256`` = SHA-256(canonical manifest): the 32-byte nonce handed to the NVIDIA
+  attestation flow (NRAS echoes it back in ``eat_nonce``).
+* ``commitment512`` = SHA-512(canonical manifest): the 64-byte ``report_data`` written into
+  the Intel TDX quote request (the quote embeds it verbatim).
+
+Anyone who changes a single byte of the manifest (image digest, model digest, challenge,
+anything) changes both commitments, and both proofs stop matching.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from typing import Any
+
+
+class CanonicalError(ValueError):
+    """Raised when a manifest cannot be canonicalised deterministically."""
+
+
+def _reject_floats(value: Any, path: str = "$") -> None:
+    if isinstance(value, float):
+        raise CanonicalError(f"floats are not allowed in a manifest (at {path})")
+    if isinstance(value, dict):
+        for k, v in value.items():
+            if not isinstance(k, str):
+                raise CanonicalError(f"object keys must be strings (at {path})")
+            _reject_floats(v, f"{path}.{k}")
+    elif isinstance(value, list):
+        for i, v in enumerate(value):
+            _reject_floats(v, f"{path}[{i}]")
+
+
+def canonical_bytes(manifest: dict[str, Any]) -> bytes:
+    """Return the canonical UTF-8 encoding of ``manifest``."""
+    _reject_floats(manifest)
+    return json.dumps(manifest, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+@dataclass(frozen=True)
+class Commitments:
+    canonical: bytes
+    sha256: bytes
+    sha512: bytes
+
+    @property
+    def sha256_hex(self) -> str:
+        return self.sha256.hex()
+
+    @property
+    def sha512_hex(self) -> str:
+        return self.sha512.hex()
+
+
+def commitments(manifest: dict[str, Any]) -> Commitments:
+    """Compute both commitments of a manifest."""
+    raw = canonical_bytes(manifest)
+    return Commitments(raw, hashlib.sha256(raw).digest(), hashlib.sha512(raw).digest())

voltage_verify/cli.py

@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: MIT
+"""Command line entry point."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from .bundle import Bundle, BundleError
+from .canonical import commitments
+from .manifest import ManifestError, build_manifest
+from .registry import RegistryError
+from .verify import Report, verify_bundle
+
+
+def _print_report(report: Report) -> None:
+    width = max(len(c.name) for c in report.checks) if report.checks else 20
+    for check in report.checks:
+        print(f"[{check.label}] {check.name.ljust(width)}  {check.detail}")
+    facts = report.facts
+    if "tdx" in facts:
+        t = facts["tdx"]
+        print(f"\nTDX: MRTD {t['mr_td'][:32]}...  TCB {t.get('tcb_status', '?')}  QE {t.get('qe_status', '?')}")
+    if "nvidia" in facts:
+        for d in facts["nvidia"]["devices"]:
+            print(f"GPU: {d['name']} {d['hwmodel']} driver {d['driver']} vbios {d['vbios']} measurements {d['measres']}")
+    print("\nRESULT:", "VERIFIED" if report.ok else "NOT VERIFIED (" + ", ".join(report.failed()) + ")")
+
+
+def cmd_manifest(args: argparse.Namespace) -> int:
+    extra: dict[str, str] = {}
+    for item in args.extra or []:
+        if "=" not in item:
+            print(f"--extra expects key=value, got {item!r}", file=sys.stderr)
+            return 2
+        key, value = item.split("=", 1)
+        extra[key] = value
+    try:
+        manifest = build_manifest(
+            image=args.image,
+            image_digest=args.image_digest,
+            artifacts=[Path(p) for p in (args.artifact or [])],
+            extra=extra,
+            statement=args.statement,
+            challenge=None if args.challenge in (None, "auto") else args.challenge,
+        )
+    except (ManifestError, RegistryError) as err:
+        print(f"error: {err}", file=sys.stderr)
+        return 2
+    Path(args.output).write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    com = commitments(manifest)
+    print(f"manifest written to {args.output}")
+    print(f"challenge        {manifest['challenge']}")
+    print(f"commitment256    {com.sha256_hex}   (NVIDIA nonce)")
+    print(f"commitment512    {com.sha512_hex[:64]}...   (TDX report_data)")
+    print("keep the challenge: pass it to `verify --challenge` to reject replayed bundles")
+    return 0
+
+
+def cmd_attest(args: argparse.Namespace) -> int:
+    from .attest import AttestError, run_attest  # imported late: VM-only dependencies
+
+    try:
+        bundle = run_attest(Path(args.manifest), Path(args.output), mode=args.mode, with_collateral=not args.no_collateral)
+    except AttestError as err:
+        print(f"error: {err}", file=sys.stderr)
+        return 2
+    print(f"bundle written to {args.output} ({bundle.nvidia_mode}, {len(bundle.quote)}-byte quote)")
+    return 0
+
+
+def _load(path: str) -> Bundle | None:
+    try:
+        return Bundle.load(Path(path))
+    except BundleError as err:
+        print(f"error: {err}", file=sys.stderr)
+        return None
+
+
+def cmd_verify(args: argparse.Namespace) -> int:
+    bundle = _load(args.bundle)
+    if bundle is None:
+        return 2
+    report = verify_bundle(
+        bundle,
+        expected_challenge=args.challenge,
+        expected_image_digest=args.image_digest,
+        online=not args.offline,
+        allowed_hwmodels=set(args.hwmodel) if args.hwmodel else None,
+        require_devices=args.gpus,
+    )
+    if args.json:
+        print(json.dumps(report.to_json(), indent=2))
+    else:
+        _print_report(report)
+    return 0 if report.ok else 1
+
+
+def cmd_inspect(args: argparse.Namespace) -> int:
+    bundle = _load(args.bundle)
+    if bundle is None:
+        return 2
+    data = bundle.to_json()
+    data["tdx"]["quote_b64"] = f"<{len(bundle.quote)} bytes>"
+    data["nvidia"]["jwks"] = "<embedded>" if bundle.jwks else None
+    data["collateral"] = "<embedded>" if bundle.collateral else None
+    print(json.dumps(data, indent=2, sort_keys=True))
+    return 0
+
+
+def cmd_selftest(args: argparse.Namespace) -> int:
+    from .selftest import run_selftest
+
+    bundle = _load(args.bundle)
+    if bundle is None:
+        return 2
+    clean, results = run_selftest(bundle, online=not args.offline, expected_challenge=args.challenge)
+    print("clean bundle:", "VERIFIED" if clean.ok else "NOT VERIFIED (" + ", ".join(clean.failed()) + ")")
+    all_ok = clean.ok
+    for r in results:
+        all_ok = all_ok and r.passed
+        rejected = ", ".join(r.failed_checks) or "nothing"
+        print(f"[{'PASS' if r.passed else 'FAIL'}] {r.name.ljust(16)} {r.description}  ->  rejected on {rejected}")
+    print("\nSELFTEST:", "PASS" if all_ok else "FAIL")
+    return 0 if all_ok else 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="voltage-verify",
+        description="Bind TDX and NVIDIA attestations to a workload and verify them.",
+    )
+    p.add_argument("--version", action="version", version=f"voltage-verify {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    m = sub.add_parser("manifest", help="build the workload manifest on the verifier's machine")
+    m.add_argument("--image", help="container image reference, e.g. ghcr.io/org/app:1.2.3")
+    m.add_argument("--image-digest", help="sha256:... digest, when the registry cannot be queried")
+    m.add_argument("--artifact", action="append", help="file to hash (model weights, config); repeatable")
+    m.add_argument("--extra", action="append", help="key=value to include in the manifest; repeatable")
+    m.add_argument("--statement", help="free text describing the run")
+    m.add_argument("--challenge", default="auto", help="32-byte hex challenge, or 'auto' to generate one")
+    m.add_argument("-o", "--output", default="manifest.json")
+    m.set_defaults(func=cmd_manifest)
+
+    a = sub.add_parser("attest", help="produce the evidence bundle; run as root inside the TDX VM")
+    a.add_argument("--manifest", required=True)
+    a.add_argument("-o", "--output", default="bundle.json")
+    a.add_argument("--mode", choices=["auto", "single-gpu", "multi-gpu-ppcie"], default="auto")
+    a.add_argument("--no-collateral", action="store_true", help="do not embed Intel/NVIDIA collateral")
+    a.set_defaults(func=cmd_attest)
+
+    v = sub.add_parser("verify", help="verify a bundle")
+    v.add_argument("bundle")
+    v.add_argument("--challenge", help="the challenge you issued; rejects replayed bundles")
+    v.add_argument("--image-digest", help="expected sha256:... of the workload image")
+    v.add_argument("--offline", action="store_true", help="use the collateral embedded in the bundle")
+    v.add_argument("--hwmodel", action="append", help="allowed GPU model claim, e.g. GH100; repeatable")
+    v.add_argument("--gpus", type=int, help="exact number of attested GPUs expected")
+    v.add_argument("--json", action="store_true")
+    v.set_defaults(func=cmd_verify)
+
+    i = sub.add_parser("inspect", help="print a bundle without the bulky fields")
+    i.add_argument("bundle")
+    i.set_defaults(func=cmd_inspect)
+
+    s = sub.add_parser("selftest", help="verify a bundle, then check that six mutations are rejected")
+    s.add_argument("bundle")
+    s.add_argument("--challenge")
+    s.add_argument("--offline", action="store_true")
+    s.set_defaults(func=cmd_selftest)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

voltage_verify/data/intel_sgx_root_ca.pem

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICjzCCAjSgAwIBAgIUImUM1lqdNInzg7SVUr9QGzknBqwwCgYIKoZIzj0EAwIw
+aDEaMBgGA1UEAwwRSW50ZWwgU0dYIFJvb3QgQ0ExGjAYBgNVBAoMEUludGVsIENv
+cnBvcmF0aW9uMRQwEgYDVQQHDAtTYW50YSBDbGFyYTELMAkGA1UECAwCQ0ExCzAJ
+BgNVBAYTAlVTMB4XDTE4MDUyMTEwNDUxMFoXDTQ5MTIzMTIzNTk1OVowaDEaMBgG
+A1UEAwwRSW50ZWwgU0dYIFJvb3QgQ0ExGjAYBgNVBAoMEUludGVsIENvcnBvcmF0
+aW9uMRQwEgYDVQQHDAtTYW50YSBDbGFyYTELMAkGA1UECAwCQ0ExCzAJBgNVBAYT
+AlVTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEC6nEwMDIYZOj/iPWsCzaEKi7
+1OiOSLRFhWGjbnBVJfVnkY4u3IjkDYYL0MxO4mqsyYjlBalTVYxFP2sJBK5zlKOB
+uzCBuDAfBgNVHSMEGDAWgBQiZQzWWp00ifODtJVSv1AbOScGrDBSBgNVHR8ESzBJ
+MEegRaBDhkFodHRwczovL2NlcnRpZmljYXRlcy50cnVzdGVkc2VydmljZXMuaW50
+ZWwuY29tL0ludGVsU0dYUm9vdENBLmRlcjAdBgNVHQ4EFgQUImUM1lqdNInzg7SV
+Ur9QGzknBqwwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQEwCgYI
+KoZIzj0EAwIDSQAwRgIhAOW/5QkR+S9CiSDcNoowLuPRLsWGf/Yi7GSX94BgwTwg
+AiEA4J0lrHoMs+Xo5o/sX6O9QWxHRAvZUGOdRQ7cvqRXaqI=
+-----END CERTIFICATE-----

voltage_verify/der.py

@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: MIT
+"""A deliberately small DER reader, enough to walk the Intel SGX PCK certificate extension.
+
+The extension (OID 1.2.840.113741.1.13.1) is a SEQUENCE of SEQUENCE { OID, value } pairs whose
+values are OCTET STRINGs, INTEGERs, ENUMERATEDs or nested SEQUENCEs. Nothing else is needed,
+so nothing else is implemented; unknown tags are returned as raw bytes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+TAG_INTEGER = 0x02
+TAG_OCTET_STRING = 0x04
+TAG_OID = 0x06
+TAG_ENUMERATED = 0x0A
+TAG_SEQUENCE = 0x30
+
+
+class DerError(ValueError):
+    """Raised on malformed DER."""
+
+
+@dataclass(frozen=True)
+class Node:
+    tag: int
+    value: Any  # int | bytes | str (OID) | list[Node]
+
+
+def _read_length(data: bytes, pos: int) -> tuple[int, int]:
+    first = data[pos]
+    pos += 1
+    if first < 0x80:
+        return first, pos
+    count = first & 0x7F
+    if count == 0 or count > 4 or pos + count > len(data):
+        raise DerError("unsupported DER length encoding")
+    return int.from_bytes(data[pos : pos + count], "big"), pos + count
+
+
+def _decode_oid(raw: bytes) -> str:
+    if not raw:
+        raise DerError("empty OID")
+    first = raw[0]
+    parts = [str(first // 40), str(first % 40)]
+    value = 0
+    for byte in raw[1:]:
+        value = (value << 7) | (byte & 0x7F)
+        if not byte & 0x80:
+            parts.append(str(value))
+            value = 0
+    if value:
+        raise DerError("truncated OID")
+    return ".".join(parts)
+
+
+def decode(data: bytes) -> list[Node]:
+    """Decode a concatenation of DER TLVs into nodes (SEQUENCEs are decoded recursively)."""
+    nodes: list[Node] = []
+    pos = 0
+    while pos < len(data):
+        if pos + 2 > len(data):
+            raise DerError("truncated TLV")
+        tag = data[pos]
+        length, body_start = _read_length(data, pos + 1)
+        body_end = body_start + length
+        if body_end > len(data):
+            raise DerError("TLV runs past the end of the buffer")
+        body = data[body_start:body_end]
+        if tag == TAG_SEQUENCE:
+            nodes.append(Node(tag, decode(body)))
+        elif tag == TAG_OID:
+            nodes.append(Node(tag, _decode_oid(body)))
+        elif tag in (TAG_INTEGER, TAG_ENUMERATED):
+            nodes.append(Node(tag, int.from_bytes(body, "big", signed=True)))
+        else:
+            nodes.append(Node(tag, body))
+        pos = body_end
+    return nodes
+
+
+def pairs(sequence: Node) -> dict[str, Node]:
+    """Turn a SEQUENCE of { OID, value } SEQUENCEs into a dict keyed by dotted OID."""
+    if sequence.tag != TAG_SEQUENCE:
+        raise DerError("expected a SEQUENCE")
+    out: dict[str, Node] = {}
+    for item in sequence.value:
+        if item.tag != TAG_SEQUENCE or len(item.value) != 2 or item.value[0].tag != TAG_OID:
+            raise DerError("expected SEQUENCE { OID, value }")
+        out[item.value[0].value] = item.value[1]
+    return out