Botan 2.13.0 Crypto and TLS for C++11

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode Class Referenceabstract

`#include <tls_cbc.h>`

Inheritance diagram for Botan::TLS::TLS_CBC_HMAC_AEAD_Mode:

## Public Member Functions
virtual bool | associated_data_requires_key () const
bool | authenticated () const override
void | clear () overridefinal
size_t | default_nonce_length () const overridefinal
virtual void | finish (secure_vector< uint8_t > &final_block, size_t offset=0)=0
Key_Length_Specification | key_spec () const overridefinal
size_t | maximum_keylength () const
virtual size_t | minimum_final_size () const =0
size_t | minimum_keylength () const
std::string | name () const overridefinal
virtual size_t | output_length (size_t input_length) const =0
size_t | process (uint8_t buf[], size_t sz) overridefinal
virtual std::string | provider () const
void | reset () overridefinal
template<typename Alloc >
void | set_ad (const std::vector< uint8_t, Alloc > &ad)
void | set_associated_data (const uint8_t ad[], size_t ad_len) override
template<typename Alloc >
void | set_associated_data_vec (const std::vector< uint8_t, Alloc > &ad)
void | set_key (const SymmetricKey &key)
template<typename Alloc >
void | set_key (const std::vector< uint8_t, Alloc > &key)
void | set_key (const uint8_t key[], size_t length)
template<typename Alloc >
void | start (const std::vector< uint8_t, Alloc > &nonce)
void | start (const uint8_t nonce[], size_t nonce_len)
void | start ()
size_t | tag_size () const overridefinal
void | update (secure_vector< uint8_t > &buffer, size_t offset=0)
size_t | update_granularity () const overridefinal
bool | valid_keylength (size_t length) const
bool | valid_nonce_length (size_t nl) const overridefinal

## Static Public Member Functions
static std::unique_ptr< AEAD_Mode > | create (const std::string &algo, Cipher_Dir direction, const std::string &provider="")
static std::unique_ptr< AEAD_Mode > | create_or_throw (const std::string &algo, Cipher_Dir direction, const std::string &provider="")
static std::vector< std::string > | providers (const std::string &algo_spec)

## Protected Member Functions
std::vector< uint8_t > & | assoc_data ()
std::vector< uint8_t > | assoc_data_with_len (uint16_t len)
size_t | block_size () const
Cipher_Mode & | cbc () const
secure_vector< uint8_t > & | cbc_state ()
size_t | cipher_keylen () const
bool | is_datagram_protocol () const
size_t | iv_size () const
MessageAuthenticationCode & | mac () const
size_t | mac_keylen () const
secure_vector< uint8_t > & | msg ()
| TLS_CBC_HMAC_AEAD_Mode (Cipher_Dir direction, std::unique_ptr< BlockCipher > cipher, std::unique_ptr< MessageAuthenticationCode > mac, size_t cipher_keylen, size_t mac_keylen, Protocol_Version version, bool use_encrypt_then_mac)
bool | use_encrypt_then_mac () const
void | verify_key_set (bool cond) const

## Detailed Description

TLS CBC+HMAC AEAD base class (GenericBlockCipher in TLS spec) This is the weird TLS-specific mode, not for general consumption.

Definition at line 25 of file tls_cbc.h.

## Constructor & Destructor Documentation

Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::TLS_CBC_HMAC_AEAD_Mode | ( | Cipher_Dir | direction,
|  | std::unique_ptr< BlockCipher > | cipher,
|  | std::unique_ptr< MessageAuthenticationCode > | mac,
|  | size_t | cipher_keylen,
|  | size_t | mac_keylen,
|  | Protocol_Version | version,
|  | bool | use_encrypt_then_mac
| ) |  |
| protected

Definition at line 27 of file tls_cbc.cpp.

References Botan::ENCRYPTION, Botan::TLS::Protocol_Version::is_datagram_protocol(), and Botan::TLS::Protocol_Version::supports_explicit_cbc_ivs().

