#include <tls_session.h>

Inheritance diagram for Botan::TLS::Session:

Public Member Functions
Ciphersuite	ciphersuite () const

uint16_t	ciphersuite_code () const

secure_vector< uint8_t >	DER_encode () const

uint16_t	dtls_srtp_profile () const

std::vector< uint8_t >	encrypt (const SymmetricKey &key, RandomNumberGenerator &rng) const

secure_vector< uint8_t >	extract_master_secret ()

std::chrono::seconds	lifetime_hint () const

const secure_vector< uint8_t > &	master_secret () const

uint32_t	max_early_data_bytes () const

const std::vector< X509_Certificate > &	peer_certs () const

std::shared_ptr< const Public_Key >	peer_raw_public_key () const

std::string	PEM_encode () const

const Server_Information &	server_info () const

	Session (const secure_vector< uint8_t > &master_secret, Protocol_Version version, uint16_t ciphersuite, Connection_Side side, bool supports_extended_master_secret, bool supports_encrypt_then_mac, const std::vector< X509_Certificate > &peer_certs, const Server_Information &server_info, uint16_t srtp_profile, std::chrono::system_clock::time_point current_timestamp, std::chrono::seconds lifetime_hint=std::chrono::seconds::max())

	Session (const secure_vector< uint8_t > &session_psk, const std::optional< uint32_t > &max_early_data_bytes, uint32_t ticket_age_add, std::chrono::seconds lifetime_hint, Protocol_Version version, uint16_t ciphersuite, Connection_Side side, const std::vector< X509_Certificate > &peer_certs, std::shared_ptr< const Public_Key > peer_raw_public_key, const Server_Information &server_info, std::chrono::system_clock::time_point current_timestamp)

	Session (secure_vector< uint8_t > &&session_psk, const std::optional< uint32_t > &max_early_data_bytes, std::chrono::seconds lifetime_hint, const std::vector< X509_Certificate > &peer_certs, std::shared_ptr< const Public_Key > peer_raw_public_key, const Client_Hello_13 &client_hello, const Server_Hello_13 &server_hello, Callbacks &callbacks, RandomNumberGenerator &rng)

	Session (std::span< const uint8_t > ber_data)

	Session (std::string_view pem)

uint32_t	session_age_add () const

Connection_Side	side () const

std::chrono::system_clock::time_point	start_time () const

bool	supports_early_data () const

bool	supports_encrypt_then_mac () const

bool	supports_extended_master_secret () const

Protocol_Version	version () const

Static Public Member Functions
static Session	decrypt (const uint8_t ctext[], size_t ctext_size, const SymmetricKey &key)

static Session	decrypt (std::span< const uint8_t > ctext, const SymmetricKey &key)

Protected Attributes
uint16_t	m_ciphersuite

Connection_Side	m_connection_side

bool	m_encrypt_then_mac

bool	m_extended_master_secret

std::vector< X509_Certificate >	m_peer_certs

std::shared_ptr< const Public_Key >	m_peer_raw_public_key

Server_Information	m_server_info

uint16_t	m_srtp_profile

std::chrono::system_clock::time_point	m_start_time

Protocol_Version	m_version

Detailed Description

Represents a session's negotiated features along with all resumption information to re-establish a TLS connection later on.

Definition at line 336 of file tls_session.h.

Constructor & Destructor Documentation

◆ Session() [1/5]

Botan::TLS::Session::Session	(	const secure_vector< uint8_t > &	master_secret,
		Protocol_Version	version,
		uint16_t	ciphersuite,
		Connection_Side	side,
		bool	supports_extended_master_secret,
		bool	supports_encrypt_then_mac,
		const std::vector< X509_Certificate > &	peer_certs,
		const Server_Information &	server_info,
		uint16_t	srtp_profile,
		std::chrono::system_clock::time_point	current_timestamp,
		std::chrono::seconds	lifetime_hint = std::chrono::seconds::max() )

New TLS 1.2 session (sets session start time)

Definition at line 202 of file tls_session.cpp.

                                                 :
      Session_Base(current_timestamp,
                   version,
                   ciphersuite,
                   side,
                   srtp_profile,
                   extended_master_secret,
                   encrypt_then_mac,
                   certs,
                   nullptr,  // RFC 7250 (raw public keys) is NYI for TLS 1.2
                   server_info),
      m_master_secret(master_secret),
      m_early_data_allowed(false),
      m_max_early_data_bytes(0),
      m_ticket_age_add(0),
      m_lifetime_hint(lifetime_hint) {
   BOTAN_ARG_CHECK(version.is_pre_tls_13(), "Instantiated a TLS 1.2 session object with a TLS version newer than 1.2");
}

