rustls pour Rust : guide complet avec exemples

1. Qu'est-ce que rustls et pourquoi l'utiliser ?

rustls est une implémentation moderne, sécurisée et haute performance du protocole TLS (Transport Layer Security) en langage Rust. Contrairement à des géants comme OpenSSL ou native-tls, rustls est entièrement écrit en Rust sans dépendances aux bibliothèques C, ce qui en fait un choix idéal pour les projets où la sécurité mémoire, l'absence de comportement indéfini (undefined behavior) et la facilité de compilation sont primordiales.

Pourquoi utiliser rustls ? Premièrement, elle résout le problème de « l'enfer des dépendances » : vous n'avez pas besoin d'installer OpenSSL sur votre serveur ou de lutter avec les versions de libssl-dev. Deuxièmement, rustls utilise par défaut uniquement des algorithmes cryptographiques sécurisés (TLS 1.2 et 1.3, en excluant les chiffrements obsolètes). Troisièmement, elle s'intègre parfaitement avec l'écosystème Rust via async/await et des frameworks comme Tokio et async-std.

Les principaux cas d'utilisation : création de serveurs et clients HTTPS, connexions WebSocket sécurisées, travail avec gRPC, ainsi que tout autre cas nécessitant le chiffrement du trafic sur TCP. rustls est activement utilisé dans des projets comme curl, Firefox (via Neqo), et de nombreuses applications Rust industrielles.

2. Installation

Ajoutez rustls à votre projet à l'aide du gestionnaire de paquets Cargo. Pour une utilisation de base, deux dépendances suffisent :

# Cargo.toml
[dependencies]
rustls = "0.23"           # Bibliothèque principale
webpki-roots = "0.26"     # Certificats racines de confiance (pour le client)
tokio = { version = "1", features = ["full"] }  # Pour l'exemple asynchrone
tokio-rustls = "0.26"     # Wrapper asynchrone pour Tokio

Si vous n'avez besoin que du mode synchrone (bloquant), vous pouvez vous passer de tokio-rustls. Pour travailler avec les certificats, vous aurez peut-être besoin de rcgen (génération de certificats auto-signés) et de rustls-pemfile (lecture de fichiers PEM).

# Installation via cargo add (si vous utilisez cargo-edit)
cargo add rustls webpki-roots tokio tokio-rustls

3. Démarrage rapide — exemple minimal fonctionnel

Créons un client HTTPS simple qui télécharge une page depuis example.com. Cet exemple illustre la configuration de base de rustls avec les certificats racines système.

// 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. Création de la configuration client avec les racines de confiance
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(TLS_SERVER_ROOTS.clone())
        .with_no_client_auth();

    // 2. Création du connecteur TLS
    let connector = TlsConnector::from(Arc::new(config));

    // 3. Établissement de la connexion TCP
    let stream = TcpStream::connect("example.com:443").await?;

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

    // 5. Envoi de la requête 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. Lecture de la réponse
    use tokio::io::AsyncReadExt;
    let mut response = String::new();
    tls_stream.read_to_string(&mut response).await?;
    println!("Réponse du serveur :\n{}", response);

    Ok(())
}

Ce code établit une connexion sécurisée avec example.com, envoie une requête HTTP et affiche la réponse. Notez que nous utilisons webpki-roots pour vérifier le certificat du serveur — c'est sécurisé et ne nécessite pas l'installation d'OpenSSL.