rs-tfhe: Rust TFHE Library

A high-performance Rust implementation of TFHE (Torus Fully Homomorphic Encryption).

Overview

rs-tfhe is a comprehensive homomorphic encryption library that enables computation on encrypted data without decryption, built in Rust for performance and safety.

(Looking to build in golang? Check out our go-tfhe Sister Project)

Key Features

• Multiple Security Levels: 80-bit, 110-bit, and 128-bit security parameters
• Specialized Uint Parameters: Optimized parameter sets for different message moduli (1-8 bits)
• Homomorphic Gates: Complete set of boolean operations (AND, OR, NAND, NOR, XOR, XNOR, NOT, MUX)
• Fast Arithmetic: Efficient multi-bit arithmetic operations using nibble-based addition
• Parallel Processing: Rayon-based parallelization for batch operations
• Optimized FFT: Multiple FFT implementations including SIMD optimizations
• Feature Flags: Modular compilation with optional features

Installation

Add rs-tfhe to your Cargo.toml:

[dependencies]
rs_tfhe = "0.1.0"

Feature Flags

[dependencies]
rs_tfhe = { version = "0.1.0", features = ["lut-bootstrap", "fft_fma"] }

Available features:

• bootstrapping: Enable bootstrapping operations (default)
• lut-bootstrap: Enable programmable bootstrapping with lookup tables
• fft_avx: Enable AVX-optimized FFT (x86_64 only)
• fft_fma: Enable FMA-optimized FFT (default)

Quick Start

Basic Homomorphic Operations

use rs_tfhe::key;
use rs_tfhe::gates::Gates;
use rs_tfhe::utils::Ciphertext;

// Generate keys
let secret_key = key::SecretKey::new();
let cloud_key = key::CloudKey::new(&secret_key);

// Encrypt boolean values
let ct_true = Ciphertext::encrypt(true, &secret_key.key_lv0);
let ct_false = Ciphertext::encrypt(false, &secret_key.key_lv0);

// Perform homomorphic operations
let gates = Gates::new(&cloud_key);
let result = gates.hom_and(&ct_true, &ct_false);

// Decrypt result
let decrypted = result.decrypt(&secret_key.key_lv0);
assert_eq!(decrypted, false);

Programmable Bootstrapping

#[cfg(feature = "lut-bootstrap")]
use rs_tfhe::bootstrap::lut::LutBootstrap;
#[cfg(feature = "lut-bootstrap")]
use rs_tfhe::lut::Generator;

#[cfg(feature = "lut-bootstrap")]
fn programmable_bootstrap_example() {
    let secret_key = key::SecretKey::new();
    let cloud_key = key::CloudKey::new(&secret_key);
    let bootstrap = LutBootstrap::new();
    
    // Encrypt a value
    let encrypted = Ciphertext::encrypt_lwe_message(5, 8, 0.0001, &secret_key.key_lv0);
    
    // Define a function to evaluate (square function)
    let square_func = |x: usize| (x * x) % 8;
    
    // Apply function during bootstrapping
    let result = bootstrap.bootstrap_func(&encrypted, square_func, 8, &cloud_key);
    
    // Decrypt result
    let decrypted = result.decrypt_lwe_message(8, &secret_key.key_lv0);
    assert_eq!(decrypted, 1); // 5^2 mod 8 = 25 mod 8 = 1
}

Fast Arithmetic with LUT Bootstrapping

#[cfg(feature = "lut-bootstrap")]
fn fast_addition_example() {
    use rs_tfhe::params;
    
    // Use specialized parameters for arithmetic
    let current_params = params::SECURITY_128_BIT;
    
    let secret_key = key::SecretKey::new();
    let cloud_key = key::CloudKey::new(&secret_key);
    let bootstrap = LutBootstrap::new();
    
    // Encrypt two 4-bit values
    let a = 5;
    let b = 7;
    let ct_a = Ciphertext::encrypt_lwe_message(a, 16, current_params.tlwe_lv0.alpha, &secret_key.key_lv0);
    let ct_b = Ciphertext::encrypt_lwe_message(b, 16, current_params.tlwe_lv0.alpha, &secret_key.key_lv0);
    
    // Homomorphic addition
    let ct_sum = &ct_a + &ct_b;
    
    // Extract result using LUT bootstrapping
    let mod_func = |x: usize| x % 16;
    let result = bootstrap.bootstrap_func(&ct_sum, mod_func, 16, &cloud_key);
    
    let decrypted = result.decrypt_lwe_message(16, &secret_key.key_lv0);
    assert_eq!(decrypted, (a + b) % 16);
}

Architecture

Core Components

Encryption Schemes

• TLWE: Torus Learning With Errors for level-0 ciphertexts
• TRLWE: Torus Ring Learning With Errors for level-1 ciphertexts
• TRGSW: Torus GSW for bootstrapping keys

Bootstrapping Strategies

• Vanilla Bootstrap: Traditional noise refreshing
• LUT Bootstrap: Programmable bootstrapping with lookup tables

