Botan::TLS::Certificate_Request_12 Class Reference

#include <tls_messages_12.h>

Inheritance diagram for Botan::TLS::Certificate_Request_12:

Public Member Functions
const std::vector< X509_DN > &	acceptable_CAs () const
const std::vector< std::string > &	acceptable_cert_types () const
	Certificate_Request_12 (Certificate_Request_12 &&)=delete
	Certificate_Request_12 (const Certificate_Request_12 &)=delete
	Certificate_Request_12 (const std::vector< uint8_t > &buf)
	Certificate_Request_12 (Handshake_IO &io, Handshake_Hash &hash, const Policy &policy, const std::vector< X509_DN > &allowed_cas)
Certificate_Request_12 &	operator= (Certificate_Request_12 &&other)=delete
Certificate_Request_12 &	operator= (const Certificate_Request_12 &other)=delete
std::vector< uint8_t >	serialize () const override
const std::vector< Signature_Scheme > &	signature_schemes () const
Handshake_Type	type () const override
std::string	type_string () const
virtual Handshake_Type	wire_type () const
	~Certificate_Request_12 () override

Detailed Description

Certificate Request Message (TLS 1.2)

Definition at line 232 of file tls_messages_12.h.

Constructor & Destructor Documentation

Certificate_Request_12() [1/4]

Botan::TLS::Certificate_Request_12::Certificate_Request_12	(	Handshake_IO &	io,
		Handshake_Hash &	hash,
		const Policy &	policy,
		const std::vector< X509_DN > &	ca_certs )

Create a new Certificate Request message

Definition at line 59 of file msg_certificate_req_12.cpp.

                                                                                   :
      m_names(ca_certs), m_cert_key_types({"RSA", "ECDSA"}) {
   m_schemes = policy.acceptable_signature_schemes();
   hash.update(io.send(*this));
}

Referenced by Certificate_Request_12(), Certificate_Request_12(), operator=(), and operator=().

Certificate_Request_12() [2/4]

Botan::TLS::Certificate_Request_12::Certificate_Request_12 ( const std::vector< uint8_t > & buf )

explicit

Deserialize a Certificate Request message

Definition at line 71 of file msg_certificate_req_12.cpp.

                                                                            {
   if(buf.size() < 4) {
      throw Decoding_Error("Certificate_Req: Bad certificate request");
   }
 
   TLS_Data_Reader reader("CertificateRequest", buf);
 
   const auto cert_type_codes = reader.get_range_vector<uint8_t>(1, 1, 255);
 
   for(const auto cert_type_code : cert_type_codes) {
      const std::string cert_type_name = cert_type_code_to_name(cert_type_code);
 
      if(cert_type_name.empty()) {  // something we don't know
         continue;
      }
 
      m_cert_key_types.emplace_back(cert_type_name);
   }
 
   const std::vector<uint8_t> algs = reader.get_range_vector<uint8_t>(2, 2, 65534);
 
   if(algs.size() % 2 != 0) {
      throw Decoding_Error("Bad length for signature IDs in certificate request");
   }
 
   for(size_t i = 0; i != algs.size(); i += 2) {
      m_schemes.emplace_back(make_uint16(algs[i], algs[i + 1]));
   }
 
   const uint16_t purported_size = reader.get_uint16_t();
 
   if(reader.remaining_bytes() != purported_size) {
      throw Decoding_Error("Inconsistent length in certificate request");
   }
 
   while(reader.has_remaining()) {
      std::vector<uint8_t> name_bits = reader.get_range_vector<uint8_t>(2, 0, 65535);
 
      BER_Decoder decoder(name_bits.data(), name_bits.size());
      X509_DN name;
      decoder.decode(name);
      m_names.emplace_back(name);
   }
}

References Botan::TLS::TLS_Data_Reader::get_range_vector(), Botan::TLS::TLS_Data_Reader::get_uint16_t(), Botan::TLS::TLS_Data_Reader::has_remaining(), Botan::make_uint16(), and Botan::TLS::TLS_Data_Reader::remaining_bytes().

~Certificate_Request_12()

Botan::TLS::Certificate_Request_12::~Certificate_Request_12 ( )

overridedefault

Certificate_Request_12() [3/4]

Botan::TLS::Certificate_Request_12::Certificate_Request_12 ( const Certificate_Request_12 & )

