astrbot_plugin_private_comp.../tests/test_p5_provenance_attestation.py

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()