Botan  1.11.34
Crypto and TLS for C++11
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:
Botan::Block_Cipher_Fixed_Params< 8, 32 > Botan::BlockCipher Botan::SymmetricAlgorithm

Public Types

enum  
 

Public Member Functions

size_t block_size () const override
 
void clear () override
 
BlockCipherclone () const override
 
void decrypt (const byte in[], byte out[]) const
 
void decrypt (byte block[]) const
 
template<typename Alloc >
void decrypt (std::vector< byte, Alloc > &block) const
 
template<typename Alloc , typename Alloc2 >
void decrypt (const std::vector< byte, Alloc > &in, std::vector< byte, Alloc2 > &out) const
 
void decrypt_n (const byte in[], byte out[], size_t blocks) const override
 
void encrypt (const byte in[], byte out[]) const
 
void encrypt (byte block[]) const
 
template<typename Alloc >
void encrypt (std::vector< byte, Alloc > &block) const
 
template<typename Alloc , typename Alloc2 >
void encrypt (const std::vector< byte, Alloc > &in, std::vector< byte, Alloc2 > &out) const
 
void encrypt_n (const byte in[], byte 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< byte, Alloc > &key)
 
void set_key (const byte 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)
 

Detailed Description

GOST 28147-89

Definition at line 52 of file gost_28147.h.

Member Enumeration Documentation

§ anonymous enum

anonymous enum
inherited

Constructor & Destructor Documentation

§ GOST_28147_89()

Botan::GOST_28147_89::GOST_28147_89 ( const GOST_28147_89_Params params)
explicit
Parameters
paramsthe 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 u32bit 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  }
T rotate_left(T input, size_t rot)
Definition: rotate.h:21
std::uint32_t u32bit
Definition: types.h:33

Member Function Documentation

§ block_size()

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

Implements Botan::BlockCipher.

Definition at line 187 of file block_cipher.h.

187 { return BS; }

§ clear()

void Botan::GOST_28147_89::clear ( )
overridevirtual

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  }
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:213

§ clone()

BlockCipher* Botan::GOST_28147_89::clone ( ) const
inlineoverridevirtual
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); }
GOST_28147_89(const GOST_28147_89_Params &params)
Definition: gost_28147.cpp:53

§ 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 88 of file block_cipher.cpp.

References Botan::BlockCipher::block_size(), Botan::HashFunction::create(), Botan::StreamCipher::create(), hash, and Botan::make_openssl_block_cipher().

Referenced by 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  return nullptr;
278  }
static std::unique_ptr< HashFunction > create(const std::string &algo_spec, const std::string &provider="")
Definition: hash.cpp:93
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:71
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 282 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().

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

§ decrypt() [1/4]

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

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

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

§ decrypt() [2/4]

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

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

§ decrypt() [3/4]

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

Decrypt one or more blocks

Parameters
blockthe 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  }
virtual void decrypt_n(const byte in[], byte 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< byte, Alloc > &  in,
std::vector< byte, 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 147 of file block_cipher.h.

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

§ decrypt_n()

void Botan::GOST_28147_89::decrypt_n ( const byte  in[],
byte  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 135 of file gost_28147.cpp.

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

136  {
137  for(size_t i = 0; i != blocks; ++i)
138  {
139  u32bit N1 = load_le<u32bit>(in, 0);
140  u32bit N2 = load_le<u32bit>(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  }
void store_le(u16bit in, byte out[2])
Definition: loadstor.h:457
std::uint32_t u32bit
Definition: types.h:33
u32bit load_le< u32bit >(const byte in[], size_t off)
Definition: loadstor.h:204
#define GOST_2ROUND(N1, N2, R1, R2)
Definition: gost_28147.cpp:87

§ encrypt() [1/4]

void Botan::BlockCipher::encrypt ( const byte  in[],
byte  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 80 of file block_cipher.h.

Referenced by Botan::aont_package(), Botan::aont_unpackage(), Botan::GOST_34_11::clear(), Botan::DESX::encrypt_n(), Botan::XTS_Encryption::finish(), Botan::CTS_Encryption::finish(), Botan::CFB_Encryption::process(), Botan::CBC_Encryption::process(), Botan::CFB_Decryption::process(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data(), and Botan::CFB_Mode::valid_nonce_length().

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

§ encrypt() [2/4]

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

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

§ encrypt() [3/4]

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

Encrypt one or more blocks

Parameters
blockthe 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  }
virtual void encrypt_n(const byte in[], byte 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< byte, Alloc > &  in,
std::vector< byte, 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 135 of file block_cipher.h.

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

§ encrypt_n()

void Botan::GOST_28147_89::encrypt_n ( const byte  in[],
byte  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 105 of file gost_28147.cpp.

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

106  {
107  for(size_t i = 0; i != blocks; ++i)
108  {
109  u32bit N1 = load_le<u32bit>(in, 0);
110  u32bit N2 = load_le<u32bit>(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  }
void store_le(u16bit in, byte out[2])
Definition: loadstor.h:457
std::uint32_t u32bit
Definition: types.h:33
u32bit load_le< u32bit >(const byte in[], size_t off)
Definition: loadstor.h:204
#define GOST_2ROUND(N1, N2, R1, R2)
Definition: gost_28147.cpp:87

§ key_spec()

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::key_spec ( ) const
inlineoverridevirtualinherited
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  }

§ maximum_keylength()

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

Definition at line 39 of file sym_algo.h.

40  {
41  return key_spec().maximum_keylength();
42  }
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 47 of file sym_algo.h.

48  {
49  return key_spec().minimum_keylength();
50  }
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 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  }

§ parallel_bytes()

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

Definition at line 62 of file block_cipher.h.

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

63  {
64  return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
65  }
virtual size_t parallelism() const
Definition: block_cipher.h:57
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::Serpent.

Definition at line 57 of file block_cipher.h.

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

Definition at line 71 of file block_cipher.h.

71 { 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 292 of file block_cipher.cpp.

Referenced by Botan::TLS::Ciphersuite::by_id(), and Botan::get_block_cipher_providers().

293  {
294  return probe_providers_of<BlockCipher>(algo, { "base", "openssl" });
295  }

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

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

Referenced by Botan::aont_package(), Botan::aont_unpackage(), botan_mac_set_key(), Botan::GOST_34_11::clear(), Botan::DESX::decrypt_n(), Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::key_spec(), Botan::pbkdf2(), and Botan::TLS_PRF::TLS_PRF().

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

§ set_key() [2/3]

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

Definition at line 72 of file sym_algo.h.

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

§ set_key() [3/3]

void Botan::SymmetricAlgorithm::set_key ( const byte  key[],
size_t  length 
)
inlineinherited

Set the symmetric key of this object.

Parameters
keythe to be set as a byte array.
lengthin bytes of key param

Definition at line 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  }
bool valid_keylength(size_t length) const
Definition: sym_algo.h:57
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 57 of file sym_algo.h.

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

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

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