Botan 3.8.1
Crypto and TLS for C&
Botan::Blowfish Class Referencefinal

#include <blowfish.h>

Inheritance diagram for Botan::Blowfish:
Botan::Block_Cipher_Fixed_Params< 8, 1, 56 > Botan::BlockCipher Botan::SymmetricAlgorithm

Public Types

enum  
 

Public Member Functions

size_t block_size () const final
 
void clear () override
 
BlockCipherclone () const
 
void decrypt (const uint8_t in[], uint8_t out[]) const
 
void decrypt (std::span< const uint8_t > in, std::span< uint8_t > out) const
 
void decrypt (std::span< uint8_t > block) const
 
void decrypt (uint8_t block[]) const
 
void decrypt_n (const uint8_t in[], uint8_t out[], size_t blocks) const override
 
void decrypt_n_xex (uint8_t data[], const uint8_t mask[], size_t blocks) const
 
void encrypt (const uint8_t in[], uint8_t out[]) const
 
void encrypt (std::span< const uint8_t > in, std::span< uint8_t > out) const
 
void encrypt (std::span< uint8_t > block) const
 
void encrypt (uint8_t block[]) const
 
void encrypt_n (const uint8_t in[], uint8_t out[], size_t blocks) const override
 
void encrypt_n_xex (uint8_t data[], const uint8_t mask[], size_t blocks) const
 
bool has_keying_material () const override
 
Key_Length_Specification key_spec () const final
 
size_t maximum_keylength () const
 
size_t minimum_keylength () const
 
std::string name () const override
 
std::unique_ptr< BlockCiphernew_object () const override
 
size_t parallel_bytes () const
 
virtual size_t parallelism () const
 
virtual std::string provider () const
 
void salted_set_key (const uint8_t key[], size_t key_length, const uint8_t salt[], size_t salt_length, size_t workfactor, bool salt_first=false)
 
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)
 
bool valid_keylength (size_t length) const
 

Static Public Member Functions

static std::unique_ptr< BlockCiphercreate (std::string_view algo_spec, std::string_view provider="")
 
static std::unique_ptr< BlockCiphercreate_or_throw (std::string_view algo_spec, std::string_view provider="")
 
static std::vector< std::string > providers (std::string_view algo_spec)
 

Static Public Attributes

static constexpr size_t ParallelismMult
 

Protected Member Functions

void assert_key_material_set () const
 
void assert_key_material_set (bool predicate) const
 

Detailed Description

Blowfish

Definition at line 19 of file blowfish.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
inherited

Definition at line 214 of file block_cipher.h.

Member Function Documentation

◆ assert_key_material_set() [1/2]

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

◆ assert_key_material_set() [2/2]

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

Definition at line 143 of file sym_algo.h.

143 {
144 if(!predicate) {
146 }
147 }

◆ block_size()

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, 1, BlockCipher >::block_size ( ) const
inlinefinalvirtualinherited
Returns
block size of this algorithm

Implements Botan::BlockCipher.

Definition at line 216 of file block_cipher.h.

216{ return BS; }

◆ clear()

void Botan::Blowfish::clear ( )
overridevirtual

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 391 of file blowfish.cpp.

391 {
392 zap(m_P);
393 zap(m_S);
394}
void zap(std::vector< T, Alloc > &vec)
Definition secmem.h:124

References Botan::zap().

◆ clone()

BlockCipher * Botan::BlockCipher::clone ( ) const
inlineinherited

Definition at line 188 of file block_cipher.h.

188{ return this->new_object().release(); }
virtual std::unique_ptr< BlockCipher > new_object() const=0

◆ create()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create ( std::string_view algo_spec,
std::string_view provider = "" )
staticinherited

Create an instance based on a name If provider is empty then best available is chosen.

Parameters
algo_specalgorithm name
providerprovider implementation to choose
Returns
a null pointer if the algo/provider combination cannot be found

Definition at line 31 of file block_cipher.cpp.

