Crate native_tls

An abstraction over platform-specific TLS implementations.

Many applications require TLS/SSL communication in one form or another as part of their implementation, but finding a library for this isn’t always trivial! The purpose of this crate is to provide a seamless integration experience on all platforms with a cross-platform API that deals with all the underlying details for you.

How is this implemented?

This crate uses SChannel on Windows (via the schannel crate), Secure Transport on OSX (via the security-framework crate), and OpenSSL (via the openssl crate) on all other platforms. Future features may also enable other TLS frameworks as well, but these initial libraries are likely to remain as the defaults.

Note that this crate also strives to be secure-by-default. For example when using OpenSSL it will configure validation callbacks to ensure that hostnames match certificates, use strong ciphers, etc. This implies that this crate is not just a thin abstraction around the underlying libraries, but also an implementation that strives to strike reasonable defaults.

Supported features

This crate supports the following features out of the box:

• TLS/SSL client communication
• TLS/SSL server communication
• PKCS#12 encoded identities
• X.509/PKCS#8 encoded identities
• Secure-by-default for client and server
  • Includes hostname verification for clients
• Supports asynchronous I/O for both the server and the client

Cargo Features

• vendored - If enabled, the crate will compile and statically link to a vendored copy of OpenSSL. This feature has no effect on Windows and macOS, where OpenSSL is not used.

Examples

To connect as a client to a remote server:

use native_tls::TlsConnector;
use std::io::{Read, Write};
use std::net::TcpStream;

let connector = TlsConnector::new().unwrap();

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 native_tls::{Identity, TlsAcceptor, TlsStream};
use std::fs::File;
use std::io::{Read};
use std::net::{TcpListener, TcpStream};
use std::sync::Arc;
use std::thread;

let mut file = File::open("identity.pfx").unwrap();
let mut identity = vec![];
file.read_to_end(&mut identity).unwrap();
let identity = Identity::from_pkcs12(&identity, "hunter2").unwrap();

let listener = TcpListener::bind("0.0.0.0:8443").unwrap();
let acceptor = TlsAcceptor::new(identity).unwrap();
let acceptor = Arc::new(acceptor);

fn handle_client(stream: TlsStream<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

• Certificate
  An X509 certificate.
• Error
  An error returned from the TLS implementation.
• Identity
  A cryptographic identity.
• MidHandshakeTlsStream
  A TLS stream which has been interrupted midway through the handshake process.
• TlsAcceptor
  A builder for server-side TLS connections.
• TlsAcceptorBuilder
  A builder for TlsAcceptors.
• TlsConnector
  A builder for client-side TLS connections.
• TlsConnectorBuilder
  A builder for TlsConnectors.
• TlsStream
  A stream managing a TLS session.

Enums

• HandshakeError
  An error returned from ClientBuilder::handshake.
• Protocol
  SSL/TLS protocol versions.

Type Definitions

• Result
  A typedef of the result-type returned by many methods.