References BOTAN_ARG_CHECK, Botan::TLS::Protocol_Version::is_pre_tls_13(), and Botan::TLS::Session_Base::version().

Referenced by decrypt().

◆ Session() [2/5]

Botan::TLS::Session::Session	(	const secure_vector< uint8_t > &	session_psk,
		const std::optional< uint32_t > &	max_early_data_bytes,
		uint32_t	ticket_age_add,
		std::chrono::seconds	lifetime_hint,
		Protocol_Version	version,
		uint16_t	ciphersuite,
		Connection_Side	side,
		const std::vector< X509_Certificate > &	peer_certs,
		std::shared_ptr< const Public_Key >	peer_raw_public_key,
		const Server_Information &	server_info,
		std::chrono::system_clock::time_point	current_timestamp )

New TLS 1.3 session (sets session start time)

Definition at line 233 of file tls_session.cpp.

                                                                    :
      Session_Base(current_timestamp,
                   version,
                   ciphersuite,
                   side,
 
                   // TODO: SRTP might become necessary when DTLS 1.3 is being implemented
                   0,
 
                   // RFC 8446 Appendix D
                   //    Because TLS 1.3 always hashes in the transcript up to the server
                   //    Finished, implementations which support both TLS 1.3 and earlier
                   //    versions SHOULD indicate the use of the Extended Master Secret
                   //    extension in their APIs whenever TLS 1.3 is used.
                   true,
 
                   // TLS 1.3 uses AEADs, so technically encrypt-then-MAC is not applicable.
                   false,
                   peer_certs,
                   std::move(peer_raw_public_key),
                   server_info),
      m_master_secret(session_psk),
      m_early_data_allowed(max_early_data_bytes.has_value()),
      m_max_early_data_bytes(max_early_data_bytes.value_or(0)),
      m_ticket_age_add(ticket_age_add),
      m_lifetime_hint(lifetime_hint) {
   BOTAN_ARG_CHECK(!version.is_pre_tls_13(), "Instantiated a TLS 1.3 session object with a TLS version older than 1.3");
}

References BOTAN_ARG_CHECK, Botan::TLS::Protocol_Version::is_pre_tls_13(), and Botan::TLS::Session_Base::version().

◆ Session() [3/5]

Botan::TLS::Session::Session	(	secure_vector< uint8_t > &&	session_psk,
		const std::optional< uint32_t > &	max_early_data_bytes,
		std::chrono::seconds	lifetime_hint,
		const std::vector< X509_Certificate > &	peer_certs,
		std::shared_ptr< const Public_Key >	peer_raw_public_key,
		const Client_Hello_13 &	client_hello,
		const Server_Hello_13 &	server_hello,
		Callbacks &	callbacks,
		RandomNumberGenerator &	rng )

Create a new TLS 1.3 session object from server data structures after a successful handshake with a TLS 1.3 client

Definition at line 272 of file tls_session.cpp.

                                             :
      Session_Base(callbacks.tls_current_timestamp(),
                   server_hello.selected_version(),
                   server_hello.ciphersuite(),
                   Connection_Side::Server,
                   0,
                   true,
                   false,  // see constructor above for rationales
                   peer_certs,
                   std::move(peer_raw_public_key),
                   Server_Information(client_hello.sni_hostname())),
      m_master_secret(std::move(session_psk)),
      m_early_data_allowed(max_early_data_bytes.has_value()),
      m_max_early_data_bytes(max_early_data_bytes.value_or(0)),
      m_ticket_age_add(load_be<uint32_t>(rng.random_vec(4).data(), 0)),
      m_lifetime_hint(lifetime_hint) {
   BOTAN_ARG_CHECK(!m_version.is_pre_tls_13(),
                   "Instantiated a TLS 1.3 session object with a TLS version older than 1.3");
}

References BOTAN_ARG_CHECK, Botan::TLS::Protocol_Version::is_pre_tls_13(), and Botan::TLS::Session_Base::m_version.

◆ Session() [4/5]

