Rust全同态加密库TFHE的使用指南

TFHE简介

TFHE (Fast Fully Homomorphic Encryption over the Torus) 是一个基于环面的快速全同态加密库，允许在加密数据上直接进行计算而无需解密。Rust实现的TFHE库提供了高性能的安全计算能力，特别适合需要隐私保护的场景。

安装方法

在Cargo.toml中添加依赖：

[dependencies]
tfhe = "0.4"

基本使用方法

1. 密钥生成

use tfhe::{ConfigBuilder, generate_keys, set_server_key, FheUint8};

fn main() {
    // 配置参数
    let config = ConfigBuilder::all_disabled()
        .enable_default_integers()
        .build();
    
    // 生成客户端密钥和服务端密钥
    let (client_key, server_key) = generate_keys(config);
    
    // 设置服务端密钥(必须在同态操作前调用)
    set_server_key(server_key);
}

2. 加密与解密

use tfhe::{FheUint8, generate_keys, set_server_key, ConfigBuilder};

fn main() {
    let config = ConfigBuilder::all_disabled()
        .enable_default_integers()
        .build();
    
    let (client_key, server_key) = generate_keys(config);
    set_server_key(server_key);
    
    // 加密数据
    let clear_a = 27u8;
    let clear_b = 128u8;
    let a = FheUint8::encrypt(clear_a, &client_key);
    let b = FheUint8::encrypt(clear_b, &client_key);
    
    // 同态计算
    let result = a + b;
    
    // 解密结果
    let decrypted_result: u8 = result.decrypt(&client_key);
    println!("{} + {} = {}", clear_a, clear_b, decrypted_result);
}

3. 布尔运算

use tfhe::{FheBool, generate_keys, set_server_key, ConfigBuilder};

fn main() {
    let config = ConfigBuilder::all_disabled()
        .enable_default_bool()
        .build();
    
    let (client_key, server_key) = generate_keys(config);
    set_server_key(server_key);
    
    let a = FheBool::encrypt(true, &client_key);
    let b = FheBool::encrypt(false, &client_key);
    
    // 同态布尔运算
    let result = a & b;
    
    let decrypted_result = result.decrypt(&client_key);
    println!("true AND false = {}", decrypted_result);
}

高级功能

1. 自定义参数配置

use tfhe::{ConfigBuilder, generate_keys, set_server_key, FheUint16};

fn main() {
    let config = ConfigBuilder::all_disabled()
        .enable_custom_integers(
            tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS,
            None,
        )
        .build();
    
    let (client_key, server_key) = generate_keys(config);
    set_server_key(server_key);
    
    let a = FheUint16::try_encrypt(30000u16, &client_key).unwrap();
    let b = FheUint16::try_encrypt(20000u16, &client_key).unwrap();
    
    let result = a + b;
    let decrypted: u16 = result.decrypt(&client_key);
    println!("30000 + 20000 = {}", decrypted);
}

2. 条件分支

use tfhe::{FheUint8, generate_keys, set_server_key, ConfigBuilder};

fn main() {
    let config = ConfigBuilder::all_disabled()
        .enable_default_integers()
        .build();
    
    let (client_key, server_key) = generate_keys(config);
    set_server_key(server_key);
    
    let a = FheUint8::encrypt(10u8, &client_key);
    let b = FheUint8::encrypt(20u8, &client_key);
    let condition = FheBool::encrypt(true, &client_key);
    
    // 同态条件选择
    let result = condition.if_then_else(&a, &b);
    
    let decrypted: u8 = result.decrypt(&client_key);
    println!("Condition was true, so result is {}", decrypted);
}

性能优化建议

1. 批量处理：尽可能批量处理加密数据
2. 参数选择：根据安全性和性能需求调整参数
3. 并行计算：利用Rust的并行特性加速计算

应用场景

1. 隐私保护的数据分析
2. 安全多方计算
3. 加密数据库查询
4. 机器学习模型的安全推断

注意事项

1. TFHE计算开销较大，适合小规模数据或对隐私要求极高的场景
2. 密钥管理是关键，需要安全存储客户端密钥
3. 不同版本的TFHE可能参数不兼容

完整示例代码

// 完整示例：使用TFHE进行加密计算
use tfhe::{ConfigBuilder, generate_keys, set_server_key, FheUint8, FheBool};

fn main() {
    // 配置参数 - 启用默认整数和布尔支持
    let config = ConfigBuilder::all_disabled()
        .enable_default_integers()
        .enable_default_bool()
        .build();
    
    // 生成密钥对
    let (client_key, server_key) = generate_keys(config);
    
    // 必须在同态操作前设置服务端密钥
    set_server_key(server_key);
    
    // 示例1: 整数加密计算
    let num1 = FheUint8::encrypt(42u8, &client_key);
    let num2 = FheUint8::encrypt(10u8, &client_key);
    let sum = &num1 + &num2;
    let product = &num1 * &num2;
    
    println!("解密结果:");
    println!("42 + 10 = {}", sum.decrypt(&client_key));
    println!("42 * 10 = {}", product.decrypt(&client_key));
    
    // 示例2: 布尔运算
    let flag1 = FheBool::encrypt(true, &client_key);
    let flag2 = FheBool::encrypt(false, &client_key);
    let and_result = &flag1 & &flag2;
    let or_result = &flag1 | &flag2;
    
    println!("布尔运算结果:");
    println!("true AND false = {}", and_result.decrypt(&client_key));
    println!("true OR false = {}", or_result.decrypt(&client_key));
    
    // 示例3: 条件选择
    let small = FheUint8::encrypt(5u8, &client_key);
    let large = FheUint8::encrypt(50u8, &client_key);
    let condition = FheBool::encrypt(true, &client_key);
    let selected = condition.if_then_else(&small, &large);
    
    println!("条件选择结果:");
    println!("条件为true时选择: {}", selected.decrypt(&client_key));
}

这个完整示例演示了:

1. 如何配置和初始化TFHE
2. 基本的整数加密运算(加法和乘法)
3. 布尔运算(AND和OR)
4. 条件选择操作