33 :
34 m_cipher_name(cipher->name()),
35 m_mac_name(mac->name()),
36 m_cipher_keylen(cipher_keylen),
37 m_mac_keylen(mac_keylen),
38 m_use_encrypt_then_mac(use_encrypt_then_mac)
39 {
40 m_tag_size = mac->output_length();
41 m_block_size = cipher->block_size();
42
43 m_iv_size = version.supports_explicit_cbc_ivs() ? m_block_size : 0;
44
45 m_is_datagram = version.is_datagram_protocol();
46
47 m_mac = std::move(mac);
48
49 if(dir == ENCRYPTION)
50 m_cbc.reset(new CBC_Encryption(cipher.release(), new Null_Padding));
51 else
52 m_cbc.reset(new CBC_Decryption(cipher.release(), new Null_Padding));
53 }
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::mac
MessageAuthenticationCode & mac() const
Definition: tls_cbc.h:68
Botan::SymmetricAlgorithm::name
virtual std::string name() const =0
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::mac_keylen
size_t mac_keylen() const
Definition: tls_cbc.h:58
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::use_encrypt_then_mac
bool use_encrypt_then_mac() const
Definition: tls_cbc.h:62
Botan::Buffered_Computation::output_length
virtual size_t output_length() const =0
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::cipher_keylen
size_t cipher_keylen() const
Definition: tls_cbc.h:57

## Member Function Documentation

std::vector<uint8_t>& Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::assoc_data | ( |  | ) |
| inline protected

Definition at line 75 of file tls_cbc.h.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data().

75 { return m_ad; }

std::vector< uint8_t > Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::assoc_data_with_len | ( | uint16_t | len | ) |
| protected

Definition at line 123 of file tls_cbc.cpp.

References BOTAN_ASSERT, and Botan::get_byte().

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish().

124 {
125 std::vector<uint8_t> ad = m_ad;
126 BOTAN_ASSERT(ad.size() == 13, "Expected AAD size");
127 ad[11] = get_byte(0, len);
128 ad[12] = get_byte(1, len);
129 return ad;
130 }
Botan::get_byte
constexpr uint8_t get_byte(size_t byte_num, T input)
Definition: loadstor.h:41
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:55

virtual bool Botan::AEAD_Mode::associated_data_requires_key | ( |  | ) | const
| inline virtual inherited

Most AEADs require the key to be set prior to setting the AD A few allow the AD to be set even before the cipher is keyed. Such ciphers would return false from this function.

Reimplemented in Botan::ChaCha20Poly1305_Mode, and Botan::CCM_Mode.

Definition at line 68 of file aead.h.

68 { return true; }

bool Botan::AEAD_Mode::authenticated | ( |  | ) | const
| inline override virtual inherited

Returns
  true iff this mode provides authentication as well as confidentiality.

Reimplemented from Botan::Cipher_Mode.

Definition at line 47 of file aead.h.

47 { return true; }

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::block_size | ( |  | ) | const
| inline protected

Definition at line 60 of file tls_cbc.h.

References m_block_size.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::output_length(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data(), and valid_nonce_length().

60 { return m_block_size; }

Cipher_Mode& Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::cbc | ( |  | ) | const
| inline protected

Definition at line 66 of file tls_cbc.h.

Referenced by clear().

66 { return *m_cbc; }

secure_vector<uint8_t>& Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::cbc_state | ( |  | ) |
| inline protected

Definition at line 74 of file tls_cbc.h.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), and reset().

74 { return m_cbc_state; }

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::cipher_keylen | ( |  | ) | const
| inline protected

Definition at line 57 of file tls_cbc.h.

57 { return m_cipher_keylen; }

void Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::clear | ( |  | ) |
| final override virtual

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 55 of file tls_cbc.cpp.

References cbc(), Botan::SymmetricAlgorithm::clear(), mac(), and reset().

56 {
57 cbc().clear();
58 mac().clear();
59 reset();
60 }
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::cbc
Cipher_Mode & cbc() const
Definition: tls_cbc.h:66
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::mac
MessageAuthenticationCode & mac() const
Definition: tls_cbc.h:68
Botan::SymmetricAlgorithm::clear
virtual void clear()=0
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::reset
void reset() overridefinal
Definition: tls_cbc.cpp:62

std::unique_ptr< AEAD_Mode > Botan::AEAD_Mode::create | ( | const std::string & | algo,
|  | Cipher_Dir | direction,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

Create an AEAD mode

Parameters

  algo | the algorithm to create
  direction | specify if this should be an encryption or decryption AEAD
  provider | optional specification for provider to use

Returns
  an AEAD mode or a null pointer if not available

Definition at line 52 of file aead.cpp.

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), BOTAN_UNUSED, Botan::BlockCipher::create(), Botan::ENCRYPTION, Botan::parse_algorithm_name(), Botan::Cipher_Mode::provider(), and Botan::split_on().

Referenced by Botan::Cipher_Mode::create(), Botan::AEAD_Mode::create_or_throw(), and Botan::get_aead().

