Fury · Post-quantum file encryption

Encrypt it now. Keep it secret afterwards.

A file encrypted today may be copied today and opened decades later. Fury is built for that: hybrid post-quantum key agreement by default, no classical fallback, and no way to write a private identity unprotected.

  • 2Independent lattice KEMs
  • 0Classical downgrade paths
  • 256Bit file keys
  • GPLv3Free software
Discover

Harvest now, decrypt later is somebody's actual plan.

Traffic and archives captured today can be stored cheaply and opened when the mathematics catches up. Anything you encrypt with classical public-key cryptography is only confidential for as long as that assumption holds.

Fury does one job: turn a file into encrypted data that only the holder of the matching private identity can read, using key agreement chosen to survive that transition. Three commands, one file format, and a design document that says plainly what it does not protect against.

Five decisions, made once.

Every other choice in Fury follows from these — including the features it deliberately refuses to offer.

  1. I

    Post-quantum only

    No classical public-key recipients and no silent downgrade path. There is no negotiation an attacker can push towards the weaker option, because the weaker option was never shipped.

  2. II

    Conservative hybrid

    The default suite combines FrodoKEM-640-SHAKE with ML-KEM-768 — two different lattice families. Your file stays confidential unless both assumptions fail for the same target.

  3. III

    Agility with permanence

    New suites can become the default without old files becoming unreadable. Suite identifiers and stanza tags are wire constants and are never reused, so every shipped suite remains decryptable.

  4. IV

    No unprotected identities

    A private identity serialises only with a passphrase. There is no API, and no flag, for writing one in the clear — because the one that exists is the one that eventually leaks.

  5. V

    Pure Go

    Static binaries, no cgo requirement, nothing to install alongside. Copy the binary to the machine that needs it and it works.

What Fury gives you.

Three commands cover the everyday work. Two more exist for the day you want hardware and remote machines involved.

02

Key agreement

Two lattice families, one file key.

FrodoKEM-640-SHAKE and ML-KEM-768 both wrap the same file key. Breaking one is not enough — an attacker needs both to fall, for the same recipient, on the same day.

  • Suite identity embedded in every key and file
  • Decryption dispatches on the stanza tag it finds
  • 256-bit keys preserve a post-quantum symmetric floor
03

Identities

Protected on disk, always.

Private identities are encrypted with Argon2id and XChaCha20-Poly1305 before they touch the filesystem. Change the passphrase whenever you like; inspect and manage unlock methods without exporting anything.

  • Multi-slot format with passphrase and security-key recovery
  • Existing identities migrate in place
  • Public keys as fury1…, fingerprints as furyfp1…
04

Hardware

Unlock with a security key.

Enrol a FIDO2 security key as an unlock method, so opening a file needs a physical touch as well as a passphrase — and losing the laptop is no longer the same as losing the archive.

  • Optional helper for compatible local keys
  • Enrolment and recovery guidance in the guide
  • Passphrase recovery stays available alongside
05

Remote work

Decrypt on the server without shipping your key to it.

The agent approves decryption requests over a local or explicitly forwarded Unix socket. The private identity never leaves your machine, and each request needs confirmation.

  • Works over standard SSH agent forwarding
  • Explicit forwarding only — nothing implicit
  • Confirmed per request, not once per session
06

Inspection

Know what a file is before you open it.

Describe an encrypted file — its suite, its recipients, its shape — without decrypting a byte. Useful when an archive arrives with no context and you need to know whose key it wants.

  • Recipient stanzas and suite reported
  • No passphrase needed to look
  • Labels for keeping large collections straight
07

Everyday use

Fits the way you already work.

Encrypt to several recipients at once, keep a team's keys in a recipient file, pipe text straight through, wrap a whole folder, or armour the output as text for systems that will not carry binary.

  • Fingerprints instead of pasting whole public keys
  • Non-interactive mode for scripts and pipelines
  • Progress display and configurable worker threads
08

For developers

A file format and a Go library, not just a binary.

The format is documented end to end — intro line, stanzas, header MAC, chunked payload, armour — and the same behaviour is available as a library, with the private-identity rule enforced in the API itself.

  • Stable v1 wire format with published compatibility rules
  • Reproducible release builds and a British-English handbook
  • GPLv3, so you can read every line before trusting it

What Fury does not claim

Fury provides confidentiality, not authorship. It does not offer sender authentication, digital signatures, forward secrecy, or meaningful hiding of plaintext size — and resolving a fingerprint authenticates a key, not a person. Verify important fingerprints through a separate trusted channel. A tool that told you otherwise would be selling you a feeling rather than a guarantee.

Four steps, and the mathematics is somebody else's problem.

The whole model fits in a paragraph, which is the point. Cryptography people do not understand is cryptography people use wrongly.

  1. I

    Create an identity

    One command produces your private identity and its matching public key. Choose a long passphrase, then back the identity up somewhere you would trust with the files it protects.

  2. II

    Share the public half

    Give the public key — or just its short fingerprint — to whoever needs to send you something. It is not a secret and never was.

  3. III

    They encrypt

    One command against the public key produces an encrypted file. Add more recipients if a team needs access; each gets their own wrapped copy of the file key.

  4. IV

    You open it

    Your identity and its passphrase — plus a touch of a security key, if you enrolled one — restore the original file. Everything else is detail you can read at leisure.

Reach for Fury when…

01The material must stay confidential for years, not months.

02You assume an adversary who stores everything and waits.

03Your archive backups leave your control the moment they leave the building.

04You need a decryption key on a server you do not entirely trust.

05Your compliance position now names post-quantum readiness.

06You want to read the design document before you rely on the tool.

Questions worth asking.

Why hybrid, rather than one post-quantum algorithm?

Because post-quantum cryptanalysis is young. Combining two different lattice families means the file key survives unless both assumptions fail for the same target. It costs a little size and time, and buys a great deal of margin.

What happens to my old files when the default suite changes?

They keep opening. Decryption dispatches on the tag written into each file, suite identifiers are never reused, and every suite Fury has shipped stays decryptable. Agility was designed in from the start rather than bolted on at the first migration.

Can I lose access to my own files?

Yes — and that is the honest answer for any tool worth using. Lose the private identity and its passphrase, and nothing recovers the data. Back up the identity file, choose a passphrase you will still know next year, and consider enrolling a second unlock method before you need it.

Does it prove who sent the file?

No. Fury is confidentiality, not authenticity: no sender authentication and no signatures. Anyone holding your public key can encrypt to you, which is exactly what a public key is for. If you need to know who sent something, sign it separately.

How is it licensed?

Fury is free software under version 3 or later of the GNU General Public Licence. Read it, audit it, build it yourself from the patched toolchain named in the module — and get in touch if you would like help deploying it across a team.

Also from Alchamentary.

Independent products, built because they should exist.

01

4ensics Leviathan

Drop a file. See everything.

A complete binary analysis, reverse-engineering and digital-forensics workbench, running inside a browser tab with your artefacts kept local.

See Leviathan
02

Blackwall

Passwordless identity for everything you ship.

OAuth 2.1 and OpenID Connect with passkeys only, an integrity-chained audit log and signed project licences — in a single binary.

See Blackwall

Make it unreadable to the future.

Ask about rolling Fury out across a team, integrating the library, or whether post-quantum encryption is genuinely the right answer to the problem in front of you.