Botan::Serpent Class Reference

#include <serpent.h>

Inheritance diagram for Botan::Serpent:

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
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< BlockCipher >	new_object () const override
size_t	parallel_bytes () const
size_t	parallelism () const override
std::string	provider () const override
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< 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)

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

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

Definition at line 20 of file serpent.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

Definition at line 234 of file block_cipher.h.

{ BLOCK_SIZE = BS }; /* NOLINT(*-enum-size,*-use-enum-class) */

Member Function Documentation

assert_key_material_set() [1/2]

void Botan::SymmetricAlgorithm::assert_key_material_set ( ) const

inlineprotectedinherited

Throw Key_Not_Set unless a key has been set on this object

Definition at line 180 of file sym_algo.h.

{ assert_key_material_set(has_keying_material()); }

Referenced by Botan::Serpent::decrypt_n(), Botan::Twofish::decrypt_n(), Botan::Serpent::encrypt_n(), and Botan::Twofish::encrypt_n().

assert_key_material_set() [2/2]

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

inlineprotectedinherited

Throw Key_Not_Set unless the predicate holds

Parameters

predicate

if false, a Key_Not_Set exception is thrown

Definition at line 186 of file sym_algo.h.

                                                         {
         if(!predicate) {
            throw_key_not_set_error();
         }
      }

block_size()

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, KMOD, BlockCipher >::block_size ( ) const

inlinefinalvirtualinherited

Return the block size of this cipher

Returns

the fixed block size BS

Implements Botan::BlockCipher.

Definition at line 240 of file block_cipher.h.

