Botan 2.1.0 Crypto and TLS for C++11

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

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

`#include <gost_28147.h>`

Inheritance diagram for Botan::GOST_28147_89:

## Public Types
enum |

## Public Member Functions
size_t | block_size () const override
void | clear () override
BlockCipher * | clone () 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 | 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
| GOST_28147_89 (const GOST_28147_89_Params &params)
Key_Length_Specification | key_spec () const 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< BlockCipher > | create (const std::string &algo_spec, const std::string &provider="")
static std::unique_ptr< BlockCipher > | create_or_throw (const std::string &algo_spec, const std::string &provider="")
static std::vector< std::string > | providers (const std::string &algo_spec)

## Detailed Description

GOST 28147-89

Definition at line 52 of file gost_28147.h.

## Member Enumeration Documentation

anonymous enum
| inherited

Definition at line 186 of file block_cipher.h.

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

## Constructor & Destructor Documentation

Botan::GOST_28147_89::GOST_28147_89 | ( | const GOST_28147_89_Params & | params | ) |
| explicit

Parameters

  params | the sbox parameters to use

Definition at line 53 of file gost_28147.cpp.

References Botan::rotate_left(), and Botan::GOST_28147_89_Params::sbox_entry().

53 : m_SBOX(1024)
54 {
55 // Convert the parallel 4x4 sboxes into larger word-based sboxes
56 for(size_t i = 0; i != 4; ++i)
57 for(size_t j = 0; j != 256; ++j)
58 {
59 const uint32_t T = (param.sbox_entry(2*i , j % 16)) |
60 (param.sbox_entry(2*i+1, j / 16) << 4);
61 m_SBOX[256*i+j] = rotate_left(T, (11+8*i) % 32);
62 }
63 }
Botan::rotate_left
T rotate_left(T input, size_t rot)
Definition: rotate.h:21

## Member Function Documentation

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::block_size | ( |  | ) | const
| inline override virtual inherited

Returns
  block size of this algorithm

Implements Botan::BlockCipher.

Definition at line 187 of file block_cipher.h.

187 { return BS; }

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

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 171 of file gost_28147.cpp.

References Botan::zap().

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

172 {
173 zap(m_EK);
174 }
Botan::zap
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:221

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

Returns
  new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 61 of file gost_28147.h.

61 { return new GOST_28147_89(m_SBOX); }
Botan::GOST_28147_89::GOST_28147_89
GOST_28147_89(const GOST_28147_89_Params &params)
Definition: gost_28147.cpp:53

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

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

Parameters

  algo_spec | algorithm name
  provider | provider implementation to choose

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

Definition at line 88 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, and Botan::make_openssl_block_cipher().

Referenced by botan_block_cipher_init(), Botan::MessageAuthenticationCode::create(), Botan::StreamCipher::create(), Botan::BlockCipher::create_or_throw(), Botan::get_aead(), Botan::get_block_cipher(), and Botan::get_cipher_mode().

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

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

Create an instance based on a name, or throw if the algo/provider combination cannot be found. If provider is empty then best available is chosen.

Definition at line 285 of file block_cipher.cpp.

References Botan::BlockCipher::create().

