Compliance and auditing

from qwed_finance import ReceiptGenerator, VerificationEngine

receipt = ReceiptGenerator.create_receipt(
    guard_name="ComplianceGuard.verify_aml_flag",
    engine=VerificationEngine.Z3,
    llm_output="Transaction approved",
    verified=False,
    violations=["AML_CTR_THRESHOLD"]
)

print(receipt.to_json())

import hmac
import secrets

# Generate a key once per verifier and keep it outside the receipt
signing_key = secrets.token_bytes(32)

signature = receipt.get_signature(signing_key)
# "b4d30b8e..."

# Verify the receipt has not been modified (constant-time comparison)
same = hmac.compare_digest(receipt.get_signature(signing_key), signature)

from qwed_finance import AuditLog

log = AuditLog()

# Log verifications
log.log(receipt1)
log.log(receipt2)

# Get summary
summary = log.summary()
# {
#     "total_verifications": 100,
#     "passed": 95,
#     "failed": 5,
#     "pass_rate": "95.0%",
#     "by_guard": {"ComplianceGuard": 40, "QueryGuard": 60}
# }

# Export for regulators
json_export = log.export_json()

# Get all failures for investigation
failures = log.get_failures()

for receipt in failures:
    print(f"Failed: {receipt.guard_name}")
    print(f"  Input: {receipt.input_preview}")
    print(f"  Violations: {receipt.violations}")

# tests/adversarial/test_sql_jailbreaks.py

def test_delete_in_subquery():
    """DELETE hidden in subquery should be caught"""
    sql = "SELECT * FROM (DELETE FROM users WHERE id=1 RETURNING *) AS deleted"
    result = guard.verify_readonly_safety(sql)
    assert result.safe == False  # ✅ Caught

def test_mixed_case_drop():
    """DrOp TaBlE should be caught"""
    result = guard.verify_readonly_safety("DrOp TaBlE users")
    assert result.safe == False  # ✅ Caught

from pathlib import Path

signature = receipt.get_signature(signing_key)
base = f"receipt-{receipt.receipt_id}"

try:
    Path(f"{base}.json").write_text(receipt.to_json(), encoding="utf-8")
    Path(f"{base}.sig").write_text(signature, encoding="utf-8")
except OSError as exc:
    raise RuntimeError(f"receipt export failed, pair incomplete: {exc}") from exc

{
  "receipt_id": "abc-123",
  "timestamp": "2026-01-18T14:30:00.123456+00:00",
  "input_hash": "7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069",
  "input_preview": "Transaction approved",
  "guard_name": "ComplianceGuard.verify_aml_flag",
  "engine_used": "Z3",
  "status": "verified",
  "verified": true,
  "computed_value": "flag_required=True",
  "llm_value": "Transaction approved",
  "difference": null,
  "proof_steps": [
    "amount = 15000",
    "threshold = 10000",
    "15000 >= 10000 → flag_required = True",
    "llm_flagged = True",
    "llm_flagged == flag_required → COMPLIANT"
  ],
  "formula_used": "llm_flagged == flag_required",
  "violations": [],
  "metadata": {}
}

import hashlib
import hmac
import json
import os
from pathlib import Path

# The verifier's HMAC key, provisioned to the auditor out of band
signing_key = bytes.fromhex(os.environ["QWED_RECEIPT_KEY_HEX"])

# Collect receipt names from both file types, so an orphaned file is caught
directory = Path(".")
names = sorted(
    {p.stem for p in directory.glob("receipt-*.json")}
    | {p.stem for p in directory.glob("receipt-*.sig")}
)
if not names:
    raise SystemExit("no exported receipts to audit")

results = {}
failures = []
for base in names:  # "receipt-<receipt_id>"
    try:
        receipt_json = (directory / f"{base}.json").read_text(encoding="utf-8")
        stored = (directory / f"{base}.sig").read_text(encoding="utf-8")
        canonical = json.dumps(
            json.loads(receipt_json),
            sort_keys=True,
            separators=(",", ":"),
            allow_nan=False,
        )
        results[base] = hmac.compare_digest(
            hmac.new(signing_key, canonical.encode("utf-8"), hashlib.sha256).hexdigest(),
            stored,
        )
    except (OSError, ValueError, TypeError) as exc:
        # unreadable/invalid UTF-8, malformed or NaN JSON, non-ASCII signature
        results[base] = False
        failures.append(f"{base}: {exc}")
    else:
        if not results[base]:
            failures.append(f"{base}: signature mismatch")

for failure in failures:
    print(f"verification failed: {failure}")

audited_ok = all(results.values())
if not audited_ok:
    raise SystemExit(1)  # fail the audit job on any missing, unreadable, or tampered receipt