tls.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CRYPTO_TLS_HPP
#define JOIN_CRYPTO_TLS_HPP
 
// libjoin.
#include <join/datagram_socket.hpp>
#include <join/stream_socket.hpp>
#include <join/tls_protocol.hpp>
#include <join/tls_context.hpp>
#include <join/tls_error.hpp>
#include <join/error.hpp>
 
// C++.
#include <algorithm>
#include <iostream>
#include <utility>
#include <chrono>
#include <string>
 
// C.
#include <fnmatch.h>
#include <cassert>
 
namespace join
{
    template <class Protocol>
    class BasicTls
    {
    public:
        using UnderlyingSocket = typename Protocol::Transport::Socket;
        using Mode = typename UnderlyingSocket::Mode;
        using Option = typename UnderlyingSocket::Option;
        using State = typename UnderlyingSocket::State;
        using Endpoint = typename Protocol::Endpoint;
        using TimePoint = typename UnderlyingSocket::TimePoint;
 
        explicit BasicTls (TlsContext ctx, Mode mode = Mode::NonBlocking) noexcept
        : BasicTls (UnderlyingSocket{mode}, ctx)
        {
        }
 
        explicit BasicTls (UnderlyingSocket&& socket) noexcept
        : _socket (std::move (socket))
        {
        }
 
        BasicTls (UnderlyingSocket&& socket, TlsContext ctx) noexcept
        : _socket (std::move (socket))
        , _ctx (ctx)
        {
        }
 
        BasicTls (const BasicTls& other) = delete;
 
        BasicTls& operator= (const BasicTls& other) = delete;
 
        BasicTls (BasicTls&& other) noexcept
        : _socket (std::move (other._socket))
        , _ctx (std::move (other._ctx))
        , _ssl (std::move (other._ssl))
        {
            if (_ssl)
            {
                SSL_set_app_data (_ssl.get (), this);
            }
        }
 
        BasicTls& operator= (BasicTls&& other) noexcept
        {
            _socket = std::move (other._socket);
            _ctx = std::move (other._ctx);
            _ssl = std::move (other._ssl);
 
            if (_ssl)
            {
                SSL_set_app_data (_ssl.get (), this);
            }
 
            return *this;
        }
 
        virtual ~BasicTls () = default;
 
        int open (const Protocol& protocol = Protocol ()) noexcept
        {
            return _socket.open (typename Protocol::Transport (protocol.family ()));
        }
 
        bool opened () const noexcept
        {
            return _socket.opened ();
        }
 
        int bind (const Endpoint& ep) noexcept
        {
            return _socket.bind (ep);
        }
 
        int bindToDevice (const std::string& dev) noexcept
        {
            return _socket.bindToDevice (dev);
        }
 
        int connect (const Endpoint& ep) noexcept
        {
            return _socket.connect (ep);
        }
 
        bool connected () noexcept
        {
            return _socket.connected ();
        }
 