92 {
93#if defined(BOTAN_HAS_COMMONCRYPTO)
94 if(provider.empty() || provider == "commoncrypto") {
96 return bc;
97
98 if(!provider.empty())
99 return nullptr;
100 }
101#endif
102
103 // TODO: CryptoAPI
104 // TODO: /dev/crypto
105
106 // Only base providers from here on out
107 if(provider.empty() == false && provider != "base") {
108 return nullptr;
109 }
110
111#if defined(BOTAN_HAS_AES)
112 if(algo == "AES-128") {
114 }
115
116 if(algo == "AES-192") {
118 }
119
120 if(algo == "AES-256") {
122 }
123#endif
124
125#if defined(BOTAN_HAS_ARIA)
126 if(algo == "ARIA-128") {
128 }
129
130 if(algo == "ARIA-192") {
132 }
133
134 if(algo == "ARIA-256") {
136 }
137#endif
138
139#if defined(BOTAN_HAS_SERPENT)
140 if(algo == "Serpent") {
142 }
143#endif
144
145#if defined(BOTAN_HAS_SHACAL2)
146 if(algo == "SHACAL2") {
148 }
149#endif
150
151#if defined(BOTAN_HAS_TWOFISH)
152 if(algo == "Twofish") {
154 }
155#endif
156
157#if defined(BOTAN_HAS_THREEFISH_512)
158 if(algo == "Threefish-512") {
160 }
161#endif
162
163#if defined(BOTAN_HAS_BLOWFISH)
164 if(algo == "Blowfish") {
166 }
167#endif
168
169#if defined(BOTAN_HAS_CAMELLIA)
170 if(algo == "Camellia-128") {
172 }
173
174 if(algo == "Camellia-192") {
176 }
177
178 if(algo == "Camellia-256") {
180 }
181#endif
182
183#if defined(BOTAN_HAS_DES)
184 if(algo == "DES") {
185 return std::make_unique<DES>();
186 }
187
188 if(algo == "TripleDES" || algo == "3DES" || algo == "DES-EDE") {
190 }
191#endif
192
193#if defined(BOTAN_HAS_NOEKEON)
194 if(algo == "Noekeon") {
196 }
197#endif
198
199#if defined(BOTAN_HAS_CAST_128)
200 if(algo == "CAST-128" || algo == "CAST5") {
202 }
203#endif
204
205#if defined(BOTAN_HAS_IDEA)
206 if(algo == "IDEA") {
207 return std::make_unique<IDEA>();
208 }
209#endif
210
211#if defined(BOTAN_HAS_KUZNYECHIK)
212 if(algo == "Kuznyechik") {
214 }
215#endif
216
217#if defined(BOTAN_HAS_SEED)
218 if(algo == "SEED") {
219 return std::make_unique<SEED>();
220 }
221#endif
222
223#if defined(BOTAN_HAS_SM4)
224 if(algo == "SM4") {
225 return std::make_unique<SM4>();
226 }
227#endif
228
229 const SCAN_Name req(algo);
230
231#if defined(BOTAN_HAS_GOST_28147_89)
232 if(req.algo_name() == "GOST-28147-89") {
233 return std::make_unique<GOST_28147_89>(req.arg(0, "R3411_94_TestParam"));
234 }
235#endif
236
237#if defined(BOTAN_HAS_CASCADE)
238 if(req.algo_name() == "Cascade" && req.arg_count() == 2) {
239 auto c1 = BlockCipher::create(req.arg(0));
240 auto c2 = BlockCipher::create(req.arg(1));
241
242 if(c1 && c2) {
244 }
245 }
246#endif
247
248#if defined(BOTAN_HAS_LION)
249 if(req.algo_name() == "Lion" && req.arg_count_between(2, 3)) {
250 auto hash = HashFunction::create(req.arg(0));
251 auto stream = StreamCipher::create(req.arg(1));
252
253 if(hash && stream) {
254 const size_t block_size = req.arg_as_integer(2, 1024);
256 }
257 }
258#endif
259
262
263 return nullptr;
264}
#define BOTAN_UNUSED
Definition assert.h:120
static std::unique_ptr< BlockCipher > create(std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< HashFunction > create(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:107
static std::unique_ptr< StreamCipher > create(std::string_view algo_spec, std::string_view provider="")
std::unique_ptr< BlockCipher > make_commoncrypto_block_cipher(std::string_view name)

◆ create_or_throw()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create_or_throw ( std::string_view algo_spec,
std::string_view provider = "" )
staticinherited

Create an instance based on a name, or throw if the algo/provider combination cannot be found. If provider is empty then best available is chosen.

Definition at line 38 of file block_cipher.cpp.

267 {
268 if(auto bc = BlockCipher::create(algo, provider)) {
269 return bc;
270 }
271 throw Lookup_Error("Block cipher", algo, provider);
272}

◆ decrypt() [1/4]

void Botan::BlockCipher::decrypt ( const uint8_t in[],
uint8_t out[] ) const
inlineinherited

Decrypt a block.

Parameters
inThe ciphertext block to be decypted as a byte array. Must be of length block_size().
outThe byte array designated to hold the decrypted block. Must be of length block_size().

Definition at line 91 of file block_cipher.h.

91{ decrypt_n(in, out, 1); }
virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const=0

◆ decrypt() [2/4]

void Botan::BlockCipher::decrypt ( std::span< const uint8_t > in,
std::span< uint8_t > out ) const
inlineinherited

Decrypt one or more blocks

Parameters
inthe input buffer (multiple of block_size())
outthe output buffer (same size as in)

Definition at line 139 of file block_cipher.h.

139 {
140 return decrypt_n(in.data(), out.data(), in.size() / block_size());
141 }

◆ decrypt() [3/4]

void Botan::BlockCipher::decrypt ( std::span< uint8_t > block) const
inlineinherited

Decrypt one or more blocks

Parameters
blockthe input/output buffer (multiple of block_size())

Definition at line 121 of file block_cipher.h.

121 {
122 return decrypt_n(block.data(), block.data(), block.size() / block_size());
123 }

◆ decrypt() [4/4]

void Botan::BlockCipher::decrypt ( uint8_t block[]) const
inlineinherited

Decrypt a block.

Parameters
blockthe ciphertext block to be decrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 107 of file block_cipher.h.

107{ decrypt_n(block, block, 1); }

◆ decrypt_n()

void Botan::Blowfish::decrypt_n ( const uint8_t in[],
uint8_t out[],
size_t blocks ) const
overridevirtual

Decrypt one or more blocks

Parameters
inthe input buffer (multiple of block_size())
outthe output buffer (same size as in)
blocksthe number of blocks to process

Implements Botan::BlockCipher.

Definition at line 225 of file blowfish.cpp.

225 {
227
228 while(blocks >= 4) {
229 uint32_t L0, R0, L1, R1, L2, R2, L3, R3;
230 load_be(in, L0, R0, L1, R1, L2, R2, L3, R3);
231
232 for(size_t r = 17; r != 1; r -= 2) {
233 L0 ^= m_P[r];
234 L1 ^= m_P[r];
235 L2 ^= m_P[r];
236 L3 ^= m_P[r];
237 R0 ^= BFF(L0, m_S);
238 R1 ^= BFF(L1, m_S);
239 R2 ^= BFF(L2, m_S);
240 R3 ^= BFF(L3, m_S);
241
242 R0 ^= m_P[r - 1];
243 R1 ^= m_P[r - 1];
244 R2 ^= m_P[r - 1];
245 R3 ^= m_P[r - 1];
246
247 L0 ^= BFF(R0, m_S);
248 L1 ^= BFF(R1, m_S);
249 L2 ^= BFF(R2, m_S);
250 L3 ^= BFF(R3, m_S);
251 }
252
253 L0 ^= m_P[1];
254 R0 ^= m_P[0];
255 L1 ^= m_P[1];
256 R1 ^= m_P[0];
257 L2 ^= m_P[1];
258 R2 ^= m_P[0];
259 L3 ^= m_P[1];
260 R3 ^= m_P[0];
261
262 store_be(out, R0, L0, R1, L1, R2, L2, R3, L3);
263
264 in += 4 * BLOCK_SIZE;
265 out += 4 * BLOCK_SIZE;
266 blocks -= 4;
267 }
268
269 while(blocks) {
270 uint32_t L, R;
271 load_be(in, L, R);
272
273 for(size_t r = 17; r != 1; r -= 2) {
274 L ^= m_P[r];
275 R ^= BFF(L, m_S);
276
277 R ^= m_P[r - 1];
278 L ^= BFF(R, m_S);
279 }
280
281 L ^= m_P[1];
282 R ^= m_P[0];
283
284 store_be(out, R, L);
285
286 in += BLOCK_SIZE;
287 out += BLOCK_SIZE;
288 blocks--;
289 }
290}
constexpr auto store_be(ParamTs &&... params)
Definition loadstor.h:745
constexpr auto load_be(ParamTs &&... params)
Definition loadstor.h:504

References Botan::Block_Cipher_Fixed_Params< 8, 1, 56 >::assert_key_material_set(), Botan::Block_Cipher_Fixed_Params< 8, 1, 56 >::BLOCK_SIZE, Botan::load_be(), and Botan::store_be().

◆ decrypt_n_xex()

void Botan::BlockCipher::decrypt_n_xex ( uint8_t data[],
const uint8_t mask[],
size_t blocks ) const
inlineinherited

Definition at line 172 of file block_cipher.h.

172 {
173 const size_t BS = block_size();
174 for(size_t i = 0; i != blocks * BS; ++i) {
175 data[i] ^= mask[i];
176 }
178 for(size_t i = 0; i != blocks * BS; ++i) {
179 data[i] ^= mask[i];
180 }
181 }

◆ encrypt() [1/4]

void Botan::BlockCipher::encrypt ( const uint8_t in[],
uint8_t out[] ) const
inlineinherited

Encrypt a block.

Parameters
inThe plaintext block to be encrypted as a byte array. Must be of length block_size().
outThe byte array designated to hold the encrypted block. Must be of length block_size().

Definition at line 82 of file block_cipher.h.

82{ encrypt_n(in, out, 1); }
virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const=0

◆ encrypt() [2/4]

void Botan::BlockCipher::encrypt ( std::span< const uint8_t > in,
std::span< uint8_t > out ) const
inlineinherited

Encrypt one or more blocks

Parameters
inthe input buffer (multiple of block_size())
outthe output buffer (same size as in)

Definition at line 130 of file block_cipher.h.

130 {
131 return encrypt_n(in.data(), out.data(), in.size() / block_size());
132 }

◆ encrypt() [3/4]

void Botan::BlockCipher::encrypt ( std::span< uint8_t > block) const
inlineinherited

Encrypt one or more blocks

Parameters
blockthe input/output buffer (multiple of block_size())

Definition at line 113 of file block_cipher.h.

113 {
114 return encrypt_n(block.data(), block.data(), block.size() / block_size());
115 }

◆ encrypt() [4/4]

void Botan::BlockCipher::encrypt ( uint8_t block[]) const
inlineinherited

Encrypt a block.

Parameters
blockthe plaintext block to be encrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 99 of file block_cipher.h.

99{ encrypt_n(block, block, 1); }

◆ encrypt_n()

void Botan::Blowfish::encrypt_n ( const uint8_t in[],
uint8_t out[],
size_t blocks ) const
overridevirtual

Encrypt one or more blocks

Parameters
inthe input buffer (multiple of block_size())
outthe output buffer (same size as in)
blocksthe number of blocks to process

Implements Botan::BlockCipher.

Definition at line 156 of file blowfish.cpp.

156 {
158
159 while(blocks >= 4) {
160 uint32_t L0, R0, L1, R1, L2, R2, L3, R3;
161 load_be(in, L0, R0, L1, R1, L2, R2, L3, R3);
162
163 for(size_t r = 0; r != 16; r += 2) {
164 L0 ^= m_P[r];
165 L1 ^= m_P[r];
166 L2 ^= m_P[r];
167 L3 ^= m_P[r];
168 R0 ^= BFF(L0, m_S);
169 R1 ^= BFF(L1, m_S);
170 R2 ^= BFF(L2, m_S);
171 R3 ^= BFF(L3, m_S);
172
173 R0 ^= m_P[r + 1];
174 R1 ^= m_P[r + 1];
175 R2 ^= m_P[r + 1];
176 R3 ^= m_P[r + 1];
177 L0 ^= BFF(R0, m_S);
178 L1 ^= BFF(R1, m_S);
179 L2 ^= BFF(R2, m_S);
180 L3 ^= BFF(R3, m_S);
181 }
182
183 L0 ^= m_P[16];
184 R0 ^= m_P[17];
185 L1 ^= m_P[16];
186 R1 ^= m_P[17];
187 L2 ^= m_P[16];
188 R2 ^= m_P[17];
189 L3 ^= m_P[16];
190 R3 ^= m_P[17];
191
192 store_be(out, R0, L0, R1, L1, R2, L2, R3, L3);
193
194 in += 4 * BLOCK_SIZE;
195 out += 4 * BLOCK_SIZE;
196 blocks -= 4;
197 }
198
199 while(blocks) {
200 uint32_t L, R;
201 load_be(in, L, R);
202
203 for(size_t r = 0; r != 16; r += 2) {
204 L ^= m_P[r];
205 R ^= BFF(L, m_S);
206
207 R ^= m_P[r + 1];
208 L ^= BFF(R, m_S);
209 }
210
211 L ^= m_P[16];
212 R ^= m_P[17];
213
214 store_be(out, R, L);
215
216 in += BLOCK_SIZE;
217 out += BLOCK_SIZE;
218 blocks--;
219 }
220}

References Botan::Block_Cipher_Fixed_Params< 8, 1, 56 >::assert_key_material_set(), Botan::Block_Cipher_Fixed_Params< 8, 1, 56 >::BLOCK_SIZE, Botan::load_be(), and Botan::store_be().

◆ encrypt_n_xex()

void Botan::BlockCipher::encrypt_n_xex ( uint8_t data[],
const uint8_t mask[],
size_t blocks ) const
inlineinherited

Definition at line 160 of file block_cipher.h.

160 {
161 const size_t BS = block_size();
162 for(size_t i = 0; i != blocks * BS; ++i) {
163 data[i] ^= mask[i];
164 }
166 for(size_t i = 0; i != blocks * BS; ++i) {
167 data[i] ^= mask[i];
168 }
169 }

◆ has_keying_material()

bool Botan::Blowfish::has_keying_material ( ) const
overridevirtual
Returns
true if a key has been set on this object

Implements Botan::SymmetricAlgorithm.

Definition at line 292 of file blowfish.cpp.

292 {
293 return !m_P.empty();
294}

◆ key_spec()

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, 1, BlockCipher >::key_spec ( ) const
inlinefinalvirtualinherited
Returns
object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 218 of file block_cipher.h.

◆ maximum_keylength()

size_t Botan::SymmetricAlgorithm::maximum_keylength ( ) const
inlineinherited
Returns
maximum allowed key length

Definition at line 97 of file sym_algo.h.

97{ return key_spec().maximum_keylength(); }
Key_Length_Specification key_spec() const final
size_t maximum_keylength() const
Definition sym_algo.h:56

◆ minimum_keylength()

size_t Botan::SymmetricAlgorithm::minimum_keylength ( ) const
inlineinherited
Returns
minimum allowed key length

Definition at line 102 of file sym_algo.h.

102{ return key_spec().minimum_keylength(); }
size_t minimum_keylength() const
Definition sym_algo.h:51

◆ name()

std::string Botan::Blowfish::name ( ) const
inlineoverridevirtual
Returns
the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 36 of file blowfish.h.

36{ return "Blowfish"; }

◆ new_object()

std::unique_ptr< BlockCipher > Botan::Blowfish::new_object ( ) const
inlineoverridevirtual
Returns
new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 38 of file blowfish.h.

38{ return std::make_unique<Blowfish>(); }

◆ parallel_bytes()

size_t Botan::BlockCipher::parallel_bytes ( ) const
inlineinherited
Returns
prefererred parallelism of this cipher in bytes

Definition at line 67 of file block_cipher.h.

◆ parallelism()

virtual size_t Botan::BlockCipher::parallelism ( ) const
inlinevirtualinherited
Returns
native parallelism of this cipher in blocks

Definition at line 62 of file block_cipher.h.

62{ return 1; }

◆ provider()

virtual std::string Botan::BlockCipher::provider ( ) const
inlinevirtualinherited
Returns
provider information about this implementation. Default is "base", might also return "sse2", "avx2", "openssl", or some other arbitrary string.

Definition at line 73 of file block_cipher.h.

73{ return "base"; }

◆ providers()

std::vector< std::string > Botan::BlockCipher::providers ( std::string_view algo_spec)
staticinherited
Returns
list of available providers for this algorithm, empty if not available
Parameters
algo_specalgorithm name

Definition at line 44 of file block_cipher.cpp.

274 {
275 return probe_providers_of<BlockCipher>(algo, {"base", "commoncrypto"});
276}
std::vector< std::string > probe_providers_of(std::string_view algo_spec, const std::vector< std::string > &possible={"base"})
Definition scan_name.h:105

◆ salted_set_key()

void Botan::Blowfish::salted_set_key ( const uint8_t key[],
size_t key_length,
const uint8_t salt[],
size_t salt_length,
size_t workfactor,
bool salt_first = false )

Modified EKSBlowfish key schedule, used for bcrypt password hashing

Definition at line 326 of file blowfish.cpp.

327 {
328 BOTAN_ARG_CHECK(salt_length > 0 && salt_length % 4 == 0, "Invalid salt length for Blowfish salted key schedule");
329
330 if(length > 72) {
331 // Truncate longer passwords to the 72 char bcrypt limit
332 length = 72;
333 }
334
335 m_P.resize(18);
336 copy_mem(m_P.data(), P_INIT, 18);
337
338 m_S.resize(1024);
339 copy_mem(m_S.data(), S_INIT, 1024);
340 key_expansion(key, length, salt, salt_length);
341
342 if(workfactor > 0) {
343 const size_t rounds = static_cast<size_t>(1) << workfactor;
344
345 for(size_t r = 0; r != rounds; ++r) {
346 if(salt_first) {
347 key_expansion(salt, salt_length, nullptr, 0);
348 key_expansion(key, length, nullptr, 0);
349 } else {
350 key_expansion(key, length, nullptr, 0);
351 key_expansion(salt, salt_length, nullptr, 0);
352 }
353 }
354 }
355}
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:31
constexpr void copy_mem(T *out, const T *in, size_t n)
Definition mem_ops.h:149

References BOTAN_ARG_CHECK, and Botan::copy_mem().

◆ set_key() [1/3]

void Botan::SymmetricAlgorithm::set_key ( const OctetString & key)
inherited

Set the symmetric key of this object.

Parameters
keythe SymmetricKey to be set.

Definition at line 115 of file sym_algo.cpp.

14 {
15 set_key(std::span{key.begin(), key.length()});
16}
void set_key(const OctetString &key)
Definition sym_algo.cpp:14

◆ 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 128 of file sym_algo.h.

◆ 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 121 of file sym_algo.cpp.

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

◆ 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 109 of file sym_algo.h.

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

Member Data Documentation

◆ ParallelismMult

size_t Botan::BlockCipher::ParallelismMult
staticconstexprinherited

Multiplier on a block cipher's native parallelism

Usually notable performance gains come from further loop blocking, at least for 2 or 4x

Definition at line 52 of file block_cipher.h.


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