Botan 3.14.1
Crypto and TLS for C&
Botan::TLS::TLS_Handshake_Layer Class Referencefinal

#include <tls_handshake_layer_13.h>

Inheritance diagram for Botan::TLS::TLS_Handshake_Layer:
Botan::TLS::Handshake_Layer

Public Member Functions

void copy_data (const Policy &policy, const Handshake_Record &data_from_peer) override
bool has_pending_data () const override
std::optional< Handshake_Message_13 > next_message (const Policy &policy, Transcript_Hash_State &transcript_hash) override
std::optional< Post_Handshake_Message_13 > next_post_handshake_message (const Policy &policy) override
void set_selected_certificate_type (Certificate_Type cert_type)
 TLS_Handshake_Layer (Connection_Side whoami)

Static Public Member Functions

static HandshakeProtocolHeader prepare_header (Handshake_Type type, size_t payload_length)
static SerializedHandshakeMessage serialize (const Handshake_Message &message)
static void update_transcript_for_psk_binder_calc (const Client_Hello_13 &message, Transcript_Hash_State &transcript_hash)

Protected Types

enum class  Handshake_Phase : bool { Handshake , PostHandshake }

Protected Member Functions

Certificate_Type certificate_type () const
virtual Handshake_Message_13 parse_handshake_message (Handshake_Type type, std::span< const uint8_t > msg, const Policy &policy) const
Post_Handshake_Message_13 parse_post_handshake_message (Handshake_Type type, std::span< const uint8_t > msg) const
Connection_Side peer () const

Static Protected Member Functions

static Handshake_Type read_handshake_message_type (uint8_t value, Handshake_Phase phase)

Detailed Description

Definition at line 141 of file tls_handshake_layer_13.h.

Member Enumeration Documentation

◆ Handshake_Phase

enum class Botan::TLS::Handshake_Layer::Handshake_Phase : bool
strongprotectedinherited
Enumerator
Handshake 
PostHandshake 

Definition at line 122 of file tls_handshake_layer_13.h.

122: bool { Handshake, PostHandshake };

Constructor & Destructor Documentation

◆ TLS_Handshake_Layer()

Botan::TLS::TLS_Handshake_Layer::TLS_Handshake_Layer ( Connection_Side whoami)
inlineexplicit

Definition at line 143 of file tls_handshake_layer_13.h.

143: Handshake_Layer(whoami) {}
Handshake_Layer(Connection_Side whoami)

References Botan::TLS::Handshake_Layer::Handshake_Layer().

Member Function Documentation

◆ certificate_type()

Certificate_Type Botan::TLS::Handshake_Layer::certificate_type ( ) const
inlineprotectedinherited

Definition at line 128 of file tls_handshake_layer_13.h.

128{ return m_certificate_type; }

Referenced by parse_handshake_message().

◆ copy_data()

void Botan::TLS::TLS_Handshake_Layer::copy_data ( const Policy & policy,
const Handshake_Record & data_from_peer )
overridevirtual

Reads data that was received in handshake records and stores it internally for further processing during the invocation of next_message().

Parameters
policyThe TLS policy
data_from_peerThe data to be parsed; typically the payload of one handshake record

Implements Botan::TLS::Handshake_Layer.

Definition at line 137 of file tls_handshake_layer_13.cpp.

137 {
138 BOTAN_UNUSED(policy);
139
140 // Compact consumed data before appending new data
141 BOTAN_ASSERT_NOMSG(m_read_offset <= m_read_buffer.size());
142 if(m_read_offset > 0) {
143 m_read_buffer.erase(m_read_buffer.begin(), m_read_buffer.begin() + m_read_offset);
144 m_read_offset = 0;
145 }
146
147 m_read_buffer.insert(m_read_buffer.end(), data_from_peer.payload.begin(), data_from_peer.payload.end());
148}
#define BOTAN_UNUSED
Definition assert.h:151
#define BOTAN_ASSERT_NOMSG(expr)
Definition assert.h:82

