Skip to content

About

About Tallow

Secure file transfer that respects your privacy. No accounts, no cloud storage, no compromise.

Mission

Why Tallow exists

Every day, billions of files move across the internet through services that can read your data. Cloud providers scan your uploads. Email services inspect attachments. Even “secure” transfer tools often rely on server-side encryption where the provider holds the keys.

Tallow was built on a simple principle: your files should be encrypted before they leave your device, and only the intended recipient should be able to decrypt them.

The relay server is untrusted by design. It passes encrypted bytes without ever seeing plaintext. No accounts. No data retention. No metadata logging. Just math protecting your privacy.

Open Source

Transparent by default

Tallow is licensed under the GNU Affero General Public License v3.0 . Every line of code is publicly auditable on GitHub.

We believe security through obscurity is no security at all. The strongest cryptographic systems are the ones where the algorithm is public and the security comes from the math, not from hiding the implementation.

Contributions are welcome. Whether it's a bug report, a feature request, or a pull request, every contribution makes Tallow better for everyone.

Security

Post-quantum from day one

Tallow uses a hybrid key exchange combining ML-KEM-1024 (NIST FIPS 203) with X25519. This means your transfers are protected against both today's classical computers and tomorrow's quantum computers.

Data is encrypted with AES-256-GCM using counter-based nonces that guarantee uniqueness. File integrity is verified through Merkle trees with BLAKE3 hashing.

All key material is zeroized on drop. Secrets are pinned in RAM and never written to swap. Core dumps are disabled. The relay has zero knowledge of your encryption keys.

ML-KEM

Post-Quantum KEM

AES-256

Encryption

BLAKE3

Integrity

Argon2id

Key Derivation

Engineering

Built with Rust

Tallow is written in Rust, a language designed for safety and performance. Rust's ownership system prevents entire classes of memory bugs at compile time — buffer overflows, use-after-free, data races.

The codebase uses #![forbid(unsafe_code)] in all crates except where explicitly required for cryptographic memory operations. Every unsafe block has a documented safety justification.

Security isn't a feature we added on top. It's the foundation everything else is built on.