Crypto++ 8.2
Free C&
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
31NAMESPACE_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
49class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CipherModeBase : public SymmetricCipher
50{
51public:
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
127protected:
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
148template <class POLICY_INTERFACE>
149class 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
155template <class POLICY_INTERFACE>
156void 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
165class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_ModePolicy : public ModePolicyCommonTemplate<CFB_CipherAbstractPolicy>
166{
167public:
168 CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "CFB";}
169
170 virtual ~CFB_ModePolicy() {}
171 CFB_ModePolicy() : m_feedbackSize(0) {}
173
174protected:
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.
196inline 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
208class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE OFB_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
209{
210public:
211 CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "OFB";}
212
213 bool CipherIsRandomAccess() const {return false;}
215
216protected:
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
224class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CTR_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
225{
226public:
227 CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "CTR";}
228
229 virtual ~CTR_ModePolicy() {}
230 bool CipherIsRandomAccess() const {return true;}
232
233protected:
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
250class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockOrientedCipherModeBase : public CipherModeBase
251{
252public:
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
261protected:
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
269class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ECB_OneWay : public BlockOrientedCipherModeBase
270{
271public:
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
282class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_ModeBase : public BlockOrientedCipherModeBase
283{
284public:
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
293class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Encryption : public CBC_ModeBase
294{
295public:
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
301class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Encryption : public CBC_Encryption
302{
303public:
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
310protected:
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
321class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Decryption : public CBC_ModeBase
322{
323public:
324 virtual ~CBC_Decryption() {}
325 void ProcessData(byte *outString, const byte *inString, size_t length);
326
327protected:
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
335class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Decryption : public CBC_Decryption
336{
337public:
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
343template <class CIPHER, class BASE>
344class CipherModeFinalTemplate_CipherHolder : protected ObjectHolder<CIPHER>, public AlgorithmImpl<BASE, CipherModeFinalTemplate_CipherHolder<CIPHER, BASE> >
345{
346public:
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
406template <class BASE>
408{
409public:
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.
449template <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.
469template <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.
491template <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.
513template <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.
532template <class CIPHER>
534{
537};
538
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.
553template <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
576template <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
596NAMESPACE_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
Classes for working with NameValuePairs.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Definition: algparam.h:502
Standard names for retrieving values by name when working with NameValuePairs.
Base class for additive stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:300
Base class information.
Definition: simple.h:37
Interface for one direction (encryption or decryption) of a block cipher.
Definition: cryptlib.h:1251
Block cipher mode of operation default implementation.
Definition: modes.h:251
bool IsForwardTransformation() const
Determines if the cipher is being operated in its forward direction.
Definition: modes.h:258
bool IsSelfInverting() const
Determines whether the cipher is self-inverting.
Definition: modes.h:257
bool IsRandomAccess() const
Determines whether the cipher supports random access.
Definition: modes.h:256
unsigned int MandatoryBlockSize() const
Provides the mandatory block size of the cipher.
Definition: modes.h:255
void Resynchronize(const byte *iv, int length=-1)
Resynchronize with an IV.
Definition: modes.h:259
CBC-CTS block cipher mode of operation decryption operation.
Definition: modes.h:336
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:338
CBC-CTS block cipher mode of operation encryption operation.
Definition: modes.h:302
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:307
CBC block cipher mode of operation decryption operation.
Definition: modes.h:322
CBC block cipher mode of operation encryption operation.
Definition: modes.h:294
CBC block cipher mode of operation default implementation.
Definition: modes.h:283
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:287
unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: modes.h:289
Base class for feedback based stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:564
Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface.
Definition: strciphr.h:654
Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface.
Definition: strciphr.h:645
CFB block cipher mode of operation.
Definition: modes.h:166
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:172
CTR block cipher mode of operation.
Definition: modes.h:225
bool CipherIsRandomAccess() const
Flag indicating random access.
Definition: modes.h:230
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:231
Block cipher mode of operation information.
Definition: modes.h:50
unsigned int IVSize() const
Returns length of the IV accepted by this object.
Definition: modes.h:96
size_t GetValidKeyLength(size_t keylength) const
Returns a valid key length for the algorithm.
Definition: modes.h:79
void SetCipherWithIV(BlockCipher &cipher, const byte *iv, int feedbackSize=0)
Set external block cipher and IV.
Definition: modes.h:117
size_t MaxKeyLength() const
Returns largest valid key length.
Definition: modes.h:65
size_t DefaultKeyLength() const
Returns default key length.
Definition: modes.h:69
void SetCipher(BlockCipher &cipher)
Set external block cipher.
Definition: modes.h:105
virtual IV_Requirement IVRequirement() const =0
Minimal requirement for secure IVs.
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition: modes.h:90
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
Definition: modes.h:55
size_t MinKeyLength() const
Returns smallest valid key length.
Definition: modes.h:61
bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
Definition: modes.h:85
Block cipher mode of operation aggregate.
Definition: modes.h:345
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
Construct a CipherModeFinalTemplate.
Definition: modes.h:392
CipherModeFinalTemplate_CipherHolder()
Construct a CipherModeFinalTemplate.
Definition: modes.h:356
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
Construct a CipherModeFinalTemplate.
Definition: modes.h:367
CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
Construct a CipherModeFinalTemplate.
Definition: modes.h:379
static std::string StaticAlgorithmName()
Provides the name of this algorithm.
Definition: modes.h:352
CipherModeFinalTemplate_ExternalCipher()
Construct a default CipherModeFinalTemplate.
Definition: modes.h:412
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: modes.h:434
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher)
Construct a CipherModeFinalTemplate.
Definition: modes.h:417
CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher, const byte *iv, int feedbackSize=0)
Construct a CipherModeFinalTemplate.
Definition: modes.h:425
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:21
ECB block cipher mode of operation default implementation.
Definition: modes.h:270
unsigned int OptimalBlockSize() const
Provides the input block size most efficient for this cipher.
Definition: modes.h:277
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
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:276
An invalid argument was detected.
Definition: cryptlib.h:203
Block cipher mode of operation common operations.
Definition: modes.h:150
Interface for retrieving values given their names.
Definition: cryptlib.h:294
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
Definition: cryptlib.h:363
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
Definition: cryptlib.h:395
OFB block cipher mode of operation.
Definition: modes.h:209
bool CipherIsRandomAccess() const
Flag indicating random access.
Definition: modes.h:213
IV_Requirement IVRequirement() const
Minimal requirement for secure IVs.
Definition: modes.h:214
Uses encapsulation to hide an object in derived classes.
Definition: misc.h:190
SecBlock<byte> typedef.
Definition: secblock.h:1058
bool IsResynchronizable() const
Determines if the object can be resynchronized.
Definition: cryptlib.h:712
IV_Requirement
Secure IVs requirements as enumerated values.
Definition: cryptlib.h:691
@ UNIQUE_IV
The IV must be unique.
Definition: cryptlib.h:693
@ RANDOM_IV
The IV must be random and possibly predictable.
Definition: cryptlib.h:695
@ NOT_RESYNCHRONIZABLE
The object does not use an IV.
Definition: cryptlib.h:701
@ UNPREDICTABLE_RANDOM_IV
The IV must be random and unpredictable.
Definition: cryptlib.h:697
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
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
Definition: cryptlib.h:755
virtual void ProcessData(byte *outString, const byte *inString, size_t length)=0
Encrypt or decrypt an array of bytes.
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
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode.
Definition: cryptlib.h:1259
Abstract base classes that provide a uniform interface to this library.
CipherDir
Specifies a direction for a cipher to operate.
Definition: cryptlib.h:123
Utility functions for the Crypto++ library.
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
Definition: misc.h:443
void CopyOrZero(void *dest, size_t dsize, const void *src, size_t ssize)
Initialize a block of memory.
Definition: modes.h:196
Crypto++ library namespace.
const char * StolenIV()
byte *
Definition: argnames.h:22
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
Definition: argnames.h:21
const char * FeedbackSize()
int
Definition: argnames.h:25
const char * BlockSize()
int, in bytes
Definition: argnames.h:27
Classes and functions for secure memory allocations.
Classes for implementing stream ciphers.
KeystreamOperation
Keystream operation flags.
Definition: strciphr.h:88
@ WRITE_KEYSTREAM
Wirte the keystream to the output buffer, input is NULL.
Definition: strciphr.h:90
CBC mode with ciphertext stealing, external cipher.
Definition: modes.h:591
CBC-CTS block cipher mode of operation.
Definition: modes.h:578
CBC mode, external cipher.
Definition: modes.h:567
CBC block cipher mode of operation.
Definition: modes.h:555
CFB mode, external cipher, providing FIPS validated cryptography.
Definition: modes.h:481
CFB block cipher mode of operation providing FIPS validated cryptography.
Definition: modes.h:471
CFB mode, external cipher.
Definition: modes.h:460
CFB block cipher mode of operation.
Definition: modes.h:451
CTR mode, external cipher.
Definition: modes.h:524
CTR block cipher mode of operation.
Definition: modes.h:515
Block cipher mode of operation information.
Definition: modes.h:45
ECB mode, external cipher.
Definition: modes.h:545
ECB block cipher mode of operation.
Definition: modes.h:534
OFB mode, external cipher.
Definition: modes.h:502
OFB block cipher mode of operation.
Definition: modes.h:493
Provides Encryption and Decryption typedefs used by derived classes to implement a symmetric cipher.
Definition: seckey.h:414
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:69