Binary transparency

Verify the code. Every build, every time.

Even perfect encryption depends on the code your browser runs. Henedo signs its builds and publishes their manifests, so the code we serve can be compared with the code we signed.

How it works

One signed manifest per build.

Every production build emits a transparency manifest: a JSON document listing the SHA-384 hash of every JavaScript, CSS and WASM asset in the build.

  1. Signed

    With an Ed25519 key Henedo keeps offline. It is never placed in CI or on a server, and whoever holds that key can sign.

  2. Published

    To the transparency_manifests table, which anyone can read.

  3. Applied

    As SRI integrity attributes on matching local script and stylesheet tags in the generated HTML.

Your browser enforces SRI when it loads resources carrying an integrity attribute. For an additional audit, verify the build below. A deployment change or an unavailable resource can make an audit inconclusive, and a mismatch alone does not establish that code was tampered with.

Threat model

What it defends against, and what it does not.

Signed builds narrow one specific risk: code that changes between signing and your browser.

Defends against

  • SRI blocks a modified script or stylesheet when its bytes differ from the integrity hash in the page.
  • A signed manifest lets auditors detect changes to assets after signing.
  • Comparing assets with a trusted manifest can reveal inconsistent or modified deployments.

Does not defend against

  • A compromise of Henedo’s offline signing key or release process, which could sign a malicious build.
  • A compromised server that replaces both the page and its verifier. Independent verification requires a trusted public key and verifier.
  • A browser extension that modifies page content after SRI verification.
  • A physically compromised user device.

Auditor workflow

Check any build yourself.

Any external auditor or browser extension can verify a Henedo build independently. The public signing key is published at /.well-known/transparency-key.pub.

  1. Fetch the manifest

    Read manifest_json and its signature for a build from the public log.

  2. Check the signature

    Verify the Ed25519 signature over manifest_json with the known public key.

  3. Hash each asset

    Fetch each asset URL from the CDN and compute its SHA-384 hash.

  4. Compare

    Compare the hashes with the manifest and investigate any mismatch, including deployment changes.

Query the public log
SELECT manifest_json, signatureFROM transparency_manifestsWHERE build_id = ?

Audit the served JavaScript

This fetches the signed manifest, checks its Ed25519 signature, then requests and hashes its JavaScript assets, including chunks this page never loaded. Cached responses may be reused. The audit runs only when you ask for it and does not verify the bytes already executed by this tab.

Oversight

Documented first, open to independent review.

The architecture is published for review. No completed independent audit or confirmed engagement schedule is asserted by this release, and independent review may reveal defects rather than confirm every claim.

Architecture spec

SECURITY.md: public, maintained and citable line by line.

Signed builds

Every production deploy publishes its manifest to the public log, and the workflow above runs in any browser.

Security findings

The security page describes reporting and review boundaries. No funded reward programme is asserted here.

Primitives and versions

The cryptographic primitives we depend on are listed on the security page.

Continuity

Verification that outlasts a visit.

Published manifests are public records. The signing public key is embedded in every build, but a key inside the same app is not an independent trust anchor: to check a retained build later, keep the exact assets, the matching signed manifest and a trusted copy of the key.

Your data

Retain the complete encrypted export, its full decryption keys and the offline reader. Together they support independent recovery.

Security architecture

Zero-knowledge encryption, Argon2id key derivation, server-hardened v5 vault passwords, read-only v4 and legacy ASK wrappers, WebAuthn PRF and Shamir secret sharing.

Fault isolation

How the bundled product separates its subsystems, and where shared components remain a risk.

[ Begin ]

A vault you can audit.

Release builds are designed to be signed, with manifests you can check. Your vault keys never reach us unwrapped.