Crypto++  7.0
Free C++ class library of cryptographic schemes
modes.h
Go to the documentation of this file.
1 // modes.h - originally written and placed in the public domain by Wei Dai
2 
3 /// \file modes.h
4 /// \brief Classes for block cipher modes of operation
5 
6 #ifndef CRYPTOPP_MODES_H
7 #define CRYPTOPP_MODES_H
8 
9 #include "cryptlib.h"
10 #include "secblock.h"
11 #include "misc.h"
12 #include "strciphr.h"
13 #include "argnames.h"
14 #include "algparam.h"
15 
16 // Issue 340
17 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
18 # pragma GCC diagnostic push
19 # pragma GCC diagnostic ignored "-Wconversion"
20 # pragma GCC diagnostic ignored "-Wsign-conversion"
21 #endif
22 
23 #if CRYPTOPP_MSC_VERSION
24 # pragma warning(push)
25 # pragma warning(disable: 4231 4275)
26 # if (CRYPTOPP_MSC_VERSION >= 1400)
27 # pragma warning(disable: 6011 6386 28193)
28 # endif
29 #endif
30 
31 NAMESPACE_BEGIN(CryptoPP)
32 
33 /// \brief Block cipher mode of operation information
34 /// \details Each class derived from this one defines two types, Encryption and Decryption,
35 /// both of which implement the SymmetricCipher interface.
36 /// For each mode there are two classes, one of which is a template class,
37 /// and the other one has a name that ends in "_ExternalCipher".
38 /// The "external cipher" mode objects hold a reference to the underlying block cipher,
39 /// instead of holding an instance of it. The reference must be passed in to the constructor.
40 /// For the "cipher holder" classes, the CIPHER template parameter should be a class
41 /// derived from BlockCipherDocumentation, for example DES or AES.
42 /// \details See NIST SP 800-38A for definitions of these modes. See
43 /// AuthenticatedSymmetricCipherDocumentation for authenticated encryption modes.
45 {
46 };
47 
48 /// \brief Block cipher mode of operation information
49 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CipherModeBase : public SymmetricCipher
50 {
51 public:
52  virtual ~CipherModeBase() {}
53 
54  // Algorithm class
55  std::string AlgorithmProvider() const {
56  return m_cipher != NULLPTR ? m_cipher->AlgorithmProvider() : "C++";
57  }
58 
59  /// \brief Returns smallest valid key length
60  /// \returns the minimum key length, in bytes
61  size_t MinKeyLength() const {return m_cipher->MinKeyLength();}
62 
63  /// \brief Returns largest valid key length
64  /// \returns the maximum key length, in bytes
65  size_t MaxKeyLength() const {return m_cipher->MaxKeyLength();}
66 
67  /// \brief Returns default key length
68  /// \returns the default key length, in bytes
69  size_t DefaultKeyLength() const {return m_cipher->DefaultKeyLength();}
70 
71  /// \brief Returns a valid key length for the algorithm
72  /// \param keylength the size of the key, in bytes
73  /// \returns the valid key length, in bytes
74  /// \details keylength is provided in bytes, not bits. If keylength is less than MIN_KEYLENGTH,
75  /// then the function returns MIN_KEYLENGTH. If keylength is greater than MAX_KEYLENGTH,
76  /// then the function returns MAX_KEYLENGTH. if If keylength is a multiple of KEYLENGTH_MULTIPLE,
77  /// then keylength is returned. Otherwise, the function returns a \a lower multiple of
78  /// KEYLENGTH_MULTIPLE.
79  size_t GetValidKeyLength(size_t keylength) const {return m_cipher->GetValidKeyLength(keylength);}
80 
81  /// \brief Returns whether keylength is a valid key length
82  /// \param keylength the requested keylength
83  /// \return true if keylength is valid, false otherwise
84  /// \details Internally the function calls GetValidKeyLength()
85  bool IsValidKeyLength(size_t keylength) const {return m_cipher->IsValidKeyLength(keylength);}
86 
87  /// \brief Provides input and output data alignment for optimal performance.
88  /// \return the input data alignment that provides optimal performance
89  /// \sa GetAlignment() and OptimalBlockSize()
90  unsigned int OptimalDataAlignment() const {return m_cipher->OptimalDataAlignment();}
91 
92  /// \brief Returns length of the IV accepted by this object
93  /// \return the size of an IV, in bytes
94  /// \throws NotImplemented() if the object does not support resynchronization
95  /// \details The default implementation throws NotImplemented
96  unsigned int IVSize() const {return BlockSize();}
97 
98  /// \brief Minimal requirement for secure IVs
99  /// \return the secure IV requirement of the algorithm
100  virtual IV_Requirement IVRequirement() const =0;
101 
102  /// \brief Set external block cipher
103  /// \param cipher An external block cipher
104  /// \details The cipher should be keyed.
105  void SetCipher(BlockCipher &cipher)
106  {
107  this->ThrowIfResynchronizable();
108  this->m_cipher = &cipher;
109  this->ResizeBuffers();
110  }
111 
112  /// \brief Set external block cipher and IV
113  /// \param cipher An external block cipher
114  /// \param iv a byte array used to resynchronize the cipher
115  /// \param feedbackSize the feedback size, in bytes
116  /// \details The cipher should be keyed.
117  void SetCipherWithIV(BlockCipher &cipher, const byte *iv, int feedbackSize = 0)
118  {
119  this->ThrowIfInvalidIV(iv);
120  this->m_cipher = &cipher;
121  this->ResizeBuffers();
122  this->SetFeedbackSize(feedbackSize);
123  if (this->IsResynchronizable())
124  this->Resynchronize(iv);
125  }
126 
127 protected:
128  CipherModeBase() : m_cipher(NULLPTR) {}
129  inline unsigned int BlockSize() const
130  {
131  CRYPTOPP_ASSERT(m_register.size() > 0);
132  return static_cast<unsigned int>(m_register.size());
133  }
134  virtual void SetFeedbackSize(unsigned int feedbackSize)
135  {
136  if (!(feedbackSize == 0 || feedbackSize == BlockSize()))
137  throw InvalidArgument("CipherModeBase: feedback size cannot be specified for this cipher mode");
138  }
139 
140  virtual void ResizeBuffers();
141 
142  BlockCipher *m_cipher;
143  SecByteBlock m_register;
144 };
145 
146 /// \brief Block cipher mode of operation common operations
147 /// \tparam POLICY_INTERFACE common operations
148 template <class POLICY_INTERFACE>
149 class CRYPTOPP_NO_VTABLE ModePolicyCommonTemplate : public CipherModeBase, public POLICY_INTERFACE
150 {
151  unsigned int GetAlignment() const {return m_cipher->OptimalDataAlignment();}
152  void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length);
153 };
154 
155 template <class POLICY_INTERFACE>
156 void ModePolicyCommonTemplate<POLICY_INTERFACE>::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)
157 {
158  m_cipher->SetKey(key, length, params);
159  ResizeBuffers();
160  int feedbackSize = params.GetIntValueWithDefault(Name::FeedbackSize(), 0);
161  SetFeedbackSize(feedbackSize);
162 }
163 
164 /// \brief CFB block cipher mode of operation
165 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_ModePolicy : public ModePolicyCommonTemplate<CFB_CipherAbstractPolicy>
166 {
167 public:
168  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "CFB";}
169 
170  virtual ~CFB_ModePolicy() {}
171  CFB_ModePolicy() : m_feedbackSize(0) {}
173 
174 protected:
175  unsigned int GetBytesPerIteration() const {return m_feedbackSize;}
176  bool CanIterate() const {return m_feedbackSize == BlockSize();}
177  void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount);
178  void TransformRegister();
179  void CipherResynchronize(const byte *iv, size_t length);
180  void SetFeedbackSize(unsigned int feedbackSize);
181  void ResizeBuffers();
182  byte * GetRegisterBegin();
183 
184  SecByteBlock m_temp;
185  unsigned int m_feedbackSize;
186 };
187 
188 /// \brief Initialize a block of memory
189 /// \param dest the destination block of memory
190 /// \param dsize the size of the destination block, in bytes
191 /// \param src the source block of memory
192 /// \param ssize the size of the source block, in bytes
193 /// \details CopyOrZero copies ssize bytes from source to destination if
194 /// src is not NULL. If src is NULL then dest is zero'd. Bounds are not
195 /// checked at runtime. Debug builds assert if ssize exceeds dsize.
196 inline void CopyOrZero(void *dest, size_t dsize, const void *src, size_t ssize)
197 {
198  CRYPTOPP_ASSERT(dest);
199  CRYPTOPP_ASSERT(dsize >= ssize);
200 
201  if (src != NULLPTR)
202  memcpy_s(dest, dsize, src, ssize);
203  else
204  memset(dest, 0, dsize);
205 }
206 
207 /// \brief OFB block cipher mode of operation
208 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE OFB_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
209 {
210 public:
211  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "OFB";}
212 
213  bool CipherIsRandomAccess() const {return false;}
215 
216 protected:
217  unsigned int GetBytesPerIteration() const {return BlockSize();}
218  unsigned int GetIterationsToBuffer() const {return m_cipher->OptimalNumberOfParallelBlocks();}
219  void WriteKeystream(byte *keystreamBuffer, size_t iterationCount);
220  void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length);
221 };
222 
223 /// \brief CTR block cipher mode of operation
224 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CTR_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
225 {
226 public:
227  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "CTR";}
228 
229  virtual ~CTR_ModePolicy() {}
230  bool CipherIsRandomAccess() const {return true;}
232 
233 protected:
234  virtual void IncrementCounterBy256();
235  unsigned int GetAlignment() const {return m_cipher->OptimalDataAlignment();}
236  unsigned int GetBytesPerIteration() const {return BlockSize();}
237  unsigned int GetIterationsToBuffer() const {return m_cipher->OptimalNumberOfParallelBlocks();}
238  void WriteKeystream(byte *buffer, size_t iterationCount)
239  {OperateKeystream(WRITE_KEYSTREAM, buffer, NULLPTR, iterationCount);}
240  bool CanOperateKeystream() const {return true;}
241  void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount);
242  void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length);
243  void SeekToIteration(lword iterationCount);
244 
245  // adv-simd.h increments the counter
246  mutable SecByteBlock m_counterArray;
247 };
248 
249 /// \brief Block cipher mode of operation default implementation
250 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockOrientedCipherModeBase : public CipherModeBase
251 {
252 public:
253  virtual ~BlockOrientedCipherModeBase() {}
254  void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);
255  unsigned int MandatoryBlockSize() const {return BlockSize();}
256  bool IsRandomAccess() const {return false;}
257  bool IsSelfInverting() const {return false;}
258  bool IsForwardTransformation() const {return m_cipher->IsForwardTransformation();}
259  void Resynchronize(const byte *iv, int length=-1) {memcpy_s(m_register, m_register.size(), iv, ThrowIfInvalidIVLength(length));}
260 
261 protected:
262  bool RequireAlignedInput() const {return true;}
263  virtual void ResizeBuffers();
264 
265  SecByteBlock m_buffer;
266 };
267 
268 /// \brief ECB block cipher mode of operation default implementation
269 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ECB_OneWay : public BlockOrientedCipherModeBase
270 {
271 public:
272  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECB";}
273 
274  void SetKey(const byte *key, size_t length, const NameValuePairs &params = g_nullNameValuePairs)
275  {m_cipher->SetKey(key, length, params); BlockOrientedCipherModeBase::ResizeBuffers();}
277  unsigned int OptimalBlockSize() const {return static_cast<unsigned int>(BlockSize() * m_cipher->OptimalNumberOfParallelBlocks());}
278  void ProcessData(byte *outString, const byte *inString, size_t length);
279 };
280 
281 /// \brief CBC block cipher mode of operation default implementation
282 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_ModeBase : public BlockOrientedCipherModeBase
283 {
284 public:
285  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "CBC";}
286 
288  bool RequireAlignedInput() const {return false;}
289  unsigned int MinLastBlockSize() const {return 0;}
290 };
291 
292 /// \brief CBC block cipher mode of operation encryption operation
293 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Encryption : public CBC_ModeBase
294 {
295 public:
296  void ProcessData(byte *outString, const byte *inString, size_t length);
297 };
298 
299 /// \brief CBC-CTS block cipher mode of operation encryption operation
300 /// \since Crypto++ 3.0
301 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Encryption : public CBC_Encryption
302 {
303 public:
304  CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "CBC/CTS";}
305 
306  void SetStolenIV(byte *iv) {m_stolenIV = iv;}
307  unsigned int MinLastBlockSize() const {return BlockSize()+1;}
308  size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength);
309 
310 protected:
311  void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params)
312  {
313  CBC_Encryption::UncheckedSetKey(key, length, params);
314  m_stolenIV = params.GetValueWithDefault(Name::StolenIV(), static_cast<byte *>(NULLPTR));
315  }
316 
317  byte *m_stolenIV;
318 };
319 
320 /// \brief CBC block cipher mode of operation decryption operation
321 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Decryption : public CBC_ModeBase
322 {
323 public:
324  virtual ~CBC_Decryption() {}
325  void ProcessData(byte *outString, const byte *inString, size_t length);
326 
327 protected:
328  virtual void ResizeBuffers();
329 
330  SecByteBlock m_temp;
331 };
332 
333 /// \brief CBC-CTS block cipher mode of operation decryption operation
334 /// \since Crypto++ 3.0
335 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Decryption : public CBC_Decryption
336 {
337 public:
338  unsigned int MinLastBlockSize() const {return BlockSize()+1;}
339  size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength);
340 };
341 
342 /// \brief Block cipher mode of operation aggregate
343 template <class CIPHER, class BASE>
344 class CipherModeFinalTemplate_CipherHolder : protected ObjectHolder<CIPHER>, public AlgorithmImpl<BASE, CipherModeFinalTemplate_CipherHolder<CIPHER, BASE> >
345 {
346 public:
347  /// \brief Provides the name of this algorithm
348  /// \return the standard algorithm name
349  /// \details The standard algorithm name can be a name like \a AES or \a AES/GCM. Some algorithms
350  /// do not have standard names yet. For example, there is no standard algorithm name for
351  /// Shoup's ECIES.
352  static std::string CRYPTOPP_API StaticAlgorithmName()
353  {return CIPHER::StaticAlgorithmName() + "/" + BASE::StaticAlgorithmName();}
354 
355  /// \brief Construct a CipherModeFinalTemplate
357  {
358  this->m_cipher = &this->m_object;
359  this->ResizeBuffers();
360  }
361 
362  /// \brief Construct a CipherModeFinalTemplate
363  /// \param key a byte array used to key the cipher
364  /// \details key must be at least DEFAULT_KEYLENGTH in length. Internally, the function calls
365  /// SimpleKeyingInterface::SetKey.
366  CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
367  {
368  this->m_cipher = &this->m_object;
369  this->SetKey(key, length);
370  }
371 
372  /// \brief Construct a CipherModeFinalTemplate
373  /// \param key a byte array used to key the cipher
374  /// \param iv a byte array used to resynchronize the cipher
375  /// \details key must be at least DEFAULT_KEYLENGTH in length. iv must be IVSize() or
376  /// BLOCKSIZE in length. Internally, the function calls SimpleKeyingInterface::SetKey.
377  CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
378  {
379  this->m_cipher = &this->m_object;
380  this->SetKey(key, length, MakeParameters(Name::IV(), ConstByteArrayParameter(iv, this->m_cipher->BlockSize())));
381  }
382 
383  /// \brief Construct a CipherModeFinalTemplate
384  /// \param key a byte array used to key the cipher
385  /// \param iv a byte array used to resynchronize the cipher
386  /// \param feedbackSize the feedback size, in bytes
387  /// \details key must be at least DEFAULT_KEYLENGTH in length. iv must be IVSize() or
388  /// BLOCKSIZE in length. Internally, the function calls SimpleKeyingInterface::SetKey.
389  CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
390  {
391  this->m_cipher = &this->m_object;
392  this->SetKey(key, length, MakeParameters(Name::IV(), ConstByteArrayParameter(iv, this->m_cipher->BlockSize()))(Name::FeedbackSize(), feedbackSize));
393  }
394 
395  // Algorithm class
396  std::string AlgorithmProvider() const {
397  return this->m_cipher->AlgorithmProvider();
398  }
399 };
400 
401 /// \tparam BASE CipherModeFinalTemplate_CipherHolder base class
402 /// \details Base class for external mode cipher combinations
403 template <class BASE>
405 {
406 public:
407  /// \brief Construct a default CipherModeFinalTemplate
408  /// \details The cipher is not keyed.
410 
411  /// \brief Construct a CipherModeFinalTemplate
412  /// \param cipher An external block cipher
413  /// \details The cipher should be keyed.
415  {this->SetCipher(cipher);}
416 
417  /// \brief Construct a CipherModeFinalTemplate
418  /// \param cipher An external block cipher
419  /// \param iv a byte array used to resynchronize the cipher
420  /// \param feedbackSize the feedback size, in bytes
421  /// \details The cipher should be keyed.
422  CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher, const byte *iv, int feedbackSize = 0)
423  {this->SetCipherWithIV(cipher, iv, feedbackSize);}
424 
425  /// \brief Provides the name of this algorithm
426  /// \return the standard algorithm name
427  /// \details The standard algorithm name can be a name like \a AES or \a AES/GCM. Some algorithms
428  /// do not have standard names yet. For example, there is no standard algorithm name for
429  /// Shoup's ECIES.
430  /// \note AlgorithmName is not universally implemented yet
431  std::string AlgorithmName() const
432  {return (this->m_cipher ? this->m_cipher->AlgorithmName() + "/" : std::string("")) + BASE::StaticAlgorithmName();}
433 
434  // Algorithm class
435  std::string AlgorithmProvider() const
436  {return this->m_cipher->AlgorithmProvider();}
437 };
438 
442 
443 /// \brief CFB block cipher mode of operation
444 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
445 /// on the Crypto++ wiki.
446 template <class CIPHER>
448 {
451 };
452 
453 /// \brief CFB mode, external cipher.
454 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
455 /// on the Crypto++ wiki.
457 {
460 };
461 
462 /// \brief CFB block cipher mode of operation providing FIPS validated cryptography.
463 /// \details Requires full block plaintext according to FIPS 800-38A
464 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
465 /// on the Crypto++ wiki.
466 template <class CIPHER>
468 {
471 };
472 
473 /// \brief CFB mode, external cipher, providing FIPS validated cryptography.
474 /// \details Requires full block plaintext according to FIPS 800-38A
475 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
476 /// on the Crypto++ wiki.
478 {
481 };
482 
484 
485 /// \brief OFB block cipher mode of operation
486 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
487 /// on the Crypto++ wiki.
488 template <class CIPHER>
490 {
492  typedef Encryption Decryption;
493 };
494 
495 /// \brief OFB mode, external cipher.
496 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
497 /// on the Crypto++ wiki.
499 {
501  typedef Encryption Decryption;
502 };
503 
506 
507 /// \brief CTR block cipher mode of operation
508 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
509 /// on the Crypto++ wiki.
510 template <class CIPHER>
512 {
514  typedef Encryption Decryption;
515 };
516 
517 /// \brief CTR mode, external cipher.
518 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
519 /// on the Crypto++ wiki.
521 {
523  typedef Encryption Decryption;
524 };
525 
526 /// \brief ECB block cipher mode of operation
527 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
528 /// on the Crypto++ wiki.
529 template <class CIPHER>
531 {
534 };
535 
536 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ECB_OneWay>;
537 
538 /// \brief ECB mode, external cipher.
539 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
540 /// on the Crypto++ wiki.
542 {
544  typedef Encryption Decryption;
545 };
546 
547 /// \brief CBC block cipher mode of operation
548 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
549 /// on the Crypto++ wiki.
550 template <class CIPHER>
552 {
555 };
556 
559 
560 /// \brief CBC mode, external cipher
561 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
562 /// on the Crypto++ wiki.
564 {
567 };
568 
569 /// \brief CBC-CTS block cipher mode of operation
570 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
571 /// on the Crypto++ wiki.
572 /// \since Crypto++ 3.0
573 template <class CIPHER>
575 {
578 };
579 
582 
583 /// \brief CBC mode with ciphertext stealing, external cipher
584 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
585 /// on the Crypto++ wiki.
586 /// \since Crypto++ 3.0
588 {
591 };
592 
593 NAMESPACE_END
594 
595 // Issue 340
596 #if CRYPTOPP_MSC_VERSION
597 # pragma warning(pop)
598 #endif
599 
600 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
601 # pragma GCC diagnostic pop
602 #endif
603 
604 #endif
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:20
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
Definition: cryptlib.h:393
Standard names for retrieving values by name when working with NameValuePairs.
An invalid argument was detected.
Definition: cryptlib.h:200
const char * FeedbackSize()
int
Definition: argnames.h:25
CipherModeFinalTemplate_CipherHolder()
Construct a CipherModeFinalTemplate.
Definition: modes.h:356
void Resynchronize(const byte *iv, int length=-1)
Resynchronize with an IV.
Definition: modes.h:259
Classes for working with NameValuePairs.
virtual void ProcessData(byte *outString, const byte *inString, size_t length)=0
Encrypt or decrypt an array of bytes.
Utility functions for the Crypto++ library.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs &params=g_nullNameValuePairs)
Sets or reset the key of this object.
Definition: cryptlib.cpp:58
size_t GetValidKeyLength(size_t keylength) const
Returns a valid key length for the algorithm.
Definition: modes.h:79
CFB mode, external cipher, providing FIPS validated cryptography.
Definition: modes.h:477
bool IsForwardTransformation() const
Determines if the cipher is being operated in its forward direction.
Definition: modes.h:258
void SetCipherWithIV(BlockCipher &cipher, const byte *iv, int feedbackSize=0)
Set external block cipher and IV.
Definition: modes.h:117
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
Definition: cryptlib.h:361
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:231
virtual size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength)
Encrypt or decrypt the last block of data.
Definition: cryptlib.cpp:217
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher, const byte *iv, int feedbackSize=0)
Construct a CipherModeFinalTemplate.
Definition: modes.h:422
CipherDir
Specifies a direction for a cipher to operate.
Definition: cryptlib.h:121
CipherModeFinalTemplate_ExternalCipher()
Construct a default CipherModeFinalTemplate.
Definition: modes.h:409
Abstract base classes that provide a uniform interface to this library.
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
Definition: misc.h:439
Base class for feedback based stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:541
The object does not use an IV.
Definition: cryptlib.h:705
void CopyOrZero(void *dest, size_t dsize, const void *src, size_t ssize)
Initialize a block of memory.
Definition: modes.h:196
Wirte the keystream to the output buffer, input is NULL.
Definition: strciphr.h:90
SecBlock<byte> typedef.
Definition: secblock.h:1047
static std::string StaticAlgorithmName()
Provides the name of this algorithm.
Definition: modes.h:352
CBC-CTS block cipher mode of operation.
Definition: modes.h:574
bool CipherIsRandomAccess() const
Flag indicating random access.
Definition: modes.h:230
size_t MinKeyLength() const
Returns smallest valid key length.
Definition: modes.h:61
CTR block cipher mode of operation.
Definition: modes.h:511
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: modes.h:431
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
Construct a CipherModeFinalTemplate.
Definition: modes.h:366
unsigned int OptimalBlockSize() const
Provides the input block size most efficient for this cipher.
Definition: modes.h:277
Interface for one direction (encryption or decryption) of a block cipher.
Definition: cryptlib.h:1252
const char * StolenIV()
byte *
Definition: argnames.h:22
OFB block cipher mode of operation.
Definition: modes.h:208
CBC-CTS block cipher mode of operation decryption operation.
Definition: modes.h:335
size_t MaxKeyLength() const
Returns largest valid key length.
Definition: modes.h:65
Classes and functions for secure memory allocations.
ECB block cipher mode of operation.
Definition: modes.h:530
Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface...
Definition: strciphr.h:631
Uses encapsulation to hide an object in derived classes.
Definition: misc.h:217
void SetCipher(BlockCipher &cipher)
Set external block cipher.
Definition: modes.h:105
CBC-CTS block cipher mode of operation encryption operation.
Definition: modes.h:301
virtual IV_Requirement IVRequirement() const =0
Minimal requirement for secure IVs.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Definition: algparam.h:502
Block cipher mode of operation aggregate.
Definition: modes.h:344
CFB mode, external cipher.
Definition: modes.h:456
CBC block cipher mode of operation default implementation.
Definition: modes.h:282
bool IsSelfInverting() const
Determines whether the cipher is self-inverting.
Definition: modes.h:257
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:338
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
Definition: cryptlib.h:759
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
Definition: modes.h:55
void SetKey(const byte *key, size_t length, const NameValuePairs &params=g_nullNameValuePairs)
Sets or reset the key of this object.
Definition: modes.h:274
Block cipher mode of operation information.
Definition: modes.h:44
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode...
Definition: cryptlib.h:1260
unsigned int MandatoryBlockSize() const
Provides the mandatory block size of the cipher.
Definition: modes.h:255
Block cipher mode of operation default implementation.
Definition: modes.h:250
ECB mode, external cipher.
Definition: modes.h:541
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:307
size_t DefaultKeyLength() const
Returns default key length.
Definition: modes.h:69
Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface...
Definition: strciphr.h:622
OFB block cipher mode of operation.
Definition: modes.h:489
CBC mode, external cipher.
Definition: modes.h:563
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:60
const char * BlockSize()
int, in bytes
Definition: argnames.h:27
CFB block cipher mode of operation.
Definition: modes.h:447
CTR block cipher mode of operation.
Definition: modes.h:224
OFB mode, external cipher.
Definition: modes.h:498
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
Construct a CipherModeFinalTemplate.
Definition: modes.h:377
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
Definition: argnames.h:21
Classes for implementing stream ciphers.
Provides Encryption and Decryption typedefs used by derived classes to implement a symmetric cipher...
Definition: seckey.h:419
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition: modes.h:90
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:172
const NameValuePairs g_nullNameValuePairs
An empty set of name-value pairs.
Definition: cryptlib.h:495
IV_Requirement
Secure IVs requirements as enumerated values.
Definition: cryptlib.h:695
Block cipher mode of operation information.
Definition: modes.h:49
CBC block cipher mode of operation decryption operation.
Definition: modes.h:321
CTR mode, external cipher.
Definition: modes.h:520
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:289
CBC block cipher mode of operation encryption operation.
Definition: modes.h:293
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params)
Sets the key for this object without performing parameter validation.
Definition: modes.cpp:173
Block cipher mode of operation common operations.
Definition: modes.h:149
KeystreamOperation
Keystream operation flags.
Definition: strciphr.h:88
Crypto++ library namespace.
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:276
The IV must be random and unpredictable.
Definition: cryptlib.h:701
unsigned int IVSize() const
Returns length of the IV accepted by this object.
Definition: modes.h:96
bool IsResynchronizable() const
Determines if the object can be resynchronized.
Definition: cryptlib.h:716
bool CipherIsRandomAccess() const
Flag indicating random access.
Definition: modes.h:213
CFB block cipher mode of operation.
Definition: modes.h:165
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:287
bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
Definition: modes.h:85
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:214
Base class for additive stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:288
CFB block cipher mode of operation providing FIPS validated cryptography.
Definition: modes.h:467
ECB block cipher mode of operation default implementation.
Definition: modes.h:269
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher)
Construct a CipherModeFinalTemplate.
Definition: modes.h:414
The IV must be unique.
Definition: cryptlib.h:697
bool IsRandomAccess() const
Determines whether the cipher supports random access.
Definition: modes.h:256
Interface for retrieving values given their names.
Definition: cryptlib.h:291
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
Construct a CipherModeFinalTemplate.
Definition: modes.h:389
The IV must be random and possibly predictable.
Definition: cryptlib.h:699
CBC block cipher mode of operation.
Definition: modes.h:551
CBC mode with ciphertext stealing, external cipher.
Definition: modes.h:587
Base class information.
Definition: simple.h:36