Site Integrity | BRY-NFET-SX

How it works

The signing pipeline is small and deliberately boring: hash every file, sign the manifest, publish both the manifest and the verification key.

Step 1

Content is hashed

Every HTML, CSS, JS, WASM, text, JSON and zip file in the signed list is SHA-256 hashed at deployment time. The filenames and their hex digests are recorded in a canonical JSON manifest with sorted keys and deterministic formatting.

Step 2

Manifest is ed25519-signed

The manifest is signed with an ed25519 private key kept off the web server. The signature covers the domain separator BRY-NFET-SX|SITE-INTEGRITY|V2 concatenated with the canonical manifest bytes. The ed25519 public key is published at /site-signer.ed25519.pub.

Step 3

Anyone can verify

Because ed25519 is an asymmetric signature scheme, anyone who fetches the public key and the manifest can verify the signature locally — no secret required. A ready-to-run verifier is available in the project repo at scripts/verify_site_integrity.py and uses only the Python cryptography library.

Verify it yourself

Two checks: (1) the ed25519 signature over the manifest, and (2) the SHA-256 of each file. Neither check requires anything beyond the public key and the manifest.

Option A — One-liner with the bundled verifier

The project repo ships a standalone verifier that does both checks using only the Python cryptography library.

git clone https://github.com/TheArtOfSound/nfet-primitive  # any project checkout works
uv run python scripts/verify_site_integrity.py --url https://secure.imagineqira.com

Output on success:

Step 1: ed25519 signature...
  OK
Step 2: SHA-256 file hashes...
  OK (21 files)

VERIFIED. The manifest is signed by the holder of the ed25519 private
key corresponding to the committed public key, and every file's SHA-256
matches.

Option B — Verify the signature manually

Fetch the public key and the manifest, then verify the ed25519 signature with any standard library. Python example:

import hashlib, json, urllib.request
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

BASE = "https://secure.imagineqira.com"
DOMAIN = b"BRY-NFET-SX|SITE-INTEGRITY|V2"

# 1. Fetch the public key and the signed manifest.
pub_hex = urllib.request.urlopen(BASE + "/site-signer.ed25519.pub").read().strip().decode()
pub = Ed25519PublicKey.from_public_bytes(bytes.fromhex(pub_hex))
record = json.loads(urllib.request.urlopen(BASE + "/site-integrity.json").read())

# 2. Strip the signature block and reconstruct the signed bytes exactly
#    as the signer did: domain separator + canonical JSON.
manifest = {k: v for k, v in record.items() if k != "signature"}
signed_bytes = DOMAIN + json.dumps(manifest, indent=2, sort_keys=True).encode()

# 3. Verify. Raises InvalidSignature on mismatch.
pub.verify(bytes.fromhex(record["signature"]["signature_hex"]), signed_bytes)
print("signature OK")

# 4. Hash every file and compare.
for name, expected in record["files"].items():
    body = urllib.request.urlopen(f"{BASE}/{name}").read()
    actual = hashlib.sha256(body).hexdigest()
    assert actual == expected, f"{name}: {actual} != {expected}"
    print(f"  {name}: OK")

Option C — Just check a single file's hash

If you trust the signed manifest itself (because you already checked the ed25519 signature, or because you're only worried about over-the-wire tampering with a single file), you can just compare a SHA-256 digest with shasum:

curl -s https://secure.imagineqira.com/ | shasum -a 256
# compare against files.index.html in the integrity record below

What this does and does not prove

The integrity claim has a specific, bounded meaning. Read it before drawing conclusions.

What it proves

The manifest was signed by whoever holds the ed25519 private key whose public half is at /site-signer.ed25519.pub. Anyone can verify this locally.
Every byte of every listed file matches its SHA-256 digest in the signed manifest. Tampering with even one byte of any listed file breaks the comparison.
The list of signed files is itself bound into the signature, so silently adding or removing files from the manifest breaks verification.
The manifest includes a signing timestamp, so you can tell when the operator last signed this version.

What it does NOT prove

That the published ed25519 public key belongs to the person you think it does. If you haven't verified the key out-of-band (TLS certificate pinning, prior knowledge, a trusted channel), a sophisticated attacker controlling this page could publish their own key alongside their own forged manifest.
That the source code under the hashed HTML/JS is free of bugs. Hash integrity is not code correctness.
That files NOT in the signed list are untampered. Files outside the manifest (e.g. third-party search engine verification tokens) are explicitly out of scope.
That the operator is trustworthy — only that a specific party with continuous control of one ed25519 key signed a specific manifest at a specific moment.

Signed by an ed25519 key.
Anyone with the public key can verify it.