Botan 3.2.0
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:
Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 > Botan::BlockCipher Botan::SymmetricAlgorithm

Public Types

enum  
 

Public Member Functions

size_t block_size () const final
 
void clear () override
 
BlockCipher * clone () 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 final
 
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 final
 
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< BlockCipher > new_object () const override
 
size_t parallel_bytes () const
 
size_t parallelism () const override
 
std::string provider () const override
 
void set_key (const SymmetricKey &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< BlockCipher > create (std::string_view algo_spec, std::string_view provider="")
 
static std::unique_ptr< BlockCipher > create_or_throw (std::string_view algo_spec, 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
 

Detailed Description

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

Definition at line 19 of file serpent.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
inherited

Definition at line 196 of file block_cipher.h.

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

Member Function Documentation

◆ assert_key_material_set() [1/2]

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

Definition at line 139 of file sym_algo.h.

139{ assert_key_material_set(has_keying_material()); }
Botan::SymmetricAlgorithm::has_keying_material
virtual bool has_keying_material() const =0
Botan::SymmetricAlgorithm::assert_key_material_set
void assert_key_material_set() const
Definition sym_algo.h:139

References Botan::SymmetricAlgorithm::assert_key_material_set().

Referenced by Botan::SymmetricAlgorithm::assert_key_material_set(), Botan::Salsa20::cipher_bytes(), 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::DES::decrypt_n(), Botan::TripleDES::decrypt_n(), Botan::GOST_28147_89::decrypt_n(), Botan::IDEA::decrypt_n(), Botan::Kuznyechik::decrypt_n(), Botan::Lion::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::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::DES::encrypt_n(), Botan::TripleDES::encrypt_n(), Botan::GOST_28147_89::encrypt_n(), Botan::IDEA::encrypt_n(), Botan::Kuznyechik::encrypt_n(), Botan::Lion::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::GHASH::final(), Botan::GHASH::ghash_update(), Botan::ChaCha::seek(), Botan::CTR_BE::seek(), Botan::Salsa20::seek(), Botan::OCB_Mode::set_associated_data_n(), Botan::Salsa20::set_iv_bytes(), Botan::GHASH::update(), and Botan::GHASH::update_associated_data().

◆ assert_key_material_set() [2/2]

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

Definition at line 141 of file sym_algo.h.

141 {
142 if(!predicate) {
143 throw_key_not_set_error();
144 }
145 }

◆ block_size()

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

Implements Botan::BlockCipher.

Definition at line 198 of file block_cipher.h.

198{ return BS; }

◆ clear()

void Botan::Serpent::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 384 of file serpent.cpp.

384 {
385 zap(m_round_key);
386}
Botan::zap
void zap(std::vector< T, Alloc > &vec)
Definition secmem.h:117

References Botan::zap().

◆ clone()

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

Definition at line 170 of file block_cipher.h.

170{ return this->new_object().release(); }
Botan::BlockCipher::new_object
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 91 of file block_cipher.cpp.

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

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(), 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 ( 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 266 of file block_cipher.cpp.

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

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

Referenced by botan_nist_kw_dec(), botan_nist_kw_enc(), 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]

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 83 of file block_cipher.h.

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

Referenced by Botan::nist_key_unwrap(), and Botan::nist_key_unwrap_padded().

◆ 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 131 of file block_cipher.h.

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

◆ 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 113 of file block_cipher.h.

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

◆ 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 99 of file block_cipher.h.

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

◆ decrypt_n()

void Botan::Serpent::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 171 of file serpent.cpp.

171 {
172 using namespace Botan::Serpent_F;
173
174 assert_key_material_set();
175
176#if defined(BOTAN_HAS_SERPENT_AVX512)
177 if(CPUID::has_avx512()) {
178 while(blocks >= 16) {
179 avx512_decrypt_16(in, out);
180 in += 16 * BLOCK_SIZE;
181 out += 16 * BLOCK_SIZE;
182 blocks -= 16;
183 }
184 }
185#endif
186
187#if defined(BOTAN_HAS_SERPENT_AVX2)
188 if(CPUID::has_avx2()) {
189 while(blocks >= 8) {
190 avx2_decrypt_8(in, out);
191 in += 8 * BLOCK_SIZE;
192 out += 8 * BLOCK_SIZE;
193 blocks -= 8;
194 }
195 }
196#endif
197
198#if defined(BOTAN_HAS_SERPENT_SIMD)
199 if(CPUID::has_simd_32()) {
200 while(blocks >= 4) {
201 simd_decrypt_4(in, out);
202 in += 4 * BLOCK_SIZE;
203 out += 4 * BLOCK_SIZE;
204 blocks -= 4;
205 }
206 }
207#endif
208
209 const Key_Inserter key_xor(m_round_key.data());
210
211 BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i) {
212 uint32_t B0, B1, B2, B3;
213 load_le(in + 16 * i, B0, B1, B2, B3);
214
215 key_xor(32, B0, B1, B2, B3);
216 SBoxD7(B0, B1, B2, B3);
217 key_xor(31, B0, B1, B2, B3);
218 i_transform(B0, B1, B2, B3);
219 SBoxD6(B0, B1, B2, B3);
220 key_xor(30, B0, B1, B2, B3);
221 i_transform(B0, B1, B2, B3);
222 SBoxD5(B0, B1, B2, B3);
223 key_xor(29, B0, B1, B2, B3);
224 i_transform(B0, B1, B2, B3);
225 SBoxD4(B0, B1, B2, B3);
226 key_xor(28, B0, B1, B2, B3);
227 i_transform(B0, B1, B2, B3);
228 SBoxD3(B0, B1, B2, B3);
229 key_xor(27, B0, B1, B2, B3);
230 i_transform(B0, B1, B2, B3);
231 SBoxD2(B0, B1, B2, B3);
232 key_xor(26, B0, B1, B2, B3);
233 i_transform(B0, B1, B2, B3);
234 SBoxD1(B0, B1, B2, B3);
235 key_xor(25, B0, B1, B2, B3);
236 i_transform(B0, B1, B2, B3);
237 SBoxD0(B0, B1, B2, B3);
238 key_xor(24, B0, B1, B2, B3);
239 i_transform(B0, B1, B2, B3);
240 SBoxD7(B0, B1, B2, B3);
241 key_xor(23, B0, B1, B2, B3);
242 i_transform(B0, B1, B2, B3);
243 SBoxD6(B0, B1, B2, B3);
244 key_xor(22, B0, B1, B2, B3);
245 i_transform(B0, B1, B2, B3);
246 SBoxD5(B0, B1, B2, B3);
247 key_xor(21, B0, B1, B2, B3);
248 i_transform(B0, B1, B2, B3);
249 SBoxD4(B0, B1, B2, B3);
250 key_xor(20, B0, B1, B2, B3);
251 i_transform(B0, B1, B2, B3);
252 SBoxD3(B0, B1, B2, B3);
253 key_xor(19, B0, B1, B2, B3);
254 i_transform(B0, B1, B2, B3);
255 SBoxD2(B0, B1, B2, B3);
256 key_xor(18, B0, B1, B2, B3);
257 i_transform(B0, B1, B2, B3);
258 SBoxD1(B0, B1, B2, B3);
259 key_xor(17, B0, B1, B2, B3);
260 i_transform(B0, B1, B2, B3);
261 SBoxD0(B0, B1, B2, B3);
262 key_xor(16, B0, B1, B2, B3);
263 i_transform(B0, B1, B2, B3);
264 SBoxD7(B0, B1, B2, B3);
265 key_xor(15, B0, B1, B2, B3);
266 i_transform(B0, B1, B2, B3);
267 SBoxD6(B0, B1, B2, B3);
268 key_xor(14, B0, B1, B2, B3);
269 i_transform(B0, B1, B2, B3);
270 SBoxD5(B0, B1, B2, B3);
271 key_xor(13, B0, B1, B2, B3);
272 i_transform(B0, B1, B2, B3);
273 SBoxD4(B0, B1, B2, B3);
274 key_xor(12, B0, B1, B2, B3);
275 i_transform(B0, B1, B2, B3);
276 SBoxD3(B0, B1, B2, B3);
277 key_xor(11, B0, B1, B2, B3);
278 i_transform(B0, B1, B2, B3);
279 SBoxD2(B0, B1, B2, B3);
280 key_xor(10, B0, B1, B2, B3);
281 i_transform(B0, B1, B2, B3);
282 SBoxD1(B0, B1, B2, B3);
283 key_xor(9, B0, B1, B2, B3);
284 i_transform(B0, B1, B2, B3);
285 SBoxD0(B0, B1, B2, B3);
286 key_xor(8, B0, B1, B2, B3);
287 i_transform(B0, B1, B2, B3);
288 SBoxD7(B0, B1, B2, B3);
289 key_xor(7, B0, B1, B2, B3);
290 i_transform(B0, B1, B2, B3);
291 SBoxD6(B0, B1, B2, B3);
292 key_xor(6, B0, B1, B2, B3);
293 i_transform(B0, B1, B2, B3);
294 SBoxD5(B0, B1, B2, B3);
295 key_xor(5, B0, B1, B2, B3);
296 i_transform(B0, B1, B2, B3);
297 SBoxD4(B0, B1, B2, B3);
298 key_xor(4, B0, B1, B2, B3);
299 i_transform(B0, B1, B2, B3);
300 SBoxD3(B0, B1, B2, B3);
301 key_xor(3, B0, B1, B2, B3);
302 i_transform(B0, B1, B2, B3);
303 SBoxD2(B0, B1, B2, B3);
304 key_xor(2, B0, B1, B2, B3);
305 i_transform(B0, B1, B2, B3);
306 SBoxD1(B0, B1, B2, B3);
307 key_xor(1, B0, B1, B2, B3);
308 i_transform(B0, B1, B2, B3);
309 SBoxD0(B0, B1, B2, B3);
310 key_xor(0, B0, B1, B2, B3);
311
312 store_le(out + 16 * i, B0, B1, B2, B3);
313 }
314}
Botan::CPUID::has_simd_32
static bool has_simd_32()
Definition cpuid.cpp:18
Botan::Serpent_F::Key_Inserter
Definition serpent_fn.h:54
BOTAN_PARALLEL_SIMD_FOR
#define BOTAN_PARALLEL_SIMD_FOR
Definition compiler.h:167
Botan::Serpent_F
Definition serpent_fn.h:13
Botan::Serpent_F::i_transform
BOTAN_FORCE_INLINE void i_transform(T &B0, T &B1, T &B2, T &B3)
Definition serpent_fn.h:41
Botan::store_le
constexpr void store_le(uint16_t in, uint8_t out[2])
Definition loadstor.h:405
Botan::SBoxD4
BOTAN_FORCE_INLINE void SBoxD4(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:200
Botan::SBoxD5
BOTAN_FORCE_INLINE void SBoxD5(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:216
Botan::load_le
constexpr T load_le(const uint8_t in[], size_t off)
Definition loadstor.h:108
Botan::SBoxD0
BOTAN_FORCE_INLINE void SBoxD0(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:139
Botan::SBoxD1
BOTAN_FORCE_INLINE void SBoxD1(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:154
Botan::SBoxD6
BOTAN_FORCE_INLINE void SBoxD6(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:232
Botan::SBoxD2
BOTAN_FORCE_INLINE void SBoxD2(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:169
Botan::SBoxD3
BOTAN_FORCE_INLINE void SBoxD3(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:184
Botan::SBoxD7
BOTAN_FORCE_INLINE void SBoxD7(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:248

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

◆ 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
inlinefinalvirtualinherited

Reimplemented from Botan::BlockCipher.

Definition at line 207 of file block_cipher.h.

207 {
208 xor_buf(data, mask, blocks * BS);
209 this->decrypt_n(data, data, blocks);
210 xor_buf(data, mask, blocks * BS);
211 }
Botan::xor_buf
void xor_buf(uint8_t out[], const uint8_t in[], size_t length)
Definition mem_ops.h:237

◆ 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 74 of file block_cipher.h.

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

Referenced by Botan::nist_key_wrap(), Botan::nist_key_wrap_padded(), and Botan::CFB_Mode::shift_register().

◆ 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 122 of file block_cipher.h.

122 {
123 return encrypt_n(in.data(), out.data(), in.size() / block_size());
124 }

◆ 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 105 of file block_cipher.h.

105 {
106 return encrypt_n(block.data(), block.data(), block.size() / block_size());
107 }

◆ 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 91 of file block_cipher.h.

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

◆ encrypt_n()

void Botan::Serpent::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 23 of file serpent.cpp.

23 {
24 using namespace Botan::Serpent_F;
25
26 assert_key_material_set();
27
28#if defined(BOTAN_HAS_SERPENT_AVX512)
29 if(CPUID::has_avx512()) {
30 while(blocks >= 16) {
31 avx512_encrypt_16(in, out);
32 in += 16 * BLOCK_SIZE;
33 out += 16 * BLOCK_SIZE;
34 blocks -= 16;
35 }
36 }
37#endif
38
39#if defined(BOTAN_HAS_SERPENT_AVX2)
40 if(CPUID::has_avx2()) {
41 while(blocks >= 8) {
42 avx2_encrypt_8(in, out);
43 in += 8 * BLOCK_SIZE;
44 out += 8 * BLOCK_SIZE;
45 blocks -= 8;
46 }
47 }
48#endif
49
50#if defined(BOTAN_HAS_SERPENT_SIMD)
51 if(CPUID::has_simd_32()) {
52 while(blocks >= 4) {
53 simd_encrypt_4(in, out);
54 in += 4 * BLOCK_SIZE;
55 out += 4 * BLOCK_SIZE;
56 blocks -= 4;
57 }
58 }
59#endif
60
61 const Key_Inserter key_xor(m_round_key.data());
62
63 BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i) {
64 uint32_t B0, B1, B2, B3;
65 load_le(in + 16 * i, B0, B1, B2, B3);
66
67 key_xor(0, B0, B1, B2, B3);
68 SBoxE0(B0, B1, B2, B3);
69 transform(B0, B1, B2, B3);
70 key_xor(1, B0, B1, B2, B3);
71 SBoxE1(B0, B1, B2, B3);
72 transform(B0, B1, B2, B3);
73 key_xor(2, B0, B1, B2, B3);
74 SBoxE2(B0, B1, B2, B3);
75 transform(B0, B1, B2, B3);
76 key_xor(3, B0, B1, B2, B3);
77 SBoxE3(B0, B1, B2, B3);
78 transform(B0, B1, B2, B3);
79 key_xor(4, B0, B1, B2, B3);
80 SBoxE4(B0, B1, B2, B3);
81 transform(B0, B1, B2, B3);
82 key_xor(5, B0, B1, B2, B3);
83 SBoxE5(B0, B1, B2, B3);
84 transform(B0, B1, B2, B3);
85 key_xor(6, B0, B1, B2, B3);
86 SBoxE6(B0, B1, B2, B3);
87 transform(B0, B1, B2, B3);
88 key_xor(7, B0, B1, B2, B3);
89 SBoxE7(B0, B1, B2, B3);
90 transform(B0, B1, B2, B3);
91 key_xor(8, B0, B1, B2, B3);
92 SBoxE0(B0, B1, B2, B3);
93 transform(B0, B1, B2, B3);
94 key_xor(9, B0, B1, B2, B3);
95 SBoxE1(B0, B1, B2, B3);
96 transform(B0, B1, B2, B3);
97 key_xor(10, B0, B1, B2, B3);
98 SBoxE2(B0, B1, B2, B3);
99 transform(B0, B1, B2, B3);
100 key_xor(11, B0, B1, B2, B3);
101 SBoxE3(B0, B1, B2, B3);
102 transform(B0, B1, B2, B3);
103 key_xor(12, B0, B1, B2, B3);
104 SBoxE4(B0, B1, B2, B3);
105 transform(B0, B1, B2, B3);
106 key_xor(13, B0, B1, B2, B3);
107 SBoxE5(B0, B1, B2, B3);
108 transform(B0, B1, B2, B3);
109 key_xor(14, B0, B1, B2, B3);
110 SBoxE6(B0, B1, B2, B3);
111 transform(B0, B1, B2, B3);
112 key_xor(15, B0, B1, B2, B3);
113 SBoxE7(B0, B1, B2, B3);
114 transform(B0, B1, B2, B3);
115 key_xor(16, B0, B1, B2, B3);
116 SBoxE0(B0, B1, B2, B3);
117 transform(B0, B1, B2, B3);
118 key_xor(17, B0, B1, B2, B3);
119 SBoxE1(B0, B1, B2, B3);
120 transform(B0, B1, B2, B3);
121 key_xor(18, B0, B1, B2, B3);
122 SBoxE2(B0, B1, B2, B3);
123 transform(B0, B1, B2, B3);
124 key_xor(19, B0, B1, B2, B3);
125 SBoxE3(B0, B1, B2, B3);
126 transform(B0, B1, B2, B3);
127 key_xor(20, B0, B1, B2, B3);
128 SBoxE4(B0, B1, B2, B3);
129 transform(B0, B1, B2, B3);
130 key_xor(21, B0, B1, B2, B3);
131 SBoxE5(B0, B1, B2, B3);
132 transform(B0, B1, B2, B3);
133 key_xor(22, B0, B1, B2, B3);
134 SBoxE6(B0, B1, B2, B3);
135 transform(B0, B1, B2, B3);
136 key_xor(23, B0, B1, B2, B3);
137 SBoxE7(B0, B1, B2, B3);
138 transform(B0, B1, B2, B3);
139 key_xor(24, B0, B1, B2, B3);
140 SBoxE0(B0, B1, B2, B3);
141 transform(B0, B1, B2, B3);
142 key_xor(25, B0, B1, B2, B3);
143 SBoxE1(B0, B1, B2, B3);
144 transform(B0, B1, B2, B3);
145 key_xor(26, B0, B1, B2, B3);
146 SBoxE2(B0, B1, B2, B3);
147 transform(B0, B1, B2, B3);
148 key_xor(27, B0, B1, B2, B3);
149 SBoxE3(B0, B1, B2, B3);
150 transform(B0, B1, B2, B3);
151 key_xor(28, B0, B1, B2, B3);
152 SBoxE4(B0, B1, B2, B3);
153 transform(B0, B1, B2, B3);
154 key_xor(29, B0, B1, B2, B3);
155 SBoxE5(B0, B1, B2, B3);
156 transform(B0, B1, B2, B3);
157 key_xor(30, B0, B1, B2, B3);
158 SBoxE6(B0, B1, B2, B3);
159 transform(B0, B1, B2, B3);
160 key_xor(31, B0, B1, B2, B3);
161 SBoxE7(B0, B1, B2, B3);
162 key_xor(32, B0, B1, B2, B3);
163
164 store_le(out + 16 * i, B0, B1, B2, B3);
165 }
166}
Botan::Serpent_F::transform
BOTAN_FORCE_INLINE void transform(T &B0, T &B1, T &B2, T &B3)
Definition serpent_fn.h:24
Botan::SBoxE6
BOTAN_FORCE_INLINE void SBoxE6(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:107
Botan::SBoxE4
BOTAN_FORCE_INLINE void SBoxE4(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:75
Botan::SBoxE7
BOTAN_FORCE_INLINE void SBoxE7(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:123
Botan::SBoxE5
BOTAN_FORCE_INLINE void SBoxE5(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:91
Botan::SBoxE2
BOTAN_FORCE_INLINE void SBoxE2(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:43
Botan::SBoxE3
BOTAN_FORCE_INLINE void SBoxE3(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:59
Botan::SBoxE0
BOTAN_FORCE_INLINE void SBoxE0(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:13
Botan::SBoxE1
BOTAN_FORCE_INLINE void SBoxE1(SIMD_16x32 &a, SIMD_16x32 &b, SIMD_16x32 &c, SIMD_16x32 &d)
Definition serpent_avx512.cpp:28

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

◆ 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
inlinefinalvirtualinherited

Reimplemented from Botan::BlockCipher.

Definition at line 201 of file block_cipher.h.

201 {
202 xor_buf(data, mask, blocks * BS);
203 this->encrypt_n(data, data, blocks);
204 xor_buf(data, mask, blocks * BS);
205 }

◆ has_keying_material()

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

Implements Botan::SymmetricAlgorithm.

Definition at line 316 of file serpent.cpp.

316 {
317 return !m_round_key.empty();
318}

◆ key_spec()

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

Implements Botan::SymmetricAlgorithm.

Definition at line 213 of file block_cipher.h.

213{ return Key_Length_Specification(KMIN, KMAX, KMOD); }

◆ maximum_keylength()

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

Definition at line 95 of file sym_algo.h.

95{ return key_spec().maximum_keylength(); }
Botan::Key_Length_Specification::maximum_keylength
size_t maximum_keylength() const
Definition sym_algo.h:54
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

◆ minimum_keylength()

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

Definition at line 100 of file sym_algo.h.

100{ return key_spec().minimum_keylength(); }
Botan::Key_Length_Specification::minimum_keylength
size_t minimum_keylength() const
Definition sym_algo.h:49

◆ name()

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

Implements Botan::SymmetricAlgorithm.

Definition at line 27 of file serpent.h.

27{ return "Serpent"; }

◆ new_object()

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

Implements Botan::BlockCipher.

Definition at line 29 of file serpent.h.

29{ return std::make_unique<Serpent>(); }

◆ parallel_bytes()

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

Definition at line 59 of file block_cipher.h.

59{ return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT; }
Botan::BlockCipher::parallelism
virtual size_t parallelism() const
Definition block_cipher.h:54
BOTAN_BLOCK_CIPHER_PAR_MULT
#define BOTAN_BLOCK_CIPHER_PAR_MULT
Definition build.h:438

References BOTAN_BLOCK_CIPHER_PAR_MULT.

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

◆ parallelism()

size_t Botan::Serpent::parallelism ( ) const
inlineoverridevirtual
Returns
native parallelism of this cipher in blocks

Reimplemented from Botan::BlockCipher.

Definition at line 31 of file serpent.h.

31{ return 4; }

◆ provider()

std::string Botan::Serpent::provider ( ) const
overridevirtual
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 388 of file serpent.cpp.

388 {
389#if defined(BOTAN_HAS_SERPENT_AVX512)
390 if(CPUID::has_avx512()) {
391 return "avx512";
392 }
393#endif
394
395#if defined(BOTAN_HAS_SERPENT_AVX2)
396 if(CPUID::has_avx2()) {
397 return "avx2";
398 }
399#endif
400
401#if defined(BOTAN_HAS_SERPENT_SIMD)
402 if(CPUID::has_simd_32()) {
403 return "simd";
404 }
405#endif
406
407 return "base";
408}

References Botan::CPUID::has_simd_32().

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

273 {
274 return probe_providers_of<BlockCipher>(algo, {"base", "commoncrypto"});
275}

◆ set_key() [1/3]

void Botan::SymmetricAlgorithm::set_key ( const SymmetricKey &  key)
inlineinherited

Set the symmetric key of this object.

Parameters
keythe SymmetricKey to be set.

Definition at line 113 of file sym_algo.h.

113{ set_key(std::span{key.begin(), key.length()}); }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition sym_algo.h:113

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

Referenced by 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(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sodium::randombytes_buf_deterministic(), and Botan::SymmetricAlgorithm::set_key().

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

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

References Botan::SymmetricAlgorithm::set_key().

Referenced by Botan::SymmetricAlgorithm::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 17 of file sym_algo.cpp.

17 {
18 if(!valid_keylength(key.size())) {
19 throw Invalid_Key_Length(name(), key.size());
20 }
21 key_schedule(key);
22}
Botan::SymmetricAlgorithm::valid_keylength
bool valid_keylength(size_t length) const
Definition sym_algo.h:107
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
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 107 of file sym_algo.h.

107{ return key_spec().valid_keylength(length); }
Botan::Key_Length_Specification::valid_keylength
bool valid_keylength(size_t length) const
Definition sym_algo.h:42

Referenced by Botan::SymmetricAlgorithm::set_key().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.8