#include <tls_extensions_13.h>

Inheritance diagram for Botan::TLS::Certificate_Authorities:

Public Member Functions
	Certificate_Authorities (std::vector< X509_DN > acceptable_DNs)
	Certificate_Authorities (TLS_Data_Reader &reader, uint16_t extension_size)
const std::vector< X509_DN > &	distinguished_names () const
bool	empty () const override
virtual bool	is_implemented () const
std::vector< uint8_t >	serialize (Connection_Side whoami) const override
Extension_Code	type () const override

Static Public Member Functions
static Extension_Code	static_type ()

Detailed Description

Certificate Authorities Extension from RFC 8446 4.2.4

Definition at line 88 of file tls_extensions_13.h.

Constructor & Destructor Documentation

◆ Certificate_Authorities() [1/2]

Botan::TLS::Certificate_Authorities::Certificate_Authorities	(	TLS_Data_Reader &	reader,
		uint16_t	extension_size )

Definition at line 106 of file tls_extensions_13.cpp.

                                                                                                 {
   if(extension_size < 2) {
      throw Decoding_Error("Empty certificate_authorities extension is illegal");
   }
 
   const uint16_t purported_size = reader.get_uint16_t();
 
   if(reader.remaining_bytes() != purported_size) {
      throw Decoding_Error("Inconsistent length in certificate_authorities extension");
   }
 
   // RFC 8446 4.2.4: DistinguishedName authorities<3..2^16-1>;
   if(purported_size < 3) {
      throw Decoding_Error("Empty certificate_authorities list is illegal");
   }
 
   while(reader.has_remaining()) {
      // RFC 8446 4.2.4: opaque DistinguishedName<1..2^16-1>
      const std::vector<uint8_t> name_bits = reader.get_range<uint8_t>(2, 1, 65535);
 
      BER_Decoder decoder(name_bits, BER_Decoder::Limits::DER());
      m_distinguished_names.emplace_back();
      decoder.decode(m_distinguished_names.back()).verify_end();
   }
}

References Botan::BER_Decoder::Limits::DER(), Botan::TLS::TLS_Data_Reader::get_range(), Botan::TLS::TLS_Data_Reader::get_uint16_t(), Botan::TLS::TLS_Data_Reader::has_remaining(), and Botan::TLS::TLS_Data_Reader::remaining_bytes().

◆ Certificate_Authorities() [2/2]

Botan::TLS::Certificate_Authorities::Certificate_Authorities ( std::vector< X509_DN > acceptable_DNs )

explicit

Definition at line 132 of file tls_extensions_13.cpp.

132 :

133 m_distinguished_names(std::move(acceptable_DNs)) {}

Member Function Documentation

◆ distinguished_names()

const std::vector< X509_DN > & Botan::TLS::Certificate_Authorities::distinguished_names ( ) const

inline

Definition at line 98 of file tls_extensions_13.h.

98{ return m_distinguished_names; }

◆ empty()

bool Botan::TLS::Certificate_Authorities::empty ( ) const

inlineoverridevirtual

Predicate if a TLS extension should be included or not

Returns: true if this extension should be encoded, otherwise false

Implements Botan::TLS::Extension.

Definition at line 96 of file tls_extensions_13.h.

96{ return m_distinguished_names.empty(); }

◆ is_implemented()

virtual bool Botan::TLS::Extension::is_implemented ( ) const

inlinevirtualinherited

Predicate if the extension is known/implemented

Note: this exists primarily to support unknown extension handling and doesn't need to be overridden even in the custom extension case.

Returns: true if this extension is known

Reimplemented in Botan::TLS::Unknown_Extension.

Definition at line 113 of file tls_extensions.h.

113{ return true; }

◆ serialize()

std::vector< uint8_t > Botan::TLS::Certificate_Authorities::serialize ( Connection_Side whoami ) const

overridevirtual

Serialize a TLS extension

Parameters

whoami which peer we are acting as in the protocol

Returns: serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 90 of file tls_extensions_13.cpp.

                                                                             {
   std::vector<uint8_t> out;
   std::vector<uint8_t> dn_list;
 
   for(const auto& dn : m_distinguished_names) {
      std::vector<uint8_t> encoded_dn;
      auto encoder = DER_Encoder(encoded_dn);
      dn.encode_into(encoder);
      append_tls_length_value(dn_list, encoded_dn, 2);
   }
 
   append_tls_length_value(out, dn_list, 2);
 
   return out;
}