proofbundle 1.9.1__tar.gz → 2.0.0b1__tar.gz

{proofbundle-1.9.1/src/proofbundle.egg-info → proofbundle-2.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proofbundle
-Version: 1.9.1
+Version: 2.0.0b1
 Summary: Emit and verify portable cryptographic evidence bundles, offline: Ed25519 + RFC 6962 Merkle + optional SD-JWT.
 Author: Konrad Gruszka
 License: MIT
@@ -28,6 +28,7 @@ Provides-Extra: sdjwt
 Provides-Extra: eval
 Requires-Dist: rfc8785>=0.1.4; extra == "eval"
 Provides-Extra: adapters
+Provides-Extra: experimental
 Provides-Extra: pq
 Requires-Dist: cryptography>=48; extra == "pq"
 Provides-Extra: pytest
@@ -153,6 +154,7 @@ flowchart LR
 | Honest comparison to Rekor / in-toto / OMS / ValiChord | [INTEROP.md](INTEROP.md) |
 | Regulatory mapping (and what to never claim) | [COMPLIANCE.md](COMPLIANCE.md) |
 | Funders / role fit | [docs/PROJECT_BRIEF.md](docs/PROJECT_BRIEF.md) |
+| **Preview:** TEE-attestation bridge (v2.0 beta) | [docs/EXPERIMENTAL_ENCLAVE.md](docs/EXPERIMENTAL_ENCLAVE.md) |
 
 ## Install
 

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/README.md

@@ -105,6 +105,7 @@ flowchart LR
 | Honest comparison to Rekor / in-toto / OMS / ValiChord | [INTEROP.md](INTEROP.md) |
 | Regulatory mapping (and what to never claim) | [COMPLIANCE.md](COMPLIANCE.md) |
 | Funders / role fit | [docs/PROJECT_BRIEF.md](docs/PROJECT_BRIEF.md) |
+| **Preview:** TEE-attestation bridge (v2.0 beta) | [docs/EXPERIMENTAL_ENCLAVE.md](docs/EXPERIMENTAL_ENCLAVE.md) |
 
 ## Install
 

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "proofbundle"
-version = "1.9.1"
+version = "2.0.0b1"
 description = "Emit and verify portable cryptographic evidence bundles, offline: Ed25519 + RFC 6962 Merkle + optional SD-JWT."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,6 +46,11 @@ sdjwt = []
 eval = ["rfc8785>=0.1.4"]
 # The lm-eval adapter reads exported results.json (no import) → pure stdlib.
 adapters = []
+# EXPERIMENTAL (v2.0 preview): the TEE-attestation bridge (proofbundle.experimental.enclave).
+# Opt-in and clearly unstable — API/wire-format may change or be removed without deprecation.
+# No new runtime dependency (pure stdlib + the core `cryptography`); the extra exists to signal
+# intent and gate the preview, mirroring the `sdjwt` extra. `pip install "proofbundle[experimental]"`.
+experimental = []
 # ML-DSA-44 (FIPS 204) cosignature verification (C2SP tlog-cosignature type 0x06). Needs a
 # cryptography build with OpenSSL 3.5+ (default PyPI wheels since 48.0.0). Verify-only by default;
 # the emit helper needs the same. Ed25519 paths never require this.

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/src/proofbundle/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-__version__ = "1.9.1"
+__version__ = "2.0.0b1"
 
 __all__ = [
     "__version__",

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/src/proofbundle/cli.py

@@ -283,6 +283,34 @@ def _cmd_prereg(args: argparse.Namespace) -> int:
         return 2
 
 
+def _cmd_verify_enclave(args: argparse.Namespace) -> int:
+    import base64 as _b64  # noqa: PLC0415
+    from .bundle import load_bundle  # noqa: PLC0415
+    from .experimental.enclave import (enclave_binding_for,  # noqa: PLC0415
+                                       verify_enclave_attestation)
+    try:
+        bundle = load_bundle(args.receipt)
+        with open(args.eat, encoding="utf-8") as handle:
+            eat = handle.read().strip()
+        verifier_pub = _b64.b64decode(args.verifier_key, validate=True)
+        res = verify_enclave_attestation(
+            eat, verifier_pubkey=verifier_pub, expected_binding=enclave_binding_for(bundle),
+            expected_profile=args.profile)
+    except (ProofBundleError, OSError, ValueError) as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 2
+    if args.json:
+        print(json.dumps({k: res[k] for k in ("ok", "tier", "profile", "ueid", "nonce_ok",
+                                              "fresh", "detail")}))
+    else:
+        print(f"[{'PASS' if res['ok'] else 'FAIL'}] enclave-attestation: {res['detail']}")
+        if res["ok"]:
+            print(f"    tier    {res['tier']}")
+            print(f"    profile {res['profile']}")
+        print("=> OK" if res["ok"] else "=> FAILED")
+    return 0 if res["ok"] else 1
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="proofbundle",
@@ -369,6 +397,17 @@ def build_parser() -> argparse.ArgumentParser:
     verify_opening.add_argument("--json", action="store_true", help="machine readable output")
     verify_opening.set_defaults(func=_cmd_verify_opening)
 
+    verify_enclave = sub.add_parser(
+        "verify-enclave",
+        help="[EXPERIMENTAL v2.0] verify a TEE Attestation Result (EAT) bound to a receipt")
+    verify_enclave.add_argument("eat", help="path to the EAT (compact JWS) file")
+    verify_enclave.add_argument("--receipt", required=True, help="the receipt bundle JSON the EAT must bind")
+    verify_enclave.add_argument("--verifier-key", required=True,
+                                help="the RATS Verifier's Ed25519 public key (base64)")
+    verify_enclave.add_argument("--profile", help="pin an expected eat_profile URI (optional)")
+    verify_enclave.add_argument("--json", action="store_true", help="machine readable output")
+    verify_enclave.set_defaults(func=_cmd_verify_enclave)
+
     demo = sub.add_parser(
         "demo",
         help="run the whole trust story in memory (pip-only, offline): honest receipt verifies, "

proofbundle-2.0.0b1/src/proofbundle/experimental/__init__.py

@@ -0,0 +1,28 @@
+"""Experimental, opt-in features — NOT part of the stable API surface (v2.0 beta).
+
+Everything under ``proofbundle.experimental`` is a preview: its API, wire format, and behavior may
+change or be removed in any release without a deprecation cycle. It is deliberately NOT re-exported
+from the top-level package — you must import it explicitly, e.g.
+``from proofbundle.experimental.enclave import verify_enclave_attestation``. Importing this
+subpackage emits an ``ExperimentalWarning`` once, so nobody depends on it by accident.
+
+The stable v1.x trusted core (signature / merkle / bundle) does not import anything here.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+
+class ExperimentalWarning(UserWarning):
+    """Raised once when the experimental subpackage is first imported."""
+
+
+warnings.warn(
+    "proofbundle.experimental is a v2.0 preview: its API and wire format may change or be removed "
+    "in any release without deprecation. Do not depend on it in production.",
+    ExperimentalWarning,
+    stacklevel=2,
+)
+
+__all__ = ["ExperimentalWarning"]

proofbundle-2.0.0b1/src/proofbundle/experimental/enclave.py

@@ -0,0 +1,196 @@
+"""TEE-attestation bridge — bind a receipt to hardware-attested execution (v2.0 PREVIEW).
+
+This closes the one gap a software-only receipt structurally has: it proves *who signed these
+bytes and that nothing changed*, but not *that the computation ran untampered*. A Trusted
+Execution Environment (Intel TDX, an NVIDIA confidential-computing GPU, …) can attest the latter.
+This module lets a receipt carry `assurance_level = enclave_attested` in a way a relying party
+can actually check — offline, standards-native, vendor-neutral.
+
+**Scope, stated with the same honesty as the rest of proofbundle — read this before trusting it.**
+proofbundle does NOT parse or appraise raw hardware evidence (a TDX DCAP quote, an NVIDIA GPU
+attestation report). Appraising raw evidence needs vendor libraries, live collateral, and TCB
+policy — it is the job of a **Verifier** in the IETF RATS architecture (RFC 9334). This module
+implements the RATS **Passport model**: the Verifier appraises the evidence out of band and issues
+a signed **Attestation Result**; proofbundle verifies that Attestation Result offline against the
+Verifier's public key (a supplied trust anchor, exactly like every other anchor in
+docs/TRUST_ANCHORS.md) and checks that it is bound to *this* receipt. So the chain of trust is:
+you trust the Verifier's key → the Verifier's result says the enclave was genuine → the result's
+nonce binds it to your receipt. proofbundle checks the last two links; the first is your anchor.
+
+**Wire format (v2.0 preview — subject to change).** The Attestation Result is an EAT
+(Entity Attestation Token, RFC 9711) in its **JSON/JWS** encoding, signed with **EdDSA** (the same
+primitive as everything else here — no new dependency). Claims used:
+  - ``eat_nonce`` (RFC 9711 §4.1) — the binding: it MUST equal ``enclave_binding_for(bundle)``,
+    a base64url SHA-256 over the receipt's exact signed payload. Practically, the enclave places
+    this value in the hardware quote's user-data (Intel TDX ``REPORTDATA`` / an NVIDIA GPU report
+    nonce) when it runs the eval, so "this hardware ran the computation that produced this receipt"
+    is cryptographically tied. proofbundle only checks the EAT-level equality — it does not see
+    the raw quote.
+  - ``eat_profile`` (RFC 9711 §4.3.2) — a profile URI identifying the appraisal semantics; a
+    relying party MAY pin an expected profile.
+  - ``ueid`` (optional) — the attested entity/enclave id, reported, not interpreted.
+  - a ``tier`` string (this preview's stand-in for the AR4SI/EAR trustworthiness tier, which are
+    still IETF Internet-Drafts) — REPORTED verbatim, never interpreted as a guarantee.
+  - optional ``iat``/``exp`` — freshness, reported and only judged when the caller passes ``now``
+    (offline verifier, no trusted clock — same discipline as the status-list module).
+
+What this does NOT establish, and must never be claimed: that the enclave is genuine (that is the
+Verifier's appraisal, which you trust via its key), that the TEE vendor's root of trust is sound,
+or that the eval inside the enclave was well-designed or honest. It raises the assurance floor from
+"the issuer says so" to "a Verifier you trust attested the enclave, bound to this receipt" — no
+further.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+from typing import Optional
+
+from ..errors import BundleFormatError
+from ..signature import verify_ed25519
+
+__all__ = ["EAT_TYP", "enclave_binding_for", "verify_enclave_attestation",
+           "issue_enclave_attestation"]
+
+EAT_TYP = "eat+jwt"                       # RFC 9711 media type application/eat+jwt
+_BINDING_DOMAIN = b"proofbundle/v2/enclave-binding\x00"
+
+
+def _b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _b64url_decode(s: str) -> bytes:
+    raw = s.encode("ascii")
+    return base64.urlsafe_b64decode(raw + b"=" * (-len(raw) % 4))
+
+
+def enclave_binding_for(bundle: dict) -> str:
+    """The value an Attestation Result's ``eat_nonce`` MUST carry to be bound to ``bundle``.
+
+    = base64url(SHA-256(domain || the bundle's exact signed payload bytes)). This is what an
+    enclave puts in its hardware quote's user-data (TDX REPORTDATA / GPU report nonce) at run
+    time, so the resulting Attestation Result is tied to this exact receipt. Fits the RFC 9711
+    JSON ``eat_nonce`` size window (a 43-char base64url of 32 bytes, well within 8..88).
+    """
+    if not isinstance(bundle, dict) or "payload_b64" not in bundle:
+        raise BundleFormatError("enclave_binding_for needs a bundle dict with payload_b64")
+    try:
+        payload = base64.b64decode(bundle["payload_b64"], validate=True)
+    except (ValueError, TypeError) as exc:
+        raise BundleFormatError("bundle.payload_b64 is not valid base64") from exc
+    return _b64url(hashlib.sha256(_BINDING_DOMAIN + payload).digest())
+
+
+def _match_nonce(eat_nonce, expected: str) -> bool:
+    """RFC 9711 eat_nonce is a text string OR an array of text strings — accept either, match any."""
+    if isinstance(eat_nonce, str):
+        return eat_nonce == expected
+    if isinstance(eat_nonce, list):
+        return any(isinstance(x, str) and x == expected for x in eat_nonce)
+    return False
+
+
+def verify_enclave_attestation(eat_jws: str, *, verifier_pubkey: bytes, expected_binding: str,
+                               expected_profile: Optional[str] = None,
+                               now: Optional[int] = None) -> dict:
+    """Verify a Verifier-signed EAT Attestation Result and its binding to a receipt — offline.
+
+    Checks, fail-closed: compact-JWS shape, header ``typ`` == ``eat+jwt`` and ``alg`` == EdDSA,
+    signature under ``verifier_pubkey`` (the RATS Verifier key — a supplied trust anchor),
+    ``eat_nonce`` == ``expected_binding`` (from :func:`enclave_binding_for`), and — if given —
+    ``eat_profile`` == ``expected_profile``. Freshness (``iat``/``exp``) is reported and only
+    judged when ``now`` is supplied.
+
+    Returns ``{ok, tier, profile, ueid, nonce_ok, fresh, iat, exp, detail}``. ``ok`` covers
+    signature + typ/alg + binding (+ profile if requested); ``tier`` is the Verifier's declared
+    trustworthiness tier, REPORTED verbatim — combining ``ok``/``tier``/``fresh`` into a trust
+    decision is the relying party's policy.
+    """
+    result = {"ok": False, "tier": None, "profile": None, "ueid": None, "nonce_ok": False,
+              "fresh": None, "iat": None, "exp": None, "detail": ""}
+    if not isinstance(eat_jws, str) or eat_jws.count(".") != 2:
+        result["detail"] = "not a compact JWS"
+        return result
+    header_b64, payload_b64, sig_b64 = eat_jws.split(".")
+    try:
+        header = json.loads(_b64url_decode(header_b64))
+        claims = json.loads(_b64url_decode(payload_b64))
+        sig = _b64url_decode(sig_b64)
+    except (ValueError, TypeError, json.JSONDecodeError):
+        result["detail"] = "malformed EAT token"
+        return result
+    if not isinstance(header, dict) or not isinstance(claims, dict):
+        result["detail"] = "malformed EAT token"
+        return result
+    if header.get("typ") != EAT_TYP:
+        result["detail"] = f"EAT typ must be '{EAT_TYP}'"
+        return result
+    if header.get("alg") != "EdDSA":
+        result["detail"] = f"EAT alg {header.get('alg')!r} not supported (EdDSA only)"
+        return result
+
+    signing_input = f"{header_b64}.{payload_b64}".encode("ascii")
+    try:
+        sig_ok = verify_ed25519(verifier_pubkey, sig, signing_input)
+    except ValueError:
+        sig_ok = False
+    if not sig_ok:
+        result["detail"] = "EAT signature invalid (verifier key mismatch?)"
+        return result
+
+    result["tier"] = claims.get("tier")
+    result["profile"] = claims.get("eat_profile")
+    result["ueid"] = claims.get("ueid")
+    iat, exp = claims.get("iat"), claims.get("exp")
+    result["iat"], result["exp"] = iat, exp
+
+    if not _match_nonce(claims.get("eat_nonce"), expected_binding):
+        result["detail"] = "eat_nonce does not bind this receipt (attestation is for other bytes)"
+        return result
+    result["nonce_ok"] = True
+
+    if expected_profile is not None and claims.get("eat_profile") != expected_profile:
+        result["detail"] = "eat_profile does not match the expected profile"
+        return result
+
+    for _name, _val in (("iat", iat), ("exp", exp)):
+        if _val is not None and (isinstance(_val, bool) or not isinstance(_val, int)):
+            result["detail"] = f"EAT {_name} must be an integer when present"
+            return result
+    if now is not None:
+        if exp is None:
+            result["fresh"] = None            # unbounded — cannot judge (relying-party policy)
+        else:
+            result["fresh"] = (iat is None or iat <= now) and now < exp
+
+    result["ok"] = True
+    result["detail"] = f"enclave attestation verified (tier={result['tier']!r})"
+    return result
+
+
+def issue_enclave_attestation(binding: str, signer, *, profile: str, tier: str,
+                              ueid: Optional[str] = None, iat: Optional[int] = None,
+                              exp: Optional[int] = None) -> str:
+    """Issue a signed EAT Attestation Result (for tests / a Verifier reference / demos).
+
+    ``signer`` is the Verifier's Ed25519 key; ``binding`` is :func:`enclave_binding_for` of the
+    receipt (the value the enclave placed in its quote user-data). In production a real Verifier
+    emits this after appraising the raw TDX/GPU evidence — this helper does NOT appraise evidence,
+    it only frames + signs the result, so tests and reference verifiers have a token to check.
+    """
+    # explizite Annotation (analog statuslist.py): die Init-Werte sind str, aber iat/exp weiter unten
+    # sind int — ohne Annotation inferiert mypy dict[str, str] und lehnt die int-Zuweisungen ab (CI-mypy,
+    # kein Runtime-Bug).
+    claims: dict[str, str | int] = {"eat_nonce": binding, "eat_profile": profile, "tier": tier}
+    if ueid is not None:
+        claims["ueid"] = ueid
+    if iat is not None:
+        claims["iat"] = iat
+    if exp is not None:
+        claims["exp"] = exp
+    header = {"alg": "EdDSA", "typ": EAT_TYP}
+    signing_input = _b64url(json.dumps(header).encode()) + "." + _b64url(json.dumps(claims).encode())
+    return signing_input + "." + _b64url(signer.sign(signing_input.encode("ascii")))

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/src/proofbundle/statuslist.py

@@ -92,8 +92,12 @@ def verify_status_snapshot(status_list_token: str, *, expected_uri: str, index:
     covers signature + structure + lookup; combining ``ok`` with ``fresh``/``self_issued`` is the
     caller's policy.
     """
-    result = {"ok": False, "status": None, "status_label": None, "fresh": None,
-              "self_issued": None, "iat": None, "exp": None, "ttl": None, "detail": ""}
+    # explizite Annotation: der Result-Dict traegt bool (ok/self_issued), str (status_label/detail), int
+    # (status/iat/exp/ttl) und None gemischt — ohne Annotation inferiert mypy nur 'str|bool|None' aus den
+    # Init-Werten und lehnt die spaeteren int-Zuweisungen ab (CI-mypy-Fehler, kein Runtime-Bug).
+    result: dict[str, str | bool | int | None] = {
+        "ok": False, "status": None, "status_label": None, "fresh": None,
+        "self_issued": None, "iat": None, "exp": None, "ttl": None, "detail": ""}
     if receipt_issuer_pubkey is not None:
         # hmac.compare_digest for a constant-time compare of the two public keys (defensive; the
         # values are public, but consistent with the codebase's compare discipline).

{proofbundle-1.9.1 → proofbundle-2.0.0b1/src/proofbundle.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proofbundle
-Version: 1.9.1
+Version: 2.0.0b1
 Summary: Emit and verify portable cryptographic evidence bundles, offline: Ed25519 + RFC 6962 Merkle + optional SD-JWT.
 Author: Konrad Gruszka
 License: MIT
@@ -28,6 +28,7 @@ Provides-Extra: sdjwt
 Provides-Extra: eval
 Requires-Dist: rfc8785>=0.1.4; extra == "eval"
 Provides-Extra: adapters
+Provides-Extra: experimental
 Provides-Extra: pq
 Requires-Dist: cryptography>=48; extra == "pq"
 Provides-Extra: pytest
@@ -153,6 +154,7 @@ flowchart LR
 | Honest comparison to Rekor / in-toto / OMS / ValiChord | [INTEROP.md](INTEROP.md) |
 | Regulatory mapping (and what to never claim) | [COMPLIANCE.md](COMPLIANCE.md) |
 | Funders / role fit | [docs/PROJECT_BRIEF.md](docs/PROJECT_BRIEF.md) |
+| **Preview:** TEE-attestation bridge (v2.0 beta) | [docs/EXPERIMENTAL_ENCLAVE.md](docs/EXPERIMENTAL_ENCLAVE.md) |
 
 ## Install
 

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/src/proofbundle.egg-info/SOURCES.txt

@@ -41,6 +41,8 @@ src/proofbundle/adapters/inspect_ai.py
 src/proofbundle/adapters/lm_eval.py
 src/proofbundle/adapters/promptfoo.py
 src/proofbundle/adapters/samples.py
+src/proofbundle/experimental/__init__.py
+src/proofbundle/experimental/enclave.py
 tests/test_adapters.py
 tests/test_adversarial.py
 tests/test_beacon.py
@@ -57,6 +59,7 @@ tests/test_emit.py
 tests/test_eval_claim_schema.py
 tests/test_evalclaim.py
 tests/test_examples.py
+tests/test_experimental_enclave.py
 tests/test_fuzz_parsers.py
 tests/test_hf_evals.py
 tests/test_inspect_hook.py

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/src/proofbundle.egg-info/requires.txt

@@ -16,6 +16,8 @@ inspect_ai<0.4,>=0.3.112
 [eval]
 rfc8785>=0.1.4
 
+[experimental]
+
 [inspect]
 inspect_ai<0.4,>=0.3.112
 

proofbundle-2.0.0b1/tests/test_experimental_enclave.py

@@ -0,0 +1,205 @@
+"""TEE-attestation bridge (v2.0 preview) — binding, verify roundtrip, adversarial red matrix.
+
+Also pins the experimental gating: importing proofbundle.experimental warns, and enclave is NOT
+on the top-level package surface.
+"""
+import base64
+import json
+import unittest
+import warnings
+
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+
+from proofbundle import emit_bundle, generate_signer
+from proofbundle.errors import BundleFormatError
+from proofbundle.experimental.enclave import (EAT_TYP, enclave_binding_for,
+                                              issue_enclave_attestation,
+                                              verify_enclave_attestation)
+
+PROFILE = "https://b7n0de.com/proofbundle/eat-profile/tdx-gpu/v1"
+
+
+def _raw(k):
+    return k.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)
+
+
+def _b64url(b):
+    return base64.urlsafe_b64encode(b).rstrip(b"=").decode("ascii")
+
+
+def _b64url_decode(s):
+    return base64.urlsafe_b64decode(s.encode("ascii") + b"=" * (-len(s) % 4))
+
+
+def _setup():
+    """A receipt + a Verifier who attests the enclave that produced it, bound to the receipt."""
+    issuer = generate_signer()
+    bundle = emit_bundle(b'{"suite": "safety", "passed": true}', issuer)
+    binding = enclave_binding_for(bundle)
+    verifier = generate_signer()
+    eat = issue_enclave_attestation(binding, verifier, profile=PROFILE, tier="affirming",
+                                    ueid="tdx:0x1234", iat=1_780_000_000, exp=1_780_003_600)
+    return bundle, binding, verifier, eat
+
+
+class TestBinding(unittest.TestCase):
+    def test_binding_is_stable_and_receipt_specific(self):
+        b1 = emit_bundle(b"payload-A", generate_signer())
+        b2 = emit_bundle(b"payload-B", generate_signer())
+        self.assertEqual(enclave_binding_for(b1), enclave_binding_for(b1))    # deterministic
+        self.assertNotEqual(enclave_binding_for(b1), enclave_binding_for(b2)) # bytes-specific
+        # fits the RFC 9711 JSON eat_nonce window (8..88 chars): sha256 b64url = 43 chars
+        self.assertEqual(len(enclave_binding_for(b1)), 43)
+
+    def test_binding_rejects_non_bundle(self):
+        with self.assertRaises(BundleFormatError):
+            enclave_binding_for({"no": "payload"})
+        with self.assertRaises(BundleFormatError):
+            enclave_binding_for({"payload_b64": "!!not-base64!!"})
+
+
+class TestVerifyRoundtrip(unittest.TestCase):
+    def test_green(self):
+        bundle, binding, verifier, eat = _setup()
+        res = verify_enclave_attestation(eat, verifier_pubkey=_raw(verifier),
+                                         expected_binding=binding, expected_profile=PROFILE)
+        self.assertTrue(res["ok"], res["detail"])
+        self.assertEqual(res["tier"], "affirming")
+        self.assertEqual(res["profile"], PROFILE)
+        self.assertEqual(res["ueid"], "tdx:0x1234")
+        self.assertTrue(res["nonce_ok"])
+
+    def test_freshness_reported_not_assumed(self):
+        bundle, binding, verifier, eat = _setup()
+        r = verify_enclave_attestation(eat, verifier_pubkey=_raw(verifier), expected_binding=binding)
+        self.assertIsNone(r["fresh"])                                   # no clock → no judgement
+        self.assertTrue(verify_enclave_attestation(eat, verifier_pubkey=_raw(verifier),
+                        expected_binding=binding, now=1_780_000_060)["fresh"])
+        self.assertFalse(verify_enclave_attestation(eat, verifier_pubkey=_raw(verifier),
+                         expected_binding=binding, now=1_780_010_000)["fresh"])  # past exp
+
+    def test_unbounded_fresh_is_none(self):
+        bundle, binding, verifier, eat = _setup()
+        v = generate_signer()
+        eat2 = issue_enclave_attestation(binding, v, profile=PROFILE, tier="affirming")  # no exp
+        r = verify_enclave_attestation(eat2, verifier_pubkey=_raw(v), expected_binding=binding,
+                                       now=10**12)
+        self.assertTrue(r["ok"])
+        self.assertIsNone(r["fresh"])                                   # unbounded → cannot judge
+
+
+class TestAdversarial(unittest.TestCase):
+    def test_red_wrong_verifier_key(self):
+        bundle, binding, verifier, eat = _setup()
+        res = verify_enclave_attestation(eat, verifier_pubkey=_raw(generate_signer()),
+                                         expected_binding=binding)
+        self.assertFalse(res["ok"])
+        self.assertIn("signature", res["detail"])
+
+    def test_red_binding_mismatch_other_receipt(self):
+        # An attestation for a DIFFERENT receipt must not verify against this one — the core guard.
+        bundle, binding, verifier, eat = _setup()
+        other = emit_bundle(b'{"forged": true}', generate_signer())
+        res = verify_enclave_attestation(eat, verifier_pubkey=_raw(verifier),
+                                         expected_binding=enclave_binding_for(other))
+        self.assertFalse(res["ok"])
+        self.assertIn("does not bind", res["detail"])
+
+    def test_red_wrong_typ(self):
+        bundle, binding, verifier, eat = _setup()
+        h, p, s = eat.split(".")
+        header = json.loads(_b64url_decode(h))
+        header["typ"] = "jwt"
+        h2 = _b64url(json.dumps(header).encode())
+        sig2 = _b64url(verifier.sign(f"{h2}.{p}".encode("ascii")))
+        res = verify_enclave_attestation(f"{h2}.{p}.{sig2}", verifier_pubkey=_raw(verifier),
+                                         expected_binding=binding)
+        self.assertFalse(res["ok"])
+        self.assertIn(EAT_TYP, res["detail"])
+
+    def test_red_alg_none(self):
+        bundle, binding, verifier, eat = _setup()
+        h, p, s = eat.split(".")
+        h2 = _b64url(json.dumps({"alg": "none", "typ": EAT_TYP}).encode())
+        res = verify_enclave_attestation(f"{h2}.{p}.{s}", verifier_pubkey=_raw(verifier),
+                                         expected_binding=binding)
+        self.assertFalse(res["ok"])
+
+    def test_red_profile_mismatch(self):
+        bundle, binding, verifier, eat = _setup()
+        res = verify_enclave_attestation(eat, verifier_pubkey=_raw(verifier),
+                                         expected_binding=binding,
+                                         expected_profile="https://evil.example/profile")
+        self.assertFalse(res["ok"])
+        self.assertIn("profile", res["detail"])
+
+    def test_red_claim_tamper_breaks_signature(self):
+        # Flip the tier in the payload without re-signing → signature fails.
+        bundle, binding, verifier, eat = _setup()
+        h, p, s = eat.split(".")
+        claims = json.loads(_b64url_decode(p))
+        claims["tier"] = "contraindicated->affirming"
+        p2 = _b64url(json.dumps(claims).encode())
+        res = verify_enclave_attestation(f"{h}.{p2}.{s}", verifier_pubkey=_raw(verifier),
+                                         expected_binding=binding)
+        self.assertFalse(res["ok"])
+
+    def test_red_garbage(self):
+        for bad in ("", "not.a.jws", "a.b", "x.y.z"):
+            res = verify_enclave_attestation(bad, verifier_pubkey=b"\x00" * 32, expected_binding="x")
+            self.assertFalse(res["ok"])
+
+    def test_red_string_exp_rejected(self):
+        bundle, binding, verifier, eat = _setup()
+        v = generate_signer()
+        h = _b64url(json.dumps({"alg": "EdDSA", "typ": EAT_TYP}).encode())
+        claims = {"eat_nonce": binding, "eat_profile": PROFILE, "tier": "affirming", "exp": "9999"}
+        p = _b64url(json.dumps(claims).encode())
+        sig = _b64url(v.sign(f"{h}.{p}".encode("ascii")))
+        res = verify_enclave_attestation(f"{h}.{p}.{sig}", verifier_pubkey=_raw(v),
+                                         expected_binding=binding, now=1)
+        self.assertFalse(res["ok"])
+        self.assertIn("exp", res["detail"])
+
+
+class TestExperimentalGating(unittest.TestCase):
+    def test_not_on_top_level_surface(self):
+        import proofbundle
+        self.assertNotIn("enclave", getattr(proofbundle, "__all__", []))
+        self.assertFalse(hasattr(proofbundle, "verify_enclave_attestation"))
+
+    def test_import_warns(self):
+        import importlib
+        import proofbundle.experimental as exp
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            importlib.reload(exp)
+        self.assertTrue(any(issubclass(x.category, exp.ExperimentalWarning) for x in w))
+
+    def test_cli_verify_enclave(self):
+        import contextlib
+        import io
+        import os
+        import tempfile
+        from proofbundle.cli import main
+        bundle, binding, verifier, eat = _setup()
+        d = tempfile.mkdtemp()
+        rp = os.path.join(d, "receipt.json"); json.dump(bundle, open(rp, "w"))
+        ep = os.path.join(d, "att.eat"); open(ep, "w").write(eat)
+        vkey = base64.b64encode(_raw(verifier)).decode()
+        with contextlib.redirect_stdout(io.StringIO()), warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            rc = main(["verify-enclave", ep, "--receipt", rp, "--verifier-key", vkey,
+                       "--profile", PROFILE, "--json"])
+        self.assertEqual(rc, 0)
+        # wrong receipt → fail
+        other = os.path.join(d, "other.json")
+        json.dump(emit_bundle(b"other", generate_signer()), open(other, "w"))
+        with contextlib.redirect_stdout(io.StringIO()), warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            rc2 = main(["verify-enclave", ep, "--receipt", other, "--verifier-key", vkey])
+        self.assertEqual(rc2, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{proofbundle-1.9.1 → proofbundle-2.0.0b1}/tests/test_fuzz_parsers.py

@@ -24,6 +24,7 @@ from proofbundle.checkpoint import verify_checkpoint, verify_cosignature
 from proofbundle.statuslist import verify_status_snapshot
 from proofbundle.kbjwt import split_key_binding, verify_key_binding
 from proofbundle.sdjwt import verify_sd_jwt
+from proofbundle.experimental.enclave import verify_enclave_attestation
 
 _ALLOWED = (ProofBundleError, ValueError)   # the documented "malformed input" surface
 
@@ -77,6 +78,12 @@ if given is not None:
         def test_verify_sd_jwt_never_crashes(self, compact):
             _must_not_crash(verify_sd_jwt, compact)
 
+        @settings(max_examples=200, deadline=None)
+        @given(_texts)
+        def test_verify_enclave_attestation_never_crashes(self, eat):
+            _must_not_crash(verify_enclave_attestation, eat, verifier_pubkey=b"\x00" * 32,
+                            expected_binding="x")
+
         @settings(max_examples=200, deadline=None)
         @given(_texts)
         def test_verify_status_snapshot_never_crashes(self, token):