kShare
Account-free, end-to-end encrypted file transfer between two devices - the receiver invites, verifies, and consents; no service ever holds the files.
The problem
Sending a file to the person next to you still routes through somebody's cloud. AirDrop works until one of you has the wrong phone, and everything else asks for an account, uploads the file to a server, and hands back a link with a lifetime the service decides (usually 'forever, on our disk'). Convenient, and the wrong shape: a transfer between two online devices does not need a third party that stores anything.
kShare is the tool for that case. The receiver opens Receive and gets a single-use invitation as a short code, a QR, or a link. The sender picks files and pastes it. The receiver sees who is offering what, verifies the sender, accepts, and the transfer runs directly between the two machines where the network allows and over an encrypted relay where it does not. Nothing is stored anywhere in between.
Architecture
Rust owns everything that can hurt: identity, pairing, networking, storage, and filesystem safety. TypeScript owns presentation, twice - a Tauri/React desktop app and an Ink terminal client that talk to the same engine through a generated client. Both expose the same security behavior; the TUI adds a headless mode for scripts.
Each installation holds a stable Ed25519 (a fast elliptic-curve signature scheme) identity in the platform's secret store. Pairing runs CPace, a PAKE (a key exchange where two peers sharing a short code derive a strong key without revealing the code): the invitation's pairing code (four words from the EFF long list by default, 15-minute lifetime) never reaches the rendezvous service, which sees only opaque ciphertext and deletes the mailbox once both sides have met. The optional eight-character short code is stretched with Argon2id (a memory-hard password derivation function) before it becomes an envelope identifier, so an operator holding the whole envelope store cannot sweep the 40-bit space at hashing speed. Transport is Iroh (a QUIC-based networking library with NAT traversal and relay fallback) with a fresh transport identity per session; direct addresses travel only inside the pairing-encrypted mailbox and never appear in the invitation.
Three connectivity modes state the trade-off out loud. Auto tries a direct path and falls back to an encrypted relay. Direct-only forbids any file payload over a relay, and enforces it structurally: the data endpoint is created with relay disabled, so a lost direct path pauses the transfer instead of leaking through a fallback. Private routes everything over Tor through embedded Arti and stops the session on any failure rather than downgrading; it stays hidden behind a beta gate until its leak tests pass.
The transfer itself is a signed offer over a BLAKE3 (a hash function whose output identifies the content it was computed over)-hashed manifest, pulled by the receiver, resumable after a restart, and finalized atomically per file: staged on the destination volume, verified against size and hash, then renamed into place with overwrite disabled. Every incoming path is hostile input - traversal, reserved names, case and Unicode collisions, and symlink races are rejected, and an existing file is never replaced unless you say so.
Boundaries
kShare moves files between two online peers. It is not a sync tool, not a drop box, and does not deliver to someone who is offline - if that is the job, the answer is a server, and kShare deliberately is not one (see kUtils, two entries up).
End-to-end encryption covers content, not metadata. In Auto and Direct-only, a direct peer sees the other peer's network address, and the app says so before the transfer starts. Private hides that behind Tor and claims nothing against a global observer or colluding relays. Version 1 has no key revocation: a stolen identity key means a new identity and re-adding contacts by hand. And the security review so far is internal, which is why neither the app nor this page uses the word audited.