rustls für Rust: Vollständiges Tutorial mit Beispielen

1. Was ist rustls und warum braucht man es?

rustls ist eine moderne, sichere und hochperformante Implementierung des TLS-Protokolls (Transport Layer Security) in Rust. Im Gegensatz zu Schwergewichten wie OpenSSL oder native-tls ist rustls vollständig in Rust geschrieben, ohne C-Bibliotheksbindungen. Das macht es zur idealen Wahl für Projekte, bei denen Speichersicherheit, die Vermeidung von undefiniertem Verhalten (undefined behavior) und eine einfache Build-Konfiguration entscheidend sind.

Warum rustls verwenden? Erstens löst es das Problem des „Dependency Hell“: Du musst weder OpenSSL auf dem Server installieren noch mit verschiedenen libssl-dev-Versionen kämpfen. Zweitens verwendet rustls standardmäßig nur sichere kryptografische Algorithmen (TLS 1.2 und 1.3, ohne veraltete Cipher Suites). Drittens lässt es sich nahtlos in die Rust-Ökosysteme mit async/await und Frameworks wie Tokio und async-std integrieren.

Hauptanwendungsfälle: Erstellung von HTTPS-Servern und -Clients, gesicherte WebSocket-Verbindungen, Arbeit mit gRPC sowie alle anderen Szenarien, die eine Verschlüsselung des Datenverkehrs über TCP erfordern. rustls wird aktiv in Projekten wie curl, Firefox (über Neqo) und vielen industriellen Rust-Anwendungen eingesetzt.

2. Installation

Füge rustls mit dem Paketmanager Cargo zu deinem Projekt hinzu. Für die grundlegende Nutzung reichen zwei Abhängigkeiten:

# Cargo.toml
[dependencies]
rustls = "0.23"           # Hauptbibliothek
webpki-roots = "0.26"     # Vertrauenswürdige Root-Zertifikate (für den Client)
tokio = { version = "1", features = ["full"] }  # Für das asynchrone Beispiel
tokio-rustls = "0.26"     # Asynchrone Wrapper für Tokio

Wenn du nur den synchronen (blockierenden) Modus benötigst, kannst du auf tokio-rustls verzichten. Für die Arbeit mit Zertifikaten können auch rcgen (Generierung selbstsignierter Zertifikate) und rustls-pemfile (Lesen von PEM-Dateien) nützlich sein.

# Installation via cargo add (falls cargo-edit verwendet wird)
cargo add rustls webpki-roots tokio tokio-rustls

3. Schnellstart – Minimales funktionierendes Beispiel

Erstellen wir einen einfachen HTTPS-Client, der eine Seite von example.com lädt. Dieses Beispiel zeigt die grundlegende Konfiguration von rustls mit systemweiten Root-Zertifikaten.

// 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. Client-Konfiguration mit vertrauenswürdigen Roots erstellen
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(TLS_SERVER_ROOTS.clone())
        .with_no_client_auth();

    // 2. TLS-Connector erstellen
    let connector = TlsConnector::from(Arc::new(config));

    // 3. TCP-Verbindung herstellen
    let stream = TcpStream::connect("example.com:443").await?;

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

    // 5. HTTP-Anfrage senden
    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. Antwort lesen
    use tokio::io::AsyncReadExt;
    let mut response = String::new();
    tls_stream.read_to_string(&mut response).await?;
    println!("Serverantwort:\n{}", response);

    Ok(())
}

Dieser Code stellt eine gesicherte Verbindung zu example.com her, sendet eine HTTP-Anfrage und gibt die Antwort aus. Beachte: Wir verwenden webpki-roots zur Überprüfung des Serverzertifikats – das ist sicher und erfordert keine OpenSSL-Installation.