Botan 3.14.1
Crypto and TLS for C&
Botan::TLS::TLS_NULL_HMAC_AEAD_Mode Class Referenceabstract

#include <tls_null.h>

Inheritance diagram for Botan::TLS::TLS_NULL_HMAC_AEAD_Mode:
Botan::AEAD_Mode Botan::Cipher_Mode Botan::SymmetricAlgorithm Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption Botan::TLS::TLS_NULL_HMAC_AEAD_Encryption

Public Member Functions

virtual bool associated_data_requires_key () const
bool authenticated () const
void clear () final
size_t default_nonce_length () const override
void finish (secure_vector< uint8_t > &final_block, size_t offset=0)
template<concepts::resizable_byte_buffer T>
void finish (T &final_block, size_t offset=0)
bool has_keying_material () const final
size_t ideal_granularity () const final
Key_Length_Specification key_spec () const final
virtual size_t maximum_associated_data_inputs () const
size_t maximum_keylength () const
virtual size_t minimum_final_size () const =0
size_t minimum_keylength () const
std::string name () const final
virtual size_t output_length (size_t input_length) const =0
size_t process (std::span< uint8_t > msg)
size_t process (uint8_t msg[], size_t msg_len)
virtual std::string provider () const
virtual bool requires_entire_message () const
void reset () final
void set_ad (std::span< const uint8_t > ad)
void set_associated_data (const uint8_t ad[], size_t ad_len)
void set_associated_data (std::span< const uint8_t > ad)
void set_associated_data_n (size_t idx, std::span< const uint8_t > ad) override
template<typename Alloc>
void set_associated_data_vec (const std::vector< uint8_t, Alloc > &ad)
void set_key (const OctetString &key)
void set_key (const uint8_t key[], size_t length)
void set_key (std::span< const uint8_t > key)
void start ()
void start (const uint8_t nonce[], size_t nonce_len)
void start (std::span< const uint8_t > nonce)
size_t tag_size () const final
template<concepts::resizable_byte_buffer T>
void update (T &buffer, size_t offset=0)
size_t update_granularity () const final
bool valid_keylength (size_t length) const
bool valid_nonce_length (size_t nl) const final

Static Public Member Functions

static std::unique_ptr< AEAD_Mode > create (std::string_view algo, Cipher_Dir direction, std::string_view provider="")
static std::unique_ptr< AEAD_Mode > create_or_throw (std::string_view algo, Cipher_Dir direction, std::string_view provider="")
static std::vector< std::string > providers (std::string_view algo_spec)

Protected Member Functions

void assert_key_material_set () const
void assert_key_material_set (bool predicate) const
virtual void finish_msg (secure_vector< uint8_t > &final_block, size_t offset=0)=0
MessageAuthenticationCode & mac () const
size_t mac_keylen () const
 TLS_NULL_HMAC_AEAD_Mode (std::unique_ptr< MessageAuthenticationCode > mac, size_t mac_keylen)

Detailed Description

TLS NULL+HMAC AEAD base class (GenericStreamCipher in TLS spec)

Definition at line 20 of file tls_null.h.

Constructor & Destructor Documentation

◆ TLS_NULL_HMAC_AEAD_Mode()

Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::TLS_NULL_HMAC_AEAD_Mode ( std::unique_ptr< MessageAuthenticationCode > mac,
size_t mac_keylen )
protected

Definition at line 23 of file tls_null.cpp.

23 :
24 m_mac_name(mac->name()), m_mac_keylen(mac_keylen), m_tag_size(mac->output_length()), m_mac(std::move(mac)) {
25 // An empty m_key means that no key was set
26 BOTAN_ARG_CHECK(m_mac_keylen > 0, "TLS 1.2 NULL/HMAC: MAC key length must not be zero");
27}
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33
MessageAuthenticationCode & mac() const
Definition tls_null.cpp:72

References BOTAN_ARG_CHECK, mac(), mac_keylen(), name(), and Botan::Cipher_Mode::output_length().

Referenced by Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption::TLS_NULL_HMAC_AEAD_Decryption(), and Botan::TLS::TLS_NULL_HMAC_AEAD_Encryption::TLS_NULL_HMAC_AEAD_Encryption().

