modes.h

Go to the documentation of this file.
00001 #ifndef CRYPTOPP_MODES_H
00002 #define CRYPTOPP_MODES_H
00003 
00004 /*! \file
00005 */
00006 
00007 #include "cryptlib.h"
00008 #include "secblock.h"
00009 #include "misc.h"
00010 #include "strciphr.h"
00011 #include "argnames.h"
00012 #include "algparam.h"
00013 
00014 NAMESPACE_BEGIN(CryptoPP)
00015 
00016 //! Cipher mode documentation. See NIST SP 800-38A for definitions of these modes.
00017 
00018 /*! Each class derived from this one defines two types, Encryption and Decryption, 
00019     both of which implement the SymmetricCipher interface.
00020     For each mode there are two classes, one of which is a template class,
00021     and the other one has a name that ends in "_ExternalCipher".
00022     The "external cipher" mode objects hold a reference to the underlying block cipher,
00023     instead of holding an instance of it. The reference must be passed in to the constructor.
00024     For the "cipher holder" classes, the CIPHER template parameter should be a class
00025     derived from BlockCipherDocumentation, for example DES or AES.
00026 */
00027 struct CipherModeDocumentation : public SymmetricCipherDocumentation
00028 {
00029 };
00030 
00031 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CipherModeBase : public SymmetricCipher
00032 {
00033 public:
00034     size_t MinKeyLength() const {return m_cipher->MinKeyLength();}
00035     size_t MaxKeyLength() const {return m_cipher->MaxKeyLength();}
00036     size_t DefaultKeyLength() const {return m_cipher->DefaultKeyLength();}
00037     size_t GetValidKeyLength(size_t n) const {return m_cipher->GetValidKeyLength(n);}
00038     bool IsValidKeyLength(size_t n) const {return m_cipher->IsValidKeyLength(n);}
00039 
00040     unsigned int OptimalDataAlignment() const {return BlockSize();}
00041 
00042     unsigned int IVSize() const {return BlockSize();}
00043     virtual IV_Requirement IVRequirement() const =0;
00044 
00045 protected:
00046     inline unsigned int BlockSize() const {assert(m_register.size() > 0); return (unsigned int)m_register.size();}
00047     virtual void SetFeedbackSize(unsigned int feedbackSize)
00048     {
00049         if (!(feedbackSize == 0 || feedbackSize == BlockSize()))
00050             throw InvalidArgument("CipherModeBase: feedback size cannot be specified for this cipher mode");
00051     }
00052     virtual void ResizeBuffers()
00053     {
00054         m_register.New(m_cipher->BlockSize());
00055     }
00056 
00057     BlockCipher *m_cipher;
00058     SecByteBlock m_register;
00059 };
00060 
00061 template <class POLICY_INTERFACE>
00062 class CRYPTOPP_NO_VTABLE ModePolicyCommonTemplate : public CipherModeBase, public POLICY_INTERFACE
00063 {
00064     unsigned int GetAlignment() const {return m_cipher->BlockAlignment();}
00065     void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length);
00066 };
00067 
00068 template <class POLICY_INTERFACE>
00069 void ModePolicyCommonTemplate<POLICY_INTERFACE>::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)
00070 {
00071     m_cipher->SetKey(key, length, params);
00072     ResizeBuffers();
00073     int feedbackSize = params.GetIntValueWithDefault(Name::FeedbackSize(), 0);
00074     SetFeedbackSize(feedbackSize);
00075 }
00076 
00077 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_ModePolicy : public ModePolicyCommonTemplate<CFB_CipherAbstractPolicy>
00078 {
00079 public:
00080     IV_Requirement IVRequirement() const {return RANDOM_IV;}
00081     static const char * CRYPTOPP_API StaticAlgorithmName() {return "CFB";}
00082 
00083 protected:
00084     unsigned int GetBytesPerIteration() const {return m_feedbackSize;}
00085     byte * GetRegisterBegin() {return m_register + BlockSize() - m_feedbackSize;}
00086     void TransformRegister()
00087     {
00088         assert(m_cipher->IsForwardTransformation());    // CFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt
00089         m_cipher->ProcessBlock(m_register, m_temp);
00090         unsigned int updateSize = BlockSize()-m_feedbackSize;
00091         memmove_s(m_register, m_register.size(), m_register+m_feedbackSize, updateSize);
00092         memcpy_s(m_register+updateSize, m_register.size()-updateSize, m_temp, m_feedbackSize);
00093     }
00094     void CipherResynchronize(const byte *iv)
00095     {
00096         memcpy_s(m_register, m_register.size(), iv, BlockSize());
00097         TransformRegister();
00098     }
00099     void SetFeedbackSize(unsigned int feedbackSize)
00100     {
00101         if (feedbackSize > BlockSize())
00102             throw InvalidArgument("CFB_Mode: invalid feedback size");
00103         m_feedbackSize = feedbackSize ? feedbackSize : BlockSize();
00104     }
00105     void ResizeBuffers()
00106     {
00107         CipherModeBase::ResizeBuffers();
00108         m_temp.New(BlockSize());
00109     }
00110 
00111     SecByteBlock m_temp;
00112     unsigned int m_feedbackSize;
00113 };
00114 
00115 inline void CopyOrZero(void *dest, const void *src, size_t s)
00116 {
00117     if (src)
00118         memcpy_s(dest, s, src, s);
00119     else
00120         memset(dest, 0, s);
00121 }
00122 
00123 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE OFB_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
00124 {
00125 public:
00126     bool IsRandomAccess() const {return false;}
00127     IV_Requirement IVRequirement() const {return UNIQUE_IV;}
00128     static const char * CRYPTOPP_API StaticAlgorithmName() {return "OFB";}
00129 
00130 private:
00131     unsigned int GetBytesPerIteration() const {return BlockSize();}
00132     unsigned int GetIterationsToBuffer() const {return 1;}
00133     void WriteKeystream(byte *keystreamBuffer, size_t iterationCount)
00134     {
00135         assert(iterationCount == 1);
00136         assert(m_cipher->IsForwardTransformation());    // OFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt
00137         m_cipher->ProcessBlock(keystreamBuffer);
00138     }
00139     void CipherResynchronize(byte *keystreamBuffer, const byte *iv)
00140     {
00141         CopyOrZero(keystreamBuffer, iv, BlockSize());
00142     }
00143 };
00144 
00145 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CTR_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
00146 {
00147 public:
00148     bool IsRandomAccess() const {return true;}
00149     IV_Requirement IVRequirement() const {return UNIQUE_IV;}
00150     static const char * CRYPTOPP_API StaticAlgorithmName() {return "CTR";}
00151 
00152 private:
00153     unsigned int GetAlignment() const {return m_cipher->BlockAlignment();}
00154     unsigned int GetBytesPerIteration() const {return BlockSize();}
00155     unsigned int GetIterationsToBuffer() const {return m_cipher->OptimalNumberOfParallelBlocks();}
00156     void WriteKeystream(byte *buffer, size_t iterationCount)
00157         {OperateKeystream(WRITE_KEYSTREAM, buffer, NULL, iterationCount);}
00158     bool CanOperateKeystream() const {return true;}
00159     void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount);
00160     void CipherResynchronize(byte *keystreamBuffer, const byte *iv);
00161     void SeekToIteration(lword iterationCount);
00162 
00163     inline void ProcessMultipleBlocks(byte *output, const byte *input, size_t n);
00164 
00165     SecByteBlock m_counterArray;
00166 };
00167 
00168 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockOrientedCipherModeBase : public CipherModeBase
00169 {
00170 public:
00171     void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);
00172     unsigned int MandatoryBlockSize() const {return BlockSize();}
00173     bool IsRandomAccess() const {return false;}
00174     bool IsSelfInverting() const {return false;}
00175     bool IsForwardTransformation() const {return m_cipher->IsForwardTransformation();}
00176     void Resynchronize(const byte *iv) {memcpy_s(m_register, m_register.size(), iv, BlockSize());}
00177     void ProcessData(byte *outString, const byte *inString, size_t length);
00178 
00179 protected:
00180     bool RequireAlignedInput() const {return true;}
00181     virtual void ProcessBlocks(byte *outString, const byte *inString, size_t numberOfBlocks) =0;
00182     void ResizeBuffers()
00183     {
00184         CipherModeBase::ResizeBuffers();
00185         m_buffer.New(BlockSize());
00186     }
00187 
00188     SecByteBlock m_buffer;
00189 };
00190 
00191 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ECB_OneWay : public BlockOrientedCipherModeBase
00192 {
00193 public:
00194     void SetKey(const byte *key, size_t length, const NameValuePairs &params = g_nullNameValuePairs)
00195         {m_cipher->SetKey(key, length, params); BlockOrientedCipherModeBase::ResizeBuffers();}
00196     IV_Requirement IVRequirement() const {return NOT_RESYNCHRONIZABLE;}
00197     unsigned int OptimalBlockSize() const {return BlockSize() * m_cipher->OptimalNumberOfParallelBlocks();}
00198     void ProcessBlocks(byte *outString, const byte *inString, size_t numberOfBlocks)
00199         {m_cipher->ProcessAndXorMultipleBlocks(inString, NULL, outString, numberOfBlocks);}
00200     static const char * CRYPTOPP_API StaticAlgorithmName() {return "ECB";}
00201 };
00202 
00203 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_ModeBase : public BlockOrientedCipherModeBase
00204 {
00205 public:
00206     IV_Requirement IVRequirement() const {return UNPREDICTABLE_RANDOM_IV;}
00207     bool RequireAlignedInput() const {return false;}
00208     unsigned int MinLastBlockSize() const {return 0;}
00209     static const char * CRYPTOPP_API StaticAlgorithmName() {return "CBC";}
00210 };
00211 
00212 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Encryption : public CBC_ModeBase
00213 {
00214 public:
00215     void ProcessBlocks(byte *outString, const byte *inString, size_t numberOfBlocks);
00216 };
00217 
00218 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Encryption : public CBC_Encryption
00219 {
00220 public:
00221     void SetStolenIV(byte *iv) {m_stolenIV = iv;}
00222     unsigned int MinLastBlockSize() const {return BlockSize()+1;}
00223     void ProcessLastBlock(byte *outString, const byte *inString, size_t length);
00224     static const char * CRYPTOPP_API StaticAlgorithmName() {return "CBC/CTS";}
00225 
00226 protected:
00227     void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params)
00228     {
00229         CBC_Encryption::UncheckedSetKey(key, length, params);
00230         m_stolenIV = params.GetValueWithDefault(Name::StolenIV(), (byte *)NULL);
00231     }
00232 
00233     byte *m_stolenIV;
00234 };
00235 
00236 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Decryption : public CBC_ModeBase
00237 {
00238 public:
00239     void ProcessBlocks(byte *outString, const byte *inString, size_t numberOfBlocks);
00240     
00241 protected:
00242     void ResizeBuffers()
00243     {
00244         BlockOrientedCipherModeBase::ResizeBuffers();
00245         m_temp.New(BlockSize());
00246     }
00247     SecByteBlock m_temp;
00248 };
00249 
00250 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Decryption : public CBC_Decryption
00251 {
00252 public:
00253     unsigned int MinLastBlockSize() const {return BlockSize()+1;}
00254     void ProcessLastBlock(byte *outString, const byte *inString, size_t length);
00255 };
00256 
00257 //! _
00258 template <class CIPHER, class BASE>
00259 class CipherModeFinalTemplate_CipherHolder : protected ObjectHolder<CIPHER>, public AlgorithmImpl<BASE, CipherModeFinalTemplate_CipherHolder<CIPHER, BASE> >
00260 {
00261 public:
00262     CipherModeFinalTemplate_CipherHolder()
00263     {
00264         this->m_cipher = &this->m_object;
00265         this->ResizeBuffers();
00266     }
00267     CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length)
00268     {
00269         this->m_cipher = &this->m_object;
00270         this->SetKey(key, length);
00271     }
00272     CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv)
00273     {
00274         this->m_cipher = &this->m_object;
00275         this->SetKey(key, length, MakeParameters(Name::IV(), iv));
00276     }
00277     CipherModeFinalTemplate_CipherHolder(const byte *key, size_t length, const byte *iv, int feedbackSize)
00278     {
00279         this->m_cipher = &this->m_object;
00280         this->SetKey(key, length, MakeParameters(Name::IV(), iv)(Name::FeedbackSize(), feedbackSize));
00281     }
00282 
00283     static std::string CRYPTOPP_API StaticAlgorithmName()
00284         {return CIPHER::StaticAlgorithmName() + "/" + BASE::StaticAlgorithmName();}
00285 };
00286 
00287 //! _
00288 template <class BASE>
00289 class CipherModeFinalTemplate_ExternalCipher : public BASE
00290 {
00291 public:
00292     CipherModeFinalTemplate_ExternalCipher() {}
00293     CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher)
00294         {SetCipher(cipher);}
00295     CipherModeFinalTemplate_ExternalCipher(BlockCipher &cipher, const byte *iv, int feedbackSize = 0)
00296         {SetCipherWithIV(cipher, iv, feedbackSize);}
00297 
00298     void SetCipher(BlockCipher &cipher);
00299     void SetCipherWithIV(BlockCipher &cipher, const byte *iv, int feedbackSize = 0);
00300 };
00301 
00302 template <class BASE>
00303 void CipherModeFinalTemplate_ExternalCipher<BASE>::SetCipher(BlockCipher &cipher)
00304 {
00305     this->ThrowIfResynchronizable();
00306     this->m_cipher = &cipher;
00307     this->ResizeBuffers();
00308 }
00309 
00310 template <class BASE>
00311 void CipherModeFinalTemplate_ExternalCipher<BASE>::SetCipherWithIV(BlockCipher &cipher, const byte *iv, int feedbackSize)
00312 {
00313     this->ThrowIfInvalidIV(iv);
00314     this->m_cipher = &cipher;
00315     this->ResizeBuffers();
00316     this->SetFeedbackSize(feedbackSize);
00317     if (this->IsResynchronizable())
00318         this->Resynchronize(iv);
00319 }
00320 
00321 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
00322 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
00323 CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
00324 
00325 //! CFB mode
00326 template <class CIPHER>
00327 struct CFB_Mode : public CipherModeDocumentation
00328 {
00329     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Encryption;
00330     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption;
00331 };
00332 
00333 //! CFB mode, external cipher
00334 struct CFB_Mode_ExternalCipher : public CipherModeDocumentation
00335 {
00336     typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Encryption;
00337     typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption;
00338 };
00339 
00340 //! CFB mode FIPS variant, requiring full block plaintext according to FIPS 800-38A
00341 template <class CIPHER>
00342 struct CFB_FIPS_Mode : public CipherModeDocumentation
00343 {
00344     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Encryption;
00345     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Decryption;
00346 };
00347 
00348 //! CFB mode FIPS variant, requiring full block plaintext according to FIPS 800-38A, external cipher
00349 struct CFB_FIPS_Mode_ExternalCipher : public CipherModeDocumentation
00350 {
00351     typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Encryption;
00352     typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Decryption;
00353 };
00354 
00355 CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> >;
00356 
00357 //! OFB mode
00358 template <class CIPHER>
00359 struct OFB_Mode : public CipherModeDocumentation
00360 {
00361     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> > > > Encryption;
00362     typedef Encryption Decryption;
00363 };
00364 
00365 //! OFB mode, external cipher
00366 struct OFB_Mode_ExternalCipher : public CipherModeDocumentation
00367 {
00368     typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> > > > Encryption;
00369     typedef Encryption Decryption;
00370 };
00371 
00372 CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> >;
00373 
00374 //! CTR mode
00375 template <class CIPHER>
00376 struct CTR_Mode : public CipherModeDocumentation
00377 {
00378     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > > Encryption;
00379     typedef Encryption Decryption;
00380 };
00381 
00382 //! CTR mode, external cipher
00383 struct CTR_Mode_ExternalCipher : public CipherModeDocumentation
00384 {
00385     typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > > Encryption;
00386     typedef Encryption Decryption;
00387 };
00388 
00389 //! ECB mode
00390 template <class CIPHER>
00391 struct ECB_Mode : public CipherModeDocumentation
00392 {
00393     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, ECB_OneWay> Encryption;
00394     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Decryption, ECB_OneWay> Decryption;
00395 };
00396 
00397 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ECB_OneWay>;
00398 
00399 //! ECB mode, external cipher
00400 struct ECB_Mode_ExternalCipher : public CipherModeDocumentation
00401 {
00402     typedef CipherModeFinalTemplate_ExternalCipher<ECB_OneWay> Encryption;
00403     typedef Encryption Decryption;
00404 };
00405 
00406 //! CBC mode
00407 template <class CIPHER>
00408 struct CBC_Mode : public CipherModeDocumentation
00409 {
00410     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, CBC_Encryption> Encryption;
00411     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Decryption, CBC_Decryption> Decryption;
00412 };
00413 
00414 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Encryption>;
00415 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Decryption>;
00416 
00417 //! CBC mode, external cipher
00418 struct CBC_Mode_ExternalCipher : public CipherModeDocumentation
00419 {
00420     typedef CipherModeFinalTemplate_ExternalCipher<CBC_Encryption> Encryption;
00421     typedef CipherModeFinalTemplate_ExternalCipher<CBC_Decryption> Decryption;
00422 };
00423 
00424 //! CBC mode with ciphertext stealing
00425 template <class CIPHER>
00426 struct CBC_CTS_Mode : public CipherModeDocumentation
00427 {
00428     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Encryption, CBC_CTS_Encryption> Encryption;
00429     typedef CipherModeFinalTemplate_CipherHolder<CPP_TYPENAME CIPHER::Decryption, CBC_CTS_Decryption> Decryption;
00430 };
00431 
00432 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Encryption>;
00433 CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Decryption>;
00434 
00435 //! CBC mode with ciphertext stealing, external cipher
00436 struct CBC_CTS_Mode_ExternalCipher : public CipherModeDocumentation
00437 {
00438     typedef CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Encryption> Encryption;
00439     typedef CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Decryption> Decryption;
00440 };
00441 
00442 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00443 typedef CFB_Mode_ExternalCipher::Encryption CFBEncryption;
00444 typedef CFB_Mode_ExternalCipher::Decryption CFBDecryption;
00445 typedef OFB_Mode_ExternalCipher::Encryption OFB;
00446 typedef CTR_Mode_ExternalCipher::Encryption CounterMode;
00447 #endif
00448 
00449 NAMESPACE_END
00450 
00451 #endif

Generated on Thu Jul 5 22:21:37 2007 for Crypto++ by  doxygen 1.5.2