Status: Phase 8 — Documentation & Deployment (approaching 1.0) Version: 0.1.0

Recrypt is a quantum-resistant proxy recryption system enabling secure, revocable file sharing with untrusted storage providers. Built on lattice-based cryptography (OpenFHE) with post-quantum signatures (liboqs), it provides end-to-end encryption where files can be shared without exposing private keys or plaintext to any intermediary.

Proxy recryption. A semi-trusted proxy transforms ciphertext encrypted for Alice into ciphertext for Bob without ever decrypting it. The storage provider facilitates sharing without access to plaintext, and access can be revoked without re-encrypting the file.

Hybrid encryption (KEM-DEM). A 256-bit symmetric key is wrapped with the post-quantum PRE backend (KEM); bulk data is encrypted with XChaCha20 + Bao (DEM). Only the wrapped key (~KB) is recrypted on share — never the file itself.

Pluggable PRE backends. OpenFHE BFV is the post-quantum default; a mock backend exists for fast testing.

just setup          # first time: submodules + C/C++ deps + build
just build-release  # subsequent release builds

See Development for prerequisites.

# Create an identity (ED25519 + ML-DSA-87 keypair, stored in an encrypted wallet)
recrypt identity new

# Encrypt / decrypt locally (--for selects the recipient identity)
recrypt encrypt myfile.txt --for alice --output myfile.enc
recrypt decrypt myfile.enc --output myfile.txt

# Register an account and upload a file to the proxy
recrypt --server https://recrypt.example.com account register
recrypt --server https://recrypt.example.com file upload myfile.enc

# Share with a recipient (generates a recryption key for the proxy)
recrypt share create <file-hash> --to <recipient-pubkey>

# Recipient downloads; the proxy recrypts the wrapped key on the fly
recrypt share download <share-id> --output myfile.txt

Run recrypt --help (and recrypt <command> --help) for the full command set: identity, encrypt, decrypt, account, file, share, config, wallet.

For a guided walkthrough see docs/user-guide.md.

recrypt/
├── crates/
│   ├── recrypt-ffi/            # Safe Rust API over OpenFHE + liboqs + ed25519
│   ├── recrypt-openfhe-sys/    # Low-level CXX bridge to OpenFHE C++
│   ├── recrypt-core/           # PRE backends, hybrid encryption, signatures
│   ├── recrypt-wire/           # Wire protocol (Gordian Envelope + Bao)
│   ├── recrypt-storage/        # S3-compatible content-addressed storage
│   ├── identikey-storage-auth/ # Auth service (capabilities, ownership)
│   └── recrypt-client/         # Generated Rust HTTP client (from OpenAPI)
├── recrypt-server/             # Recryption proxy server (Axum)
├── recrypt-cli/                # Command-line interface
├── recrypt-client-ts/          # Generated TypeScript HTTP client
├── tests/e2e/                  # E2E test harness (36 tests)
├── docs/                       # Architecture, standards, decisions
└── vendor/                     # OpenFHE, liboqs (git submodules)

                      ┌──────────────────┐
                      │   recrypt-cli    │  workflows, wallet, HTTP client
                      └────────┬─────────┘
                               │ reqwest (HTTP)
                               ▼
                      ┌──────────────────┐
                      │  recrypt-server  │  Axum proxy, auth middleware, routes
                      └────────┬─────────┘
          ┌────────────────────┼──────────────────┐
          ▼                    ▼                  ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────────────┐
│   recrypt-core   │ │   recrypt-wire   │ │   recrypt-storage        │
│  crypto objects  │ │   wire format    │ │  content-addressed blobs │
└────────┬─────────┘ └────���─────────────┘ └──────────────────────────┘
         ▼
┌──────────────────┐           ┌──────────────────────────┐
│   recrypt-ffi    │           │  identikey-storage-auth  │
│  OpenFHE+liboqs  │           │  capabilities, ownership │
└────────┬─────────┘           └──────────────────────────┘
         ▼
┌────────────────────┐
│ recrypt-openfhe-sys│  raw CXX bridge to OpenFHE C++
└────────────────────┘

See docs/architecture.md for per-crate ownership and the full dependency graph.

Both HTTP clients are generated from the utoipa-annotated handlers in recrypt-server (single source of truth → openapi.json → codegen). Regenerate with just openapi-regen.

• OpenFHE BFV lattice-based proxy recryption (post-quantum)
• ED25519 (classical) + ML-DSA-87 (post-quantum) dual signatures
• Multi-signature authorization (all keys must sign)
• Blake3 for all hashing; Blake3/Bao tree mode for streaming integrity
• XChaCha20 + Bao authenticated symmetric encryption

• S3-compatible storage (Minio for dev, any S3 backend for prod)
• Content-addressed by Blake3 hash
• Separate auth service controls access by public key → file hash
• Chunked streaming for large files

• HTTP REST API (Axum) with OpenAPI schema
• CLI with encrypted wallet (Argon2id + XChaCha20-Poly1305), OS-keychain caching
• Generated Rust and TypeScript clients

• E2E encryption — plaintext never leaves the client
• Quantum resistance — lattice-based PRE + ML-DSA-87 signatures
• Per-file keys — fresh random symmetric key per file
• Streaming integrity — Blake3/Bao verification during download

See docs/threat-model.md and docs/security-tiers.md for the full model.

• Rust (stable, edition 2024)
• OpenFHE C++ library + liboqs (built via just build-deps; vendored as submodules)
• OpenMP — brew install libomp on macOS
• Docker (for the Minio S3 development environment)

just build            # build the workspace
just test             # run all tests (--test-threads=1; OpenFHE global state)
just lint             # clippy
just format           # rustfmt
just test-e2e         # E2E harness (mock backend, ~30s)
just minio-up         # start Minio for S3 development
just openapi-regen    # regenerate Rust + TS clients from the server schema

• Per-crate unit tests, with proptest property tests for crypto operations
• E2E harness at tests/e2e/ — 36 tests (19 CLI + 17 API), ~30s on the mock backend
• S3 tests gated behind --features s3-tests (requires Docker/Minio)
• Tests validate semantic correctness (decrypt(encrypt(x)) == x), not byte equality — OpenFHE serialization is non-deterministic. See docs/non-determinism.md.

Start with docs/architecture.md for the system overview, then docs/user-guide.md for usage.

Architectural decisions live in docs/decisions/; read them before relitigating long-tail design questions.

• Recryption — transformation of ciphertext from one key to another (not "re-encryption")
• Recryption key — the key enabling that transformation (not "rekey")
• Recrypted — data that has undergone recryption

Standardized throughout the codebase.

Recrypt is dual-licensed:

• Noncommercial use — licensed under the PolyForm Noncommercial License 1.0.0. Personal, research, educational, and nonprofit use is free, including running it in production. You are not required to publish your own source code.
• Commercial use — any use as part of a money-making product, service, or business requires a commercial license from Identikey Inc. See LICENSE-COMMERCIAL.md or contact sales@identikey.io.

If you are not making money with Recrypt, the noncommercial license covers you. If you are, you need a commercial license.

Vendored third-party dependencies under vendor/ (e.g. OpenFHE, liboqs) remain under their own licenses.

• Website: identikey.io/recryption
• Repository: github.com/identikey/recrypt