CRYPTOPP 5.6.3 RC6 checkin

1 files changed, 414 insertions, 221 deletions

diff --git a/seckey.h b/seckey.h
index 35046a61..7457bc42 100644
--- a/seckey.h
+++ b/seckey.h
@@ -1,221 +1,414 @@
-// seckey.h - written and placed in the public domain by Wei Dai
-
-// This file contains helper classes/functions for implementing secret key algorithms.
-
-#ifndef CRYPTOPP_SECKEY_H
-#define CRYPTOPP_SECKEY_H
-
-#include "cryptlib.h"
-#include "misc.h"
-#include "simple.h"
-
-NAMESPACE_BEGIN(CryptoPP)
-
-inline CipherDir ReverseCipherDir(CipherDir dir)
-{
-	return (dir == ENCRYPTION) ? DECRYPTION : ENCRYPTION;
-}
-
-//! to be inherited by block ciphers with fixed block size
-template <unsigned int N>
-class FixedBlockSize
-{
-public:
-	CRYPTOPP_CONSTANT(BLOCKSIZE = N)
-};
-
-// ************** rounds ***************
-
-//! to be inherited by ciphers with fixed number of rounds
-template <unsigned int R>
-class FixedRounds
-{
-public:
-	CRYPTOPP_CONSTANT(ROUNDS = R)
-};
-
-//! to be inherited by ciphers with variable number of rounds
-template <unsigned int D, unsigned int N=1, unsigned int M=INT_MAX>		// use INT_MAX here because enums are treated as signed ints
-class VariableRounds
-{
-public:
-	CRYPTOPP_CONSTANT(DEFAULT_ROUNDS = D)
-	CRYPTOPP_CONSTANT(MIN_ROUNDS = N)
-	CRYPTOPP_CONSTANT(MAX_ROUNDS = M)
-	static unsigned int StaticGetDefaultRounds(size_t keylength) {return DEFAULT_ROUNDS;}
-
-protected:
-	inline void ThrowIfInvalidRounds(int rounds, const Algorithm *alg)
-	{
-		if (rounds < MIN_ROUNDS || rounds > MAX_ROUNDS)
-			throw InvalidRounds(alg->AlgorithmName(), rounds);
-	}
-
-	inline unsigned int GetRoundsAndThrowIfInvalid(const NameValuePairs &param, const Algorithm *alg)
-	{
-		int rounds = param.GetIntValueWithDefault("Rounds", DEFAULT_ROUNDS);
-		ThrowIfInvalidRounds(rounds, alg);
-		return (unsigned int)rounds;
-	}
-};
-
-// ************** key length ***************
-
-//! to be inherited by keyed algorithms with fixed key length
-template <unsigned int N, unsigned int IV_REQ = SimpleKeyingInterface::NOT_RESYNCHRONIZABLE, unsigned int IV_L = 0>
-class FixedKeyLength
-{
-public:
-	CRYPTOPP_CONSTANT(KEYLENGTH=N)
-	CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N)
-	CRYPTOPP_CONSTANT(MAX_KEYLENGTH=N)
-	CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=N)
-	CRYPTOPP_CONSTANT(IV_REQUIREMENT = IV_REQ)
-	CRYPTOPP_CONSTANT(IV_LENGTH = IV_L)
-	static size_t CRYPTOPP_API StaticGetValidKeyLength(size_t) {return KEYLENGTH;}
-};
-
-/// support query of variable key length, template parameters are default, min, max, multiple (default multiple 1)
-template <unsigned int D, unsigned int N, unsigned int M, unsigned int Q = 1, unsigned int IV_REQ = SimpleKeyingInterface::NOT_RESYNCHRONIZABLE, unsigned int IV_L = 0>
-class VariableKeyLength
-{
-	// make these private to avoid Doxygen documenting them in all derived classes
-	CRYPTOPP_COMPILE_ASSERT(Q > 0);
-	CRYPTOPP_COMPILE_ASSERT(N % Q == 0);
-	CRYPTOPP_COMPILE_ASSERT(M % Q == 0);
-	CRYPTOPP_COMPILE_ASSERT(N < M);
-	CRYPTOPP_COMPILE_ASSERT(D >= N);
-	CRYPTOPP_COMPILE_ASSERT(M >= D);
-
-public:
-	CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N)
-	CRYPTOPP_CONSTANT(MAX_KEYLENGTH=M)
-	CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=D)
-	CRYPTOPP_CONSTANT(KEYLENGTH_MULTIPLE=Q)
-	CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ)
-	CRYPTOPP_CONSTANT(IV_LENGTH=IV_L)
-
-	static size_t CRYPTOPP_API StaticGetValidKeyLength(size_t n)
-	{
-		if (n < (size_t)MIN_KEYLENGTH)
-			return MIN_KEYLENGTH;
-		else if (n > (size_t)MAX_KEYLENGTH)
-			return (size_t)MAX_KEYLENGTH;
-		else
-		{
-			n += KEYLENGTH_MULTIPLE-1;
-			return n - n%KEYLENGTH_MULTIPLE;
-		}
-	}
-};
-
-/// support query of key length that's the same as another class
-template <class T, unsigned int IV_REQ = SimpleKeyingInterface::NOT_RESYNCHRONIZABLE, unsigned int IV_L = 0>
-class SameKeyLengthAs
-{
-public:
-	CRYPTOPP_CONSTANT(MIN_KEYLENGTH=T::MIN_KEYLENGTH)
-	CRYPTOPP_CONSTANT(MAX_KEYLENGTH=T::MAX_KEYLENGTH)
-	CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=T::DEFAULT_KEYLENGTH)
-	CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ)
-	CRYPTOPP_CONSTANT(IV_LENGTH=IV_L)
-
-	static size_t CRYPTOPP_API StaticGetValidKeyLength(size_t keylength)
-		{return T::StaticGetValidKeyLength(keylength);}
-};
-
-// ************** implementation helper for SimpleKeyed ***************
-
-//! _
-template <class BASE, class INFO = BASE>
-class CRYPTOPP_NO_VTABLE SimpleKeyingInterfaceImpl : public BASE
-{
-public:
-	size_t MinKeyLength() const {return INFO::MIN_KEYLENGTH;}
-	size_t MaxKeyLength() const {return (size_t)INFO::MAX_KEYLENGTH;}
-	size_t DefaultKeyLength() const {return INFO::DEFAULT_KEYLENGTH;}
-	size_t GetValidKeyLength(size_t n) const {return INFO::StaticGetValidKeyLength(n);}
-	SimpleKeyingInterface::IV_Requirement IVRequirement() const {return (SimpleKeyingInterface::IV_Requirement)INFO::IV_REQUIREMENT;}
-	unsigned int IVSize() const {return INFO::IV_LENGTH;}
-};
-
-template <class INFO, class BASE = BlockCipher>
-class CRYPTOPP_NO_VTABLE BlockCipherImpl : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<BASE, INFO> > >
-{
-public:
-	unsigned int BlockSize() const {return this->BLOCKSIZE;}
-};
-
-//! _
-template <CipherDir DIR, class BASE>
-class BlockCipherFinal : public ClonableImpl<BlockCipherFinal<DIR, BASE>, BASE>
-{
-public:
- 	BlockCipherFinal() {}
-	BlockCipherFinal(const byte *key)
-		{this->SetKey(key, this->DEFAULT_KEYLENGTH);}
-	BlockCipherFinal(const byte *key, size_t length)
-		{this->SetKey(key, length);}
-	BlockCipherFinal(const byte *key, size_t length, unsigned int rounds)
-		{this->SetKeyWithRounds(key, length, rounds);}
-
-	bool IsForwardTransformation() const {return DIR == ENCRYPTION;}
-};
-
-//! _
-template <class BASE, class INFO = BASE>
-class MessageAuthenticationCodeImpl : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>
-{
-};
-
-//! _
-template <class BASE>
-class MessageAuthenticationCodeFinal : public ClonableImpl<MessageAuthenticationCodeFinal<BASE>, MessageAuthenticationCodeImpl<BASE> >
-{
-public:
- 	MessageAuthenticationCodeFinal() {}
-	MessageAuthenticationCodeFinal(const byte *key)
-		{this->SetKey(key, this->DEFAULT_KEYLENGTH);}
-	MessageAuthenticationCodeFinal(const byte *key, size_t length)
-		{this->SetKey(key, length);}
-};
-
-// ************** documentation ***************
-
-//! These objects usually should not be used directly. See CipherModeDocumentation instead.
-/*! Each class derived from this one defines two types, Encryption and Decryption, 
-	both of which implement the BlockCipher interface. */
-struct BlockCipherDocumentation
-{
-	//! implements the BlockCipher interface
-	typedef BlockCipher Encryption;
-	//! implements the BlockCipher interface
-	typedef BlockCipher Decryption;
-};
-
-/*! \brief Each class derived from this one defines two types, Encryption and Decryption, 
-	both of which implement the SymmetricCipher interface. Two types of classes derive
-	from this class: stream ciphers and block cipher modes. Stream ciphers can be used
-	alone, cipher mode classes need to be used with a block cipher. See CipherModeDocumentation
-	for more for information about using cipher modes and block ciphers. */
-struct SymmetricCipherDocumentation
-{
-	//! implements the SymmetricCipher interface
-	typedef SymmetricCipher Encryption;
-	//! implements the SymmetricCipher interface
-	typedef SymmetricCipher Decryption;
-};
-
-/*! \brief Each class derived from this one defines two types, Encryption and Decryption, 
-	both of which implement the AuthenticatedSymmetricCipher interface. */
-struct AuthenticatedSymmetricCipherDocumentation
-{
-	//! implements the AuthenticatedSymmetricCipher interface
-	typedef AuthenticatedSymmetricCipher Encryption;
-	//! implements the AuthenticatedSymmetricCipher interface
-	typedef AuthenticatedSymmetricCipher Decryption;
-};
-
-NAMESPACE_END
-
-#endif
+// seckey.h - written and placed in the public domain by Wei Dai