Botan::TLS::Session::Session ( std::span< const uint8_t > ber_data )

Load a session from DER representation (created by DER_encode)

Parameters

ber_data DER representation buffer

Definition at line 304 of file tls_session.cpp.

                                                {
   uint8_t side_code = 0;
 
   std::vector<uint8_t> raw_pubkey_or_empty;
 
   ASN1_String server_hostname;
   ASN1_String server_service;
   size_t server_port;
 
   uint8_t major_version = 0, minor_version = 0;
 
   size_t start_time = 0;
   size_t srtp_profile = 0;
   uint16_t ciphersuite_code = 0;
   uint64_t lifetime_hint = 0;
 
   BER_Decoder(ber_data.data(), ber_data.size())
      .start_sequence()
      .decode_and_check(static_cast<size_t>(TLS_SESSION_PARAM_STRUCT_VERSION),
                        "Unknown version in serialized TLS session")
      .decode_integer_type(start_time)
      .decode_integer_type(major_version)
      .decode_integer_type(minor_version)
      .decode_integer_type(ciphersuite_code)
      .decode_integer_type(side_code)
      .decode(m_extended_master_secret)
      .decode(m_encrypt_then_mac)
      .decode(m_master_secret, ASN1_Type::OctetString)
      .decode_list<X509_Certificate>(m_peer_certs)
      .decode(raw_pubkey_or_empty, ASN1_Type::OctetString)
      .decode(server_hostname)
      .decode(server_service)
      .decode(server_port)
      .decode(srtp_profile)
      .decode(m_early_data_allowed)
      .decode_integer_type(m_max_early_data_bytes)
      .decode_integer_type(m_ticket_age_add)
      .decode_integer_type(lifetime_hint)
      .end_cons()
      .verify_end();
 
   if(!Ciphersuite::by_id(ciphersuite_code)) {
      throw Decoding_Error(
         "Serialized TLS session contains unknown cipher suite "
         "(" +
         std::to_string(ciphersuite_code) + ")");
   }
 
   m_ciphersuite = ciphersuite_code;
   m_version = Protocol_Version(major_version, minor_version);
   m_start_time = std::chrono::system_clock::from_time_t(start_time);
   m_connection_side = static_cast<Connection_Side>(side_code);
   m_srtp_profile = static_cast<uint16_t>(srtp_profile);
 
   m_server_info =
      Server_Information(server_hostname.value(), server_service.value(), static_cast<uint16_t>(server_port));
 
   if(!raw_pubkey_or_empty.empty()) {
      m_peer_raw_public_key = X509::load_key(raw_pubkey_or_empty);
   }
 
   m_lifetime_hint = std::chrono::seconds(lifetime_hint);
}

◆ Session() [5/5]

Botan::TLS::Session::Session ( std::string_view pem )

explicit

Load a session from PEM representation (created by PEM_encode)

Parameters

pem	PEM representation

Definition at line 302 of file tls_session.cpp.

302: Session(PEM_Code::decode_check_label(pem, "TLS SESSION")) {}

Botan::TLS::Session::Session

Session(const secure_vector< uint8_t > &master_secret, Protocol_Version version, uint16_t ciphersuite, Connection_Side side, bool supports_extended_master_secret, bool supports_encrypt_then_mac, const std::vector< X509_Certificate > &peer_certs, const Server_Information &server_info, uint16_t srtp_profile, std::chrono::system_clock::time_point current_timestamp, std::chrono::seconds lifetime_hint=std::chrono::seconds::max())

Definition tls_session.cpp:202

Botan::PEM_Code::decode_check_label

secure_vector< uint8_t > decode_check_label(DataSource &source, std::string_view label_want)

Definition pem.cpp:49

Member Function Documentation

◆ ciphersuite()

Ciphersuite Botan::TLS::Session_Base::ciphersuite ( ) const

inherited

Get the ciphersuite info of the negotiated TLS session

Definition at line 86 of file tls_session.cpp.

                                            {
   auto suite = Ciphersuite::by_id(m_ciphersuite);
   if(!suite.has_value()) {
      throw Decoding_Error("Failed to find cipher suite for ID " + std::to_string(m_ciphersuite));
   }
   return suite.value();
}

References Botan::TLS::Ciphersuite::by_id(), and Botan::TLS::Session_Base::m_ciphersuite.

◆ ciphersuite_code()

