Botan 2.19.5 Crypto and TLS for C&

Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::Serpent Class Referencefinal

`#include <serpent.h>`

Inheritance diagram for Botan::Serpent:

## Public Types
enum |

## Public Member Functions
size_t | block_size () const final override
void | clear () override
BlockCipher * | clone () const override
template<typename Alloc , typename Alloc2 >
void | decrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) const
void | decrypt (const uint8_t in[], uint8_t out[]) const
template<typename Alloc >
void | decrypt (std::vector< uint8_t, Alloc > &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 final override
template<typename Alloc , typename Alloc2 >
void | encrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) const
void | encrypt (const uint8_t in[], uint8_t out[]) const
template<typename Alloc >
void | encrypt (std::vector< uint8_t, Alloc > &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 final override
Key_Length_Specification | key_spec () const final override
size_t | maximum_keylength () const
size_t | minimum_keylength () const
std::string | name () const override
size_t | parallel_bytes () const
size_t | parallelism () const override
std::string | provider () const override
template<typename Alloc >
void | set_key (const std::vector< uint8_t, Alloc > &key)
void | set_key (const SymmetricKey &key)
void | set_key (const uint8_t key[], size_t length)
bool | valid_keylength (size_t length) const

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

## Protected Member Functions
void | verify_key_set (bool cond) const

## Detailed Description

Serpent is the most conservative of the AES finalists https://www.cl.cam.ac.uk/~rja14/serpent.html

Definition at line 21 of file serpent.h.

## Member Enumeration Documentation

## ◆ anonymous enum

anonymous enum
| inherited

Definition at line 224 of file block_cipher.h.

224{ BLOCK_SIZE = BS };
Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::BLOCK_SIZE
@ BLOCK_SIZE
Definition: block_cipher.h:224

## Member Function Documentation

## ◆ block_size()

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, KMOD, BlockCipher >::block_size | ( |  | ) | const
| inline final override virtual inherited

Returns
  block size of this algorithm

Implements Botan::BlockCipher.

Definition at line 225 of file block_cipher.h.

225{ return BS; }

## ◆ clear()

void Botan::Serpent::clear | ( |  | ) |
| override virtual

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 273 of file serpent.cpp.

274 {
275 zap(m_round_key);
276 }
Botan::zap
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:124

References Botan::zap().

## ◆ clone()

BlockCipher * Botan::Serpent::clone | ( |  | ) | const
| inline override virtual

Returns
  new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 30 of file serpent.h.

30{ return new Serpent; }

## ◆ create()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create | ( | const std::string & | algo_spec,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

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

Parameters

  algo_spec | algorithm name
  provider | provider implementation to choose

Returns
  a null pointer if the algo/provider combination cannot be found

Definition at line 104 of file block_cipher.cpp.

106 {
107#if defined(BOTAN_HAS_COMMONCRYPTO)
108 if(provider.empty() || provider == "commoncrypto")
109 {
110 if(auto bc = make_commoncrypto_block_cipher(algo))
111 return bc;
112
113 if(!provider.empty())
114 return nullptr;
115 }
116#endif
117
118 // TODO: CryptoAPI
119 // TODO: /dev/crypto
120
121 // Only base providers from here on out
122 if(provider.empty() == false && provider != "base")
123 return nullptr;
124
125#if defined(BOTAN_HAS_AES)
126 if(algo == "AES-128")
127 {
128 return std::unique_ptr<BlockCipher>(new AES_128);
129 }
130
131 if(algo == "AES-192")
132 {
133 return std::unique_ptr<BlockCipher>(new AES_192);
134 }
135
136 if(algo == "AES-256")
137 {
138 return std::unique_ptr<BlockCipher>(new AES_256);
139 }
140#endif
141
142#if defined(BOTAN_HAS_ARIA)
143 if(algo == "ARIA-128")
144 {
145 return std::unique_ptr<BlockCipher>(new ARIA_128);
146 }
147
148 if(algo == "ARIA-192")
149 {
150 return std::unique_ptr<BlockCipher>(new ARIA_192);
151 }
152
153 if(algo == "ARIA-256")
154 {
155 return std::unique_ptr<BlockCipher>(new ARIA_256);
156 }
157#endif
158
159#if defined(BOTAN_HAS_SERPENT)
160 if(algo == "Serpent")
161 {
162 return std::unique_ptr<BlockCipher>(new Serpent);
163 }
164#endif
165
166#if defined(BOTAN_HAS_SHACAL2)
167 if(algo == "SHACAL2")
168 {
169 return std::unique_ptr<BlockCipher>(new SHACAL2);
170 }
171#endif
172
173#if defined(BOTAN_HAS_TWOFISH)
174 if(algo == "Twofish")
175 {
176 return std::unique_ptr<BlockCipher>(new Twofish);
177 }
178#endif
179
180#if defined(BOTAN_HAS_THREEFISH_512)
181 if(algo == "Threefish-512")
182 {
183 return std::unique_ptr<BlockCipher>(new Threefish_512);
184 }
185#endif
186
187#if defined(BOTAN_HAS_BLOWFISH)
188 if(algo == "Blowfish")
189 {
190 return std::unique_ptr<BlockCipher>(new Blowfish);
191 }
192#endif
193
194#if defined(BOTAN_HAS_CAMELLIA)
195 if(algo == "Camellia-128")
196 {
197 return std::unique_ptr<BlockCipher>(new Camellia_128);
198 }
199
200 if(algo == "Camellia-192")
201 {
202 return std::unique_ptr<BlockCipher>(new Camellia_192);
203 }
204
205 if(algo == "Camellia-256")
206 {
207 return std::unique_ptr<BlockCipher>(new Camellia_256);
208 }
209#endif
210
211#if defined(BOTAN_HAS_DES)
212 if(algo == "DES")
213 {
214 return std::unique_ptr<BlockCipher>(new DES);
215 }
216
217 if(algo == "DESX")
218 {
219 return std::unique_ptr<BlockCipher>(new DESX);
220 }
221
222 if(algo == "TripleDES" || algo == "3DES" || algo == "DES-EDE")
223 {
224 return std::unique_ptr<BlockCipher>(new TripleDES);
225 }
226#endif
227
228#if defined(BOTAN_HAS_NOEKEON)
229 if(algo == "Noekeon")
230 {
231 return std::unique_ptr<BlockCipher>(new Noekeon);
232 }
233#endif
234
235#if defined(BOTAN_HAS_CAST_128)
236 if(algo == "CAST-128" || algo == "CAST5")
237 {
238 return std::unique_ptr<BlockCipher>(new CAST_128);
239 }
240#endif
241
242#if defined(BOTAN_HAS_CAST_256)
243 if(algo == "CAST-256")
244 {
245 return std::unique_ptr<BlockCipher>(new CAST_256);
246 }
247#endif
248
249#if defined(BOTAN_HAS_IDEA)
250 if(algo == "IDEA")
251 {
252 return std::unique_ptr<BlockCipher>(new IDEA);
253 }
254#endif
255
256#if defined(BOTAN_HAS_KASUMI)
257 if(algo == "KASUMI")
258 {
259 return std::unique_ptr<BlockCipher>(new KASUMI);
260 }
261#endif
262
263#if defined(BOTAN_HAS_MISTY1)
264 if(algo == "MISTY1")
265 {
266 return std::unique_ptr<BlockCipher>(new MISTY1);
267 }
268#endif
269
270#if defined(BOTAN_HAS_SEED)
271 if(algo == "SEED")
272 {
273 return std::unique_ptr<BlockCipher>(new SEED);
274 }
275#endif
276
277#if defined(BOTAN_HAS_SM4)
278 if(algo == "SM4")
279 {
280 return std::unique_ptr<BlockCipher>(new SM4);
281 }
282#endif
283
284#if defined(BOTAN_HAS_XTEA)
285 if(algo == "XTEA")
286 {
287 return std::unique_ptr<BlockCipher>(new XTEA);
288 }
289#endif
290
291 const SCAN_Name req(algo);
292
293#if defined(BOTAN_HAS_GOST_28147_89)
294 if(req.algo_name() == "GOST-28147-89")
295 {
296 return std::unique_ptr<BlockCipher>(new GOST_28147_89(req.arg(0, "R3411_94_TestParam")));
297 }
298#endif
299
300#if defined(BOTAN_HAS_CASCADE)
301 if(req.algo_name() == "Cascade" && req.arg_count() == 2)
302 {
303 std::unique_ptr<BlockCipher> c1(BlockCipher::create(req.arg(0)));
304 std::unique_ptr<BlockCipher> c2(BlockCipher::create(req.arg(1)));
305
306 if(c1 && c2)
307 return std::unique_ptr<BlockCipher>(new Cascade_Cipher(c1.release(), c2.release()));
308 }
309#endif
310
311#if defined(BOTAN_HAS_LION)
312 if(req.algo_name() == "Lion" && req.arg_count_between(2, 3))
313 {
314 std::unique_ptr<HashFunction> hash(HashFunction::create(req.arg(0)));
315 std::unique_ptr<StreamCipher> stream(StreamCipher::create(req.arg(1)));
316
317 if(hash && stream)
318 {
319 const size_t block_size = req.arg_as_integer(2, 1024);
320 return std::unique_ptr<BlockCipher>(new Lion(hash.release(), stream.release(), block_size));
321 }
322 }
323#endif
324
325 BOTAN_UNUSED(req);
326 BOTAN_UNUSED(provider);
327
328 return nullptr;
329 }
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:104
Botan::BlockCipher::block_size
virtual size_t block_size() const =0
Botan::BlockCipher::provider
virtual std::string provider() const
Definition: block_cipher.h:73
Botan::HashFunction::create
static std::unique_ptr< HashFunction > create(const std::string &algo_spec, const std::string &provider="")
Definition: hash.cpp:102
Botan::StreamCipher::create
static std::unique_ptr< StreamCipher > create(const std::string &algo_spec, const std::string &provider="")
Definition: stream_cipher.cpp:38
Botan::make_commoncrypto_block_cipher
std::unique_ptr< BlockCipher > make_commoncrypto_block_cipher(const std::string &name)
Definition: commoncrypto_block.cpp:150
hash
MechanismType hash
Definition: p11_mechanism.cpp:64

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), Botan::SCAN_Name::arg_count_between(), Botan::BlockCipher::block_size(), BOTAN_UNUSED, Botan::BlockCipher::create(), Botan::HashFunction::create(), Botan::StreamCipher::create(), hash, Botan::make_commoncrypto_block_cipher(), and Botan::BlockCipher::provider().