+

+//! \file

+//! \brief Contains helper classes and functions for implementing secret key algorithms.

+

+#ifndef CRYPTOPP_SECKEY_H

+#define CRYPTOPP_SECKEY_H

+

+#include "cryptlib.h"

+

+#if CRYPTOPP_MSC_VERSION

+# pragma warning(push)

+# pragma warning(disable: 4189)

+#endif

+

+#include "misc.h"

+#include "simple.h"

+

+NAMESPACE_BEGIN(CryptoPP)

+

+//! \brief Inverts the cipher's direction

+//! \param dir the cipher's direction

+//! \returns \p DECRYPTION if \p dir is ENCRYPTION, \p DECRYPTION otherwise

+inline CipherDir ReverseCipherDir(CipherDir dir)

+{

+	return (dir == ENCRYPTION) ? DECRYPTION : ENCRYPTION;

+}

+

+//! \class FixedBlockSize

+//! \brief Inherited by block ciphers with fixed block size

+//! \tparam N the blocksize of the cipher

+template <unsigned int N>

+class FixedBlockSize

+{

+public:

+	//! \brief The block size of the cipher provided as a constant.

+	CRYPTOPP_CONSTANT(BLOCKSIZE = N)

+};

+

+// ************** rounds ***************

+

+//! \class FixedRounds