Member Function Documentation

◆ assert_key_material_set() [1/2]

◆ assert_key_material_set() [2/2]

void Botan::SymmetricAlgorithm::assert_key_material_set ( bool predicate) const
inlineprotectedinherited

Throw Key_Not_Set unless the predicate holds

Parameters
predicateif false, a Key_Not_Set exception is thrown

Definition at line 186 of file sym_algo.h.

186 {
187 if(!predicate) {
188 throw_key_not_set_error();
189 }
190 }

◆ associated_data_requires_key()

virtual bool Botan::AEAD_Mode::associated_data_requires_key ( ) const
inlinevirtualinherited

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::Ascon_AEAD128_Mode, Botan::CCM_Mode, Botan::ChaCha20Poly1305_Mode, and Botan::GCM_SIV_Mode.

Definition at line 106 of file aead.h.

106{ return true; }

◆ authenticated()

bool Botan::Cipher_Mode::authenticated ( ) const
inlineinherited

Return the length in bytes of the authentication tag this algorithm generates. If the mode is not authenticated, this will return 0.

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

Definition at line 272 of file cipher_mode.h.

272{ return this->tag_size() > 0; }
virtual size_t tag_size() const

References tag_size().

◆ clear()

void Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::clear ( )
finalvirtual

Reset the internal state. This includes not just the key, but any partial message that may have been in process.

Implements Botan::SymmetricAlgorithm.

Definition at line 29 of file tls_null.cpp.

29 {
30 m_key.clear();
31 m_ad.clear();
32 mac().clear();
33}
virtual void clear()=0

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

◆ create()

std::unique_ptr< AEAD_Mode > Botan::AEAD_Mode::create ( std::string_view algo,
Cipher_Dir direction,
std::string_view provider = "" )
staticinherited

Create an AEAD mode

Parameters
algothe algorithm to create
directionspecify if this should be an encryption or decryption AEAD
provideroptional specification for provider to use
Returns
an AEAD mode or a null pointer if not available

Definition at line 61 of file aead.cpp.

