5230455705

Committed 10 Jun 2023 02:30PM UTC coverage: 91.715% (-0.03%) from 91.746%

Build # 5230455705

Build Type

push

github

Committed by

randombit

Commit Message

Merge GH #3584 Change clang-format AllowShortFunctionsOnASingleLine config from All to Inline

Run Details

77182 of 84154 relevant lines covered (91.72%)

11975295.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.23

/src/lib/tls/msg_session_ticket.cpp

/*
* Session Tickets
* (C) 2012 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/tls_messages.h>

#include <botan/rng.h>
#include <botan/tls_callbacks.h>
#include <botan/tls_session.h>
#include <botan/tls_session_manager.h>
#include <botan/internal/loadstor.h>
#include <botan/internal/tls_handshake_hash.h>
#include <botan/internal/tls_handshake_io.h>
#include <botan/internal/tls_reader.h>

#include <botan/tls_exceptn.h>

#include <span>

namespace Botan::TLS {

New_Session_Ticket_12::New_Session_Ticket_12(Handshake_IO& io,
                                             Handshake_Hash& hash,
                                             Session_Ticket ticket,
                                             std::chrono::seconds lifetime) :
      m_ticket_lifetime_hint(lifetime), m_ticket(std::move(ticket)) {
   hash.update(io.send(*this));
}

New_Session_Ticket_12::New_Session_Ticket_12(Handshake_IO& io, Handshake_Hash& hash) {
   hash.update(io.send(*this));
}

New_Session_Ticket_12::New_Session_Ticket_12(const std::vector<uint8_t>& buf) {
   if(buf.size() < 6) {
      throw Decoding_Error("Session ticket message too short to be valid");
   }

   TLS_Data_Reader reader("SessionTicket", buf);

   m_ticket_lifetime_hint = std::chrono::seconds(reader.get_uint32_t());
   m_ticket = Session_Ticket(reader.get_range<uint8_t>(2, 0, 65535));
   reader.assert_done();
}

namespace {

template <typename lifetime_t = uint32_t>
void store_lifetime(std::span<uint8_t> sink, std::chrono::seconds lifetime) {
   BOTAN_ARG_CHECK(lifetime.count() >= 0 && lifetime.count() <= std::numeric_limits<lifetime_t>::max(),
                   "Ticket lifetime is out of range");
   store_be(static_cast<lifetime_t>(lifetime.count()), sink.data());
}

}  // namespace

std::vector<uint8_t> New_Session_Ticket_12::serialize() const {
   std::vector<uint8_t> buf(4);
   store_be(static_cast<uint32_t>(m_ticket_lifetime_hint.count()), buf.data());
   append_tls_length_value(buf, m_ticket.get(), 2);
   return buf;
}

#if defined(BOTAN_HAS_TLS_13)

New_Session_Ticket_13::New_Session_Ticket_13(Ticket_Nonce nonce,
                                             const Session& session,
                                             const Session_Handle& handle,
                                             Callbacks& callbacks) :
      m_ticket_lifetime_hint(session.lifetime_hint()),
      m_ticket_age_add(session.session_age_add()),
      m_ticket_nonce(std::move(nonce)),
      m_handle(handle.opaque_handle()) {
   callbacks.tls_modify_extensions(m_extensions, Connection_Side::Server, type());
}

New_Session_Ticket_13::New_Session_Ticket_13(const std::vector<uint8_t>& buf, Connection_Side from) {
   TLS_Data_Reader reader("New_Session_Ticket_13", buf);

   m_ticket_lifetime_hint = std::chrono::seconds(reader.get_uint32_t());

   // RFC 8446 4.6.1
   //    Servers MUST NOT use any value [of ticket_lifetime] greater than 604800
   //    seconds (7 days).
   if(m_ticket_lifetime_hint > std::chrono::days(7)) {
      throw TLS_Exception(Alert::IllegalParameter, "Received a session ticket with lifetime longer than one week.");
   }

   m_ticket_age_add = reader.get_uint32_t();
   m_ticket_nonce = Ticket_Nonce(reader.get_tls_length_value(1));
   m_handle = Opaque_Session_Handle(reader.get_tls_length_value(2));

   m_extensions.deserialize(reader, from, type());

   // RFC 8446 4.6.1
   //    The sole extension currently defined for NewSessionTicket is
   //    "early_data", indicating that the ticket may be used to send 0-RTT
   //    data [...]. Clients MUST ignore unrecognized extensions.
   if(m_extensions.contains_implemented_extensions_other_than({Extension_Code::EarlyData})) {
      throw TLS_Exception(Alert::IllegalParameter, "NewSessionTicket message contained unexpected extension");
   }

   reader.assert_done();
}

std::optional<uint32_t> New_Session_Ticket_13::early_data_byte_limit() const {
   if(!m_extensions.has<EarlyDataIndication>()) {
      return std::nullopt;
   }

   const EarlyDataIndication* ext = m_extensions.get<EarlyDataIndication>();
   BOTAN_ASSERT_NOMSG(ext->max_early_data_size().has_value());
   return ext->max_early_data_size().value();
}

std::vector<uint8_t> New_Session_Ticket_13::serialize() const {
   std::vector<uint8_t> result(8);

   store_lifetime(std::span(result.data(), 4), m_ticket_lifetime_hint);
   store_be(m_ticket_age_add, result.data() + 4);
   append_tls_length_value(result, m_ticket_nonce.get(), 1);
   append_tls_length_value(result, m_handle.get(), 2);

   // TODO: re-evaluate this construction when reworking message marshalling
   if(m_extensions.size() == 0) {
      result.push_back(0x00);
      result.push_back(0x00);
   } else {
      result += m_extensions.serialize(Connection_Side::Server);
   }

   return result;
}

#endif

}  // namespace Botan::TLS

1	/*
2	* Session Tickets
3	* (C) 2012 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/tls_messages.h>
9
10	#include <botan/rng.h>
11	#include <botan/tls_callbacks.h>
12	#include <botan/tls_session.h>
13	#include <botan/tls_session_manager.h>
14	#include <botan/internal/loadstor.h>
15	#include <botan/internal/tls_handshake_hash.h>
16	#include <botan/internal/tls_handshake_io.h>
17	#include <botan/internal/tls_reader.h>
18
19	#include <botan/tls_exceptn.h>
20
21	#include <span>
22
23	namespace Botan::TLS {
24
25	New_Session_Ticket_12::New_Session_Ticket_12(Handshake_IO& io,	389✔
26	Handshake_Hash& hash,
27	Session_Ticket ticket,
28	std::chrono::seconds lifetime) :	389✔
29	m_ticket_lifetime_hint(lifetime), m_ticket(std::move(ticket)) {	389✔
30	hash.update(io.send(*this));	778✔
31	}	389✔
32
33	New_Session_Ticket_12::New_Session_Ticket_12(Handshake_IO& io, Handshake_Hash& hash) {	×
34	hash.update(io.send(*this));	×
35	}	×
36
37	New_Session_Ticket_12::New_Session_Ticket_12(const std::vector<uint8_t>& buf) {	601✔
38	if(buf.size() < 6) {	601✔
39	throw Decoding_Error("Session ticket message too short to be valid");	1✔
40	}
41
42	TLS_Data_Reader reader("SessionTicket", buf);	600✔
43
44	m_ticket_lifetime_hint = std::chrono::seconds(reader.get_uint32_t());	600✔
45	m_ticket = Session_Ticket(reader.get_range<uint8_t>(2, 0, 65535));	600✔
46	reader.assert_done();	599✔
47	}	601✔
48
49	namespace {
50
51	template <typename lifetime_t = uint32_t>
52	void store_lifetime(std::span<uint8_t> sink, std::chrono::seconds lifetime) {	267✔
53	BOTAN_ARG_CHECK(lifetime.count() >= 0 && lifetime.count() <= std::numeric_limits<lifetime_t>::max(),	267✔
54	"Ticket lifetime is out of range");
55	store_be(static_cast<lifetime_t>(lifetime.count()), sink.data());	267✔
56	}	267✔
57
58	} // namespace
59
60	std::vector<uint8_t> New_Session_Ticket_12::serialize() const {	389✔
61	std::vector<uint8_t> buf(4);	389✔
62	store_be(static_cast<uint32_t>(m_ticket_lifetime_hint.count()), buf.data());	389✔
63	append_tls_length_value(buf, m_ticket.get(), 2);	389✔
64	return buf;	389✔
65	}	×
66
67	#if defined(BOTAN_HAS_TLS_13)
68
69	New_Session_Ticket_13::New_Session_Ticket_13(Ticket_Nonce nonce,	266✔
70	const Session& session,
71	const Session_Handle& handle,
72	Callbacks& callbacks) :	266✔
73	m_ticket_lifetime_hint(session.lifetime_hint()),	266✔
74	m_ticket_age_add(session.session_age_add()),	266✔
75	m_ticket_nonce(std::move(nonce)),	266✔
76	m_handle(handle.opaque_handle()) {	266✔
77	callbacks.tls_modify_extensions(m_extensions, Connection_Side::Server, type());	266✔
78	}	266✔
79
80	New_Session_Ticket_13::New_Session_Ticket_13(const std::vector<uint8_t>& buf, Connection_Side from) {	549✔
81	TLS_Data_Reader reader("New_Session_Ticket_13", buf);	549✔
82
83	m_ticket_lifetime_hint = std::chrono::seconds(reader.get_uint32_t());	549✔
84
85	// RFC 8446 4.6.1
86	// Servers MUST NOT use any value [of ticket_lifetime] greater than 604800
87	// seconds (7 days).
88	if(m_ticket_lifetime_hint > std::chrono::days(7)) {	1,098✔
89	throw TLS_Exception(Alert::IllegalParameter, "Received a session ticket with lifetime longer than one week.");	×
90	}
91
92	m_ticket_age_add = reader.get_uint32_t();	549✔
93	m_ticket_nonce = Ticket_Nonce(reader.get_tls_length_value(1));	1,098✔
94	m_handle = Opaque_Session_Handle(reader.get_tls_length_value(2));	1,098✔
95
96	m_extensions.deserialize(reader, from, type());	549✔
97
98	// RFC 8446 4.6.1
99	// The sole extension currently defined for NewSessionTicket is
100	// "early_data", indicating that the ticket may be used to send 0-RTT
101	// data [...]. Clients MUST ignore unrecognized extensions.
102	if(m_extensions.contains_implemented_extensions_other_than({Extension_Code::EarlyData})) {	1,098✔
103	throw TLS_Exception(Alert::IllegalParameter, "NewSessionTicket message contained unexpected extension");	×
104	}
105
106	reader.assert_done();	549✔
107	}	549✔
108
109	std::optional<uint32_t> New_Session_Ticket_13::early_data_byte_limit() const {	549✔
110	if(!m_extensions.has<EarlyDataIndication>()) {	549✔
111	return std::nullopt;	548✔
112	}
113
114	const EarlyDataIndication* ext = m_extensions.get<EarlyDataIndication>();	1✔
115	BOTAN_ASSERT_NOMSG(ext->max_early_data_size().has_value());	1✔
116	return ext->max_early_data_size().value();	1✔
117	}
118
119	std::vector<uint8_t> New_Session_Ticket_13::serialize() const {	267✔
120	std::vector<uint8_t> result(8);	267✔
121
122	store_lifetime(std::span(result.data(), 4), m_ticket_lifetime_hint);	267✔
123	store_be(m_ticket_age_add, result.data() + 4);	267✔
124	append_tls_length_value(result, m_ticket_nonce.get(), 1);	267✔
125	append_tls_length_value(result, m_handle.get(), 2);	267✔
126
127	// TODO: re-evaluate this construction when reworking message marshalling
128	if(m_extensions.size() == 0) {	267✔
129	result.push_back(0x00);	265✔
130	result.push_back(0x00);	265✔
131	} else {
132	result += m_extensions.serialize(Connection_Side::Server);	4✔
133	}
134
135	return result;	267✔
136	}	×
137
138	#endif
139
140	} // namespace Botan::TLS

randombit / botan / 5230455705

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous