Botan  2.8.0
Crypto and TLS for C++11
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::GOST_28147_89 Class Referencefinal

#include <gost_28147.h>

Inheritance diagram for Botan::GOST_28147_89:
Botan::Block_Cipher_Fixed_Params< 8, 32 > Botan::BlockCipher Botan::SymmetricAlgorithm

Public Types

enum  
 

Public Member Functions

size_t block_size () const final override
 
void clear () override
 
BlockCipherclone () const override
 
void decrypt (const uint8_t in[], uint8_t out[]) const
 
void decrypt (uint8_t block[]) const
 
template<typename Alloc >
void decrypt (std::vector< uint8_t, Alloc > &block) const
 
template<typename Alloc , typename Alloc2 >
void decrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) 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
 
void encrypt (const uint8_t in[], uint8_t out[]) const
 
void encrypt (uint8_t block[]) const
 
template<typename Alloc >
void encrypt (std::vector< uint8_t, Alloc > &block) const
 
template<typename Alloc , typename Alloc2 >
void encrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) 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
 
 GOST_28147_89 (const GOST_28147_89_Params &params)
 
 GOST_28147_89 (const std::string &param_name)
 
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
 
virtual size_t parallelism () const
 
virtual std::string provider () const
 
void set_key (const SymmetricKey &key)
 
