30496461195

Committed 29 Jul 2026 08:43PM UTC coverage: 89.519% (+0.09%) from 89.425%

Build # 30496461195

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5776 from Rohde-Schwarz/fix/tls_anvil

Coverage Stats

116233 of 129841 relevant lines covered (89.52%)

10620449.77 hits per line

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

78.38

/src/lib/tls/tls_server.cpp

/*
* TLS Server
* (C) 2004-2011,2012,2016 Jack Lloyd
*     2016 Matthias Gierlings
*     2021 Elektrobit Automotive GmbH
*     2022 René Meusel, Hannes Rantzsch - neXenio GmbH
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/tls_server.h>

#include <botan/tls_policy.h>
#include <botan/x509cert.h>
#include <botan/internal/tls_channel_impl.h>

#if defined(BOTAN_HAS_TLS_12)
   #include <botan/internal/tls_server_impl_12.h>
#endif

#if defined(BOTAN_HAS_TLS_13)
   #include <botan/internal/tls_server_impl_13.h>
#endif

namespace Botan::TLS {

/*
* TLS Server Constructor
*/
Server::Server(const std::shared_ptr<Callbacks>& callbacks,
               const std::shared_ptr<Session_Manager>& session_manager,
               const std::shared_ptr<Credentials_Manager>& creds,
               const std::shared_ptr<const Policy>& policy,
               const std::shared_ptr<RandomNumberGenerator>& rng,
               bool is_datagram,
               size_t io_buf_sz) {
   const auto max_version = policy->latest_supported_version(is_datagram);

#if defined(BOTAN_HAS_TLS_13)
   if(!max_version.is_pre_tls_13()) {
      m_impl = std::make_unique<Server_Impl_13>(callbacks, session_manager, creds, policy, rng);

      if(m_impl->expects_downgrade()) {
         m_impl->set_io_buffer_size(io_buf_sz);
      }

      return;
   }
#endif

#if defined(BOTAN_HAS_TLS_12)
   if(max_version.is_pre_tls_13()) {
      m_impl = std::make_unique<Server_Impl_12>(callbacks, session_manager, creds, policy, rng, is_datagram, io_buf_sz);
      return;
   }
#endif

   BOTAN_UNUSED(max_version, callbacks, session_manager, creds, policy, rng, is_datagram, io_buf_sz);
   throw Not_Implemented("Requested TLS server version is not available in this build");
}

Server::~Server() = default;

size_t Server::from_peer(std::span<const uint8_t> data) {
   auto read = m_impl->from_peer(data);

#if defined(BOTAN_HAS_TLS_12)
   // If TLS 1.2 is not available, we will never downgrade, the downgrade info
   // won't even be created and `is_downgrading()` would always return false.
   if(m_impl->is_downgrading()) {
      auto info = m_impl->extract_downgrade_info();
      m_impl = std::make_unique<Server_Impl_12>(*info);

      // replay peer data received so far
      read = m_impl->from_peer(info->peer_transcript);
   }
#endif

   return read;
}

bool Server::is_handshake_complete() const {
   return m_impl->is_handshake_complete();
}

bool Server::is_active() const {
   return m_impl->is_active();
}

std::optional<std::chrono::milliseconds> Server::next_retransmission_timeout() const {
   return m_impl->next_retransmission_timeout();
}

bool Server::is_closed() const {
   return m_impl->is_closed();
}

bool Server::is_closed_for_reading() const {
   return m_impl->is_closed_for_reading();
}

bool Server::is_closed_for_writing() const {
   return m_impl->is_closed_for_writing();
}

std::vector<X509_Certificate> Server::peer_cert_chain() const {
   return m_impl->peer_cert_chain();
}

std::shared_ptr<const Public_Key> Server::peer_raw_public_key() const {
   return m_impl->peer_raw_public_key();
}

std::optional<std::string> Server::external_psk_identity() const {
   return m_impl->external_psk_identity();
}

