socket.h

Go to the documentation of this file.

 
#include <filesystem>
#include <openssl/ssl.h>
#include "../socket.h"
 
#ifndef QB_IO_TCP_SSL_SOCKET_H_
#define QB_IO_TCP_SSL_SOCKET_H_
 
namespace qb::io::ssl {

struct Certificate {
    std::string subject; 
    std::string issuer;  
    int64_t     version; 
    std::string serial_number; 
    int64_t     not_before;    
    int64_t     not_after;     
    std::string signature_algorithm; 
    std::vector<std::string> subject_alternative_names; 
};

Certificate get_certificate(SSL *ssl);

SSL_CTX *create_client_context(const SSL_METHOD *method);

SSL_CTX *create_server_context(const SSL_METHOD *method, std::filesystem::path cert_path,
                               std::filesystem::path key_path);

bool load_ca_certificates(SSL_CTX *ctx, const std::string &ca_file_path);

bool load_ca_directory(SSL_CTX *ctx, const std::string &ca_dir_path);

bool set_cipher_list(SSL_CTX *ctx, const std::string &ciphers);

bool set_ciphersuites_tls13(SSL_CTX *ctx, const std::string &ciphersuites);

bool set_tls_protocol_versions(SSL_CTX *ctx, int min_version, int max_version);

bool configure_mtls_server_context(SSL_CTX *ctx, const std::string &client_ca_file_path, int verification_mode = SSL_VERIFY_PEER);

bool configure_client_certificate(SSL_CTX *ctx, const std::string &client_cert_path, const std::string &client_key_path);

bool set_alpn_protos_client(SSL_CTX *ctx, const std::vector<std::string>& protocols);

bool set_alpn_selection_callback_server(SSL_CTX *ctx, SSL_CTX_alpn_select_cb_func callback, void *arg);

bool enable_server_session_caching(SSL_CTX *ctx, long cache_size);

bool disable_client_session_cache(SSL_CTX *ctx);

bool set_custom_verify_callback(SSL_CTX *ctx, int (*callback)(int, X509_STORE_CTX *), int verification_mode);

bool set_ocsp_stapling_client_callback(SSL_CTX *ctx, int (*callback)(SSL *s, void *arg), void *arg);

bool set_ocsp_stapling_responder_server(SSL_CTX *ctx, int (*callback)(SSL *s, void *arg), void *arg);

bool set_sni_hostname_selection_callback_server(SSL_CTX *ctx, int (*callback)(SSL *s, int *al, void *arg), void *arg);

bool set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func callback);

bool configure_dh_parameters_server(SSL_CTX* ctx, const std::string& dh_param_file_path);

bool configure_ecdh_curves_server(SSL_CTX* ctx, const std::string& curve_names_list);

struct Session {
    SSL_SESSION *_session_handle = nullptr;
    // Add any other metadata if needed, e.g., creation time, peer identifier

    [[nodiscard]] bool is_valid() const { return _session_handle != nullptr; }
};

void free_session(Session& session);

bool enable_post_handshake_auth_server(SSL_CTX* ctx);
 
} // namespace qb::io::ssl
namespace qb::io::tcp::ssl {
 
// class listener;

class QB_API socket : public tcp::socket {
    std::unique_ptr<SSL, void (*)(SSL *)> _ssl_handle; 
    bool _connected; 

    int handCheck() noexcept;

    int connect_in(int af, std::string const &host, uint16_t port) noexcept;

    int n_connect_in(int af, std::string const &host, uint16_t port) noexcept;
 
public:
    constexpr static bool is_secure() noexcept { return true; }
    ~socket() noexcept;

    socket() noexcept;

    socket(SSL *ssl_ptr, tcp::socket &sock) noexcept;

    socket(socket const &rhs) = delete;

    socket(socket &&rhs) = default;

    socket &operator=(socket &&rhs) = default;

    void init(SSL *handle = nullptr) noexcept;

    int connect(endpoint const &ep, std::string const &hostname = "") noexcept;

    int connect(uri const &u) noexcept;

    int connect_v4(std::string const &host, uint16_t port) noexcept;

    int connect_v6(std::string const &host, uint16_t port) noexcept;

    int connect_un(std::string const &path) noexcept;

    int n_connect(qb::io::endpoint const &ep, std::string const &hostname = "") noexcept;

    int connected() noexcept;

    int n_connect(uri const &u) noexcept;

    int n_connect_v4(std::string const &host, uint16_t port) noexcept;

    int n_connect_v6(std::string const &host, uint16_t port) noexcept;

    int n_connect_un(std::string const &path) noexcept;

    int disconnect() noexcept;

    int read(void *data, std::size_t size) noexcept;

    int write(const void *data, std::size_t size) noexcept;

    [[nodiscard]] SSL *ssl_handle() const noexcept;

    qb::io::ssl::Certificate get_peer_certificate_details() const noexcept;

    std::string get_negotiated_cipher_suite() const noexcept;

    std::string get_negotiated_tls_version() const noexcept;

    std::string get_alpn_selected_protocol() const noexcept;
    
    std::string get_last_ssl_error_string() const noexcept;

    bool disable_session_resumption() noexcept;

    bool request_ocsp_stapling(bool enable = true) noexcept;

    std::vector<qb::io::ssl::Certificate> get_peer_certificate_chain() const noexcept;

    qb::io::ssl::Session get_session() const noexcept;

    bool set_session(qb::io::ssl::Session& session) noexcept;

    bool request_client_post_handshake_auth() noexcept;

    bool set_sni_hostname(const std::string& hostname) noexcept;

    bool set_alpn_protocols(const std::vector<std::string>& protocols) noexcept;

    bool set_verify_callback(int (*callback)(int, X509_STORE_CTX *), int verification_mode) noexcept;

    bool set_verify_depth(int depth) noexcept;
 
    inline int do_handshake() noexcept {
        return handCheck();
    }
 
private:
    //    friend class ssl::listener; // If listener needs to call private methods for accept
};
 
} // namespace qb::io::tcp::ssl
 
#endif // QB_IO_TCP_SSL_SOCKET_H_