Small verification workflows where someone needs a fresh image from a remote person and both parties want to avoid storing an unencrypted original on a new central service. It is a technical proof-of-concept for a privacy-preserving handoff, not a legal identity-verification product.
Capture
Web security utility
A camera-first, encrypted handoff designed to make image collection more auditable and private.

The problem I chose to solve
The most useful way to understand this project is to start with the friction behind it, then examine the system choices made to address that friction.
A recipient who needs a fresh photo—such as a remote verifier—may receive a recycled, edited, or unrelated image through ordinary file uploads. At the same time, sending an unencrypted source image through a centralized upload service exposes it to unnecessary storage and account-access risks.
Capture uses a requester-generated keypair and a sender-side camera flow. The sender captures an image through the browser’s camera interface, encrypts it for the requester, and shares an opaque `.capture` artifact through an ordinary channel. The requester decrypts it with a private key retained in their own browser. The goal is to reduce raw-image exposure and make the expected capture workflow stricter.
Where it fits in the real world
A strong implementation has a bounded audience and context. These are the use cases supported by the current design—not a claim that all of them have been validated at scale.
- Camera-first workflow intended to reject ordinary file upload as a source image
- Asymmetric cryptography separates the requester’s private key from the sender
- Encrypted `.capture` artifacts can be sent over an existing communication channel
- Browser-local key storage and no server-side application database are the documented design goal
What the system actually does
An overview of key capabilities and system features.
Request creation
The requester creates a capture request and local keypair.
Live camera interaction
The sender grants camera permission and captures inside the browser workflow.
Encrypted artifact
The source image is encrypted before the resulting artifact leaves the sender’s browser.
Manual distribution
The `.capture` file can be sent by email or messaging without a new image-hosting backend.
Local decryption
The requester uses their private key from local browser storage to view the result.
Architecture & data flow
Architecture and system flow overview.
Requester browser
Creates keypair and retains private key locally.
Capture link
Transfers only the public/request-specific information needed to start capture.
Sender browser
Uses MediaDevices camera input and encrypts the image with TweetNaCl-based cryptography.
Manual file transfer
Opaque artifact goes through an ordinary channel; requester decrypts locally.
React, Vite, TypeScript, Tailwind CSS, TweetNaCl.js, IndexedDB, MediaDevices camera APIs.
Decisions behind the implementation
Engineering choices and design decisions behind the implementation.
- Avoid a central upload API so the system does not become a new repository of raw sensitive photos.
- Make camera capture a first-class part of the workflow rather than accepting every image source.
- Use asymmetric encryption so the sender does not possess the requester’s private key.
Technical Considerations
Key technical details and system scope considerations.
- Camera-only capture does not prove that a real-world event happened as claimed. A malicious/compromised sender device can replay a scene, alter browser execution, or capture a display. The correct claim is “camera-first encrypted workflow,” not forensic proof of authenticity.
- Browser storage is subject to local-device risks. If the requester’s private key is lost, encrypted artifacts may be unrecoverable; if it is exposed, confidentiality is lost.
- No application database is documented, but static hosting and third-party dependencies still exist. Audit the deployed JavaScript build and dependency supply chain before use in high-stakes contexts.
What I would improve next
The next step is not simply adding features. It is increasing reliability, evidence quality, user trust, and clarity about the boundaries of the system.
Add request expiry, replay protection, and clearly scoped challenge text.
Make key backup/recovery trade-offs explicit without silently uploading private keys.
Document the threat model and test that malformed or reused request artifacts are rejected.
Use it only as one control in a larger verification process when consequences are high.
Sources & Resources
Project repositories and resource links.