+//! \brief Inherited by ciphers with fixed number of rounds

+//! \tparam R the number of rounds used by the cipher

+template <unsigned int R>

+class FixedRounds

+{

+public:

+	//! \brief The number of rounds for the cipher provided as a constant.

+	CRYPTOPP_CONSTANT(ROUNDS = R)

+};

+

+//! \class VariableRounds

+//! \brief Inherited by ciphers with variable number of rounds

+//! \tparam D Default number of rounds

+//! \tparam N Minimum number of rounds

+//! \tparam D Maximum number of rounds

+template <unsigned int D, unsigned int N=1, unsigned int M=INT_MAX>		// use INT_MAX here because enums are treated as signed ints

+class VariableRounds

+{

+public:

+	//! \brief The default number of rounds for the cipher provided as a constant.

+	CRYPTOPP_CONSTANT(DEFAULT_ROUNDS = D)

+	//! \brief The minimum number of rounds for the cipher provided as a constant.

+	CRYPTOPP_CONSTANT(MIN_ROUNDS = N)

+	//! \brief The maximum number of rounds for the cipher provided as a constant.

+	CRYPTOPP_CONSTANT(MAX_ROUNDS = M)

+	//! \brief The default number of rounds for the cipher based on key length 

+	//!   provided by a static function.

+	//! \param keylength the size of the key, in bytes

+	//! \details \p keylength is unused in the default implementation.

+	static unsigned int StaticGetDefaultRounds(size_t keylength)

+		{CRYPTOPP_UNUSED(keylength); return DEFAULT_ROUNDS;}

+

+protected:

+	//! \brief Validates the number of \p rounds for a cipher.

+	//! \param rounds the canddiate number of \p rounds

+	//! \param alg an \p Algorithm object used if the number of \p rounds are invalid

+	//! \throws InvalidRounds if the number of \p rounds are invalid

+	inline void ThrowIfInvalidRounds(int rounds, const Algorithm *alg)

+	{

+		if (rounds < MIN_ROUNDS || rounds > MAX_ROUNDS)

+			throw InvalidRounds(alg ? alg->AlgorithmName() : "VariableRounds", rounds);

+	}

+

+	//! \brief Validates the number of \p rounds for a cipher

+	//! \param param the canddiate number of \p rounds

+	//! \param alg an \p Algorithm object used if the number of \p rounds are invalid

+	//! \returns the number of rounds for the cipher

+	//! \throws InvalidRounds if the number of \p rounds are invalid

+	inline unsigned int GetRoundsAndThrowIfInvalid(const NameValuePairs &param, const Algorithm *alg)

+	{

+		int rounds = param.GetIntValueWithDefault("Rounds", DEFAULT_ROUNDS);

+		ThrowIfInvalidRounds(rounds, alg);

+		return (unsigned int)rounds;

+	}

+};

