rustls para Rust: guia completo com exemplos práticos

1. O que é e para que serve

rustls é uma implementação moderna, segura e de alto desempenho do protocolo TLS (Transport Layer Security) na linguagem Rust. Diferente de gigantes como OpenSSL ou native-tls, o rustls é escrito inteiramente em Rust, sem dependências de bibliotecas C, tornando-o a escolha ideal para projetos onde segurança de memória, ausência de comportamento indefinido (undefined behavior) e facilidade de compilação são prioridades.

Para que serve o rustls? Primeiro, ele resolve o problema de "dependency hell": você não precisa instalar OpenSSL no servidor ou lidar com versões do libssl-dev. Segundo, o rustls usa por padrão apenas algoritmos criptográficos seguros (TLS 1.2 e 1.3, excluindo cifras obsoletas). Terceiro, ele se integra perfeitamente ao ecossistema Rust através de async/await e frameworks como Tokio e async-std.

Principais casos de uso: criação de servidores e clientes HTTPS, conexões WebSocket seguras, integração com gRPC e qualquer outro cenário que exija criptografia de tráfego sobre TCP. O rustls é amplamente utilizado em projetos como curl, Firefox (via Neqo) e diversas aplicações Rust industriais.

2. Instalação

Adicione o rustls ao seu projeto usando o gerenciador de pacotes Cargo. Para uso básico, bastam duas dependências:

# Cargo.toml
[dependencies]
rustls = "0.23"           # Biblioteca principal
webpki-roots = "0.26"     # Certificados raiz confiáveis (para cliente)
tokio = { version = "1", features = ["full"] }  # Para exemplo assíncrono
tokio-rustls = "0.26"     # Wrapper assíncrono para Tokio

Se você precisar apenas do modo síncrono (bloqueante), pode dispensar o tokio-rustls. Para trabalhar com certificados, também podem ser necessários rcgen (geração de certificados autoassinados) e rustls-pemfile (leitura de arquivos PEM).

# Instalação via cargo add (se você usa cargo-edit)
cargo add rustls webpki-roots tokio tokio-rustls

3. Início rápido — exemplo mínimo funcional

Vamos criar um cliente HTTPS simples que baixa uma página do example.com. Este exemplo demonstra a configuração básica do rustls usando os certificados raiz do 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. Criar configuração do cliente com raízes confiáveis
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(TLS_SERVER_ROOTS.clone())
        .with_no_client_auth();

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

    // 3. Estabelecer conexão TCP
    let stream = TcpStream::connect("example.com:443").await?;

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

    // 5. Enviar requisição 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. Ler resposta
    use tokio::io::AsyncReadExt;
    let mut response = String::new();
    tls_stream.read_to_string(&mut response).await?;
    println!("Resposta do servidor:\n{}", response);

    Ok(())
}

Este código estabelece uma conexão segura com example.com, envia uma requisição HTTP e exibe a resposta. Observe que usamos webpki-roots para validar o certificado do servidor — isso é seguro e não requer instalação do OpenSSL.