Referenced by botan_block_cipher_init(), Botan::AEAD_Mode::create(), Botan::Cipher_Mode::create(), Botan::BlockCipher::create(), Botan::MessageAuthenticationCode::create(), Botan::StreamCipher::create(), and Botan::BlockCipher::create_or_throw().

## ◆ create_or_throw()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create_or_throw | ( | const std::string & | algo_spec,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

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 333 of file block_cipher.cpp.

335 {
336 if(auto bc = BlockCipher::create(algo, provider))
337 {
338 return bc;
339 }
340 throw Lookup_Error("Block cipher", algo, provider);
341 }

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

Referenced by Botan::TLS::Connection_Cipher_State::Connection_Cipher_State(), Botan::Encrypted_PSK_Database::Encrypted_PSK_Database(), Botan::rfc3394_keyunwrap(), and Botan::rfc3394_keywrap().

## ◆ decrypt() [1/4]

template<typename Alloc , typename Alloc2 >

void Botan::BlockCipher::decrypt | ( | const std::vector< uint8_t, Alloc > & | in,
|  | std::vector< uint8_t, Alloc2 > & | out
| ) |  | const
| inline inherited

Decrypt one or more blocks

Parameters

  in | the input buffer (multiple of block_size())
  out | the output buffer (same size as in)