        int deferHandshake ()
        {
            if (!_ctx.handle ())
            {
                lastError = make_error_code (Errc::OperationFailed);
                return -1;
            }
 
            if (!_ssl)
            {
                if (_socket.type () == SOCK_DGRAM)
                {
                    if (!_socket.opened ())
                    {
                        lastError = make_error_code (Errc::OperationFailed);
                        return -1;
                    }
 
                    if (!_ctx.isServer () && !_socket.connected ())
                    {
                        lastError = make_error_code (Errc::OperationFailed);
                        return -1;
                    }
                }
 
                if (_socket.type () == SOCK_STREAM)
                {
                    if (!_socket.connected ())
                    {
                        lastError = make_error_code (Errc::OperationFailed);
                        return -1;
                    }
                }
 
                _ssl.reset (SSL_new (_ctx.handle ()));
                if (!_ssl)
                {
                    // LCOV_EXCL_START
                    lastError = make_error_code (Errc::OutOfMemory);
                    return -1;
                    // LCOV_EXCL_STOP
                }
 
                if (_socket.type () == SOCK_DGRAM)
                {
                    BIO* bio = BIO_new_dgram (_socket.handle (), BIO_NOCLOSE);
                    if (!bio)
                    {
                        lastError = make_error_code (Errc::OutOfMemory);
                        _ssl.reset ();
                        return -1;
                    }
 
                    if (_socket.connected ())
                    {
                        BIO_ctrl (bio, BIO_CTRL_DGRAM_SET_CONNECTED, 0,
                                  const_cast<struct sockaddr*> (_socket.remoteEndpoint ().addr ()));
                    }
 
                    SSL_set_bio (_ssl.get (), bio, bio);
                    SSL_set_read_ahead (_ssl.get (), 1);
                }
                else
                {
                    if (SSL_set_fd (_ssl.get (), _socket.handle ()) == 0)
                    {
                        lastError = make_error_code (Errc::InvalidParam);
                        _ssl.reset ();
                        return -1;
                    }
                }
 
                if (SSL_is_server (_ssl.get ()))
                {
                    SSL_set_accept_state (_ssl.get ());
                }
                else
                {
                    const std::string& host = _socket.remoteEndpoint ().hostname ();
                    if (!host.empty () && SSL_set_tlsext_host_name (_ssl.get (), host.c_str ()) != 1)
                    {
                        lastError = make_error_code (Errc::InvalidParam);
                        _ssl.reset ();
                        return -1;
                    }
 
                    SSL_set_connect_state (_ssl.get ());
                }
 
                SSL_set_app_data (_ssl.get (), this);
#ifdef DEBUG
                SSL_set_info_callback (_ssl.get (), infoWrapper);
#endif
 
                if (_ctx.verify ())
                {
                    SSL_set_verify (_ssl.get (), SSL_VERIFY_PEER, verifyWrapper);
                    SSL_set_verify_depth (_ssl.get (), _ctx.depth ());
                }
                else
                {
                    SSL_set_verify (_ssl.get (), SSL_VERIFY_NONE, nullptr);
                }
            }
 
            return 0;
        }
 
        int handshake ()
        {
            if (encrypted ())
            {
                return 0;
            }
 
            if (deferHandshake () == -1)
            {
                return -1;
            }
 
            int result = SSL_do_handshake (_ssl.get ());
            if (result < 1)
            {
                int ret = handleTlsError (result);
                if (lastError != make_error_code (Errc::TemporaryError))
                {
                    _ssl.reset ();
                }
                return ret;
            }
 
            return 0;
        }
 
        bool waitHandshake ()
        {
            return waitHandshake (TimePoint::max ());
        }
 
        bool waitHandshake (std::chrono::nanoseconds timeout)
        {
            return waitHandshake (std::chrono::steady_clock::now () + timeout);
        }
 
        virtual bool waitHandshake (TimePoint deadline)
        {
            if (JOIN_UNLIKELY ((deadline != TimePoint::max ()) && (_socket.mode () == Mode::Blocking)))
            {
                lastError = make_error_code (Errc::OperationFailed);
                return false;
            }
 
            if (handshake () == 0)
            {
                return true;
            }
 
            const bool isDtls = (_socket.type () == SOCK_DGRAM);
 
            while (lastError == make_error_code (Errc::TemporaryError))
            {
                bool wantRead = SSL_want_read (_ssl.get ());
                bool wantWrite = SSL_want_write (_ssl.get ());
 
                if (!wantRead && !wantWrite)
                {
                    break;  // LCOV_EXCL_LINE
                }
 
                TimePoint activeDeadline = deadline;
 
                if (isDtls)
                {
                    struct timeval dtlsTimeout;
                    if (DTLSv1_get_timeout (_ssl.get (), &dtlsTimeout))
                    {
                        activeDeadline = std::min (activeDeadline, std::chrono::steady_clock::now () +
                                                                       std::chrono::seconds (dtlsTimeout.tv_sec) +
                                                                       std::chrono::microseconds (dtlsTimeout.tv_usec));
                    }
                }
 
                if (_socket.waitUntil (wantRead, wantWrite, activeDeadline) == -1)
                {
                    if (isDtls && (lastError == make_error_code (Errc::TimedOut)) &&
                        (std::chrono::steady_clock::now () < deadline))
                    {
                        int ret = DTLSv1_handle_timeout (_ssl.get ());
                        if (ret < 0)
                        {
                            lastError = make_error_code (TlsErrc::TlsProtocolError);
                            return false;
                        }
                        else if (ret == 0)
                        {
                            continue;
                        }
 
                        lastError = make_error_code (Errc::TemporaryError);
                        if (handshake () == 0)
                        {
                            return true;
                        }
 
                        continue;
                    }
 
                    return false;
                }
 
                if (handshake () == 0)
                {
                    return true;
                }
            }
 
            return false;
        }
 
