Receipt Verification

"""Verify every exported receipt using separately selected trusted signers."""
import argparse
import json
from pathlib import Path
from chio.invariants import verify_receipt_with_trusted_signers


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('receipts', nargs='?', type=Path, default=Path('fixtures/minimal-evidence/receipts.ndjson'))
    parser.add_argument('--trusted-signers', type=Path, default=Path('trusted-signers.json'))
    args = parser.parse_args()
    signers = json.loads(args.trusted_signers.read_text())
    if not isinstance(signers, list) or not signers or not all(isinstance(key, str) for key in signers):
        parser.error('trusted-signers must be a nonempty JSON array of public keys')
    records = [json.loads(line) for line in args.receipts.read_text().splitlines() if line.strip()]
    if not records:
        parser.error('receipt file is empty')
    results = [verify_receipt_with_trusted_signers(record.get('receipt', record), signers) for record in records]
    print(json.dumps(results, indent=2))
    return 0 if all(result['ok'] for result in results) else 1


if __name__ == '__main__':
    raise SystemExit(main())

import { readFileSync } from 'node:fs';
import { verifyReceiptWithTrustedSigners } from '@chio-protocol/sdk/invariants';
const [receipts = 'fixtures/minimal-evidence/receipts.ndjson', trust = 'trusted-signers.json'] = process.argv.slice(2);
const signers = JSON.parse(readFileSync(trust, 'utf8'));
if (!Array.isArray(signers) || !signers.length || signers.some(key => typeof key !== 'string')) throw Error('Trusted signers must be a nonempty JSON array of public keys');
const records = readFileSync(receipts, 'utf8').split('\n').filter(line => line.trim()).map(JSON.parse);
if (!records.length) throw Error('Receipt file is empty');
const results = records.map(record => verifyReceiptWithTrustedSigners(record.receipt ?? record, signers));
console.log(JSON.stringify(results, null, 2));
process.exitCode = results.every(result => result.ok) ? 0 : 1;

package main

import (
	"bufio"
	"encoding/json"
	"flag"
	"fmt"
	"github.com/backbay-labs/chio/sdks/go/chio-go/invariants"
	"os"
)

func run() error {
	trust := flag.String("trusted-signers", "trusted-signers.json", "JSON array of independently selected trusted public keys")
	flag.Parse()
	receiptPath := "fixtures/minimal-evidence/receipts.ndjson"
	if flag.NArg() > 0 {
		receiptPath = flag.Arg(0)
	}
	keys, err := os.ReadFile(*trust)
	if err != nil {
		return err
	}
	var signers []string
	if err := json.Unmarshal(keys, &signers); err != nil {
		return err
	}
	if len(signers) == 0 {
		return fmt.Errorf("trusted signer set is empty")
	}
	f, err := os.Open(receiptPath)
	if err != nil {
		return err
	}
	defer f.Close()
	scanner := bufio.NewScanner(f)
	scanner.Buffer(make([]byte, 4096), 4*1024*1024)
	count := 0
	valid := true
	for scanner.Scan() {
		if len(scanner.Bytes()) == 0 {
			continue
		}
		var record map[string]any
		if err := json.Unmarshal(scanner.Bytes(), &record); err != nil {
			return err
		}
		receipt, ok := record["receipt"].(map[string]any)
		if !ok {
			receipt = record
		}
		result, err := invariants.VerifyReceiptWithTrustedSigners(receipt, signers)
		if err != nil {
			return err
		}
		out, err := json.MarshalIndent(result, "", "  ")
		if err != nil {
			return err
		}
		fmt.Println(string(out))
		valid = valid && result.Ok
		count++
	}
	if err := scanner.Err(); err != nil {
		return err
	}
	if count == 0 || !valid {
		return fmt.Errorf("receipt verification failed")
	}
	return nil
}
func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

"""Require semantic rejection even after an attacker updates package checksums."""

import argparse
import hashlib
import json
import os
from pathlib import Path
import shutil
import subprocess
import tempfile


def check(binary, original, destination):
    destination.mkdir(parents=True, exist_ok=True)
    subprocess.run(
        [binary, "evidence", "verify", "--input", str(original), "--json"],
        check=True,
        capture_output=True,
        timeout=60,
    )
    cases = []
    for name in ("unsigned-lineage", "changed-signed-token", "changed-receipt"):
        package = destination / name
        shutil.copytree(original, package)
        relative = "receipts.ndjson" if name == "changed-receipt" else "capability-lineage.ndjson"
        path = package / relative
        records = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
        if name == "unsigned-lineage":
            records[0].pop("signed_capability")
            records[0]["provenance"] = "legacy_projection"
        elif name == "changed-signed-token":
            records[0]["signed_capability"]["subject"] = "01" * 32
        else:
            records[0]["receipt"]["tool_name"] = "substituted_tool"
        path.write_text("".join(json.dumps(record) + "\n" for record in records))
        manifest_path = package / "manifest.json"
        manifest = json.loads(manifest_path.read_text())
        for entry in manifest["files"]:
            payload = (package / entry["path"]).read_bytes()
            entry["sha256"] = hashlib.sha256(payload).hexdigest()
            entry["bytes"] = len(payload)
        manifest_path.write_text(json.dumps(manifest, indent=2) + "\n")
        result = subprocess.run(
            [binary, "evidence", "verify", "--input", str(package), "--json"],
            capture_output=True,
            text=True,
            timeout=60,
        )
        (destination / (name + ".stdout.json")).write_text(result.stdout)
        (destination / (name + ".stderr.txt")).write_text(result.stderr)
        if result.returncode == 0:
            raise ValueError("Rehashed malicious package was accepted: " + name)
        # A verifier crash or CLI usage error is not a successful refusal.
        output = json.loads(result.stderr)
        if not output.get("code", "").startswith("urn:chio:error:attest:"):
            raise ValueError("Expected a structured semantic verification failure: " + name)
        cases.append(name)
    return {"refused_rehashed_packages": cases}


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--chio", default=os.environ.get("CHIO_BIN") or shutil.which("chio"))
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()
    if not args.chio:
        parser.error("Install the matching Chio CLI or set CHIO_BIN")
    root = Path(__file__).resolve().parent
    if args.output:
        print(json.dumps(check(args.chio, root / "fixtures/minimal-evidence", args.output)))
    else:
        with tempfile.TemporaryDirectory(prefix="chio-rehashed-evidence-") as temporary:
            print(json.dumps(check(args.chio, root / "fixtures/minimal-evidence", Path(temporary))))