55 {
56 BOTAN_UNUSED(provider);
57 #if defined(BOTAN_HAS_AEAD_CHACHA20_POLY1305)
58 if(algo == "ChaCha20Poly1305")
59 {
60 if(dir == ENCRYPTION)
61 return std::unique_ptr<AEAD_Mode>(new ChaCha20Poly1305_Encryption);
62 else
63 return std::unique_ptr<AEAD_Mode>(new ChaCha20Poly1305_Decryption);
64
65 }
66 #endif
67
68 if(algo.find('/') != std::string::npos)
69 {
70 const std::vector<std::string> algo_parts = split_on(algo, '/');
71 const std::string cipher_name = algo_parts[0];
72 const std::vector<std::string> mode_info = parse_algorithm_name(algo_parts[1]);
73
74 if(mode_info.empty())
75 return std::unique_ptr<AEAD_Mode>();
76
77 std::ostringstream alg_args;
78
79 alg_args << '(' << cipher_name;
80 for(size_t i = 1; i < mode_info.size(); ++i)
81 alg_args << ',' << mode_info[i];
82 for(size_t i = 2; i < algo_parts.size(); ++i)
83 alg_args << ',' << algo_parts[i];
84 alg_args << ')';
85
86 const std::string mode_name = mode_info[0] + alg_args.str();
87 return AEAD_Mode::create(mode_name, dir);
88 }
89
90 #if defined(BOTAN_HAS_BLOCK_CIPHER)
91
92 SCAN_Name req(algo);
93
94 if(req.arg_count() == 0)
95 {
96 return std::unique_ptr<AEAD_Mode>();
97 }
98
99 std::unique_ptr<BlockCipher> bc(BlockCipher::create(req.arg(0), provider));
100
101 if(!bc)
102 {
103 return std::unique_ptr<AEAD_Mode>();
104 }
105
106 #if defined(BOTAN_HAS_AEAD_CCM)
107 if(req.algo_name() == "CCM")
108 {
109 size_t tag_len = req.arg_as_integer(1, 16);
110 size_t L_len = req.arg_as_integer(2, 3);
111 if(dir == ENCRYPTION)
112 return std::unique_ptr<AEAD_Mode>(new CCM_Encryption(bc.release(), tag_len, L_len));
113 else
114 return std::unique_ptr<AEAD_Mode>(new CCM_Decryption(bc.release(), tag_len, L_len));
115 }
116 #endif
117
118 #if defined(BOTAN_HAS_AEAD_GCM)
119 if(req.algo_name() == "GCM")
120 {
121 size_t tag_len = req.arg_as_integer(1, 16);
122 if(dir == ENCRYPTION)
123 return std::unique_ptr<AEAD_Mode>(new GCM_Encryption(bc.release(), tag_len));
124 else
125 return std::unique_ptr<AEAD_Mode>(new GCM_Decryption(bc.release(), tag_len));
126 }
127 #endif
128
129 #if defined(BOTAN_HAS_AEAD_OCB)
130 if(req.algo_name() == "OCB")
131 {
132 size_t tag_len = req.arg_as_integer(1, 16);
133 if(dir == ENCRYPTION)
134 return std::unique_ptr<AEAD_Mode>(new OCB_Encryption(bc.release(), tag_len));
135 else
136 return std::unique_ptr<AEAD_Mode>(new OCB_Decryption(bc.release(), tag_len));
137 }
138 #endif
139
140 #if defined(BOTAN_HAS_AEAD_EAX)
141 if(req.algo_name() == "EAX")
142 {
143 size_t tag_len = req.arg_as_integer(1, bc->block_size());
144 if(dir == ENCRYPTION)
145 return std::unique_ptr<AEAD_Mode>(new EAX_Encryption(bc.release(), tag_len));
146 else
147 return std::unique_ptr<AEAD_Mode>(new EAX_Decryption(bc.release(), tag_len));
148 }
149 #endif
150
151 #if defined(BOTAN_HAS_AEAD_SIV)
152 if(req.algo_name() == "SIV")
153 {
154 if(dir == ENCRYPTION)
155 return std::unique_ptr<AEAD_Mode>(new SIV_Encryption(bc.release()));
156 else
157 return std::unique_ptr<AEAD_Mode>(new SIV_Decryption(bc.release()));
158 }
159 #endif
160
161 #endif
162
163 return std::unique_ptr<AEAD_Mode>();
164 }
Botan::split_on
std::vector< std::string > split_on(const std::string &str, char delim)
Definition: parsing.cpp:148
Botan::Cipher_Mode::provider
virtual std::string provider() const
Definition: cipher_mode.h:180
Botan::Usage_Type::ENCRYPTION
Botan::AEAD_Mode::create
static std::unique_ptr< AEAD_Mode > create(const std::string &algo, Cipher_Dir direction, const std::string &provider="")
Definition: aead.cpp:52
Botan::parse_algorithm_name
std::vector< std::string > parse_algorithm_name(const std::string &namex)
Definition: parsing.cpp:95
BOTAN_UNUSED
#define BOTAN_UNUSED(...)
Definition: assert.h:142
Botan::BlockCipher::create
static std::unique_ptr< BlockCipher > create(const std::string &algo_spec, const std::string &provider="")
Definition: block_cipher.cpp:108