Referenced by Botan::make_block_cipher(), Botan::rfc3394_keyunwrap(), Botan::rfc3394_keywrap(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::TLS_CBC_HMAC_AEAD_Mode().

287 {
288 if(auto bc = BlockCipher::create(algo, provider))
289 {
290 return bc;
291 }
292 throw Lookup_Error("Block cipher", algo, provider);
293 }
Botan::BlockCipher::create
static std::unique_ptr< BlockCipher > create(const std::string &algo_spec, const std::string &provider="")
Definition: block_cipher.cpp:88
Botan::BlockCipher::provider
virtual std::string provider() const
Definition: block_cipher.h:71

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

Decrypt a block.

Parameters

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

Definition at line 90 of file block_cipher.h.

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

91 { 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

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

Decrypt a block.

Parameters

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

Definition at line 107 of file block_cipher.h.

107 { decrypt_n(block, block, 1); }
Botan::BlockCipher::decrypt_n
virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0
template<typename Alloc >

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

Decrypt one or more blocks

Parameters

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

Definition at line 124 of file block_cipher.h.

125 {
126 return decrypt_n(block.data(), block.data(), block.size() / block_size());
127 }
Botan::BlockCipher::decrypt_n
virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0
Botan::BlockCipher::block_size
virtual size_t block_size() const =0
template<typename Alloc , typename Alloc2 >

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

Decrypt one or more blocks

Parameters

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

Definition at line 147 of file block_cipher.h.

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

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

Decrypt one or more blocks

Parameters

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

Implements Botan::BlockCipher.

Definition at line 135 of file gost_28147.cpp.

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

136 {
137 for(size_t i = 0; i != blocks; ++i)
138 {
139 uint32_t N1 = load_le<uint32_t>(in, 0);
140 uint32_t N2 = load_le<uint32_t>(in, 1);
141
142 GOST_2ROUND(N1, N2, 0, 1);
143 GOST_2ROUND(N1, N2, 2, 3);
144 GOST_2ROUND(N1, N2, 4, 5);
145 GOST_2ROUND(N1, N2, 6, 7);
146
147 for(size_t j = 0; j != 3; ++j)
148 {
149 GOST_2ROUND(N1, N2, 7, 6);
150 GOST_2ROUND(N1, N2, 5, 4);
151 GOST_2ROUND(N1, N2, 3, 2);
152 GOST_2ROUND(N1, N2, 1, 0);
153 }
154
155 store_le(out, N2, N1);
156 in += BLOCK_SIZE;
157 out += BLOCK_SIZE;
158 }
159 }
Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE
Definition: block_cipher.h:186
Botan::load_le< uint32_t >
uint32_t load_le< uint32_t >(const uint8_t in[], size_t off)
Definition: loadstor.h:204
GOST_2ROUND
#define GOST_2ROUND(N1, N2, R1, R2)
Definition: gost_28147.cpp:87
Botan::store_le
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:457

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

Encrypt a block.

Parameters

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

Definition at line 80 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::CFB_Encryption::process(), Botan::CBC_Encryption::process(), and Botan::CFB_Decryption::process().

81 { 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

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

Encrypt a block.

Parameters

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

Definition at line 99 of file block_cipher.h.

99 { encrypt_n(block, block, 1); }
Botan::BlockCipher::encrypt_n
virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0
template<typename Alloc >

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

Encrypt one or more blocks

Parameters

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

Definition at line 114 of file block_cipher.h.

115 {
116 return encrypt_n(block.data(), block.data(), block.size() / block_size());
117 }
Botan::BlockCipher::encrypt_n
virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0
Botan::BlockCipher::block_size
virtual size_t block_size() const =0
template<typename Alloc , typename Alloc2 >

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

Encrypt one or more blocks

Parameters

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

Definition at line 135 of file block_cipher.h.

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

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

Encrypt one or more blocks

Parameters

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

Implements Botan::BlockCipher.

Definition at line 105 of file gost_28147.cpp.

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

106 {
107 for(size_t i = 0; i != blocks; ++i)
108 {
109 uint32_t N1 = load_le<uint32_t>(in, 0);
110 uint32_t N2 = load_le<uint32_t>(in, 1);
111
112 for(size_t j = 0; j != 3; ++j)
113 {
114 GOST_2ROUND(N1, N2, 0, 1);
115 GOST_2ROUND(N1, N2, 2, 3);
116 GOST_2ROUND(N1, N2, 4, 5);
117 GOST_2ROUND(N1, N2, 6, 7);
118 }
119
120 GOST_2ROUND(N1, N2, 7, 6);
121 GOST_2ROUND(N1, N2, 5, 4);
122 GOST_2ROUND(N1, N2, 3, 2);
123 GOST_2ROUND(N1, N2, 1, 0);
124
125 store_le(out, N2, N1);
126
127 in += BLOCK_SIZE;
128 out += BLOCK_SIZE;
129 }
130 }
Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE
Definition: block_cipher.h:186
Botan::load_le< uint32_t >
uint32_t load_le< uint32_t >(const uint8_t in[], size_t off)
Definition: loadstor.h:204
GOST_2ROUND
#define GOST_2ROUND(N1, N2, R1, R2)
Definition: gost_28147.cpp:87
Botan::store_le
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:457

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::key_spec | ( |  | ) | const
| inline override virtual inherited

Returns
  object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 189 of file block_cipher.h.

190 {
191 return Key_Length_Specification(KMIN, KMAX, KMOD);
192 }

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

Returns
  minimum allowed key length

Definition at line 39 of file sym_algo.h.

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

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

Returns
  maximum allowed key length

Definition at line 47 of file sym_algo.h.

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

std::string Botan::GOST_28147_89::name | ( |  | ) | const
| override virtual

Returns
  the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 65 of file gost_28147.cpp.

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

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

Returns
  prefererred parallelism of this cipher in bytes

Definition at line 62 of file block_cipher.h.

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

63 {
64 return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
65 }
Botan::BlockCipher::parallelism
virtual size_t parallelism() const
Definition: block_cipher.h:57
Botan::BlockCipher::block_size
virtual size_t block_size() const =0

virtual size_t Botan::BlockCipher::parallelism | ( |  | ) | const
| inline virtual inherited

Returns
  native parallelism of this cipher in blocks

Reimplemented in Botan::Serpent.

Definition at line 57 of file block_cipher.h.

57 { return 1; }

virtual std::string Botan::BlockCipher::provider | ( |  | ) | const
| inline virtual inherited

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::Threefish_512, Botan::AES_128, Botan::IDEA, Botan::Serpent, and Botan::Noekeon.

Definition at line 71 of file block_cipher.h.

71 { return "base"; }

std::vector< std::string > Botan::BlockCipher::providers | ( | const std::string & | algo_spec | ) |
| static inherited

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

Parameters

  algo_spec | algorithm name

Definition at line 295 of file block_cipher.cpp.

Referenced by Botan::get_block_cipher_providers().

296 {
297 return probe_providers_of<BlockCipher>(algo, { "base", "openssl" });
298 }

void Botan::SymmetricAlgorithm::set_key | ( | const SymmetricKey & | key | ) |
| inline inherited

Set the symmetric key of this object.

Parameters

  key | the SymmetricKey to be set.

Definition at line 66 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_mac_set_key(), and Botan::pbkdf2().

67 {
68 set_key(key.begin(), key.length());
69 }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:66
template<typename Alloc >

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

Definition at line 72 of file sym_algo.h.

73 {
74 set_key(key.data(), key.size());
75 }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:66

void Botan::SymmetricAlgorithm::set_key | ( | const uint8_t | key[],
|  | size_t | length
| ) |  |
| inline inherited

Set the symmetric key of this object.

Parameters

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

Definition at line 82 of file sym_algo.h.

83 {
84 if(!valid_keylength(length))
85 throw Invalid_Key_Length(name(), length);
86 key_schedule(key, length);
87 }
Botan::SymmetricAlgorithm::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:57
Botan::SymmetricAlgorithm::name
virtual std::string name() const =0

bool Botan::SymmetricAlgorithm::valid_keylength | ( | size_t | length | ) | const
| inline inherited

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

Parameters

  length | the key length to be checked.

Returns
  true if the key length is valid.

Definition at line 57 of file sym_algo.h.

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

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

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

- src/lib/block/gost_28147/gost_28147.h
- src/lib/block/gost_28147/gost_28147.cpp