+

+// ************** key length ***************

+

+//! \class FixedKeyLength

+//! \brief Inherited by keyed algorithms with fixed key length

+//! \tparam N Default key length, in bytes

+//! \tparam IV_REQ The IV requirements. See \p IV_Requirement in cryptlib.h for allowed values

+//! \tparam IV_L Default IV length, in bytes

+template <unsigned int N, unsigned int IV_REQ = SimpleKeyingInterface::NOT_RESYNCHRONIZABLE, unsigned int IV_L = 0>

+class FixedKeyLength

+{

+public:

+	//! \brief The default key length used by the cipher provided as a constant

+	//! \details \p KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(KEYLENGTH=N)

+	//! \brief The minimum key length used by the cipher provided as a constant

+	//! \details \p MIN_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N)

+	//! \brief The maximum key length used by the cipher provided as a constant

+	//! \details \p MAX_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(MAX_KEYLENGTH=N)

+	//! \brief The default key length used by the cipher provided as a constant

+	//! \details \p DEFAULT_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=N)

+	//! \brief The default IV requirements for the cipher provided as a constant

+	//! \details The default value is \p NOT_RESYNCHRONIZABLE. See \p IV_Requirement

+	//!  in cryptlib.h for allowed values.

+	CRYPTOPP_CONSTANT(IV_REQUIREMENT = IV_REQ)

+	//! \brief The default IV length used by the cipher provided as a constant

+	//! \details \p IV_LENGTH is provided in bytes, not bits. The default implementation uses \p 0.

+	CRYPTOPP_CONSTANT(IV_LENGTH = IV_L)

+	//! \brief The default key length for the cipher provided by a static function.

+	//! \param keylength the size of the key, in bytes

+	//! \details The default implementation returns \p KEYLENGTH. \p keylength is unused

+	//!   in the default implementation.

+	static size_t CRYPTOPP_API StaticGetValidKeyLength(size_t keylength)

+		{CRYPTOPP_UNUSED(keylength); return KEYLENGTH;}

+};

