Report Verifier

Verify without Forge

Forge reports are self-contained cryptographic artifacts. You do not need this website or any Forge software to verify them. The Ed25519 public key and signature are embedded in every report. Use any standard cryptographic library to verify independently.

Python (cryptography library)

import json, base64
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

report = json.load(open("report.json"))

# Extract signature and public key
sig = base64.b64decode(report.pop("signature"))
pub_bytes = base64.b64decode(report.pop("pub_key_b64"))
report.pop("paired_run_id", None)
report.pop("_verification", None)

# Reconstruct the exact payload that was signed
payload = json.dumps(report, sort_keys=True).encode("utf-8")

# Verify
key = Ed25519PublicKey.from_public_bytes(pub_bytes)
key.verify(sig, payload)  # raises InvalidSignature if tampered
print("Signature valid.")

Node.js (built-in crypto)

const crypto = require('crypto');
const report = JSON.parse(require('fs').readFileSync('report.json'));

const sig = Buffer.from(report.signature, 'base64');
const pub = Buffer.from(report.pub_key_b64, 'base64');
delete report.signature; delete report.pub_key_b64;
delete report.paired_run_id; delete report._verification;

// Sort keys to match Python json.dumps(sort_keys=True)
const sorted = {};
Object.keys(report).sort().forEach(k => sorted[k] = report[k]);
const payload = JSON.stringify(sorted);
const key = crypto.createPublicKey({
  key: Buffer.concat([Buffer.from('302a300506032b6570032100','hex'), pub]),
  format: 'der', type: 'spki'
});
const valid = crypto.verify(null, payload, key, sig);
console.log(valid ? 'Signature valid.' : 'TAMPERED.');

Command line (OpenSSL)

# Extract public key to PEM
echo "MCowBQYDK2VwAyEA$(jq -r .pub_key_b64 report.json)" | base64 -d | \
  openssl pkey -inform DER -pubin -out pub.pem

# Build canonical payload (strip sig fields, sort keys)
python3 -c "
import json; r=json.load(open('report.json'))
for k in ['signature','pub_key_b64','paired_run_id','_verification']:
    r.pop(k, None)
open('payload.bin','wb').write(json.dumps(r,sort_keys=True).encode())
"

# Extract raw signature
jq -r .signature report.json | base64 -d > sig.bin

# Verify
openssl pkeyutl -verify -pubin -inkey pub.pem \
  -sigfile sig.bin -rawin -in payload.bin

Hash chain verification

Each scenario result includes entry_hash and prev_hash. Walk the array and verify that each entry's prev_hash matches the previous entry's entry_hash. The first entry's prev_hash is an empty string. Any missing, reordered, or modified entry breaks the chain.

import json
report = json.load(open("report.json"))
prev = ""
for i, r in enumerate(report["results"]):
    if r["prev_hash"] != prev:
        print(f"Chain broken at scenario {i}: {r['scenario_id']}")
        break
    prev = r["entry_hash"]
else:
    print(f"Hash chain intact: {len(report['results'])} entries verified.")

Forge does not control the Ed25519 algorithm, the SHA-512 hash function, or the JSON canonical encoding. These are open, auditable standards. Any competent security team can verify a Forge report without trusting Forge.