Struct SslConfig

pub struct SslConfig {
    pub modern_security: bool,
    pub ssl_timeout: u64,
    /* private fields */
}

Available on crate feature config only.

SSL configuration for socket

Client SSL socket

use std::io;
use std::pin::Pin;
use tokio::net::TcpStream;
use tokio_openssl::SslStream;
use openssl::ssl::{ErrorCode, Ssl, SslMethod, SslVerifyMode};
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};

async fn client() -> Result<(), io::Error> {
    let mut stream = TcpStream::connect("localhost:4443").await?;

    let client_config = SslConfig::default();
    if let Ok(mut ssl_context_builder) = client_config.init_tls_client_context() {
        let ssl = ssl_context_builder.build().configure().unwrap().into_ssl("localhost").unwrap();
        let mut stream = SslStream::new(ssl, stream).unwrap();
        if let Err(e) = Pin::new(&mut stream).connect().await {
            if e.code() != ErrorCode::ZERO_RETURN {
                eprintln!("Can't connect the client: {}", e);
            }
        }

        // SSL stream ...
    }

    Ok(())
}

Server SSL socket

use std::io;
use std::pin::Pin;
use tokio::net::TcpListener;
use tokio_openssl::SslStream;
use openssl::ssl::{ErrorCode, Ssl, SslMethod, SslVerifyMode};
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};

async fn server() -> Result<(), io::Error> {
    let listener = TcpListener::bind("0.0.0.0:4443").await?;

    let server_config = SslConfig::new_cert_key("cert.pem".into(), "cert.key".into(), Some("passphrase".into()));
    if let Ok(mut ssl_context_builder) = server_config.init_tls_server_context(None) {
        ssl_context_builder.set_verify(SslVerifyMode::NONE);
        let ssl_context = ssl_context_builder.build();

        loop {
            let (stream, cli_addr) = listener.accept().await?;
            let ssl = Ssl::new(&ssl_context.context()).unwrap();
            let mut stream = SslStream::new(ssl, stream).unwrap();
            if let Err(e) = Pin::new(&mut stream).accept().await {
                if e.code() != ErrorCode::ZERO_RETURN {
                    eprintln!("Can't accept the client {}: {}", cli_addr, e);
                }
            }

            // SSL stream ...
        }
    }

    Ok(())
}

Fields

modern_security: bool

Security level. If true, it’ll use the modern version 5 of Mozilla’s TLS recommendations.

ssl_timeout: u64

SSL operation timeout in milliseconds

Implementations

impl SslConfig

pub fn new_pkcs12(pkcs12_path: String) -> SslConfig

Method to create an ssl configuration from a pkcs12 manually Should be use with config instead of building it manually

pub fn new_cert_key( cert_path: String, key_path: String, passphrase: Option<String>, ) -> SslConfig

Method to create an ssl configuration from a certificate and its key manually Should be use with config instead of building it manually

pub fn new_self_cert(cert_path: String) -> SslConfig

Method to create an ssl configuration that will generate a self signed certificate and write it’s certificate to the cert_path Should be use with config instead of building it manually

pub fn get_ssl_timeout(&self) -> Duration

Getter of the SSL timeout

pub fn set_store(&mut self, store: Store)

Setter of the store certificate

pub fn set_alpn(&mut self, alpn: Vec<String>)

Setter of the ALPN list send by the client, or order of ALPN accepted by the server

Trait Implementations

impl Clone for SslConfig

fn clone(&self) -> SslConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SslConfig

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

Formats the value using the given formatter.

impl Default for SslConfig

fn default() -> SslConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SslConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SslConfig

fn eq(&self, other: &SslConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SslConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SslConfigContext<SslConnectorBuilder, SslAcceptorBuilder> for SslConfig

Available on crate feature config-openssl only.

fn init_tls_client_context(&self) -> Result<SslConnectorBuilder, ConfigError>

Method to init an OpenSSL context for a client socket

use std::io;
use std::pin::Pin;
use tokio::net::TcpStream;
use tokio_openssl::SslStream;
use openssl::ssl::{ErrorCode, Ssl, SslMethod, SslVerifyMode};
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};

async fn client() -> Result<(), io::Error> {
    let mut stream = TcpStream::connect("localhost:4443").await?;

    let client_config = SslConfig::default();
    if let Ok(mut ssl_context_builder) = client_config.init_tls_client_context() {
        let ssl_context = ssl_context_builder.build();
        let ssl = Ssl::new(&ssl_context.context()).unwrap();
        let mut stream = SslStream::new(ssl, stream).unwrap();
        if let Err(e) = Pin::new(&mut stream).connect().await {
            if e.code() != ErrorCode::ZERO_RETURN {
                eprintln!("Can't connect the client: {}", e);
            }
        }

        // SSL stream ...
    }

    Ok(())
}

fn init_tls_server_context( &self, host: Option<&str>, ) -> Result<SslAcceptorBuilder, ConfigError>

Method to init an OpenSSL context for a server socket

use std::io;
use std::pin::Pin;
use tokio::net::TcpListener;
use tokio_openssl::SslStream;
use openssl::ssl::{ErrorCode, Ssl, SslMethod, SslVerifyMode};
use prosa_utils::config::ssl::{SslConfig, SslConfigContext};

async fn server() -> Result<(), io::Error> {
    let listener = TcpListener::bind("0.0.0.0:4443").await?;

    let server_config = SslConfig::new_cert_key("cert.pem".into(), "cert.key".into(), Some("passphrase".into()));
    if let Ok(mut ssl_context_builder) = server_config.init_tls_server_context(Some("localhost")) {
        ssl_context_builder.set_verify(SslVerifyMode::NONE);
        let ssl_context = ssl_context_builder.build();

        loop {
            let (stream, cli_addr) = listener.accept().await?;
            let ssl = Ssl::new(&ssl_context.context()).unwrap();
            let mut stream = SslStream::new(ssl, stream).unwrap();
            if let Err(e) = Pin::new(&mut stream).accept().await {
                if e.code() != ErrorCode::ZERO_RETURN {
                    eprintln!("Can't accept the client {}: {}", cli_addr, e);
                }
            }

            // SSL stream ...
        }
    }

    Ok(())
}

impl StructuralPartialEq for SslConfig