+

+//! \class VariableKeyLength

+//! \brief Inherited by keyed algorithms with variable key length

+//! \tparam D Default key length, in bytes

+//! \tparam N Minimum key length, in bytes

+//! \tparam M Maximum key length, in bytes

+//! \tparam M Default key length multiple, in bytes. The default multiple is 1.

+//! \tparam IV_REQ The IV requirements. See \p IV_Requirement in cryptlib.h for allowed values

+//! \tparam IV_L Default IV length, in bytes. The default length is 0.

+template <unsigned int D, unsigned int N, unsigned int M, unsigned int Q = 1, unsigned int IV_REQ = SimpleKeyingInterface::NOT_RESYNCHRONIZABLE, unsigned int IV_L = 0>

+class VariableKeyLength

+{

+	// Make these private to avoid Doxygen documenting them in all derived classes

+	CRYPTOPP_COMPILE_ASSERT(Q > 0);

+	CRYPTOPP_COMPILE_ASSERT(N % Q == 0);

+	CRYPTOPP_COMPILE_ASSERT(M % Q == 0);

+	CRYPTOPP_COMPILE_ASSERT(N < M);

+	CRYPTOPP_COMPILE_ASSERT(D >= N);

+	CRYPTOPP_COMPILE_ASSERT(M >= D);

+

+public:

+	//! \brief The minimum key length used by the cipher provided as a constant

+	//! \details \p MIN_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N)

+	//! \brief The maximum key length used by the cipher provided as a constant

+	//! \details \p MAX_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(MAX_KEYLENGTH=M)

+	//! \brief The default key length used by the cipher provided as a constant

+	//! \details \p DEFAULT_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=D)

+	//! \brief The key length multiple used by the cipher provided as a constant

+	//! \details \p MAX_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(KEYLENGTH_MULTIPLE=Q)

+	//! \brief The default IV requirements for the cipher provided as a constant

+	//! \details The default value is \p NOT_RESYNCHRONIZABLE. See \p IV_Requirement

+	//!  in cryptlib.h for allowed values.

+	CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ)

+	//! \brief The default initialization vector length for the cipher provided as a constant

+	//! \details \p IV_LENGTH is provided in bytes, not bits. The default implementation uses \p 0.

+	CRYPTOPP_CONSTANT(IV_LENGTH=IV_L)

+	//! \brief Provides a valid key length for the cipher provided by a static function.

+	//! \param keylength the size of the key, in bytes

+	//! \details If \p keylength is less than \p MIN_KEYLENGTH, then the function returns

+	//!   \p MIN_KEYLENGTH. If \p keylength is greater than \p MAX_KEYLENGTH, then the function

+	//!   returns \p MAX_KEYLENGTH. If \p keylength is a multiple of \p KEYLENGTH_MULTIPLE,

+	//!   then \p keylength is returned. Otherwise, the function returns \p keylength rounded

+	//!   \a down to the next smaller multiple of \p KEYLENGTH_MULTIPLE.

+	//! \details \p keylength is provided in bytes, not bits.

+	static size_t CRYPTOPP_API StaticGetValidKeyLength(size_t keylength)

+	{

+		if (keylength < (size_t)MIN_KEYLENGTH)

+			return MIN_KEYLENGTH;

+		else if (keylength > (size_t)MAX_KEYLENGTH)

+			return (size_t)MAX_KEYLENGTH;

+		else

+		{

+			keylength += KEYLENGTH_MULTIPLE-1;

+			return keylength - keylength%KEYLENGTH_MULTIPLE;

+		}

+	}

