TLS (std/tls/) #

#include <std/tls/tls.h>

#include <std/tls/tls.h>
#include <std/http/http.h>       // http_resolve_host
#include <std/sched/io_nb.h>     // tcp_connect_timeout
#include <std/str.h>
#include <std/io.h>

int main() {
    unsigned int addr = 0U;
    if (!std::http_resolve_host("example.com", &addr)) return 1;
    int fd = std::tcp_connect_timeout(addr, 443, 5000);
    if (fd < 0) return 1;
    std::sock_set_io_timeout(fd, 10000);              // bounds the handshake and every read

    struct TlsConfig cfg = std::TlsConfig::new();     // system roots, host name checked
    cfg.set_alpn("http/1.1");
    struct Result<TlsStream, TlsError> r = std::TlsStream::connect(fd, "example.com", &cfg);
    cfg.free();
    match (r.get_err()) {
        case some(e): { std::println(e.message); r.drop(); return 1; }   // the fd is still yours to close
        case null: { }
    }
    struct TlsStream t = r.unwrap();                  // consumes r
    std::print(t.backend_name()); std::print(" "); std::println(t.cipher());

    const &char req = "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
    unsafe { t.write(((const unsigned char*)req)[0..std::str_len(req)]); }
    unsigned char buf[4096];
    long long n = t.read(buf[0..4096UL]);            // count, 0 once the server closed, -1 on error
    t.close();                                        // close_notify, then closes the socket
    return n > 0LL ? 0 : 1;
}

struct TlsServerConfig sc = std::TlsServerConfig::new();
sc.load_files("cert.pem", "key.pem");     // chain (leaf first) and its key: PKCS#8, RSA or EC PEM
sc.set_alpn("h2,http/1.1");               // the server's preference order
struct Result<TlsAcceptor, TlsError> ar = std::TlsAcceptor::new(&sc);
sc.free();                                // the acceptor keeps what it needs
struct TlsAcceptor acc = ar.unwrap();     // (check ar.ok() first: unwrap() panics on an error)

int fd = std::tcp_accept_nb(listen_fd);   // blocking from here: fd_set_blocking(fd)
struct Result<TlsStream, TlsError> r = acc.accept(fd);   // the handshake
if (r.ok()) {
    struct TlsStream t = r.unwrap();
    // t.read / t.write ..., t.alpn(), t.peer_certificate(&cert) ...
    t.close();
} else {
    r.drop();                             // frees the TlsError
}
acc.free();                               // after the streams it started have finished their handshakes

struct TlsConfig {
    int           verify_peer;       // 1: check the chain and dates (default)
    int           verify_hostname;   // 1: check the name (default)
    int           use_system_roots;  // 1: trust the OS's roots (default)
    struct String ca_pem;            // more trusted roots, PEM
    struct String ca_file;           // a PEM bundle file of more trusted roots
    struct String server_name;       // SNI + the name to verify; empty: connect()'s host
    struct String alpn;              // protocols to offer, comma-separated ("h2,http/1.1")
    int           min_version;       // TLS_VERSION_1_2 (default) or TLS_VERSION_1_3
    int           max_version;       // TLS_VERSION_1_3 (default)
    int           backend;           // TLS_BACKEND_AUTO (default)
    struct String cert_pem;          // client certificate chain, if the server asks for one
    struct String key_pem;           // its private key

    static struct TlsConfig new();
    void set_ca_pem(const &char pem);
    void set_ca_file(const &char path);
    void set_server_name(const &char name);
    void set_alpn(const &char protocols);
    void set_client_cert(const &char cert_pem, const &char key_pem);
    void insecure_skip_verify();     // verification off: tests against self-signed servers only
    struct TlsConfig clone() const;
    void free() consume;
};

struct TlsServerConfig {
    struct String cert_pem;          // leaf first, then intermediates
    struct String key_pem;           // PKCS#8, RSA or EC PEM
    struct String alpn;              // the protocols the server speaks, preferred first
    int           min_version;       // TLS_VERSION_1_2 (default)
    int           max_version;       // TLS_VERSION_1_3 (default)
    int           backend;           // TLS_BACKEND_AUTO (default)
    int           verify_client;     // 0 none (default), 1 request a certificate, 2 require one
    struct String client_ca_pem;     // roots for client certificates

    static struct TlsServerConfig new();
    int  load_files(const &char cert_path, const &char key_path);   // 0 if either can't be read
    void set_alpn(const &char protocols);
    void free() consume;
};

struct TlsStream {
    // Client, blocking: the whole handshake. On failure the fd stays open.
    static struct Result<TlsStream, TlsError> connect(int fd, const &char host, const ?&TlsConfig cfg);
    // Client, non-blocking: set up only; drive with handshake().
    static struct Result<TlsStream, TlsError> client(int fd, const &char host, const ?&TlsConfig cfg);

    int       handshake();     // 0 done, TLS_WANT_READ / TLS_WANT_WRITE, -1 failed
    long long read([]unsigned char buf);         // count, 0 = peer closed, -1, TLS_WANT_*
    long long write([]const unsigned char buf);  // count, -1, TLS_WANT_*
    int       shutdown();      // send close_notify (once)
    int       close() consume; // shutdown, free, close the socket
    void      release() consume;       // free the TLS state, leave the fd open

    int  is_open() const;
    int  version() const;               // TLS_VERSION_1_2 / TLS_VERSION_1_3
    const &char cipher() const;         // IANA name: "TLS_AES_128_GCM_SHA256"
    const &char alpn() const;           // the protocol agreed, "" if none
    const &char backend_name() const;   // "openssl", "schannel", "securetransport", "safec"
    int  peer_certificate(&X509Cert out) const;   // the peer's leaf, summarized
    const &TlsError last_error() const;
};

struct TlsAcceptor {
    static struct Result<TlsAcceptor, TlsError> new(const &TlsServerConfig cfg);
    struct Result<TlsStream, TlsError> accept(int fd);   // blocking handshake
    struct Result<TlsStream, TlsError> start(int fd);    // non-blocking: drive with handshake()
    void free() consume;
};