Every value in my little embedded key-value store gets encrypted, then
its ciphertext gets encoded as a string of A/C/G/T characters before it
ever touches the filesystem. Open the file in a text editor and you'll
see actual DNA-looking text - not because it's a gimmick, but because
that's genuinely the storage format.
This is mdc-lite, a ~348KB embeddable encrypted key-value store I
built in Rust for places a server can't reach - a watch face, a phone
app, a background service. It's part of a larger repo, ModelDB,
that also includes MDC, a Python conversational data engine (query AI
models, databases, images, and documents in plain English, no SQL) with
its own DNA-inspired archival storage tier.
The actual storage format
Every put() call does this, in order:
- Pack
[key_len][key_bytes][value_bytes]into one plaintext buffer. - Encrypt the whole thing with XChaCha20-Poly1305 (a 256-bit key you supply - the crate never generates or stores key material itself; real key custody belongs to the platform's secure hardware, iOS Secure Enclave or Android Keystore).
- DNA-encode the resulting
[nonce][ciphertext][tag]blob: 2 bits per base,00→A 01→C 10→G 11→T. Every byte maps to exactly 4 bases, so there's no padding ambiguity on decode. - Write the ACGT text to disk, atomically (temp file + rename).
Filenames are keyed BLAKE3 hashes of the logical key, not the key name
itself, so a directory listing alone leaks nothing - no key names, no
values, no way to tell how many distinct keys exist versus how many
files are on disk.
rust
pub fn put(&self, key: &str, value: &[u8]) -> Result<(), LiteStoreError> {
let mut plaintext = Vec::new();
plaintext.extend_from_slice(&(key.len() as u16).to_le_bytes());
plaintext.extend_from_slice(key.as_bytes());
plaintext.extend_from_slice(value);
let nonce = XChaCha20Poly1305::generate_nonce(&mut OsRng);
let ciphertext = self.cipher().encrypt(&nonce, plaintext.as_ref())?;
let mut record = nonce.to_vec();
record.extend_from_slice(&ciphertext);
let acgt_text = dna::encode(&record); // <- the actual bytes on disk
fs::write(tmp_path, &acgt_text)?;
fs::rename(tmp_path, final_path)?;
Ok(())
}
Top comments (1)
Hi HN,
I've been building two related but separate projects under one repo:
mdc-lite – a tiny (348KB) embeddable encrypted key-value store for
iOS/watchOS/Android/Wear OS/desktop. Every value and key name is sealed
with XChaCha20-Poly1305 before it touches disk, and then the resulting
ciphertext is encoded as a DNA base sequence (2 bits/base, A/C/G/T)
before being written to the file. So the actual bytes on disk are ACGT
text, not raw binary - "DNA-inspired storage" isn't just a name here,
it's literally what the file contains. (The DNA encoding itself is
public/reversible on its own - it's the encryption underneath that
makes it unreadable without the key, not the encoding on top. I try to
be explicit about that distinction in the docs, since "DNA storage"
invites some real misconceptions.)
MDC (Molecular Data Center) - a Python conversational data engine:
query AI models, databases, images, and documents in plain English, no
SQL. It has an archival storage tier that does the same DNA-encoding
trick at a bigger scale, plus a real error-correction and
corruption-simulation harness for it (not real synthesized DNA,
obviously - a software simulation of the redundancy problem DNA storage
research actually has).
Things I tried to be careful about, since this space attracts a lot of
hype:
Repo: github.com/saji1970/ModelDB
Docs/demo site: saji1970.github.io/ModelDB/
Whitepaper (the DNA + quantum honesty pass):
github.com/saji1970/ModelDB/blob/m...
Happy to answer questions about the encoding, the crypto choices, or
the conversational-query side.