The record, and everything attached to it.
A patient record has its scans. A contract has the signed PDF. A credential has its certificate. VaultDB Objects keeps each file with its record: opened with the record's permissions, written to its audit trail, erased with it.
A record's files belong with the record. Keep them in VaultDB and they share everything the record has: its key, its permissions, its audit trail and its erasure. One store to secure, one trail to show an auditor, one backup.
three buckets · secure-full · secure-writes · plain
every version kept · up to 64 MB a file
byte ranges · prefix listing · SHA-256 ETag
same audit chain · verifiable without a key
erased with the record by crypto-shred
Access to the record is access to its files. A grant on a node covers its whole subtree: every record beneath it, and every file of those records.
Every change to a secure file goes on the record's audit chain, and in secure-full every read as well. Anyone can verify the chain, with no key at all.
Each upload is a new version, and a delete leaves a marker. Every earlier version can still be listed and read.
Crypto-shred the record and every version of every file it holds becomes unreadable at once: GDPR and HIPAA erasure that reaches the attachments.
The bucket decides what goes on the chain.
Every store has the same three buckets, each its own namespace. You choose the bucket when you store a file, and the bucket sets the audit of every version in it.
secure-full
Belongs to a record, opened through it: a write needs write access to the record, a read needs read access. Sealed under a key derived from the record's content key. Every read and every write goes on the audit chain. For what must leave a trace each time it is opened.
secure-writes
The same record, the same access, the same seal. Every write goes on the chain, a delete included; reads are left quiet. For what is written once and read often, like image slices.
plain
Addressed by a free name and owned by no record. Always zstd-compressed, and sealed under a key derived from the key you pass with the call, whenever you pass one. For files that are public or carry nothing personal: what needs no ceremony.
A refused access is on the chain in both secure buckets. A secure file arrives encrypted by your application; the engine stores it whole, without compressing it, and seals it again under the record. To change a file's audit, write it again into the other bucket.
Nothing is overwritten.
Every put is a new version. A delete is a delete marker, not a hole: the history stays, and every version can still be listed and read by its number.
Whole or by range.
A file runs up to 64 MB and is stored whole, one file per version. Read it whole, or ask for a byte range and get the slice.
Listed the way object stores taught everyone to expect.
Names may contain /. List by prefix with the delimiter / and the folders appear as common prefixes, page by page, each page naming where the next one starts.
Written before it counts.
Every version is written to a temporary file, flushed and renamed into place before its manifest row commits, in one transaction with its audit event for a secure file. cleanup_files() removes what an interrupted write left behind, once it is an hour old.
The records are one file. Their files sit beside it.
The .vault file holds the records, their content keys, the audit chain and the manifest of every file. The files sit beside it in two folders, one for the secure buckets and one for plain. Click a part.
One file, two folders, one backup.
The .vault file holds the records, their keys, the audit chain and the manifest. Every file version sits beside it, in its bucket's folder, under a random id.
- entries
- entry_keys
- audit_log
- vdb_files
- .secure/
- .plain/
A sealed file opens only where it belongs.
Every sealed version carries its bucket, its owner, its file id and its version as the associated data of its AES-256-GCM seal. Move it to another record or bucket, or pass one version off as another, and it no longer opens. Its SHA-256, which doubles as its ETag, and its content type are sealed with it.
The manifest is an engine-owned table in the store, vdb_files; the files sit beside the store in two directories, one for the secure buckets and one for plain, under random ids. Names and record ids never appear in a path. A file name is plaintext shape metadata, like a type: validated, and never a place for secrets. Back up the store and its two directories together.
Erasure that reaches the attachments.
Crypto-shred a record and every version of its files, in both secure buckets, becomes unreadable in the same breath: they were sealed under keys derived from the one key shred destroys. Their names are blanked, and sweep() then deletes them from disk, retrying any delete that failed. No forgotten scan in a folder nobody remembers.
verify_deep checks every file as well as every record: each stored file against its hash, each file it holds the key for opened, and each secure version against exactly one write event on the chain.
The engine records who did it. The caller never gets to say.
Your application writes its own events into the audit log with log_event: a document opened, an approval given, a series viewed. One event for "opened the study" instead of a hundred image reads. The engine binds the actor itself, requires read access to any record the event names, and seals the event on the chain like every other.
Titles up to 200 characters, reasons up to 1,000, no control characters. Keep personal data out of both; the engine cannot check that for you.