.ch
For regulated industries · Swiss law
The Salginatobel bridge over its gorge
Guarantees

Every guarantee, and how it holds.

The adversaries the engine is built against, the mechanism that answers each one, and exactly what the file holds. Decide against facts.

Salginatobel Bridge · Schiers · Robert Maillart · 90 m span · 1930
Threat model
#AdversaryDefense
T1Key-less reader of the file — stolen backup, seized disk, curious host adminAEAD on every blob and audit payload; plaintext columns expose shape only; the two-byte bucket index denies the equality graph.
T2Key-less writer altering history — roll back a rotated credential, delete a revision, resurrect a tombstone, reparent into a granted subtreeAAD-bound seals, metadata-bound checksums, gapless seq, hash-chained audit, verify_store / verify_deep, external witness.
T3Authenticated but unauthorized caller probing beyond their grantsOne arbiter at every choke point; discovery scoped like reads; dossier-scoped uniqueness; bounded delegation; four-character search floor; everything audited.
T4Erasure obligations against immutabilityCrypto-shred: the record's key destroyed, its index rows purged, its file names blanked and every version of its files unreadable, then removed from disk by sweep().
T5Whole-file rollbackThe witness, comparing the anchored chain head with the file's own.
T6Key-less writer moving, swapping or relabelling files on diskEach sealed file version bound to its bucket, owner, file id and version by its seal; every stored file checked against its hash and every secure version against its write event by verify_deep.

Values you encrypted client-side are opaque to the engine at every layer: their secrecy rests on your key alone.

At rest

The store, as a key-less holder sees it.

Steal the file, seize the disk, restore the backup: this is what you get. Shape in the clear, content sealed, keys not present. Nothing here is a slogan; every line is a column.

Shape, plaintext by design

A standard SQLite header. Per record: entry id, version, type name, parent id, status, timestamps, sequence number, checksum bytes. The index: two-byte buckets against entry ids. Per file version: bucket, name, owning record, version, size, stored hash, timestamp. Per audit row: seq, previous hash, row hash, event id, timestamp. The schema document — type and field names, labels, templates — configuration that describes shape, never content. Grants: by type and parent.

Sealed

Every payload — zstd, then AES-256-GCM, bound to its row. Every audit body — actor, actee, action, outcome, address. Every grant — grantee, ops, relation, grantor. Every secure file, its SHA-256 and its content type, bound to its bucket, record and version; every plain file written with a key. Every content key, wrapped with AES-KW; the master secret, wrapped under your key material.

Never on disk

Your key material — supplied at open, never stored. The key of a plain file — brought by each call, gone when it ends. The live access decisions — an in-memory table rebuilt from the sealed grants on open. Any record plaintext, ever.

Plain tables, where your application keeps them, are in the same file as ordinary tables, in the clear: not audited and not covered by crypto-shred, and a deleted plain row can stay in the file’s free pages until they are reused. They are for data that is about no one; keeping anything secret out of them is up to you.

An index entry is two bytes: one of 65,536 buckets, each shared by about twenty-six four-character prefixes.

How each guarantee holds

The index holds no values.

At most two bytes per indexed value — a bucket that around twenty-six four-character prefixes share. No value, plaintext or otherwise, is ever in the index; a stolen file yields buckets, not names, and no equality graph.

Grants are sealed records.

Who holds a grant, at what permission, under which relationship and from whom is inside the ciphertext, and the live authorization table never touches disk. A file holder sees that grant rows exist under a tenant, and nothing about them.

Size privacy is yours to set.

Payloads are compressed, then sealed, byte for byte. Where the size of a record should stay private, pad it client-side: the engine seals your padding like any other byte.

Shred is proven in the file.

Once shred returns, the file holds no recoverable key for that record — proven by test, including the rollback journal — and every file of the record is unreadable. Sweeping backups, replicas and snapshots taken before the shred completes your erasure procedure.

The witness closes the chain.

Any edit, removal or reordering in history is named by verify_chain with no key. Anchor the head somewhere the writer cannot reach and reconcile on a schedule: the witness answers Match, Truncated or Diverged, so a cut tail it has anchored is caught at the next reconcile.

Rotation re-wraps one thing.

Rotating your key re-wraps the master secret and re-encrypts nothing: right for scheduled hygiene, custody handover and moving to an HSM. For a fresh master secret, re-encrypt into a new store.

Unique means one thing in a tenant.

A uniqueness check runs across the whole tenant, in the write transaction, for every writer alike — and stops at the tenant boundary, so a value's existence in another tenant is never an oracle.

System belongs to your application.

Nothing that parses a request can construct the System accessor; your application builds it for its own maintenance paths. Keep it there — off request paths, tokens and headers — and the arbiter decides everything else.

The chain records what matters.

Data that changes all the time and is about no one (counters, settings, lookup tables, sign-in state as ids and hashes, display labels) goes in plain tables in the same file, read and written with guarded SQL, so it never floods the chain with a revision and an audit row per change. Your application still puts discrete security events, such as a lock, on the chain with log_event. From plain SQL, VaultDB’s own tables can be read but never changed. Plain tables themselves have no protection at all: keeping credentials, PII, PHI and anything else regulated out of them is your responsibility; VaultDB does not stop you.