+};

+

+//! \class SameKeyLengthAs

+//! \brief Provides key lengths based on another class's key length

+//! \tparam T another \p FixedKeyLength or \p VariableKeyLength class

+//! \tparam IV_REQ The IV requirements. See \p IV_Requirement in cryptlib.h for allowed values

+//! \tparam IV_L Default IV length, in bytes

+template <class T, unsigned int IV_REQ = SimpleKeyingInterface::NOT_RESYNCHRONIZABLE, unsigned int IV_L = 0>

+class SameKeyLengthAs

+{

+public:

+	//! \brief The minimum key length used by the cipher provided as a constant

+	//! \details \p MIN_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(MIN_KEYLENGTH=T::MIN_KEYLENGTH)

+	//! \brief The maximum key length used by the cipher provided as a constant

+	//! \details \p MIN_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(MAX_KEYLENGTH=T::MAX_KEYLENGTH)

+	//! \brief The default key length used by the cipher provided as a constant

+	//! \details \p MIN_KEYLENGTH is provided in bytes, not bits

+	CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=T::DEFAULT_KEYLENGTH)

+	//! \brief The default IV requirements for the cipher provided as a constant

+	//! \details The default value is \p NOT_RESYNCHRONIZABLE. See \p IV_Requirement

+	//!  in cryptlib.h for allowed values.

+	CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ)

+	//! \brief The default initialization vector length for the cipher provided as a constant

+	//! \details \p IV_LENGTH is provided in bytes, not bits. The default implementation uses \p 0.

+	CRYPTOPP_CONSTANT(IV_LENGTH=IV_L)

+	//! \brief Provides a valid key length for the cipher provided by a static function.

+	//! \param keylength the size of the key, in bytes

+	//! \details If \p keylength is less than \p MIN_KEYLENGTH, then the function returns

+	//!   \p MIN_KEYLENGTH. If \p keylength is greater than \p MAX_KEYLENGTH, then the function

+	//!   returns \p MAX_KEYLENGTH. If \p keylength is a multiple of \p KEYLENGTH_MULTIPLE,

+	//!   then \p keylength is returned. Otherwise, the function returns \p keylength rounded

+	//!   \a down to the next smaller multiple of \p KEYLENGTH_MULTIPLE.

+	//! \details \p keylength is provided in bytes, not bits.

+	static size_t CRYPTOPP_API StaticGetValidKeyLength(size_t keylength)

+		{return T::StaticGetValidKeyLength(keylength);}

+};

+

+// ************** implementation helper for SimpleKeyed ***************

+

+//! \class SimpleKeyingInterfaceImpl

+//! \brief Provides class member functions to access SimpleKeyingInterface constants

+//! \tparam BASE a SimpleKeyingInterface derived class

+//! \tparam INFO a SimpleKeyingInterface derived class

+template <class BASE, class INFO = BASE>

+class CRYPTOPP_NO_VTABLE SimpleKeyingInterfaceImpl : public BASE

