Struct RustlsConfig

pub struct RustlsConfig { /* private fields */ }

Available on crate feature tls-rustls only.

Rustls configuration.

Implementations

impl RustlsConfig

pub fn from_config(config: Arc<ServerConfig>) -> Self

Create config from Arc<ServerConfig>.

NOTE: You need to set ALPN protocols (like http/1.1 or h2) manually.

pub async fn from_der(cert: Vec<Vec<u8>>, key: Vec<u8>) -> Result<Self>

Create config from DER-encoded data.

The certificate must be DER-encoded X.509.

The private key must be DER-encoded ASN.1 in either PKCS#8 or PKCS#1 format.

pub async fn from_pem(cert: Vec<u8>, key: Vec<u8>) -> Result<Self>

Create config from PEM formatted data.

Certificate and private key must be in PEM format.

pub async fn from_pem_file( cert: impl AsRef<Path>, key: impl AsRef<Path>, ) -> Result<Self>

Create config from PEM formatted files.

Contents of certificate file and private key file must be in PEM format.

Examples found in repository

examples/rustls_server.rs (lines 13-16)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    axum_server::tls_rustls::bind_rustls(addr, config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/http_and_https.rs (lines 39-42)

async fn https_server() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3443));
    println!("https listening on {}", addr);
    axum_server::bind_rustls(addr, config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/rustls_session.rs (lines 20-23)

async fn main() {
    let app = Router::new().route("/", get(handler));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    println!("listening on {}", addr);

    let acceptor = CustomAcceptor::new(RustlsAcceptor::new(config));
    let server = axum_server::bind(addr).acceptor(acceptor);

    server.serve(app.into_make_service()).await.unwrap();
}

examples/from_std_listener_rustls.rs (lines 14-17)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    let listener = TcpListener::bind(addr).unwrap();
    println!("listening on {}", addr);
    axum_server::from_tcp_rustls(listener, config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/rustls_reload.rs (lines 18-21)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    // Spawn a task to reload tls.
    tokio::spawn(reload(config.clone()));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    axum_server::bind_rustls(addr, config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

pub fn get_inner(&self) -> Arc<ServerConfig>

Get inner Arc<ServerConfig>.

pub fn reload_from_config(&self, config: Arc<ServerConfig>)

Reload config from Arc<ServerConfig>.

pub async fn reload_from_der( &self, cert: Vec<Vec<u8>>, key: Vec<u8>, ) -> Result<()>

Reload config from DER-encoded data.

The certificate must be DER-encoded X.509.

The private key must be DER-encoded ASN.1 in either PKCS#8 or PKCS#1 format.

pub async fn from_pem_chain_file( chain: impl AsRef<Path>, key: impl AsRef<Path>, ) -> Result<Self>

This helper will establish a TLS server based on strong cipher suites from a PEM-formatted certificate chain and key.

pub async fn reload_from_pem(&self, cert: Vec<u8>, key: Vec<u8>) -> Result<()>

Reload config from PEM formatted data.

Certificate and private key must be in PEM format.

pub async fn reload_from_pem_file( &self, cert: impl AsRef<Path>, key: impl AsRef<Path>, ) -> Result<()>

Reload config from PEM formatted files.

Contents of certificate file and private key file must be in PEM format.

Examples found in repository

examples/rustls_reload.rs (lines 44-47)

async fn reload(config: RustlsConfig) {
    // Wait for 20 seconds.
    sleep(Duration::from_secs(20)).await;

    println!("reloading rustls configuration");

    // Reload rustls configuration from new files.
    config
        .reload_from_pem_file(
            "examples/self-signed-certs/reload/cert.pem",
            "examples/self-signed-certs/reload/key.pem",
        )
        .await
        .unwrap();

    println!("rustls configuration reloaded");
}

Trait Implementations

impl Clone for RustlsConfig

fn clone(&self) -> RustlsConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RustlsConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.