template<typename Alloc >
void set_key (const std::vector< uint8_t, Alloc > &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< BlockCiphercreate (const std::string &algo_spec, const std::string &provider="")
 
static std::unique_ptr< BlockCiphercreate_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

GOST 28147-89

Definition at line 58 of file gost_28147.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
inherited

Constructor & Destructor Documentation

◆ GOST_28147_89() [1/2]

Botan::GOST_28147_89::GOST_28147_89 ( const GOST_28147_89_Params params)
explicit
Parameters
paramsthe sbox parameters to use

Definition at line 60 of file gost_28147.cpp.

References Botan::GOST_28147_89_Params::sbox_pair().

60  : m_SBOX(1024)
61  {
62  // Convert the parallel 4x4 sboxes into larger word-based sboxes
63 
64  for(size_t i = 0; i != 256; ++i)
65  {
66  m_SBOX[i ] = rotl<11, uint32_t>(param.sbox_pair(0, i));
67  m_SBOX[i+256] = rotl<19, uint32_t>(param.sbox_pair(1, i));
68  m_SBOX[i+512] = rotl<27, uint32_t>(param.sbox_pair(2, i));
69  m_SBOX[i+768] = rotl< 3, uint32_t>(param.sbox_pair(3, i));
70  }
71  }

◆ GOST_28147_89() [2/2]

Botan::GOST_28147_89::GOST_28147_89 ( const std::string &  param_name)
inlineexplicit

Definition at line 74 of file gost_28147.h.

74  :
75  GOST_28147_89(GOST_28147_89_Params(param_name)) {}
GOST_28147_89(const GOST_28147_89_Params &params)
Definition: gost_28147.cpp:60

Member Function Documentation

◆ block_size()

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 , BlockCipher >::block_size ( ) const
inlinefinaloverridevirtualinherited

Implements Botan::BlockCipher.

Definition at line 224 of file block_cipher.h.

224 { return BS; }

◆ clear()

void Botan::GOST_28147_89::clear ( )
overridevirtual

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 183 of file gost_28147.cpp.

References Botan::zap().

Referenced by Botan::GOST_34_11::clear().

184  {
185  zap(m_EK);
186  }
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:193

◆ clone()

BlockCipher* Botan::GOST_28147_89::clone ( ) const
inlineoverridevirtual
Returns
new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 67 of file gost_28147.h.

67 { return new GOST_28147_89(m_SBOX); }
GOST_28147_89(const GOST_28147_89_Params &params)
Definition: gost_28147.cpp:60

◆ create()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create ( const std::string &  algo_spec,
const std::string &  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 108 of file block_cipher.cpp.

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::HashFunction::create(), Botan::StreamCipher::create(), hash, Botan::make_commoncrypto_block_cipher(), Botan::make_openssl_block_cipher(), and Botan::BlockCipher::provider().

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

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

◆ create_or_throw()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create_or_throw ( const std::string &  algo_spec,
const std::string &  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 348 of file block_cipher.cpp.

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

350  {
351  if(auto bc = BlockCipher::create(algo, provider))
352  {
353  return bc;
354  }
355  throw Lookup_Error("Block cipher", algo, provider);
356  }
static std::unique_ptr< BlockCipher > create(const std::string &algo_spec, const std::string &provider="")
virtual std::string provider() const
Definition: block_cipher.h:72

◆ decrypt() [1/4]

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

Decrypt a block.

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

Definition at line 91 of file block_cipher.h.

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

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

◆ decrypt() [2/4]

void Botan::BlockCipher::decrypt ( 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 108 of file block_cipher.h.

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

◆ decrypt() [3/4]

template<typename Alloc >
void Botan::BlockCipher::decrypt ( std::vector< uint8_t, Alloc > &  block) const
inlineinherited

Decrypt one or more blocks

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

Definition at line 125 of file block_cipher.h.

126  {
127  return decrypt_n(block.data(), block.data(), block.size() / block_size());
128  }
virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0
virtual size_t block_size() const =0

◆ decrypt() [4/4]

template<typename Alloc , typename Alloc2 >
void Botan::BlockCipher::decrypt ( const std::vector< uint8_t, Alloc > &  in,
std::vector< uint8_t, Alloc2 > &  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 148 of file block_cipher.h.

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

◆ decrypt_n()

void Botan::GOST_28147_89::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 145 of file gost_28147.cpp.

References Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE, GOST_2ROUND, Botan::load_le< uint32_t >(), Botan::store_le(), and Botan::SymmetricAlgorithm::verify_key_set().

146  {
147  verify_key_set(m_EK.empty() == false);
148 
149  for(size_t i = 0; i != blocks; ++i)
150  {
151  uint32_t N1 = load_le<uint32_t>(in, 0);
152  uint32_t N2 = load_le<uint32_t>(in, 1);
153 
154  GOST_2ROUND(N1, N2, 0, 1);
155  GOST_2ROUND(N1, N2, 2, 3);
156  GOST_2ROUND(N1, N2, 4, 5);
157  GOST_2ROUND(N1, N2, 6, 7);
158 
159  for(size_t j = 0; j != 3; ++j)
160  {
161  GOST_2ROUND(N1, N2, 7, 6);
162  GOST_2ROUND(N1, N2, 5, 4);
163  GOST_2ROUND(N1, N2, 3, 2);
164  GOST_2ROUND(N1, N2, 1, 0);
165  }
166 
167  store_le(out, N2, N1);
168  in += BLOCK_SIZE;
169  out += BLOCK_SIZE;
170  }
171  }
void verify_key_set(bool cond) const
Definition: sym_algo.h:89
uint32_t load_le< uint32_t >(const uint8_t in[], size_t off)
Definition: loadstor.h:196
#define GOST_2ROUND(N1, N2, R1, R2)
Definition: gost_28147.cpp:95
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:450

◆ decrypt_n_xex()

void Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 , BlockCipher >::decrypt_n_xex ( uint8_t  data[],
const uint8_t  mask[],
size_t  blocks 
) const
inlinefinaloverridevirtualinherited

Reimplemented from Botan::BlockCipher.

Definition at line 236 of file block_cipher.h.

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

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

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

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

◆ encrypt() [2/4]

void Botan::BlockCipher::encrypt ( 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 100 of file block_cipher.h.

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

◆ encrypt() [3/4]

template<typename Alloc >
void Botan::BlockCipher::encrypt ( std::vector< uint8_t, Alloc > &  block) const
inlineinherited

Encrypt one or more blocks

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

Definition at line 115 of file block_cipher.h.

116  {
117  return encrypt_n(block.data(), block.data(), block.size() / block_size());
118  }
virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0
virtual size_t block_size() const =0

◆ encrypt() [4/4]

template<typename Alloc , typename Alloc2 >
void Botan::BlockCipher::encrypt ( const std::vector< uint8_t, Alloc > &  in,
std::vector< uint8_t, Alloc2 > &  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 136 of file block_cipher.h.

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

◆ encrypt_n()

void Botan::GOST_28147_89::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 113 of file gost_28147.cpp.

References Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE, GOST_2ROUND, Botan::load_le< uint32_t >(), Botan::store_le(), and Botan::SymmetricAlgorithm::verify_key_set().

114  {
115  verify_key_set(m_EK.empty() == false);
116 
117  for(size_t i = 0; i != blocks; ++i)
118  {
119  uint32_t N1 = load_le<uint32_t>(in, 0);
120  uint32_t N2 = load_le<uint32_t>(in, 1);
121 
122  for(size_t j = 0; j != 3; ++j)
123  {
124  GOST_2ROUND(N1, N2, 0, 1);
125  GOST_2ROUND(N1, N2, 2, 3);
126  GOST_2ROUND(N1, N2, 4, 5);
127  GOST_2ROUND(N1, N2, 6, 7);
128  }
129 
130  GOST_2ROUND(N1, N2, 7, 6);
131  GOST_2ROUND(N1, N2, 5, 4);
132  GOST_2ROUND(N1, N2, 3, 2);
133  GOST_2ROUND(N1, N2, 1, 0);
134 
135  store_le(out, N2, N1);
136 
137  in += BLOCK_SIZE;
138  out += BLOCK_SIZE;
139  }
140  }
void verify_key_set(bool cond) const
Definition: sym_algo.h:89
uint32_t load_le< uint32_t >(const uint8_t in[], size_t off)
Definition: loadstor.h:196
#define GOST_2ROUND(N1, N2, R1, R2)
Definition: gost_28147.cpp:95
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:450

◆ encrypt_n_xex()

void Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 , BlockCipher >::encrypt_n_xex ( uint8_t  data[],
const uint8_t  mask[],
size_t  blocks 
) const
inlinefinaloverridevirtualinherited

Reimplemented from Botan::BlockCipher.

Definition at line 227 of file block_cipher.h.

230  {
231  xor_buf(data, mask, blocks * BS);
232  this->encrypt_n(data, data, blocks);
233  xor_buf(data, mask, blocks * BS);
234  }
void xor_buf(uint8_t out[], const uint8_t in[], size_t length)
Definition: mem_ops.h:174
virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

◆ key_spec()

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 , BlockCipher >::key_spec ( ) const
inlinefinaloverridevirtualinherited

Implements Botan::SymmetricAlgorithm.

Definition at line 245 of file block_cipher.h.

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

◆ maximum_keylength()

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

Definition at line 38 of file sym_algo.h.

39  {
40  return key_spec().maximum_keylength();
41  }
size_t maximum_keylength() const
Definition: key_spec.h:69
virtual Key_Length_Specification key_spec() const =0

◆ minimum_keylength()

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

Definition at line 46 of file sym_algo.h.

Referenced by botan_block_cipher_get_keyspec(), and botan_mac_get_keyspec().

47  {
48  return key_spec().minimum_keylength();
49  }
virtual Key_Length_Specification key_spec() const =0
size_t minimum_keylength() const
Definition: key_spec.h:61

◆ name()

std::string Botan::GOST_28147_89::name ( ) const
overridevirtual
Returns
the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 73 of file gost_28147.cpp.

74  {
75  /*
76  'Guess' the right name for the sbox on the basis of the values.
77  This would need to be updated if support for other sbox parameters
78  is added. Preferably, we would just store the string value in the
79  constructor, but can't break binary compat.
80  */
81  std::string sbox_name = "";
82  if(m_SBOX[0] == 0x00072000)
83  sbox_name = "R3411_94_TestParam";
84  else if(m_SBOX[0] == 0x0002D000)
85  sbox_name = "R3411_CryptoPro";
86  else
87  throw Internal_Error("GOST-28147 unrecognized sbox value");
88 
89  return "GOST-28147-89(" + sbox_name + ")";
90  }

◆ parallel_bytes()

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

Definition at line 63 of file block_cipher.h.

Referenced by Botan::XTS_Mode::update_granularity(), and Botan::CBC_Mode::update_granularity().

64  {
65  return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
66  }
virtual size_t parallelism() const
Definition: block_cipher.h:58
virtual size_t block_size() const =0

◆ parallelism()

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

Reimplemented in Botan::AES_256, Botan::AES_192, Botan::Threefish_512, Botan::Serpent, Botan::AES_128, Botan::IDEA, Botan::SM4, Botan::Noekeon, and Botan::SHACAL2.

Definition at line 58 of file block_cipher.h.

58 { return 1; }

◆ provider()

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

Reimplemented in Botan::AES_256, Botan::AES_192, Botan::SM4, Botan::Threefish_512, Botan::AES_128, Botan::IDEA, Botan::Serpent, Botan::Noekeon, and Botan::SHACAL2.

Definition at line 72 of file block_cipher.h.

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

72 { return "base"; }

◆ providers()

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

Definition at line 358 of file block_cipher.cpp.

359  {
360  return probe_providers_of<BlockCipher>(algo, { "base", "openssl", "commoncrypto" });
361  }

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

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::FPE::fe1_decrypt(), and Botan::FPE::fe1_encrypt().

66  {
67  set_key(key.begin(), key.length());
68  }
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:65

◆ set_key() [2/3]

template<typename Alloc >
void Botan::SymmetricAlgorithm::set_key ( const std::vector< uint8_t, Alloc > &  key)
inlineinherited

Definition at line 71 of file sym_algo.h.

72  {
73  set_key(key.data(), key.size());
74  }
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:65

◆ 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
keythe to be set as a byte array.
lengthin bytes of key param

Definition at line 17 of file sym_algo.cpp.

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

18  {
19  if(!valid_keylength(length))
20  throw Invalid_Key_Length(name(), length);
21  key_schedule(key, length);
22  }
bool valid_keylength(size_t length) const
Definition: sym_algo.h:56
virtual std::string name() const =0

◆ valid_keylength()

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

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

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

Definition at line 56 of file sym_algo.h.

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

57  {
58  return key_spec().valid_keylength(length);
59  }
bool valid_keylength(size_t length) const
Definition: key_spec.h:51
virtual Key_Length_Specification key_spec() const =0

◆ verify_key_set()

void Botan::SymmetricAlgorithm::verify_key_set ( bool  cond) const
inlineprotectedinherited

Definition at line 89 of file sym_algo.h.

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

90  {
91  if(cond == false)
92  throw_key_not_set_error();
93  }

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