std::unique_ptr< AEAD_Mode > Botan::AEAD_Mode::create_or_throw | ( | const std::string & | algo,
|  | Cipher_Dir | direction,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

Create an AEAD mode, or throw

Parameters

  algo | the algorithm to create
  direction | specify if this should be an encryption or decryption AEAD
  provider | optional specification for provider to use

Returns
  an AEAD mode, or throw an exception

Definition at line 42 of file aead.cpp.

References Botan::AEAD_Mode::create().

Referenced by Botan::TLS::Connection_Cipher_State::Connection_Cipher_State(), Botan::TLS::Session::decrypt(), Botan::TLS::Session::encrypt(), Botan::mceies_decrypt(), and Botan::mceies_encrypt().

45 {
46 if(auto aead = AEAD_Mode::create(algo, dir, provider))
47 return aead;
48
49 throw Lookup_Error("AEAD", algo, provider);
50 }
Botan::Cipher_Mode::provider
virtual std::string provider() const
Definition: cipher_mode.h:180
Botan::AEAD_Mode::create
static std::unique_ptr< AEAD_Mode > create(const std::string &algo, Cipher_Dir direction, const std::string &provider="")
Definition: aead.cpp:52

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::default_nonce_length | ( |  | ) | const
| inline final override virtual

Returns
  default AEAD nonce size (a commonly supported value among AEAD modes, and large enough that random collisions are unlikely)

Reimplemented from Botan::AEAD_Mode.

Definition at line 42 of file tls_cbc.h.

42 { return m_iv_size; }

virtual void Botan::Cipher_Mode::finish | ( | secure_vector< uint8_t > & | final_block,
|  | size_t | offset = `0`
| ) |  |
| pure virtual inherited

Complete processing of a message.

Parameters

  final_block | in/out parameter which must be at least minimum_final_size() bytes, and will be set to any final output
  offset | an offset into final_block to begin processing

Implemented in Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption, Botan::CTS_Decryption, Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption, Botan::OCB_Decryption, Botan::CBC_Decryption, Botan::CCM_Decryption, Botan::EAX_Decryption, Botan::SIV_Decryption, Botan::GCM_Decryption, Botan::OCB_Encryption, Botan::CTS_Encryption, Botan::CFB_Decryption, Botan::ChaCha20Poly1305_Decryption, Botan::XTS_Decryption, Botan::SIV_Encryption, Botan::CCM_Encryption, Botan::EAX_Encryption, Botan::GCM_Encryption, Botan::CBC_Encryption, Botan::CFB_Encryption, Botan::ChaCha20Poly1305_Encryption, and Botan::XTS_Encryption.

Referenced by botan_cipher_update(), and Botan::TLS::write_record().

bool Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::is_datagram_protocol | ( |  | ) | const
| inline protected

Definition at line 64 of file tls_cbc.h.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish().

64 { return m_is_datagram; }

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::iv_size | ( |  | ) | const
| inline protected

Definition at line 59 of file tls_cbc.h.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data(), and valid_nonce_length().

59 { return m_iv_size; }

Key_Length_Specification Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::key_spec | ( |  | ) | const
| final override virtual

Returns
  object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 86 of file tls_cbc.cpp.

87 {
88 return Key_Length_Specification(m_cipher_keylen + m_mac_keylen);
89 }

MessageAuthenticationCode& Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::mac | ( |  | ) | const
| inline protected

Definition at line 68 of file tls_cbc.h.

References BOTAN_ASSERT_NONNULL.

Referenced by clear(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish().

69 {
70 BOTAN_ASSERT_NONNULL(m_mac);
71 return *m_mac;
72 }
BOTAN_ASSERT_NONNULL
#define BOTAN_ASSERT_NONNULL(ptr)
Definition: assert.h:107

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::mac_keylen | ( |  | ) | const
| inline protected

Definition at line 58 of file tls_cbc.h.

58 { return m_mac_keylen; }

size_t Botan::SymmetricAlgorithm::maximum_keylength | ( |  | ) | const
| inline inherited

Returns
  minimum allowed key length

Definition at line 38 of file sym_algo.h.

39 {
40 return key_spec().maximum_keylength();
41 }
Botan::Key_Length_Specification::maximum_keylength
size_t maximum_keylength() const
Definition: key_spec.h:69
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

virtual size_t Botan::Cipher_Mode::minimum_final_size | ( |  | ) | const
| pure virtual inherited

Returns
  required minimium size to finalize() - may be any length larger than this.

Implemented in Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption, Botan::CTS_Decryption, Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption, Botan::CBC_Decryption, Botan::OCB_Decryption, Botan::CCM_Decryption, Botan::SIV_Decryption, Botan::EAX_Decryption, Botan::GCM_Decryption, Botan::CTS_Encryption, Botan::OCB_Encryption, Botan::SIV_Encryption, Botan::CCM_Encryption, Botan::ChaCha20Poly1305_Decryption, Botan::CBC_Encryption, Botan::EAX_Encryption, Botan::GCM_Encryption, Botan::ChaCha20Poly1305_Encryption, Botan::CFB_Mode, and Botan::XTS_Mode.

Referenced by botan_cipher_update().

size_t Botan::SymmetricAlgorithm::minimum_keylength | ( |  | ) | const
| inline inherited

Returns
  maximum allowed key length

Definition at line 46 of file sym_algo.h.

Referenced by botan_block_cipher_get_keyspec(), and botan_mac_get_keyspec().

47 {
48 return key_spec().minimum_keylength();
49 }
Botan::Key_Length_Specification::minimum_keylength
size_t minimum_keylength() const
Definition: key_spec.h:61
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

secure_vector<uint8_t>& Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::msg | ( |  | ) |
| inline protected

Definition at line 76 of file tls_cbc.h.

References m_msg.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish().

76 { return m_msg; }

std::string Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::name | ( |  | ) | const
| final override virtual

Returns
  the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 69 of file tls_cbc.cpp.

70 {
71 return "TLS_CBC(" + m_cipher_name + "," + m_mac_name + ")";
72 }

virtual size_t Botan::Cipher_Mode::output_length | ( | size_t | input_length | ) | const
| pure virtual inherited

Returns the size of the output if this transform is used to process a message with input_length bytes. In most cases the answer is precise. If it is not possible to precise (namely for CBC decryption) instead a lower bound is returned.

Implemented in Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption, Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption, Botan::CBC_Decryption, Botan::OCB_Decryption, Botan::CCM_Decryption, Botan::SIV_Decryption, Botan::EAX_Decryption, Botan::GCM_Decryption, Botan::CTS_Encryption, Botan::OCB_Encryption, Botan::XTS_Decryption, Botan::SIV_Encryption, Botan::CCM_Encryption, Botan::ChaCha20Poly1305_Decryption, Botan::CBC_Encryption, Botan::EAX_Encryption, Botan::XTS_Encryption, Botan::GCM_Encryption, Botan::ChaCha20Poly1305_Encryption, and Botan::CFB_Mode.

Referenced by botan_cipher_output_length(), and Botan::TLS::write_record().

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::process | ( | uint8_t | msg[],
|  | size_t | msg_len
| ) |  |
| final override virtual

Process message blocks

Input must be a multiple of update_granularity

Processes msg in place and returns bytes written. Normally this will be either msg_len (indicating the entire message was processed) or for certain AEAD modes zero (indicating that the mode requires the entire message be processed in one pass).

Parameters

  msg | the message to be processed
  msg_len | length of the message in bytes

Implements Botan::Cipher_Mode.

Definition at line 117 of file tls_cbc.cpp.

118 {
119 m_msg.insert(m_msg.end(), buf, buf + sz);
120 return 0;
121 }

virtual std::string Botan::Cipher_Mode::provider | ( |  | ) | const
| inline virtual inherited

Returns
  provider information about this implementation. Default is "base", might also return "sse2", "avx2", "openssl", or some other arbitrary string.

Reimplemented in Botan::GCM_Mode.

Definition at line 180 of file cipher_mode.h.

Referenced by Botan::AEAD_Mode::create(), and Botan::Cipher_Mode::create().

180 { return "base"; }

std::vector< std::string > Botan::Cipher_Mode::providers | ( | const std::string & | algo_spec | ) |
| static inherited

Returns
  list of available providers for this algorithm, empty if not available

Parameters

  algo_spec | algorithm name

Definition at line 190 of file cipher_mode.cpp.

References Botan::Cipher_Mode::create(), and Botan::ENCRYPTION.

191 {
192 const std::vector<std::string>& possible = { "base", "openssl", "commoncrypto" };
193 std::vector<std::string> providers;
194 for(auto&& prov : possible)
195 {
196 std::unique_ptr<Cipher_Mode> mode = Cipher_Mode::create(algo_spec, ENCRYPTION, prov);
197 if(mode)
198 {
199 providers.push_back(prov); // available
200 }
201 }
202 return providers;
203 }
Botan::Usage_Type::ENCRYPTION
Botan::Cipher_Mode::create
static std::unique_ptr< Cipher_Mode > create(const std::string &algo, Cipher_Dir direction, const std::string &provider="")
Definition: cipher_mode.cpp:54
Botan::Cipher_Mode::providers
static std::vector< std::string > providers(const std::string &algo_spec)
Definition: cipher_mode.cpp:190

void Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::reset | ( |  | ) |
| final override virtual

Resets just the message specific state and allows encrypting again under the existing key

Implements Botan::Cipher_Mode.

Definition at line 62 of file tls_cbc.cpp.

References cbc_state().

Referenced by clear().

63 {
64 cbc_state().clear();
65 m_ad.clear();
66 m_msg.clear();
67 }
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::cbc_state
secure_vector< uint8_t > & cbc_state()
Definition: tls_cbc.h:74
template<typename Alloc >

void Botan::AEAD_Mode::set_ad | ( | const std::vector< uint8_t, Alloc > & | ad | ) |
| inline inherited

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

See set_associated_data().

Parameters

  ad | the associated data

Definition at line 95 of file aead.h.

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

96 {
97 set_associated_data(ad.data(), ad.size());
98 }
Botan::AEAD_Mode::set_associated_data
virtual void set_associated_data(const uint8_t ad[], size_t ad_len)=0

void Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::set_associated_data | ( | const uint8_t | ad[],
|  | size_t | ad_len
| ) |  |
| override virtual

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

Unless reset by another call, the associated data is kept between messages. Thus, if the AD does not change, calling once (after set_key) is the optimum.

Parameters

  ad | the associated data
  ad_len | length of add in bytes

Implements Botan::AEAD_Mode.

Reimplemented in Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption.

Definition at line 132 of file tls_cbc.cpp.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data().

133 {
134 if(ad_len != 13)
135 throw Invalid_Argument("Invalid TLS AEAD associated data length");
136 m_ad.assign(ad, ad + ad_len);
137 }
template<typename Alloc >

void Botan::AEAD_Mode::set_associated_data_vec | ( | const std::vector< uint8_t, Alloc > & | ad | ) |
| inline inherited

Set associated data that is not included in the ciphertext but that should be authenticated. Must be called after set_key and before start.

See set_associated_data().

Parameters

  ad | the associated data

Definition at line 80 of file aead.h.

81 {
82 set_associated_data(ad.data(), ad.size());
83 }
Botan::AEAD_Mode::set_associated_data
virtual void set_associated_data(const uint8_t ad[], size_t ad_len)=0

void Botan::SymmetricAlgorithm::set_key | ( | const SymmetricKey & | key | ) |
| inline inherited

Set the symmetric key of this object.

Parameters

  key | the SymmetricKey to be set.

Definition at line 65 of file sym_algo.h.

References Botan::OctetString::begin(), and Botan::OctetString::length().

Referenced by Botan::aont_package(), Botan::aont_unpackage(), botan_block_cipher_set_key(), botan_cipher_set_key(), botan_mac_set_key(), Botan::Sodium::crypto_stream_salsa20(), Botan::Sodium::crypto_stream_salsa20_xor_ic(), Botan::Sodium::crypto_stream_xsalsa20(), Botan::Sodium::crypto_stream_xsalsa20_xor_ic(), Botan::FPE::fe1_decrypt(), Botan::FPE::fe1_encrypt(), and Botan::Sodium::randombytes_buf_deterministic().

66 {
67 set_key(key.begin(), key.length());
68 }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:65
template<typename Alloc >

void Botan::SymmetricAlgorithm::set_key | ( | const std::vector< uint8_t, Alloc > & | key | ) |
| inline inherited

Definition at line 71 of file sym_algo.h.

72 {
73 set_key(key.data(), key.size());
74 }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:65

void Botan::SymmetricAlgorithm::set_key | ( | const uint8_t | key[],
|  | size_t | length
| ) |  |
| inherited

Set the symmetric key of this object.

Parameters

  key | the to be set as a byte array.
  length | in bytes of key param

Definition at line 17 of file sym_algo.cpp.

References Botan::SymmetricAlgorithm::name(), and Botan::SymmetricAlgorithm::valid_keylength().

18 {
19 if(!valid_keylength(length))
20 throw Invalid_Key_Length(name(), length);
21 key_schedule(key, length);
22 }
Botan::SymmetricAlgorithm::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:56
Botan::SymmetricAlgorithm::name
virtual std::string name() const =0
template<typename Alloc >

void Botan::Cipher_Mode::start | ( | const std::vector< uint8_t, Alloc > & | nonce | ) |
| inline inherited

Begin processing a message.

Parameters

  nonce | the per message nonce

Definition at line 69 of file cipher_mode.h.

Referenced by botan_cipher_start(), and Botan::TLS::write_record().

70 {
71 start_msg(nonce.data(), nonce.size());
72 }
Botan::Cipher_Mode::start_msg
virtual void start_msg(const uint8_t nonce[], size_t nonce_len)=0

void Botan::Cipher_Mode::start | ( | const uint8_t | nonce[],
|  | size_t | nonce_len
| ) |  |
| inline inherited

Begin processing a message.

Parameters

  nonce | the per message nonce
  nonce_len | length of nonce

Definition at line 79 of file cipher_mode.h.

80 {
81 start_msg(nonce, nonce_len);
82 }
Botan::Cipher_Mode::start_msg
virtual void start_msg(const uint8_t nonce[], size_t nonce_len)=0

void Botan::Cipher_Mode::start | ( |  | ) |
| inline inherited

Begin processing a message.

Definition at line 87 of file cipher_mode.h.

88 {
89 return start_msg(nullptr, 0);
90 }
Botan::Cipher_Mode::start_msg
virtual void start_msg(const uint8_t nonce[], size_t nonce_len)=0

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::tag_size | ( |  | ) | const
| inline final override virtual

Returns
  the size of the authentication tag used (in bytes)

Reimplemented from Botan::Cipher_Mode.

Definition at line 40 of file tls_cbc.h.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::output_length().

40 { return m_tag_size; }

void Botan::Cipher_Mode::update | ( | secure_vector< uint8_t > & | buffer,
|  | size_t | offset = `0`
| ) |  |
| inline inherited

Process some data. Input must be in size update_granularity() uint8_t blocks.

Parameters

  buffer | in/out parameter which will possibly be resized
  offset | an offset into blocks to begin processing

Definition at line 112 of file cipher_mode.h.

References BOTAN_ASSERT.

Referenced by botan_cipher_update(), Botan::XTS_Encryption::finish(), Botan::ChaCha20Poly1305_Encryption::finish(), Botan::CFB_Encryption::finish(), Botan::CBC_Encryption::finish(), Botan::EAX_Encryption::finish(), Botan::XTS_Decryption::finish(), Botan::CFB_Decryption::finish(), Botan::CTS_Encryption::finish(), Botan::CBC_Decryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::CTS_Decryption::finish(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish().

113 {
114 BOTAN_ASSERT(buffer.size() >= offset, "Offset ok");
115 uint8_t* buf = buffer.data() + offset;
116 const size_t buf_size = buffer.size() - offset;
117
118 const size_t written = process(buf, buf_size);
119 buffer.resize(offset + written);
120 }
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:55
Botan::Cipher_Mode::process
virtual size_t process(uint8_t msg[], size_t msg_len)=0

size_t Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::update_granularity | ( |  | ) | const
| final override virtual

Returns
  size of required blocks to update

Implements Botan::Cipher_Mode.

Definition at line 74 of file tls_cbc.cpp.

75 {
76 return 1; // just buffers anyway
77 }

bool Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::use_encrypt_then_mac | ( |  | ) | const
| inline protected

Definition at line 62 of file tls_cbc.h.

Referenced by Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::output_length(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data().

62 { return m_use_encrypt_then_mac; }

bool Botan::SymmetricAlgorithm::valid_keylength | ( | size_t | length | ) | const
| inline inherited

Check whether a given key length is valid for this algorithm.

Parameters

  length | the key length to be checked.

Returns
  true if the key length is valid.

Definition at line 56 of file sym_algo.h.

Referenced by Botan::aont_package(), Botan::aont_unpackage(), and Botan::SymmetricAlgorithm::set_key().

57 {
58 return key_spec().valid_keylength(length);
59 }
Botan::Key_Length_Specification::valid_keylength
bool valid_keylength(size_t length) const
Definition: key_spec.h:51
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

bool Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::valid_nonce_length | ( | size_t | nonce_len | ) | const
| final override virtual

Returns
  true iff nonce_len is a valid length for the nonce

Implements Botan::Cipher_Mode.

Definition at line 79 of file tls_cbc.cpp.

References block_size(), and iv_size().

80 {
81 if(m_cbc_state.empty())
82 return nl == block_size();
83 return nl == iv_size();
84 }
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::block_size
size_t block_size() const
Definition: tls_cbc.h:60
Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::iv_size
size_t iv_size() const
Definition: tls_cbc.h:59

void Botan::SymmetricAlgorithm::verify_key_set | ( | bool | cond | ) | const
| inline protected inherited

Definition at line 89 of file sym_algo.h.

Referenced by Botan::Salsa20::cipher(), Botan::CTR_BE::cipher(), Botan::RC4::cipher(), Botan::SHAKE_128_Cipher::cipher(), Botan::ChaCha::cipher(), Botan::DESX::decrypt_n(), Botan::DES::decrypt_n(), Botan::Blowfish::decrypt_n(), Botan::KASUMI::decrypt_n(), Botan::MISTY1::decrypt_n(), Botan::Noekeon::decrypt_n(), Botan::CAST_256::decrypt_n(), Botan::Camellia_128::decrypt_n(), Botan::AES_128::decrypt_n(), Botan::SM4::decrypt_n(), Botan::SEED::decrypt_n(), Botan::XTEA::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::CAST_128::decrypt_n(), Botan::SHACAL2::decrypt_n(), Botan::IDEA::decrypt_n(), Botan::Serpent::decrypt_n(), Botan::Threefish_512::decrypt_n(), Botan::Lion::decrypt_n(), Botan::ARIA_128::decrypt_n(), Botan::Camellia_192::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::ARIA_192::decrypt_n(), Botan::Camellia_256::decrypt_n(), Botan::GOST_28147_89::decrypt_n(), Botan::AES_192::decrypt_n(), Botan::ARIA_256::decrypt_n(), Botan::AES_256::decrypt_n(), Botan::SHACAL2::encrypt_n(), Botan::SM4::encrypt_n(), Botan::IDEA::encrypt_n(), Botan::KASUMI::encrypt_n(), Botan::AES_128::encrypt_n(), Botan::MISTY1::encrypt_n(), Botan::Noekeon::encrypt_n(), Botan::CAST_128::encrypt_n(), Botan::SEED::encrypt_n(), Botan::CAST_256::encrypt_n(), Botan::DES::encrypt_n(), Botan::Blowfish::encrypt_n(), Botan::Twofish::encrypt_n(), Botan::DESX::encrypt_n(), Botan::Camellia_128::encrypt_n(), Botan::XTEA::encrypt_n(), Botan::Threefish_512::encrypt_n(), Botan::Serpent::encrypt_n(), Botan::Lion::encrypt_n(), Botan::ARIA_128::encrypt_n(), Botan::Camellia_192::encrypt_n(), Botan::TripleDES::encrypt_n(), Botan::ARIA_192::encrypt_n(), Botan::Camellia_256::encrypt_n(), Botan::GOST_28147_89::encrypt_n(), Botan::AES_192::encrypt_n(), Botan::ARIA_256::encrypt_n(), Botan::AES_256::encrypt_n(), Botan::OCB_Encryption::finish(), Botan::OCB_Decryption::finish(), Botan::GHASH::ghash_update(), Botan::CFB_Encryption::process(), Botan::CFB_Decryption::process(), Botan::Salsa20::seek(), Botan::CTR_BE::seek(), Botan::ChaCha::seek(), Botan::OCB_Mode::set_associated_data(), Botan::Salsa20::set_iv(), Botan::ChaCha::set_iv(), Botan::GHASH::update(), Botan::GHASH::update_associated_data(), and Botan::ChaCha::write_keystream().

90 {
91 if(cond == false)
92 throw_key_not_set_error();
93 }

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

- src/lib/tls/tls_cbc/tls_cbc.h
- src/lib/tls/tls_cbc/tls_cbc.cpp