session_ticket_store.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "transport_params.h"
 
#include <chrono>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace kcenon::network::protocols::quic
{
 
struct session_ticket_info
{
    std::vector<uint8_t> ticket_data;
 
    std::chrono::system_clock::time_point expiry;
 
    std::string server_name;
 
    unsigned short port{0};
 
    transport_parameters saved_params;
 
    uint32_t max_early_data_size{0};
 
    uint32_t ticket_age_add{0};
 
    std::chrono::system_clock::time_point received_time;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool;
 
    [[nodiscard]] auto get_obfuscated_age() const noexcept -> uint32_t;
};
 
class session_ticket_store
{
public:
    session_ticket_store() = default;
 
    ~session_ticket_store() = default;
 
    // Non-copyable, non-movable (contains mutex)
    session_ticket_store(const session_ticket_store&) = delete;
    session_ticket_store& operator=(const session_ticket_store&) = delete;
    session_ticket_store(session_ticket_store&&) = delete;
    session_ticket_store& operator=(session_ticket_store&&) = delete;
 
    auto store(const std::string& server,
               unsigned short port,
               const session_ticket_info& ticket) -> void;
 
    [[nodiscard]] auto retrieve(const std::string& server,
                                 unsigned short port) const
        -> std::optional<session_ticket_info>;
 
    auto remove(const std::string& server, unsigned short port) -> bool;
 
    auto cleanup_expired() -> size_t;
 
    auto clear() -> void;
 
    [[nodiscard]] auto size() const -> size_t;
 
    [[nodiscard]] auto has_ticket(const std::string& server,
                                   unsigned short port) const -> bool;
 
private:
    [[nodiscard]] static auto make_key(const std::string& server,
                                        unsigned short port) -> std::string;
 
    mutable std::mutex mutex_;
 
    std::unordered_map<std::string, session_ticket_info> tickets_;
};
 
class replay_filter
{
public:
    struct config
    {
        std::chrono::seconds window_size{10};
 
        size_t max_entries{100000};
    };
 
    replay_filter();
 
    explicit replay_filter(const config& cfg);
 
    [[nodiscard]] auto check_and_record(
        std::span<const uint8_t> nonce,
        std::chrono::system_clock::time_point timestamp
            = std::chrono::system_clock::now()) -> bool;
 
    auto cleanup(std::chrono::system_clock::time_point now
                     = std::chrono::system_clock::now()) -> size_t;
 
    auto clear() -> void;
 
    [[nodiscard]] auto size() const -> size_t;
 
private:
    struct nonce_entry
    {
        std::vector<uint8_t> nonce;
        std::chrono::system_clock::time_point timestamp;
    };
 
    config config_;
    mutable std::mutex mutex_;
    std::vector<nonce_entry> entries_;
};
 
} // namespace kcenon::network::protocols::quic