uint16_t Botan::TLS::Session_Base::ciphersuite_code ( ) const

inlineinherited

Get the ciphersuite code of the negotiated TLS session

Definition at line 177 of file tls_session.h.

177{ return m_ciphersuite; }

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), and Session().

◆ decrypt() [1/2]

static Session Botan::TLS::Session::decrypt	(	const uint8_t	ctext[],
		size_t	ctext_size,
		const SymmetricKey &	key )

inlinestatic

Decrypt a session created by encrypt

Parameters

ctext	the ciphertext returned by encrypt
ctext_size	the size of ctext in bytes
key	the same key used by the encrypting side

Definition at line 416 of file tls_session.h.

416 {

417 return Session::decrypt(std::span(ctext, ctext_size), key);

418 }

Botan::TLS::Session::decrypt

static Session decrypt(const uint8_t ctext[], size_t ctext_size, const SymmetricKey &key)

Definition tls_session.h:416

Referenced by Botan::TLS::Session_Manager_SQL::find_some(), Botan::TLS::Session_Manager_SQL::retrieve_one(), and Botan::TLS::Session_Manager_Stateless::retrieve_one().

◆ decrypt() [2/2]

Session Botan::TLS::Session::decrypt	(	std::span< const uint8_t >	ctext,
		const SymmetricKey &	key )

static

Decrypt a session created by encrypt

Parameters

ctext	the ciphertext returned by encrypt
key	the same key used by the encrypting side

Definition at line 474 of file tls_session.cpp.

                                                                           {
   try {
      const size_t min_session_size = 48 + 4;  // serious under-estimate
      if(in.size() < TLS_SESSION_CRYPT_OVERHEAD + min_session_size) {
         throw Decoding_Error("Encrypted session too short to be valid");
      }
 
      BufferSlicer sub(in);
      const auto magic = sub.take(TLS_SESSION_CRYPT_MAGIC_LEN).data();
      const auto key_name = sub.take(TLS_SESSION_CRYPT_KEY_NAME_LEN).data();
      const auto key_seed = sub.take(TLS_SESSION_CRYPT_AEAD_KEY_SEED_LEN).data();
      const auto aead_nonce = sub.take(TLS_SESSION_CRYPT_AEAD_NONCE_LEN).data();
      auto ctext = sub.copy_as_secure_vector(sub.remaining());
 
      if(load_be<uint64_t>(magic, 0) != TLS_SESSION_CRYPT_MAGIC) {
         throw Decoding_Error("Missing expected magic numbers");
      }
 
      auto hmac = MessageAuthenticationCode::create_or_throw(TLS_SESSION_CRYPT_HMAC);
      hmac->set_key(key);
 
      // First derive and check the "key name"
      std::vector<uint8_t> cmp_key_name(hmac->output_length());
      hmac->update(TLS_SESSION_CRYPT_KEY_NAME);
      hmac->final(cmp_key_name.data());
 
      if(CT::is_equal(cmp_key_name.data(), key_name, TLS_SESSION_CRYPT_KEY_NAME_LEN).as_bool() == false) {
         throw Decoding_Error("Wrong key name for encrypted session");
      }
 
      hmac->update(key_seed, TLS_SESSION_CRYPT_AEAD_KEY_SEED_LEN);
      const secure_vector<uint8_t> aead_key = hmac->final();
 
      auto aead = AEAD_Mode::create_or_throw(TLS_SESSION_CRYPT_AEAD, Cipher_Dir::Decryption);
      aead->set_key(aead_key);
      aead->set_associated_data(in.data(), TLS_SESSION_CRYPT_HDR_LEN);
      aead->start(aead_nonce, TLS_SESSION_CRYPT_AEAD_NONCE_LEN);
      aead->finish(ctext, 0);
      return Session(ctext);
   } catch(std::exception& e) {
      throw Decoding_Error("Failed to decrypt serialized TLS session: " + std::string(e.what()));
   }
}

References Botan::BufferSlicer::copy_as_secure_vector(), Botan::AEAD_Mode::create_or_throw(), Botan::MessageAuthenticationCode::create_or_throw(), Botan::Decryption, Botan::CT::is_equal(), Botan::load_be(), Botan::BufferSlicer::remaining(), Session(), and Botan::BufferSlicer::take().

◆ DER_encode()