        bool encrypted () const noexcept
        {
            return _ssl != nullptr && SSL_is_init_finished (_ssl.get ());
        }
 
        int shutdown () noexcept
        {
            if (!_ssl)
            {
                return 0;
            }
 
            if ((SSL_get_shutdown (_ssl.get ()) & SSL_SENT_SHUTDOWN) == 0)
            {
                int result = SSL_shutdown (_ssl.get ());
                if (result < 0)
                {
                    return handleTlsError (result);
                }
            }
 
            if (_socket.type () == SOCK_DGRAM)
            {
                if ((SSL_get_shutdown (_ssl.get ()) & SSL_RECEIVED_SHUTDOWN) == 0)
                {
                    int result = SSL_shutdown (_ssl.get ());
                    if (result < 0)
                    {
                        handleTlsError (result);
                        if (lastError != Errc::ConnectionClosed && lastError != TlsErrc::TlsCloseNotifyAlert)
                        {
                            return -1;
                        }
                    }
                }
            }
 
            _ssl.reset ();
            return 0;
        }
 
        bool waitShutdown () noexcept
        {
            return waitShutdown (TimePoint::max ());
        }
 
        bool waitShutdown (std::chrono::nanoseconds timeout) noexcept
        {
            return waitShutdown (std::chrono::steady_clock::now () + timeout);
        }
 
        bool waitShutdown (TimePoint deadline) noexcept
        {
            if (JOIN_UNLIKELY ((deadline != TimePoint::max ()) && (_socket.mode () == Mode::Blocking)))
            {
                lastError = make_error_code (Errc::OperationFailed);
                return false;
            }
 
            if (!_ssl)
            {
                return true;
            }
 
            if (shutdown () == 0)
            {
                return true;
            }
 
            while (lastError == make_error_code (Errc::TemporaryError))
            {
                bool wantRead = SSL_want_read (_ssl.get ());
                bool wantWrite = SSL_want_write (_ssl.get ());
 
                if (!wantRead && !wantWrite)
                {
                    break;  // LCOV_EXCL_LINE
                }
 
                if (_socket.waitUntil (wantRead, wantWrite, deadline) == -1)
                {
                    return false;
                }
 
                if (shutdown () == 0)
                {
                    return true;
                }
            }
 
            return false;
        }
 
        int disconnect () noexcept
        {
            return _socket.disconnect ();
        }
 
        void close () noexcept
        {
            _ssl.reset ();
            _socket.close ();
        }
 
        bool waitReadyRead () const noexcept
        {
            return waitReadyRead (TimePoint::max ());
        }
 
        bool waitReadyRead (std::chrono::nanoseconds timeout) const noexcept
        {
            return waitReadyRead (std::chrono::steady_clock::now () + timeout);
        }
 
        bool waitReadyRead (TimePoint deadline) const noexcept
        {
            bool wantRead = true;
            bool wantWrite = false;
 
            if (_ssl && (SSL_want_read (_ssl.get ()) || SSL_want_write (_ssl.get ())))
            {
                wantRead = SSL_want_read (_ssl.get ());
                wantWrite = SSL_want_write (_ssl.get ());
            }
 
            return (_socket.waitUntil (wantRead, wantWrite, deadline) == 0);
        }
 
        ssize_t read (char* buf, size_t len) noexcept
        {
            if (_ssl)
            {
                int nread = SSL_read (_ssl.get (), buf, static_cast<int> (len));
                if (nread < 1)
                {
                    return handleTlsError (nread);
                }
 
                return nread;
            }
 
            return _socket.read (buf, len);
        }
 
        int readExactly (char* data, size_t size)
        {
            return readExactly (data, size, TimePoint::max ());
        }
 
        int readExactly (char* data, size_t size, std::chrono::nanoseconds timeout)
        {
            return readExactly (data, size, std::chrono::steady_clock::now () + timeout);
        }
 