61 {
63#if defined(BOTAN_HAS_AEAD_CHACHA20_POLY1305)
64 if(algo == "ChaCha20Poly1305") {
65 if(dir == Cipher_Dir::Encryption) {
66 return std::make_unique<ChaCha20Poly1305_Encryption>();
67 } else {
68 return std::make_unique<ChaCha20Poly1305_Decryption>();
69 }
70 }
71#endif
72
73#if defined(BOTAN_HAS_ASCON_AEAD128)
74 if(algo == "Ascon-AEAD128") {
75 if(dir == Cipher_Dir::Encryption) {
76 return std::make_unique<Ascon_AEAD128_Encryption>();
77 } else {
78 return std::make_unique<Ascon_AEAD128_Decryption>();
79 }
80 }
81#endif
82
83#if defined(BOTAN_HAS_BLOCK_CIPHER)
84 const AlgorithmSpec req(algo, AlgorithmSpec::Syntax::CipherMode);
85
86 #if defined(BOTAN_HAS_AEAD_CCM)
87 if(auto m = req.match("CCM({cipher},{tag_len:int=16},{L:int=3})")) {
88 if(auto bc = BlockCipher::create(m->str("cipher"), provider)) {
89 const size_t tag_len = m->integer("tag_len");
90 const size_t L_len = m->integer("L");
91 if(dir == Cipher_Dir::Encryption) {
92 return std::make_unique<CCM_Encryption>(std::move(bc), tag_len, L_len);
93 } else {
94 return std::make_unique<CCM_Decryption>(std::move(bc), tag_len, L_len);
95 }
96 }
97 }
98 #endif
99
100 #if defined(BOTAN_HAS_AEAD_GCM)
101 if(auto m = req.match("GCM({cipher},{tag_len:int=16})")) {
102 if(auto bc = BlockCipher::create(m->str("cipher"), provider)) {
103 const size_t tag_len = m->integer("tag_len");
104 if(dir == Cipher_Dir::Encryption) {
105 return std::make_unique<GCM_Encryption>(std::move(bc), tag_len);
106 } else {
107 return std::make_unique<GCM_Decryption>(std::move(bc), tag_len);
108 }
109 }
110 }
111 #endif
112
113 #if defined(BOTAN_HAS_AEAD_GCM_SIV)
114 // Unlike GCM the tag length is fixed, so reject eg "AES-128/GCM-SIV(12)"
115 if(auto m = req.match("GCM-SIV({cipher})")) {
116 if(auto bc = BlockCipher::create(m->str("cipher"), provider)) {
117 if(dir == Cipher_Dir::Encryption) {
118 return std::make_unique<GCM_SIV_Encryption>(std::move(bc));
119 } else {
120 return std::make_unique<GCM_SIV_Decryption>(std::move(bc));
121 }
122 }
123 }
124 #endif
125
126 #if defined(BOTAN_HAS_AEAD_OCB)
127 if(auto m = req.match("OCB({cipher},{tag_len:int=16})")) {
128 if(auto bc = BlockCipher::create(m->str("cipher"), provider)) {
129 const size_t tag_len = m->integer("tag_len");
130 if(dir == Cipher_Dir::Encryption) {
131 return std::make_unique<OCB_Encryption>(std::move(bc), tag_len);
132 } else {
133 return std::make_unique<OCB_Decryption>(std::move(bc), tag_len);
134 }
135 }
136 }
137 #endif
138
139 #if defined(BOTAN_HAS_AEAD_EAX)
140 if(auto m = req.match("EAX({cipher},{tag_len:int?})")) {
141 if(auto bc = BlockCipher::create(m->str("cipher"), provider)) {
142 const size_t tag_len = m->has("tag_len") ? m->integer("tag_len") : bc->block_size();
143 if(dir == Cipher_Dir::Encryption) {
144 return std::make_unique<EAX_Encryption>(std::move(bc), tag_len);
145 } else {
146 return std::make_unique<EAX_Decryption>(std::move(bc), tag_len);
147 }
148 }
149 }
150 #endif
151
152 #if defined(BOTAN_HAS_AEAD_SIV)
153 if(auto m = req.match("SIV({cipher})")) {
154 if(auto bc = BlockCipher::create(m->str("cipher"), provider)) {
155 if(dir == Cipher_Dir::Encryption) {
156 return std::make_unique<SIV_Encryption>(std::move(bc));
157 } else {
158 return std::make_unique<SIV_Decryption>(std::move(bc));
159 }
160 }
161 }
162 #endif
163
164 BOTAN_UNUSED(req);
165#endif
166
167 return std::unique_ptr<AEAD_Mode>();
168}
#define BOTAN_UNUSED
Definition assert.h:151
static std::unique_ptr< BlockCipher > create(std::string_view algo_spec, std::string_view provider="")
virtual std::string provider() const

References BOTAN_UNUSED, Botan::AlgorithmSpec::CipherMode, Botan::BlockCipher::create(), Botan::Encryption, Botan::AlgorithmSpec::match(), and Botan::Cipher_Mode::provider().

Referenced by Botan::ChaCha20Poly1305_Mode::ChaCha20Poly1305_Mode(), Botan::Cipher_Mode::create(), create_or_throw(), Botan::get_aead(), Botan::HPKE::AEAD_Id::is_available(), and Botan::TLS::Cipher_State::is_compatible_with().

◆ create_or_throw()

std::unique_ptr< AEAD_Mode > Botan::AEAD_Mode::create_or_throw ( std::string_view algo,
Cipher_Dir direction,
std::string_view provider = "" )
staticinherited

Create an AEAD mode, or throw

Parameters
algothe algorithm to create
directionspecify if this should be an encryption or decryption AEAD
provideroptional specification for provider to use
Returns
an AEAD mode, or throw an exception

Definition at line 51 of file aead.cpp.

53 {
54 if(auto aead = AEAD_Mode::create(algo, dir, provider)) {
55 return aead;
56 }
57
58 throw Lookup_Error("AEAD", algo, provider);
59}
static std::unique_ptr< AEAD_Mode > create(std::string_view algo, Cipher_Dir direction, std::string_view provider="")
Definition aead.cpp:61

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