+{

+public:

+	//! \brief The minimum key length used by the cipher

+	size_t MinKeyLength() const

+		{return INFO::MIN_KEYLENGTH;}

+

+	//! \brief The maximum key length used by the cipher

+	size_t MaxKeyLength() const

+		{return (size_t)INFO::MAX_KEYLENGTH;}

+	

+	//! \brief The default key length used by the cipher

+	size_t DefaultKeyLength() const

+		{return INFO::DEFAULT_KEYLENGTH;}

+	

+	//! \brief Provides a valid key length for the cipher

+	//! \param keylength the size of the key, in bytes

+	//! \details \p keylength is provided in bytes, not bits. If \p keylength is less than \p MIN_KEYLENGTH,

+	//!   then the function returns \p MIN_KEYLENGTH. If \p keylength is greater than \p MAX_KEYLENGTH,

+	//!   then the function returns \p MAX_KEYLENGTH. if If \p keylength is a multiple of \p KEYLENGTH_MULTIPLE,

+	//!   then \p keylength is returned. Otherwise, the function returns a \a lower multiple of

+	//!   \p KEYLENGTH_MULTIPLE.

+	size_t GetValidKeyLength(size_t keylength) const {return INFO::StaticGetValidKeyLength(keylength);}

+

+	//! \brief The default IV requirements for the cipher

+	//! \details The default value is \p NOT_RESYNCHRONIZABLE. See \p IV_Requirement

+	//!  in cryptlib.h for allowed values.

+	SimpleKeyingInterface::IV_Requirement IVRequirement() const

+		{return (SimpleKeyingInterface::IV_Requirement)INFO::IV_REQUIREMENT;}

+	

+	//! \brief The default initialization vector length for the cipher

+	//! \details \p IVSize is provided in bytes, not bits. The default implementation uses \p IV_LENGTH, which is 0.

+	unsigned int IVSize() const

+		{return INFO::IV_LENGTH;}

+};

+

+//! \class BlockCipherImpl

+//! \brief Provides class member functions to access BlockCipher constants

+//! \tparam INFO a SimpleKeyingInterface derived class

+//! \tparam BASE a SimpleKeyingInterface derived class

+template <class INFO, class BASE = BlockCipher>

+class CRYPTOPP_NO_VTABLE BlockCipherImpl : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<BASE, INFO> > >

+{

+public:

+	//! \brief The block size of the cipher

+	unsigned int BlockSize() const {return this->BLOCKSIZE;}

+};

+

+//! \class BlockCipherFinal

+//! \brief Provides class member functions to key a block cipher

+//! \tparam DIR a CipherDir

+//! \tparam BASE a BlockCipherImpl derived class

+template <CipherDir DIR, class BASE>

+class BlockCipherFinal : public ClonableImpl<BlockCipherFinal<DIR, BASE>, BASE>

+{

+public:

+	//! \brief Construct a default BlockCipherFinal

+	//! \details The cipher is not keyed.

+ 	BlockCipherFinal() {}

+	//! \brief Construct a BlockCipherFinal

+	//! \param key a byte array used to key the cipher

+	//! \details \p key must be at least \p DEFAULT_KEYLENGTH in length. Internally, the function calls

+	//!    \p SimpleKeyingInterface::SetKey.

+	BlockCipherFinal(const byte *key)

+		{this->SetKey(key, this->DEFAULT_KEYLENGTH);}

+	//! \brief Construct a BlockCipherFinal

+	//! \param key a byte array used to key the cipher

+	//! \param length the length of the byte array

+	//! \details \p key must be at least \p DEFAULT_KEYLENGTH in length. Internally, the function calls

+	//!    \p SimpleKeyingInterface::SetKey.

+	BlockCipherFinal(const byte *key, size_t length)

+		{this->SetKey(key, length);}

+	//! \brief Construct a BlockCipherFinal

+	//! \param key a byte array used to key the cipher

+	//! \param length the length of the byte array

+	//! \param rounds the number of rounds

+	//! \details \p key must be at least \p DEFAULT_KEYLENGTH in length. Internally, the function calls

+	//!    \p SimpleKeyingInterface::SetKeyWithRounds.

+	BlockCipherFinal(const byte *key, size_t length, unsigned int rounds)

+		{this->SetKeyWithRounds(key, length, rounds);}

+

+	//! \brief Provides the direction of the cipher

+	//! \returns \p true if \p DIR is \p ENCRYPTION, \p false otherwise

+	bool IsForwardTransformation() const {return DIR == ENCRYPTION;}

+};

+

+//! \class MessageAuthenticationCodeImpl

+//! \brief Provides class member functions to access MessageAuthenticationCode constants

