tls_layer.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_TLS_LAYER_HEADER
#define LIBFILEZILLA_TLS_LAYER_HEADER
 
#include "socket.hpp"
 
namespace fz {
class logger_interface;
class tls_system_trust_store;
class tls_session_info;
 
class tls_layer;
class tls_layer_impl;
 
struct certificate_verification_event_type;
 
typedef simple_event<certificate_verification_event_type, tls_layer*, tls_session_info> certificate_verification_event;
 
enum class tls_ver
{
    v1_0,
    v1_1,
    v1_2,
    v1_3
};
 
enum class tls_server_flags : unsigned int
{
    none = 0,
 
    no_auto_ticket = 0x1
};
 
inline bool operator&(tls_server_flags lhs, tls_server_flags rhs) {
    return (static_cast<std::underlying_type_t<tls_server_flags>>(lhs) & static_cast<std::underlying_type_t<tls_server_flags>>(rhs)) != 0;
}
inline tls_server_flags operator|(tls_server_flags lhs, tls_server_flags rhs) {
    return static_cast<tls_server_flags>(static_cast<std::underlying_type_t<tls_server_flags>>(lhs) | static_cast<std::underlying_type_t<tls_server_flags>>(rhs));
}
 
 
class FZ_PUBLIC_SYMBOL tls_layer final : protected event_handler, public socket_layer
{
public:
    tls_layer(event_loop& event_loop, event_handler* evt_handler, socket_interface& layer, tls_system_trust_store * system_trust_store, logger_interface& logger);
    virtual ~tls_layer();
 
    bool client_handshake(std::vector<uint8_t> const& required_certificate, std::vector<uint8_t> const& session_to_resume = std::vector<uint8_t>(), native_string const& session_hostname = native_string());
 
    bool client_handshake(event_handler *const verification_handler, std::vector<uint8_t> const& session_to_resume = std::vector<uint8_t>(), native_string const& session_hostname = native_string());
 
    bool server_handshake(std::vector<uint8_t> const& session_to_resume = {}, std::string_view const& preamble = {}, tls_server_flags flags = {});
 
    std::vector<uint8_t> get_session_parameters() const;
 
    std::vector<uint8_t> get_raw_certificate() const;
 
    void set_verification_result(bool trusted);
 
    std::string get_protocol() const;
 
    std::string get_key_exchange() const;
    std::string get_cipher() const;
    std::string get_mac() const;
    int get_algorithm_warnings() const;
 
    bool resumed_session() const;
 
    static std::string list_tls_ciphers(std::string const& priority);
 
    bool set_certificate_file(native_string const& keyfile, native_string const& certsfile, native_string const& password, bool pem = true);
 
    bool set_certificate(std::string_view const& key, std::string_view const& certs, native_string const& password, bool pem = true);
 
    static std::string get_gnutls_version();
 
    static std::pair<std::string, std::string> generate_selfsigned_certificate(native_string const& password, std::string const& distinguished_name, std::vector<std::string> const& hostnames);
    static std::pair<std::string, std::string> generate_csr(native_string const& password, std::string const& distinguished_name, std::vector<std::string> const& hostnames, bool csr_as_pem = true);
 
    bool set_alpn(std::string_view const& alpn);
    bool set_alpn(std::vector<std::string> const& alpns, bool server_priority = false);
 
    void set_min_tls_ver(tls_ver ver);
 
    void set_max_tls_ver(tls_ver ver);
 
    std::string get_alpn() const;
 
    native_string get_hostname() const;
 
    bool is_server() const;
 
    int new_session_ticket();
 
    void set_unexpected_eof_cb(std::function<bool()> const& cb);
    void set_unexpected_eof_cb(std::function<bool()> && cb);
 
    virtual socket_state get_state() const override;
 
    virtual int connect(native_string const& host, unsigned int port, address_type family = address_type::unknown) override;
 
    virtual int read(void *buffer, unsigned int size, int& error) override;
    virtual int write(void const* buffer, unsigned int size, int& error) override;
 
    virtual int shutdown() override;
 
    virtual int shutdown_read() override;
 
    virtual void set_event_handler(event_handler* pEvtHandler, fz::socket_event_flag retrigger_block = socket_event_flag{}) override;
 
private:
    virtual void FZ_PRIVATE_SYMBOL operator()(event_base const& ev) override;
 
    friend class tls_layer_impl;
    std::unique_ptr<tls_layer_impl> impl_;
};
}
 
#endif