References BOTAN_ASSERT_NOMSG, BOTAN_UNUSED, and Botan::TLS::Record_Content::payload.

◆ has_pending_data()

bool Botan::TLS::TLS_Handshake_Layer::has_pending_data ( ) const
inlineoverridevirtual

Check if the Handshake_Layer has stored a partial message in its internal buffer. This can happen if a handshake message spans multiple records.

Implements Botan::TLS::Handshake_Layer.

Definition at line 150 of file tls_handshake_layer_13.h.

150{ return m_read_offset < m_read_buffer.size(); }

◆ next_message()

std::optional< Handshake_Message_13 > Botan::TLS::TLS_Handshake_Layer::next_message ( const Policy & policy,
Transcript_Hash_State & transcript_hash )
overridevirtual

Parses one handshake message off the internal buffer that is being filled using copy_data.

Parameters
policythe TLS policy
transcript_hashthe transcript hash state to be updated
Returns
the parsed handshake message, or nullopt if more data is needed to complete the message

Implements Botan::TLS::Handshake_Layer.

Definition at line 197 of file tls_handshake_layer_13.cpp.

198 {
199 if(auto msg = next_incoming_message(policy, Handshake_Phase::Handshake)) {
200 auto parsed = parse_handshake_message(msg->type, msg->message, policy);
201 transcript_hash.update(msg->header, msg->message);
202 return parsed;
203 } else {
204 return std::nullopt;
205 }
206}
virtual Handshake_Message_13 parse_handshake_message(Handshake_Type type, std::span< const uint8_t > msg, const Policy &policy) const

References Botan::TLS::Handshake_Layer::Handshake, Botan::TLS::Handshake_Layer::parse_handshake_message(), and Botan::TLS::Transcript_Hash_State::update().

◆ next_post_handshake_message()

std::optional< Post_Handshake_Message_13 > Botan::TLS::TLS_Handshake_Layer::next_post_handshake_message ( const Policy & policy)
overridevirtual

Parses one post-handshake message off the internal buffer that is being filled using copy_data.

Parameters
policythe TLS policy
Returns
the parsed post-handshake message, or nullopt if more data is needed to complete the message

Implements Botan::TLS::Handshake_Layer.

Definition at line 208 of file tls_handshake_layer_13.cpp.

208 {
209 if(auto msg = next_incoming_message(policy, Handshake_Phase::PostHandshake)) {
210 return parse_post_handshake_message(msg->type, msg->message);
211 } else {
212 return std::nullopt;
213 }
214}
Post_Handshake_Message_13 parse_post_handshake_message(Handshake_Type type, std::span< const uint8_t > msg) const

References Botan::TLS::Handshake_Layer::parse_post_handshake_message(), and Botan::TLS::Handshake_Layer::PostHandshake.

◆ parse_handshake_message()

Handshake_Message_13 Botan::TLS::Handshake_Layer::parse_handshake_message ( Handshake_Type type,
std::span< const uint8_t > msg,
const Policy & policy ) const
protectedvirtualinherited

Definition at line 30 of file tls_handshake_layer_13.cpp.

32 {
33 switch(type) {
34 // Client Hello and Server Hello messages are ambiguous. Both may come
35 // from non-TLS 1.3 peers. Hence, their parsing is somewhat different.
37 // ... might be TLS 1.2 Client Hello or TLS 1.3 Client Hello
40 // ... might be TLS 1.2 Server Hello or TLS 1.3 Server Hello or
41 // a TLS 1.3 Hello Retry Request disguising as a Server Hello
43 // case Handshake_Type::EndOfEarlyData:
44 // return End_Of_Early_Data(msg);
46 return Encrypted_Extensions(msg);
48 return Certificate_13(msg, policy, peer(), certificate_type());
50 return Certificate_Request_13(msg, peer());
52 return Certificate_Verify_13(msg, peer());
54 return Finished_13({msg.begin(), msg.end()});
55 default:
56 throw TLS_Exception(AlertType::UnexpectedMessage, "Unexpected handshake message received");
57 }
58}
static std::variant< Client_Hello_13, Client_Hello_12_Shim > parse(std::span< const uint8_t > buf)
Certificate_Type certificate_type() const
static std::variant< Hello_Retry_Request, Server_Hello_13, Server_Hello_12_Shim > parse(std::span< const uint8_t > buf)
constexpr GeneralVariantT generalize_to(SpecialT &&specific)
Converts a given variant into another variant-ish whose type states are a super set of the given vari...
Definition stl_util.h:88