{ 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 390 of file serpent.cpp.

                    {
   zap(m_round_key);
}

References Botan::zap().

clone()

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

inlineinherited

Create a new uninitialized object of the same type

Returns

new object representing the same algorithm as *this

Definition at line 210 of file block_cipher.h.

{ return this->new_object().release(); }

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_spec	algorithm name
provider	provider implementation to choose

Returns

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

Definition at line 31 of file block_cipher.cpp.

                                                                                           {
#if defined(BOTAN_HAS_COMMONCRYPTO)
   if(provider.empty() || provider == "commoncrypto") {
      if(auto bc = make_commoncrypto_block_cipher(algo))
         return bc;
 
      if(!provider.empty())
         return nullptr;
   }
#endif
 
   // TODO: CryptoAPI
   // TODO: /dev/crypto
 
   // Only base providers from here on out
   if(provider.empty() == false && provider != "base") {
      return nullptr;
   }
 
#if defined(BOTAN_HAS_AES)
   if(algo == "AES-128") {
      return std::make_unique<AES_128>();
   }
 
   if(algo == "AES-192") {
      return std::make_unique<AES_192>();
   }
 
   if(algo == "AES-256") {
      return std::make_unique<AES_256>();
   }
#endif
 
#if defined(BOTAN_HAS_ARIA)
   if(algo == "ARIA-128") {
      return std::make_unique<ARIA_128>();
   }
 
   if(algo == "ARIA-192") {
      return std::make_unique<ARIA_192>();
   }
 
   if(algo == "ARIA-256") {
      return std::make_unique<ARIA_256>();
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT)
   if(algo == "Serpent") {
      return std::make_unique<Serpent>();
   }
#endif
 
#if defined(BOTAN_HAS_SHACAL2)
   if(algo == "SHACAL2") {
      return std::make_unique<SHACAL2>();
   }
#endif
 
#if defined(BOTAN_HAS_TWOFISH)
   if(algo == "Twofish") {
      return std::make_unique<Twofish>();
   }
#endif
 
#if defined(BOTAN_HAS_THREEFISH_512)
   if(algo == "Threefish-512") {
      return std::make_unique<Threefish_512>();
   }
#endif
 
#if defined(BOTAN_HAS_BLOWFISH)
   if(algo == "Blowfish") {
      return std::make_unique<Blowfish>();
   }
#endif
 
#if defined(BOTAN_HAS_CAMELLIA)
   if(algo == "Camellia-128") {
      return std::make_unique<Camellia_128>();
   }
 
   if(algo == "Camellia-192") {
      return std::make_unique<Camellia_192>();
   }
 
   if(algo == "Camellia-256") {
      return std::make_unique<Camellia_256>();
   }
#endif
 
#if defined(BOTAN_HAS_DES)
   if(algo == "DES") {
      return std::make_unique<DES>();
   }
 
   if(algo == "TripleDES" || algo == "3DES" || algo == "DES-EDE") {
      return std::make_unique<TripleDES>();
   }
#endif
 
#if defined(BOTAN_HAS_NOEKEON)
   if(algo == "Noekeon") {
      return std::make_unique<Noekeon>();
   }
#endif
 
#if defined(BOTAN_HAS_CAST_128)
   if(algo == "CAST-128" || algo == "CAST5") {
      return std::make_unique<CAST_128>();
   }
#endif
 
#if defined(BOTAN_HAS_IDEA)
   if(algo == "IDEA") {
      return std::make_unique<IDEA>();
   }
#endif
 
#if defined(BOTAN_HAS_KUZNYECHIK)
   if(algo == "Kuznyechik") {
      return std::make_unique<Kuznyechik>();
   }
#endif
 
#if defined(BOTAN_HAS_SEED)
   if(algo == "SEED") {
      return std::make_unique<SEED>();
   }
#endif
 
#if defined(BOTAN_HAS_SM4)
   if(algo == "SM4") {
      return std::make_unique<SM4>();
   }
#endif
 
   const SCAN_Name req(algo);
 
#if defined(BOTAN_HAS_GOST_28147_89)
   if(req.algo_name() == "GOST-28147-89") {
      return std::make_unique<GOST_28147_89>(req.arg(0, "R3411_94_TestParam"));
   }
#endif
 
#if defined(BOTAN_HAS_CASCADE)
   if(req.algo_name() == "Cascade" && req.arg_count() == 2) {
      auto c1 = BlockCipher::create(req.arg(0));
      auto c2 = BlockCipher::create(req.arg(1));
 
      if(c1 && c2) {
         return std::make_unique<Cascade_Cipher>(std::move(c1), std::move(c2));
      }
   }
#endif
 
#if defined(BOTAN_HAS_LION)
   if(req.algo_name() == "Lion" && req.arg_count_between(2, 3)) {
      auto hash = HashFunction::create(req.arg(0));
      auto stream = StreamCipher::create(req.arg(1));
 
      if(hash && stream) {
         const size_t block_size = req.arg_as_integer(2, 1024);
         return std::make_unique<Lion>(std::move(hash), std::move(stream), block_size);
      }
   }
#endif
 
   BOTAN_UNUSED(req);
   BOTAN_UNUSED(provider);
 
   return nullptr;
}

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.

                                                                                                    {
   if(auto bc = BlockCipher::create(algo, provider)) {
      return bc;
   }
   throw Lookup_Error("Block cipher", algo, provider);
}

decrypt() [1/4]

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

inlineinherited

Decrypt a block.

Parameters

in	The ciphertext block to be decrypted 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 96 of file block_cipher.h.

{ decrypt_n(in, out, 1); }

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

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

Definition at line 144 of file block_cipher.h.

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

decrypt() [3/4]

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

inlineinherited

Decrypt one or more blocks

Parameters

Block Ciphers

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

Definition at line 126 of file block_cipher.h.

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

decrypt() [4/4]

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

inlineinherited

Decrypt a block.

Parameters

Block Ciphers

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

Definition at line 112 of file block_cipher.h.

{ 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

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 174 of file serpent.cpp.

                                                                              {
   using namespace Botan::Serpent_F;
 
   assert_key_material_set();
 
#if defined(BOTAN_HAS_SERPENT_AVX512)
   if(CPUID::has(CPUID::Feature::AVX512)) {
      while(blocks >= 16) {
         avx512_decrypt_16(in, out);
         in += 16 * BLOCK_SIZE;
         out += 16 * BLOCK_SIZE;
         blocks -= 16;
      }
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT_AVX2)
   if(CPUID::has(CPUID::Feature::AVX2)) {
      while(blocks >= 8) {
         avx2_decrypt_8(in, out);
         in += 8 * BLOCK_SIZE;
         out += 8 * BLOCK_SIZE;
         blocks -= 8;
      }
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT_SIMD)
   if(CPUID::has(CPUID::Feature::SIMD_4X32)) {
      while(blocks >= 4) {
         simd_decrypt_4(in, out);
         in += 4 * BLOCK_SIZE;
         out += 4 * BLOCK_SIZE;
         blocks -= 4;
      }
   }
#endif
 
   const Key_Inserter key_xor(m_round_key.data());
 
   for(size_t i = 0; i < blocks; ++i) {
      uint32_t B0 = 0;
      uint32_t B1 = 0;
      uint32_t B2 = 0;
      uint32_t B3 = 0;
      load_le(in + 16 * i, B0, B1, B2, B3);
 
      key_xor(32, B0, B1, B2, B3);
      SBoxD7(B0, B1, B2, B3);
      key_xor(31, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD6(B0, B1, B2, B3);
      key_xor(30, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD5(B0, B1, B2, B3);
      key_xor(29, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD4(B0, B1, B2, B3);
      key_xor(28, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD3(B0, B1, B2, B3);
      key_xor(27, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD2(B0, B1, B2, B3);
      key_xor(26, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD1(B0, B1, B2, B3);
      key_xor(25, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD0(B0, B1, B2, B3);
      key_xor(24, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD7(B0, B1, B2, B3);
      key_xor(23, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD6(B0, B1, B2, B3);
      key_xor(22, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD5(B0, B1, B2, B3);
      key_xor(21, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD4(B0, B1, B2, B3);
      key_xor(20, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD3(B0, B1, B2, B3);
      key_xor(19, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD2(B0, B1, B2, B3);
      key_xor(18, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD1(B0, B1, B2, B3);
      key_xor(17, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD0(B0, B1, B2, B3);
      key_xor(16, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD7(B0, B1, B2, B3);
      key_xor(15, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD6(B0, B1, B2, B3);
      key_xor(14, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD5(B0, B1, B2, B3);
      key_xor(13, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD4(B0, B1, B2, B3);
      key_xor(12, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD3(B0, B1, B2, B3);
      key_xor(11, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD2(B0, B1, B2, B3);
      key_xor(10, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD1(B0, B1, B2, B3);
      key_xor(9, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD0(B0, B1, B2, B3);
      key_xor(8, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD7(B0, B1, B2, B3);
      key_xor(7, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD6(B0, B1, B2, B3);
      key_xor(6, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD5(B0, B1, B2, B3);
      key_xor(5, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD4(B0, B1, B2, B3);
      key_xor(4, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD3(B0, B1, B2, B3);
      key_xor(3, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD2(B0, B1, B2, B3);
      key_xor(2, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD1(B0, B1, B2, B3);
      key_xor(1, B0, B1, B2, B3);
      i_transform(B0, B1, B2, B3);
      SBoxD0(B0, B1, B2, B3);
      key_xor(0, B0, B1, B2, B3);
 
      store_le(out + 16 * i, B0, B1, B2, B3);
   }
}

References Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::assert_key_material_set(), Botan::CPUFeature::AVX2, Botan::CPUFeature::AVX512, Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::BLOCK_SIZE, Botan::CPUID::has(), Botan::Serpent_F::i_transform(), Botan::load_le(), Botan::Serpent_F::SBoxD0(), Botan::Serpent_F::SBoxD1(), Botan::Serpent_F::SBoxD2(), Botan::Serpent_F::SBoxD3(), Botan::Serpent_F::SBoxD4(), Botan::Serpent_F::SBoxD5(), Botan::Serpent_F::SBoxD6(), Botan::Serpent_F::SBoxD7(), Botan::CPUFeature::SIMD_4X32, and Botan::store_le().

decrypt_n_xex()

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

inlineinherited

Decrypt blocks in XEX mode: XOR with the mask, decrypt, then XOR again

Parameters

data	the input/output buffer of blocks*block_size() bytes
mask	the mask to XOR with, same size as data
blocks	the number of blocks to process

Definition at line 189 of file block_cipher.h.

                                                                                    {
         const size_t BS = block_size();
         for(size_t i = 0; i != blocks * BS; ++i) {
            data[i] ^= mask[i];
         }
         decrypt_n(data, data, blocks);
         for(size_t i = 0; i != blocks * BS; ++i) {
            data[i] ^= mask[i];
         }
      }

encrypt() [1/4]

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

inlineinherited

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

{ encrypt_n(in, out, 1); }

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

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

Definition at line 135 of file block_cipher.h.

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

encrypt() [3/4]

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

inlineinherited

Encrypt one or more blocks

Parameters

Block Ciphers

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

Definition at line 118 of file block_cipher.h.

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

encrypt() [4/4]

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

inlineinherited

Encrypt a block.

Parameters

Block Ciphers

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

Definition at line 104 of file block_cipher.h.

{ 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

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 23 of file serpent.cpp.

                                                                              {
   using namespace Botan::Serpent_F;
 
   assert_key_material_set();
 
#if defined(BOTAN_HAS_SERPENT_AVX512)
   if(CPUID::has(CPUID::Feature::AVX512)) {
      while(blocks >= 16) {
         avx512_encrypt_16(in, out);
         in += 16 * BLOCK_SIZE;
         out += 16 * BLOCK_SIZE;
         blocks -= 16;
      }
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT_AVX2)
   if(CPUID::has(CPUID::Feature::AVX2)) {
      while(blocks >= 8) {
         avx2_encrypt_8(in, out);
         in += 8 * BLOCK_SIZE;
         out += 8 * BLOCK_SIZE;
         blocks -= 8;
      }
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT_SIMD)
   if(CPUID::has(CPUID::Feature::SIMD_4X32)) {
      while(blocks >= 4) {
         simd_encrypt_4(in, out);
         in += 4 * BLOCK_SIZE;
         out += 4 * BLOCK_SIZE;
         blocks -= 4;
      }
   }
#endif
 
   const Key_Inserter key_xor(m_round_key.data());
 
   for(size_t i = 0; i < blocks; ++i) {
      uint32_t B0 = 0;
      uint32_t B1 = 0;
      uint32_t B2 = 0;
      uint32_t B3 = 0;
      load_le(in + 16 * i, B0, B1, B2, B3);
 
      key_xor(0, B0, B1, B2, B3);
      SBoxE0(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(1, B0, B1, B2, B3);
      SBoxE1(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(2, B0, B1, B2, B3);
      SBoxE2(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(3, B0, B1, B2, B3);
      SBoxE3(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(4, B0, B1, B2, B3);
      SBoxE4(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(5, B0, B1, B2, B3);
      SBoxE5(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(6, B0, B1, B2, B3);
      SBoxE6(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(7, B0, B1, B2, B3);
      SBoxE7(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(8, B0, B1, B2, B3);
      SBoxE0(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(9, B0, B1, B2, B3);
      SBoxE1(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(10, B0, B1, B2, B3);
      SBoxE2(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(11, B0, B1, B2, B3);
      SBoxE3(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(12, B0, B1, B2, B3);
      SBoxE4(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(13, B0, B1, B2, B3);
      SBoxE5(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(14, B0, B1, B2, B3);
      SBoxE6(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(15, B0, B1, B2, B3);
      SBoxE7(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(16, B0, B1, B2, B3);
      SBoxE0(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(17, B0, B1, B2, B3);
      SBoxE1(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(18, B0, B1, B2, B3);
      SBoxE2(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(19, B0, B1, B2, B3);
      SBoxE3(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(20, B0, B1, B2, B3);
      SBoxE4(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(21, B0, B1, B2, B3);
      SBoxE5(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(22, B0, B1, B2, B3);
      SBoxE6(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(23, B0, B1, B2, B3);
      SBoxE7(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(24, B0, B1, B2, B3);
      SBoxE0(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(25, B0, B1, B2, B3);
      SBoxE1(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(26, B0, B1, B2, B3);
      SBoxE2(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(27, B0, B1, B2, B3);
      SBoxE3(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(28, B0, B1, B2, B3);
      SBoxE4(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(29, B0, B1, B2, B3);
      SBoxE5(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(30, B0, B1, B2, B3);
      SBoxE6(B0, B1, B2, B3);
      transform(B0, B1, B2, B3);
      key_xor(31, B0, B1, B2, B3);
      SBoxE7(B0, B1, B2, B3);
      key_xor(32, B0, B1, B2, B3);
 
      store_le(out + 16 * i, B0, B1, B2, B3);
   }
}

References Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::assert_key_material_set(), Botan::CPUFeature::AVX2, Botan::CPUFeature::AVX512, Botan::Block_Cipher_Fixed_Params< 16, 16, 32, 8 >::BLOCK_SIZE, Botan::CPUID::has(), Botan::load_le(), Botan::Serpent_F::SBoxE0(), Botan::Serpent_F::SBoxE1(), Botan::Serpent_F::SBoxE2(), Botan::Serpent_F::SBoxE3(), Botan::Serpent_F::SBoxE4(), Botan::Serpent_F::SBoxE5(), Botan::Serpent_F::SBoxE6(), Botan::Serpent_F::SBoxE7(), Botan::CPUFeature::SIMD_4X32, Botan::store_le(), and Botan::Serpent_F::transform().

encrypt_n_xex()

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

inlineinherited

Encrypt blocks in XEX mode: XOR with the mask, encrypt, then XOR again

Parameters

data	the input/output buffer of blocks*block_size() bytes
mask	the mask to XOR with, same size as data
blocks	the number of blocks to process

Definition at line 171 of file block_cipher.h.

                                                                                    {
         const size_t BS = block_size();
         for(size_t i = 0; i != blocks * BS; ++i) {
            data[i] ^= mask[i];
         }
         encrypt_n(data, data, blocks);
         for(size_t i = 0; i != blocks * BS; ++i) {
            data[i] ^= mask[i];
         }
      }

has_keying_material()

bool Botan::Serpent::has_keying_material ( ) const

overridevirtual

Test whether a key has been set on this object

Returns

true if a key has been set on this object

Implements Botan::SymmetricAlgorithm.

Definition at line 322 of file serpent.cpp.

                                        {
   return !m_round_key.empty();
}

key_spec()

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, KMAX, KMOD, BlockCipher >::key_spec ( ) const

inlinefinalvirtualinherited

Return the key lengths supported by this cipher

Returns

the fixed key length specification

Implements Botan::SymmetricAlgorithm.

Definition at line 246 of file block_cipher.h.

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

maximum_keylength()

size_t Botan::SymmetricAlgorithm::maximum_keylength ( ) const

inlineinherited

Return the largest acceptable key length

Returns

maximum allowed key length

Definition at line 130 of file sym_algo.h.

{ return key_spec().maximum_keylength(); }

minimum_keylength()

size_t Botan::SymmetricAlgorithm::minimum_keylength ( ) const

inlineinherited

Return the smallest acceptable key length

Returns

minimum allowed key length

Definition at line 136 of file sym_algo.h.

{ return key_spec().minimum_keylength(); }

name()

std::string Botan::Serpent::name ( ) const

inlineoverridevirtual

Return the name of this algorithm

Returns

the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 28 of file serpent.h.

{ return "Serpent"; }

new_object()

std::unique_ptr< BlockCipher > Botan::Serpent::new_object ( ) const

inlineoverridevirtual

Create a new uninitialized object of the same type

Returns

new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 30 of file serpent.h.

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

parallel_bytes()

size_t Botan::BlockCipher::parallel_bytes ( ) const

inlineinherited

Return the preferred input size for bulk processing

Returns

preferred parallelism of this cipher in bytes

Definition at line 71 of file block_cipher.h.

{ return parallelism() * block_size() * BlockCipher::ParallelismMult; }

parallelism()

size_t Botan::Serpent::parallelism ( ) const

inlineoverridevirtual

Return how many blocks this cipher processes in parallel

Returns

native parallelism of this cipher in blocks

Reimplemented from Botan::BlockCipher.

Definition at line 32 of file serpent.h.

{ return 4; }

provider()

std::string Botan::Serpent::provider ( ) const

overridevirtual

Return the name of the provider implementing this object

Returns

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

Reimplemented from Botan::BlockCipher.

Definition at line 394 of file serpent.cpp.

                                  {
#if defined(BOTAN_HAS_SERPENT_AVX512)
   if(auto feat = CPUID::check(CPUID::Feature::AVX512)) {
      return *feat;
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT_AVX2)
   if(auto feat = CPUID::check(CPUID::Feature::AVX2)) {
      return *feat;
   }
#endif
 
#if defined(BOTAN_HAS_SERPENT_SIMD)
   if(auto feat = CPUID::check(CPUID::Feature::SIMD_4X32)) {
      return *feat;
   }
#endif
 
   return "base";
}

References Botan::CPUFeature::AVX2, Botan::CPUFeature::AVX512, Botan::CPUID::check(), and Botan::CPUFeature::SIMD_4X32.

providers()

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

staticinherited

List the providers available for a given block cipher

Returns

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

Parameters

algo_spec

algorithm name

Definition at line 45 of file block_cipher.cpp.

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

set_key() [1/3]

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

inherited

Set the symmetric key of this object.

Parameters

key	the SymmetricKey to be set.

Definition at line 149 of file sym_algo.cpp.

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

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

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

Definition at line 162 of file sym_algo.h.

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

set_key() [3/3]

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

inherited

Set the symmetric key of this object.

Parameters

key	the contiguous byte range to be set.

Definition at line 155 of file sym_algo.cpp.

                                                           {
   if(!valid_keylength(key.size())) {
      throw Invalid_Key_Length(name(), key.size());
   }
   key_schedule(key);
}

valid_keylength()

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

inlineinherited

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

{ return key_spec().valid_keylength(length); }

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

---

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_avx512/serpent_avx512.cpp
• src/lib/block/serpent/serpent_simd/serpent_simd.cpp