FFT Implementations

• Standard FFT: Pure Rust implementation
• SIMD FFT: AVX/FMA optimized for x86_64
• Real FFT: Optimized for real-valued polynomials

Parameter Sets

Standard Security Parameters

• SECURITY_80_BIT: 80-bit security level
• SECURITY_110_BIT: 110-bit security level
• SECURITY_128_BIT: 128-bit security level (default)

Specialized Uint Parameters (requires lut-bootstrap feature)

• SECURITY_UINT1: Binary operations (messageModulus=2)
• SECURITY_UINT2: 2-bit arithmetic (messageModulus=4)
• SECURITY_UINT3: 3-bit arithmetic (messageModulus=8)
• SECURITY_UINT4: 4-bit arithmetic (messageModulus=16)
• SECURITY_UINT5: 5-bit arithmetic (messageModulus=32) - Recommended for complex operations
• SECURITY_UINT6: 6-bit arithmetic (messageModulus=64)
• SECURITY_UINT7: 7-bit arithmetic (messageModulus=128)
• SECURITY_UINT8: 8-bit arithmetic (messageModulus=256)

Examples

The examples/ directory contains comprehensive examples:

Basic Examples

• add_two_numbers.rs: Simple homomorphic addition
• gates_with_strategies.rs: Boolean gate operations
• security_levels.rs: Different security parameter comparisons

LUT Bootstrapping Examples

• lut_bootstrapping.rs: Complete programmable bootstrapping demo
• lut_bootstrapping_simple.rs: Minimal LUT example
• lut_add_two_numbers.rs: Fast 8-bit addition using nibble operations
• lut_arithmetic_demo.rs: Various arithmetic operations
• lut_uint_parameters_demo.rs: Parameter set comparisons

Performance Examples

• batch_gates.rs: Parallel gate processing
• custom_railgun.rs: Custom parallelization strategies
• fft_diagnostics.rs: FFT performance analysis

Performance

Benchmarks

Run benchmarks with:

cargo bench

Performance Characteristics

Optimization Features

• Parallel Processing: Rayon-based batch operations
• SIMD FFT: AVX/FMA optimizations for x86_64
• Specialized Parameters: Optimized for specific message moduli
• LUT Reuse: Pre-computed lookup tables for repeated functions

API Reference

Core Types

Ciphertext

Main ciphertext type supporting homomorphic operations.

impl Ciphertext {
    pub fn encrypt(plaintext: bool, key: &SecretKey) -> Self;
    pub fn decrypt(&self, key: &SecretKey) -> bool;
    pub fn encrypt_lwe_message(msg: usize, modulus: usize, alpha: f64, key: &SecretKey) -> Self;
    pub fn decrypt_lwe_message(&self, modulus: usize, key: &SecretKey) -> usize;
}

Gates

Boolean gate operations.

impl Gates {
    pub fn hom_and(&self, a: &Ciphertext, b: &Ciphertext) -> Ciphertext;
    pub fn hom_or(&self, a: &Ciphertext, b: &Ciphertext) -> Ciphertext;
    pub fn hom_xor(&self, a: &Ciphertext, b: &Ciphertext) -> Ciphertext;
    pub fn hom_not(&self, a: &Ciphertext) -> Ciphertext;
    pub fn mux(&self, cond: &Ciphertext, a: &Ciphertext, b: &Ciphertext) -> Ciphertext;
}

LutBootstrap (requires lut-bootstrap feature)

Programmable bootstrapping with lookup tables.

impl LutBootstrap {
    pub fn bootstrap_func<F>(&self, ct: &Ciphertext, f: F, modulus: usize, key: &CloudKey) -> Ciphertext
    where F: Fn(usize) -> usize;
    
    pub fn bootstrap_lut(&self, ct: &Ciphertext, lut: &LookupTable, key: &CloudKey) -> Ciphertext;
}

Generator (requires lut-bootstrap feature)

Lookup table generation.

impl Generator {
    pub fn new(message_modulus: usize) -> Self;
    pub fn generate_lookup_table<F>(&self, f: F) -> LookupTable
    where F: Fn(usize) -> usize;
}

Contributing

Contributions are welcome! Please see the existing code style and add tests for new functionality.

Development Setup

git clone <repository>
cd rs-tfhe
cargo test
cargo test --features "lut-bootstrap"
cargo bench

Running Examples

# Basic examples
cargo run --example add_two_numbers --release
cargo run --example gates_with_strategies --release

# LUT bootstrapping examples (requires feature flag)
cargo run --example lut_bootstrapping --features "lut-bootstrap" --release
cargo run --example lut_add_two_numbers --features "lut-bootstrap" --release

License

This project is licensed under the same terms as the original TFHE library. See LICENSE for details.

Acknowledgments

• Based on the TFHE library by Ilaria Chillotti, Nicolas Gama, Mariya Georgieva, and Malika Izabachène
• Inspired by the go-tfhe implementation
• FFT optimizations from tfhe-go reference implementation