secure_vector< uint8_t > Botan::TLS::Session::DER_encode ( ) const

Encode this session data for storage

Warning: if the master secret is compromised so is the session traffic

Definition at line 368 of file tls_session.cpp.

                                                 {
   const auto raw_pubkey_or_empty =
      m_peer_raw_public_key ? m_peer_raw_public_key->subject_public_key() : std::vector<uint8_t>{};
 
   return DER_Encoder()
      .start_sequence()
      .encode(static_cast<size_t>(TLS_SESSION_PARAM_STRUCT_VERSION))
      .encode(static_cast<size_t>(std::chrono::system_clock::to_time_t(m_start_time)))
      .encode(static_cast<size_t>(m_version.major_version()))
      .encode(static_cast<size_t>(m_version.minor_version()))
      .encode(static_cast<size_t>(m_ciphersuite))
      .encode(static_cast<size_t>(m_connection_side))
      .encode(m_extended_master_secret)
      .encode(m_encrypt_then_mac)
      .encode(m_master_secret, ASN1_Type::OctetString)
      .start_sequence()
      .encode_list(m_peer_certs)
      .end_cons()
      .encode(raw_pubkey_or_empty, ASN1_Type::OctetString)
      .encode(ASN1_String(m_server_info.hostname(), ASN1_Type::Utf8String))
      .encode(ASN1_String(m_server_info.service(), ASN1_Type::Utf8String))
      .encode(static_cast<size_t>(m_server_info.port()))
      .encode(static_cast<size_t>(m_srtp_profile))
 
      // the fields below were introduced for TLS 1.3 session tickets
      .encode(m_early_data_allowed)
      .encode(static_cast<size_t>(m_max_early_data_bytes))
      .encode(static_cast<size_t>(m_ticket_age_add))
      .encode(static_cast<size_t>(m_lifetime_hint.count()))
      .end_cons()
      .get_contents();
}

Referenced by encrypt(), and PEM_encode().

◆ dtls_srtp_profile()

uint16_t Botan::TLS::Session_Base::dtls_srtp_profile ( ) const

inlineinherited

Get the negotiated DTLS-SRTP algorithm (RFC 5764)

Definition at line 192 of file tls_session.h.

192{ return m_srtp_profile; }

◆ encrypt()

std::vector< uint8_t > Botan::TLS::Session::encrypt	(	const SymmetricKey &	key,
		RandomNumberGenerator &	rng ) const

Encrypt a session (useful for serialization or session tickets)

Definition at line 431 of file tls_session.cpp.

                                                                                             {
   auto hmac = MessageAuthenticationCode::create_or_throw(TLS_SESSION_CRYPT_HMAC);
   hmac->set_key(key);
 
   // First derive the "key name"
   std::vector<uint8_t> key_name(hmac->output_length());
   hmac->update(TLS_SESSION_CRYPT_KEY_NAME);
   hmac->final(key_name.data());
   key_name.resize(TLS_SESSION_CRYPT_KEY_NAME_LEN);
 
   std::vector<uint8_t> aead_nonce;
   std::vector<uint8_t> key_seed;
 
   rng.random_vec(aead_nonce, TLS_SESSION_CRYPT_AEAD_NONCE_LEN);
   rng.random_vec(key_seed, TLS_SESSION_CRYPT_AEAD_KEY_SEED_LEN);
 
   hmac->update(key_seed);
   const secure_vector<uint8_t> aead_key = hmac->final();
 
   secure_vector<uint8_t> bits = this->DER_encode();
 
   // create the header
   std::vector<uint8_t> buf;
   buf.reserve(TLS_SESSION_CRYPT_OVERHEAD + bits.size());
   buf.resize(TLS_SESSION_CRYPT_MAGIC_LEN);
   store_be(TLS_SESSION_CRYPT_MAGIC, &buf[0]);
   buf += key_name;
   buf += key_seed;
   buf += aead_nonce;
 
   auto aead = AEAD_Mode::create_or_throw(TLS_SESSION_CRYPT_AEAD, Cipher_Dir::Encryption);
   BOTAN_ASSERT_NOMSG(aead->valid_nonce_length(TLS_SESSION_CRYPT_AEAD_NONCE_LEN));
   BOTAN_ASSERT_NOMSG(aead->tag_size() == TLS_SESSION_CRYPT_AEAD_TAG_SIZE);
   aead->set_key(aead_key);
   aead->set_associated_data(buf);
   aead->start(aead_nonce);
   aead->finish(bits, 0);
 
   // append the ciphertext
   buf += bits;
   return buf;
}

