witnora 0.9.3 → 0.10.2

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

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from decimal import Decimal, InvalidOperation
+from typing import Any
+
+from .errors import VerificationError, require
+
+CANONICAL_VERSION = "witnora.canonical_json.v0.2"
+MAX_SAFE_INTEGER = (1 << 53) - 1
+MAX_DEPTH = 64
+
+
+def loads_strict(data: str | bytes | bytearray) -> Any:
+    """Parse JSON while retaining enough lexical information to reject ambiguity."""
+
+    if isinstance(data, (bytes, bytearray)):
+        try:
+            text = bytes(data).decode("utf-8", "strict")
+        except UnicodeDecodeError as exc:
+            raise VerificationError("INVALID_UTF8", "JSON input is not valid UTF-8.") from exc
+    elif isinstance(data, str):
+        text = data
+    else:
+        raise VerificationError("INVALID_INPUT", "JSON input must be text or UTF-8 bytes.")
+
+    def object_pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for key, value in pairs:
+            if key in output:
+                raise VerificationError(
+                    "DUPLICATE_KEY", f"Duplicate object key {key!r} is forbidden."
+                )
+            output[key] = value
+        return output
+
+    def parse_int(token: str) -> int:
+        if token == "-0":
+            raise VerificationError("NEGATIVE_ZERO", "Negative zero is forbidden.")
+        value = int(token, 10)
+        require(
+            abs(value) <= MAX_SAFE_INTEGER,
+            "UNSAFE_INTEGER",
+            "Integer exceeds the interoperable safe range.",
+        )
+        return value
+
+    def parse_decimal(token: str) -> int:
+        try:
+            value = Decimal(token)
+        except InvalidOperation as exc:
+            raise VerificationError("INVALID_NUMBER", "Decimal token is invalid.") from exc
+        require(value.is_finite(), "NON_FINITE_NUMBER", "Non-finite numbers are forbidden.")
+        require(
+            not value.is_zero() or not value.is_signed(),
+            "NEGATIVE_ZERO",
+            "Negative zero is forbidden.",
+        )
+        require(
+            value == value.to_integral_value(),
+            "NON_INTEGER_NUMBER",
+            "JSON numbers must be safe integers; encode decimals as normalized strings.",
+        )
+        integer = int(value)
+        require(
+            abs(integer) <= MAX_SAFE_INTEGER,
+            "UNSAFE_INTEGER",
+            "Integer exceeds the interoperable safe range.",
+        )
+        return integer
+
+    def parse_constant(token: str) -> Any:
+        raise VerificationError("NON_FINITE_NUMBER", f"{token} is forbidden.")
+
+    try:
+        value = json.loads(
+            text,
+            object_pairs_hook=object_pairs,
+            parse_int=parse_int,
+            parse_float=parse_decimal,
+            parse_constant=parse_constant,
+        )
+    except VerificationError:
+        raise
+    except (json.JSONDecodeError, UnicodeError) as exc:
+        raise VerificationError("INVALID_JSON", "Input is not strict JSON.") from exc
+    _validate_value(value, depth=0)
+    return value
+
+
+def canonical_json(value: Any) -> str:
+    """Return the frozen Witnora v0.2 canonical JSON representation."""
+
+    _validate_value(value, depth=0)
+    return _encode(value)
+
+
+def canonical_bytes(value: Any) -> bytes:
+    try:
+        return canonical_json(value).encode("utf-8", "strict")
+    except UnicodeEncodeError as exc:
+        raise VerificationError(
+            "INVALID_UNICODE", "Canonical JSON contains an unpaired surrogate."
+        ) from exc
+
+
+def sha256_canonical(value: Any) -> str:
+    return hashlib.sha256(canonical_bytes(value)).hexdigest()
+
+
+def _encode(value: Any) -> str:
+    if value is None:
+        return "null"
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, Decimal):
+        return str(int(value))
+    if isinstance(value, float):
+        return str(int(value))
+    if isinstance(value, (list, tuple)):
+        return "[" + ",".join(_encode(item) for item in value) + "]"
+    if isinstance(value, dict):
+        return (
+            "{"
+            + ",".join(
+                f"{json.dumps(key, ensure_ascii=False, separators=(',', ':'))}:{_encode(value[key])}"
+                for key in sorted(value, key=_utf16_sort_key)
+            )
+            + "}"
+        )
+    raise VerificationError(
+        "UNSUPPORTED_TYPE", f"Type {type(value).__name__} is not canonical JSON."
+    )
+
+
+def _validate_value(value: Any, depth: int) -> None:
+    require(
+        depth <= MAX_DEPTH,
+        "MAX_DEPTH_EXCEEDED",
+        f"JSON exceeds the v0.2 nesting limit of {MAX_DEPTH}.",
+    )
+    if value is None or isinstance(value, bool):
+        return
+    if isinstance(value, str):
+        _validate_unicode(value)
+        return
+    if isinstance(value, int):
+        require(
+            abs(value) <= MAX_SAFE_INTEGER,
+            "UNSAFE_INTEGER",
+            "Integer exceeds the interoperable safe range.",
+        )
+        return
+    if isinstance(value, Decimal):
+        _validate_number(value)
+        return
+    if isinstance(value, float):
+        require(math.isfinite(value), "NON_FINITE_NUMBER", "Non-finite numbers are forbidden.")
+        require(
+            not (value == 0 and math.copysign(1.0, value) < 0),
+            "NEGATIVE_ZERO",
+            "Negative zero is forbidden.",
+        )
+        _validate_number(Decimal(str(value)))
+        return
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            _validate_value(item, depth + 1)
+        return
+    if isinstance(value, dict):
+        for key, item in value.items():
+            require(isinstance(key, str), "NON_STRING_KEY", "Object keys must be strings.")
+            _validate_unicode(key)
+            _validate_value(item, depth + 1)
+        return
+    raise VerificationError(
+        "UNSUPPORTED_TYPE", f"Type {type(value).__name__} is not canonical JSON."
+    )
+
+
+def _validate_unicode(value: str) -> None:
+    try:
+        value.encode("utf-8", "strict")
+    except UnicodeEncodeError as exc:
+        raise VerificationError(
+            "INVALID_UNICODE", "Unpaired Unicode surrogates are forbidden."
+        ) from exc
+
+
+def _validate_number(value: Decimal) -> None:
+    require(value.is_finite(), "NON_FINITE_NUMBER", "Non-finite numbers are forbidden.")
+    require(
+        not value.is_zero() or not value.is_signed(), "NEGATIVE_ZERO", "Negative zero is forbidden."
+    )
+    require(
+        value == value.to_integral_value(),
+        "NON_INTEGER_NUMBER",
+        "JSON numbers must be safe integers; encode decimals as normalized strings.",
+    )
+    require(
+        abs(value) <= MAX_SAFE_INTEGER,
+        "UNSAFE_INTEGER",
+        "Integer exceeds the interoperable safe range.",
+    )
+
+
+def _utf16_sort_key(value: str) -> bytes:
+    """Match JavaScript Array.sort() ordering for cross-language object keys."""
+
+    return value.encode("utf-16-be", "surrogatepass")

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

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from .canonical import canonical_json, loads_strict, sha256_canonical
+from .conformance import verify_conformance_directory
+from .errors import VerificationError
+from .event_chain import verify_event_chain
+from .evidence import verify_evidence_packet
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="witnora-verify", description="Offline Witnora v0.2 verifier"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for command in ("canonical", "digest"):
+        child = subparsers.add_parser(command)
+        child.add_argument("input", type=Path)
+    event = subparsers.add_parser("event-chain")
+    event.add_argument("input", type=Path)
+    conformance = subparsers.add_parser("conformance")
+    conformance.add_argument("directory", type=Path)
+    evidence = subparsers.add_parser("evidence")
+    evidence.add_argument("packet", type=Path)
+    evidence.add_argument("--root", required=True, type=Path)
+    evidence.add_argument("--revocation-journal", required=True, type=Path)
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command in {"canonical", "digest"}:
+            value = loads_strict(args.input.read_bytes())
+            print(canonical_json(value) if args.command == "canonical" else sha256_canonical(value))
+        elif args.command == "event-chain":
+            events = loads_strict(args.input.read_bytes())
+            print(
+                json.dumps(
+                    {"valid": True, "headDigest": verify_event_chain(events), "networkUsed": False},
+                    separators=(",", ":"),
+                )
+            )
+        elif args.command == "conformance":
+            report = verify_conformance_directory(args.directory)
+            print(json.dumps(report.as_dict(), separators=(",", ":"), sort_keys=True))
+            return 0 if report.overall == "PASS" else 1
+        else:
+            packet = loads_strict(args.packet.read_bytes())
+            root = loads_strict(args.root.read_bytes())
+            journal = (
+                loads_strict(args.revocation_journal.read_bytes())
+                if args.revocation_journal
+                else None
+            )
+            report = verify_evidence_packet(packet, root, latest_revocation_journal=journal)
+            print(json.dumps(report, separators=(",", ":"), sort_keys=True))
+            return 0 if report["overall"] == "PASS" else 1
+        return 0
+    except (OSError, VerificationError, ValueError, TypeError) as error:
+        code = error.code if isinstance(error, VerificationError) else "VERIFICATION_FAILED"
+        print(
+            json.dumps(
+                {"valid": False, "code": code, "message": str(error), "networkUsed": False},
+                separators=(",", ":"),
+            ),
+            file=sys.stderr,
+        )
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from .canonical import canonical_bytes, loads_strict, sha256_canonical
+from .errors import VerificationError
+from .event_chain import verify_event_chain
+from .probe import verify_probe_exchange
+from .trust import PinnedTrustStore, verify_key_certificate, verify_revocation_journal
+
+
+@dataclass(frozen=True)
+class ConformanceReport:
+    schema_version: str
+    overall: str
+    case_count: int
+    passed: int
+    failed: int
+    network_used: bool
+    failures: tuple[str, ...]
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "schemaVersion": self.schema_version,
+            "overall": self.overall,
+            "caseCount": self.case_count,
+            "passed": self.passed,
+            "failed": self.failed,
+            "networkUsed": self.network_used,
+            "failures": list(self.failures),
+        }
+
+
+def verify_conformance_directory(directory: str | Path) -> ConformanceReport:
+    root = Path(directory)
+    failures: list[str] = []
+    passed = 0
+    case_count = 0
+
+    vectors = _read_json(root / "canonical-vectors.json")
+    for vector in vectors["vectors"]:
+        case_count += 1
+        try:
+            parsed = loads_strict(vector["rawJson"])
+            canonical = canonical_bytes(parsed)
+            if not vector["valid"]:
+                failures.append(f"{vector['id']}: expected rejection")
+                continue
+            if (
+                canonical.hex() != vector["canonicalUtf8Hex"]
+                or sha256_canonical(parsed) != vector["sha256"]
+            ):
+                failures.append(f"{vector['id']}: canonical bytes or digest mismatch")
+                continue
+            passed += 1
+        except VerificationError as error:
+            if not vector["valid"] and error.code == vector["errorCode"]:
+                passed += 1
+            else:
+                failures.append(
+                    f"{vector['id']}: {error.code}, expected {vector.get('errorCode', 'PASS')}"
+                )
+
+    protocol = _read_json(root / "protocol-fixture.json")
+    store = PinnedTrustStore.from_roots(protocol["pinnedRoots"])
+    checks = (
+        (
+            "request-certificate",
+            lambda: verify_key_certificate(
+                protocol["requestCertificate"],
+                store,
+                expected_role="server_attestor",
+                tenant_ref=protocol["expected"]["tenantRef"],
+                project_ref=protocol["expected"]["projectRef"],
+                environment=protocol["expected"]["environment"],
+                at=protocol["request"]["requestedAt"],
+                revocation_journal=protocol["revocationJournal"],
+            ),
+        ),
+        (
+            "revocation-journal",
+            lambda: verify_revocation_journal(protocol["revocationJournal"], store),
+        ),
+        (
+            "probe-exchange",
+            lambda: verify_probe_exchange(
+                protocol["request"],
+                protocol["attestation"],
+                trust_store=store,
+                request_certificate=protocol["requestCertificate"],
+                probe_certificate=protocol["probeCertificate"],
+                revocation_journal=protocol["revocationJournal"],
+                expected=protocol["expected"],
+                now=datetime.fromisoformat(protocol["verificationTime"].replace("Z", "+00:00")),
+                max_freshness_ms=protocol["maxFreshnessMs"],
+            ),
+        ),
+        ("event-chain", lambda: verify_event_chain(protocol["events"])),
+    )
+    for name, check in checks:
+        case_count += 1
+        try:
+            check()
+            passed += 1
+        except (VerificationError, KeyError, TypeError, ValueError) as error:
+            failures.append(f"{name}: {error}")
+
+    return ConformanceReport(
+        schema_version="witnora.conformance_report.v0.2",
+        overall="PASS" if not failures else "FAIL",
+        case_count=case_count,
+        passed=passed,
+        failed=len(failures),
+        network_used=False,
+        failures=tuple(failures),
+    )
+
+
+def _read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))

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

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+from collections.abc import Mapping
+from typing import Any
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+
+from .canonical import CANONICAL_VERSION, canonical_bytes, sha256_canonical
+from .errors import VerificationError, require
+
+
+def b64url_encode(value: bytes) -> str:
+    return base64.urlsafe_b64encode(value).rstrip(b"=").decode("ascii")
+
+
+def b64url_decode(value: str, expected_length: int | None = None) -> bytes:
+    require(
+        isinstance(value, str) and value != "",
+        "INVALID_BASE64URL",
+        "A non-empty base64url value is required.",
+    )
+    require(
+        "=" not in value and "+" not in value and "/" not in value,
+        "INVALID_BASE64URL",
+        "Padded or standard base64 is forbidden.",
+    )
+    try:
+        raw = base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
+    except (ValueError, TypeError) as exc:
+        raise VerificationError(
+            "INVALID_BASE64URL", "Value is not valid unpadded base64url."
+        ) from exc
+    if expected_length is not None:
+        require(
+            len(raw) == expected_length, "INVALID_KEY_LENGTH", f"Expected {expected_length} bytes."
+        )
+    return raw
+
+
+def public_key_text(public_key: Ed25519PublicKey) -> str:
+    return public_key.public_bytes(
+        serialization.Encoding.PEM,
+        serialization.PublicFormat.SubjectPublicKeyInfo,
+    ).decode("ascii")
+
+
+def private_key_text(private_key: Ed25519PrivateKey) -> str:
+    return private_key.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.PKCS8,
+        serialization.NoEncryption(),
+    ).decode("ascii")
+
+
+def private_key_from_seed(seed: bytes) -> Ed25519PrivateKey:
+    return Ed25519PrivateKey.from_private_bytes(hashlib.sha256(seed).digest())
+
+
+def sign_value(value: Any, private_key: Ed25519PrivateKey, key_id: str) -> dict[str, str]:
+    payload = canonical_bytes(value)
+    return {
+        "algorithm": "Ed25519",
+        "canonicalization": CANONICAL_VERSION,
+        "keyId": key_id,
+        "valueDigest": hashlib.sha256(payload).hexdigest(),
+        "signature": b64url_encode(private_key.sign(payload)),
+    }
+
+
+def sign_document(value: Any, private_key: Ed25519PrivateKey) -> str:
+    return base64.b64encode(private_key.sign(canonical_bytes(value))).decode("ascii")
+
+
+def verify_document_signature(value: Any, signature: str, public_key_pem: str) -> None:
+    try:
+        public_key = serialization.load_pem_public_key(public_key_pem.encode("ascii"))
+        require(
+            isinstance(public_key, Ed25519PublicKey),
+            "INVALID_PUBLIC_KEY",
+            "Public key must be Ed25519.",
+        )
+        public_key.verify(base64.b64decode(signature, validate=True), canonical_bytes(value))
+    except VerificationError:
+        raise
+    except (InvalidSignature, ValueError, TypeError) as exc:
+        raise VerificationError("SIGNATURE_INVALID", "Ed25519 signature is invalid.") from exc
+
+
+def verify_signed_value(
+    value: Any,
+    signature: Mapping[str, Any],
+    public_key_text_value: str,
+    expected_key_id: str | None = None,
+) -> None:
+    require(
+        signature.get("algorithm") == "Ed25519",
+        "SIGNATURE_ALGORITHM_MISMATCH",
+        "Ed25519 is required.",
+    )
+    require(
+        signature.get("canonicalization") == CANONICAL_VERSION,
+        "CANONICAL_VERSION_MISMATCH",
+        "Signature uses a different canonical profile.",
+    )
+    if expected_key_id is not None:
+        require(
+            signature.get("keyId") == expected_key_id,
+            "SIGNATURE_KEY_MISMATCH",
+            "Signature key ID does not match.",
+        )
+    payload = canonical_bytes(value)
+    require(
+        hmac.compare_digest(str(signature.get("valueDigest", "")), sha256_canonical(value)),
+        "SIGNED_DIGEST_MISMATCH",
+        "Signed value digest does not match canonical bytes.",
+    )
+    try:
+        public_key = serialization.load_pem_public_key(public_key_text_value.encode("ascii"))
+    except (ValueError, TypeError) as exc:
+        raise VerificationError("INVALID_PUBLIC_KEY", "Public key PEM is invalid.") from exc
+    require(
+        isinstance(public_key, Ed25519PublicKey),
+        "INVALID_PUBLIC_KEY",
+        "Public key must be Ed25519.",
+    )
+    try:
+        public_key.verify(b64url_decode(str(signature.get("signature", "")), 64), payload)
+    except InvalidSignature as exc:
+        raise VerificationError("SIGNATURE_INVALID", "Ed25519 signature is invalid.") from exc
+
+
+def signed_body(document: Mapping[str, Any]) -> dict[str, Any]:
+    require("signature" in document, "SIGNATURE_MISSING", "Signed document has no signature.")
+    return {key: value for key, value in document.items() if key != "signature"}

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

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+
+class VerificationError(ValueError):
+    """A deterministic, machine-actionable verification failure."""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(f"{code}: {message}")
+        self.code = code
+        self.message = message
+
+
+def require(condition: bool, code: str, message: str) -> None:
+    if not condition:
+        raise VerificationError(code, message)

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

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from typing import Any
+
+from .canonical import sha256_canonical
+from .errors import require
+from .trust import parse_timestamp
+
+EVENT_CHAIN_VERSION = "witnora.event_hash_chain.v0.2"
+
+
+def make_event(
+    *,
+    sequence: int,
+    event_type: str,
+    occurred_at: str,
+    previous_hash: str | None,
+    payload_digest: str,
+) -> dict[str, Any]:
+    body = {
+        "sequence": sequence,
+        "type": event_type,
+        "occurredAt": occurred_at,
+        "previousHash": previous_hash,
+        "payloadDigest": payload_digest,
+    }
+    return {**body, "eventHash": sha256_canonical(body)}
+
+
+def verify_event_chain(events: Sequence[Mapping[str, Any]]) -> str:
+    require(bool(events), "EVENT_CHAIN_EMPTY", "Event chain must contain at least one event.")
+    previous_hash: str | None = None
+    previous_time: datetime | None = None
+    seen_hashes: set[str] = set()
+    for index, event in enumerate(events):
+        expected_sequence = index + 1
+        require(
+            event.get("sequence") == expected_sequence,
+            "EVENT_SEQUENCE_GAP",
+            f"Expected event sequence {expected_sequence}.",
+        )
+        require(
+            event.get("previousHash") == previous_hash,
+            "EVENT_PREVIOUS_HASH_MISMATCH",
+            f"Event {expected_sequence} does not reference its predecessor.",
+        )
+        payload_digest = str(event.get("payloadDigest", ""))
+        _require_sha256(payload_digest, "EVENT_PAYLOAD_DIGEST_INVALID")
+        occurred_at = parse_timestamp(event.get("occurredAt"), f"events[{index}].occurredAt")
+        require(
+            previous_time is None or occurred_at >= previous_time,
+            "EVENT_TIME_NON_MONOTONIC",
+            "Event time moved backwards.",
+        )
+        body = {
+            key: event.get(key)
+            for key in ("sequence", "type", "occurredAt", "previousHash", "payloadDigest")
+        }
+        event_hash = str(event.get("eventHash", ""))
+        _require_sha256(event_hash, "EVENT_HASH_INVALID")
+        require(
+            event_hash == sha256_canonical(body),
+            "EVENT_HASH_MISMATCH",
+            f"Event {expected_sequence} hash is invalid.",
+        )
+        require(event_hash not in seen_hashes, "EVENT_HASH_DUPLICATE", "Event hash is duplicated.")
+        seen_hashes.add(event_hash)
+        previous_hash = event_hash
+        previous_time = occurred_at
+    return previous_hash or ""
+
+
+def _require_sha256(value: str, code: str) -> None:
+    require(
+        len(value) == 64 and all(character in "0123456789abcdef" for character in value),
+        code,
+        "A lowercase SHA-256 hex digest is required.",
+    )