Definition at line 149 of file block_cipher.h.

151 {
152 return decrypt_n(in.data(), out.data(), in.size() / block_size());
153 }
Botan::BlockCipher::decrypt_n
virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

## ◆ decrypt() [2/4]

void Botan::BlockCipher::decrypt | ( | const uint8_t | in[],
|  | uint8_t | out[]
| ) |  | const
| inline inherited

Decrypt a block.

Parameters

  in | The ciphertext block to be decypted as a byte array. Must be of length block_size().
  out | The byte array designated to hold the decrypted block. Must be of length block_size().

Definition at line 92 of file block_cipher.h.

93 { decrypt_n(in, out, 1); }

Referenced by Botan::DESX::decrypt_n(), Botan::CTS_Decryption::finish(), Botan::XTS_Decryption::finish(), Botan::nist_key_unwrap(), and Botan::nist_key_unwrap_padded().

## ◆ decrypt() [3/4]

template<typename Alloc >

void Botan::BlockCipher::decrypt | ( | std::vector< uint8_t, Alloc > & | block | ) | const
| inline inherited

Decrypt one or more blocks

Parameters

  block | the input/output buffer (multiple of block_size())

Definition at line 126 of file block_cipher.h.

127 {
128 return decrypt_n(block.data(), block.data(), block.size() / block_size());
129 }

## ◆ decrypt() [4/4]

void Botan::BlockCipher::decrypt | ( | uint8_t | block[] | ) | const
| inline inherited

Decrypt a block.

Parameters

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

Definition at line 109 of file block_cipher.h.

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

