Zero-relay, end-to-end encrypted peer-to-peer file transfer — from any device to any device.
No cloud upload. No accounts. No file size limits imposed by a server. Files travel directly between browsers, encrypted before they leave the sender.
- True P2P — WebRTC DataChannel transfers files device-to-device; the signaling server is only a matchmaker and never sees file content
- AES-256-GCM encryption — every chunk encrypted independently before leaving the sender's machine
- ECDH P-256 key exchange — ephemeral keys negotiated per session; no pre-shared secrets
- HKDF-SHA-256 key derivation — raw ECDH bits stretched into a 256-bit AES key
- SHA-256 integrity verification — full file hash checked on receipt
- MITM fingerprint — 8-character session fingerprint both peers can read aloud to verify no interception
- Drag & Drop + Click to browse — always-active file zone,
⌘Okeyboard shortcut - QR code join — scan to connect a second device instantly; URL encodes the signaling server
- Dark / Light mode — sci-fi dark (default) + clean light theme
- Real-time transfer stats — speed (MB/s), progress bar, CPU %, memory, uptime
- Transfer history — completed and failed transfers with details
- Editable device name — personalise your node label
- Platform independent — runs in any modern browser on Mac, Windows, Linux, iOS, Android
- LAN mode — single
./start-lan.shlaunches everything, zero config - Internet mode — deploy frontend to Netlify + signaling to Railway (both free)
┌──────────────────────────────────────────────────────────────────┐
│ Browser A │
│ ┌──────────┐ ┌────────────┐ ┌─────────────┐ ┌───────────┐ │
│ │SignalingC│ │PeerConnect │ │ChunkTransfer│ │CryptoSvc │ │
│ │ (WS) │ │ (WebRTC) │ │ (DataChannel│ │AES-256-GCM│ │
│ └────┬─────┘ └─────┬──────┘ └──────┬──────┘ └───────────┘ │
└───────┼──────────────┼────────────────┼─────────────────────────┘
│ WebSocket │ ICE/SDP │ Encrypted chunks (P2P)
▼ ▼ ▼
┌───────────────┐ ┌─────────────────────────────────────┐
│ Signaling Srv │ │ Browser B │
│ (Python WS) │ │ (same stack, receiving side) │
│ matchmaker │ └─────────────────────────────────────┘
│ only — no │
│ file data │
└───────────────┘
Data path: File ──► Encrypt (AES-256-GCM) ──► Chunk ──► WebRTC P2P ──► Decrypt ──► File
Server path: Register ──► Exchange SDP/ICE ──► (server done, P2P begins)
| Layer | Technology |
|---|---|
| Frontend framework | React 18 + TypeScript + Vite |
| Styling | Tailwind CSS + inline design tokens |
| Fonts | Space Grotesk (UI) · JetBrains Mono (technical values) |
| P2P transport | WebRTC DataChannel |
| Signaling | Python websockets (async WebSocket server) |
| Encryption | Web Crypto API — ECDH P-256, HKDF-SHA-256, AES-256-GCM |
| QR code | qrcode.react |
| Toasts | sonner |
| Theme | next-themes |
| State management | useSecureDrop custom hook (no external store) |
| Frontend hosting | Netlify (free tier) |
| Signaling hosting | Railway (free tier) / ngrok / LAN |
| NAT traversal | Google STUN + Open Relay TURN (free) |
# 1. Install Python deps (once)
pip3 install websockets zeroconf
# 2. Start everything
./start-lan.sh
# 3. Open on other devices
# → http://192.168.X.X:8080 (printed by the script)
# → Or scan the QR code inside the app# 1. Deploy signaling server to Railway
# railway.app → New Project → GitHub → set Root Dir = server
# Copy your Railway URL, e.g. wss://secure-drop-xyz.railway.app
# 2. Set env var in Netlify dashboard
VITE_SIGNALING_URL=wss://secure-drop-xyz.railway.app
# 3. Deploy frontend to Netlify
# netlify.com → New site → GitHub → build: npm run build, publish: dist
# 4. Open your Netlify URL on any device worldwidenpm install
npm run dev # frontend at http://localhost:8080
python server/main.py # signaling at ws://localhost:8765Take screenshot: open http://localhost:8080 → ⌘+Shift+4
Drag a file into the drop zone and click a peer card to activate the Send button
Transfer in progress showing speed, percentage, and progress bar
The receiving device sees a modal with file info, sender fingerprint, and Accept/Reject buttons
Click the QR button in the header to generate a join URL — scan it on another device
Toggle with the ☀️ button in the header
| Property | Implementation |
|---|---|
| Key exchange | ECDH P-256 — ephemeral per session |
| Key derivation | HKDF-SHA-256 (salt + "secure-drop-v1" info) |
| Encryption | AES-256-GCM — per-chunk, unique 96-bit IV each chunk |
| Integrity | SHA-256 hash of full file, verified on receipt |
| MITM detection | 8-char hex fingerprint derived from raw ECDH shared secret — read aloud to verify |
| Server trust | Signaling server sees only peer IDs + encrypted SDP; never sees keys or file data |
| Forward secrecy | Ephemeral ECDH keys — compromise of one session reveals nothing about others |
secure-drop/
├── src/
│ ├── engine/
│ │ ├── SignalingClient.ts # WebSocket connection + reconnect backoff
│ │ ├── PeerConnection.ts # WebRTC offer/answer + ICE negotiation
│ │ ├── ChunkTransfer.ts # File chunking, backpressure, reassembly
│ │ ├── CryptoService.ts # ECDH + HKDF + AES-256-GCM + SHA-256
│ │ └── IntegrityVerifier.ts # SHA-256 file hash verification
│ ├── hooks/
│ │ ├── useSecureDrop.ts # Central app state + logic orchestrator
│ │ ├── useSystemMonitor.ts # CPU / memory / network metrics
│ │ └── useTheme.ts # Dark/light mode
│ ├── pages/
│ │ └── LandingPage.tsx # Full UI — all components inline
│ └── lib/
│ └── constants.ts # ICE servers, chunk sizes, crypto params
├── server/
│ ├── main.py # LAN server (WebSocket + mDNS discovery)
│ ├── cloud_main.py # Cloud server (Railway/Fly.io)
│ ├── signaling.py # Peer registry + message relay
│ └── discovery.py # mDNS advertisement (zeroconf)
├── start-lan.sh # One-command LAN launcher
├── netlify.toml # Netlify deploy config
└── server/railway.toml # Railway deploy config
The signaling server binds to 127.0.0.1 by default and accepts localhost browser origins. LAN or internet deployments must explicitly choose a bind address and pass each trusted web origin with --origin; do not disable origin validation as a convenience.
The signaling layer relays connection metadata and encrypted-session setup messages. It does not authenticate users, prevent malicious peers from connecting, or guarantee that a peer is honest. Verify the displayed session fingerprint out of band when the threat model requires protection against an active man-in-the-middle. Use TLS (wss://) for internet deployments, apply network access controls, and keep the server dependency set current.
MIT — free to use, modify, and distribute.
Star Secure-Drop if private peer-to-peer file transfer, WebRTC data channels, browser cryptography, or local-first privacy tooling is useful to you. Feedback on threat models, deployment hardening, and interoperability is especially welcome.