From f11b35871498843286019a485f13c00716cd00d0 Mon Sep 17 00:00:00 2001 From: ahraz <38987266+ahrazzle@users.noreply.github.com> Date: Fri, 20 Nov 2026 00:40:57 -0600 Subject: [PATCH 1/2] audit: reject a certificate that names no recognized status An empty object and an unknown status produced no findings, and the auditor reported VERIFIED. A rejected or conjectural record was relabeled the same way. Those records now keep their own status, and a missing or unknown status is a finding. CONJECTURE still needs no pins. --- mde_soko/domain_oracle.py | 35 ++++++++++++++- tests/test_audit_status_fail_closed.py | 60 ++++++++++++++++++++++++++ 2 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 tests/test_audit_status_fail_closed.py diff --git a/mde_soko/domain_oracle.py b/mde_soko/domain_oracle.py index 31c19a1..dc22063 100644 --- a/mde_soko/domain_oracle.py +++ b/mde_soko/domain_oracle.py @@ -688,6 +688,16 @@ def apply_reply_json(self, raw_reply: str) -> dict[str, Any]: CERTIFIED_STATUSES: frozenset[str] = frozenset({"VERIFIED", "PROVEN", "LOWER_BOUND"}) +RECOGNIZED_CERT_STATUSES: frozenset[str] = CERTIFIED_STATUSES | frozenset( + { + "CONJECTURE", + "LOWER_BOUND_UNWITNESSED", + "LINT_PASS", + "VERIFIED_ON_BOUNDED_REACHABLE_SUBGRAPH", + "REJECTED", + "UNVERIFIED_CALLER_BOUNDS", + } +) def audit_soko_certificate(cert: Mapping[str, Any]) -> dict[str, Any]: @@ -696,6 +706,22 @@ def audit_soko_certificate(cert: Mapping[str, Any]) -> dict[str, Any]: status = str(cert.get("epistemic_status", "")).strip().upper() proof_mode = str(cert.get("proof_mode", "")).strip().lower() + # An omitted or invented status has no checks to fail, so it must not pass. + if not status: + findings.append( + { + "rule": "F00_STATUS_ABSENT", + "message": "Certificate omits epistemic_status.", + } + ) + elif status not in RECOGNIZED_CERT_STATUSES: + findings.append( + { + "rule": "F00_STATUS_UNKNOWN", + "message": f"epistemic_status {status!r} is not a recognized certificate status.", + } + ) + engines = cert.get("oracles_checked") or cert.get("engines_verified") or [] if cert.get("differential_match") is True and (not isinstance(engines, list) or len(engines) < 2): findings.append( @@ -800,9 +826,16 @@ def audit_soko_certificate(cert: Mapping[str, Any]) -> dict[str, Any]: ) passed = len(findings) == 0 + # Do not relabel a lower bound, a conjecture, or a rejection as VERIFIED. + if not passed: + out_status = "REJECTED" + elif status in ("VERIFIED", "PROVEN"): + out_status = "VERIFIED" + else: + out_status = status return { "passed": passed, - "epistemic_status": "VERIFIED" if passed else "REJECTED", + "epistemic_status": out_status, "finding_count": len(findings), "findings": findings, } diff --git a/tests/test_audit_status_fail_closed.py b/tests/test_audit_status_fail_closed.py new file mode 100644 index 0000000..05a4638 --- /dev/null +++ b/tests/test_audit_status_fail_closed.py @@ -0,0 +1,60 @@ +"""An empty or unknown certificate must not come back VERIFIED. + +The auditor used to return VERIFIED whenever it found no red-flag field. +A certificate with no status has no such field, so `{}` passed. The same +path relabeled REJECTED and CONJECTURE as VERIFIED. CONJECTURE still needs +no pins. It keeps its own status. +""" + +from __future__ import annotations + +import unittest + +from mde_soko.domain_oracle import audit_soko_certificate + +HEX64 = "a" * 64 + + +def _require(condition: bool, message: str) -> None: + if not condition: + raise AssertionError(message) + + +class AuditStatusFailClosedTests(unittest.TestCase): + def test_empty_certificate_is_rejected(self) -> None: + result = audit_soko_certificate({}) + _require(not bool(result["passed"]), f"empty certificate passed: {result}") + self.assertEqual(result["epistemic_status"], "REJECTED") + self.assertIn("F00_STATUS_ABSENT", {f["rule"] for f in result["findings"]}) + + def test_unknown_status_is_rejected(self) -> None: + result = audit_soko_certificate({"epistemic_status": "BANANA"}) + _require(not bool(result["passed"]), f"unknown status passed: {result}") + self.assertEqual(result["epistemic_status"], "REJECTED") + self.assertIn("F00_STATUS_UNKNOWN", {f["rule"] for f in result["findings"]}) + + def test_rejected_and_conjecture_are_not_relabeled_verified(self) -> None: + rejected = audit_soko_certificate({"epistemic_status": "REJECTED"}) + _require(bool(rejected["passed"]), f"a plain rejection is not an illegal claim: {rejected}") + self.assertEqual(rejected["epistemic_status"], "REJECTED") + + conjecture = audit_soko_certificate({"epistemic_status": "CONJECTURE"}) + _require(bool(conjecture["passed"]), f"CONJECTURE does not require pins: {conjecture}") + self.assertEqual(conjecture["epistemic_status"], "CONJECTURE") + + def test_verified_with_pins_still_passes(self) -> None: + cert = { + "epistemic_status": "VERIFIED", + "tcb_pins": { + "tcb_manifest_verified": True, + "checker_auditor_py_sha256": HEX64, + }, + "witness_or_proof_sha256": "b" * 64, + } + result = audit_soko_certificate(cert) + _require(bool(result["passed"]), f"pinned VERIFIED certificate rejected: {result}") + self.assertEqual(result["epistemic_status"], "VERIFIED") + + +if __name__ == "__main__": + unittest.main() From 760376fe8040fa2486a1e29f55c4fd1aeda291ee Mon Sep 17 00:00:00 2001 From: ahraz <38987266+ahrazzle@users.noreply.github.com> Date: Fri, 20 Nov 2026 11:25:18 -0600 Subject: [PATCH 2/2] audit: a passing PROVEN certificate keeps the status PROVEN --- mde_soko/domain_oracle.py | 9 ++---- tests/test_audit_status_fail_closed.py | 39 ++++++++++++++++++++++++-- 2 files changed, 39 insertions(+), 9 deletions(-) diff --git a/mde_soko/domain_oracle.py b/mde_soko/domain_oracle.py index dc22063..8f02172 100644 --- a/mde_soko/domain_oracle.py +++ b/mde_soko/domain_oracle.py @@ -826,13 +826,8 @@ def audit_soko_certificate(cert: Mapping[str, Any]) -> dict[str, Any]: ) passed = len(findings) == 0 - # Do not relabel a lower bound, a conjecture, or a rejection as VERIFIED. - if not passed: - out_status = "REJECTED" - elif status in ("VERIFIED", "PROVEN"): - out_status = "VERIFIED" - else: - out_status = status + # A record that clears every check keeps its own recognized status. + out_status = status if passed else "REJECTED" return { "passed": passed, "epistemic_status": out_status, diff --git a/tests/test_audit_status_fail_closed.py b/tests/test_audit_status_fail_closed.py index 05a4638..32de2e4 100644 --- a/tests/test_audit_status_fail_closed.py +++ b/tests/test_audit_status_fail_closed.py @@ -2,8 +2,9 @@ The auditor used to return VERIFIED whenever it found no red-flag field. A certificate with no status has no such field, so `{}` passed. The same -path relabeled REJECTED and CONJECTURE as VERIFIED. CONJECTURE still needs -no pins. It keeps its own status. +path relabeled REJECTED and CONJECTURE as VERIFIED, and PROVEN as VERIFIED. +CONJECTURE still needs no pins. Every recognized status that passes keeps +its own name. """ from __future__ import annotations @@ -55,6 +56,40 @@ def test_verified_with_pins_still_passes(self) -> None: _require(bool(result["passed"]), f"pinned VERIFIED certificate rejected: {result}") self.assertEqual(result["epistemic_status"], "VERIFIED") + def test_pinned_proven_keeps_its_own_status(self) -> None: + cert = { + "epistemic_status": "PROVEN", + "tcb_pins": { + "tcb_manifest_verified": True, + "checker_auditor_py_sha256": HEX64, + }, + "witness_or_proof_sha256": "b" * 64, + } + result = audit_soko_certificate(cert) + _require(bool(result["passed"]), f"pinned PROVEN certificate rejected: {result}") + self.assertEqual(result["epistemic_status"], "PROVEN") + + def test_every_passing_recognized_status_keeps_its_name(self) -> None: + pins = {"tcb_manifest_verified": True, "checker_auditor_py_sha256": HEX64} + for status in ("VERIFIED", "PROVEN", "LOWER_BOUND"): + result = audit_soko_certificate( + {"epistemic_status": status, "tcb_pins": pins, "witness_or_proof_sha256": "b" * 64} + ) + _require(bool(result["passed"]), f"{status} with pins rejected: {result}") + self.assertEqual(result["epistemic_status"], status) + for status in ("CONJECTURE", "REJECTED", "LINT_PASS", "LOWER_BOUND_UNWITNESSED", "UNVERIFIED_CALLER_BOUNDS"): + result = audit_soko_certificate({"epistemic_status": status}) + self.assertEqual(result["epistemic_status"], status) + bounded = audit_soko_certificate( + {"epistemic_status": "VERIFIED_ON_BOUNDED_REACHABLE_SUBGRAPH", "complete_space": True} + ) + self.assertEqual(bounded["epistemic_status"], "VERIFIED_ON_BOUNDED_REACHABLE_SUBGRAPH") + + def test_bare_proven_is_still_rejected(self) -> None: + result = audit_soko_certificate({"epistemic_status": "PROVEN"}) + _require(not bool(result["passed"]), f"bare PROVEN passed: {result}") + self.assertEqual(result["epistemic_status"], "REJECTED") + if __name__ == "__main__": unittest.main()