以下是基于您提供的标题和内容整理的关于tor-cert库的完整示例demo，包含创建证书、验证证书、处理链接认证证书以及证书链验证的完整实现：

完整示例demo

use anyhow::{Context, Result};
use tor_cert::{CertDecodeError, CertType, Ed25519Cert, Ed25519CertConstructor, CertExt};
use tor_llcrypto::pk::ed25519;
use rand::rngs::OsRng;

fn main() -> Result<()> {
    // 示例1: 创建Ed25519证书
    let signing_key = ed25519::Keypair::generate(&mut OsRng);
    let cert = create_ed25519_certificate(&signing_key)?;
    println!("成功创建Ed25519证书");

    // 示例2: 验证证书
    let cert_bytes = cert.as_ref().to_vec();
    verify_certificate(&cert_bytes, &signing_key.public)?;
    println!("证书验证成功");

    // 示例3: 处理Tor链接认证证书
    process_link_certificate(&cert_bytes)?;
    println!("链接证书处理成功");

    // 示例4: 自定义证书扩展
    let cert_with_ext = create_cert_with_extension(&signing_key)?;
    println!("创建带扩展的证书成功");

    // 示例5: 证书链验证
    // 创建中间证书
    let intermediate_key = ed25519::Keypair::generate(&mut OsRng);
    let intermediate_cert = create_intermediate_cert(&signing_key, &intermediate_key.public)?;
    let intermediate_bytes = intermediate_cert.as_ref().to_vec();

    // 创建叶子证书
    let leaf_key = ed25519::Keypair::generate(&mut OsRng);
    let leaf_cert = create_leaf_cert(&intermediate_key, &leaf_key.public)?;
    let leaf_bytes = leaf_cert.as_ref().to_vec();

    // 验证证书链
    verify_certificate_chain(&leaf_bytes, &[&intermediate_bytes[..]], &signing_key.public)?;
    println!("证书链验证成功");

    Ok(())
}

/// 创建Ed25519证书
fn create_ed25519_certificate(signing_key: &ed25519::Keypair) -> Result<Vec<u8>> {
    let mut cert_builder = Ed25519CertConstructor::new(
        CertType::IDENTITY_V_SIGNING,
        0, // 版本
        0, // 证书类型特定字段
        std::time::SystemTime::now(), // 生效时间
        std::time::Duration::from_secs(3600 * 24 * 365), // 有效期1年
        signing_key.public,
    );

    cert_builder
        .sign_and_encode(signing_key)
        .context("创建证书失败")
}

/// 验证证书
fn verify_certificate(cert_bytes: &[u8], public_key: &ed25519::PublicKey) -> Result<()> {
    let cert = Ed25519Cert::decode(cert_bytes).context("解码证书失败")?;
    cert.check_signature(public_key).context("证书签名验证失败")?;
    
    // 检查有效期
    if cert.expired() {
        return Err(anyhow::anyhow!("证书已过期"));
    }
    
    Ok(())
}

/// 处理Tor链接认证证书
fn process_link_certificate(cert_bytes: &[u8]) -> Result<()> {
    let cert = Ed25519Cert::decode(cert_bytes).context("解码链接证书失败")?;
    
    if cert.cert_type() != CertType::LINK_AUTH {
        return Err(anyhow::anyhow!("错误的证书类型，期望LINK_AUTH"));
    }
    
    // 可以添加更多业务逻辑
    Ok(())
}

/// 创建带有自定义扩展的证书
fn create_cert_with_extension(signing_key: &ed25519::Keypair) -> Result<Vec<u8>> {
    #[derive(Debug)]
    struct MyExtension {
        custom_data: Vec<u8>,
    }

    impl CertExt for MyExtension {
        fn encode(&self) -> Vec<u8> {
            self.custom_data.clone()
        }
    }

    let mut builder = Ed25519CertConstructor::new(
        CertType::IDENTITY_V_SIGNING,
        0,
        0,
        std::time::SystemTime::now(),
        std::time::Duration::from_secs(3600 * 24 * 30), // 30天有效期
        signing_key.public,
    );

    let extension = MyExtension {
        custom_data: b"custom extension data".to_vec(),
    };

    builder.add_extension(extension);
    builder.sign_and_encode(signing_key).context("创建带扩展的证书失败")
}

/// 创建中间证书
fn create_intermediate_cert(
    root_key: &ed25519::Keypair,
    subject_key: &ed25519::PublicKey,
) -> Result<Vec<u8>> {
    let mut builder = Ed25519CertConstructor::new(
        CertType::IDENTITY_V_SIGNING,
        0,
        0,
        std::time::SystemTime::now(),
        std::time::Duration::from_secs(3600 * 24 * 180), // 6个月有效期
        *subject_key,
    );

    builder.sign_and_encode(root_key).context("创建中间证书失败")
}

/// 创建叶子证书
fn create_leaf_cert(
    signing_key: &ed25519::Keypair,
    subject_key: &ed25519::PublicKey,
) -> Result<Vec<u8>> {
    let mut builder = Ed25519CertConstructor::new(
        CertType::LINK_AUTH,
        0,
        0,
        std::time::SystemTime::now(),
        std::time::Duration::from_secs(3600 * 24 * 30), // 30天有效期
        *subject_key,
    );

    builder.sign_and_encode(signing_key).context("创建叶子证书失败")
}

/// 验证证书链
fn verify_certificate_chain(
    leaf_cert: &[u8],
    intermediate_certs: &[&[u8]],
    root_key: &ed25519::PublicKey,
) -> Result<()> {
    // 解码叶子证书
    let leaf = Ed25519Cert::decode(leaf_cert).context("解码叶子证书失败")?;
    
    let mut current_key = None;
    
    // 验证中间证书
    for &cert_bytes in intermediate_certs {
        let cert = Ed25519Cert::decode(cert_bytes).context("解码中间证书失败")?;
        
        if let Some(key) = current_key {
            cert.check_signature(&key).context("中间证书签名验证失败")?;
        } else {
            // 第一个中间证书应该由根密钥签名
            cert.check_signature(root_key).context("根证书签名验证失败")?;
        }
        
        current_key = Some(cert.subject_key());
    }
    
    // 验证叶子证书
    if let Some(key) = current_key {
        leaf.check_signature(&key).context("叶子证书签名验证失败")?;
    } else {
        // 如果没有中间证书，叶子证书应该直接由根密钥签名
        leaf.check_signature(root_key).context("根证书签名验证失败")?;
    }
    
    Ok(())
}

代码说明

1. 创建Ed25519证书：

   • 使用Ed25519CertConstructor创建证书构造器
   • 设置证书类型、版本、有效期等参数
   • 使用私钥签名并编码证书

2. 验证证书：

   • 解码证书字节
   • 检查签名是否有效
   • 验证证书是否过期

3. 处理链接认证证书：

   • 专门处理LINK_AUTH类型的证书
   • 验证证书类型和有效期

4. 自定义证书扩展：

   • 实现CertExt trait定义自定义扩展
   • 将扩展添加到证书构造器

5. 证书链验证：

   • 从根证书开始逐级验证
   • 检查每一级证书的签名是否由上一级证书的公钥验证
   • 最后验证叶子证书

Cargo.toml 依赖

[dependencies]
tor-cert = "0.8.0"
tor-llcrypto = "0.4.0"
anyhow = "1.0"
rand = "0.8"

这个完整示例演示了tor-cert库的主要功能，包括证书创建、验证、自定义扩展和证书链验证等关键操作，可用于构建Tor网络相关的安全应用。