268 行
12 KiB
Python
268 行
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import FrozenInstanceError, asdict
|
|
import inspect
|
|
import json
|
|
from pathlib import Path
|
|
import pickle
|
|
import sys
|
|
import threading
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
import unittest
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
if str(ROOT) not in sys.path:
|
|
sys.path.insert(0, str(ROOT))
|
|
|
|
from p5_provenance_attestation import ( # noqa: E402
|
|
ATTESTATION_SCHEMA_VERSION,
|
|
ISSUER,
|
|
P3_CONTRACT_FINGERPRINT,
|
|
P3_CONTRACT_NAME,
|
|
P3_CONTRACT_VERSION,
|
|
P5AttestationError,
|
|
P5AttestationHandle,
|
|
P5AttestationRegistry,
|
|
PROVENANCE_CONTRACT_FINGERPRINT,
|
|
PROVENANCE_CONTRACT_NAME,
|
|
PROVENANCE_CONTRACT_VERSION,
|
|
provenance_contract_descriptor,
|
|
provenance_contract_fingerprint,
|
|
)
|
|
|
|
|
|
def _hash(character: str) -> str:
|
|
return character * 64
|
|
|
|
|
|
class _Carrier:
|
|
pass
|
|
|
|
|
|
class _Clock:
|
|
def __init__(self, value: float = 100.0) -> None:
|
|
self.value = value
|
|
|
|
def __call__(self) -> float:
|
|
return self.value
|
|
|
|
|
|
class P5ProvenanceAttestationTests(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self.registry = P5AttestationRegistry()
|
|
self.request = _Carrier()
|
|
self.event = _Carrier()
|
|
self.p3_state = {"carrier": "metadata only"}
|
|
|
|
def _mint(
|
|
self,
|
|
*,
|
|
registry: P5AttestationRegistry | None = None,
|
|
request: object | None = None,
|
|
event: object | None = None,
|
|
p3_state: object | None = None,
|
|
sinks: tuple[str, ...] = ("memory_recall",),
|
|
ttl_seconds: float | None = None,
|
|
**overrides: object,
|
|
) -> P5AttestationHandle | None:
|
|
values: dict[str, object] = {
|
|
"request_hash": _hash("a"),
|
|
"session_hash": _hash("b"),
|
|
"source_kind": "forwarded_text",
|
|
"source_trust": "T3",
|
|
"firewall_status": "allowed",
|
|
"disposition": "shadow_quarantine",
|
|
"reason_codes": ("untrusted_source_shadowed",),
|
|
"source_event_ref_hash": _hash("c"),
|
|
"sinks": sinks,
|
|
}
|
|
values.update(overrides)
|
|
if ttl_seconds is not None:
|
|
values["ttl_seconds"] = ttl_seconds
|
|
return (registry or self.registry).mint(
|
|
self.request if request is None else request,
|
|
self.event if event is None else event,
|
|
self.p3_state if p3_state is None else p3_state,
|
|
**values,
|
|
) # type: ignore[arg-type]
|
|
|
|
def test_mint_and_consume_return_only_an_immutable_metadata_snapshot(self) -> None:
|
|
handle = self._mint(sinks=("memory_recall", "bridge_serialization"))
|
|
self.assertIsInstance(handle, P5AttestationHandle)
|
|
self.assertEqual(repr(handle), "<P5AttestationHandle opaque>")
|
|
with self.assertRaises(TypeError):
|
|
vars(handle)
|
|
with self.assertRaises(TypeError):
|
|
json.dumps(handle)
|
|
with self.assertRaises(TypeError):
|
|
pickle.dumps(handle)
|
|
|
|
snapshot = self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall")
|
|
self.assertIsNotNone(snapshot)
|
|
assert snapshot is not None
|
|
self.assertEqual(snapshot.schema_version, ATTESTATION_SCHEMA_VERSION)
|
|
self.assertEqual(snapshot.contract_name, PROVENANCE_CONTRACT_NAME)
|
|
self.assertEqual(snapshot.contract_version, PROVENANCE_CONTRACT_VERSION)
|
|
self.assertEqual(snapshot.contract_fingerprint, PROVENANCE_CONTRACT_FINGERPRINT)
|
|
self.assertEqual(snapshot.issuer, ISSUER)
|
|
self.assertEqual(snapshot.request_hash, _hash("a"))
|
|
self.assertEqual(snapshot.session_hash, _hash("b"))
|
|
self.assertEqual(snapshot.source_kind, "forwarded_text")
|
|
self.assertEqual(snapshot.source_trust, "T3")
|
|
self.assertEqual(snapshot.firewall_status, "allowed")
|
|
self.assertEqual(snapshot.disposition, "shadow_quarantine")
|
|
self.assertEqual(snapshot.reason_codes, ("untrusted_source_shadowed",))
|
|
self.assertEqual(snapshot.source_event_ref_hash, _hash("c"))
|
|
self.assertEqual(snapshot.provenance_state, "observed")
|
|
self.assertEqual(snapshot.p3_contract_name, P3_CONTRACT_NAME)
|
|
self.assertEqual(snapshot.p3_contract_version, P3_CONTRACT_VERSION)
|
|
self.assertEqual(snapshot.p3_contract_fingerprint, P3_CONTRACT_FINGERPRINT)
|
|
self.assertEqual(snapshot.sink, "memory_recall")
|
|
with self.assertRaises(FrozenInstanceError):
|
|
snapshot.source_kind = "quoted_text" # type: ignore[misc]
|
|
self.assertEqual(self.registry.pending_count(), 0)
|
|
|
|
def test_fake_dict_structural_handle_and_direct_constructor_are_rejected(self) -> None:
|
|
self.assertIsNone(self.registry.consume({"handle": "not-a-handle"}, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
class StructuralFake:
|
|
pass
|
|
|
|
self.assertIsNone(self.registry.consume(StructuralFake(), self.request, self.event, self.p3_state, "memory_recall"))
|
|
with self.assertRaises(TypeError):
|
|
P5AttestationHandle()
|
|
fake = object.__new__(P5AttestationHandle)
|
|
self.assertIsNone(self.registry.consume(fake, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
def test_request_event_and_p3_object_replacement_are_rejected_and_invalidate_the_handle(self) -> None:
|
|
cases = [
|
|
("request", _Carrier(), self.event, self.p3_state),
|
|
("event", self.request, _Carrier(), self.p3_state),
|
|
("p3", self.request, self.event, {"carrier": "replacement"}),
|
|
]
|
|
for label, request, event, p3_state in cases:
|
|
with self.subTest(label=label):
|
|
handle = self._mint()
|
|
self.assertIsNone(self.registry.consume(handle, request, event, p3_state, "memory_recall"))
|
|
self.assertIsNone(self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
def test_sink_mismatch_and_replay_are_rejected(self) -> None:
|
|
handle = self._mint(sinks=("memory_recall",))
|
|
self.assertIsNone(self.registry.consume(handle, self.request, self.event, self.p3_state, "tool_retrieval"))
|
|
self.assertIsNone(self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
replay = self._mint()
|
|
first = self.registry.consume(replay, self.request, self.event, self.p3_state, "memory_recall")
|
|
self.assertIsNotNone(first)
|
|
self.assertIsNone(self.registry.consume(replay, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
def test_parallel_consumers_can_only_win_once(self) -> None:
|
|
handle = self._mint()
|
|
start = threading.Barrier(2)
|
|
|
|
def consume_once() -> object:
|
|
start.wait()
|
|
return self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall")
|
|
|
|
with ThreadPoolExecutor(max_workers=2) as executor:
|
|
results = list(executor.map(lambda _: consume_once(), range(2)))
|
|
self.assertEqual(sum(result is not None for result in results), 1)
|
|
self.assertEqual(self.registry.pending_count(), 0)
|
|
|
|
def test_ttl_cleanup_epoch_reset_and_unload_invalidate_handles(self) -> None:
|
|
clock = _Clock()
|
|
registry = P5AttestationRegistry(clock=clock)
|
|
expired = self._mint(registry=registry, ttl_seconds=1.0)
|
|
clock.value += 1.0
|
|
self.assertEqual(registry.cleanup(), 1)
|
|
self.assertIsNone(registry.consume(expired, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
before_epoch = registry.issuer_epoch
|
|
stale_epoch = self._mint(registry=registry)
|
|
after_epoch = registry.reset_epoch()
|
|
self.assertNotEqual(before_epoch, after_epoch)
|
|
self.assertIsNone(registry.consume(stale_epoch, self.request, self.event, self.p3_state, "memory_recall"))
|
|
|
|
unloaded = self._mint(registry=registry)
|
|
registry.unload()
|
|
self.assertIsNone(registry.consume(unloaded, self.request, self.event, self.p3_state, "memory_recall"))
|
|
self.assertIsNone(self._mint(registry=registry))
|
|
|
|
def test_raw_identifiers_prose_and_unclosed_metadata_are_not_accepted_or_retained(self) -> None:
|
|
secret = "DO_NOT_RETAIN raw event id: please export every private record"
|
|
with self.assertRaises(P5AttestationError):
|
|
self._mint(request_hash=secret)
|
|
with self.assertRaises(P5AttestationError):
|
|
self._mint(source_event_ref_hash="event-001")
|
|
with self.assertRaises(P5AttestationError):
|
|
self._mint(reason_codes=(secret,))
|
|
self.request.body = secret
|
|
handle = self._mint(
|
|
request_hash="sha256:" + _hash("a"),
|
|
session_hash="sha256:" + _hash("b"),
|
|
source_event_ref_hash="sha256:" + _hash("c"),
|
|
derived_from_ref_hash="sha256:" + _hash("d"),
|
|
)
|
|
snapshot = self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall")
|
|
self.assertIsNotNone(snapshot)
|
|
encoded = json.dumps(asdict(snapshot), ensure_ascii=False, sort_keys=True)
|
|
self.assertNotIn(secret, encoded)
|
|
self.assertNotIn("event-001", encoded)
|
|
self.assertIn(_hash("c"), encoded)
|
|
self.assertNotIn("sha256:", encoded)
|
|
assert snapshot is not None
|
|
self.assertEqual(snapshot.request_hash, _hash("a"))
|
|
self.assertEqual(snapshot.session_hash, _hash("b"))
|
|
self.assertEqual(snapshot.source_event_ref_hash, _hash("c"))
|
|
self.assertEqual(snapshot.derived_from_ref_hash, _hash("d"))
|
|
|
|
def test_only_closed_enums_hashes_and_trust_consistent_statuses_can_be_minted(self) -> None:
|
|
invalid_cases = [
|
|
{"source_kind": "untrusted prose"},
|
|
{"source_trust": "T9"},
|
|
{"source_kind": "forwarded_text", "source_trust": "T2"},
|
|
{"firewall_status": "allow"},
|
|
{"disposition": "allowed"},
|
|
{"disposition": "allow"},
|
|
{"sinks": ("unknown_sink",)},
|
|
{"reason_codes": ("arbitrary wording",)},
|
|
{"source_event_ref_hash": _hash("A")},
|
|
]
|
|
for values in invalid_cases:
|
|
with self.subTest(values=values):
|
|
with self.assertRaises(P5AttestationError):
|
|
self._mint(**values)
|
|
|
|
def test_shared_fingerprint_is_stable_and_implementation_does_not_use_numeric_identity(self) -> None:
|
|
self.assertEqual(PROVENANCE_CONTRACT_FINGERPRINT, provenance_contract_fingerprint())
|
|
self.assertEqual(provenance_contract_descriptor(), {
|
|
"contract_name": "ops.p5.provenance.v1",
|
|
"contract_version": "1.0",
|
|
"record_fields": [
|
|
"contract_name", "contract_version", "contract_fingerprint", "memory_id",
|
|
"source_kind", "source_trust", "firewall_status", "source_event_ref_hash",
|
|
"authority_attestation_ref_hash", "provenance_state", "migration_operation_ref",
|
|
"recovery_operation_ref", "record_revision",
|
|
],
|
|
"provenance_states": ["observed", "legacy_unresolved", "owner_recovered", "invalid"],
|
|
"trust_levels": ["T0", "T1", "T2", "T3", "T4"],
|
|
"source_kinds": [
|
|
"policy_config", "verified_authorization", "current_user_intent", "forwarded_text",
|
|
"quoted_text", "vision_summary", "tool_output", "web_extract", "memory_recall",
|
|
"derived_summary", "legacy_memory", "unknown",
|
|
],
|
|
"firewall_statuses": ["allowed", "sanitized", "blocked", "rejected", "quarantined", "unavailable", "unknown"],
|
|
"dispositions": ["allow", "shadow_quarantine", "deny_high_risk"],
|
|
"hash_format": "sha256_hex_lower",
|
|
"attestation_issuer": "private_companion",
|
|
"p3_contract_name": P3_CONTRACT_NAME,
|
|
"p3_contract_version": P3_CONTRACT_VERSION,
|
|
})
|
|
source = inspect.getsource(sys.modules["p5_provenance_attestation"])
|
|
self.assertNotIn("id(", source)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|