Rust的TLS加密库deno_tls的使用，deno_tls为Rust应用提供安全的传输层加密功能

Rust的TLS加密库deno_tls的使用，deno_tls为Rust应用提供安全的传输层加密功能

deno_tls是一个用于处理TLS加密的Rust库，它为Deno扩展和其他Rust应用提供了常见的安全传输层加密功能。

安装

在您的项目目录中运行以下Cargo命令：

cargo add deno_tls

或者在您的Cargo.toml中添加以下行：

deno_tls = "0.199.0"

示例代码

以下是一个使用deno_tls库的基本示例，展示了如何创建一个简单的TLS客户端：

use deno_tls::rustls::{ClientConfig, RootCertStore};
use deno_tls::rustls::pki_types::CertificateDer;
use std::sync::Arc;
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;

async fn example_tls_client() -> Result<(), Box<dyn std::error::Error>> {
    // 创建根证书存储
    let mut root_store = RootCertStore::empty();
    
    // 添加系统默认的根证书（实际使用时可能需要添加特定证书）
    for cert in rustls_native_certs::load_native_certs()? {
        root_store.add(cert)?;
    }

    // 配置TLS客户端
    let config = ClientConfig::builder()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    
    // 创建TLS连接器
    let connector = TlsConnector::from(Arc::new(config));

    // 建立TCP连接
    let stream = TcpStream::connect("example.com:443").await?;
    
    // 建立TLS连接
    let domain = "example.com".try_into()?;
    let tls_stream = connector.connect(domain, stream).await?;

    // 在这里可以使用tls_stream进行安全通信...
    
    Ok(())
}

完整示例demo

下面是一个更完整的TLS客户端示例，包含HTTP请求功能：

use deno_tls::rustls::{ClientConfig, RootCertStore};
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 创建根证书存储
    let mut root_store = RootCertStore::empty();
    
    // 加载系统默认证书
    for cert in rustls_native_certs::load_native_certs()? {
        root_store.add(cert)?;
    }

    // 2. 配置TLS客户端
    let config = ClientConfig::builder()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    
    // 3. 创建TLS连接器
    let connector = TlsConnector::from(Arc::new(config));

    // 4. 建立TCP连接
    let stream = TcpStream::connect("www.rust-lang.org:443").await?;
    
    // 5. 建立TLS连接
    let domain = "www.rust-lang.org".try_into()?;
    let mut tls_stream = connector.connect(domain, stream).await?;

    // 6. 发送HTTP GET请求
    let request = "GET / HTTP/1.1\r\nHost: www.rust-lang.org\r\nConnection: close\r\n\r\n";
    tls_stream.write_all(request.as_bytes()).await?;

    // 7. 读取响应
    let mut response = Vec::new();
    tls_stream.read_to_end(&mut response).await?;
    
    // 8. 打印响应
    println!("{}", String::from_utf8_lossy(&response));

    Ok(())
}

主要特点

  1. 提供安全的TLS/SSL加密功能
  2. 支持现代加密协议和算法
  3. 与Deno生态系统紧密集成
  4. 可用于构建安全的网络应用程序

许可证

deno_tls采用MIT许可证发布。

文档

更多详细信息和API参考，请查看官方文档。


1 回复

Rust的TLS加密库deno_tls使用指南

完整示例代码

TLS客户端完整示例

use deno_tls::rustls::ClientConfig;
use deno_tls::rustls::RootCertStore;
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 创建根证书存储
    let mut root_store = RootCertStore::empty();
    // 添加系统信任的根证书
    root_store.add_server_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.0.iter().map(|ta| {
        deno_tls::rustls::OwnedTrustAnchor::from_subject_spki_name_constraints(
            ta.subject,
            ta.spki,
            ta.name_constraints,
        )
    }));
    
    // 2. 配置TLS客户端
    let config = ClientConfig::builder()
        .with_safe_defaults()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    
    let connector = TlsConnector::from(Arc::new(config));
    
    // 3. 建立TCP连接
    let stream = TcpStream::connect("example.com:443").await?;
    
    // 4. 建立TLS连接
    let domain = "example.com".try_into()?;
    let mut tls_stream = connector.connect(domain, stream).await?;
    
    // 5. 发送HTTP请求
    tls_stream.write_all(b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n").await?;
    
    // 6. 读取响应
    let mut buf = Vec::new();
    tls_stream.read_to_end(&mut buf).await?;
    println!("{}", String::from_utf8_lossy(&buf));
    
    Ok(())
}

TLS服务器完整示例

use deno_tls::rustls::{ServerConfig, Certificate, PrivateKey};
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio_rustls::TlsAcceptor;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 加载证书和私钥
    let certs = vec![Certificate(fs::read("cert.pem")?)];
    let key = PrivateKey(fs::read("key.pem")?);
    
    // 2. 配置TLS服务器
    let config = ServerConfig::builder()
        .with_safe_defaults()
        .with_no_client_auth()
        .with_single_cert(certs, key)?;
    
    let acceptor = TlsAcceptor::from(Arc::new(config));
    
    // 3. 监听TCP端口
    let listener = TcpListener::bind("0.0.0.0:8443").await?;
    println!("Server listening on 0.0.0.0:8443");
    
    loop {
        let (stream, _) = listener.accept().await?;
        let acceptor = acceptor.clone();
        
        tokio::spawn(async move {
            // 4. 接受TLS连接
            let mut tls_stream = match acceptor.accept(stream).await {
                Ok(stream) => stream,
                Err(e) => {
                    eprintln!("TLS handshake failed: {}", e);
                    return;
                }
            };
            
            // 5. 处理客户端请求
            let mut buf = [0; 1024];
            match tls_stream.read(&mut buf).await {
                Ok(n) if n == 0 => return,
                Ok(n) => {
                    println!("Received: {}", String::from_utf8_lossy(&buf[..n]));
                    tls_stream.write_all(b"HTTP/1.1 200 OK\r\n\r\nHello from TLS server!").await?;
                }
                Err(e) => {
                    eprintln!("Error reading from stream: {}", e);
                    return;
                }
            }
            
            Ok::<(), Box<dyn std::error::Error>>(())
        });
    }
}

证书生成说明

在实际使用前，需要生成自签名证书用于测试：

# 生成私钥
openssl genrsa -out key.pem 2048

# 生成自签名证书
openssl req -new -x509 -sha256 -key key.pem -out cert.pem -days 365 -subj "/CN=localhost"

注意：生产环境应使用由受信任CA签发的证书，而不是自签名证书。

回到顶部