        int readExactly (char* data, size_t size, TimePoint deadline)
        {
            if (JOIN_UNLIKELY ((deadline != TimePoint::max ()) && (_socket.mode () == Mode::Blocking)))
            {
                lastError = make_error_code (Errc::OperationFailed);
                return -1;
            }
 
            size_t numRead = 0;
 
            while (numRead < size)
            {
                ssize_t result = read (data + numRead, size - numRead);
                if (result == -1)
                {
                    if (lastError == Errc::TemporaryError)
                    {
                        if (waitReadyRead (deadline))
                        {
                            continue;
                        }
                    }
 
                    return -1;
                }
 
                numRead += result;
            }
 
            return 0;
        }
 
        bool waitReadyWrite () const noexcept
        {
            return waitReadyWrite (TimePoint::max ());
        }
 
        bool waitReadyWrite (std::chrono::nanoseconds timeout) const noexcept
        {
            return waitReadyWrite (std::chrono::steady_clock::now () + timeout);
        }
 
        bool waitReadyWrite (TimePoint deadline) const noexcept
        {
            bool wantRead = false;
            bool wantWrite = true;
 
            if (_ssl && (SSL_want_read (_ssl.get ()) || SSL_want_write (_ssl.get ())))
            {
                wantRead = SSL_want_read (_ssl.get ());
                wantWrite = SSL_want_write (_ssl.get ());
            }
 
            return (_socket.waitUntil (wantRead, wantWrite, deadline) == 0);
        }
 
        ssize_t write (const char* buf, size_t len) noexcept
        {
            if (_ssl)
            {
                int nwritten = SSL_write (_ssl.get (), buf, static_cast<int> (len));
                if (nwritten < 1)
                {
                    return handleTlsError (nwritten);
                }
 
                return nwritten;
            }
 
            return _socket.write (buf, len);
        }
 
        int writeExactly (const char* data, size_t size)
        {
            return writeExactly (data, size, TimePoint::max ());
        }
 
        int writeExactly (const char* data, size_t size, std::chrono::nanoseconds timeout)
        {
            return writeExactly (data, size, std::chrono::steady_clock::now () + timeout);
        }
 
        int writeExactly (const char* data, size_t size, TimePoint deadline)
        {
            if (JOIN_UNLIKELY ((deadline != TimePoint::max ()) && (_socket.mode () == Mode::Blocking)))
            {
                lastError = make_error_code (Errc::OperationFailed);
                return -1;
            }
 
            size_t numWrite = 0;
 
            while (numWrite < size)
            {
                ssize_t result = write (data + numWrite, size - numWrite);
                if (result == -1)
                {
                    if (lastError == Errc::TemporaryError)
                    {
                        if (waitReadyWrite (deadline))
                        {
                            continue;
                        }
                    }
 
                    return -1;
                }
 
                numWrite += result;
            }
 
            return 0;
        }
 
        void setMode (Mode mode) noexcept
        {
            _socket.setMode (mode);
        }
 
        int setOption (Option opt, int val) noexcept
        {
            return _socket.setOption (opt, val);
        }
 
        int handle () const noexcept
        {
            return _socket.handle ();
        }
 
        int family () const noexcept
        {
            return _socket.family ();
        }
 
        int type () const noexcept
        {
            return _socket.type ();
        }
 
        int protocol () const noexcept
        {
            return _socket.protocol ();
        }
 
        int mtu () const noexcept
        {
            return _socket.mtu ();
        }
 
        Endpoint localEndpoint () const noexcept
        {
            return _socket.localEndpoint ();
        }
 
        Endpoint remoteEndpoint () const
        {
            return _socket.remoteEndpoint ();
        }
 
    protected:
        int handleTlsError (int result) noexcept
        {
            switch (SSL_get_error (_ssl.get (), result))
            {
                case SSL_ERROR_WANT_READ:
                case SSL_ERROR_WANT_WRITE:
                case SSL_ERROR_WANT_X509_LOOKUP:
                    // want read, want write or want lookup.
                    lastError = make_error_code (Errc::TemporaryError);
                    break;
 
                case SSL_ERROR_ZERO_RETURN:
                    // a close notify alert was received.
                    // we have to answer by sending a close notify alert too.
                    lastError = make_error_code (TlsErrc::TlsCloseNotifyAlert);
                    break;
 
                case SSL_ERROR_SYSCALL:
                    // an error occurred at the socket level.
                    if (errno == 0 || errno == ECONNRESET || errno == EPIPE)
                    {
                        lastError = make_error_code (Errc::ConnectionClosed);
                    }
                    else
                    {
                        lastError = std::error_code (errno, std::generic_category ());
                    }
                    break;
 
                default:
                    // SSL protocol error.
#ifdef DEBUG
                    std::cout << ERR_reason_error_string (ERR_get_error ()) << std::endl;
#endif
                    lastError = make_error_code (TlsErrc::TlsProtocolError);
                    break;
            }
 
            return -1;
        }
 
