tls_info.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_TLS_INFO_HEADER
#define LIBFILEZILLA_TLS_INFO_HEADER
 
#include "time.hpp"
 
namespace fz {
class logger_interface;
 
class x509_certificate final
{
public:
    class subject_name final
    {
    public:
        std::string name;
        bool is_dns{};
    };
 
    x509_certificate() = default;
    ~x509_certificate() noexcept = default;
    x509_certificate(x509_certificate const&) = default;
    x509_certificate(x509_certificate&&) noexcept = default;
    x509_certificate& operator=(x509_certificate const&) = default;
    x509_certificate& operator=(x509_certificate&&) noexcept = default;
 
    x509_certificate(
        std::vector<uint8_t> const& rawData,
        fz::datetime const& activation_time, fz::datetime const& expiration_time,
        std::string const& serial,
        std::string const& pkalgoname, unsigned int bits,
        std::string const& signalgoname,
        std::string const& fingerprint_sha256,
        std::string const& fingerprint_sha1,
        std::string const& issuer,
        std::string const& subject,
        std::vector<subject_name> const& alt_subject_names,
        bool const self_signed);
 
    x509_certificate(
        std::vector<uint8_t> && rawdata,
        fz::datetime const& activation_time, fz::datetime const& expiration_time,
        std::string const& serial,
        std::string const& pkalgoname, unsigned int bits,
        std::string const& signalgoname,
        std::string const& fingerprint_sha256,
        std::string const& fingerprint_sha1,
        std::string const& issuer,
        std::string const& subject,
        std::vector<subject_name> && alt_subject_names,
        bool const self_Signed);
 
 
    std::vector<uint8_t> get_raw_data() const { return raw_cert_; }
 
    fz::datetime const& get_activation_time() const { return activation_time_; }
    fz::datetime const& get_expiration_time() const { return expiration_time_; }
 
    std::string const& get_serial() const { return serial_; }
 
    std::string const& get_pubkey_algorithm() const { return pkalgoname_; }
 
    unsigned int get_pubkey_bits() const { return pkalgobits_; }
 
    std::string const& get_signature_algorithm() const { return signalgoname_; }
 
    std::string const& get_fingerprint_sha256() const { return fingerprint_sha256_; }
 
    std::string const& get_fingerprint_sha1() const { return fingerprint_sha1_; }
 
    std::string const& get_subject() const { return subject_; }
 
    std::string const& get_issuer() const { return issuer_; }
 
    std::vector<subject_name> const& get_alt_subject_names() const { return alt_subject_names_; }
 
    explicit operator bool() const { return !raw_cert_.empty(); }
 
    bool self_signed() const { return self_signed_; }
 
private:
    fz::datetime activation_time_;
    fz::datetime expiration_time_;
 
    std::vector<uint8_t> raw_cert_;
 
    std::string serial_;
    std::string pkalgoname_;
    unsigned int pkalgobits_{};
 
    std::string signalgoname_;
 
    std::string fingerprint_sha256_;
    std::string fingerprint_sha1_;
 
    std::string issuer_;
    std::string subject_;
 
    std::vector<subject_name> alt_subject_names_;
 
    bool self_signed_{};
};
 
std::vector<x509_certificate> FZ_PUBLIC_SYMBOL load_certificates_file(native_string const& certsfile, bool pem, bool sort, logger_interface * logger = nullptr);
std::vector<x509_certificate> FZ_PUBLIC_SYMBOL load_certificates(std::string_view const& certdata, bool pem, bool sort, logger_interface * logger = nullptr);
 
native_string FZ_PUBLIC_SYMBOL check_certificate_status(std::string_view const& key, std::string_view const& certs, native_string const& password, bool pem = true);
 
class tls_session_info final
{
public:
    tls_session_info() = default;
    ~tls_session_info() = default;
    tls_session_info(tls_session_info const&) = default;
    tls_session_info(tls_session_info&&) noexcept = default;
    tls_session_info& operator=(tls_session_info const&) = default;
    tls_session_info& operator=(tls_session_info&&) noexcept = default;
 
    tls_session_info(std::string const& host, unsigned int port,
        std::string const& protocol,
        std::string const& key_exchange,
        std::string const& session_cipher,
        std::string const& session_mac,
        int algorithm_warnings,
        std::vector<x509_certificate>&& peer_certificates,
        std::vector<x509_certificate>&& system_trust_chain,
        bool hostname_mismatch);
 
    std::string const& get_host() const { return host_; }
 
    unsigned int get_port() const { return port_; }
 
    std::string const& get_session_cipher() const { return session_cipher_; }
 
    std::string const& get_session_mac() const { return session_mac_; }
 
    std::vector<fz::x509_certificate> const& get_certificates() const { return system_trust_chain_.empty() ? peer_certificates_ : system_trust_chain_; }
 
    std::vector<fz::x509_certificate> const& get_peer_certificates() const { return peer_certificates_; }
 
    std::string const& get_protocol() const { return protocol_; }
 
    std::string const& get_key_exchange() const { return key_exchange_; }
 
    enum algorithm_warnings_t
    {
        tlsver = 1,
        cipher = 2,
        mac = 4,
        kex = 8
    };
 
    int get_algorithm_warnings() const { return algorithm_warnings_; }
 
    bool system_trust() const { return !system_trust_chain_.empty(); }
 
    bool mismatched_hostname() const { return hostname_mismatch_; }
 
private:
    std::string host_;
    unsigned int port_{};
 
    std::string protocol_;
    std::string key_exchange_;
    std::string session_cipher_;
    std::string session_mac_;
    int algorithm_warnings_{};
 
    std::vector<x509_certificate> peer_certificates_;
    std::vector<x509_certificate> system_trust_chain_;
 
    bool hostname_mismatch_{};
};
}
 
#endif