#include <tls_messages.h>

Inheritance diagram for Botan::Client_Key_Exchange:

Public Member Functions
	Client_Key_Exchange (const MemoryRegion< byte > &buf, const CipherSuite &suite, Version_Code using_version)
	Client_Key_Exchange (RandomNumberGenerator &rng, Record_Writer &output, HandshakeHash &hash, const Public_Key *my_key, Version_Code using_version, Version_Code pref_version)
SecureVector< byte >	pre_master_secret () const
SecureVector< byte >	pre_master_secret (RandomNumberGenerator &rng, const Private_Key *key, Version_Code version)
void	send (Record_Writer &, HandshakeHash &) const
Handshake_Type	type () const

Detailed Description

Client Key Exchange Message

Definition at line 86 of file tls_messages.h.

Constructor & Destructor Documentation

◆ Client_Key_Exchange() [1/2]

Botan::Client_Key_Exchange::Client_Key_Exchange	(	RandomNumberGenerator &	rng,
		Record_Writer &	writer,
		HandshakeHash &	hash,
		const Public_Key *	pub_key,
		Version_Code	using_version,
		Version_Code	pref_version )

Create a new Client Key Exchange message

Definition at line 22 of file c_kex.cpp.

   {
   include_length = true;
 
   if(const DH_PublicKey* dh_pub = dynamic_cast<const DH_PublicKey*>(pub_key))
      {
      DH_PrivateKey priv_key(rng, dh_pub->get_domain());
 
      PK_Key_Agreement ka(priv_key, "Raw");
 
      pre_master = ka.derive_key(0, dh_pub->public_value()).bits_of();
 
      key_material = priv_key.public_value();
      }
   else if(const RSA_PublicKey* rsa_pub = dynamic_cast<const RSA_PublicKey*>(pub_key))
      {
      pre_master = rng.random_vec(48);
      pre_master[0] = (pref_version >> 8) & 0xFF;
      pre_master[1] = (pref_version     ) & 0xFF;
 
      PK_Encryptor_EME encryptor(*rsa_pub, "PKCS1v15");
 
      key_material = encryptor.encrypt(pre_master, rng);
 
      if(using_version == SSL_V3)
         include_length = false;
      }
   else
      throw Invalid_Argument("Client_Key_Exchange: Key not RSA or DH");
 
   send(writer, hash);
   }

References Botan::OctetString::bits_of(), Botan::PK_Key_Agreement::derive_key(), Botan::PK_Encryptor::encrypt(), Botan::DH_PrivateKey::public_value(), Botan::RandomNumberGenerator::random_vec(), Botan::HandshakeMessage::send(), and Botan::SSL_V3.

◆ Client_Key_Exchange() [2/2]

Botan::Client_Key_Exchange::Client_Key_Exchange	(	const MemoryRegion< byte > &	contents,
		const CipherSuite &	suite,
		Version_Code	using_version )

Read a Client Key Exchange message

Definition at line 63 of file c_kex.cpp.

   {
   include_length = true;
 
   if(using_version == SSL_V3 && (suite.kex_type() == TLS_ALGO_KEYEXCH_RSA))
      include_length = false;
 
   deserialize(contents);
   }

References Botan::CipherSuite::kex_type(), Botan::SSL_V3, and Botan::TLS_ALGO_KEYEXCH_RSA.

Member Function Documentation

◆ pre_master_secret() [1/2]

SecureVector< byte > Botan::Client_Key_Exchange::pre_master_secret ( ) const

Return the pre_master_secret

Definition at line 160 of file c_kex.cpp.

   {
   return pre_master;
   }

◆ pre_master_secret() [2/2]

SecureVector< byte > Botan::Client_Key_Exchange::pre_master_secret	(	RandomNumberGenerator &	rng,
		const Private_Key *	priv_key,
		Version_Code	version )

Return the pre_master_secret

Definition at line 108 of file c_kex.cpp.

   {
 
   if(const DH_PrivateKey* dh_priv = dynamic_cast<const DH_PrivateKey*>(priv_key))
      {
      try {
         PK_Key_Agreement ka(*dh_priv, "Raw");
 
         pre_master = ka.derive_key(0, key_material).bits_of();
      }
      catch(...)
         {
         /*
         * Something failed in the DH computation. To avoid possible
         * timing attacks, randomize the pre-master output and carry
         * on, allowing the protocol to fail later in the finished
         * checks.
         */
         pre_master = rng.random_vec(dh_priv->public_value().size());
         }
 
      return pre_master;
      }
   else if(const RSA_PrivateKey* rsa_priv = dynamic_cast<const RSA_PrivateKey*>(priv_key))
      {
      PK_Decryptor_EME decryptor(*rsa_priv, "PKCS1v15");
 
      try {
         pre_master = decryptor.decrypt(key_material);
 
         if(pre_master.size() != 48 ||
            make_u16bit(pre_master[0], pre_master[1]) != version)
            throw Decoding_Error("Client_Key_Exchange: Secret corrupted");
      }
      catch(...)
         {
         pre_master = rng.random_vec(48);
         pre_master[0] = (version >> 8) & 0xFF;
         pre_master[1] = (version     ) & 0xFF;
         }
 
      return pre_master;
      }
   else
      throw Invalid_Argument("Client_Key_Exchange: Bad key for decrypt");
   }

References Botan::OctetString::bits_of(), Botan::Decoding_Error::Decoding_Error(), Botan::PK_Decryptor::decrypt(), Botan::PK_Key_Agreement::derive_key(), Botan::make_u16bit(), and Botan::RandomNumberGenerator::random_vec().

◆ send()

void Botan::HandshakeMessage::send	(	Record_Writer &	writer,
		HandshakeHash &	hash ) const

inherited

Definition at line 16 of file hello.cpp.

   {
   SecureVector<byte> buf = serialize();
   SecureVector<byte> send_buf(4);
 
   const size_t buf_size = buf.size();
 
   send_buf[0] = type();
 
   for(size_t i = 1; i != 4; ++i)
     send_buf[i] = get_byte<u32bit>(i, buf_size);
 
   send_buf += buf;
 
   hash.update(send_buf);
 
   writer.send(HANDSHAKE, &send_buf[0], send_buf.size());
   writer.flush();
   }