ssl.cppm

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
module;
 
// =============================================================================
// Global Module Fragment - Standard Library Headers
// =============================================================================
#include <atomic>
#include <chrono>
#include <filesystem>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
// Third-party headers
#include <asio.hpp>
#include <asio/ssl.hpp>
 
export module kcenon.network:ssl;
 
import :core;
 
// =============================================================================
// SSL Configuration Types
// =============================================================================
 
export namespace kcenon::network::core {
 
enum class ssl_protocol {
    tls_1_2,    
    tls_1_3,    
    dtls_1_2,   
    dtls_1_3    
};
 
enum class ssl_verify_mode {
    none,               
    peer,               
    fail_if_no_peer_cert, 
    client_once         
};
 
struct ssl_config {
    std::filesystem::path certificate_path;
 
    std::filesystem::path private_key_path;
 
    std::filesystem::path ca_certificate_path;
 
    std::string private_key_password;
 
    ssl_protocol protocol = ssl_protocol::tls_1_3;
 
    ssl_verify_mode verify_mode = ssl_verify_mode::peer;
 
    std::string server_name;
 
    std::string cipher_list;
 
    bool enable_session_resumption = true;
 
    bool enable_ocsp_stapling = false;
};
 
// =============================================================================
// Secure TCP Client
// =============================================================================
 
class secure_messaging_client {
public:
    explicit secure_messaging_client(std::string_view client_id, const ssl_config& config = {});
 
    virtual ~secure_messaging_client() noexcept;
 
    // Non-copyable, movable
    secure_messaging_client(const secure_messaging_client&) = delete;
    secure_messaging_client& operator=(const secure_messaging_client&) = delete;
    secure_messaging_client(secure_messaging_client&&) noexcept;
    secure_messaging_client& operator=(secure_messaging_client&&) noexcept;
 
    bool start_client(std::string_view host, uint16_t port);
 
    void stop_client();
 
    bool wait_for_stop(std::chrono::milliseconds timeout = std::chrono::milliseconds(5000));
 
    bool send_packet(std::span<const uint8_t> data);
 
    bool send_packet(std::string_view data);
 
    bool is_connected() const noexcept;
 
    bool is_running() const noexcept;
 
    connection_state get_state() const noexcept;
 
    std::string_view client_id() const noexcept;
 
    void set_connection_callback(connection_callback callback);
 
    void set_disconnection_callback(disconnection_callback callback);
 
    void set_error_callback(error_callback callback);
 
    void set_data_callback(data_callback callback);
 
    std::optional<std::string> get_peer_certificate_subject() const;
 
    std::string get_protocol_version() const;
 
    std::string get_cipher_suite() const;
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Secure TCP Server
// =============================================================================
 
class secure_messaging_server {
public:
    using client_connected_callback = std::function<void(const std::string& session_id)>;
 
    using client_disconnected_callback = std::function<void(const std::string& session_id)>;
 
    using client_data_callback = std::function<void(
        const std::string& session_id,
        std::span<const uint8_t> data)>;
 
    explicit secure_messaging_server(std::string_view server_id, const ssl_config& config);
 
    virtual ~secure_messaging_server() noexcept;
 
    // Non-copyable, movable
    secure_messaging_server(const secure_messaging_server&) = delete;
    secure_messaging_server& operator=(const secure_messaging_server&) = delete;
    secure_messaging_server(secure_messaging_server&&) noexcept;
    secure_messaging_server& operator=(secure_messaging_server&&) noexcept;
 
    bool start_server(uint16_t port, int backlog = 128);
 
    bool start_server(std::string_view address, uint16_t port, int backlog = 128);
 
    void stop_server();
 
    bool wait_for_stop(std::chrono::milliseconds timeout = std::chrono::milliseconds(5000));
 
    bool send_to(std::string_view session_id, std::span<const uint8_t> data);
 
    void broadcast(std::span<const uint8_t> data);
 
    void disconnect(std::string_view session_id);
 
    bool is_running() const noexcept;
 
    size_t client_count() const noexcept;
 
    std::string_view server_id() const noexcept;
 
    void set_client_connected_callback(client_connected_callback callback);
 
    void set_client_disconnected_callback(client_disconnected_callback callback);
 
    void set_client_data_callback(client_data_callback callback);
 
    void set_error_callback(error_callback callback);
 
    std::optional<std::string> get_peer_certificate_subject(std::string_view session_id) const;
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Secure UDP Client (DTLS)
// =============================================================================
 
class secure_messaging_udp_client {
public:
    explicit secure_messaging_udp_client(std::string_view client_id, const ssl_config& config = {});
 
    virtual ~secure_messaging_udp_client() noexcept;
 
    // Non-copyable, movable
    secure_messaging_udp_client(const secure_messaging_udp_client&) = delete;
    secure_messaging_udp_client& operator=(const secure_messaging_udp_client&) = delete;
    secure_messaging_udp_client(secure_messaging_udp_client&&) noexcept;
    secure_messaging_udp_client& operator=(secure_messaging_udp_client&&) noexcept;
 
    bool start_client(std::string_view remote_host, uint16_t remote_port);
 
    void stop_client();
 
    bool send_packet(std::span<const uint8_t> data);
 
    bool is_connected() const noexcept;
 
    bool is_running() const noexcept;
 
    std::string_view client_id() const noexcept;
 
    void set_connection_callback(connection_callback callback);
 
    void set_disconnection_callback(disconnection_callback callback);
 
    void set_data_callback(data_callback callback);
 
    void set_error_callback(error_callback callback);
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Secure UDP Server (DTLS)
// =============================================================================
 
class secure_messaging_udp_server {
public:
    using dtls_data_callback = std::function<void(
        const std::string& session_id,
        std::span<const uint8_t> data)>;
 
    explicit secure_messaging_udp_server(std::string_view server_id, const ssl_config& config);
 
    virtual ~secure_messaging_udp_server() noexcept;
 
    // Non-copyable, movable
    secure_messaging_udp_server(const secure_messaging_udp_server&) = delete;
    secure_messaging_udp_server& operator=(const secure_messaging_udp_server&) = delete;
    secure_messaging_udp_server(secure_messaging_udp_server&&) noexcept;
    secure_messaging_udp_server& operator=(secure_messaging_udp_server&&) noexcept;
 
    bool start_server(uint16_t port);
 
    bool start_server(std::string_view address, uint16_t port);
 
    void stop_server();
 
    bool send_to(std::string_view session_id, std::span<const uint8_t> data);
 
    bool is_running() const noexcept;
 
    size_t session_count() const noexcept;
 
    std::string_view server_id() const noexcept;
 
    void set_session_connected_callback(std::function<void(const std::string&)> callback);
 
    void set_session_disconnected_callback(std::function<void(const std::string&)> callback);
 
    void set_data_callback(dtls_data_callback callback);
 
    void set_error_callback(error_callback callback);
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
} // namespace kcenon::network::core