11#include <botan/tls_extensions_13.h>
13#include <botan/tls_callbacks.h>
14#include <botan/tls_exceptn.h>
15#include <botan/tls_policy.h>
16#include <botan/internal/scoped_cleanup.h>
17#include <botan/internal/stl_util.h>
18#include <botan/internal/tls_messages_internal.h>
19#include <botan/internal/tls_reader.h>
21#include <unordered_set>
33void check_ecdh_uncompressed_format(
Group_Params group, std::span<const uint8_t> bytes) {
34 const auto hybrid_ecc = group.pqc_hybrid_ecc();
40 if(bytes.empty() || bytes[0] != 0x04) {
41 throw TLS_Exception(Alert::IllegalParameter,
"TLS 1.3 ECDH key share must use uncompressed point format");
49void check_ffdhe_padding(
Group_Params group, std::span<const uint8_t> bytes) {
50 const size_t p_bytes = [&]() ->
size_t {
51 switch(group.code()) {
67 if(p_bytes > 0 && bytes.size() != p_bytes) {
68 throw TLS_Exception(Alert::IllegalParameter,
"TLS 1.3 FFDHE key share must be padded to the size of p");
72class Key_Share_Entry {
74 explicit Key_Share_Entry(TLS_Data_Reader& reader) {
76 m_group =
static_cast<Named_Group>(reader.get_uint16_t());
78 m_key_exchange = reader.get_range<uint8_t>(2, 1, 65535);
83 explicit Key_Share_Entry(
const TLS::Group_Params group) : m_group(group) {}
85 Key_Share_Entry(
const TLS::Group_Params group, Callbacks& cb, RandomNumberGenerator& rng) :
86 m_group(group), m_private_key(cb.tls_kem_generate_key(group, rng)) {
88 throw TLS_Exception(Alert::InternalError,
"Application did not provide a suitable ephemeral key pair");
91 m_key_exchange = m_private_key->raw_public_key_bits();
94 bool empty()
const {
return (m_group == Group_Params::NONE) && m_key_exchange.empty(); }
96 std::vector<uint8_t> serialize()
const {
97 std::vector<uint8_t> result;
98 result.reserve(m_key_exchange.size() + 4);
100 const uint16_t named_curve_id = m_group.wire_code();
111 const Policy& policy,
113 RandomNumberGenerator& rng) {
114 check_ecdh_uncompressed_format(m_group, client_share.m_key_exchange);
115 check_ffdhe_padding(m_group, client_share.m_key_exchange);
116 auto [encapsulated_shared_key, shared_key] =
118 m_key_exchange = std::move(encapsulated_shared_key);
119 return std::move(shared_key);
129 const Policy& policy,
131 RandomNumberGenerator& rng) {
132 const auto scope = scoped_cleanup([&] { m_private_key.reset(); });
135 check_ecdh_uncompressed_format(m_group, received.m_key_exchange);
136 check_ffdhe_padding(m_group, received.m_key_exchange);
137 return cb.tls_kem_decapsulate(m_group, *m_private_key, received.m_key_exchange, rng, policy);
142 std::vector<uint8_t> m_key_exchange;
143 std::unique_ptr<Private_Key> m_private_key;
146class Key_Share_ClientHello;
148class Key_Share_ServerHello {
150 Key_Share_ServerHello(TLS_Data_Reader& reader, uint16_t ) : m_server_share(reader) {}
153 const Key_Share_ClientHello& client_keyshare,
154 const Policy& policy,
156 RandomNumberGenerator& rng);
158 ~Key_Share_ServerHello() =
default;
160 Key_Share_ServerHello(
const Key_Share_ServerHello&) =
delete;
161 Key_Share_ServerHello& operator=(
const Key_Share_ServerHello&) =
delete;
163 Key_Share_ServerHello(Key_Share_ServerHello&&) =
default;
164 Key_Share_ServerHello& operator=(Key_Share_ServerHello&&) =
default;
166 std::vector<uint8_t> serialize()
const {
return m_server_share.serialize(); }
168 bool empty()
const {
return m_server_share.empty(); }
170 Key_Share_Entry& get_singleton_entry() {
return m_server_share; }
172 const Key_Share_Entry& get_singleton_entry()
const {
return m_server_share; }
174 std::vector<Named_Group> offered_groups()
const {
return {selected_group()}; }
176 Named_Group selected_group()
const {
return m_server_share.group(); }
180 return std::exchange(m_shared_secret, {});
184 Key_Share_Entry m_server_share;
188class Key_Share_ClientHello {
190 Key_Share_ClientHello(TLS_Data_Reader& reader, uint16_t ) {
196 const auto client_key_share_length = reader.get_uint16_t();
197 if(reader.remaining_bytes() != client_key_share_length) {
198 throw TLS_Exception(Alert::DecodeError,
"Inconsistent length in client KeyShare extension");
201 std::unordered_set<uint16_t> seen_groups;
202 while(reader.has_remaining()) {
206 if(reader.remaining_bytes() < 4) {
207 throw TLS_Exception(Alert::DecodeError,
"Not enough data to read another KeyShareEntry");
210 Key_Share_Entry new_entry(reader);
217 if(!seen_groups.insert(new_entry.group().wire_code()).second) {
218 throw TLS_Exception(Alert::IllegalParameter,
"Received multiple key share entries for the same group");
221 m_client_shares.emplace_back(std::move(new_entry));
225 Key_Share_ClientHello(
const Policy& policy, Callbacks& cb, RandomNumberGenerator& rng) {
226 const auto supported = policy.key_exchange_groups();
227 const auto offers = policy.key_exchange_groups_to_offer();
240 for(
const auto group : supported) {
241 if(std::find(offers.begin(), offers.end(), group) == offers.end() ||
245 m_client_shares.emplace_back(group, cb, rng);
249 ~Key_Share_ClientHello() =
default;
251 Key_Share_ClientHello(
const Key_Share_ClientHello&) =
delete;
252 Key_Share_ClientHello& operator=(
const Key_Share_ClientHello&) =
delete;
254 Key_Share_ClientHello(Key_Share_ClientHello&&) =
default;
255 Key_Share_ClientHello& operator=(Key_Share_ClientHello&&) =
default;
257 void retry_offer(
const TLS::Group_Params to_offer, Callbacks& cb, RandomNumberGenerator& rng) {
261 if(std::find_if(m_client_shares.cbegin(), m_client_shares.cend(), [&](
const auto& kse) {
262 return kse.group() == to_offer;
263 }) != m_client_shares.cend()) {
264 throw TLS_Exception(Alert::IllegalParameter,
"group was already offered");
267 m_client_shares.clear();
268 m_client_shares.emplace_back(to_offer, cb, rng);
271 std::vector<Named_Group> offered_groups()
const {
272 std::vector<Named_Group> offered_groups;
273 offered_groups.reserve(m_client_shares.size());
274 for(
const auto& share : m_client_shares) {
275 offered_groups.push_back(share.group());
277 return offered_groups;
280 Named_Group selected_group()
const {
throw Invalid_Argument(
"Client Hello Key Share does not select a group"); }
282 std::vector<uint8_t> serialize()
const {
283 std::vector<uint8_t> shares;
284 for(
const auto& share : m_client_shares) {
285 const auto serialized_share = share.serialize();
286 shares.insert(shares.end(), serialized_share.cbegin(), serialized_share.cend());
289 std::vector<uint8_t> result;
303 const Policy& policy,
305 RandomNumberGenerator& rng)
const {
306 auto& server_selected = server_share.get_singleton_entry();
309 const auto match = std::find_if(m_client_shares.begin(), m_client_shares.end(), [&](
const auto& offered) {
310 return offered.group() == server_selected.group();
318 return server_selected.encapsulate(*match, policy, cb, rng);
322 const Policy& policy,
324 RandomNumberGenerator& rng) {
325 const auto& server_selected = server_share.get_singleton_entry();
328 const auto match = std::find_if(m_client_shares.begin(), m_client_shares.end(), [&](
const auto& offered) {
329 return offered.group() == server_selected.group();
336 if(match == m_client_shares.end()) {
337 throw TLS_Exception(Alert::IllegalParameter,
"Server selected a key exchange group we didn't offer.");
340 return match->decapsulate(server_selected, policy, cb, rng);
344 std::vector<Key_Share_Entry> m_client_shares;
347Key_Share_ServerHello::Key_Share_ServerHello(
Named_Group group,
348 const Key_Share_ClientHello& client_keyshare,
351 RandomNumberGenerator& rng) :
352 m_server_share(group) {
353 m_shared_secret = client_keyshare.encapsulate(*
this, policy, cb, rng);
356class Key_Share_HelloRetryRequest {
358 Key_Share_HelloRetryRequest(TLS_Data_Reader& reader, uint16_t extension_size) {
359 constexpr auto sizeof_uint16_t =
sizeof(uint16_t);
361 if(extension_size != sizeof_uint16_t) {
362 throw Decoding_Error(
"Size of KeyShare extension in HelloRetryRequest must be " +
363 std::to_string(sizeof_uint16_t) +
" bytes");
366 m_selected_group =
static_cast<Named_Group>(reader.get_uint16_t());
369 explicit Key_Share_HelloRetryRequest(Named_Group selected_group) : m_selected_group(selected_group) {}
371 ~Key_Share_HelloRetryRequest() =
default;
373 Key_Share_HelloRetryRequest(
const Key_Share_HelloRetryRequest&) =
delete;
374 Key_Share_HelloRetryRequest& operator=(
const Key_Share_HelloRetryRequest&) =
delete;
376 Key_Share_HelloRetryRequest(Key_Share_HelloRetryRequest&&) =
default;
377 Key_Share_HelloRetryRequest& operator=(Key_Share_HelloRetryRequest&&) =
default;
379 std::vector<uint8_t> serialize()
const {
380 auto code = m_selected_group.wire_code();
381 return {get_byte<0>(code), get_byte<1>(code)};
384 Named_Group selected_group()
const {
return m_selected_group; }
386 std::vector<Named_Group> offered_groups()
const {
387 throw Invalid_Argument(
"Hello Retry Request never offers any key exchange groups");
390 bool empty()
const {
return m_selected_group == Group_Params::NONE; }
398class Key_Share::Key_Share_Impl {
400 using Key_Share_Type = std::variant<Key_Share_ClientHello, Key_Share_ServerHello, Key_Share_HelloRetryRequest>;
402 explicit Key_Share_Impl(Key_Share_Type ks) : key_share(std::move(ks)) {}
404 Key_Share_Type key_share;
409 m_impl = std::make_unique<Key_Share_Impl>(Key_Share_ClientHello(reader, extension_size));
412 m_impl = std::make_unique<Key_Share_Impl>(Key_Share_HelloRetryRequest(reader, extension_size));
415 m_impl = std::make_unique<Key_Share_Impl>(Key_Share_ServerHello(reader, extension_size));
417 throw Invalid_Argument(std::string(
"cannot create a Key_Share extension for message of type: ") +
424 m_impl(std::make_unique<Key_Share_Impl>(Key_Share_ClientHello(policy, cb, rng))) {}
428 m_impl(std::make_unique<Key_Share_Impl>(Key_Share_HelloRetryRequest(
selected_group))) {}
436 m_impl(std::make_unique<Key_Share_Impl>(Key_Share_ServerHello(
437 selected_group, std::get<Key_Share_ClientHello>(client_keyshare.m_impl->key_share), policy, cb, rng))) {}
442 return std::visit([](
const auto& key_share) {
return key_share.serialize(); }, m_impl->key_share);
446 return std::visit([](
const auto& key_share) {
return key_share.empty(); }, m_impl->key_share);
461 return std::visit(
overloaded{[&](Key_Share_ClientHello& ch,
const Key_Share_ServerHello& sh) {
462 return ch.decapsulate(sh, policy, cb, rng);
466 "can only decapsulate in ClientHello Key_Share with a ServerHello Key_Share");
469 server_keyshare.m_impl->key_share);
473 return std::visit([](
const auto& keyshare) {
return keyshare.offered_groups(); }, m_impl->key_share);
477 return std::visit([](
const auto& keyshare) {
return keyshare.selected_group(); }, m_impl->key_share);
482 overloaded{[](Key_Share_ServerHello& server_keyshare) {
return server_keyshare.take_shared_secret(); },
484 throw Invalid_Argument(
"Only the key share in Server Hello contains a shared secret");
490 const std::vector<Named_Group>& supported_groups,
493 std::visit(
overloaded{[&](Key_Share_ClientHello& ch,
const Key_Share_HelloRetryRequest& hrr) {
494 const auto selected = hrr.selected_group();
500 throw TLS_Exception(Alert::IllegalParameter,
"group was not advertised as supported");
503 return ch.retry_offer(selected, cb, rng);
505 [](
const auto&,
const auto&) {
506 throw Invalid_Argument(
"can only retry with HelloRetryRequest on a ClientHello Key_Share");
509 retry_request_keyshare.m_impl->key_share);
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_STATE_CHECK(expr)
static std::pair< std::vector< uint8_t >, secure_vector< uint8_t > > destructure(KEM_Encapsulation &&kem)
constexpr bool is_ecdh_named_curve() const
Named_Group selected_group() const
std::vector< Named_Group > offered_groups() const
Key_Share(TLS_Data_Reader &reader, uint16_t extension_size, Handshake_Type message_type)
secure_vector< uint8_t > decapsulate(const Key_Share &server_keyshare, const Policy &policy, Callbacks &cb, RandomNumberGenerator &rng)
void retry_offer(const Key_Share &retry_request_keyshare, const std::vector< Named_Group > &supported_groups, Callbacks &cb, RandomNumberGenerator &rng)
static std::unique_ptr< Key_Share > create_as_encapsulation(Group_Params selected_group, const Key_Share &client_keyshare, const Policy &policy, Callbacks &cb, RandomNumberGenerator &rng)
std::vector< uint8_t > serialize(Connection_Side whoami) const override
bool empty() const override
secure_vector< uint8_t > take_shared_secret()
const char * handshake_type_to_string(Handshake_Type type)
bool group_usable_in_version(Group_Params group, Protocol_Version version)
void append_tls_length_value(std::vector< uint8_t, Alloc > &buf, const T *vals, size_t vals_size, size_t tag_size)
constexpr uint8_t get_byte(T input)
bool value_exists(const std::vector< T > &vec, const V &val)
std::vector< T, secure_allocator< T > > secure_vector