Architecture

One product. Seven subsystems.Each one fails alone.

Bundling features increases UX power. It does not have to increase blast radius. Henedo's will builder, vault encryption, dead man's switch, canary detector, transparency verifier, contact PII layer, and Eternal Vault signer are independent modules built on a single audited primitive layer. A bug in any one of them is contained to that one.

The argument we are answering

A common critique of all-in-one platforms is that more features mean more failure points. On a poorly architected product, that is true. On a modular product, it is the opposite: every cross-product handoff between separate vendors (a password manager → a separate will tool → a separate vault → a separate inheritance app) is a plaintext-touching boundary, and every boundary is a place data can leak.

Henedo's design rule is the opposite: bundled UX, modular internals.The user sees one product and one passphrase. Underneath, each feature is a self-contained subsystem that holds only the keys it needs and fails in place if it ever fails at all.

The seven subsystems

Each subsystem is a separable module with its own threat model, its own data flow, and its own audit boundary.

Content surfaces — the Journal, the 1,000-prompt Life Story, voice memos, video messages — are not separate subsystems. They are users of the Vault crypto subsystem: every byte they produce is encrypted under the same per-record FEK wrapped under the same MK as the document vault. Adding a content surface adds zero new cryptographic boundaries and zero new attack surface.

Will builder

What it does: State-specific legal templates, attorney-reviewed.

What it touches: Plaintext form input → encrypted in place via the vault module before persistence.

If it fails: A bug here cannot read your master key. The will is encrypted under the same MK as everything else; the builder never sees the MK.

Vault crypto

What it does: Per-file FEKs wrapped under a single MK. AES-256-GCM at rest.

What it touches: File bytes during encrypt/decrypt only. Web Worker isolated.

If it fails: A bug here is the only one that could affect data confidentiality. It is also the most-audited code path in the product.

Dead Man's Switch

What it does: Server-side state machine: ACTIVE → WARNED → TRIGGERED → DELETED.

What it touches: Timestamps and email queues. Never touches keys, never touches ciphertext.

If it fails: A bug here can cause a wrong-time email or a mistaken state transition. It cannot decrypt anything.

Canary detector

What it does: Tripwire blobs planted in every vault. SECURITY DEFINER Postgres function.

What it touches: Vault row IDs and access timestamps.

If it fails: Failing open here means a real attacker is not auto-locked-out, the DMS still gates everything else and sessions can still be revoked manually.

Transparency verifier

What it does: Client-side Ed25519 signature check on every JS asset.

What it touches: Asset hashes and a public key.

If it fails: Verification failure produces a visible warning banner. Other subsystems continue to operate, but the user is told the build cannot be trusted.

Contact PII layer

What it does: Server-side pgcrypto AES-256 + HMAC-SHA-256 blind index for emails.

What it touches: Trusted-contact name, email, phone, address. Never touches MK or vault FEKs.

If it fails: A bug here can leak ciphertext PII columns. The application-layer key is in a separate Postgres schema with no PUBLIC privileges, so a DB-only breach still yields ciphertext.

Eternal Vault signer

What it does: Ed25519 + ML-DSA-65 hybrid signing on sealed vaults.

What it touches: A serialised vault manifest at sealing time only. Keys are zeroed after signing.

If it fails: A bug here can produce an invalid signature, which the inheritor would detect. It cannot retroactively decrypt prior vaults.

Failure-mode matrix

For each subsystem, what is exposed if that one subsystem has a critical bug? In a well-isolated architecture, the answer in most rows is nothing.

FeatureConfidentialityAvailabilityIntegrity
Will builder bugNo leak (encrypted in place)Will form may fail to saveValidation by attorney-reviewed templates
Vault crypto bugPossible — most-audited pathFiles become unreadableAES-GCM auth tag detects tampering
DMS timer bugNo leak (no key access)Possibly miscounted timerVisible to user — login resets state
Canary detector bugNo leakLockdown may not triggerManual session revocation still works
Transparency verifier bugNo leakBanner may misfireUser notified of any mismatch
Contact PII layer bugPossible — ciphertext only (DB-only)PII reads may failHMAC blind index unaffected
Eternal Vault signer bugNo leak (signing only)New seals may failInheritor detects invalid signature

The shared surface

The only thing the seven subsystems share is the cryptographic primitive layer: AES-256-GCM, Argon2id, HKDF-SHA-256, SHA3-512, Ed25519, ML-DSA-65. These are NIST-standardised, widely audited algorithms with reference implementations in the @noble/* family and the Web Crypto API. Sharing them is a feature, one well-reviewed implementation per primitive, one place to fix any vulnerability, one thing an external auditor needs to read.

Above the primitive layer, every subsystem is independent.

Why bundling beats separating

If you assemble your own legacy stack from a separate password manager, a separate will tool, a separate cloud vault, and a separate inheritance app, you have created four plaintext-touching boundaries: one each at every export and import. Each handoff is a place ciphertext is decrypted, recombined, and re-encrypted under a different key, and each step is a place a bug can leak data.

Henedo bundles the UX so plaintext only ever lives in one trust boundary, your browser. Cross-feature handoffs happen inside the same encrypted memory space, never across products and never over the wire. That is what fault-isolated all-in-one looks like, and it is fewer attack surfaces than the unbundled alternative, not more.

Active preservation: keeping the storage layer alive across decades

Subsystem isolation handles bugs. Active preservation handles time. A vault built to outlive its owner has to outlive its hardware too. Hard drives degrade in 3–5 years. SSDs lose charge without power. Whole storage formats become obsolete in a generation. Treating long-term storage as a static cloud bucket is the single biggest reason consumer "lifetime" services do not last.

Henedo's primary storage layer is geo-redundant: encrypted blobs are replicated across multiple regions on a current-generation cloud object store, with continuous SHA-3 fixity checks that detect silent corruption and re-replicate automatically. On top of that runs an active-preservation cycle: roughly every 10 years the underlying drives, formats, and infrastructure are migrated to current storage technology — the discipline used by the Library of Congress, national archives, and other archival institutions, formalised by ISO 14721 (OAIS) and the PREMIS preservation metadata standard. The StorageAdapter interface in BACKEND_ARCHITECTURE.md is what makes this migration low-risk: implementations swap, business logic does not change.

M-DISC is the extra redundancy layer, not the primary medium. We burn an annual encrypted snapshot to Verbatim M-DISC BDXL (ISO/IEC 10995:2011/ECMA-379, rated up to 1,000 years per U.S. DoD projection), verify with SHA-3, and store three copies in three climate-controlled vaults across three geographic locations. It is a belt-and-suspenders archival practice that survives even total loss of the primary store — never the only copy of your data.

How to verify

Every subsystem in this page is documented in our open architecture spec (SECURITY.md) and the source is loaded into your browser under a signed manifest, see the transparency log. Independent auditors can read the architecture, fetch the manifest, and verify that the JavaScript running on this page is the JavaScript we describe.

FAQ

Yes, when it is built modularly. Every cross-product handoff (a separate password manager handing data to a separate will tool to a separate vault) creates a plaintext-touching boundary. Henedo keeps plaintext inside a single trust boundary (your browser) and isolates each feature into its own subsystem. A bug in the will builder cannot read your vault keys; the DMS timer cannot decrypt your contact bundles. Bundling the UX while isolating the modules gives you fewer plaintext handoffs and fewer code surfaces to audit, not more.

A trust boundary is the line where plaintext stops. In Henedo, the only trust boundary is your browser process itself: keys live in a Web Worker, the master key is never serialised to the main thread, and ciphertext is the only thing that ever leaves the device. Server-side, every API call is bound to your authenticated session and your row-level security policy.

No. Each subsystem holds only the keys it needs. The will builder operates on plaintext that is encrypted in place before storage; it never touches the master key directly. The DMS timer is a server-side policy state machine; it never sees ciphertext. The canary detector runs in Postgres; it never sees keys. The eternal-vault signer is loaded only when a vault is sealed and zeroed afterwards. Each module fails in place.

AES-256-GCM, Argon2id, HKDF-SHA-256, SHA3-512 are the only shared surface, and they are widely audited NIST-standard primitives. Sharing them is a feature: one well-reviewed implementation per primitive, one place to fix a vulnerability, one thing for an external auditor to read. Each subsystem above the primitive layer is independent.

The architecture spec in SECURITY.md and BACKEND_ARCHITECTURE.md documents every subsystem, its inputs, outputs, and failure modes. The source is open for review and the build is signed with binary transparency, so the JavaScript running in your browser matches the architecture we describe.

No. The primary storage layer is geo-redundant — encrypted blobs are replicated across multiple regions on a current-generation cloud object store, with continuous SHA-3 fixity checks that detect silent corruption and re-replicate automatically. On top of that, Henedo runs an active-preservation cycle: roughly every 10 years the underlying drives, formats, and infrastructure are migrated to current technology, the way the Library of Congress and national archives do it. The storage adapter interface in BACKEND_ARCHITECTURE.md is what makes this migration low-risk — implementations swap, business logic does not change. M-DISC sits on top as an extra redundancy layer, never the only copy.

Bundled UX. Modular under the hood. Open for review.

Read the architecture spec. Verify the build. Then start your vault.