witnora 0.9.3 → 0.10.2

package/dist/vendor/witnora-verifier-python/src/witnora_verifier/evidence.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import UTC, datetime
+from typing import Any
+
+from .canonical import sha256_canonical
+from .crypto import verify_document_signature
+from .errors import VerificationError, require
+from .probe import verify_probe_exchange
+from .trust import (
+    PinnedTrustStore,
+    assert_revocation_journal_extends,
+    parse_timestamp,
+    verify_key_certificate,
+    verify_revocation_journal,
+)
+
+EVIDENCE_VERSION = "witnora.verifiable_evidence_packet.v0.2"
+
+
+def verify_evidence_packet(
+    packet: Mapping[str, Any],
+    pinned_root: Mapping[str, Any],
+    *,
+    at: datetime | None = None,
+    latest_revocation_journal: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    failures: list[str] = []
+    required = (
+        "approval",
+        "grant",
+        "executionAttempt",
+        "reconciliation",
+        "probeRequest",
+        "probeAttestation",
+        "trust",
+        "separation",
+        "privacy",
+        "evidenceStrength",
+        "gatewaySignature",
+    )
+    if packet.get("protocolVersion") != EVIDENCE_VERSION or any(
+        key not in packet for key in required
+    ):
+        return _failed("Evidence packet v0.2 is structurally incomplete.")
+
+    cryptographically_valid = True
+    trusted_by_pinned_root = True
+    try:
+        store = PinnedTrustStore.from_roots([pinned_root])
+        trust = packet["trust"]
+        require(
+            trust.get("rootId") == pinned_root.get("rootId"),
+            "UNPINNED_ROOT",
+            "Packet does not reference the caller-pinned root.",
+        )
+        require(
+            latest_revocation_journal is not None,
+            "LATEST_REVOCATION_REQUIRED",
+            "Caller must supply the latest trusted revocation journal.",
+        )
+        journal = latest_revocation_journal
+        verify_revocation_journal(journal, store)
+        assert_revocation_journal_extends(trust["revocationJournal"], journal)
+        request_signer_certificate = trust["requestSignerCertificate"]
+        verify_key_certificate(
+            request_signer_certificate,
+            store,
+            expected_role="server_attestor",
+            tenant_ref=str(packet["tenantRef"]),
+            project_ref=str(packet["projectRef"]),
+            environment=str(packet["environment"]),
+            at=str(packet["probeRequest"]["requestedAt"]),
+            revocation_journal=journal,
+        )
+        gateway_certificate = trust["gatewayCertificate"]
+        verify_key_certificate(
+            gateway_certificate,
+            store,
+            expected_role="gateway_runtime",
+            tenant_ref=str(packet["tenantRef"]),
+            project_ref=str(packet["projectRef"]),
+            environment=str(packet["environment"]),
+            at=str(packet["issuedAt"]),
+            revocation_journal=journal,
+        )
+        signature = packet["gatewaySignature"]
+        require(
+            signature.get("keyId") == gateway_certificate.get("subjectKeyId"),
+            "SIGNATURE_KEY_MISMATCH",
+            "Gateway signature key ID does not match its certificate.",
+        )
+        body = {key: value for key, value in packet.items() if key != "gatewaySignature"}
+        verify_document_signature(
+            body,
+            str(signature.get("signature", "")),
+            str(gateway_certificate.get("publicKeyPem", "")),
+        )
+        expected = {
+            field: str(packet[field])
+            for field in (
+                "tenantRef",
+                "projectRef",
+                "environment",
+                "actionDigest",
+                "contractDigest",
+                "resourceCommitment",
+                "predicateDigest",
+            )
+        }
+        expected["probeId"] = str(packet["probeAttestation"]["probeId"])
+        approval_certificate = trust["approvalCertificate"]
+        grant_certificate = trust["grantCertificate"]
+        approval = packet["approval"]
+        grant = packet["grant"]
+        require(
+            approval.get("protocolVersion") == "witnora.signed_action_approval.v0.2"
+            and grant.get("protocolVersion") == "witnora.signed_execution_grant.v0.2",
+            "AUTHORIZATION_VERSION_UNSUPPORTED",
+            "Signed authorization objects must use the v0.2 protocols.",
+        )
+        for authorization_name, authorization in (("approval", approval), ("grant", grant)):
+            for field in ("tenantRef", "projectRef", "environment", "actionDigest"):
+                require(
+                    authorization.get(field) == packet.get(field),
+                    "AUTHORIZATION_SCOPE_MISMATCH",
+                    f"{authorization_name} {field} is not bound to the Evidence packet.",
+                )
+        verify_key_certificate(
+            approval_certificate,
+            store,
+            expected_role="reviewer",
+            tenant_ref=str(packet["tenantRef"]),
+            project_ref=str(packet["projectRef"]),
+            environment=str(packet["environment"]),
+            at=str(approval["approvedAt"]),
+            revocation_journal=journal,
+        )
+        verify_key_certificate(
+            grant_certificate,
+            store,
+            expected_role="resource_scope_evaluator",
+            tenant_ref=str(packet["tenantRef"]),
+            project_ref=str(packet["projectRef"]),
+            environment=str(packet["environment"]),
+            at=str(grant["issuedAt"]),
+            revocation_journal=journal,
+        )
+        require(
+            approval.get("signerKeyId") == approval_certificate.get("subjectKeyId"),
+            "APPROVAL_KEY_MISMATCH",
+            "Approval key does not match its certificate.",
+        )
+        require(
+            grant.get("issuerKeyId") == grant_certificate.get("subjectKeyId"),
+            "GRANT_KEY_MISMATCH",
+            "Grant key does not match its certificate.",
+        )
+        verify_document_signature(
+            {key: value for key, value in approval.items() if key != "signature"},
+            str(approval.get("signature", "")),
+            str(approval_certificate.get("publicKeyPem", "")),
+        )
+        verify_document_signature(
+            {key: value for key, value in grant.items() if key != "signature"},
+            str(grant.get("signature", "")),
+            str(grant_certificate.get("publicKeyPem", "")),
+        )
+        require(
+            grant.get("approvalDigest") == sha256_canonical(approval),
+            "GRANT_APPROVAL_MISMATCH",
+            "Grant is not bound to the signed approval.",
+        )
+        verification_time = at or datetime.now(UTC)
+        require(
+            parse_timestamp(grant["notBefore"], "grant.notBefore")
+            <= verification_time
+            <= parse_timestamp(grant["expiresAt"], "grant.expiresAt"),
+            "GRANT_INACTIVE",
+            "Grant is not valid at verification time.",
+        )
+        require(
+            verification_time <= parse_timestamp(approval["expiresAt"], "approval.expiresAt"),
+            "APPROVAL_EXPIRED",
+            "Approval is expired at verification time.",
+        )
+        verify_probe_exchange(
+            packet["probeRequest"],
+            packet["probeAttestation"],
+            trust_store=store,
+            request_certificate=request_signer_certificate,
+            probe_certificate=trust["probeCertificate"],
+            revocation_journal=journal,
+            expected=expected,
+            now=verification_time,
+            max_freshness_ms=300_000,
+        )
+        require(
+            packet["probeAttestation"].get("probeId")
+            == trust["probeCertificate"].get("operatorIdentity"),
+            "PROBE_IDENTITY_MISMATCH",
+            "Probe identity is not bound to the certified operator identity.",
+        )
+    except (VerificationError, KeyError, TypeError, ValueError) as error:
+        cryptographically_valid = False
+        trusted_by_pinned_root = False
+        failures.append(str(error))
+
+    approval = packet["approval"]
+    grant = packet["grant"]
+    recovery_history = packet["executionAttempt"].get("recoveryHistory", [])
+    dispatch_reconciled = (
+        packet["executionAttempt"].get("dispatchCount") == 1
+        and packet["executionAttempt"].get("state") == "RECONCILED_SUCCESS"
+        and packet["reconciliation"].get("status") == "TARGET_STATE_RECONCILED"
+        and bool(recovery_history)
+        and recovery_history[-1].get("state") == "RECONCILED_SUCCESS"
+        and sha256_canonical(recovery_history) == packet.get("eventChainDigest")
+    )
+    binding_source = packet["reconciliation"].get("authorizationBindingSource")
+    grant_use_bound = (
+        packet["probeAttestation"].get("normalizedObservation", {}).get("consumedGrantId")
+        == grant.get("grantId")
+        if binding_source == "TARGET_GRANT_ECHO"
+        else binding_source == "GATEWAY_DISPATCH_RECORD" and dispatch_reconciled
+    )
+    authorization_bound = (
+        cryptographically_valid
+        and approval.get("actionDigest") == packet.get("actionDigest")
+        and grant.get("actionDigest") == packet.get("actionDigest")
+        and grant.get("maxUses") == 1
+        and grant_use_bound
+    )
+    outcome_observed = (
+        packet["probeAttestation"].get("outcomeStatus") == "VERIFIED" and dispatch_reconciled
+    )
+    deployment_mode = packet["separation"].get("probeDeploymentMode")
+    customer_operated = (
+        deployment_mode in {"separate_process", "separate_container", "customer_network"}
+        and pinned_root.get("ownerType") == "CUSTOMER_ASSURANCE_ROOT"
+        and packet["evidenceStrength"].get("outcomeObservation") == "CUSTOMER_OPERATED_READ_PATH"
+    )
+    expected_execution = (
+        "TARGET_STATE_RECONCILED"
+        if dispatch_reconciled
+        else (
+            "DISPATCH_UNKNOWN"
+            if packet["executionAttempt"].get("state") == "DISPATCH_UNKNOWN"
+            else "NOT_ESTABLISHED"
+        )
+    )
+    expected_separation = (
+        "CUSTOMER_NETWORK_SEPARATED"
+        if deployment_mode == "customer_network"
+        else (
+            "CONTAINER_SEPARATED"
+            if deployment_mode == "separate_container"
+            else "PROCESS_SEPARATED"
+        )
+    )
+    expected_authorization = (
+        (
+            "EXACT_ACTION_GRANT_BOUND"
+            if binding_source == "TARGET_GRANT_ECHO"
+            else "GATEWAY_DISPATCH_BOUND"
+        )
+        if authorization_bound
+        else "NOT_ESTABLISHED"
+    )
+    strength_consistent = (
+        packet["evidenceStrength"].get("authorizationBinding") == expected_authorization
+        and packet["evidenceStrength"].get("executionBinding") == expected_execution
+        and packet["evidenceStrength"].get("sourceIntegrity")
+        == ("CUSTOMER_ROOT_CERTIFIED" if cryptographically_valid else "SELF_ASSERTED")
+        and packet["evidenceStrength"].get("outcomeObservation")
+        == ("CUSTOMER_OPERATED_READ_PATH" if outcome_observed else "NOT_OBSERVED")
+        and packet["evidenceStrength"].get("operatorSeparation") == expected_separation
+        and packet["evidenceStrength"].get("review") != "EXTERNAL"
+        and packet["privacy"].get("rawCanaryMatchesOutsideLocal") == 0
+    )
+    if not authorization_bound:
+        failures.append("Authorization is not bound to the exact action.")
+    if not dispatch_reconciled:
+        failures.append("Target dispatch is not reconciled.")
+    if not outcome_observed:
+        failures.append("Outcome was not independently observed.")
+    if not strength_consistent:
+        failures.append("Evidence-strength vector overclaims the packet evidence.")
+    if sha256_canonical(packet["probeRequest"]) != packet["probeAttestation"].get("requestDigest"):
+        failures.append("Probe request digest mismatch.")
+    overall = (
+        cryptographically_valid
+        and authorization_bound
+        and dispatch_reconciled
+        and outcome_observed
+        and customer_operated
+        and strength_consistent
+    )
+    return {
+        "protocolVersion": "witnora.offline_verification_report.v0.2",
+        "overall": "PASS" if overall else "FAIL",
+        "networkUsed": False,
+        "dimensions": {
+            "cryptographicallyValid": cryptographically_valid,
+            "trustedByPinnedRoot": trusted_by_pinned_root,
+            "authorizationBound": authorization_bound,
+            "dispatchReconciled": dispatch_reconciled,
+            "outcomeObserved": outcome_observed,
+            "customerOperated": customer_operated,
+            # v0.2 has no independent reviewer signature object.
+            "thirdPartyReviewed": False,
+        },
+        "failures": failures,
+    }
+
+
+def _failed(message: str) -> dict[str, Any]:
+    return {
+        "protocolVersion": "witnora.offline_verification_report.v0.2",
+        "overall": "FAIL",
+        "networkUsed": False,
+        "dimensions": dict.fromkeys(
+            (
+                "cryptographicallyValid",
+                "trustedByPinnedRoot",
+                "authorizationBound",
+                "dispatchReconciled",
+                "outcomeObserved",
+                "customerOperated",
+                "thirdPartyReviewed",
+            ),
+            False,
+        ),
+        "failures": [message],
+    }

package/dist/vendor/witnora-verifier-python/src/witnora_verifier/probe.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableSet
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any
+
+from .canonical import sha256_canonical
+from .crypto import signed_body, verify_document_signature
+from .errors import require
+from .trust import (
+    PinnedTrustStore,
+    parse_timestamp,
+    verify_key_certificate,
+    verify_revocation_journal,
+)
+
+PROBE_REQUEST_VERSION = "witnora.probe_observation_request.v0.2"
+PROBE_ATTESTATION_VERSION = "witnora.probe_observation_attestation.v0.2"
+_BINDING_FIELDS = (
+    "tenantRef",
+    "projectRef",
+    "environment",
+    "actionDigest",
+    "contractDigest",
+    "resourceCommitment",
+    "predicateDigest",
+    "probeId",
+)
+
+
+@dataclass
+class ReplayLedger:
+    request_nonces: MutableSet[str] = field(default_factory=set)
+    attestation_ids: MutableSet[str] = field(default_factory=set)
+
+    def reserve(self, request: Mapping[str, Any], attestation: Mapping[str, Any]) -> None:
+        nonce = str(request.get("nonce", ""))
+        attestation_id = str(attestation.get("attestationId", ""))
+        require(
+            nonce not in self.request_nonces,
+            "PROBE_REQUEST_REPLAY",
+            "Probe request nonce was already accepted.",
+        )
+        require(
+            attestation_id not in self.attestation_ids,
+            "PROBE_ATTESTATION_REPLAY",
+            "Probe attestation ID was already accepted.",
+        )
+        self.request_nonces.add(nonce)
+        self.attestation_ids.add(attestation_id)
+
+
+def verify_probe_exchange(
+    request: Mapping[str, Any],
+    attestation: Mapping[str, Any],
+    *,
+    trust_store: PinnedTrustStore,
+    request_certificate: Mapping[str, Any],
+    probe_certificate: Mapping[str, Any],
+    revocation_journal: Mapping[str, Any],
+    expected: Mapping[str, str],
+    now: datetime,
+    max_freshness_ms: int = 300_000,
+    replay_ledger: ReplayLedger | None = None,
+) -> None:
+    require(
+        request.get("protocolVersion") == PROBE_REQUEST_VERSION,
+        "PROBE_REQUEST_VERSION_UNSUPPORTED",
+        "Probe request is not v0.2.",
+    )
+    require(
+        attestation.get("protocolVersion") == PROBE_ATTESTATION_VERSION,
+        "PROBE_ATTESTATION_VERSION_UNSUPPORTED",
+        "Probe attestation is not v0.2.",
+    )
+    verify_revocation_journal(revocation_journal, trust_store)
+
+    requested_at = parse_timestamp(request.get("requestedAt"), "request.requestedAt")
+    not_before = parse_timestamp(request.get("notBefore"), "request.notBefore")
+    expires_at = parse_timestamp(request.get("expiresAt"), "request.expiresAt")
+    require(
+        not_before <= requested_at <= expires_at,
+        "PROBE_REQUEST_WINDOW_INVALID",
+        "Request was not issued inside its declared window.",
+    )
+    require(
+        request.get("requestSignerKeyId") == request_certificate.get("subjectKeyId"),
+        "PROBE_REQUEST_KEY_MISMATCH",
+        "Request signer does not match its certificate.",
+    )
+    verify_key_certificate(
+        request_certificate,
+        trust_store,
+        expected_role="server_attestor",
+        tenant_ref=expected["tenantRef"],
+        project_ref=expected["projectRef"],
+        environment=expected["environment"],
+        at=requested_at,
+        revocation_journal=revocation_journal,
+    )
+    verify_document_signature(
+        signed_body(request),
+        str(request.get("signature", "")),
+        str(request_certificate.get("publicKeyPem", "")),
+    )
+    _assert_bindings(request, expected, "PROBE_REQUEST_BINDING_MISMATCH")
+
+    observed_at = parse_timestamp(attestation.get("observedAt"), "attestation.observedAt")
+    require(
+        not_before <= observed_at <= expires_at,
+        "PROBE_OBSERVATION_OUTSIDE_REQUEST_WINDOW",
+        "Observation falls outside the request window.",
+    )
+    require(
+        observed_at <= now + timedelta(seconds=30),
+        "PROBE_OBSERVATION_FUTURE",
+        "Observation is future-dated beyond clock skew.",
+    )
+    freshness = int(attestation.get("dataFreshnessMs", -1))
+    require(
+        0 <= freshness <= max_freshness_ms,
+        "PROBE_OBSERVATION_STALE",
+        "Declared observation freshness exceeds the limit.",
+    )
+    require(
+        (now - observed_at).total_seconds() * 1000 <= max_freshness_ms,
+        "PROBE_OBSERVATION_STALE",
+        "Observation is stale at verification time.",
+    )
+    require(
+        attestation.get("keyCertificateId") == probe_certificate.get("certificateId"),
+        "PROBE_CERTIFICATE_MISMATCH",
+        "Attestation certificate ID does not match.",
+    )
+    verify_key_certificate(
+        probe_certificate,
+        trust_store,
+        expected_role="outcome_probe",
+        tenant_ref=expected["tenantRef"],
+        project_ref=expected["projectRef"],
+        environment=expected["environment"],
+        at=observed_at,
+        revocation_journal=revocation_journal,
+    )
+    verify_document_signature(
+        signed_body(attestation),
+        str(attestation.get("signature", "")),
+        str(probe_certificate.get("publicKeyPem", "")),
+    )
+    require(
+        attestation.get("requestId") == request.get("requestId"),
+        "PROBE_REQUEST_ID_MISMATCH",
+        "Attestation references another request.",
+    )
+    require(
+        attestation.get("requestDigest") == sha256_canonical(request),
+        "PROBE_REQUEST_DIGEST_MISMATCH",
+        "Attestation request digest is invalid.",
+    )
+    require(
+        attestation.get("nonce") == request.get("nonce"),
+        "PROBE_NONCE_MISMATCH",
+        "Attestation nonce differs from the request.",
+    )
+    _assert_bindings(attestation, expected, "PROBE_ATTESTATION_BINDING_MISMATCH")
+    require(
+        isinstance(attestation.get("limitations"), list),
+        "PROBE_LIMITATIONS_INVALID",
+        "Attestation limitations must be an array.",
+    )
+    require(
+        attestation.get("outcomeStatus") in {"VERIFIED", "NOT_VERIFIED", "INDETERMINATE"},
+        "PROBE_OUTCOME_STATUS_INVALID",
+        "Probe outcome status is invalid.",
+    )
+
+    if replay_ledger is not None:
+        replay_ledger.reserve(request, attestation)
+
+
+def _assert_bindings(value: Mapping[str, Any], expected: Mapping[str, str], code: str) -> None:
+    for field_name in _BINDING_FIELDS:
+        require(
+            value.get(field_name) == expected.get(field_name),
+            code,
+            f"Probe {field_name} binding mismatch.",
+        )

package/dist/vendor/witnora-verifier-python/src/witnora_verifier/producer.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+from .canonical import sha256_canonical
+from .crypto import public_key_text, sign_document
+from .trust import root_fingerprint
+
+
+def create_trust_root(
+    *,
+    root_id: str,
+    private_key: Ed25519PrivateKey,
+    allowed_roles: list[str],
+    organization_ref: str,
+    created_at: str,
+    not_before: str,
+    not_after: str,
+    owner_type: str = "CUSTOMER_ASSURANCE_ROOT",
+    policy_version: str = "v0.2",
+) -> dict[str, Any]:
+    public_key_pem = public_key_text(private_key.public_key())
+    return {
+        "protocolVersion": "witnora.trust_root.v0.2",
+        "rootId": root_id,
+        "publicKeyPem": public_key_pem,
+        "algorithm": "Ed25519",
+        "ownerType": owner_type,
+        "allowedRoles": allowed_roles,
+        "organizationRef": organization_ref,
+        "createdAt": created_at,
+        "notBefore": not_before,
+        "notAfter": not_after,
+        "policyVersion": policy_version,
+        "rootFingerprint": root_fingerprint(public_key_pem),
+    }
+
+
+def issue_key_certificate(
+    *,
+    root: Mapping[str, Any],
+    root_private_key: Ed25519PrivateKey,
+    subject_private_key: Ed25519PrivateKey,
+    certificate_id: str,
+    serial_number: int,
+    subject_key_id: str,
+    role: str,
+    tenant_ref: str,
+    project_ref: str,
+    environment: str,
+    operator_identity: str,
+    not_before: str,
+    not_after: str,
+) -> dict[str, Any]:
+    body = {
+        "protocolVersion": "witnora.key_certificate.v0.2",
+        "certificateId": certificate_id,
+        "serialNumber": serial_number,
+        "subjectKeyId": subject_key_id,
+        "publicKeyPem": public_key_text(subject_private_key.public_key()),
+        "issuerRootId": root["rootId"],
+        "role": role,
+        "tenantRef": tenant_ref,
+        "projectRef": project_ref,
+        "environment": environment,
+        "operatorIdentity": operator_identity,
+        "notBefore": not_before,
+        "notAfter": not_after,
+    }
+    certificate_digest = sha256_canonical(body)
+    signed = {**body, "certificateDigest": certificate_digest}
+    return {**signed, "signature": sign_document(signed, root_private_key)}
+
+
+def empty_revocation_journal(root_id: str) -> dict[str, Any]:
+    return {
+        "protocolVersion": "witnora.revocation_journal.v0.2",
+        "rootId": root_id,
+        "statements": [],
+        "checkpointDigest": sha256_canonical([]),
+    }
+
+
+def append_revocation(
+    journal: Mapping[str, Any],
+    *,
+    root_private_key: Ed25519PrivateKey,
+    revoked_id: str,
+    effective_at: str,
+    retroactive: bool,
+    reason: str,
+) -> dict[str, Any]:
+    statements = list(journal["statements"])
+    body = {
+        "protocolVersion": "witnora.key_revocation_statement.v0.2",
+        "sequence": len(statements) + 1,
+        "previousJournalDigest": journal["checkpointDigest"] if statements else None,
+        "revokedId": revoked_id,
+        "effectiveAt": effective_at,
+        "retroactive": retroactive,
+        "reason": reason,
+        "issuerRootId": journal["rootId"],
+    }
+    statement_digest = sha256_canonical(body)
+    signed = {**body, "statementDigest": statement_digest}
+    statements.append({**signed, "signature": sign_document(signed, root_private_key)})
+    return {
+        "protocolVersion": "witnora.revocation_journal.v0.2",
+        "rootId": journal["rootId"],
+        "statements": statements,
+        "checkpointDigest": sha256_canonical(statements),
+    }
+
+
+def sign_probe_request(body: Mapping[str, Any], private_key: Ed25519PrivateKey) -> dict[str, Any]:
+    value = {"protocolVersion": "witnora.probe_observation_request.v0.2", **body}
+    return {**value, "signature": sign_document(value, private_key)}
+
+
+def sign_probe_attestation(
+    body: Mapping[str, Any], private_key: Ed25519PrivateKey
+) -> dict[str, Any]:
+    value = {"protocolVersion": "witnora.probe_observation_attestation.v0.2", **body}
+    return {**value, "signature": sign_document(value, private_key)}