Ciphre — a zero-knowledge cross-device workspace
Send files and text between your devices, and keep passwords, notes, and documents in an encrypted vault. User content and sensitive metadata are encrypted on your device before storage; the backend keeps only ciphertext plus the minimum operational metadata it needs to route, expire and authorize records. A full-stack system conceived, architected and built independently using AI-assisted development.
A portfolio project demonstrating full-stack product engineering, security-conscious architecture, browser cryptography and Cloudflare edge development.
What this demonstrates
What I actually did
- Designed and implemented five integrated product modules on one client-side encryption core.
- Built a Cloudflare Worker backend over D1 and R2 with 31 tracked migrations, cursor pagination, and atomic single-use credential handling.
- Implemented chunked client-side encryption with multipart upload and ranged download — no whole file buffered in memory on the supported path.
- Designed a zero-knowledge key hierarchy: the master key is wrapped by a passphrase, recovery codes, a device passkey, or a device-to-device handoff.
- Wrote 62 automated tests across 15 suites covering auth, crypto, transfer, sharing and guest-drop paths.
- Delivered a responsive, installable web app plus a public interactive demo — without a front-end framework.
What it is
One app, five modules, one security model
Ciphre started as a cross-device file drop and grew into a private workspace. Every module shares a single client-side encryption core, so the promise is consistent throughout: your data is encrypted on your device before it's stored, and the key never leaves it.
Share
Ciphre transfer
Pair devices by QR, then send files, text, links, and clipboard between them in real time — encrypted by default.
Vault
Passwords & files
A zero-knowledge store for passwords, cards, notes, and encrypted files, unlocked by a master passphrase, recovery codes, or a device passkey.
Organizer
Notes, tasks & events
An encrypted notebook — notes, to-dos, reminders — where only ciphertext and a coarse type ever reach the server.
PDF Tools
Client-side documents
Merge, split, and edit PDFs in the browser via WebAssembly — the processing step runs locally; nothing is uploaded unless you choose to.
Search
On-device semantic search
Search your items by meaning using a transformer model that runs locally in WebAssembly — no data sent to any API.
Engineering highlights
The hard parts
The interesting problems weren't the features — they were doing all of them without the server ever seeing plaintext, and keeping it fast on a phone.
A zero-knowledge key hierarchy
A random 32-byte master key encrypts everything and is itself only ever stored wrapped — by a key derived from the passphrase (Argon2id), from single-use recovery codes, from a fingerprint (WebAuthn PRF), or handed to a new device over ECDH. The server holds only wrapped keys and ciphertext; it can't unwrap anything.
Streaming encryption for large files
On the streaming path (up to 1 GB, compatible browsers), files are encrypted in 25 MB AES-256-GCM chunks and uploaded through R2 multipart, so the whole file isn't held in memory or written in the clear. Downloads fetch ciphertext by byte range and decrypt to disk via the File System Access API, with an in-memory fallback elsewhere.
Real-time sync on the edge
A Cloudflare Durable Object fans out live events over Server-Sent Events, so a file sent from a laptop appears on a phone instantly — while still carrying only an encrypted item's generic placeholder, never its name.
Everything the server can't do, the client does
Because the server can't read content, previews, PDF editing, and semantic search all run client-side in WebAssembly, and large downloads stream through a Service Worker. Trust moved to the edge; capability moved to the browser.
Scalability-conscious backend design
A modular Worker over D1 (SQLite) and R2, using cursor pagination, multipart R2 uploads, ranged downloads, Durable Object coordination, bounded request sizes, and atomic single-use pairing and recovery codes — with 31 tracked migrations. These are the mechanisms; I haven't load-tested it, so I claim sound design rather than proven scale.
Zero-knowledge sharing — even to people without the app
Public links re-encrypt under a one-time key that travels only in the URL #fragment, which browsers never send to a server — the recipient's page decrypts in the browser. Guest drops go the other way: the drop page carries a per-drop ECDH public key, so a stranger's browser encrypts a file to you before upload and only your device can open it. In both directions the server holds only ciphertext plus routing metadata — not the content or real filenames.
Proof, not just a promise
See the encrypted payload the app produces
This runs Ciphre's real scheme: it generates a random 256-bit master key and derives an AES-256-GCM transfer key from it with HKDF-SHA256, live in your browser. Type something, then compare your view with a representative encrypted record — the kind the backend would store. Nothing is transmitted; this is a local demonstration, not a live server.
Representative encrypted record, produced entirely in this browser — nothing is transmitted by this demonstration. The key itself is never shown or sent; only its SHA-256 fingerprint —.
Stack
Built with
Who built this — and why it matters
A finance professional, not an engineer
I don't come from a software-development background — my work is in finance. Ciphre is what happened when I took a real product idea, made the architectural and security calls myself, and used AI-assisted development to build it across the full stack: five modules, ~16,800 lines, a zero-knowledge encryption model, automated tests, and a deployed working demo.
The decisions that mattered are mine — the zero-knowledge model, where trust and capability should live, the product scope, and holding one standard across the whole system. The craft was in keeping the AI honest: reading the code rather than trusting it, insisting features were verified end-to-end before they counted as done, and refusing shortcuts that would have leaked plaintext or buffered gigabyte files into memory. The result is a system whose architecture, security model and key design decisions I can explain and defend.
That's the part I think matters most for AI transformation: AI doesn't just draft emails and slides — it changes who can turn business requirements into working software, and how fast. Someone who deeply understands the problem can now build the system that solves it.
Verification & limitations
Personal project, in active development. Core authentication, encryption, transfer, sharing and guest-drop paths are covered by 62 automated tests across 15 suites and exercised interactively in the browser; broader production-scale and cross-browser validation is ongoing. It's designed as a zero-knowledge workspace — encryption keys stay client-side and the backend is not intended to decrypt user content — rather than an externally audited guarantee. I'd rather show a claim I can defend than an overstated one.