Crypto++  8.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  /// \param length size of the key in bytes
365  /// \details key must be at least DEFAULT_KEYLENGTH in length. Internally, the function calls
366  /// SimpleKeyingInterface::SetKey.
367  CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
368  {
369  this->m_cipher = &this->m_object;
370  this->SetKey(key, length);
371  }
372 
373  /// \brief Construct a CipherModeFinalTemplate
374  /// \param key a byte array used to key the cipher
375  /// \param length size of the key in bytes
376  /// \param iv a byte array used to resynchronize the cipher
377  /// \details key must be at least DEFAULT_KEYLENGTH in length. iv must be IVSize() or
378  /// BLOCKSIZE in length. Internally, the function calls SimpleKeyingInterface::SetKey.
379  CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
380  {
381  this->m_cipher = &this->m_object;
382  this->SetKey(key, length, MakeParameters(Name::IV(), ConstByteArrayParameter(iv, this->m_cipher->BlockSize())));
383  }
384 
385  /// \brief Construct a CipherModeFinalTemplate
386  /// \param key a byte array used to key the cipher
387  /// \param length size of the key in bytes
388  /// \param iv a byte array used to resynchronize the cipher
389  /// \param feedbackSize the feedback size, in bytes
390  /// \details key must be at least DEFAULT_KEYLENGTH in length. iv must be IVSize() or
391  /// BLOCKSIZE in length. Internally, the function calls SimpleKeyingInterface::SetKey.
392  CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
393  {
394  this->m_cipher = &this->m_object;
395  this->SetKey(key, length, MakeParameters(Name::IV(), ConstByteArrayParameter(iv, this->m_cipher->BlockSize()))(Name::FeedbackSize(), feedbackSize));
396  }
397 
398  // Algorithm class
399  std::string AlgorithmProvider() const {
400  return this->m_cipher->AlgorithmProvider();
401  }
402 };
403 
404 /// \tparam BASE CipherModeFinalTemplate_CipherHolder base class
405 /// \details Base class for external mode cipher combinations
406 template <class BASE>
408 {
409 public:
410  /// \brief Construct a default CipherModeFinalTemplate
411  /// \details The cipher is not keyed.
413 
414  /// \brief Construct a CipherModeFinalTemplate
415  /// \param cipher An external block cipher
416  /// \details The cipher should be keyed.
418  {this->SetCipher(cipher);}
419 
420  /// \brief Construct a CipherModeFinalTemplate
421  /// \param cipher An external block cipher
422  /// \param iv a byte array used to resynchronize the cipher
423  /// \param feedbackSize the feedback size, in bytes
424  /// \details The cipher should be keyed.
425  CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher, const byte *iv, int feedbackSize = 0)
426  {this->SetCipherWithIV(cipher, iv, feedbackSize);}
427 
428  /// \brief Provides the name of this algorithm
429  /// \return the standard algorithm name
430  /// \details The standard algorithm name can be a name like \a AES or \a AES/GCM. Some algorithms
431  /// do not have standard names yet. For example, there is no standard algorithm name for
432  /// Shoup's ECIES.
433  /// \note AlgorithmName is not universally implemented yet
434  std::string AlgorithmName() const
435  {return (this->m_cipher ? this->m_cipher->AlgorithmName() + "/" : std::string("")) + BASE::StaticAlgorithmName();}
436 
437  // Algorithm class
438  std::string AlgorithmProvider() const
439  {return this->m_cipher->AlgorithmProvider();}
440 };
441 
445 
446 /// \brief CFB block cipher mode of operation
447 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
448 /// on the Crypto++ wiki.
449 template <class CIPHER>
451 {
454 };
455 
456 /// \brief CFB mode, external cipher.
457 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
458 /// on the Crypto++ wiki.
460 {
463 };
464 
465 /// \brief CFB block cipher mode of operation providing FIPS validated cryptography.
466 /// \details Requires full block plaintext according to FIPS 800-38A
467 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
468 /// on the Crypto++ wiki.
469 template <class CIPHER>
471 {
474 };
475 
476 /// \brief CFB mode, external cipher, providing FIPS validated cryptography.
477 /// \details Requires full block plaintext according to FIPS 800-38A
478 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
479 /// on the Crypto++ wiki.
481 {
484 };
485 
487 
488 /// \brief OFB block cipher mode of operation
489 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
490 /// on the Crypto++ wiki.
491 template <class CIPHER>
493 {
495  typedef Encryption Decryption;
496 };
497 
498 /// \brief OFB mode, external cipher.
499 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
500 /// on the Crypto++ wiki.
502 {
504  typedef Encryption Decryption;
505 };
506 
509 
510 /// \brief CTR block cipher mode of operation
511 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
512 /// on the Crypto++ wiki.
513 template <class CIPHER>
515 {
517  typedef Encryption Decryption;
518 };
519 
520 /// \brief CTR mode, external cipher.
521 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
522 /// on the Crypto++ wiki.
524 {
526  typedef Encryption Decryption;
527 };
528 
529 /// \brief ECB block cipher mode of operation
530 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
531 /// on the Crypto++ wiki.
532 template <class CIPHER>
534 {
537 };
538 
539 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ECB_OneWay>;
540 
541 /// \brief ECB mode, external cipher.
542 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
543 /// on the Crypto++ wiki.
545 {
547  typedef Encryption Decryption;
548 };
549 
550 /// \brief CBC block cipher mode of operation
551 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
552 /// on the Crypto++ wiki.
553 template <class CIPHER>
555 {
558 };
559 
562 
563 /// \brief CBC mode, external cipher
564 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
565 /// on the Crypto++ wiki.
567 {
570 };
571 
572 /// \brief CBC-CTS block cipher mode of operation
573 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
574 /// on the Crypto++ wiki.
575 /// \since Crypto++ 3.0
576 template <class CIPHER>
578 {
581 };
582 
585 
586 /// \brief CBC mode with ciphertext stealing, external cipher
587 /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
588 /// on the Crypto++ wiki.
589 /// \since Crypto++ 3.0
591 {
594 };
595 
596 NAMESPACE_END
597 
598 // Issue 340
599 #if CRYPTOPP_MSC_VERSION
600 # pragma warning(pop)
601 #endif
602 
603 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
604 # pragma GCC diagnostic pop
605 #endif
606 
607 #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:395
Standard names for retrieving values by name when working with NameValuePairs.
An invalid argument was detected.
Definition: cryptlib.h:202
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:480
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:363
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:425
CipherDir
Specifies a direction for a cipher to operate.
Definition: cryptlib.h:123
CipherModeFinalTemplate_ExternalCipher()
Construct a default CipherModeFinalTemplate.
Definition: modes.h:412
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:554
The object does not use an IV.
Definition: cryptlib.h:701
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:1058
static std::string StaticAlgorithmName()
Provides the name of this algorithm.
Definition: modes.h:352
CBC-CTS block cipher mode of operation.
Definition: modes.h:577
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:514
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: modes.h:434
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
Construct a CipherModeFinalTemplate.
Definition: modes.h:367
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:1248
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:533
Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface...
Definition: strciphr.h:644
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:459
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:755
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:1256
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:544
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
Definition: cryptlib.h:500
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:635
OFB block cipher mode of operation.
Definition: modes.h:492
CBC mode, external cipher.
Definition: modes.h:566
#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:450
CTR block cipher mode of operation.
Definition: modes.h:224
OFB mode, external cipher.
Definition: modes.h:501
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
Construct a CipherModeFinalTemplate.
Definition: modes.h:379
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:413
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
IV_Requirement
Secure IVs requirements as enumerated values.
Definition: cryptlib.h:691
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:523
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:697
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:712
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:290
CFB block cipher mode of operation providing FIPS validated cryptography.
Definition: modes.h:470
ECB block cipher mode of operation default implementation.
Definition: modes.h:269
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher)
Construct a CipherModeFinalTemplate.
Definition: modes.h:417
The IV must be unique.
Definition: cryptlib.h:693
bool IsRandomAccess() const
Determines whether the cipher supports random access.
Definition: modes.h:256
Interface for retrieving values given their names.
Definition: cryptlib.h:293
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
Construct a CipherModeFinalTemplate.
Definition: modes.h:392
The IV must be random and possibly predictable.
Definition: cryptlib.h:695
CBC block cipher mode of operation.
Definition: modes.h:554
CBC mode with ciphertext stealing, external cipher.
Definition: modes.h:590
Base class information.
Definition: simple.h:36