8#include <botan/internal/tls_handshake_io.h>
10#include <botan/assert.h>
11#include <botan/exceptn.h>
12#include <botan/tls_exceptn.h>
13#include <botan/tls_handshake_msg.h>
14#include <botan/internal/fmt.h>
15#include <botan/internal/loadstor.h>
16#include <botan/internal/tls_record.h>
17#include <botan/internal/tls_seq_numbers.h>
23constexpr size_t DTLS_HANDSHAKE_HEADER_SIZE = 12;
27constexpr size_t DEFAULT_PEER_REPLAY_BUDGET = 12;
34constexpr uint16_t MAX_PRE_COMMIT_CLIENT_HELLOS = 8;
40constexpr size_t MIN_CLIENT_HELLO_SIZE = 42;
48constexpr bool dtls_handshake_type_requires_body(
Handshake_Type type) {
52inline size_t load_be24(
const uint8_t q[3]) {
63 throw TLS_Exception(Alert::UnexpectedMessage,
"Invalid handshake message type");
69void store_be24(uint8_t out[3],
size_t val) {
71 throw Encoding_Error(
"Handshake message is too large to encode");
81 return Protocol_Version::TLS_V12;
89 m_queue.insert(m_queue.end(), record, record + record_len);
91 if(record_len != 1 || record[0] != 1) {
97 if(m_ccs_received || !m_queue.empty()) {
98 throw TLS_Exception(Alert::UnexpectedMessage,
"Unexpected ChangeCipherSpec");
101 m_ccs_received =
true;
103 throw Decoding_Error(
"Unknown message type " + std::to_string(
static_cast<size_t>(record_type)) +
104 " in handshake processing");
109 size_t max_message_size) {
112 throw TLS_Exception(Alert::UnexpectedMessage,
"Unexpected ChangeCipherSpec");
114 m_ccs_received =
false;
118 if(m_queue.size() >= 4) {
121 const size_t rec_length =
make_uint32(0, m_queue[1], m_queue[2], m_queue[3]);
128 throw TLS_Exception(Alert::UnexpectedMessage,
"Expected ChangeCipherSpec but got a handshake message");
131 verify_is_expected_wire_handshake_type(type);
133 if(max_message_size > 0 && rec_length > max_message_size) {
135 Alert::HandshakeFailure,
136 Botan::fmt(
"Handshake message is {} bytes, policy maximum is {}", rec_length, max_message_size));
139 const size_t length = 4 + rec_length;
141 if(m_queue.size() >= length) {
142 const std::vector<uint8_t> contents(m_queue.begin() + 4, m_queue.begin() + length);
144 m_queue.erase(m_queue.begin(), m_queue.begin() + length);
146 return std::make_pair(type, contents);
154 std::vector<uint8_t> send_buf(4 + msg.size());
156 const size_t buf_size = msg.size();
158 send_buf[0] =
static_cast<uint8_t
>(type);
160 store_be24(&send_buf[1], buf_size);
163 copy_mem(&send_buf[4], msg.data(), msg.size());
170 throw Invalid_State(
"Not possible to send under arbitrary epoch with stream based TLS");
174 const std::vector<uint8_t> msg_bits = msg.
serialize();
178 return std::vector<uint8_t>();
186#if defined(BOTAN_HAS_TLS_DOWNGRADE_SUPPORT)
188std::vector<uint8_t> Stream_Handshake_IO::start_with_client_hello_from_downgrade(
191 "Expected ClientHello message for TLS downgrade");
202size_t max_pending_reassembly(
size_t policy_hs_max) {
216 constexpr size_t overall_cap = 16 * 1024 * 1024;
218 if(policy_hs_max == 0 || policy_hs_max >= overall_cap / 4) {
223 return policy_hs_max * 4;
233 uint64_t initial_timeout_ms,
234 uint64_t max_timeout_ms,
235 std::optional<size_t> max_retransmissions,
236 size_t max_handshake_msg_size,
238 uint16_t initial_epoch) :
242 m_initial_timeout(initial_timeout_ms),
243 m_max_timeout(max_timeout_ms),
244 m_max_retransmissions(max_retransmissions),
245 m_initial_epoch(initial_epoch),
246 m_last_delivered_epoch(initial_epoch),
247 m_send_hs(std::move(writer)),
248 m_steady_clock_ms(std::move(steady_clock_ms)),
250 m_max_handshake_msg_size(max_handshake_msg_size),
251 m_max_pending_reassembly(max_pending_reassembly(m_max_handshake_msg_size)),
252 m_is_server(is_server) {}
255 return Protocol_Version::DTLS_V12;
258std::optional<size_t> Datagram_Handshake_IO::last_completed_flight_index()
const {
264 if(!m_flights.rbegin()->empty()) {
265 return m_flights.size() - 1;
268 if(m_flights.size() == 1) {
272 const size_t flight_idx = m_flights.size() - 2;
277 if(m_flights[flight_idx].empty()) {
284void Datagram_Handshake_IO::retransmit_last_flight() {
285 if(
const auto flight_idx = last_completed_flight_index()) {
286 retransmit_flight(*flight_idx);
287 m_last_write = m_steady_clock_ms();
307void Datagram_Handshake_IO::replay_last_flight_for_peer() {
311 const size_t bound = m_max_retransmissions.value_or(DEFAULT_PEER_REPLAY_BUDGET);
313 if(m_peer_replay_count >= bound) {
317 if(
const auto flight_idx = last_completed_flight_index()) {
318 m_peer_replay_count += 1;
319 retransmit_flight(*flight_idx);
323void Datagram_Handshake_IO::retransmit_flight(
size_t flight_idx) {
324 const auto& flight = m_flights.at(flight_idx);
325 const auto& ccs_records = m_flight_ccs.at(flight_idx);
326 const std::vector<uint8_t> ccs = {1};
328 BOTAN_ASSERT(!flight.empty(),
"Nonempty flight to retransmit");
331 for(
size_t msg_idx = 0; msg_idx != flight.size(); ++msg_idx) {
332 while(ccs_idx != ccs_records.size() && ccs_records[ccs_idx].first == msg_idx) {
337 const auto msg_seq = flight[msg_idx];
338 const auto& msg = m_flight_data.at(msg_seq);
339 send_message(msg_seq, msg.epoch, msg.msg_type, msg.msg_bits);
342 while(ccs_idx != ccs_records.size() && ccs_records[ccs_idx].first == flight.size()) {
353 const auto next = m_messages.find(m_in_message_seq);
354 return next != m_messages.end() && next->second.complete();
361 if(!m_flights.rbegin()->empty()) {
362 m_flights.emplace_back();
363 m_flight_ccs.emplace_back();
371 m_retransmit_terminal_flight = retransmit_terminal_flight;
374 discard_pending_messages();
379 if(!timeout || timeout->count() > 0) {
388 m_retransmit_count += 1;
389 if(m_max_retransmissions.has_value() && m_retransmit_count > m_max_retransmissions.value()) {
390 throw TLS_Exception(Alert::None,
"DTLS handshake timed out: maximum retransmissions exceeded");
396 retransmit_last_flight();
398 m_next_timeout = std::min(2 * m_next_timeout, m_max_timeout);
408 if(!m_last_write.has_value() || !last_completed_flight_index().has_value()) {
412 const uint64_t ms_since_write = m_steady_clock_ms() - m_last_write.value();
413 if(ms_since_write >= m_next_timeout) {
414 return std::chrono::milliseconds(0);
421 const uint64_t fudge_ms = std::min<uint64_t>(15, m_initial_timeout / 2);
422 const uint64_t remaining_ms = m_next_timeout - ms_since_write;
424 return std::chrono::milliseconds(remaining_ms <= fudge_ms ? 0 : remaining_ms);
430 uint64_t record_sequence) {
431 add_record(record, record_len, record_type, record_sequence,
false);
437 uint64_t record_sequence) {
438 add_record(record, record_len, record_type, record_sequence,
true);
441bool Datagram_Handshake_IO::reassemble_retransmitted_fragment(
const uint8_t fragment[],
442 size_t fragment_length,
443 size_t fragment_offset,
447 uint16_t message_seq) {
448 auto [i, inserted] = m_retransmitted_messages.try_emplace(msg_type, message_seq, Handshake_Reassembly{});
457 const bool superseded_by_higher_epoch =
458 i->second.second.initialized() && !i->second.second.complete() && epoch > i->second.second.epoch();
460 if(!inserted && (i->second.first != message_seq || superseded_by_higher_epoch)) {
461 release_reassembly_bytes(i->second.second);
462 i->second = std::make_pair(message_seq, Handshake_Reassembly());
465 auto& reassembly = i->second.second;
469 if(!charged_add_fragment(reassembly,
470 m_max_pending_reassembly,
480 if(!reassembly.complete()) {
484 release_reassembly_bytes(reassembly);
485 m_retransmitted_messages.erase(i);
489bool Datagram_Handshake_IO::charged_add_fragment(Handshake_Reassembly& reassembly,
491 const uint8_t fragment[],
492 size_t fragment_length,
493 size_t fragment_offset,
502 if(reassembly.superseded_by_client_hello(epoch, msg_type) &&
503 (msg_type != reassembly.msg_type() || msg_length != reassembly.msg_length())) {
504 release_reassembly_bytes(reassembly);
505 reassembly = Handshake_Reassembly();
512 if(!reassembly.initialized()) {
513 if(m_pending_reassembly_bytes + msg_length > ceiling) {
516 m_pending_reassembly_bytes += msg_length;
519 reassembly.add_fragment(fragment, fragment_length, fragment_offset, epoch, msg_type, msg_length);
523void Datagram_Handshake_IO::release_reassembly_bytes(
const Handshake_Reassembly& reassembly) {
525 m_pending_reassembly_bytes -= reassembly.msg_length();
528bool Datagram_Handshake_IO::process_previous_handshake_fragment(
const uint8_t fragment[],
529 size_t fragment_length,
530 size_t fragment_offset,
534 uint16_t message_seq,
535 bool retransmitted_flight) {
539 if(fragment_length == 0 && msg_length != 0) {
547 if(msg_length == 0 && dtls_handshake_type_requires_body(msg_type)) {
557 if(msg_length < MIN_CLIENT_HELLO_SIZE) {
561 if(!retransmitted_flight && m_awaiting_cookie_client_hello) {
562 if(!m_retransmitted_client_hello.has_value() || m_retransmitted_client_hello->first != message_seq) {
563 if(m_retransmitted_client_hello.has_value()) {
564 release_reassembly_bytes(m_retransmitted_client_hello->second);
566 m_retransmitted_client_hello = std::make_pair(message_seq, Handshake_Reassembly());
571 charged_add_fragment(m_retransmitted_client_hello->second,
572 m_max_pending_reassembly / 2,
590 return reassemble_retransmitted_fragment(
591 fragment, fragment_length, fragment_offset, epoch, msg_type, msg_length, message_seq);
606 if(!retransmitted_flight) {
615 reassemble_retransmitted_fragment(
616 fragment, fragment_length, fragment_offset, epoch, msg_type, msg_length, message_seq)) {
619 if(m_retransmitted_ccs_epoch == epoch) {
620 m_retransmitted_ccs_epoch.reset();
627 m_retransmitted_ccs_epoch.reset();
628 m_retransmitted_finished_epoch = epoch;
637 uint64_t record_sequence,
638 bool retransmitted_flight) {
639 const uint16_t epoch =
static_cast<uint16_t
>(record_sequence >> 48);
652 if(epoch > 0 && m_finished) {
653 m_peer_replay_count = 0;
657 if(record_len != 1 || record[0] != 1) {
658 throw Decoding_Error(
"Invalid ChangeCipherSpec");
662 m_ccs_epochs.insert(epoch);
663 if(retransmitted_flight) {
667 const uint16_t finished_epoch =
static_cast<uint16_t
>(epoch + 1);
668 if(m_retransmitted_finished_epoch == finished_epoch) {
669 m_retransmitted_finished_epoch.reset();
670 if(m_retransmit_terminal_flight) {
671 replay_last_flight_for_peer();
674 m_retransmitted_finished_epoch.reset();
675 m_retransmitted_ccs_epoch = finished_epoch;
681 bool retransmit_response =
false;
683 while(record_len > 0) {
684 if(record_len < DTLS_HANDSHAKE_HEADER_SIZE) {
690 verify_is_expected_wire_handshake_type(msg_type);
692 const size_t msg_len = load_be24(&record[1]);
694 if(m_max_handshake_msg_size > 0 && msg_len > m_max_handshake_msg_size) {
696 Alert::HandshakeFailure,
697 Botan::fmt(
"Handshake message is {} bytes, policy maximum is {}", msg_len, m_max_handshake_msg_size));
701 const size_t fragment_offset = load_be24(&record[6]);
702 const size_t fragment_length = load_be24(&record[9]);
704 const size_t total_size = DTLS_HANDSHAKE_HEADER_SIZE + fragment_length;
706 if(record_len < total_size) {
707 throw Decoding_Error(
"Bad lengths in DTLS header");
711 constexpr uint16_t reassembly_window = 16;
713 if(message_seq >= m_in_message_seq && (message_seq - m_in_message_seq) < reassembly_window) {
716 if(m_in_message_seq_wrapped) {
717 record += total_size;
718 record_len -= total_size;
727 if(epoch < m_last_delivered_epoch) {
728 record += total_size;
729 record_len -= total_size;
740 if(msg_len == 0 && message_seq != m_in_message_seq && dtls_handshake_type_requires_body(msg_type)) {
741 record += total_size;
742 record_len -= total_size;
760 record += total_size;
761 record_len -= total_size;
788 if(server_awaiting_first_flight() &&
789 (message_seq != m_in_message_seq || m_in_message_seq >= MAX_PRE_COMMIT_CLIENT_HELLOS)) {
790 record += total_size;
791 record_len -= total_size;
795 if(retransmitted_flight) {
796 if(fragment_length == 0) {
797 record += total_size;
798 record_len -= total_size;
802 throw TLS_Exception(Alert::UnexpectedMessage,
"Unexpected new DTLS handshake message");
807 if(fragment_length == 0 && msg_len > 0) {
808 record += total_size;
809 record_len -= total_size;
817 const size_t ceiling =
818 (message_seq == m_in_message_seq) ? m_max_pending_reassembly : m_max_pending_reassembly / 2;
820 auto [it, inserted] = m_messages.try_emplace(message_seq);
822 const bool accepted = charged_add_fragment(it->second,
824 &record[DTLS_HANDSHAKE_HEADER_SIZE],
830 if(!accepted && inserted) {
831 m_messages.erase(it);
833 }
else if(message_seq < m_in_message_seq) {
834 retransmit_response |= process_previous_handshake_fragment(&record[DTLS_HANDSHAKE_HEADER_SIZE],
841 retransmitted_flight);
847 record += total_size;
848 record_len -= total_size;
851 if(retransmit_response && (!m_finished || m_retransmit_terminal_flight)) {
852 replay_last_flight_for_peer();
856void Datagram_Handshake_IO::discard_pending_messages() {
857 for(
const auto& [seq, reassembly] : m_messages) {
858 release_reassembly_bytes(reassembly);
862 if(m_retransmitted_client_hello.has_value()) {
863 release_reassembly_bytes(m_retransmitted_client_hello->second);
864 m_retransmitted_client_hello.reset();
868void Datagram_Handshake_IO::discard_stale_epoch_messages() {
869 for(
auto i = m_messages.lower_bound(m_in_message_seq); i != m_messages.end();) {
870 if(i->second.epoch() < m_last_delivered_epoch) {
871 release_reassembly_bytes(i->second);
872 i = m_messages.erase(i);
882 if(!m_flights.rbegin()->empty()) {
883 m_flights.emplace_back();
884 m_flight_ccs.emplace_back();
890 if(m_first_delivered_epoch.has_value() && m_ccs_epochs.contains(*m_first_delivered_epoch)) {
896 auto i = m_messages.find(m_in_message_seq);
898 if(i == m_messages.end() || !i->second.complete()) {
903 if(!m_retransmitted_client_hello.has_value() || !m_retransmitted_client_hello->second.complete()) {
918 const uint16_t seq = m_retransmitted_client_hello->first;
920 for(
auto s = m_messages.begin(); s != m_messages.end();) {
921 if(s->first !=
static_cast<uint16_t
>(seq + 1)) {
922 release_reassembly_bytes(s->second);
923 s = m_messages.erase(s);
929 m_in_message_seq = seq;
930 m_recreating_hello_verify_request =
true;
931 i = m_messages.insert_or_assign(seq, std::move(m_retransmitted_client_hello->second)).first;
932 m_retransmitted_client_hello.reset();
935 m_in_message_seq += 1;
936 if(m_in_message_seq == 0) {
937 m_in_message_seq_wrapped =
true;
940 if(!m_first_delivered_epoch.has_value()) {
941 m_first_delivered_epoch = i->second.epoch();
944 auto result = i->second.message();
947 m_awaiting_cookie_client_hello =
false;
955 if(server_awaiting_first_flight()) {
956 m_out_message_seq =
static_cast<uint16_t
>(m_in_message_seq - 1);
961 if(m_retransmitted_client_hello.has_value()) {
962 release_reassembly_bytes(m_retransmitted_client_hello->second);
963 m_retransmitted_client_hello.reset();
967 const uint16_t delivered_epoch = i->second.epoch();
969 release_reassembly_bytes(i->second);
972 if(delivered_epoch > m_last_delivered_epoch) {
973 m_last_delivered_epoch = delivered_epoch;
974 discard_stale_epoch_messages();
980void Datagram_Handshake_IO::Handshake_Reassembly::add_fragment(
const uint8_t fragment[],
981 size_t fragment_length,
982 size_t fragment_offset,
989 m_msg_type = msg_type;
990 m_msg_length = msg_length;
991 m_message.resize(msg_length);
992 m_received_mask.assign(msg_length, 0);
1001 if(msg_type != m_msg_type || msg_length != m_msg_length || epoch != m_epoch) {
1002 throw Decoding_Error(
"Inconsistent values in fragmented DTLS handshake header");
1006 if(fragment_offset > m_msg_length) {
1007 throw Decoding_Error(
"Fragment offset past end of message");
1010 if(fragment_offset + fragment_length > m_msg_length) {
1011 throw Decoding_Error(
"Fragment overlaps past end of message");
1016 for(
size_t i = 0; i != fragment_length; ++i) {
1017 const size_t off = fragment_offset + i;
1018 if(m_received_mask[off] != 0) {
1021 if(m_message[off] != fragment[i]) {
1033 if(!superseded_by_client_hello(epoch, msg_type)) {
1034 throw Decoding_Error(
"Inconsistent overlapping DTLS handshake fragment");
1036 m_bytes_received = 0;
1037 std::fill(m_received_mask.begin(), m_received_mask.end(), 0);
1038 add_fragment(fragment, fragment_length, fragment_offset, epoch, msg_type, msg_length);
1042 m_message[off] = fragment[i];
1043 m_received_mask[off] = 1;
1049bool Datagram_Handshake_IO::Handshake_Reassembly::complete()
const {
1053std::pair<Handshake_Type, std::vector<uint8_t>> Datagram_Handshake_IO::Handshake_Reassembly::message()
const {
1055 throw Internal_Error(
"Datagram_Handshake_IO - message not complete");
1058 return std::make_pair(m_msg_type, m_message);
1061std::vector<uint8_t> Datagram_Handshake_IO::format_fragment(
const uint8_t fragment[],
1063 uint32_t frag_offset,
1066 uint16_t msg_sequence)
const {
1067 std::vector<uint8_t> send_buf(12 + frag_len);
1069 send_buf[0] =
static_cast<uint8_t
>(type);
1071 store_be24(&send_buf[1], msg_len);
1073 store_be(msg_sequence, &send_buf[4]);
1075 store_be24(&send_buf[6], frag_offset);
1076 store_be24(&send_buf[9], frag_len);
1079 copy_mem(&send_buf[12], fragment, frag_len);
1085std::vector<uint8_t> Datagram_Handshake_IO::format_w_seq(
const std::vector<uint8_t>& msg,
1087 uint16_t msg_sequence)
const {
1088 return format_fragment(msg.data(), msg.size(), 0,
static_cast<uint32_t
>(msg.size()), type, msg_sequence);
1097 return format_w_seq(msg, type,
static_cast<uint16_t
>(m_in_message_seq - 1));
1105 const std::vector<uint8_t> msg_bits = msg.
serialize();
1109 m_flight_ccs.rbegin()->emplace_back(m_flights.rbegin()->size(), epoch);
1119 const uint16_t msg_seq = m_out_message_seq++;
1123 if(!m_recreating_hello_verify_request) {
1124 discard_pending_messages();
1126 m_awaiting_cookie_client_hello =
true;
1127 m_recreating_hello_verify_request =
false;
1128 send_message(msg_seq, epoch, msg_type, msg_bits);
1132 m_flights.rbegin()->push_back(m_out_message_seq);
1133 m_flight_data.insert_or_assign(m_out_message_seq, Message_Info(epoch, msg_type, msg_bits));
1135 m_out_message_seq += 1;
1136 m_last_write = m_steady_clock_ms();
1137 m_next_timeout = m_initial_timeout;
1140 m_retransmit_count = 0;
1141 m_peer_replay_count = 0;
1143 return send_message(m_out_message_seq - 1, epoch, msg_type, msg_bits);
1146#if defined(BOTAN_HAS_TLS_DOWNGRADE_SUPPORT)
1148std::vector<uint8_t> Datagram_Handshake_IO::start_with_client_hello_from_downgrade(
1151 "Expected ClientHello message for DTLS downgrade");
1154 return format_w_seq(client_hello.
serialize(), client_hello.
wire_type(), m_out_message_seq++);
1159std::vector<uint8_t> Datagram_Handshake_IO::send_message(uint16_t msg_seq,
1162 const std::vector<uint8_t>& msg_bits) {
1163 auto no_fragment = format_w_seq(msg_bits, msg_type, msg_seq);
1170 const size_t ciphersuite_overhead = (epoch > 0) ? 48 : 0;
1172 if(no_fragment.size() +
DTLS_HEADER_SIZE + ciphersuite_overhead <= m_mtu) {
1176 size_t frag_offset = 0;
1178 constexpr size_t DTLS_HANDSHAKE_OVERHEAD =
DTLS_HEADER_SIZE + DTLS_HANDSHAKE_HEADER_SIZE;
1180 if(m_mtu <= (DTLS_HANDSHAKE_OVERHEAD + ciphersuite_overhead)) {
1181 throw Invalid_Argument(
"DTLS MTU is too small to send headers");
1184 const size_t max_rec_size = m_mtu - (DTLS_HANDSHAKE_OVERHEAD + ciphersuite_overhead);
1186 while(frag_offset != msg_bits.size()) {
1187 const size_t frag_len = std::min<size_t>(msg_bits.size() - frag_offset, max_rec_size);
1189 const std::vector<uint8_t> frag = format_fragment(&msg_bits[frag_offset],
1191 static_cast<uint32_t
>(frag_offset),
1192 static_cast<uint32_t
>(msg_bits.size()),
1198 frag_offset += frag_len;
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_DEBUG_ASSERT(expr)
#define BOTAN_STATE_CHECK(expr)
#define BOTAN_ARG_CHECK(expr, msg)
#define BOTAN_ASSERT(expr, assertion_made)
virtual uint16_t current_write_epoch() const =0
std::function< uint64_t()> steady_clock_fn
std::function< void(uint16_t, Record_Type, const std::vector< uint8_t > &)> writer_fn
std::vector< uint8_t > send_under_epoch(const Handshake_Message &msg, uint16_t epoch) override
std::optional< std::chrono::milliseconds > next_retransmission_timeout() const override
std::pair< Handshake_Type, std::vector< uint8_t > > get_next_record(bool expecting_ccs, size_t max_message_size) override
bool timeout_check() override
void add_record(const uint8_t record[], size_t record_len, Record_Type type, uint64_t sequence_number) override
std::vector< uint8_t > format(const std::vector< uint8_t > &handshake_msg, Handshake_Type handshake_type) const override
Protocol_Version initial_record_version() const override
void finalize_handshake(bool retransmit_terminal_flight)
void add_retransmitted_record(const uint8_t record[], size_t record_len, Record_Type type, uint64_t sequence_number)
std::vector< uint8_t > send(const Handshake_Message &msg) override
Datagram_Handshake_IO(writer_fn writer, steady_clock_fn clock_ms, class Connection_Sequence_Numbers &seq, uint16_t mtu, uint64_t initial_timeout_ms, uint64_t max_timeout_ms, std::optional< size_t > max_retransmissions, size_t max_handshake_msg_size, bool is_server, uint16_t initial_epoch=0)
bool have_more_data() const override
virtual Handshake_Type type() const =0
virtual std::vector< uint8_t > serialize() const =0
virtual Handshake_Type wire_type() const
std::vector< uint8_t > send_under_epoch(const Handshake_Message &msg, uint16_t epoch) override
std::vector< uint8_t > format(const std::vector< uint8_t > &handshake_msg, Handshake_Type handshake_type) const override
Protocol_Version initial_record_version() const override
std::vector< uint8_t > send(const Handshake_Message &msg) override
std::pair< Handshake_Type, std::vector< uint8_t > > get_next_record(bool expecting_ccs, size_t max_message_size) override
void add_record(const uint8_t record[], size_t record_len, Record_Type type, uint64_t sequence_number) override
constexpr uint8_t get_byte(T input)
std::string fmt(std::string_view format, const T &... args)
constexpr void copy_mem(T *out, const T *in, size_t n)
constexpr uint32_t make_uint32(uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3)
constexpr auto store_be(ParamTs &&... params)
constexpr auto load_be(ParamTs &&... params)