Security & encryption
The gap between “looks secure”
and “is secure.”
Every messaging-app disaster lived in that gap. Cipher is built on published cryptography, implemented in the open, and held to a standard we'll prove publicly — not just assert.
The stack
Proven primitives — our own implementation of a proven design.
The cryptographic primitives are audited, published open source (libsodium) — we never hand-roll a cipher. The protocol on top (X3DH + Double Ratchet) is the published Signal design, which we implement ourselves rather than shipping Signal's code. That independent implementation is exactly what a third-party audit still needs to review — and hasn't yet.
Double Ratchet + X3DH
Cipher implements the Signal Protocol design (X3DH + Double Ratchet) — the same published, peer-reviewed protocol family that underlies Signal and WhatsApp — as our own independent implementation over audited open-source primitives (libsodium), so Cipher's guarantee never depends on a third party's license or business decisions. Our implementation is pre-audit (see below).
BIP39 seed phrases
Account identity is a 24-word recovery phrase — the same standard hardware crypto wallets use. Generated with a cryptographically secure RNG, on-device, and never transmitted.
Hardware-backed key storage
Keys live in the device's Secure Enclave / Android Keystore where available — not in a file, not on a server, not recoverable by us.
On-device AI inference
Every AI feature runs locally on a small open-weight model. Message content is never transmitted for inference — zero network egress, verified at the network boundary.
Payment isolation
Two systems, deliberately never connected.
Payment system knows
Apple ID / Google account, card details, billing receipts, subscription status. It never sees message content, keys, your seed phrase, or who you talk to.
Messaging system knows
Encrypted blobs and delivery routing — nothing readable. It never sees your real name, billing email, card, or store account.
No user ID, device ID, or account ID is shared between the two databases. Without a shared key, a subpoena to one system can't be cross-referenced into the other. That's the engineering discipline — not a policy promise.
The standard we hold ourselves to
Four sentences that are each literally, technically true today.
We do not have the technical ability to read our users' messages.
If a user loses their seed phrase and their device, their data is permanently unrecoverable — by us or anyone.
If our servers were fully compromised, the attacker would gain only encrypted data they cannot decrypt.
Our implementation has not yet had a third-party audit — the design we follow (X3DH + Double Ratchet) is independently audited and proven in production for over a decade; our code is not yet — and we will publish the full results publicly when we complete one.
The fourth is the one most startups quietly skip — or pretend is done. An audit is what turns “we believe this is secure” into “independently verified,” and we haven't completed one yet. Cipher is in open alpha, pre-audit, and labeled that way on purpose: we'd rather you help us break it now than be told it's finished when it isn't. When we complete an audit, we'll publish exactly what it found.
What no architecture can solve
We'll never claim to be unbreakable, anonymous, or government-proof.
End-to-end encryption protects a message in transit — not a device that's unlocked, stolen, or compromised by spyware, and not a user tricked into authorizing something. Those are device-security and human problems, true of every app. Overclaiming is exactly the mistake that destroys trust later, so we state the limits as clearly as the strengths.
Try the alpha. Help us break it.
Cipher is in open alpha, pre-audit. Get it on both stores — and when we complete a third-party audit, we'll publish exactly what it found.