+//! \tparam INFO a SimpleKeyingInterface derived class

+//! \tparam BASE a SimpleKeyingInterface derived class

+template <class BASE, class INFO = BASE>

+class MessageAuthenticationCodeImpl : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>

+{

+};

+

+//! \class MessageAuthenticationCodeFinal

+//! \brief Provides class member functions to key a message authentication code

+//! \tparam DIR a CipherDir

+//! \tparam BASE a BlockCipherImpl derived class

+template <class BASE>

+class MessageAuthenticationCodeFinal : public ClonableImpl<MessageAuthenticationCodeFinal<BASE>, MessageAuthenticationCodeImpl<BASE> >

+{

+public:

+	//! \brief Construct a default MessageAuthenticationCodeFinal

+	//! \details The message authentication code is not keyed.

+ 	MessageAuthenticationCodeFinal() {}

+	//! \brief Construct a BlockCipherFinal

+	//! \param key a byte array used to key the cipher

+	//! \details \p key must be at least \p DEFAULT_KEYLENGTH in length. Internally, the function calls

+	//!    \p SimpleKeyingInterface::SetKey.

+	MessageAuthenticationCodeFinal(const byte *key)

+		{this->SetKey(key, this->DEFAULT_KEYLENGTH);}

+	//! \brief Construct a BlockCipherFinal

+	//! \param key a byte array used to key the cipher

+	//! \param length the length of the byte array

+	//! \details \p key must be at least \p DEFAULT_KEYLENGTH in length. Internally, the function calls

+	//!    \p SimpleKeyingInterface::SetKey.

+	MessageAuthenticationCodeFinal(const byte *key, size_t length)

+		{this->SetKey(key, length);}

+};

+

+// ************** documentation ***************

+

+//! \class BlockCipherDocumentation

+//! \brief Provides \p Encryption and \p Decryption typedefs used by derived classes to

+//!    implement a block cipher

+//! \details These objects usually should not be used directly. See CipherModeDocumentation

+//!    instead. Each class derived from this one defines two types, Encryption and Decryption, 

+//!    both of which implement the BlockCipher interface.

+struct BlockCipherDocumentation

+{

+	//! implements the BlockCipher interface

+	typedef BlockCipher Encryption;

+	//! implements the BlockCipher interface

+	typedef BlockCipher Decryption;

+};

+

+//! \class SymmetricCipherDocumentation

+//! \brief Provides \p Encryption and \p Decryption typedefs used by derived classes to

+//!    implement a symmetric cipher

+//! \details Each class derived from this one defines two types, Encryption and Decryption, 

+//!    both of which implement the SymmetricCipher interface. Two types of classes derive

+//!    from this class: stream ciphers and block cipher modes. Stream ciphers can be used

+//!    alone, cipher mode classes need to be used with a block cipher. See CipherModeDocumentation

+//!    for more for information about using cipher modes and block ciphers.

+struct SymmetricCipherDocumentation

+{

+	//! implements the SymmetricCipher interface

+	typedef SymmetricCipher Encryption;

+	//! implements the SymmetricCipher interface

+	typedef SymmetricCipher Decryption;

+};

+

+//! \class AuthenticatedSymmetricCipherDocumentation

+//! \brief Provides \p Encryption and \p Decryption typedefs used by derived classes to

+//!    implement an authenticated encryption cipher

+//! \details Each class derived from this one defines two types, Encryption and Decryption, 

+//!    both of which implement the AuthenticatedSymmetricCipher interface.

+struct AuthenticatedSymmetricCipherDocumentation

+{

+	//! implements the AuthenticatedSymmetricCipher interface

+	typedef AuthenticatedSymmetricCipher Encryption;

+	//! implements the AuthenticatedSymmetricCipher interface

+	typedef AuthenticatedSymmetricCipher Decryption;

+};

+

+NAMESPACE_END

+	

+#if CRYPTOPP_MSC_VERSION

+# pragma warning(pop)

+#endif

+

+#endif