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.
44 struct CipherModeDocumentation : public SymmetricCipherDocumentation
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) {}
172 IV_Requirement IVRequirement() const {return RANDOM_IV;}
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;}
214 IV_Requirement IVRequirement() const {return UNIQUE_IV;}
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;}
231 IV_Requirement IVRequirement() const {return RANDOM_IV;}
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();}
276 IV_Requirement IVRequirement() const {return NOT_RESYNCHRONIZABLE;}
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
287 IV_Requirement IVRequirement() const {return UNPREDICTABLE_RANDOM_IV;}
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
356 CipherModeFinalTemplate_CipherHolder()
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>
407 class CipherModeFinalTemplate_ExternalCipher : public BASE
408 {
409 public:
410 /// \brief Construct a default CipherModeFinalTemplate
411 /// \details The cipher is not keyed.
412 CipherModeFinalTemplate_ExternalCipher() {}
413
414 /// \brief Construct a CipherModeFinalTemplate
415 /// \param cipher An external block cipher
416 /// \details The cipher should be keyed.
417 CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher)
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
442 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
443 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
444 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
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>
450 struct CFB_Mode : public CipherModeDocumentation
451 {
452 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Encryption;
453 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption;
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.
459 struct CFB_Mode_ExternalCipher : public CipherModeDocumentation
460 {
461 typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Encryption;
462 typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption;
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>
470 struct CFB_FIPS_Mode : public CipherModeDocumentation
471 {
472 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Encryption;
473 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Decryption;
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.
480 struct CFB_FIPS_Mode_ExternalCipher : public CipherModeDocumentation
481 {
482 typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Encryption;
483 typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Decryption;
484 };
485
486 CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> >;
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>
492 struct OFB_Mode : public CipherModeDocumentation
493 {
494 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> > > > Encryption;
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.
501 struct OFB_Mode_ExternalCipher : public CipherModeDocumentation
502 {
503 typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> > > > Encryption;
504 typedef Encryption Decryption;
505 };
506
507 CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> >;
508 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > >;
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>
514 struct CTR_Mode : public CipherModeDocumentation
515 {
516 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > > Encryption;
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.
523 struct CTR_Mode_ExternalCipher : public CipherModeDocumentation
524 {
525 typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > > Encryption;
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>
533 struct ECB_Mode : public CipherModeDocumentation
534 {
535 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ECB_OneWay> Encryption;
536 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Decryption, ECB_OneWay> Decryption;
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.
544 struct ECB_Mode_ExternalCipher : public CipherModeDocumentation
545 {
546 typedef CipherModeFinalTemplate_ExternalCipher<ECB_OneWay> Encryption;
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>
554 struct CBC_Mode : public CipherModeDocumentation
555 {
556 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, CBC_Encryption> Encryption;
557 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Decryption, CBC_Decryption> Decryption;
558 };
559
560 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Encryption>;
561 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Decryption>;
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.
566 struct CBC_Mode_ExternalCipher : public CipherModeDocumentation
567 {
568 typedef CipherModeFinalTemplate_ExternalCipher<CBC_Encryption> Encryption;
569 typedef CipherModeFinalTemplate_ExternalCipher<CBC_Decryption> Decryption;
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>
577 struct CBC_CTS_Mode : public CipherModeDocumentation
578 {
579 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, CBC_CTS_Encryption> Encryption;
580 typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Decryption, CBC_CTS_Decryption> Decryption;
581 };
582
583 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Encryption>;
584 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Decryption>;
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
590 struct CBC_CTS_Mode_ExternalCipher : public CipherModeDocumentation
591 {
592 typedef CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Encryption> Encryption;
593 typedef CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Decryption> Decryption;
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
ConstByteArrayParameter
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:20
CipherModeFinalTemplate_ExternalCipher
Definition: modes.h:407
NameValuePairs::GetIntValueWithDefault
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
Definition: cryptlib.h:395
argnames.h
Standard names for retrieving values by name when working with NameValuePairs.
InvalidArgument
An invalid argument was detected.
Definition: cryptlib.h:202
Name::FeedbackSize
const char * FeedbackSize()
int
Definition: argnames.h:25
CipherModeFinalTemplate_CipherHolder::CipherModeFinalTemplate_CipherHolder
CipherModeFinalTemplate_CipherHolder()
Construct a CipherModeFinalTemplate.
Definition: modes.h:356
BlockOrientedCipherModeBase::Resynchronize
void Resynchronize(const byte *iv, int length=-1)
Resynchronize with an IV.
Definition: modes.h:259
algparam.h
Classes for working with NameValuePairs.
StreamTransformation::ProcessData
virtual void ProcessData(byte *outString, const byte *inString, size_t length)=0
Encrypt or decrypt an array of bytes.
misc.h
Utility functions for the Crypto++ library.
SimpleKeyingInterface::SetKey
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
CipherModeBase::GetValidKeyLength
size_t GetValidKeyLength(size_t keylength) const
Returns a valid key length for the algorithm.
Definition: modes.h:79
CFB_FIPS_Mode_ExternalCipher
CFB mode, external cipher, providing FIPS validated cryptography.
Definition: modes.h:480
BlockOrientedCipherModeBase::IsForwardTransformation
bool IsForwardTransformation() const
Determines if the cipher is being operated in its forward direction.
Definition: modes.h:258
CipherModeBase::SetCipherWithIV
void SetCipherWithIV(BlockCipher &cipher, const byte *iv, int feedbackSize=0)
Set external block cipher and IV.
Definition: modes.h:117
NameValuePairs::GetValueWithDefault
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
Definition: cryptlib.h:363
CTR_ModePolicy::IVRequirement
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:231
StreamTransformation::ProcessLastBlock
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::CipherModeFinalTemplate_ExternalCipher
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher, const byte *iv, int feedbackSize=0)
Construct a CipherModeFinalTemplate.
Definition: modes.h:425
CipherDir
CipherDir
Specifies a direction for a cipher to operate.
Definition: cryptlib.h:123
CipherModeFinalTemplate_ExternalCipher::CipherModeFinalTemplate_ExternalCipher
CipherModeFinalTemplate_ExternalCipher()
Construct a default CipherModeFinalTemplate.
Definition: modes.h:412
cryptlib.h
Abstract base classes that provide a uniform interface to this library.
memcpy_s
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
Definition: misc.h:411
CFB_CipherTemplate
Base class for feedback based stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:563
SimpleKeyingInterface::NOT_RESYNCHRONIZABLE
The object does not use an IV.
Definition: cryptlib.h:701
CopyOrZero
void CopyOrZero(void *dest, size_t dsize, const void *src, size_t ssize)
Initialize a block of memory.
Definition: modes.h:196
WRITE_KEYSTREAM
Wirte the keystream to the output buffer, input is NULL.
Definition: strciphr.h:90
SecByteBlock
SecBlock<byte> typedef.
Definition: secblock.h:1058
CipherModeFinalTemplate_CipherHolder::StaticAlgorithmName
static std::string StaticAlgorithmName()
Provides the name of this algorithm.
Definition: modes.h:352
CBC_CTS_Mode
CBC-CTS block cipher mode of operation.
Definition: modes.h:577
CTR_ModePolicy::CipherIsRandomAccess
bool CipherIsRandomAccess() const
Flag indicating random access.
Definition: modes.h:230
CipherModeBase::MinKeyLength
size_t MinKeyLength() const
Returns smallest valid key length.
Definition: modes.h:61
CTR_Mode
CTR block cipher mode of operation.
Definition: modes.h:514
CipherModeFinalTemplate_ExternalCipher::AlgorithmName
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: modes.h:434
CipherModeFinalTemplate_CipherHolder::CipherModeFinalTemplate_CipherHolder
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
Construct a CipherModeFinalTemplate.
Definition: modes.h:367
ECB_OneWay::OptimalBlockSize
unsigned int OptimalBlockSize() const
Provides the input block size most efficient for this cipher.
Definition: modes.h:277
BlockCipher
Interface for one direction (encryption or decryption) of a block cipher.
Definition: cryptlib.h:1250
Name::StolenIV
const char * StolenIV()
byte *
Definition: argnames.h:22
OFB_ModePolicy
OFB block cipher mode of operation.
Definition: modes.h:208
CBC_CTS_Decryption
CBC-CTS block cipher mode of operation decryption operation.
Definition: modes.h:335
CipherModeBase::MaxKeyLength
size_t MaxKeyLength() const
Returns largest valid key length.
Definition: modes.h:65
secblock.h
Classes and functions for secure memory allocations.
ECB_Mode
ECB block cipher mode of operation.
Definition: modes.h:533
CFB_DecryptionTemplate
Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface...
Definition: strciphr.h:653
ObjectHolder
Uses encapsulation to hide an object in derived classes.
Definition: misc.h:189
CipherModeBase::SetCipher
void SetCipher(BlockCipher &cipher)
Set external block cipher.
Definition: modes.h:105
CBC_CTS_Encryption
CBC-CTS block cipher mode of operation encryption operation.
Definition: modes.h:301
SimpleKeyingInterface::IVRequirement
virtual IV_Requirement IVRequirement() const =0
Minimal requirement for secure IVs.
MakeParameters
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Definition: algparam.h:502
CipherModeFinalTemplate_CipherHolder
Block cipher mode of operation aggregate.
Definition: modes.h:344
CFB_Mode_ExternalCipher
CFB mode, external cipher.
Definition: modes.h:459
CBC_ModeBase
CBC block cipher mode of operation default implementation.
Definition: modes.h:282
BlockOrientedCipherModeBase::IsSelfInverting
bool IsSelfInverting() const
Determines whether the cipher is self-inverting.
Definition: modes.h:257
CBC_CTS_Decryption::MinLastBlockSize
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:338
SimpleKeyingInterface::Resynchronize
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
Definition: cryptlib.h:755
CipherModeBase::AlgorithmProvider
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
Definition: modes.h:55
ECB_OneWay::SetKey
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
CipherModeDocumentation
Block cipher mode of operation information.
Definition: modes.h:44
SymmetricCipher
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode...
Definition: cryptlib.h:1258
BlockOrientedCipherModeBase::MandatoryBlockSize
unsigned int MandatoryBlockSize() const
Provides the mandatory block size of the cipher.
Definition: modes.h:255
BlockOrientedCipherModeBase
Block cipher mode of operation default implementation.
Definition: modes.h:250
ECB_Mode_ExternalCipher
ECB mode, external cipher.
Definition: modes.h:544
g_nullNameValuePairs
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
Definition: cryptlib.h:500
CBC_CTS_Encryption::MinLastBlockSize
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:307
CipherModeBase::DefaultKeyLength
size_t DefaultKeyLength() const
Returns default key length.
Definition: modes.h:69
CFB_EncryptionTemplate
Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface...
Definition: strciphr.h:644
OFB_Mode
OFB block cipher mode of operation.
Definition: modes.h:492
CBC_Mode_ExternalCipher
CBC mode, external cipher.
Definition: modes.h:566
CRYPTOPP_ASSERT
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:69
Name::BlockSize
const char * BlockSize()
int, in bytes
Definition: argnames.h:27
CFB_Mode
CFB block cipher mode of operation.
Definition: modes.h:450
CTR_ModePolicy
CTR block cipher mode of operation.
Definition: modes.h:224
OFB_Mode_ExternalCipher
OFB mode, external cipher.
Definition: modes.h:501
CipherModeFinalTemplate_CipherHolder::CipherModeFinalTemplate_CipherHolder
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
Construct a CipherModeFinalTemplate.
Definition: modes.h:379
Name::IV
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
Definition: argnames.h:21
strciphr.h
Classes for implementing stream ciphers.
SymmetricCipherDocumentation
Provides Encryption and Decryption typedefs used by derived classes to implement a symmetric cipher...
Definition: seckey.h:413
CipherModeBase::OptimalDataAlignment
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition: modes.h:90
CFB_ModePolicy::IVRequirement
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:172
SimpleKeyingInterface::IV_Requirement
IV_Requirement
Secure IVs requirements as enumerated values.
Definition: cryptlib.h:691
CipherModeBase
Block cipher mode of operation information.
Definition: modes.h:49
CBC_Decryption
CBC block cipher mode of operation decryption operation.
Definition: modes.h:321
CTR_Mode_ExternalCipher
CTR mode, external cipher.
Definition: modes.h:523
CBC_ModeBase::MinLastBlockSize
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:289
CBC_Encryption
CBC block cipher mode of operation encryption operation.
Definition: modes.h:293
BlockOrientedCipherModeBase::UncheckedSetKey
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
ModePolicyCommonTemplate
Block cipher mode of operation common operations.
Definition: modes.h:149
KeystreamOperation
KeystreamOperation
Keystream operation flags.
Definition: strciphr.h:88
CryptoPP
Crypto++ library namespace.
ECB_OneWay::IVRequirement
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:276
SimpleKeyingInterface::UNPREDICTABLE_RANDOM_IV
The IV must be random and unpredictable.
Definition: cryptlib.h:697
CipherModeBase::IVSize
unsigned int IVSize() const
Returns length of the IV accepted by this object.
Definition: modes.h:96
SimpleKeyingInterface::IsResynchronizable
bool IsResynchronizable() const
Determines if the object can be resynchronized.
Definition: cryptlib.h:712
OFB_ModePolicy::CipherIsRandomAccess
bool CipherIsRandomAccess() const
Flag indicating random access.
Definition: modes.h:213
CFB_ModePolicy
CFB block cipher mode of operation.
Definition: modes.h:165
CBC_ModeBase::IVRequirement
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:287
CipherModeBase::IsValidKeyLength
bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
Definition: modes.h:85
OFB_ModePolicy::IVRequirement
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:214
AdditiveCipherTemplate
Base class for additive stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:299
CFB_FIPS_Mode
CFB block cipher mode of operation providing FIPS validated cryptography.
Definition: modes.h:470
ECB_OneWay
ECB block cipher mode of operation default implementation.
Definition: modes.h:269
CipherModeFinalTemplate_ExternalCipher::CipherModeFinalTemplate_ExternalCipher
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher)
Construct a CipherModeFinalTemplate.
Definition: modes.h:417
SimpleKeyingInterface::UNIQUE_IV
The IV must be unique.
Definition: cryptlib.h:693
BlockOrientedCipherModeBase::IsRandomAccess
bool IsRandomAccess() const
Determines whether the cipher supports random access.
Definition: modes.h:256
NameValuePairs
Interface for retrieving values given their names.
Definition: cryptlib.h:293
CipherModeFinalTemplate_CipherHolder::CipherModeFinalTemplate_CipherHolder
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
Construct a CipherModeFinalTemplate.
Definition: modes.h:392
SimpleKeyingInterface::RANDOM_IV
The IV must be random and possibly predictable.
Definition: cryptlib.h:695
CBC_Mode
CBC block cipher mode of operation.
Definition: modes.h:554
CBC_CTS_Mode_ExternalCipher
CBC mode with ciphertext stealing, external cipher.
Definition: modes.h:590
AlgorithmImpl
Base class information.
Definition: simple.h:36