VERASNAPby VeritasChain
Download on theApp Store Get it onGoogle Play

Verification guide · CPP proofs

Check a proof yourself.

A VeraSnap proof is a small file that travels with a photo or video. You can check it in the app, with the open-source Verify SDK, or by hand with OpenSSL. No account is needed, and the SDK and OpenSSL run offline on your own machine.

Page v1.0 · Updated 18 Nov 2026 · Rules of VeraSnap 1.6.1 and Verify SDK 0.1.0

What you need

Two files: the proof, and the original.

The proof

Exported from VeraSnap in one of three formats: a shareable proof JSON (proof_version 1.2), the internal proof.json, or an Evidence Pack ZIP that bundles the photo or video with its proof.json.

The original file, exactly as exported

Not a screenshot, and not a copy re-saved by a messaging app or social network. Re-encoding changes the bytes that were hashed, so the check fails even when nothing visible changed. If you received a re-sent copy, ask for the original or the Evidence Pack.

No original file? You can still check the proof itself — signature and timestamp — but not the photo. A result without a file says that the file was not checked.

Proofs shared from VeraSnap for iOS 1.6 or later (and Android 1.6.1) contain the signed event as raw_event, so its hash can be recomputed. Proofs shared by older versions do not, and can be at most partially verified.

Three ways

In the app, with the SDK, or by hand.

All three run the same checks: the file against the signed hash, the signature, the timestamp and the batch it was anchored in. The SDK follows the rules of the VeraSnap 1.6.1 apps.

01 · APP

In the VeraSnap app

Open the Verify tab. Choose the proof file, paste the JSON, or scan a VeraSnap QR code. Add the original photo or video to check the file itself.

iOS · Android · free

02 · SDK

With the Verify SDK

Open-source Python verifier (Apache-2.0, alpha). It makes no network requests while verifying and prints a colour, a status code and every check. Exit codes: 0 green, 1 yellow, 2 red, 3 input error.

python -m pip install "verasnap-verify @ git+https://github.com/veritaschain/verasnap-verify-sdk.git@5b19884061729c1aadbf3f22daab133c42082ede"
verasnap-verify verify proof.json --media photo.jpg

03 · OPENSSL

By hand

Every step uses standard building blocks — SHA-256, ECDSA P-256 and RFC 3161 — so you can check a proof without any VeraSnap software. Commands are below.

OpenSSL 3 · jq · Python 3

Reading the result

Green, yellow, red — and what each one means.

The colours below follow VeraSnap 1.6.1 and the Verify SDK. Earlier app versions show some cases differently: for example, iOS 1.6 can show a valid proof signed on another phone as green.

Green

Meets VeraSnap's verification criteria

The file matches the signed hash, the signature is valid, the signing key is known to the verifier, the timestamp's signature and certificate chain check out, and the timestamp was obtained within 60 minutes of the recorded capture time.

The capture time itself is still the phone's clock. Green does not mean the scene is real.

ANCHOR_VERIFIED

Yellow

Nothing failed, but something could not be confirmed

Common reasons: the proof was signed on someone else's phone, so the key is unknown to you; the timestamp was obtained more than 60 minutes after the recorded capture (for example, the photo was taken offline); the timestamp authority's root is not trusted; the batch's Merkle proof is missing; or no timestamp has been obtained yet.

Yellow is not "fake". A genuine proof from another person's phone is normally yellow, unless your organisation has enrolled that phone's key.

PARTIALLY_VERIFIED · ANCHOR_PENDING

Red

The file or the proof does not match

The file was edited, re-encoded or swapped; the signature does not verify; or the proof or its timestamp was altered, swapped or removed.

HASH_MISMATCH · SIGNATURE_INVALID · ERROR

What a green result does not show

  • That the scene is real. A genuine capture of a staged scene verifies.
  • Who took the picture. A signature identifies a key, not a person. A recorded biometric check shows that someone passed the phone's own Face ID or Touch ID check before the capture, not who it was.
  • That it was not a photo of a screen. The apps record a screen check as a likelihood. The SDK does not use it.
  • The exact capture time. It comes from the phone's clock. The timestamp proves only that the file existed by the time the authority signed.

The CPP specification asks verifiers to say it plainly: This shows capture provenance. It does NOT verify content truthfulness or signer identity. (CPP v1.1 §12)

By hand

Verify a shareable proof with OpenSSL.