Referenced by Botan::TLS::Connection_Cipher_State::Connection_Cipher_State(), Botan::TLS::Cipher_State::create_epoch(), Botan::TLS::Session::decrypt(), and Botan::TLS::Session::encrypt().

◆ default_nonce_length()

size_t Botan::AEAD_Mode::default_nonce_length ( ) const
inlineoverridevirtualinherited

Return the default nonce length for this mode

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

Implements Botan::Cipher_Mode.

Reimplemented in Botan::Ascon_AEAD128_Mode, Botan::CCM_Mode, and Botan::TLS::TLS_CBC_HMAC_AEAD_Mode.

Definition at line 139 of file aead.h.

139{ return 12; }

◆ finish() [1/2]

void Botan::Cipher_Mode::finish ( secure_vector< uint8_t > & final_block,
size_t offset = 0 )
inlineinherited

Complete procession of a message with a final input of buffer, which is treated the same as with update(). If you have the entire message in hand, calling finish() without ever calling update() is both efficient and convenient.

When using an AEAD_Mode, if the supplied authentication tag does not validate, this will throw an instance of Invalid_Authentication_Tag.

If this occurs, all plaintext previously output via calls to update must be destroyed and not used in any way that an attacker could observe the effects of. This could be anything from echoing the plaintext back (perhaps in an error message), or by making an external RPC whose destination or contents depend on the plaintext. The only thing you can do is buffer it, and in the event of an invalid tag, erase the previously decrypted content from memory.

One simple way to assure this could never happen is to never call update, and instead always marshal the entire message into a single buffer and call finish on it when decrypting.

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

Definition at line 185 of file cipher_mode.h.

185{ finish_msg(final_block, offset); }
virtual void finish_msg(secure_vector< uint8_t > &final_block, size_t offset=0)=0

References finish_msg().

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

◆ finish() [2/2]

template<concepts::resizable_byte_buffer T>
void Botan::Cipher_Mode::finish ( T & final_block,
size_t offset = 0 )
inlineinherited

Complete procession of a message.

Note: Using this overload with anything but a Botan::secure_vector<> is copying the bytes in the in/out buffer.

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

Definition at line 198 of file cipher_mode.h.

198 {
199 Botan::secure_vector<uint8_t> tmp(final_block.begin(), final_block.end());
200 finish_msg(tmp, offset);
201 final_block.resize(tmp.size());
202 std::copy(tmp.begin(), tmp.end(), final_block.begin());
203 }
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128

References finish_msg().

◆ finish_msg()

virtual void Botan::Cipher_Mode::finish_msg ( secure_vector< uint8_t > & final_block,
size_t offset = 0 )
protectedpure virtualinherited

Finish processing a message

Implemented in Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption.

Referenced by finish(), and finish().

◆ has_keying_material()

bool Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::has_keying_material ( ) const
finalvirtual

Test whether a key has been set on this object

Returns
true if a key has been set on this object

Implements Botan::SymmetricAlgorithm.

Definition at line 64 of file tls_null.cpp.

64 {
65 return mac().has_keying_material();
66}

References Botan::SymmetricAlgorithm::has_keying_material(), and mac().

◆ ideal_granularity()

size_t Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::ideal_granularity ( ) const
finalvirtual

Return an ideal granularity. This will be a multiple of the result of update_granularity but may be larger. If so it indicates that better performance may be achieved by providing buffers that are at least that size (due to SIMD execution, etc).

Implements Botan::Cipher_Mode.

Definition at line 52 of file tls_null.cpp.

52 {
53 return 1;
54}

◆ key_spec()

Key_Length_Specification Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::key_spec ( ) const
finalvirtual

Return the key lengths supported by this algorithm

Returns
object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 60 of file tls_null.cpp.

60 {
61 return Key_Length_Specification(m_mac_keylen);
62}

◆ mac()

◆ mac_keylen()

size_t Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::mac_keylen ( ) const
protected

◆ maximum_associated_data_inputs()

virtual size_t Botan::AEAD_Mode::maximum_associated_data_inputs ( ) const
inlinevirtualinherited

