Botan::Server_Key_Exchange Class Reference

#include <tls_messages.h>

Inheritance diagram for Botan::Server_Key_Exchange:

Public Member Functions
Public_Key *	key () const
void	send (Record_Writer &, HandshakeHash &) const
	Server_Key_Exchange (const MemoryRegion< byte > &buf)
	Server_Key_Exchange (RandomNumberGenerator &rng, Record_Writer &, const Public_Key *, const Private_Key *, const MemoryRegion< byte > &, const MemoryRegion< byte > &, HandshakeHash &)
Handshake_Type	type () const
bool	verify (const X509_Certificate &, const MemoryRegion< byte > &, const MemoryRegion< byte > &) const

Detailed Description

Server Key Exchange Message

Definition at line 256 of file tls_messages.h.

Constructor & Destructor Documentation

Server_Key_Exchange() [1/2]

Botan::Server_Key_Exchange::Server_Key_Exchange	(	RandomNumberGenerator &	rng,
		Record_Writer &	writer,
		const Public_Key *	kex_key,
		const Private_Key *	priv_key,
		const MemoryRegion< byte > &	c_random,
		const MemoryRegion< byte > &	s_random,
		HandshakeHash &	hash )

Create a new Server Key Exchange message

Definition at line 22 of file s_kex.cpp.

   {
   const DH_PublicKey* dh_pub = dynamic_cast<const DH_PublicKey*>(kex_key);
   const RSA_PublicKey* rsa_pub = dynamic_cast<const RSA_PublicKey*>(kex_key);
 
   if(dh_pub)
      {
      params.push_back(dh_pub->get_domain().get_p());
      params.push_back(dh_pub->get_domain().get_g());
      params.push_back(BigInt::decode(dh_pub->public_value()));
      }
   else if(rsa_pub)
      {
      params.push_back(rsa_pub->get_n());
      params.push_back(rsa_pub->get_e());
      }
   else
      throw Invalid_Argument("Bad key for TLS key exchange: not DH or RSA");
 
 
   std::string padding = "";
   Signature_Format format = IEEE_1363;
 
   if(priv_key->algo_name() == "RSA")
      padding = "EMSA3(TLS.Digest.0)";
   else if(priv_key->algo_name() == "DSA")
      {
      padding = "EMSA1(SHA-1)";
      format = DER_SEQUENCE;
      }
   else
      throw Invalid_Argument(priv_key->algo_name() +
                             " is invalid/unknown for TLS signatures");
 
   PK_Signer signer(*priv_key, padding, format);
 
   signer.update(c_random);
   signer.update(s_random);
   signer.update(serialize_params());
   signature = signer.signature(rng);
 
   send(writer, hash);
   }

References Botan::Public_Key::algo_name(), Botan::BigInt::decode(), Botan::DER_SEQUENCE, Botan::DL_Scheme_PublicKey::get_domain(), Botan::IF_Scheme_PublicKey::get_e(), Botan::DL_Group::get_g(), Botan::IF_Scheme_PublicKey::get_n(), Botan::DL_Group::get_p(), Botan::IEEE_1363, Botan::DH_PublicKey::public_value(), Botan::HandshakeMessage::send(), Botan::PK_Signer::signature(), and Botan::PK_Signer::update().

Server_Key_Exchange() [2/2]

Botan::Server_Key_Exchange::Server_Key_Exchange ( const MemoryRegion< byte > & buf )

inline

Definition at line 270 of file tls_messages.h.

{ deserialize(buf); }

Member Function Documentation

key()

Public_Key * Botan::Server_Key_Exchange::key

(

)

const

Return the public key

Definition at line 136 of file s_kex.cpp.

   {
   if(params.size() == 2)
      return new RSA_PublicKey(params[0], params[1]);
   else if(params.size() == 3)
      return new DH_PublicKey(DL_Group(params[0], params[1]), params[2]);
   else
      throw Internal_Error("Server_Key_Exchange::key: No key set");
   }

References Botan::DH_PublicKey::DH_PublicKey(), Botan::DL_Group::DL_Group(), Botan::Internal_Error::Internal_Error(), and Botan::RSA_PublicKey::RSA_PublicKey().

Referenced by verify().

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();
   }

References Botan::Record_Writer::flush(), Botan::get_byte(), Botan::HANDSHAKE, Botan::Record_Writer::send(), Botan::MemoryRegion< T >::size(), type(), and Botan::HandshakeHash::update().

Referenced by Botan::Certificate::Certificate(), Botan::Certificate_Req::Certificate_Req(), Botan::Certificate_Verify::Certificate_Verify(), Botan::Client_Hello::Client_Hello(), Botan::Client_Key_Exchange::Client_Key_Exchange(), Botan::Finished::Finished(), Botan::Hello_Request::Hello_Request(), Botan::Server_Hello::Server_Hello(), Botan::Server_Hello_Done::Server_Hello_Done(), and Botan::Server_Key_Exchange::Server_Key_Exchange().

type()

Handshake_Type Botan::Server_Key_Exchange::type ( ) const

inlinevirtual

Implements Botan::HandshakeMessage.

Definition at line 259 of file tls_messages.h.

{ return SERVER_KEX; }

References Botan::SERVER_KEX.

verify()

bool Botan::Server_Key_Exchange::verify	(	const X509_Certificate &	cert,
		const MemoryRegion< byte > &	c_random,
		const MemoryRegion< byte > &	s_random ) const

Verify a Server Key Exchange message

Definition at line 149 of file s_kex.cpp.

   {
 
   std::auto_ptr<Public_Key> key(cert.subject_public_key());
 
   std::string padding = "";
   Signature_Format format = IEEE_1363;
 
   if(key->algo_name() == "RSA")
      padding = "EMSA3(TLS.Digest.0)";
   else if(key->algo_name() == "DSA")
      {
      padding = "EMSA1(SHA-1)";
      format = DER_SEQUENCE;
      }
   else
      throw Invalid_Argument(key->algo_name() +
                             " is invalid/unknown for TLS signatures");
 
   PK_Verifier verifier(*key, padding, format);
 
   SecureVector<byte> params_got = serialize_params();
   verifier.update(c_random);
   verifier.update(s_random);
   verifier.update(params_got);
 
   return verifier.check_signature(signature);
   }

References Botan::PK_Verifier::check_signature(), Botan::DER_SEQUENCE, Botan::IEEE_1363, key(), Botan::X509_Certificate::subject_public_key(), and Botan::PK_Verifier::update().

---

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

• src/ssl/tls_messages.h
• src/ssl/s_kex.cpp