FreeHole
Decentralized P2P File Transfer Asynchronous Sovereign Transfer E2EE WebRTC & IPFS
Drop a file here, or browse
File uploaded & distributed on Freenet
The encrypted chunks are live on Freenet with Reed-Solomon parity. You can safely close this window — the recipient can retrieve the file at any time using this sync code.
Waiting for peer connection
Please keep this window open. Direct WebRTC streaming will start as soon as the recipient inputs this sync code.
File uploaded to IPFS Relay
Your encrypted file is staged on the relay. You can safely close this window — the recipient can download it at any time.
The code serves as the rendezvous key and the 256-bit decryption key. Intermediaries never see plaintext.
Decentralized P2P File Transfer
FreeHole enables wire-speed, end-to-end encrypted file sharing directly between peers using WebRTC DataChannels and decentralized IPFS Relays.
Direct P2P Streaming WebRTC
Files stream directly from sender to receiver via encrypted WebRTC DataChannels without intermediaries or central servers.
- ✓ Direct Peer-to-Peer: Maximum transfer speed bounded only by peer connections.
- ✓ No Cloud Storage: Data flows memory-to-memory between browsers.
IPFS Decentralized Relay Async
Staging relay support for asynchronous transfers and difficult NAT / firewall traversal using decentralized IPFS pinning.
- ✓ Asynchronous Pickup: Receiver does not need to be online at the exact same second.
- ✓ Zero Plaintext Storage: Only AES-256 encrypted ciphertext blocks are relayed.
Universal Interoperability Web & CLI
Seamless cross-platform file transfers: send files from terminal CLI via wh send <file> and receive inside this web app.
- ✓ Cross-Platform: Terminal-to-Browser, Browser-to-Terminal, or Browser-to-Browser.
- ✓ Lightweight Core: Pure WebRTC & decentralized rendezvous protocols.
End-to-End Encryption AES-GCM
All files are encrypted client-side using AES-GCM (256-bit) with PBKDF2 key derivation and chunk-index binding.
- ✓ Zero-Knowledge Mnemonic: The code is both the rendezvous address and the secret key.
- ✓ Confidentiality: Relays and signaling peers never inspect plaintext or metadata.
How FreeHole P2P Works
Local Encryption
Sender generates mnemonic code and encrypts file via AES-256-GCM in the browser or terminal.
P2P Signaling
Peers exchange WebRTC handshake offers via decentralized zero-knowledge rendezvous.
Direct Stream
Encrypted binary chunks stream directly between connected peers over WebRTC DataChannels.
Local Decryption
Receiver decrypts chunks in-memory using derived AES-256 key and triggers file download.
Decentralized Sovereign File Transfer
FreeHole enables fast, end-to-end encrypted file sharing using Freenet WASM Contracts, content-addressed Blake3 Chunks, and sovereign storage.
Freenet Sovereign Storage Default
Files are sliced into verifiable 128KB chunks, addressed by cryptographic Blake3 hashes, and stored across sovereign Freenet peer nodes.
- ✓ Immutable & Verifiable: Every chunk verified via Blake3 digest before reassembly.
- ✓ No Central Servers: Stored across peer nodes without single points of failure.
WASM Channel Contract CRDT
The wormhole-channel WASM contract coordinates transfer manifests on Freenet with join-semilattice merge laws, ensuring robust state sync.
- ✓ Lightweight State Sync: Encrypted manifest metadata coordinated safely on Freenet.
- ✓ Deterministic Consensus: State updates validated by contract verification rules.
Universal Interoperability Web & CLI
Seamless cross-platform file transfers: send files from the CLI via wh send --freenet and download inside the Web App, or vice-versa.
- ✓ CLI + Web Gateway: Native integration with Freenet local node on port 7509.
- ✓ Sandboxed Container: Safe execution inside Freenet Web Container.
End-to-End Encryption AES-GCM
All files are encrypted client-side using AES-GCM (256-bit) with PBKDF2 key derivation and chunk-index binding.
- ✓ Zero-Knowledge Mnemonic: The code is both the rendezvous address and the secret key.
- ✓ Confidentiality: Network peers and relays never inspect plaintext or metadata.
How FreeHole Works on Freenet
Local Encryption
Sender generates mnemonic code and encrypts file via AES-256-GCM in the browser or terminal.
Freenet Publishing
Sender publishes 128KB Blake3 chunks to Freenet storage and registers the manifest on the channel contract.
Decentralized Sync
Receiver inputs code. Peers resolve manifest state from Freenet contract and fetch verifiable chunks.
Local Decryption
Receiver verifies each chunk via Blake3, decrypts in memory via AES-256-GCM, and reassembles the file.
FreeHole CLI (wh)
The CLI binary is named wh to avoid
collisions with magic-wormhole. Fast, lightweight, and sharing
the exact universal core with the browser dashboard.
Provides direct access to the global wh command in any terminal shell.
Zero installation required. Runs on-demand directly from GitHub anywhere Node.js is installed.
[+] Deriving AES-256-GCM encryption keys...
[+] Waiting for peer connection over decentralized relay...
[✓] Streaming DataChannel: [====================] 100%
[✓] Transfer complete! Decrypted and verified by recipient.
CLI Command Reference
| Command | Description | Action |
|---|---|---|
| wh send <file> | Encrypts (AES-256-GCM) and initiates direct WebRTC P2P stream between terminals or browsers. | |
| wh receive <code> | Connects to sender via sync code, receives chunks, and decrypts the file locally. | |
| wh send <file> --ipfs | Uploads encrypted chunks to IPFS relay for asynchronous transfer between nodes. | |
| wh list | Lists active transfers stored locally. |
Practical Usage Examples
Send from terminal and receive in this browser:
Paste the generated sync code (e.g. 82-gentle-bird) into the Receive File tab above to start downloading in the browser.
Drag a file into the "Send File" tab in the browser, then download from terminal anywhere:
The terminal connects directly via P2P and decrypts the file instantly.
FreeHole CLI (wh) on Freenet
The CLI binary communicates directly with your local Freenet node on port 7509, using the exact same Blake3 chunking and channel contracts as this Web App.
[+] Deriving AES-256-GCM encryption keys...
[+] Connected to Freenet node: http://127.0.0.1:7509
[+] Uploading 114 verifiable Blake3 chunks to Freenet...
[✓] Receiver connected via Freenet Gateway
[✓] Verified Chunks: [====================] 100% (Blake3 Verified)
[✓] Transfer complete! Decrypted and verified by recipient.
Freenet CLI Commands & Options
| Command / Flag | Description | Action |
|---|---|---|
| wh send <file> --freenet | Encrypts (AES-256-GCM) and stores file on Freenet in 128KB Blake3 chunks. Registers manifest on channel contract. | |
| wh receive <code> --freenet | Resolves manifest on Freenet, downloads & verifies Blake3 chunks, and decrypts the file locally. | |
| --freenet, --fn | Sovereign Freenet mode (default for Freenet web container). | true |
| Freenet Gateway | Automatic connection to local node gateway (http://127.0.0.1:7509). | 7509 |