References Botan::TLS::Certificate, certificate_type(), Botan::TLS::CertificateRequest, Botan::TLS::CertificateVerify, Botan::TLS::ClientHello, Botan::TLS::EncryptedExtensions, Botan::TLS::Finished, Botan::generalize_to(), Botan::TLS::Client_Hello_13::parse(), Botan::TLS::Server_Hello_13::parse(), peer(), Botan::TLS::ServerHello, and Botan::TLS::UnexpectedMessage.

Referenced by Botan::TLS::TLS_Handshake_Layer::next_message().

◆ parse_post_handshake_message()

Post_Handshake_Message_13 Botan::TLS::Handshake_Layer::parse_post_handshake_message ( Handshake_Type type,
std::span< const uint8_t > msg ) const
protectedinherited

Definition at line 60 of file tls_handshake_layer_13.cpp.

61 {
62 switch(type) {
64 return New_Session_Ticket_13(msg, peer());
66 return Key_Update(msg);
67 default:
68 throw TLS_Exception(AlertType::UnexpectedMessage, "Unexpected post-handshake message received");
69 }
70}

References Botan::TLS::KeyUpdate, Botan::TLS::NewSessionTicket, peer(), and Botan::TLS::UnexpectedMessage.

Referenced by Botan::TLS::TLS_Handshake_Layer::next_post_handshake_message().

◆ peer()

Connection_Side Botan::TLS::Handshake_Layer::peer ( ) const
inlineprotectedinherited

Definition at line 126 of file tls_handshake_layer_13.h.

126{ return m_peer; }

Referenced by parse_handshake_message(), and parse_post_handshake_message().

◆ prepare_header()

HandshakeProtocolHeader Botan::TLS::TLS_Handshake_Layer::prepare_header ( Handshake_Type type,
size_t payload_length )
static

Prepare the TLS message header according to RFC9846 Section 4

Definition at line 130 of file tls_handshake_layer_13.cpp.

130 {
131 BOTAN_ASSERT_NOMSG(payload_length <= 0xFFFFFF);
132 auto header = HandshakeProtocolHeader(store_be(static_cast<uint32_t>(payload_length)));
133 header[0] = static_cast<uint8_t>(type);
134 return header;
135}
Strong< std::array< uint8_t, 4 >, struct HandshakeProtocolHeader_ > HandshakeProtocolHeader
Holds the serialization of a TLS 1.3 handshake protocol header.
constexpr auto store_be(ParamTs &&... params)
Definition loadstor.h:745

References BOTAN_ASSERT_NOMSG, and Botan::store_be().

Referenced by Botan::TLS::Handshake_Layer::update_transcript_for_psk_binder_calc().

◆ read_handshake_message_type()

Handshake_Type Botan::TLS::Handshake_Layer::read_handshake_message_type ( uint8_t value,
Handshake_Phase phase )
staticprotectedinherited

Definition at line 78 of file tls_handshake_layer_13.cpp.

