Botan::Record_Writer Class Reference

#include <tls_record.h>

Public Member Functions
void	alert (Alert_Level, Alert_Type)
void	flush ()
	Record_Writer (std::tr1::function< void(const byte[], size_t)> output_fn)
void	reset ()
void	send (byte type, byte val)
void	send (byte type, const byte input[], size_t length)
void	set_keys (const CipherSuite &, const SessionKeys &, Connection_Side)
void	set_version (Version_Code)
	~Record_Writer ()

Detailed Description

TLS Record Writer

Definition at line 39 of file tls_record.h.

Constructor & Destructor Documentation

Record_Writer()

Botan::Record_Writer::Record_Writer

(

std::tr1::function< void(const byte[], size_t)>

out

)

Record_Writer Constructor

Definition at line 19 of file rec_wri.cpp.

                                                                            :
   output_fn(out),
   buffer(DEFAULT_BUFFERSIZE)
   {
   mac = 0;
   reset();
   }

References reset().

~Record_Writer()

Botan::Record_Writer::~Record_Writer ( )

inline

Definition at line 57 of file tls_record.h.

{ delete mac; }

Member Function Documentation

alert()

void Botan::Record_Writer::alert	(	Alert_Level	level,
		Alert_Type	type )

Send an alert

Definition at line 264 of file rec_wri.cpp.

   {
   byte alert[2] = { level, type };
   send(ALERT, alert, sizeof(alert));
   flush();
   }

References Botan::ALERT, alert(), flush(), and send().

Referenced by alert().

flush()

void Botan::Record_Writer::flush

(

)

Split buffer into records, and send them all

Definition at line 162 of file rec_wri.cpp.

   {
   const byte* buf_ptr = &buffer[0];
   size_t offset = 0;
 
   while(offset != buf_pos)
      {
      size_t record_size = buf_pos - offset;
      if(record_size > MAX_PLAINTEXT_SIZE)
         record_size = MAX_PLAINTEXT_SIZE;
 
      send_record(buf_type, buf_ptr + offset, record_size);
      offset += record_size;
      }
   buf_type = 0;
   buf_pos = 0;
   }

References Botan::MAX_PLAINTEXT_SIZE.

Referenced by alert(), Botan::HandshakeMessage::send(), and send().

reset()

void Botan::Record_Writer::reset

(

)

Reset the state

Definition at line 30 of file rec_wri.cpp.

   {
   cipher.reset();
 
   delete mac;
   mac = 0;
 
   zeroise(buffer);
   buf_pos = 0;
 
   major = minor = buf_type = 0;
   block_size = 0;
   mac_size = 0;
   iv_size = 0;
 
   seq_no = 0;
   }

References Botan::zeroise().

Referenced by Record_Writer().

send() [1/2]

void Botan::Record_Writer::send ( byte type, byte val )

inline

Definition at line 43 of file tls_record.h.

{ send(type, &val, 1); }

References send().

Referenced by send().

send() [2/2]

void Botan::Record_Writer::send	(	byte	type,
		const byte	input[],
		size_t	length )

Send one or more records to the other side

Definition at line 131 of file rec_wri.cpp.

   {
   if(type != buf_type)
      flush();
 
   const size_t BUFFER_SIZE = buffer.size();
   buf_type = type;
 
   // FIXME: compression right here
 
   buffer.copy(buf_pos, input, length);
   if(buf_pos + length >= BUFFER_SIZE)
      {
      send_record(buf_type, &buffer[0], length);
      input += (BUFFER_SIZE - buf_pos);
      length -= (BUFFER_SIZE - buf_pos);
      while(length >= BUFFER_SIZE)
         {
         send_record(buf_type, input, BUFFER_SIZE);
         input += BUFFER_SIZE;
         length -= BUFFER_SIZE;
         }
      buffer.copy(input, length);
      buf_pos = 0;
      }
   buf_pos += length;
   }

References flush().

Referenced by alert(), and Botan::HandshakeMessage::send().

set_keys()

void Botan::Record_Writer::set_keys	(	const CipherSuite &	suite,
		const SessionKeys &	keys,
		Connection_Side	side )

Set the keys for writing

Definition at line 63 of file rec_wri.cpp.

   {
   cipher.reset();
   delete mac;
   mac = 0;
   seq_no = 0;
 
   SymmetricKey mac_key, cipher_key;
   InitializationVector iv;
 
   if(side == CLIENT)
      {
      cipher_key = keys.client_cipher_key();
      iv = keys.client_iv();
      mac_key = keys.client_mac_key();
      }
   else
      {
      cipher_key = keys.server_cipher_key();
      iv = keys.server_iv();
      mac_key = keys.server_mac_key();
      }
 
   const std::string cipher_algo = suite.cipher_algo();
   const std::string mac_algo = suite.mac_algo();
 
   if(have_block_cipher(cipher_algo))
      {
      cipher.append(get_cipher(
                       cipher_algo + "/CBC/NoPadding",
                       cipher_key, iv, ENCRYPTION)
         );
      block_size = block_size_of(cipher_algo);
 
      if(major > 3 || (major == 3 && minor >= 2))
         iv_size = block_size;
      else
         iv_size = 0;
      }
   else if(have_stream_cipher(cipher_algo))
      {
      cipher.append(get_cipher(cipher_algo, cipher_key, ENCRYPTION));
      block_size = 0;
      iv_size = 0;
      }
   else
      throw Invalid_Argument("Record_Writer: Unknown cipher " + cipher_algo);
 
   if(have_hash(mac_algo))
      {
      Algorithm_Factory& af = global_state().algorithm_factory();
 
      if(major == 3 && minor == 0)
         mac = af.make_mac("SSL3-MAC(" + mac_algo + ")");
      else
         mac = af.make_mac("HMAC(" + mac_algo + ")");
 
      mac->set_key(mac_key);
      mac_size = mac->output_length();
      }
   else
      throw Invalid_Argument("Record_Writer: Unknown hash " + mac_algo);
   }

References Botan::Library_State::algorithm_factory(), Botan::block_size_of(), Botan::CipherSuite::cipher_algo(), Botan::CLIENT, Botan::SessionKeys::client_cipher_key(), Botan::SessionKeys::client_iv(), Botan::SessionKeys::client_mac_key(), Botan::ENCRYPTION, Botan::get_cipher(), Botan::global_state(), Botan::have_block_cipher(), Botan::have_hash(), Botan::have_stream_cipher(), Botan::CipherSuite::mac_algo(), Botan::Algorithm_Factory::make_mac(), Botan::SessionKeys::server_cipher_key(), Botan::SessionKeys::server_iv(), Botan::SessionKeys::server_mac_key(), and Botan::SymmetricAlgorithm::set_key().

set_version()

void Botan::Record_Writer::set_version

(

Version_Code

version

)

Set the version to use

Definition at line 51 of file rec_wri.cpp.

   {
   if(version != SSL_V3 && version != TLS_V10 && version != TLS_V11)
      throw Invalid_Argument("Record_Writer: Invalid protocol version");
 
   major = (version >> 8) & 0xFF;
   minor = (version & 0xFF);
   }

References Botan::SSL_V3, Botan::TLS_V10, and Botan::TLS_V11.

---

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

• src/ssl/tls_record.h
• src/ssl/rec_wri.cpp