Rust Tor网络检测库tor-checkable的使用指南

tor-checkable是一个用于高效安全地验证Tor节点和检查Tor连接状态的Rust库。它提供了简单易用的API来验证Tor网络中的节点信息，确保连接的安全性和可靠性。

主要功能

• 验证Tor节点的有效性和状态
• 检查Tor连接是否正常工作
• 提供高效的节点验证机制
• 支持异步操作

安装方法

在Cargo.toml中添加依赖：

[dependencies]
tor-checkable = "0.1"  # 请使用最新版本

基本使用方法

1. 验证单个Tor节点

use tor_checkable::{NodeChecker, NodeDescriptor};

#[tokio::main]
async fn main() {
    // 创建节点检查器
    let checker = NodeChecker::new();
    
    // 定义要检查的节点描述符
    let node = NodeDescriptor::from_fingerprint("ABCD1234ABCD1234ABCD1234ABCD1234ABCD1234");
    
    // 检查节点状态
    match checker.check_node(&node).await {
        Ok(status) => println!("节点状态: {:?}", status),
        Err(e) => println!("检查失败: {}", e),
    }
}

2. 批量检查多个节点

use tor_checkable::{NodeChecker, NodeDescriptor};

#[tokio::main]
async fn main() {
    let checker = NodeChecker::new();
    
    let fingerprints = vec![
        "ABCD1234ABCD1234ABCD1234ABCD1234ABCD1234",
        "EFGH5678EFGH5678EFGH5678EFGH5678EFGH5678",
    ];
    
    let nodes: Vec<NodeDescriptor> = fingerprints
        .iter()
        .map(|&fp| NodeDescriptor::from_fingerprint(fp))
        .collect();
    
    let results = checker.batch_check(&nodes).await;
    
    for (node, status) in nodes.iter().zip(results.iter()) {
        println!("节点 {} 状态: {:?}", node.fingerprint(), status);
    }
}

3. 检查Tor连接状态

use tor_checkable::ConnectionChecker;

#[tokio::main]
async fn main() {
    let checker = ConnectionChecker::new();
    
    match checker.check_connection().await {
        Ok(status) => {
            println!("Tor连接状态:");
            println!("  可达性: {}", status.is_reachable());
            println!("  延迟: {:?}", status.latency());
        }
        Err(e) => println!("连接检查失败: {}", e),
    }
}

高级用法

自定义检查参数

use tor_checkable::{NodeChecker, CheckOptions};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let options = CheckOptions {
        timeout: Duration::from_secs(10),
        max_retries: 3,
        strict_mode: true,
    };
    
    let checker = NodeChecker::with_options(options);
    
    // 使用自定义配置进行检查...
}

监听节点状态变化

use tor_checkable::{NodeChecker, NodeStatus};

#[tokio::main]
async fn main() {
    let checker = NodeChecker::new();
    let node = NodeDescriptor::from_fingerprint("ABCD1234ABCD1234ABCD1234ABCD1234ABCD1234");
    
    let mut watcher = checker.watch_node(&node);
    
    while let Some(status) = watcher.next().await {
        match status {
            NodeStatus::Up => println!("节点上线"),
            NodeStatus::Down => println!("节点下线"),
            NodeStatus::Changed(new_status) => println!("节点状态变化: {:?}", new_status),
        }
    }
}

完整示例代码

下面是一个综合使用tor-checkable库的完整示例，演示了如何初始化检查器、验证节点、检查连接以及监听状态变化：

use tor_checkable::{NodeChecker, NodeDescriptor, ConnectionChecker, NodeStatus, CheckOptions};
use std::time::Duration;
use tokio::time::sleep;

#[tokio::main]
async fn main() {
    // 初始化节点检查器
    let node_checker = NodeChecker::new();
    
    // 初始化连接检查器
    let conn_checker = ConnectionChecker::new();
    
    // 1. 检查Tor连接状态
    match conn_checker.check_connection().await {
        Ok(status) => {
            println!("=== Tor连接状态 ===");
            println!("可达性: {}", status.is_reachable());
            println!("延迟: {:?}", status.latency());
        }
        Err(e) => println!("连接检查失败: {}", e),
    }
    
    // 2. 验证单个节点
    let node_fp = "ABCD1234ABCD1234ABCD1234ABCD1234ABCD1234";
    let node = NodeDescriptor::from_fingerprint(node_fp);
    
    println!("\n=== 检查单个节点 ===");
    match node_checker.check_node(&node).await {
        Ok(status) => println!("节点 {} 状态: {:?}", node_fp, status),
        Err(e) => println!("检查节点 {} 失败: {}", node_fp, e),
    }
    
    // 3. 批量检查多个节点
    let fingerprints = vec![
        "ABCD1234ABCD1234ABCD1234ABCD1234ABCD1234",
        "EFGH5678EFGH5678EFGH5678EFGH5678EFGH5678",
        "IJKL9012IJKL9012IJKL9012IJKL9012IJKL9012",
    ];
    
    let nodes: Vec<NodeDescriptor> = fingerprints
        .iter()
        .map(|&fp| NodeDescriptor::from_fingerprint(fp))
        .collect();
    
    println!("\n=== 批量检查节点 ===");
    let results = node_checker.batch_check(&nodes).await;
    
    for (node, status) in nodes.iter().zip(results.iter()) {
        println!("节点 {} 状态: {:?}", node.fingerprint(), status);
    }
    
    // 4. 使用自定义配置检查节点
    println!("\n=== 使用自定义配置检查 ===");
    let options = CheckOptions {
        timeout: Duration::from_secs(5),
        max_retries: 2,
        strict_mode: false,
    };
    
    let custom_checker = NodeChecker::with_options(options);
    match custom_checker.check_node(&node).await {
        Ok(status) => println!("节点 {} 状态(自定义配置): {:?}", node_fp, status),
        Err(e) => println!("检查节点 {} 失败(自定义配置): {}", node_fp, e),
    }
    
    // 5. 监听节点状态变化
    println!("\n=== 监听节点状态变化 ===");
    println!("开始监听节点 {} 的状态变化...", node_fp);
    
    let mut watcher = node_checker.watch_node(&node);
    for _ in 0..5 {  // 监听5次状态变化
        if let Some(status) = watcher.next().await {
            match status {
                NodeStatus::Up => println!("[监听] 节点上线"),
                NodeStatus::Down => println!("[监听] 节点下线"),
                NodeStatus::Changed(new_status) => println!("[监听] 节点状态变化: {:?}", new_status),
            }
        }
        sleep(Duration::from_secs(2)).await;  // 间隔2秒
    }
}

性能建议

1. 对于大量节点检查，使用batch_check而不是循环调用check_node
2. 合理设置超时时间，避免长时间等待
3. 考虑使用缓存机制存储最近检查过的节点状态

安全注意事项

• 确保使用最新版本的库，以获得最新的安全修复
• 不要完全依赖单一检查结果做关键决策
• 对敏感操作考虑使用多重验证

tor-checkable库为Rust开发者提供了强大的工具来验证和监控Tor网络连接，帮助构建更安全可靠的Tor相关应用。