References BOTAN_ASSERT_NOMSG, Botan::AEAD_Mode::create_or_throw(), Botan::MessageAuthenticationCode::create_or_throw(), DER_encode(), Botan::Encryption, Botan::RandomNumberGenerator::random_vec(), and Botan::store_be().

Referenced by Botan::TLS::Session_Manager_Stateless::establish(), and Botan::TLS::Session_Manager_SQL::store().

◆ extract_master_secret()

secure_vector< uint8_t > Botan::TLS::Session::extract_master_secret ( )

Get the contained master secret as a moved-out object

Definition at line 405 of file tls_session.cpp.

405 {

406 BOTAN_STATE_CHECK(!m_master_secret.empty());

407 return std::exchange(m_master_secret, {});

408}

BOTAN_STATE_CHECK

#define BOTAN_STATE_CHECK(expr)

Definition assert.h:41

References BOTAN_STATE_CHECK.

◆ lifetime_hint()

std::chrono::seconds Botan::TLS::Session::lifetime_hint ( ) const

inline

Returns: the lifetime of the ticket as defined by the TLS server

Definition at line 462 of file tls_session.h.

462{ return m_lifetime_hint; }

Referenced by Session(), and Botan::TLS::Callbacks::tls_should_persist_resumption_information().

◆ master_secret()

const secure_vector< uint8_t > & Botan::TLS::Session::master_secret ( ) const

inline

Get a reference to the contained master secret

Definition at line 437 of file tls_session.h.

437{ return m_master_secret; }

◆ max_early_data_bytes()

uint32_t Botan::TLS::Session::max_early_data_bytes ( ) const

inline

Return the number of bytes allowed for 0-RTT early data

Definition at line 457 of file tls_session.h.

457{ return m_max_early_data_bytes; }

◆ peer_certs()

const std::vector< X509_Certificate > & Botan::TLS::Session_Base::peer_certs ( ) const

inlineinherited

Return the certificate chain of the peer (possibly empty)

Definition at line 209 of file tls_session.h.

209{ return m_peer_certs; }

◆ peer_raw_public_key()

std::shared_ptr< const Public_Key > Botan::TLS::Session_Base::peer_raw_public_key ( ) const

inlineinherited

Return the raw public key of the peer (possibly empty)

Definition at line 214 of file tls_session.h.

214{ return m_peer_raw_public_key; }

◆ PEM_encode()

std::string Botan::TLS::Session::PEM_encode ( ) const

Encode this session data for storage

Warning: if the master secret is compromised so is the session traffic

Definition at line 401 of file tls_session.cpp.

401 {

402 return PEM_Code::encode(this->DER_encode(), "TLS SESSION");

403}

Botan::PEM_Code::encode

std::string encode(const uint8_t der[], size_t length, std::string_view label, size_t width)

Definition pem.cpp:39

References DER_encode(), and Botan::PEM_Code::encode().

◆ server_info()

const Server_Information & Botan::TLS::Session_Base::server_info ( ) const

inlineinherited

Get information about the TLS server

Returns information that identifies the server side of the connection. This is useful for the client in that it identifies what was originally passed to the constructor. For the server, it includes the name the client specified in the server name indicator extension.

Definition at line 224 of file tls_session.h.

224{ return m_server_info; }

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), and Botan::TLS::Session_Manager_SQL::store().

◆ session_age_add()

uint32_t Botan::TLS::Session::session_age_add ( ) const

inline

Return the ticket obfuscation adder

Definition at line 452 of file tls_session.h.

452{ return m_ticket_age_add; }

◆ side()

Connection_Side Botan::TLS::Session_Base::side ( ) const

inlineinherited

Get which side of the connection we are/were acting as.

Definition at line 187 of file tls_session.h.

187{ return m_connection_side; }

Referenced by Botan::TLS::Session_Manager::establish(), and Botan::TLS::Session_Manager_Stateless::establish().

◆ start_time()

std::chrono::system_clock::time_point Botan::TLS::Session_Base::start_time ( ) const

inlineinherited

Get the wall clock time this session began

Definition at line 167 of file tls_session.h.

167{ return m_start_time; }