78 {
79 const auto type = static_cast<Handshake_Type>(value);
80
81 switch(type) {
82 // Handshake message types
90 if(phase == Handshake_Phase::Handshake) {
91 return type;
92 }
93 break;
94
95 // Post-handshake message types
99 return type;
100 }
101 break;
102
103 // TODO(0-RTT): implement handling for EndOfEarlyData
105
106 // TLS 1.2 specific handshake messages
114
115 // Pseudo handshake messages that aren't actually expected on the wire
120 break;
121 };
122
123 if(phase == Handshake_Phase::Handshake) {
124 throw TLS_Exception(AlertType::UnexpectedMessage, "Unknown handshake message received");
125 } else {
126 throw TLS_Exception(AlertType::UnexpectedMessage, "Unknown post-handshake message received");
127 }
128}

References Botan::TLS::Certificate, Botan::TLS::CertificateRequest, Botan::TLS::CertificateStatus, Botan::TLS::CertificateUrl, Botan::TLS::CertificateVerify, Botan::TLS::ClientHello, Botan::TLS::ClientKeyExchange, Botan::TLS::EncryptedExtensions, Botan::TLS::EndOfEarlyData, Botan::TLS::Finished, Handshake, Botan::TLS::HandshakeCCS, Botan::TLS::HelloRequest, Botan::TLS::HelloRetryRequest, Botan::TLS::HelloVerifyRequest, Botan::TLS::KeyUpdate, Botan::TLS::MessageHash, Botan::TLS::NewSessionTicket, Botan::TLS::None, PostHandshake, Botan::TLS::ServerHello, Botan::TLS::ServerHelloDone, Botan::TLS::ServerKeyExchange, and Botan::TLS::UnexpectedMessage.

◆ serialize()

SerializedHandshakeMessage Botan::TLS::Handshake_Layer::serialize ( const Handshake_Message & message)
inlinestaticinherited

Definition at line 46 of file tls_handshake_layer_13.h.

46 {
47 return SerializedHandshakeMessage(message.serialize());
48 }
Strong< std::vector< uint8_t >, struct SerializedHandshakeMessage_ > SerializedHandshakeMessage

References Botan::TLS::Handshake_Message::serialize().

Referenced by update_transcript_for_psk_binder_calc().

◆ set_selected_certificate_type()

void Botan::TLS::Handshake_Layer::set_selected_certificate_type ( Certificate_Type cert_type)
inlineinherited

Set the certificate_type used for parsing Certificate messages. This is determined via (client/server)_certificate_type extensions during the handshake.

RFC 7250 4.3 and 4.4 When the TLS server has specified RawPublicKey as the [client_certificate_type/server_certificate_type], authentication of the TLS [client/server] to the TLS [server/client] is supported only through authentication of the received client SubjectPublicKeyInfo via an out-of-band method.

If the peer sends a Certificate message containing an incompatible means of authentication, a 'decode_error' will be generated.

Definition at line 119 of file tls_handshake_layer_13.h.

119{ m_certificate_type = cert_type; }

Referenced by Botan::TLS::Channel_IO::set_selected_certificate_type().

◆ update_transcript_for_psk_binder_calc()

void Botan::TLS::Handshake_Layer::update_transcript_for_psk_binder_calc ( const Client_Hello_13 & message,
Transcript_Hash_State & transcript_hash )
staticinherited

Marshals a ClientHello prematurely for a truncated transcript hash calculation (cf. RFC 8446 Section 4.2.11.2).

Parameters
messagethe ClientHello message to be marshalled
transcript_hashthe transcript hash state to be updated

Definition at line 72 of file tls_handshake_layer_13.cpp.

73 {
74 const auto msg_bytes = serialize(message);
75 transcript_hash.update(TLS_Handshake_Layer::prepare_header(message.wire_type(), msg_bytes.size()), msg_bytes);
76}
static SerializedHandshakeMessage serialize(const Handshake_Message &message)
static HandshakeProtocolHeader prepare_header(Handshake_Type type, size_t payload_length)

References Botan::TLS::TLS_Handshake_Layer::prepare_header(), serialize(), Botan::TLS::Transcript_Hash_State::update(), and Botan::TLS::Handshake_Message::wire_type().

Referenced by next_post_handshake_message().


The documentation for this class was generated from the following files: