rustls para Rust: guía completa con ejemplos prácticos

1. ¿Qué es rustls y por qué usarla?

rustls es una implementación moderna, segura y de alto rendimiento del protocolo TLS (Transport Layer Security) escrita completamente en Rust. A diferencia de gigantes como OpenSSL o native-tls, rustls está desarrollada íntegramente en Rust sin dependencias de bibliotecas C, lo que la convierte en la opción ideal para proyectos donde la seguridad de memoria, la ausencia de comportamiento indefinido (undefined behavior) y la facilidad de compilación son prioritarias.

¿Para qué sirve rustls? Primero, elimina el problema del "dependency hell": no necesitas instalar OpenSSL en tu servidor ni lidiar con versiones de libssl-dev. Segundo, rustls utiliza por defecto únicamente algoritmos criptográficos seguros (TLS 1.2 y 1.3, excluyendo cifrados obsoletos). Tercero, se integra perfectamente con el ecosistema de Rust mediante async/await y frameworks como Tokio y async-std.

Casos de uso principales: creación de servidores y clientes HTTPS, conexiones WebSocket seguras, trabajo con gRPC y cualquier otro escenario que requiera cifrado de tráfico sobre TCP. rustls se utiliza activamente en proyectos como curl, Firefox (a través de Neqo) y numerosas aplicaciones Rust de nivel industrial.

2. Instalación

Añade rustls a tu proyecto usando el gestor de paquetes Cargo. Para un uso básico, necesitas dos dependencias:

# Cargo.toml
[dependencies]
rustls = "0.23"           # Biblioteca principal
webpki-roots = "0.26"     # Certificados raíz de confianza (para cliente)
tokio = { version = "1", features = ["full"] }  # Para el ejemplo asíncrono
tokio-rustls = "0.26"     # Envoltorio asíncrono para Tokio

Si solo necesitas el modo síncrono (bloqueante), puedes prescindir de tokio-rustls. Para trabajar con certificados, también pueden ser útiles rcgen (generación de certificados autofirmados) y rustls-pemfile (lectura de archivos PEM).

# Instalación mediante cargo add (si usas cargo-edit)
cargo add rustls webpki-roots tokio tokio-rustls

3. Inicio rápido — ejemplo mínimo funcional

Vamos a crear un cliente HTTPS simple que descargue una página de example.com. Este ejemplo muestra la configuración básica de rustls usando los certificados raíz del sistema.

// src/main.rs
use std::sync::Arc;
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;
use rustls::pki_types::ServerName;
use webpki_roots::TLS_SERVER_ROOTS;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Creamos la configuración del cliente con raíces de confianza
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(TLS_SERVER_ROOTS.clone())
        .with_no_client_auth();

    // 2. Creamos el conector TLS
    let connector = TlsConnector::from(Arc::new(config));

    // 3. Establecemos la conexión TCP
    let stream = TcpStream::connect("example.com:443").await?;

    // 4. Envolvemos en TLS
    let server_name = ServerName::try_from("example.com")?;
    let mut tls_stream = connector.connect(server_name, stream).await?;

    // 5. Enviamos la petición HTTP
    use tokio::io::AsyncWriteExt;
    tls_stream.write_all(b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n").await?;

    // 6. Leemos la respuesta
    use tokio::io::AsyncReadExt;
    let mut response = String::new();
    tls_stream.read_to_string(&mut response).await?;
    println!("Respuesta del servidor:\n{}", response);

    Ok(())
}

Este código establece una conexión segura con example.com, envía una petición HTTP y muestra la respuesta. Observa que usamos webpki-roots para verificar el certificado del servidor — es seguro y no requiere instalar OpenSSL.

4. Métodos/funciones/clases principales

4.1. rustls::ClientConfig::builder()

Firma: pu