# How to independently verify this evidence

You do not need to trust cainstudio.online, mcpgate.online, or anything CAIN
says about itself. Every claim below is checkable with three files and one
command, offline, on your own machine.

## 1. Download three files

```
curl -O https://cainstudio.online/proof/bundle/cain35-byzantine/cain_35_independent_verifier.py
curl -O https://cainstudio.online/proof/bundle/cain35-byzantine/live_proof_4of4_signers.json
curl -O https://cainstudio.online/proof/bundle/cain35-byzantine/live_proof_TAMPERED_demo.json
```

`cain_35_independent_verifier.py` imports only Python's standard library plus
the third-party `cryptography` package (for Ed25519) -- it does **not** import
any CAIN production code. You can `grep -n '^import\|^from' cain_35_independent_verifier.py`
yourself to confirm this before running it.

## 2. Extract the public keys the proof itself claims

```
python3 -c "
import json
proof = json.load(open('live_proof_4of4_signers.json'))
keys = proof['quorum_certificate']['membership_config']
json.dump(keys, open('keys.json', 'w'), indent=2)
print(json.dumps(keys, indent=2))
"
```

This step is the one place you are trusting the proof's own self-description
of who signed it (see the bundle's `index.json` "honest_scope_note" -- this is
key independence, not full out-of-band PKI independence). Everything after
this step is pure, independently-recomputed cryptography: the verifier will
tell you whether the four signatures actually match those keys over the
correct canonical payload, which is the part that was BROKEN the first time
this code ran live (see `CAIN_35_FINAL_FORENSIC_REPORT.md` section 7) and
which no amount of trusting the server can fake.

## 3. Verify the real proof -- expect VALID

```
python3 cain_35_independent_verifier.py live_proof_4of4_signers.json --keys-file keys.json
```

Expected output:
```json
{
  "verdict": "VALID",
  "reason": "INDEPENDENTLY_VERIFIED",
  "authorization_id": "auth-dfa73c963f894ebe",
  "quorum_accepted": ["cain-cluster-node-1", "cain-cluster-node-2", "cain-cluster-node-3", "cain-cluster-node-4"],
  "verifier": "cain_35_independent_verifier.py (zero cain_proof_carrying_fabric import)"
}
```
Exit code `0`.

## 4. Verify the tampered proof -- expect CORRUPTED (the negative control)

```
python3 cain_35_independent_verifier.py live_proof_TAMPERED_demo.json --keys-file keys.json
```

Expected output:
```json
{
  "verdict": "CORRUPTED",
  "reason": "SIGNATURE_CORRUPTED_cain-cluster-node-1"
}
```
Exit code `1`.

If step 3 does not say `VALID`, or step 4 does not say `CORRUPTED`, the claims
in this bundle are false and you should not trust them -- please report it.
That is the entire point of publishing the verifier alongside the evidence
instead of just asserting a result.

## 5. What this does and does not prove

**Proves:** the four signatures in `live_proof_4of4_signers.json` are genuine
Ed25519 signatures, produced by four distinct private keys, over the exact
canonical quorum-certificate statement (cluster, epoch, view, sequence,
request digest, state root, membership) claimed in the proof -- and that
tampering with even one field breaks verification. This is real, live,
independently-checkable cryptography, not a marketing claim.

**Does not prove:** that the four signing keys belong to four genuinely
independent machines/operators (see `CAIN_35_FINAL_FORENSIC_REPORT.md`
section 11, "Witness Independence" -- this test cluster runs as 4 containers
on one host, a documented, undisputed limitation, not hidden here). It also
does not prove anything about CAIN's broader multi-VPS peer configuration,
which this bundle deliberately does not make claims about (see `index.json`).