Rust的Tor密钥生成库tor-key-forge使用指南

介绍

tor-key-forge是一个用于安全生成和管理Tor网络密钥的Rust库。它为Tor网络提供了一套完整的密钥生成和管理解决方案，包括：

• 生成符合Tor规范的Ed25519和RSA密钥对
• 安全地存储和管理密钥材料
• 生成Tor的洋葱服务描述符
• 支持密钥轮换和过期管理

这个库特别适合需要与Tor网络交互或创建Tor隐藏服务的Rust应用程序。

安装

在Cargo.toml中添加依赖：

[dependencies]
tor-key-forge = "0.3"

基本使用方法

1. 生成Ed25519密钥对

use tor_key_forge::ed25519::Keypair;

fn main() {
    // 生成新的Ed25519密钥对
    let keypair = Keypair::generate();
    
    println!("Public key: {:?}", keypair.public);
    println!("Private key: {:?}", keypair.private);
}

2. 生成RSA密钥对

use tor_key_forge::rsa::{RSAKeypair, RSAKeySize};

fn main() {
    // 生成1024位的RSA密钥对(Tor标准)
    let keypair = RSAKeypair::generate(RSAKeySize::RSA1024).unwrap();
    
    println!("RSA Public key: {:?}", keypair.public_key());
    println!("RSA Private key: {:?}", keypair.private_key());
}

3. 创建Tor隐藏服务描述符

use tor_key_forge::{HiddenServiceDescriptor, OnionAddress};

fn main() {
    // 生成Ed25519密钥对
    let keypair = tor_key_forge::ed25519::Keypair::generate();
    
    // 创建隐藏服务描述符
    let descriptor = HiddenServiceDescriptor::new(
        OnionAddress::from_public_key(&keypair.public),
        keypair,
        vec!["80 127.0.0.1:8080".parse().unwrap()], // 端口映射
    );
    
    println!("Descriptor: {}", descriptor.to_string());
}

高级功能

1. 密钥持久化存储

use tor_key forge::{KeyStorage, FileKeyStorage};
use std::path::Path;

fn main() -> std::io::Result<()> {
    let storage = FileKeyStorage::new(Path::new("tor_keys"));
    
    // 生成并存储密钥
    let keypair = tor_key_forge::ed25519::Keypair::generate();
    storage.store("my_service", &keypair)?;
    
    // 从存储中加载密钥
    let loaded = storage.load::<tor_key_forge::ed25519::Keypair>("my_service")?;
    
    Ok(())
}

2. 密钥轮换

use tor_key_forge::{KeyRotation, ed25519::Keypair};
use std::time::{Duration, SystemTime};

fn main() {
    let mut rotation = KeyRotation::new(
        Keypair::generate(), // 当前密钥
        Keypair::generate(), // 下一个密钥
        SystemTime::now() + Duration::from_secs(30 * 24 * 3600), // 30天后过期
    );
    
    // 检查是否需要轮换密钥
    if rotation.should_rotate() {
        rotation.rotate();
        println!("Key rotated successfully!");
    }
}

安全注意事项

1. 始终确保私钥存储在安全的位置
2. 定期轮换密钥以提高安全性
3. 在生产环境中使用硬件安全模块(HSM)存储密钥
4. 避免将密钥记录到日志文件中

完整示例：创建并管理Tor隐藏服务

use tor_key_forge::{
    ed25519::Keypair,
    HiddenServiceDescriptor,
    OnionAddress,
    KeyStorage,
    FileKeyStorage,
    KeyRotation
};
use std::path::Path;
use std::time::{Duration, SystemTime};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 初始化密钥存储
    let storage_path = Path::new("tor_keys");
    let storage = FileKeyStorage::new(storage_path);
    
    // 2. 加载或生成密钥对
    let service_name = "my_hidden_service";
    let keypair = if storage.exists(service_name) {
        println!("Loading existing keypair...");
        storage.load::<Keypair>(service_name)?
    } else {
        println!("Generating new keypair...");
        let kp = Keypair::generate();
        storage.store(service_name, &kp)?;
        kp
    };
    
    // 3. 设置密钥轮换
    let mut rotation = KeyRotation::new(
        keypair.clone(), // 当前密钥
        Keypair::generate(), // 新密钥
        SystemTime::now() + Duration::from_secs(30 * 24 * 3600), // 30天后过期
    );
    
    // 4. 创建隐藏服务描述符
    let descriptor = HiddenServiceDescriptor::new(
        OnionAddress::from_public_key(&keypair.public),
        keypair,
        vec![
            "80 127.0.0.1:8080".parse()?, // HTTP服务
            "22 127.0.0.1:2222".parse()?, // SSH服务
        ],
    );
    
    // 5. 保存描述符到文件
    let desc_path = "hs_desc";
    std::fs::write(desc_path, descriptor.to_string())?;
    println!("Hidden service descriptor saved to {}", desc_path);
    
    // 6. 检查并执行密钥轮换
    if rotation.should_rotate() {
        println!("Rotating keys...");
        rotation.rotate();
        storage.store(service_name, &rotation.current_key())?;
        println!("Key rotation completed successfully!");
    }
    
    Ok(())
}

这个完整示例演示了如何：

1. 初始化密钥存储系统
2. 安全地生成或加载已有的密钥对
3. 设置密钥轮换机制
4. 创建Tor隐藏服务描述符
5. 保存描述符到文件
6. 定期检查并执行密钥轮换

通过这个示例，您可以构建一个完整的Tor隐藏服务，并确保密钥管理的安全性。