Returns the maximum supported number of associated data inputs which can be provided to set_associated_data_n

If returns 0, then no associated data is supported.

Reimplemented in Botan::SIV_Mode.

Definition at line 99 of file aead.h.

99{ return 1; }

◆ maximum_keylength()

size_t Botan::SymmetricAlgorithm::maximum_keylength ( ) const
inlineinherited

Return the largest acceptable key length

Returns
maximum allowed key length

Definition at line 130 of file sym_algo.h.

130{ return key_spec().maximum_keylength(); }
size_t maximum_keylength() const
Definition sym_algo.h:58
virtual Key_Length_Specification key_spec() const =0

References key_spec().

◆ minimum_final_size()

◆ minimum_keylength()

size_t Botan::SymmetricAlgorithm::minimum_keylength ( ) const
inlineinherited

Return the smallest acceptable key length

Returns
minimum allowed key length

Definition at line 136 of file sym_algo.h.

136{ return key_spec().minimum_keylength(); }
size_t minimum_keylength() const
Definition sym_algo.h:52

References key_spec().

◆ name()

std::string Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::name ( ) const
finalvirtual

Return the name of this algorithm

Returns
the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 44 of file tls_null.cpp.

44 {
45 return fmt("TLS_NULL({})", m_mac_name);
46}
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53

References Botan::fmt().

Referenced by TLS_NULL_HMAC_AEAD_Mode().

◆ output_length()

◆ process() [1/2]

size_t Botan::Cipher_Mode::process ( std::span< uint8_t > msg)
inlineinherited

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
msgthe message to be processed
Returns
bytes written in-place

Definition at line 132 of file cipher_mode.h.

132{ return this->process_msg(msg.data(), msg.size()); }
virtual size_t process_msg(uint8_t msg[], size_t msg_len)=0

References process_msg().

Referenced by botan_cipher_update(), Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption::finish_msg(), and update().

◆ process() [2/2]

size_t Botan::Cipher_Mode::process ( uint8_t msg[],
size_t msg_len )
inlineinherited

Process message blocks in place

Parameters
msgthe message to be processed
msg_lenlength of msg in bytes
Returns
bytes written in-place

Definition at line 140 of file cipher_mode.h.

140{ return this->process_msg(msg, msg_len); }

References process_msg().

◆ provider()

virtual std::string Botan::Cipher_Mode::provider ( ) const
inlinevirtualinherited

Return the name of the provider implementing this object

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, and Botan::GCM_SIV_Mode.

Definition at line 285 of file cipher_mode.h.

285{ return "base"; }

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

◆ providers()

std::vector< std::string > Botan::Cipher_Mode::providers ( std::string_view algo_spec)
staticinherited

List the providers available for a given cipher mode

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

Definition at line 140 of file cipher_mode.cpp.

140 {
141 const std::vector<std::string>& possible = {"base", "commoncrypto"};
142 std::vector<std::string> providers;
143 for(auto&& prov : possible) {
144 const auto mode = Cipher_Mode::create(algo_spec, Cipher_Dir::Encryption, prov);
145 if(mode) {
146 providers.push_back(prov); // available
147 }
148 }
149 return providers;
150}
static std::unique_ptr< Cipher_Mode > create(std::string_view algo, Cipher_Dir direction, std::string_view provider="")
static std::vector< std::string > providers(std::string_view algo_spec)

References create(), Botan::Encryption, and providers().

Referenced by providers().

◆ requires_entire_message()

virtual bool Botan::Cipher_Mode::requires_entire_message ( ) const
inlinevirtualinherited

Certain modes require the entire message be available before any processing can occur. For such modes, input will be consumed but not returned, until finish is called, which returns the entire message.

This function returns true if this mode has this style of operation.

Reimplemented in Botan::CCM_Mode, Botan::GCM_SIV_Mode, Botan::SIV_Mode, and Botan::TLS::TLS_CBC_HMAC_AEAD_Mode.

Definition at line 239 of file cipher_mode.h.

239{ return false; }

Referenced by botan_cipher_update().

◆ reset()

void Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::reset ( )
finalvirtual

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

Implements Botan::Cipher_Mode.

