Module ssl

SSL/TLS support.

SslConnector and SslAcceptor should be used in most cases - they handle configuration of the OpenSSL primitives for you.

Examples

To connect as a client to a remote server:

use openssl::ssl::{SslMethod, SslConnector};
use std::io::{Read, Write};
use std::net::TcpStream;

let connector = SslConnector::builder(SslMethod::tls()).unwrap().build();

let stream = TcpStream::connect("google.com:443").unwrap();
let mut stream = connector.connect("google.com", stream).unwrap();

stream.write_all(b"GET / HTTP/1.0\r\n\r\n").unwrap();
let mut res = vec![];
stream.read_to_end(&mut res).unwrap();
println!("{}", String::from_utf8_lossy(&res));

To accept connections as a server from remote clients:

use openssl::ssl::{SslMethod, SslAcceptor, SslStream, SslFiletype};
use std::net::{TcpListener, TcpStream};
use std::sync::Arc;
use std::thread;


let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
acceptor.set_private_key_file("key.pem", SslFiletype::PEM).unwrap();
acceptor.set_certificate_chain_file("certs.pem").unwrap();
acceptor.check_private_key().unwrap();
let acceptor = Arc::new(acceptor.build());

let listener = TcpListener::bind("0.0.0.0:8443").unwrap();

fn handle_client(stream: SslStream<TcpStream>) {
    // ...
}

for stream in listener.incoming() {
    match stream {
        Ok(stream) => {
            let acceptor = acceptor.clone();
            thread::spawn(move || {
                let stream = acceptor.accept(stream).unwrap();
                handle_client(stream);
            });
        }
        Err(e) => { /* connection failed */ }
    }
}

Structs

AlpnError

An error returned from an ALPN selection callback.

CipherBits

Information about the state of a cipher.

CipherLists

A stack of selected ciphers, and a stack of selected signalling cipher suites

ClientHelloResponse

The result of a client hello callback.

ConnectConfiguration

A type which allows for configuration of a client-side TLS session before connection.

Error

An SSL error.

ErrorCode

An error code returned from SSL functions.

ExtensionContext

Which messages and under which conditions an extension should be added or expected.

MidHandshakeSslStream

An SSL stream midway through the handshake process.

NameType

An identifier of a session name type.

ShutdownState

The shutdown state of a session.

SniError

An error returned from the SNI callback.

Ssl

The state of an SSL/TLS session.

SslAcceptor

A type which wraps server-side streams in a TLS session.

SslAcceptorBuilder

A builder for SslAcceptors.

SslAlert

An SSL/TLS alert.

SslCipher

Information about a cipher.

SslCipherRef

Reference to an SslCipher.

SslConnector

A type which wraps client-side streams in a TLS session.

SslConnectorBuilder

A builder for SslConnectors.

SslContext

A context object for TLS streams.

SslContextBuilder

A builder for SslContexts.

SslContextRef

Reference to SslContext

SslFiletype

An identifier of the format of a certificate or key file.

SslMethod

A type specifying the kind of protocol an SslContext will speak.

SslMode

Options controlling the behavior of an SslContext.

SslOptions

Options controlling the behavior of an SslContext.

SslRef

Reference to an Ssl.

SslSession

An encoded SSL session.

SslSessionCacheMode

Options controlling the behavior of session caching.

SslSessionRef

Reference to SslSession.

SslStream

A TLS session over a stream.

SslStreamBuilderDeprecated

A partially constructed SslStream, useful for unusual handshakes.

SslVerifyMode

Options controlling the behavior of certificate verification.

SslVersion

An SSL/TLS protocol version.

StatusType

An identifier of a certificate status type.

Enums

HandshakeError

An error or intermediate state after a TLS handshake attempt.

ShutdownResult

The result of a shutdown request.

Functions

cipher_name

Returns the OpenSSL name of a cipher corresponding to an RFC-standard cipher name.

select_next_proto

A standard implementation of protocol selection for Application Layer Protocol Negotiation (ALPN).