## ◆ decrypt_n()

void Botan::Serpent::decrypt_n | ( | const uint8_t | in[],
|  | uint8_t | out[],
|  | size_t | blocks
| ) |  | const
| override virtual

Decrypt one or more blocks

Parameters

  in | the input buffer (multiple of block_size())
  out | the output buffer (same size as in)
  blocks | the number of blocks to process

Implements Botan::BlockCipher.

Definition at line 134 of file serpent.cpp.

135 {
136 verify_key_set(m_round_key.empty() == false);
137
138#if defined(BOTAN_HAS_SERPENT_AVX2)
139 if(CPUID::has_avx2())
140 {
141 while(blocks >= 8)
142 {
143 avx2_decrypt_8(in, out);
144 in += 8 * BLOCK_SIZE;
145 out += 8 * BLOCK_SIZE;
146 blocks -= 8;
147 }
148 }
149#endif
150
151#if defined(BOTAN_HAS_SERPENT_SIMD)
152 if(CPUID::has_simd_32())
153 {
154 while(blocks >= 4)
155 {
156 simd_decrypt_4(in, out);
157 in += 4 * BLOCK_SIZE;
158 out += 4 * BLOCK_SIZE;
159 blocks -= 4;
160 }
161 }
162#endif
163
164 BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i)
165 {
166 uint32_t B0, B1, B2, B3;
167 load_le(in + 16*i, B0, B1, B2, B3);
168
169 key_xor(32,B0,B1,B2,B3); SBoxD7(B0,B1,B2,B3); key_xor(31,B0,B1,B2,B3);
170 i_transform(B0,B1,B2,B3); SBoxD6(B0,B1,B2,B3); key_xor(30,B0,B1,B2,B3);
171 i_transform(B0,B1,B2,B3); SBoxD5(B0,B1,B2,B3); key_xor(29,B0,B1,B2,B3);
172 i_transform(B0,B1,B2,B3); SBoxD4(B0,B1,B2,B3); key_xor(28,B0,B1,B2,B3);
173 i_transform(B0,B1,B2,B3); SBoxD3(B0,B1,B2,B3); key_xor(27,B0,B1,B2,B3);
174 i_transform(B0,B1,B2,B3); SBoxD2(B0,B1,B2,B3); key_xor(26,B0,B1,B2,B3);
175 i_transform(B0,B1,B2,B3); SBoxD1(B0,B1,B2,B3); key_xor(25,B0,B1,B2,B3);
176 i_transform(B0,B1,B2,B3); SBoxD0(B0,B1,B2,B3); key_xor(24,B0,B1,B2,B3);
177 i_transform(B0,B1,B2,B3); SBoxD7(B0,B1,B2,B3); key_xor(23,B0,B1,B2,B3);
178 i_transform(B0,B1,B2,B3); SBoxD6(B0,B1,B2,B3); key_xor(22,B0,B1,B2,B3);
179 i_transform(B0,B1,B2,B3); SBoxD5(B0,B1,B2,B3); key_xor(21,B0,B1,B2,B3);
180 i_transform(B0,B1,B2,B3); SBoxD4(B0,B1,B2,B3); key_xor(20,B0,B1,B2,B3);
181 i_transform(B0,B1,B2,B3); SBoxD3(B0,B1,B2,B3); key_xor(19,B0,B1,B2,B3);
182 i_transform(B0,B1,B2,B3); SBoxD2(B0,B1,B2,B3); key_xor(18,B0,B1,B2,B3);
183 i_transform(B0,B1,B2,B3); SBoxD1(B0,B1,B2,B3); key_xor(17,B0,B1,B2,B3);
184 i_transform(B0,B1,B2,B3); SBoxD0(B0,B1,B2,B3); key_xor(16,B0,B1,B2,B3);
185 i_transform(B0,B1,B2,B3); SBoxD7(B0,B1,B2,B3); key_xor(15,B0,B1,B2,B3);
186 i_transform(B0,B1,B2,B3); SBoxD6(B0,B1,B2,B3); key_xor(14,B0,B1,B2,B3);
187 i_transform(B0,B1,B2,B3); SBoxD5(B0,B1,B2,B3); key_xor(13,B0,B1,B2,B3);
188 i_transform(B0,B1,B2,B3); SBoxD4(B0,B1,B2,B3); key_xor(12,B0,B1,B2,B3);
189 i_transform(B0,B1,B2,B3); SBoxD3(B0,B1,B2,B3); key_xor(11,B0,B1,B2,B3);
190 i_transform(B0,B1,B2,B3); SBoxD2(B0,B1,B2,B3); key_xor(10,B0,B1,B2,B3);
191 i_transform(B0,B1,B2,B3); SBoxD1(B0,B1,B2,B3); key_xor( 9,B0,B1,B2,B3);
192 i_transform(B0,B1,B2,B3); SBoxD0(B0,B1,B2,B3); key_xor( 8,B0,B1,B2,B3);
193 i_transform(B0,B1,B2,B3); SBoxD7(B0,B1,B2,B3); key_xor( 7,B0,B1,B2,B3);
194 i_transform(B0,B1,B2,B3); SBoxD6(B0,B1,B2,B3); key_xor( 6,B0,B1,B2,B3);
195 i_transform(B0,B1,B2,B3); SBoxD5(B0,B1,B2,B3); key_xor( 5,B0,B1,B2,B3);
196 i_transform(B0,B1,B2,B3); SBoxD4(B0,B1,B2,B3); key_xor( 4,B0,B1,B2,B3);
197 i_transform(B0,B1,B2,B3); SBoxD3(B0,B1,B2,B3); key_xor( 3,B0,B1,B2,B3);
198 i_transform(B0,B1,B2,B3); SBoxD2(B0,B1,B2,B3); key_xor( 2,B0,B1,B2,B3);
199 i_transform(B0,B1,B2,B3); SBoxD1(B0,B1,B2,B3); key_xor( 1,B0,B1,B2,B3);
200 i_transform(B0,B1,B2,B3); SBoxD0(B0,B1,B2,B3); key_xor( 0,B0,B1,B2,B3);
201
202 store_le(out + 16*i, B0, B1, B2, B3);
203 }
204 }
Botan::CPUID::has_simd_32
static bool has_simd_32()
Definition: cpuid.cpp:16
Botan::SymmetricAlgorithm::verify_key_set
void verify_key_set(bool cond) const
Definition: sym_algo.h:171
BOTAN_PARALLEL_SIMD_FOR
#define BOTAN_PARALLEL_SIMD_FOR
Definition: compiler.h:230
Botan::load_le
T load_le(const uint8_t in[], size_t off)
Definition: loadstor.h:123
Botan::store_le
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:454
key_xor
#define key_xor(round, B0, B1, B2, B3)
Definition: serpent.cpp:50
i_transform
#define i_transform(B0, B1, B2, B3)
Definition: serpent_avx2.cpp:39
SBoxD6
BOTAN_FORCE_INLINE void SBoxD6(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:394
SBoxD1
BOTAN_FORCE_INLINE void SBoxD1(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:256
SBoxD3
BOTAN_FORCE_INLINE void SBoxD3(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:311
SBoxD2
BOTAN_FORCE_INLINE void SBoxD2(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:285
SBoxD4
BOTAN_FORCE_INLINE void SBoxD4(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:338
SBoxD5
BOTAN_FORCE_INLINE void SBoxD5(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:365
SBoxD0
BOTAN_FORCE_INLINE void SBoxD0(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:230
SBoxD7
BOTAN_FORCE_INLINE void SBoxD7(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:419

References Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::BLOCK_SIZE, BOTAN_PARALLEL_SIMD_FOR, Botan::CPUID::has_simd_32(), i_transform, key_xor, Botan::load_le(), SBoxD0(), SBoxD1(), SBoxD2(), SBoxD3(), SBoxD4(), SBoxD5(), SBoxD6(), SBoxD7(), Botan::store_le(), and Botan::SymmetricAlgorithm::verify_key_set().

## ◆ decrypt_n_xex()

void Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, KMOD, BlockCipher >::decrypt_n_xex | ( | uint8_t | data[],
|  | const uint8_t | mask[],
|  | size_t | blocks
| ) |  | const
| inline final override virtual inherited

Reimplemented from Botan::BlockCipher.

Definition at line 237 of file block_cipher.h.

240 {
241 xor_buf(data, mask, blocks * BS);
242 this->decrypt_n(data, data, blocks);
243 xor_buf(data, mask, blocks * BS);
244 }
Botan::xor_buf
void xor_buf(uint8_t out[], const uint8_t in[], size_t length)
Definition: mem_ops.h:262

## ◆ encrypt() [1/4]

template<typename Alloc , typename Alloc2 >

void Botan::BlockCipher::encrypt | ( | const std::vector< uint8_t, Alloc > & | in,
|  | std::vector< uint8_t, Alloc2 > & | out
| ) |  | const
| inline inherited

Encrypt one or more blocks

Parameters

  in | the input buffer (multiple of block_size())
  out | the output buffer (same size as in)

Definition at line 137 of file block_cipher.h.

139 {
140 return encrypt_n(in.data(), out.data(), in.size() / block_size());
141 }
Botan::BlockCipher::encrypt_n
virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

## ◆ encrypt() [2/4]

void Botan::BlockCipher::encrypt | ( | const uint8_t | in[],
|  | uint8_t | out[]
| ) |  | const
| inline inherited

Encrypt a block.

Parameters

  in | The plaintext block to be encrypted as a byte array. Must be of length block_size().
  out | The byte array designated to hold the encrypted block. Must be of length block_size().

Definition at line 82 of file block_cipher.h.

83 { encrypt_n(in, out, 1); }

Referenced by Botan::aont_package(), Botan::aont_unpackage(), Botan::DESX::encrypt_n(), Botan::CCM_Encryption::finish(), Botan::CCM_Decryption::finish(), Botan::CTS_Encryption::finish(), Botan::XTS_Encryption::finish(), Botan::nist_key_wrap(), Botan::nist_key_wrap_padded(), Botan::CBC_Encryption::process(), and Botan::CFB_Mode::shift_register().

## ◆ encrypt() [3/4]

template<typename Alloc >

void Botan::BlockCipher::encrypt | ( | std::vector< uint8_t, Alloc > & | block | ) | const
| inline inherited

Encrypt one or more blocks

Parameters

  block | the input/output buffer (multiple of block_size())

Definition at line 116 of file block_cipher.h.

117 {
118 return encrypt_n(block.data(), block.data(), block.size() / block_size());
119 }

## ◆ encrypt() [4/4]

void Botan::BlockCipher::encrypt | ( | uint8_t | block[] | ) | const
| inline inherited

Encrypt a block.

Parameters

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

Definition at line 101 of file block_cipher.h.

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

## ◆ encrypt_n()

void Botan::Serpent::encrypt_n | ( | const uint8_t | in[],
|  | uint8_t | out[],
|  | size_t | blocks
| ) |  | const
| override virtual

Encrypt one or more blocks

Parameters

  in | the input buffer (multiple of block_size())
  out | the output buffer (same size as in)
  blocks | the number of blocks to process

Implements Botan::BlockCipher.

Definition at line 59 of file serpent.cpp.

60 {
61 verify_key_set(m_round_key.empty() == false);
62
63#if defined(BOTAN_HAS_SERPENT_AVX2)
64 if(CPUID::has_avx2())
65 {
66 while(blocks >= 8)
67 {
68 avx2_encrypt_8(in, out);
69 in += 8 * BLOCK_SIZE;
70 out += 8 * BLOCK_SIZE;
71 blocks -= 8;
72 }
73 }
74#endif
75
76#if defined(BOTAN_HAS_SERPENT_SIMD)
77 if(CPUID::has_simd_32())
78 {
79 while(blocks >= 4)
80 {
81 simd_encrypt_4(in, out);
82 in += 4 * BLOCK_SIZE;
83 out += 4 * BLOCK_SIZE;
84 blocks -= 4;
85 }
86 }
87#endif
88
89 BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i)
90 {
91 uint32_t B0, B1, B2, B3;
92 load_le(in + 16*i, B0, B1, B2, B3);
93
94 key_xor( 0,B0,B1,B2,B3); SBoxE0(B0,B1,B2,B3); transform(B0,B1,B2,B3);
95 key_xor( 1,B0,B1,B2,B3); SBoxE1(B0,B1,B2,B3); transform(B0,B1,B2,B3);
96 key_xor( 2,B0,B1,B2,B3); SBoxE2(B0,B1,B2,B3); transform(B0,B1,B2,B3);
97 key_xor( 3,B0,B1,B2,B3); SBoxE3(B0,B1,B2,B3); transform(B0,B1,B2,B3);
98 key_xor( 4,B0,B1,B2,B3); SBoxE4(B0,B1,B2,B3); transform(B0,B1,B2,B3);
99 key_xor( 5,B0,B1,B2,B3); SBoxE5(B0,B1,B2,B3); transform(B0,B1,B2,B3);
100 key_xor( 6,B0,B1,B2,B3); SBoxE6(B0,B1,B2,B3); transform(B0,B1,B2,B3);
101 key_xor( 7,B0,B1,B2,B3); SBoxE7(B0,B1,B2,B3); transform(B0,B1,B2,B3);
102 key_xor( 8,B0,B1,B2,B3); SBoxE0(B0,B1,B2,B3); transform(B0,B1,B2,B3);
103 key_xor( 9,B0,B1,B2,B3); SBoxE1(B0,B1,B2,B3); transform(B0,B1,B2,B3);
104 key_xor(10,B0,B1,B2,B3); SBoxE2(B0,B1,B2,B3); transform(B0,B1,B2,B3);
105 key_xor(11,B0,B1,B2,B3); SBoxE3(B0,B1,B2,B3); transform(B0,B1,B2,B3);
106 key_xor(12,B0,B1,B2,B3); SBoxE4(B0,B1,B2,B3); transform(B0,B1,B2,B3);
107 key_xor(13,B0,B1,B2,B3); SBoxE5(B0,B1,B2,B3); transform(B0,B1,B2,B3);
108 key_xor(14,B0,B1,B2,B3); SBoxE6(B0,B1,B2,B3); transform(B0,B1,B2,B3);
109 key_xor(15,B0,B1,B2,B3); SBoxE7(B0,B1,B2,B3); transform(B0,B1,B2,B3);
110 key_xor(16,B0,B1,B2,B3); SBoxE0(B0,B1,B2,B3); transform(B0,B1,B2,B3);
111 key_xor(17,B0,B1,B2,B3); SBoxE1(B0,B1,B2,B3); transform(B0,B1,B2,B3);
112 key_xor(18,B0,B1,B2,B3); SBoxE2(B0,B1,B2,B3); transform(B0,B1,B2,B3);
113 key_xor(19,B0,B1,B2,B3); SBoxE3(B0,B1,B2,B3); transform(B0,B1,B2,B3);
114 key_xor(20,B0,B1,B2,B3); SBoxE4(B0,B1,B2,B3); transform(B0,B1,B2,B3);
115 key_xor(21,B0,B1,B2,B3); SBoxE5(B0,B1,B2,B3); transform(B0,B1,B2,B3);
116 key_xor(22,B0,B1,B2,B3); SBoxE6(B0,B1,B2,B3); transform(B0,B1,B2,B3);
117 key_xor(23,B0,B1,B2,B3); SBoxE7(B0,B1,B2,B3); transform(B0,B1,B2,B3);
118 key_xor(24,B0,B1,B2,B3); SBoxE0(B0,B1,B2,B3); transform(B0,B1,B2,B3);
119 key_xor(25,B0,B1,B2,B3); SBoxE1(B0,B1,B2,B3); transform(B0,B1,B2,B3);
120 key_xor(26,B0,B1,B2,B3); SBoxE2(B0,B1,B2,B3); transform(B0,B1,B2,B3);
121 key_xor(27,B0,B1,B2,B3); SBoxE3(B0,B1,B2,B3); transform(B0,B1,B2,B3);
122 key_xor(28,B0,B1,B2,B3); SBoxE4(B0,B1,B2,B3); transform(B0,B1,B2,B3);
123 key_xor(29,B0,B1,B2,B3); SBoxE5(B0,B1,B2,B3); transform(B0,B1,B2,B3);
124 key_xor(30,B0,B1,B2,B3); SBoxE6(B0,B1,B2,B3); transform(B0,B1,B2,B3);
125 key_xor(31,B0,B1,B2,B3); SBoxE7(B0,B1,B2,B3); key_xor(32,B0,B1,B2,B3);
126
127 store_le(out + 16*i, B0, B1, B2, B3);
128 }
129 }
transform
#define transform(B0, B1, B2, B3)
Definition: serpent_avx2.cpp:25
SBoxE6
BOTAN_FORCE_INLINE void SBoxE6(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:177
SBoxE1
BOTAN_FORCE_INLINE void SBoxE1(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:43
SBoxE7
BOTAN_FORCE_INLINE void SBoxE7(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:201
SBoxE3
BOTAN_FORCE_INLINE void SBoxE3(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:94
SBoxE4
BOTAN_FORCE_INLINE void SBoxE4(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:121
SBoxE5
BOTAN_FORCE_INLINE void SBoxE5(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:149
SBoxE2
BOTAN_FORCE_INLINE void SBoxE2(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:70
SBoxE0
BOTAN_FORCE_INLINE void SBoxE0(T &a, T &b, T &c, T &d)
Definition: serpent_sbox.h:17

References Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::BLOCK_SIZE, BOTAN_PARALLEL_SIMD_FOR, Botan::CPUID::has_simd_32(), key_xor, Botan::load_le(), SBoxE0(), SBoxE1(), SBoxE2(), SBoxE3(), SBoxE4(), SBoxE5(), SBoxE6(), SBoxE7(), Botan::store_le(), transform, and Botan::SymmetricAlgorithm::verify_key_set().

## ◆ encrypt_n_xex()

void Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, KMOD, BlockCipher >::encrypt_n_xex | ( | uint8_t | data[],
|  | const uint8_t | mask[],
|  | size_t | blocks
| ) |  | const
| inline final override virtual inherited

Reimplemented from Botan::BlockCipher.

Definition at line 228 of file block_cipher.h.

231 {
232 xor_buf(data, mask, blocks * BS);
233 this->encrypt_n(data, data, blocks);
234 xor_buf(data, mask, blocks * BS);
235 }

## ◆ key_spec()

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, KMOD, BlockCipher >::key_spec | ( |  | ) | const
| inline final override virtual inherited

Returns
  object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 246 of file block_cipher.h.

247 {
248 return Key_Length_Specification(KMIN, KMAX, KMOD);
249 }

## ◆ maximum_keylength()

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

Returns
  maximum allowed key length

Definition at line 120 of file sym_algo.h.

121 {
122 return key_spec().maximum_keylength();
123 }
Botan::Key_Length_Specification::maximum_keylength
size_t maximum_keylength() const
Definition: sym_algo.h:70
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

## ◆ minimum_keylength()

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

Returns
  minimum allowed key length

Definition at line 128 of file sym_algo.h.

129 {
130 return key_spec().minimum_keylength();
131 }
Botan::Key_Length_Specification::minimum_keylength
size_t minimum_keylength() const
Definition: sym_algo.h:62

Referenced by botan_block_cipher_get_keyspec(), and botan_mac_get_keyspec().

## ◆ name()

std::string Botan::Serpent::name | ( |  | ) | const
| inline override virtual

Returns
  the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 29 of file serpent.h.

29{ return "Serpent"; }

## ◆ parallel_bytes()

size_t Botan::BlockCipher::parallel_bytes | ( |  | ) | const
| inline inherited

Returns
  prefererred parallelism of this cipher in bytes

Definition at line 64 of file block_cipher.h.

65 {
66 return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
67 }
Botan::BlockCipher::parallelism
virtual size_t parallelism() const
Definition: block_cipher.h:59

Referenced by Botan::CBC_Mode::update_granularity().

## ◆ parallelism()

size_t Botan::Serpent::parallelism | ( |  | ) | const
| inline override virtual

Returns
  native parallelism of this cipher in blocks

Reimplemented from Botan::BlockCipher.

Definition at line 32 of file serpent.h.

32{ return 4; }

## ◆ provider()

std::string Botan::Serpent::provider | ( |  | ) | const
| override virtual

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

Reimplemented from Botan::BlockCipher.

Definition at line 278 of file serpent.cpp.

279 {
280#if defined(BOTAN_HAS_SERPENT_AVX2)
281 if(CPUID::has_avx2())
282 {
283 return "avx2";
284 }
285#endif
286
287#if defined(BOTAN_HAS_SERPENT_SIMD)
288 if(CPUID::has_simd_32())
289 {
290 return "simd";
291 }
292#endif
293
294 return "base";
295 }

References Botan::CPUID::has_simd_32().

## ◆ providers()

std::vector< std::string > Botan::BlockCipher::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 343 of file block_cipher.cpp.

344 {
345 return probe_providers_of<BlockCipher>(algo, { "base", "openssl", "commoncrypto" });
346 }

## ◆ set_key() [1/3]

template<typename Alloc >

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

Definition at line 153 of file sym_algo.h.

154 {
155 set_key(key.data(), key.size());
156 }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:147

## ◆ set_key() [2/3]

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

148 {
149 set_key(key.begin(), key.length());
150 }

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().

## ◆ set_key() [3/3]

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.

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:138
Botan::SymmetricAlgorithm::name
virtual std::string name() const =0

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

## ◆ valid_keylength()

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

139 {
140 return key_spec().valid_keylength(length);
141 }
Botan::Key_Length_Specification::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:52

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

## ◆ verify_key_set()

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

Definition at line 171 of file sym_algo.h.

172 {
173 if(cond == false)
174 throw_key_not_set_error();
175 }

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

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

- src/lib/block/serpent/serpent.h
- src/lib/block/serpent/serpent.cpp
- src/lib/block/serpent/serpent_avx2/serpent_avx2.cpp
- src/lib/block/serpent/serpent_simd/serpent_simd.cpp