SymmetricKey Server::key_material_export(std::string_view label, std::string_view context, size_t length) const {
   return m_impl->key_material_export(label, context, length);
}

void Server::renegotiate(bool force_full_renegotiation) {
   m_impl->renegotiate(force_full_renegotiation);
}

bool Server::new_session_ticket_supported() const {
   return m_impl->new_session_ticket_supported();
}

size_t Server::send_new_session_tickets(const size_t tickets) {
   return m_impl->send_new_session_tickets(tickets);
}

void Server::update_traffic_keys(bool request_peer_update) {
   m_impl->update_traffic_keys(request_peer_update);
}

bool Server::secure_renegotiation_supported() const {
   return m_impl->secure_renegotiation_supported();
}

void Server::to_peer(std::span<const uint8_t> data) {
   m_impl->to_peer(data);
}

void Server::send_alert(const Alert& alert) {
   m_impl->send_alert(alert);
}

void Server::send_warning_alert(Alert::Type type) {
   m_impl->send_warning_alert(type);
}

void Server::send_fatal_alert(Alert::Type type) {
   m_impl->send_fatal_alert(type);
}

void Server::close() {
   m_impl->close();
}

bool Server::timeout_check() {
   return m_impl->timeout_check();
}

std::string Server::application_protocol() const {
   return m_impl->application_protocol();
}
}  // namespace Botan::TLS