For a shareable proof (proof_version 1.2 with raw_event). Replace proof.json and photo.jpg with your files. Tested on 18 Nov 2026 with OpenSSL 3.0.13, jq 1.7 and Python 3 on a test proof from the SDK. macOS ships LibreSSL as openssl; the commands were not tested with it.

  1. Take out the signed event

    The readable event section is a copy for display. The signature covers raw_event, so take every value from there.

    jq -r .raw_event proof.json | base64 -d > event.json
  2. Recompute the event hash

    SHA-256 of the signed event must equal event_hash.

    openssl dgst -sha256 event.json
    jq -r .event_hash proof.json
  3. Check the photo

    SHA-256 of the original file must equal the AssetHash inside the signed event. This is the step that catches edits, re-encoding and swapped files.

    openssl dgst -sha256 photo.jpg
    jq -r .Asset.AssetHash event.json
  4. Check the signature

    ES256 (ECDSA P-256 with SHA-256) over the signed event. The public key in the proof is a raw P-256 point, so put the standard key header in front of it first. If the signature is 64 bytes instead of DER, use the SDK.

    { echo MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgA= | base64 -d; jq -r .public_key proof.json | base64 -d; } > pub.der
    openssl pkey -pubin -inform DER -in pub.der -out pub.pem
    jq -r .signature.value proof.json | sed 's/^es256://' | base64 -d > sig.der
    openssl dgst -sha256 -verify pub.pem -signature sig.der event.json

    Expected: Verified OK

    A valid signature shows that the event was signed with this key and has not changed since. It does not show whose key it is.

  5. Check that the event is in the anchored batch

    The leaf is SHA-256 of the event hash bytes; parents are SHA-256 of left‖right, with no prefix bytes (CPP v1.3 §2, v1.4 Appendix C). Save this as merkle.py:

    import hashlib, json, sys
    p = json.load(open(sys.argv[1])); tp = p["timestamp_proof"]
    h = lambda s: bytes.fromhex(s.removeprefix("sha256:"))
    node = hashlib.sha256(h(p["event_hash"])).digest()   # leaf = SHA-256(EventHash)
    i = tp.get("merkle_index", 0)
    for sib in tp.get("merkle_proof", []):                # bottom to top
        node = hashlib.sha256(node + h(sib) if i % 2 == 0 else h(sib) + node).digest()
        i //= 2
    print("OK" if node == h(tp["merkle_root"]) else "MISMATCH")
    python3 merkle.py proof.json

    Expected: OK

  6. Check the timestamp

    The RFC 3161 token must be issued for the Merkle root itself (CPP v1.3 §5) and chain to a root you trust. tsa_roots.pem is the set bundled with the Verify SDK; you can use your own.

    curl -sO https://raw.githubusercontent.com/veritaschain/verasnap-verify-sdk/5b19884061729c1aadbf3f22daab133c42082ede/src/verasnap_verify/data/tsa_roots.pem
    jq -r .timestamp_proof.token proof.json | base64 -d > token.der
    ROOT=$(jq -r .timestamp_proof.merkle_root proof.json | sed 's/^sha256://')
    openssl ts -verify -in token.der -token_in -digest "$ROOT" -CAfile tsa_roots.pem
    openssl ts -reply -in token.der -token_in -text | grep "Time stamp"

    Expected: Verification: OK, then the authority's time.

  7. Compare capture time and timestamp

    The capture time in the signed event is the phone's clock. VeraSnap treats a timestamp obtained more than 60 minutes after it as "capture time not confirmed", and a capture time more than 5 minutes after the timestamp as a clock problem.

    jq -r .Timestamp event.json

Not covered here: whether the key belongs to a particular phone (that needs key enrolment — see the insurer page), the internal proof.json format, and the chain context, whose deletion counts are not signed. The SDK handles all three; its result codes are listed in docs/RESULTS.md.

FAQ

Questions people ask.

Do I have to upload the photo anywhere?

No. The Verify SDK and the OpenSSL steps run on your own machine and make no network requests while verifying (fetching the root file above is a one-time download).

The result is yellow. Is the photo fake?

Not necessarily. Yellow means nothing failed but something could not be confirmed. The most common case is a genuine proof signed on someone else's phone: the signature is valid, but your verifier does not know that key. Read the warnings — each one names what could not be confirmed.

Why is a photo I received over a messaging app red?

Most messaging apps and social networks re-compress photos. The picture looks the same, but the bytes differ, so the hash no longer matches. Ask the sender for the original file or for the Evidence Pack ZIP.

What does "key not enrolled" mean?

The proof was signed with a key your verifier has not registered. Organisations that receive proofs regularly can enrol a phone's key with hardware attestation (Android Key Attestation or Apple App Attest) using the Verify SDK; proofs from enrolled phones can then be green. See VeraSnap for insurers.

Can I check the C2PA manifest instead?

The iOS app can also export a C2PA manifest, signed with a key created on the device. C2PA tools judge that signer against their own trust lists. The checks on this page, and the colours above, are based on the CPP proof.

Does a green result prove the photo is true?

No. It shows that the file has not changed since it was signed and that a timestamp authority saw it by a certain time. What the picture shows, and whether the scene was staged, is outside what a capture proof can establish.

Available now · free download

Start sealing what matters.

iOS 26.0+ · ANDROID