Definition at line 35 of file tls_null.cpp.

35 {
36 m_ad.clear();
37 // The base AEAD_Mode contract permits reset() before the first key has
38 // been set; only re-key the MAC if there is a key to re-key with.
39 if(!m_key.empty()) {
40 mac().set_key(m_key);
41 }
42}
void set_key(const OctetString &key)
Definition sym_algo.cpp:14

References mac(), and Botan::SymmetricAlgorithm::set_key().

◆ set_ad()

void Botan::AEAD_Mode::set_ad ( std::span< const uint8_t > ad)
inlineinherited

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
adthe associated data

Definition at line 132 of file aead.h.

132{ set_associated_data(ad); }
void set_associated_data(std::span< const uint8_t > ad)
Definition aead.h:59

References set_ad(), and set_associated_data().

Referenced by set_ad().

◆ set_associated_data() [1/2]

void Botan::AEAD_Mode::set_associated_data ( const uint8_t ad[],
size_t ad_len )
inlineinherited

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

Parameters
adthe associated data
ad_lenlength of ad in bytes

Definition at line 69 of file aead.h.

69{ set_associated_data(std::span(ad, ad_len)); }

References set_associated_data().

Referenced by set_associated_data().

◆ set_associated_data() [2/2]

void Botan::AEAD_Mode::set_associated_data ( std::span< const uint8_t > ad)
inlineinherited

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
adthe associated data

Definition at line 59 of file aead.h.

59{ set_associated_data_n(0, ad); }
virtual void set_associated_data_n(size_t idx, std::span< const uint8_t > ad)=0

References set_associated_data_n().

Referenced by set_ad(), set_associated_data_vec(), and Botan::TLS::write_record().

◆ set_associated_data_n()

void Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::set_associated_data_n ( size_t idx,
std::span< const uint8_t > ad )
overridevirtual

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.

Some AEADs (namely SIV) support multiple AD inputs. For all other modes only nominal AD input 0 is supported; all other values of idx will cause an exception.

Derived AEADs must implement this. For AEADs where maximum_associated_data_inputs() returns 1 (the default), the idx must simply be ignored.

Parameters
idxwhich associated data to set
adthe associated data

Implements Botan::AEAD_Mode.

Definition at line 109 of file tls_null.cpp.

109 {
110 BOTAN_ARG_CHECK(idx == 0, "TLS 1.2 NULL/HMAC: cannot handle non-zero index in set_associated_data_n");
111 BOTAN_ARG_CHECK(ad.size() == 13, "TLS 1.2 NULL/HMAC: invalid TLS AEAD associated data length");
112
113 // Cache the AD; the actual MAC update happens at start_msg so the AD
114 // persists across messages per the AEAD_Mode contract.
115 m_ad.assign(ad.begin(), ad.end());
116}

References BOTAN_ARG_CHECK.

Referenced by Botan::TLS::TLS_NULL_HMAC_AEAD_Encryption::set_associated_data_n().

◆ set_associated_data_vec()

template<typename Alloc>
void Botan::AEAD_Mode::set_associated_data_vec ( const std::vector< uint8_t, Alloc > & ad)
inlineinherited

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
adthe associated data

Definition at line 119 of file aead.h.

119 {
121 }

References set_associated_data(), and set_associated_data_vec().

Referenced by set_associated_data_vec().

◆ set_key() [1/3]

◆ set_key() [2/3]

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

Set the symmetric key of this object.

Parameters
keythe to be set as a byte array.
lengthin bytes of key param

Definition at line 162 of file sym_algo.h.

162{ set_key(std::span{key, length}); }

References set_key().

Referenced by set_key().

◆ set_key() [3/3]

void Botan::SymmetricAlgorithm::set_key ( std::span< const uint8_t > key)
inherited

Set the symmetric key of this object.

Parameters
keythe contiguous byte range to be set.

Definition at line 22 of file sym_algo.cpp.

22 {
23 if(!valid_keylength(key.size())) {
24 throw Invalid_Key_Length(name(), key.size());
25 }
26 key_schedule(key);
27}
bool valid_keylength(size_t length) const
Definition sym_algo.h:143
virtual std::string name() const =0