Referenced by Session(), and Botan::TLS::Session_Manager_SQL::store().

◆ supports_early_data()

bool Botan::TLS::Session::supports_early_data ( ) const

inline

Get whether the saved session supports sending/receiving of early data

Definition at line 447 of file tls_session.h.

447{ return m_early_data_allowed; }

◆ supports_encrypt_then_mac()

bool Botan::TLS::Session_Base::supports_encrypt_then_mac ( ) const

inlineinherited

Returns true if a TLS 1.2 session negotiated "encrypt then MAC"; TLS 1.3 sessions will always return false as they always use an AEAD.

Definition at line 198 of file tls_session.h.

198{ return m_encrypt_then_mac; }

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12().

◆ supports_extended_master_secret()

bool Botan::TLS::Session_Base::supports_extended_master_secret ( ) const

inlineinherited

Returns true if a TLS 1.2 session negotiated "extended master secret"; TLS 1.3 sessions will always return true (see RFC 8446 Appendix D).

Definition at line 204 of file tls_session.h.

204{ return m_extended_master_secret; }

◆ version()

Protocol_Version Botan::TLS::Session_Base::version ( ) const

inlineinherited

Get the negotiated protocol version of the TLS session

Definition at line 172 of file tls_session.h.

172{ return m_version; }

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Session_Manager_Hybrid::establish(), Botan::TLS::Channel_Impl::request_downgrade_for_resumption(), Session(), Session(), and Botan::TLS::Callbacks::tls_should_persist_resumption_information().

Member Data Documentation

◆ m_ciphersuite

uint16_t Botan::TLS::Session_Base::m_ciphersuite

protectedinherited

Definition at line 230 of file tls_session.h.

Referenced by Botan::TLS::Session_Base::ciphersuite(), DER_encode(), and Session().

◆ m_connection_side

Connection_Side Botan::TLS::Session_Base::m_connection_side

protectedinherited

Definition at line 231 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_encrypt_then_mac

bool Botan::TLS::Session_Base::m_encrypt_then_mac

protectedinherited

Definition at line 235 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_extended_master_secret

bool Botan::TLS::Session_Base::m_extended_master_secret

protectedinherited

Definition at line 234 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_peer_certs

std::vector<X509_Certificate> Botan::TLS::Session_Base::m_peer_certs

protectedinherited

Definition at line 237 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_peer_raw_public_key

std::shared_ptr<const Public_Key> Botan::TLS::Session_Base::m_peer_raw_public_key

protectedinherited

Definition at line 238 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_server_info

Server_Information Botan::TLS::Session_Base::m_server_info

protectedinherited

Definition at line 239 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_srtp_profile

uint16_t Botan::TLS::Session_Base::m_srtp_profile

protectedinherited

Definition at line 232 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_start_time

std::chrono::system_clock::time_point Botan::TLS::Session_Base::m_start_time

protectedinherited

Definition at line 227 of file tls_session.h.

Referenced by DER_encode(), and Session().

◆ m_version

Protocol_Version Botan::TLS::Session_Base::m_version

protectedinherited

Definition at line 229 of file tls_session.h.

Referenced by DER_encode(), Session(), and Session().

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

src/lib/tls/tls_session.h
src/lib/tls/tls_session.cpp

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Session() [1/5]

◆ Session() [2/5]

◆ Session() [3/5]

◆ Session() [4/5]

◆ Session() [5/5]

Member Function Documentation

◆ ciphersuite()

◆ ciphersuite_code()

◆ decrypt() [1/2]

◆ decrypt() [2/2]

◆ DER_encode()

◆ dtls_srtp_profile()

◆ encrypt()

◆ extract_master_secret()

◆ lifetime_hint()

◆ master_secret()

◆ max_early_data_bytes()

◆ peer_certs()

◆ peer_raw_public_key()

◆ PEM_encode()

◆ server_info()

◆ session_age_add()

◆ side()

◆ start_time()

◆ supports_early_data()

◆ supports_encrypt_then_mac()

◆ supports_extended_master_secret()

◆ version()

Member Data Documentation

◆ m_ciphersuite

◆ m_connection_side

◆ m_encrypt_then_mac

◆ m_extended_master_secret

◆ m_peer_certs

◆ m_peer_raw_public_key

◆ m_server_info

◆ m_srtp_profile

◆ m_start_time

◆ m_version