1	/*
2	* TLS Server
3	* (C) 2004-2011,2012,2016 Jack Lloyd
4	* 2016 Matthias Gierlings
5	* 2021 Elektrobit Automotive GmbH
6	* 2022 René Meusel, Hannes Rantzsch - neXenio GmbH
7	*
8	* Botan is released under the Simplified BSD License (see license.txt)
9	*/
10
11	#include <botan/tls_server.h>
12
13	#include <botan/tls_policy.h>
14	#include <botan/x509cert.h>
15	#include <botan/internal/tls_channel_impl.h>
16
17	#if defined(BOTAN_HAS_TLS_12)
18	#include <botan/internal/tls_server_impl_12.h>
19	#endif
20
21	#if defined(BOTAN_HAS_TLS_13)
22	#include <botan/internal/tls_server_impl_13.h>
23	#endif
24
25	namespace Botan::TLS {
26
27	/*
28	* TLS Server Constructor
29	*/
30	Server::Server(const std::shared_ptr<Callbacks>& callbacks,	2,867✔
31	const std::shared_ptr<Session_Manager>& session_manager,
32	const std::shared_ptr<Credentials_Manager>& creds,
33	const std::shared_ptr<const Policy>& policy,
34	const std::shared_ptr<RandomNumberGenerator>& rng,
35	bool is_datagram,
36	size_t io_buf_sz) {	2,867✔
37	const auto max_version = policy->latest_supported_version(is_datagram);	2,867✔
38
39	#if defined(BOTAN_HAS_TLS_13)
40	if(!max_version.is_pre_tls_13()) {	2,867✔
41	m_impl = std::make_unique<Server_Impl_13>(callbacks, session_manager, creds, policy, rng);	2,306✔
42
43	if(m_impl->expects_downgrade()) {	2,306✔
44	m_impl->set_io_buffer_size(io_buf_sz);	2,212✔
45	}
46
47	return;	2,306✔
48	}
49	#endif
50
51	#if defined(BOTAN_HAS_TLS_12)
52	if(max_version.is_pre_tls_13()) {	561✔
53	m_impl = std::make_unique<Server_Impl_12>(callbacks, session_manager, creds, policy, rng, is_datagram, io_buf_sz);	561✔
54	return;	561✔
55	}
56	#endif
57
58	BOTAN_UNUSED(max_version, callbacks, session_manager, creds, policy, rng, is_datagram, io_buf_sz);	×
59	throw Not_Implemented("Requested TLS server version is not available in this build");	×
60	}	×
61
62	Server::~Server() = default;	4,562✔
63
64	size_t Server::from_peer(std::span<const uint8_t> data) {	344,487✔
65	auto read = m_impl->from_peer(data);	344,487✔
66
67	#if defined(BOTAN_HAS_TLS_12)
68	// If TLS 1.2 is not available, we will never downgrade, the downgrade info
69	// won't even be created and `is_downgrading()` would always return false.
70	if(m_impl->is_downgrading()) {	343,043✔
71	auto info = m_impl->extract_downgrade_info();	565✔
72	m_impl = std::make_unique<Server_Impl_12>(*info);	1,130✔
73
74	// replay peer data received so far
75	read = m_impl->from_peer(info->peer_transcript);	565✔
76	}	565✔
77	#endif
78
79	return read;	343,019✔
80	}
81
82	bool Server::is_handshake_complete() const {	2,772✔
83	return m_impl->is_handshake_complete();	2,772✔
84	}
85
86	bool Server::is_active() const {	1,204✔
87	return m_impl->is_active();	1,204✔
88	}
89
90	std::optional<std::chrono::milliseconds> Server::next_retransmission_timeout() const {	7✔
91	return m_impl->next_retransmission_timeout();	7✔
92	}
93
94	bool Server::is_closed() const {	270✔
95	return m_impl->is_closed();	270✔
96	}
97
98	bool Server::is_closed_for_reading() const {	×
99	return m_impl->is_closed_for_reading();	×
100	}
101
102	bool Server::is_closed_for_writing() const {	×
103	return m_impl->is_closed_for_writing();	×
104	}
105
106	std::vector<X509_Certificate> Server::peer_cert_chain() const {	167✔
107	return m_impl->peer_cert_chain();	167✔
108	}
109
110	std::shared_ptr<const Public_Key> Server::peer_raw_public_key() const {	1✔
111	return m_impl->peer_raw_public_key();	1✔
112	}
113
114	std::optional<std::string> Server::external_psk_identity() const {	×
115	return m_impl->external_psk_identity();	×
116	}
117
118	SymmetricKey Server::key_material_export(std::string_view label, std::string_view context, size_t length) const {	252✔
119	return m_impl->key_material_export(label, context, length);	252✔
120	}
121
122	void Server::renegotiate(bool force_full_renegotiation) {	1✔
123	m_impl->renegotiate(force_full_renegotiation);	1✔
124	}	1✔
125
126	bool Server::new_session_ticket_supported() const {	×
127	return m_impl->new_session_ticket_supported();	×
128	}
129
130	size_t Server::send_new_session_tickets(const size_t tickets) {	1✔
131	return m_impl->send_new_session_tickets(tickets);	1✔
132	}
133
134	void Server::update_traffic_keys(bool request_peer_update) {	1✔
135	m_impl->update_traffic_keys(request_peer_update);	1✔
136	}	1✔
137
138	bool Server::secure_renegotiation_supported() const {	×
139	return m_impl->secure_renegotiation_supported();	×
140	}
141
142	void Server::to_peer(std::span<const uint8_t> data) {	1,555✔
143	m_impl->to_peer(data);	1,555✔
144	}	1,555✔
145
146	void Server::send_alert(const Alert& alert) {	1,118✔
147	m_impl->send_alert(alert);	1,118✔
148	}	1,118✔
149
150	void Server::send_warning_alert(Alert::Type type) {	135✔
151	m_impl->send_warning_alert(type);	135✔
152	}	135✔
153
154	void Server::send_fatal_alert(Alert::Type type) {	×
155	m_impl->send_fatal_alert(type);	×
156	}	×
157
158	void Server::close() {	48✔
159	m_impl->close();	48✔
160	}	48✔
161
162	bool Server::timeout_check() {	2✔
163	return m_impl->timeout_check();	2✔
164	}
165
166	std::string Server::application_protocol() const {	1,301✔
167	return m_impl->application_protocol();	1,301✔
168	}
169	} // namespace Botan::TLS

randombit / botan / 30496461195

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