        static void infoWrapper (const SSL* ssl, int where, int ret) noexcept
        {
            assert (ssl);
            static_cast<BasicTls<Protocol>*> (SSL_get_app_data (ssl))->infoCallback (where, ret);
        }
 
        void infoCallback (int where, int ret) const noexcept
        {
            if (where & SSL_CB_ALERT)
            {
                std::cout << "SSL/TLS Alert ";
                (where & SSL_CB_READ) ? std::cout << "[read] " : std::cout << "[write] ";
                std::cout << SSL_alert_type_string_long (ret) << ":";
                std::cout << SSL_alert_desc_string_long (ret);
                std::cout << std::endl;
            }
            else if (where & SSL_CB_LOOP)
            {
                std::cout << "SSL/TLS State ";
                (SSL_in_connect_init (_ssl.get ()))  ? std::cout << "[connect] "
                : (SSL_in_accept_init (_ssl.get ())) ? std::cout << "[accept] "
                                                     : std::cout << "[undefined] ";
                std::cout << SSL_state_string_long (_ssl.get ());
                std::cout << std::endl;
            }
            else if (where & SSL_CB_HANDSHAKE_START)
            {
                std::cout << "SSL/TLS Handshake [Start] " << SSL_state_string_long (_ssl.get ()) << std::endl;
            }
            else if (where & SSL_CB_HANDSHAKE_DONE)
            {
                std::cout << "SSL/TLS Handshake [Done] " << SSL_state_string_long (_ssl.get ()) << std::endl;
                std::cout << SSL_CTX_sess_number (_ctx.handle ()) << " items in the session cache" << std::endl;
                std::cout << SSL_CTX_sess_connect (_ctx.handle ()) << " client connects" << std::endl;
                std::cout << SSL_CTX_sess_connect_good (_ctx.handle ()) << " client connects that finished"
                          << std::endl;
                std::cout << SSL_CTX_sess_connect_renegotiate (_ctx.handle ()) << " client renegotiations requested"
                          << std::endl;
                std::cout << SSL_CTX_sess_accept (_ctx.handle ()) << " server connects" << std::endl;
                std::cout << SSL_CTX_sess_accept_good (_ctx.handle ()) << " server connects that finished" << std::endl;
                std::cout << SSL_CTX_sess_accept_renegotiate (_ctx.handle ()) << " server renegotiations requested"
                          << std::endl;
                std::cout << SSL_CTX_sess_hits (_ctx.handle ()) << " session cache hits" << std::endl;
                std::cout << SSL_CTX_sess_cb_hits (_ctx.handle ()) << " external session cache hits" << std::endl;
                std::cout << SSL_CTX_sess_misses (_ctx.handle ()) << " session cache misses" << std::endl;
                std::cout << SSL_CTX_sess_timeouts (_ctx.handle ()) << " session cache timeouts" << std::endl;
                std::cout << "negotiated " << SSL_get_cipher (_ssl.get ()) << " cipher suite" << std::endl;
            }
        }
 
        static int verifyWrapper (int preverified, X509_STORE_CTX* x509Ctx) noexcept
        {
            SSL* ssl = static_cast<SSL*> (X509_STORE_CTX_get_ex_data (x509Ctx, SSL_get_ex_data_X509_STORE_CTX_idx ()));
            assert (ssl);
            return static_cast<BasicTls<Protocol>*> (SSL_get_app_data (ssl))->verifyCallback (preverified, x509Ctx);
        }
 
        int verifyCallback (int preverified, X509_STORE_CTX* context) noexcept
        {
            int maxDepth = SSL_get_verify_depth (_ssl.get ());
            int dpth = X509_STORE_CTX_get_error_depth (context);
 
#ifdef DEBUG
            std::cout << "verification started at depth=" << dpth << std::endl;
#endif
 
            // catch a too long certificate chain.
            if ((maxDepth >= 0) && (dpth > maxDepth))
            {
                preverified = 0;
                X509_STORE_CTX_set_error (context, X509_V_ERR_CERT_CHAIN_TOO_LONG);
            }
 
            if (!preverified)
            {
#ifdef DEBUG
                std::cout << "verification failed at depth=" << dpth << " - "
                          << X509_verify_cert_error_string (X509_STORE_CTX_get_error (context)) << std::endl;
#endif
                return 0;
            }
 
            // check the certificate host name.
            if (!verifyCert (context))
            {
#ifdef DEBUG
                std::cout << "rejected by CERT at depth=" << dpth << std::endl;
#endif
                return 0;
            }
 
            // check the revocation list.
            /*if (!verifyCrl (context))
            {
            #ifdef DEBUG
                std::cout << "rejected by CRL at depth=" << dpth << std::endl;
            #endif
                return 0;
            }*/
 
            // check ocsp.
            /*if (!verifyOcsp (context))
            {
            #ifdef DEBUG
                std::cout << "rejected by OCSP at depth=" << dpth << std::endl;
            #endif
                return 0;
            }*/
 
#ifdef DEBUG
            std::cout << "certificate accepted at depth=" << dpth << std::endl;
#endif
 
            return 1;
        }
 
        int verifyCert (X509_STORE_CTX* context) const
        {
            int depth = X509_STORE_CTX_get_error_depth (context);
            X509* cert = X509_STORE_CTX_get_current_cert (context);
 
            char buf[256];
            X509_NAME_oneline (X509_get_subject_name (cert), buf, sizeof (buf));
#ifdef DEBUG
            std::cout << "subject=" << buf << std::endl;
#endif
 
            // check the certificate host name
            if (depth == 0)
            {
                // confirm a match between the hostname and the hostnames listed in the certificate.
                if (!checkHostname (cert))
                {
#ifdef DEBUG
                    std::cout << "no match for hostname in the certificate" << std::endl;
#endif
                    return 0;
                }
            }
 
            return 1;
        }
 
        bool checkHostname (X509* certificate) const noexcept
        {
            bool match = false;
 
            // get remote hostname name.
            std::string serverName (_socket.remoteEndpoint ().hostname ());
 
            // strip off trailing dots.
            if (!serverName.empty () && serverName.back () == '.')
            {
                serverName.pop_back ();
            }
 
            // get alternative names.
            join::StackOfGeneralNamePtr altnames (reinterpret_cast<STACK_OF (GENERAL_NAME)*> (
                X509_get_ext_d2i (certificate, NID_subject_alt_name, 0, 0)));
            if (altnames)
            {
                for (int i = 0; (i < sk_GENERAL_NAME_num (altnames.get ())) && !match; ++i)
                {
                    // get a handle to alternative name.
                    GENERAL_NAME* current_name = sk_GENERAL_NAME_value (altnames.get (), i);
 
                    if (current_name->type == GEN_DNS)
                    {
                        // get data and length.
                        const char* host = reinterpret_cast<const char*> (ASN1_STRING_get0_data (current_name->d.ia5));
                        size_t len = size_t (ASN1_STRING_length (current_name->d.ia5));
                        std::string pattern (host, host + len);
 
                        // strip off trailing dots.
                        if (!pattern.empty () && pattern.back () == '.')
                        {
                            pattern.pop_back ();
                        }
 
                        // compare to pattern.
                        if (fnmatch (pattern.c_str (), serverName.c_str (), 0) == 0)
                        {
                            // an alternative name matched the server hostname.
                            match = true;
                        }
                    }
                }
            }
 
            return match;
        }
 
        /*int verifyCrl ([[maybe_unused]]X509_STORE_CTX *context) const
        {
            return 1;
        }*/
 
        /*int verifyOcsp ([[maybe_unused]]X509_STORE_CTX *context) const
        {
            return 1;
        }*/
 
        UnderlyingSocket _socket;
 
        TlsContext _ctx;
 
        SslPtr _ssl;
    };
 
    template <class Protocol>
    inline bool operator< (const BasicTls<Protocol>& a, const BasicTls<Protocol>& b) noexcept
    {
        return a.handle () < b.handle ();
    }
}
 
#endif