5111374265

Committed 29 May 2023 11:19AM UTC coverage: 92.227% (+0.5%) from 91.723%

Build # 5111374265

Build Type

push

github

Committed by

randombit

Commit Message

Next release will be 3.1.0. Update release notes

Run Details

75588 of 81959 relevant lines covered (92.23%)

11886470.91 hits per line

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

97.73

/src/lib/tls/tls_alert.cpp

/*
* Alert Message
* (C) 2004-2006,2011 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/tls_alert.h>

#include <botan/tls_exceptn.h>

namespace Botan::TLS {

Alert::Alert(const secure_vector<uint8_t>& buf) {
   if(buf.size() != 2)
      throw Decoding_Error("Bad size (" + std::to_string(buf.size()) + ") for TLS alert message");

   if(buf[0] == 1)
      m_fatal = false;
   else if(buf[0] == 2)
      m_fatal = true;
   else
      throw TLS_Exception(Alert::IllegalParameter, "Bad code for TLS alert level");

   const uint8_t dc = buf[1];

   m_type_code = static_cast<Type>(dc);
}

std::vector<uint8_t> Alert::serialize() const {
   return std::vector<uint8_t>({static_cast<uint8_t>(is_fatal() ? 2 : 1), static_cast<uint8_t>(type())});
}

namespace {

const char* alert_type_to_string(AlertType type) {
   switch(type) {
      case AlertType::CloseNotify:
         return "close_notify";
      case AlertType::UnexpectedMessage:
         return "unexpected_message";
      case AlertType::BadRecordMac:
         return "bad_record_mac";
      case AlertType::DecryptionFailed:
         return "decryption_failed";
      case AlertType::RecordOverflow:
         return "record_overflow";
      case AlertType::DecompressionFailure:
         return "decompression_failure";
      case AlertType::HandshakeFailure:
         return "handshake_failure";
      case AlertType::NoCertificate:
         return "no_certificate";
      case AlertType::BadCertificate:
         return "bad_certificate";
      case AlertType::UnsupportedCertificate:
         return "unsupported_certificate";
      case AlertType::CertificateRevoked:
         return "certificate_revoked";
      case AlertType::CertificateExpired:
         return "certificate_expired";
      case AlertType::CertificateUnknown:
         return "certificate_unknown";
      case AlertType::IllegalParameter:
         return "illegal_parameter";
      case AlertType::UnknownCA:
         return "unknown_ca";
      case AlertType::AccessDenied:
         return "access_denied";
      case AlertType::DecodeError:
         return "decode_error";
      case AlertType::DecryptError:
         return "decrypt_error";
      case AlertType::ExportRestriction:
         return "export_restriction";
      case AlertType::ProtocolVersion:
         return "protocol_version";
      case AlertType::InsufficientSecurity:
         return "insufficient_security";
      case AlertType::InternalError:
         return "internal_error";
      case AlertType::InappropriateFallback:
         return "inappropriate_fallback";
      case AlertType::UserCanceled:
         return "user_canceled";
      case AlertType::NoRenegotiation:
         return "no_renegotiation";
      case AlertType::MissingExtension:
         return "missing_extension";
      case AlertType::UnsupportedExtension:
         return "unsupported_extension";
      case AlertType::CertificateUnobtainable:
         return "certificate_unobtainable";
      case AlertType::UnrecognizedName:
         return "unrecognized_name";
      case AlertType::BadCertificateStatusResponse:
         return "bad_certificate_status_response";
      case AlertType::BadCertificateHashValue:
         return "bad_certificate_hash_value";
      case AlertType::UnknownPSKIdentity:
         return "unknown_psk_identity";
      case AlertType::CertificateRequired:
         return "certificate_required";
      case AlertType::NoApplicationProtocol:
         return "no_application_protocol";

      case AlertType::None:
         return "none";
   }

   return nullptr;
}

}  // namespace

std::string Alert::type_string() const {
   if(const char* known_alert = alert_type_to_string(type()))
      return std::string(known_alert);

   return "unrecognized_alert_" + std::to_string(static_cast<size_t>(type()));
}

}  // namespace Botan::TLS

1	/*
2	* Alert Message
3	* (C) 2004-2006,2011 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/tls_alert.h>
9
10	#include <botan/tls_exceptn.h>
11
12	namespace Botan::TLS {
13
14	Alert::Alert(const secure_vector<uint8_t>& buf) {	2,401✔
15	if(buf.size() != 2)	2,401✔
16	throw Decoding_Error("Bad size (" + std::to_string(buf.size()) + ") for TLS alert message");	14✔
17
18	if(buf[0] == 1)	2,394✔
19	m_fatal = false;	2,363✔
20	else if(buf[0] == 2)	31✔
21	m_fatal = true;	28✔
22	else
23	throw TLS_Exception(Alert::IllegalParameter, "Bad code for TLS alert level");	3✔
24
25	const uint8_t dc = buf[1];	2,391✔
26
27	m_type_code = static_cast<Type>(dc);	2,391✔
28	}	2,391✔
29
30	std::vector<uint8_t> Alert::serialize() const {	5,077✔
31	return std::vector<uint8_t>({static_cast<uint8_t>(is_fatal() ? 2 : 1), static_cast<uint8_t>(type())});	7,465✔
32	}
33
34	namespace {
35
36	const char* alert_type_to_string(AlertType type) {	1,926✔
37	switch(type) {	1,926✔
38	case AlertType::CloseNotify:
39	return "close_notify";
40	case AlertType::UnexpectedMessage:	1✔
41	return "unexpected_message";	1✔
42	case AlertType::BadRecordMac:	9✔
43	return "bad_record_mac";	9✔
44	case AlertType::DecryptionFailed:	1✔
45	return "decryption_failed";	1✔
46	case AlertType::RecordOverflow:	5✔
47	return "record_overflow";	5✔
48	case AlertType::DecompressionFailure:	2✔
49	return "decompression_failure";	2✔
50	case AlertType::HandshakeFailure:	7✔
51	return "handshake_failure";	7✔
52	case AlertType::NoCertificate:	1✔
53	return "no_certificate";	1✔
54	case AlertType::BadCertificate:	3✔
55	return "bad_certificate";	3✔
56	case AlertType::UnsupportedCertificate:	1✔
57	return "unsupported_certificate";	1✔
58	case AlertType::CertificateRevoked:	1✔
59	return "certificate_revoked";	1✔
60	case AlertType::CertificateExpired:	1✔
61	return "certificate_expired";	1✔
62	case AlertType::CertificateUnknown:	1✔
63	return "certificate_unknown";	1✔
64	case AlertType::IllegalParameter:	1✔
65	return "illegal_parameter";	1✔
66	case AlertType::UnknownCA:	3✔
67	return "unknown_ca";	3✔
68	case AlertType::AccessDenied:	10✔
69	return "access_denied";	10✔
70	case AlertType::DecodeError:	1✔
71	return "decode_error";	1✔
72	case AlertType::DecryptError:	1✔
73	return "decrypt_error";	1✔
74	case AlertType::ExportRestriction:	1✔
75	return "export_restriction";	1✔
76	case AlertType::ProtocolVersion:	3✔
77	return "protocol_version";	3✔
78	case AlertType::InsufficientSecurity:	1✔
79	return "insufficient_security";	1✔
80	case AlertType::InternalError:	29✔
81	return "internal_error";	29✔
82	case AlertType::InappropriateFallback:	1✔
83	return "inappropriate_fallback";	1✔
84	case AlertType::UserCanceled:	10✔
85	return "user_canceled";	10✔
86	case AlertType::NoRenegotiation:	1✔
87	return "no_renegotiation";	1✔
88	case AlertType::MissingExtension:	1✔
89	return "missing_extension";	1✔
90	case AlertType::UnsupportedExtension:	1✔
91	return "unsupported_extension";	1✔
92	case AlertType::CertificateUnobtainable:	1✔
93	return "certificate_unobtainable";	1✔
94	case AlertType::UnrecognizedName:	3✔
95	return "unrecognized_name";	3✔
96	case AlertType::BadCertificateStatusResponse:	1✔
97	return "bad_certificate_status_response";	1✔
98	case AlertType::BadCertificateHashValue:	1✔
99	return "bad_certificate_hash_value";	1✔
100	case AlertType::UnknownPSKIdentity:	1✔
101	return "unknown_psk_identity";	1✔
102	case AlertType::CertificateRequired:	2✔
103	return "certificate_required";	2✔
104	case AlertType::NoApplicationProtocol:	1✔
105	return "no_application_protocol";	1✔
106
107	case AlertType::None:	×
108	return "none";	×
109	}
110
111	return nullptr;	1✔
112	}
113
114	} // namespace
115
116	std::string Alert::type_string() const {	1,926✔
117	if(const char* known_alert = alert_type_to_string(type()))	1,926✔
118	return std::string(known_alert);	1,925✔
119
120	return "unrecognized_alert_" + std::to_string(static_cast<size_t>(type()));	2✔
121	}
122
123	} // namespace Botan::TLS

randombit / botan / 5111374265

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