Botan 2.19.3
Crypto and TLS for C&
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
 
template<typename Alloc , typename Alloc2 >
void decrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) const
 
void decrypt (const uint8_t in[], uint8_t out[]) const
 
template<typename Alloc >
void decrypt (std::vector< uint8_t, Alloc > &block) const
 
void decrypt (uint8_t block[]) const
 
void decrypt_n (const uint8_t in[], uint8_t out[], size_t blocks) const override
 
void decrypt_n_xex (uint8_t data[], const uint8_t mask[], size_t blocks) const final override
 
template<typename Alloc , typename Alloc2 >
void encrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) const
 
void encrypt (const uint8_t in[], uint8_t out[]) const
 
template<typename Alloc >
void encrypt (std::vector< uint8_t, Alloc > &block) const
 
void encrypt (uint8_t block[]) const
 
void encrypt_n (const uint8_t in[], uint8_t out[], size_t blocks) const override
 
void encrypt_n_xex (uint8_t data[], const uint8_t mask[], size_t blocks) const final override
 
 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
 
template<typename Alloc >
void set_key (const std::vector< uint8_t, Alloc > &key)
 
void set_key (const SymmetricKey &key)
 
void set_key (const uint8_t key[], size_t length)
 
bool valid_keylength (size_t length) const
 

Static Public Member Functions

static std::unique_ptr< 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 60 of file gost_28147.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
inherited

Definition at line 224 of file block_cipher.h.

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 61 of file gost_28147.cpp.

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

References Botan::GOST_28147_89_Params::sbox_pair().

◆ GOST_28147_89() [2/2]

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

Definition at line 76 of file gost_28147.h.

76 :
77 GOST_28147_89(GOST_28147_89_Params(param_name)) {}
GOST_28147_89(const GOST_28147_89_Params &params)

Member Function Documentation

◆ block_size()

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

Implements Botan::BlockCipher.

Definition at line 225 of file block_cipher.h.

225{ return BS; }

◆ clear()

void Botan::GOST_28147_89::clear ( )
overridevirtual

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 184 of file gost_28147.cpp.

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

References Botan::zap().

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

◆ clone()

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

Implements Botan::BlockCipher.

Definition at line 69 of file gost_28147.h.

69{ return new GOST_28147_89(m_SBOX); }

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

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

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

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

◆ create_or_throw()

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

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

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

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

◆ decrypt() [1/4]

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

Decrypt one or more blocks

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

Definition at line 149 of file block_cipher.h.

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

◆ decrypt() [2/4]

void Botan::BlockCipher::decrypt ( const uint8_t  in[],
uint8_t  out[] 
) const
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 92 of file block_cipher.h.

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

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

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

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

◆ decrypt() [4/4]

void Botan::BlockCipher::decrypt ( uint8_t  block[]) const
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 109 of file block_cipher.h.

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

◆ 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 146 of file gost_28147.cpp.

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

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

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

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

◆ encrypt() [1/4]

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

Encrypt one or more blocks

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

Definition at line 137 of file block_cipher.h.

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

◆ encrypt() [2/4]

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

Encrypt a block.

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

Definition at line 82 of file block_cipher.h.

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

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

◆ encrypt() [3/4]

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

Encrypt one or more blocks

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

Definition at line 116 of file block_cipher.h.

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

◆ encrypt() [4/4]

void Botan::BlockCipher::encrypt ( uint8_t  block[]) const
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 101 of file block_cipher.h.

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

◆ 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 114 of file gost_28147.cpp.

115 {
116 verify_key_set(m_EK.empty() == false);
117
118 for(size_t i = 0; i != blocks; ++i)
119 {
120 uint32_t N1 = load_le<uint32_t>(in, 0);
121 uint32_t N2 = load_le<uint32_t>(in, 1);
122
123 for(size_t j = 0; j != 3; ++j)
124 {
125 GOST_2ROUND(N1, N2, 0, 1);
126 GOST_2ROUND(N1, N2, 2, 3);
127 GOST_2ROUND(N1, N2, 4, 5);
128 GOST_2ROUND(N1, N2, 6, 7);
129 }
130
131 GOST_2ROUND(N1, N2, 7, 6);
132 GOST_2ROUND(N1, N2, 5, 4);
133 GOST_2ROUND(N1, N2, 3, 2);
134 GOST_2ROUND(N1, N2, 1, 0);
135
136 store_le(out, N2, N1);
137
138 in += BLOCK_SIZE;
139 out += BLOCK_SIZE;
140 }
141 }

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

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

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

◆ key_spec()

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

Implements Botan::SymmetricAlgorithm.

Definition at line 246 of file block_cipher.h.

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

◆ maximum_keylength()

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

Definition at line 120 of file sym_algo.h.

121 {
122 return key_spec().maximum_keylength();
123 }
size_t maximum_keylength() const
Definition sym_algo.h:70
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 128 of file sym_algo.h.

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

Referenced by botan_block_cipher_get_keyspec(), and botan_mac_get_keyspec().

◆ name()

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

Implements Botan::SymmetricAlgorithm.

Definition at line 74 of file gost_28147.cpp.

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

◆ parallel_bytes()

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

Definition at line 64 of file block_cipher.h.

65 {
66 return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
67 }
virtual size_t parallelism() const

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

◆ parallelism()

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

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

Definition at line 59 of file block_cipher.h.

59{ 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_128, Botan::AES_192, Botan::AES_256, Botan::IDEA, Botan::Noekeon, Botan::Serpent, Botan::SHACAL2, Botan::SM4, and Botan::Threefish_512.

Definition at line 73 of file block_cipher.h.

73{ return "base"; }

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

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

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

◆ set_key() [1/3]

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

Definition at line 153 of file sym_algo.h.

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

◆ set_key() [2/3]

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

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

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

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

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

◆ verify_key_set()

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

Definition at line 171 of file sym_algo.h.

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

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


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