Python

python3 -m venv .venv && . .venv/bin/activate && pip install -r requirements.txt

cryptography>=41,<46

# Silvector quickstart for Python 3.9 or later.
# Run: pip install -r requirements.txt && python3 quickstart.py
import base64
import http.client
import json
import os
import sys
from urllib.parse import urlsplit

from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

API = urlsplit(os.environ.get("SILVECTOR_API", "https://api.silvector.com"))
if API.scheme not in ("https", "http") or not API.netloc:
    sys.exit("SILVECTOR_API must be an http or https URL")


def canonical(value):
    """Canonical JSON: keys sorted, no whitespace, integers only.

    Keys sort by UTF-16 code unit, as the signer's JavaScript does, which differs from
    Python's code point order for characters outside the Basic Multilingual Plane."""
    if isinstance(value, float):
        raise ValueError("receipts carry integers only")
    if isinstance(value, dict):
        keys = sorted(value, key=lambda k: k.encode("utf-16-be", "surrogatepass"))
        return "{" + ",".join(canonical(k) + ":" + canonical(value[k]) for k in keys) + "}"
    if isinstance(value, list):
        return "[" + ",".join(canonical(v) for v in value) + "]"
    if isinstance(value, str):
        # JavaScript escapes a lone surrogate; json.dumps would emit it raw.
        return "".join(f"\\u{ord(c):04x}" if 0xD800 <= ord(c) <= 0xDFFF else c for c in json.dumps(value, ensure_ascii=False))
    return json.dumps(value)


def b64url(text):
    return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))


def request(path, body=None):
    # A deny or step-up decision answers 403 or 401 with a receipt, so read the body whatever the status.
    connection = (http.client.HTTPSConnection if API.scheme == "https" else http.client.HTTPConnection)(API.netloc, timeout=15)
    try:
        connection.request(
            "GET" if body is None else "POST",
            API.path.rstrip("/") + path,
            body=None if body is None else json.dumps(body),
            headers={"content-type": "application/json", "user-agent": "silvector-quickstart-python"},
        )
        return json.loads(connection.getresponse().read())
    finally:
        connection.close()


def verifies(receipt, jwk):
    try:
        Ed25519PublicKey.from_public_bytes(b64url(jwk["x"])).verify(b64url(receipt["sig"]), canonical(receipt["body"]).encode())
        return True
    except InvalidSignature:
        return False


# 1. Ask for a decision. The response carries a signed receipt.
decision = request("/v1/check", {"method": "GET", "path": "/pricing"})
receipt = decision["receipt"]

# 2. Fetch the published keys.
keys = [k for k in request("/.well-known/jwks.json")["keys"] if k.get("kty") == "OKP" and k.get("crv") == "Ed25519"]

# 3. Verify with the one key whose kid equals the receipt's agent_kid. Other published
# keys sign other things, so never fall back to them.
key = next((k for k in keys if k.get("kid") == receipt["body"]["agent_kid"]), None)
verified = key is not None and verifies(receipt, key)

# 4. Change one field and check that the signature no longer holds.
tampered = {"body": dict(receipt["body"], outcome="deny" if receipt["body"]["outcome"] == "allow" else "allow"), "sig": receipt["sig"]}
tampered_verifies = key is not None and verifies(tampered, key)

print(f"receipt: {decision['receiptId']}")
print(f"outcome: {receipt['body']['outcome']} (rule {receipt['body']['rule_id']})")
print(f"key: {key['kid'] if key else 'none published for ' + receipt['body']['agent_kid']}")
print(f"verified: {'true' if verified else 'false'}")
print(f"tampered copy verifies: {'true' if tampered_verifies else 'false'}")
print("evidence grade: rung 2 Operational, confidence none, uncalibrated (assigned by the docs, not a signed field)")
sys.exit(0 if verified and not tampered_verifies else 1)

python3 quickstart.py