delete

References Certificate_Request_12().

Certificate_Request_12() [4/4]

Botan::TLS::Certificate_Request_12::Certificate_Request_12 ( Certificate_Request_12 && )

delete

References Certificate_Request_12().

Member Function Documentation

acceptable_CAs()

const std::vector< X509_DN > & Botan::TLS::Certificate_Request_12::acceptable_CAs

(

)

const

Definition at line 120 of file msg_certificate_req_12.cpp.

                                                                       {
   return m_names;
}

acceptable_cert_types()

const std::vector< std::string > & Botan::TLS::Certificate_Request_12::acceptable_cert_types

(

)

const

Definition at line 116 of file msg_certificate_req_12.cpp.

                                                                                {
   return m_cert_key_types;
}

operator=() [1/2]

Certificate_Request_12 & Botan::TLS::Certificate_Request_12::operator= ( Certificate_Request_12 && other )

delete

References Certificate_Request_12(), and serialize().

operator=() [2/2]

Certificate_Request_12 & Botan::TLS::Certificate_Request_12::operator= ( const Certificate_Request_12 & other )

delete

References Certificate_Request_12().

serialize()

std::vector< uint8_t > Botan::TLS::Certificate_Request_12::serialize ( ) const

overridevirtual

Serialize a Certificate Request message

Implements Botan::TLS::Handshake_Message.

Definition at line 131 of file msg_certificate_req_12.cpp.

                                                           {
   std::vector<uint8_t> buf;
 
   std::vector<uint8_t> cert_types;
 
   cert_types.reserve(m_cert_key_types.size());
   for(const auto& cert_key_type : m_cert_key_types) {
      cert_types.push_back(cert_type_name_to_code(cert_key_type));
   }
 
   append_tls_length_value(buf, cert_types, 1);
 
   if(!m_schemes.empty()) {
      buf += Signature_Algorithms(m_schemes).serialize(Connection_Side::Server);
   }
 
   std::vector<uint8_t> encoded_names;
 
   for(const auto& name : m_names) {
      DER_Encoder encoder;
      encoder.encode(name);
 
      append_tls_length_value(encoded_names, encoder.get_contents(), 2);
   }
 
   append_tls_length_value(buf, encoded_names, 2);
 
   return buf;
}

References Botan::TLS::append_tls_length_value(), Botan::DER_Encoder::encode(), Botan::DER_Encoder::get_contents(), Botan::TLS::Signature_Algorithms::serialize(), and Botan::TLS::Server.

Referenced by operator=().

signature_schemes()

const std::vector< Signature_Scheme > & Botan::TLS::Certificate_Request_12::signature_schemes

(

)

const

Definition at line 124 of file msg_certificate_req_12.cpp.

                                                                                   {
   return m_schemes;
}

Referenced by Botan::TLS::Handshake_State::choose_sig_format(), and Botan::TLS::Handshake_State::parse_sig_format().

type()

Handshake_Type Botan::TLS::Certificate_Request_12::type ( ) const

overridevirtual

Returns

the message type

Implements Botan::TLS::Handshake_Message.

Definition at line 26 of file msg_certificate_req_12.cpp.

                                                  {
   return Handshake_Type::CertificateRequest;
}

References Botan::TLS::CertificateRequest.

type_string()

std::string Botan::TLS::Handshake_Message::type_string ( ) const

inherited

Returns

string representation of this message type

Definition at line 21 of file tls_handshake_state.cpp.

                                               {
   return handshake_type_to_string(type());
}

References Botan::TLS::handshake_type_to_string(), and type().

wire_type()

virtual Handshake_Type Botan::TLS::Handshake_Message::wire_type ( ) const

inlinevirtualinherited

Returns

the wire representation of the message's type

Reimplemented in Botan::TLS::Hello_Retry_Request.

Definition at line 39 of file tls_handshake_msg.h.

                                               {
         // Usually equal to the Handshake_Type enum value,
         // with the exception of TLS 1.3 Hello Retry Request.
         return type();
      }

References type().

Referenced by Botan::TLS::Stream_Handshake_IO::send().

---

The documentation for this class was generated from the following files:

• src/lib/tls/tls12/tls_messages_12.h
• src/lib/tls/tls12/msg_certificate_req_12.cpp