Crate native_tls[−][src]
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 futures 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
- 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 |
TlsConnector | A builder for client-side TLS connections. |
TlsConnectorBuilder | A builder for |
TlsStream | A stream managing a TLS session. |
Enums
HandshakeError | An error returned from |
Protocol | SSL/TLS protocol versions. |
Type Definitions
Result | A typedef of the result-type returned by many methods. |