References name(), and valid_keylength().

◆ start() [1/3]

void Botan::Cipher_Mode::start ( )
inlineinherited

Begin processing a message.

The exact semantics of this depend on the mode. For many modes, the call will fail since a nonce must be provided.

For certain modes such as CBC this will instead cause the last ciphertext block to be used as the nonce of the new message; doing this isn't a good idea, but some (mostly older) protocols do this.

Definition at line 117 of file cipher_mode.h.

117{ return start_msg(nullptr, 0); }
virtual void start_msg(const uint8_t nonce[], size_t nonce_len)=0

References start_msg().

◆ start() [2/3]

void Botan::Cipher_Mode::start ( const uint8_t nonce[],
size_t nonce_len )
inlineinherited

Begin processing a message with a fresh nonce.

Parameters
noncethe per message nonce
nonce_lenlength of nonce

Definition at line 105 of file cipher_mode.h.

105{ start_msg(nonce, nonce_len); }

References start_msg().

◆ start() [3/3]

void Botan::Cipher_Mode::start ( std::span< const uint8_t > nonce)
inlineinherited

Begin processing a message with a fresh nonce.

Warning
Typically one must not reuse the same nonce for more than one message under the same key. For most cipher modes this would mean total loss of security and/or authenticity guarantees.
Note
If reliably generating unique nonces is difficult in your environment, use SIV which retains security even if nonces are repeated.
Parameters
noncethe per message nonce

Definition at line 98 of file cipher_mode.h.

98{ start_msg(nonce.data(), nonce.size()); }

References start_msg().

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

◆ tag_size()

size_t Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::tag_size ( ) const
inlinefinalvirtual

Return the authentication tag length of this mode

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

Reimplemented from Botan::Cipher_Mode.

Definition at line 34 of file tls_null.h.

34{ return m_tag_size; }

Referenced by Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption::finish_msg(), Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption::minimum_final_size(), Botan::TLS::TLS_NULL_HMAC_AEAD_Decryption::output_length(), and Botan::TLS::TLS_NULL_HMAC_AEAD_Encryption::output_length().

◆ update()

template<concepts::resizable_byte_buffer T>
void Botan::Cipher_Mode::update ( T & buffer,
size_t offset = 0 )
inlineinherited

Process some data. Input must be in size update_granularity() uint8_t blocks. The buffer is an in/out parameter and may be resized. In particular, some modes require that all input be consumed before any output is produced; with these modes, buffer will be returned empty.

The first offset bytes of buffer will be ignored (this allows in place processing of a buffer that contains an initial plaintext header).

Parameters
bufferin/out parameter which will possibly be resized
offsetan offset into blocks to begin processing

Definition at line 155 of file cipher_mode.h.

155 {
156 const size_t written = process(std::span(buffer).subspan(offset));
157 buffer.resize(offset + written);
158 }
size_t process(std::span< uint8_t > msg)

References process().

◆ update_granularity()

size_t Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::update_granularity ( ) const
finalvirtual

The :cpp:class:Cipher_Mode interface requires message processing in multiples of the block size. This returns size of required blocks to update. If the mode implementation does not require buffering it will return 1.

Returns
size of required blocks to update

Implements Botan::Cipher_Mode.

Definition at line 48 of file tls_null.cpp.

48 {
49 return 1;
50}

◆ valid_keylength()

bool Botan::SymmetricAlgorithm::valid_keylength ( size_t length) const
inlineinherited

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

Parameters
lengththe key length to be checked.
Returns
true if the key length is valid.

Definition at line 143 of file sym_algo.h.

143{ return key_spec().valid_keylength(length); }
bool valid_keylength(size_t length) const
Definition sym_algo.h:44

References key_spec().

Referenced by set_key().

◆ valid_nonce_length()

bool Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::valid_nonce_length ( size_t nonce_len) const
finalvirtual

Test if a nonce length is valid for this mode

Returns
true iff nonce_len is a valid length for the nonce

Implements Botan::Cipher_Mode.

Definition at line 56 of file tls_null.cpp.

56 {
57 return nl == 0;
58}

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