rustls-letsencrypt 0.1.4

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
//! Serve QUIC using a certificate managed by the process-scoped store.
//!
//! First run `letsencrypt_prod` or `letsencrypt_staging` and complete an ACME
//! issuance for `api.example.com`. Then run this example. In a real service,
//! keep the 443 ALPN listener running in the same process and start this QUIC
//! endpoint after `get_certificate` succeeds.

use rustls_letsencrypt::get_or_issue_certificate;
use rustls_pemfile::{certs, private_key};
use std::net::SocketAddr;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let certificate = get_or_issue_certificate("api.example.com").await?;

    let mut leaf_reader = certificate.leaf_pem().as_bytes();
    let mut certificate_chain = certs(&mut leaf_reader).collect::<Result<Vec<_>, _>>()?;
    for chain_pem in certificate.chain_pem() {
        let mut chain_reader = chain_pem.as_bytes();
        certificate_chain.extend(certs(&mut chain_reader).collect::<Result<Vec<_>, _>>()?);
    }
    let mut key_reader = certificate.private_key_pem().as_bytes();
    let private_key = private_key(&mut key_reader)?.ok_or("certificate private key is empty")?;

    let server_config = quinn::ServerConfig::with_single_cert(certificate_chain, private_key)?;
    let endpoint = quinn::Endpoint::server(server_config, "0.0.0.0:4433".parse::<SocketAddr>()?)?;
    println!("QUIC listening on {}", endpoint.local_addr()?);

    while let Some(incoming) = endpoint.accept().await {
        let connection = incoming.await?;
        println!("QUIC connection from {}", connection.remote_address());
    }
    Ok(())
}