cryptlib.h

Go to the documentation of this file.

// cryptlib.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_CRYPTLIB_H
#define CRYPTOPP_CRYPTLIB_H
 
#include "config.h"
#include "stdcpp.h"
#include "trap.h"
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4127 4189 4505 4702)
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
// forward declarations
class Integer;
class RandomNumberGenerator;
class BufferedTransformation;
 
enum CipherDir {
        ENCRYPTION,
        DECRYPTION};
 
const unsigned long INFINITE_TIME = ULONG_MAX;
 
// VC60 workaround: using enums as template parameters causes problems
template <typename ENUM_TYPE, int VALUE>
struct EnumToType
{
        static ENUM_TYPE ToEnum() {return static_cast<ENUM_TYPE>(VALUE);}
};
 
enum ByteOrder {
        LITTLE_ENDIAN_ORDER = 0,
        BIG_ENDIAN_ORDER = 1};
 
typedef EnumToType<ByteOrder, LITTLE_ENDIAN_ORDER> LittleEndian;
typedef EnumToType<ByteOrder, BIG_ENDIAN_ORDER> BigEndian;
 
class CRYPTOPP_DLL Exception : public std::exception
{
public:
        enum ErrorType {
                NOT_IMPLEMENTED,
                INVALID_ARGUMENT,
                CANNOT_FLUSH,
                DATA_INTEGRITY_CHECK_FAILED,
                INVALID_DATA_FORMAT,
                IO_ERROR,
                OTHER_ERROR
        };
 
        virtual ~Exception() throw() {}
 
        explicit Exception(ErrorType errorType, const std::string &s) : m_errorType(errorType), m_what(s) {}
 
        const char *what() const throw() {return (m_what.c_str());}
        const std::string &GetWhat() const {return m_what;}
        void SetWhat(const std::string &s) {m_what = s;}
        ErrorType GetErrorType() const {return m_errorType;}
        void SetErrorType(ErrorType errorType) {m_errorType = errorType;}
 
private:
        ErrorType m_errorType;
        std::string m_what;
};
 
class CRYPTOPP_DLL InvalidArgument : public Exception
{
public:
        explicit InvalidArgument(const std::string &s) : Exception(INVALID_ARGUMENT, s) {}
};
 
class CRYPTOPP_DLL InvalidDataFormat : public Exception
{
public:
        explicit InvalidDataFormat(const std::string &s) : Exception(INVALID_DATA_FORMAT, s) {}
};
 
class CRYPTOPP_DLL InvalidCiphertext : public InvalidDataFormat
{
public:
        explicit InvalidCiphertext(const std::string &s) : InvalidDataFormat(s) {}
};
 
class CRYPTOPP_DLL NotImplemented : public Exception
{
public:
        explicit NotImplemented(const std::string &s) : Exception(NOT_IMPLEMENTED, s) {}
};
 
class CRYPTOPP_DLL CannotFlush : public Exception
{
public:
        explicit CannotFlush(const std::string &s) : Exception(CANNOT_FLUSH, s) {}
};
 
class CRYPTOPP_DLL OS_Error : public Exception
{
public:
        virtual ~OS_Error() throw() {}
 
        OS_Error(ErrorType errorType, const std::string &s, const std::string& operation, int errorCode)
                : Exception(errorType, s), m_operation(operation), m_errorCode(errorCode) {}
 
        const std::string & GetOperation() const {return m_operation;}
        int GetErrorCode() const {return m_errorCode;}
 
protected:
        std::string m_operation;
        int m_errorCode;
};
 
struct CRYPTOPP_DLL DecodingResult
{
        explicit DecodingResult() : isValidCoding(false), messageLength(0) {}
        explicit DecodingResult(size_t len) : isValidCoding(true), messageLength(len) {}
 
        bool operator==(const DecodingResult &rhs) const {return isValidCoding == rhs.isValidCoding && messageLength == rhs.messageLength;}
        bool operator!=(const DecodingResult &rhs) const {return !operator==(rhs);}
 
        bool isValidCoding;
        size_t messageLength;
};
 
class NameValuePairs
{
public:
        virtual ~NameValuePairs() {}
 
        class CRYPTOPP_DLL ValueTypeMismatch : public InvalidArgument
        {
        public:
                ValueTypeMismatch(const std::string &name, const std::type_info &stored, const std::type_info &retrieving)
                        : InvalidArgument("NameValuePairs: type mismatch for '" + name + "', stored '" + stored.name() + "', trying to retrieve '" + retrieving.name() + "'")
                        , m_stored(stored), m_retrieving(retrieving) {}
 
                const std::type_info & GetStoredTypeInfo() const {return m_stored;}
 
                const std::type_info & GetRetrievingTypeInfo() const {return m_retrieving;}
 
        private:
                const std::type_info &m_stored;
                const std::type_info &m_retrieving;
        };
 
        template <class T>
        bool GetThisObject(T &object) const
        {
                return GetValue((std::string("ThisObject:")+typeid(T).name()).c_str(), object);
        }
 
        template <class T>
        bool GetThisPointer(T *&ptr) const
        {
                return GetValue((std::string("ThisPointer:")+typeid(T).name()).c_str(), ptr);
        }
 
        template <class T>
        bool GetValue(const char *name, T &value) const
        {
                return GetVoidValue(name, typeid(T), &value);
        }
 
        template <class T>
        T GetValueWithDefault(const char *name, T defaultValue) const
        {
                T value;
                bool result = GetValue(name, value);
                // No assert... this recovers from failure
                if (result) {return value;}
                return defaultValue;
        }
 
        CRYPTOPP_DLL std::string GetValueNames() const
                {std::string result; GetValue("ValueNames", result); return result;}
 
        CRYPTOPP_DLL bool GetIntValue(const char *name, int &value) const
                {return GetValue(name, value);}
 
        CRYPTOPP_DLL int GetIntValueWithDefault(const char *name, int defaultValue) const
                {return GetValueWithDefault(name, defaultValue);}
 
        CRYPTOPP_DLL bool GetWord64Value(const char *name, word64 &value) const
                {return GetValue(name, value);}
 
        CRYPTOPP_DLL word64 GetWord64ValueWithDefault(const char *name, word64 defaultValue) const
                {return GetValueWithDefault(name, defaultValue);}
 
        CRYPTOPP_DLL static void CRYPTOPP_API ThrowIfTypeMismatch(const char *name, const std::type_info &stored, const std::type_info &retrieving)
                {if (stored != retrieving) throw ValueTypeMismatch(name, stored, retrieving);}
 
        template <class T>
        void GetRequiredParameter(const char *className, const char *name, T &value) const
        {
                if (!GetValue(name, value))
                        throw InvalidArgument(std::string(className) + ": missing required parameter '" + name + "'");
        }
 
        CRYPTOPP_DLL void GetRequiredIntParameter(const char *className, const char *name, int &value) const
        {
                if (!GetIntValue(name, value))
                        throw InvalidArgument(std::string(className) + ": missing required parameter '" + name + "'");
        }
 
        CRYPTOPP_DLL virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0;
};
 
// Doxygen cannot handle initialization
#if CRYPTOPP_DOXYGEN_PROCESSING
const std::string DEFAULT_CHANNEL;
 
const std::string AAD_CHANNEL;
 
const NameValuePairs& g_nullNameValuePairs;
 
#else
extern CRYPTOPP_DLL const std::string DEFAULT_CHANNEL;
extern CRYPTOPP_DLL const std::string AAD_CHANNEL;
extern CRYPTOPP_DLL const NameValuePairs& g_nullNameValuePairs;
#endif
 
// Document additional name spaces which show up elsewhere in the sources.
#if CRYPTOPP_DOXYGEN_PROCESSING
DOCUMENTED_NAMESPACE_BEGIN(Name)
// more names defined in argnames.h
DOCUMENTED_NAMESPACE_END
 
DOCUMENTED_NAMESPACE_BEGIN(Weak)
// weak and wounded algorithms
DOCUMENTED_NAMESPACE_END
#endif
 
DOCUMENTED_NAMESPACE_BEGIN(NaCl)
// crypto_box, crypto_box_open, crypto_sign, and crypto_sign_open (and friends)
DOCUMENTED_NAMESPACE_END
 
DOCUMENTED_NAMESPACE_BEGIN(Test)
// testing and benchmark classes
DOCUMENTED_NAMESPACE_END
 
// ********************************************************
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Clonable
{
public:
        virtual ~Clonable() {}
 
        virtual Clonable* Clone() const {throw NotImplemented("Clone() is not implemented yet.");}      // TODO: make this =0
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Algorithm : public Clonable
{
public:
        virtual ~Algorithm() {}
 
        Algorithm(bool checkSelfTestStatus = true);
 
        virtual std::string AlgorithmName() const {return "unknown";}
 
        virtual std::string AlgorithmProvider() const {return "C++";}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyingInterface
{
public:
        virtual ~SimpleKeyingInterface() {}
 
        virtual size_t MinKeyLength() const =0;
 
        virtual size_t MaxKeyLength() const =0;
 
        virtual size_t DefaultKeyLength() const =0;
 
        virtual size_t GetValidKeyLength(size_t keylength) const =0;
 
        virtual bool IsValidKeyLength(size_t keylength) const
                {return keylength == GetValidKeyLength(keylength);}
 
        virtual void SetKey(const byte *key, size_t length, const NameValuePairs &params = g_nullNameValuePairs);
 
        void SetKeyWithRounds(const byte *key, size_t length, int rounds);
 
        void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength);
 
        void SetKeyWithIV(const byte *key, size_t length, const byte *iv)
                {SetKeyWithIV(key, length, iv, IVSize());}
 
        enum IV_Requirement {
                UNIQUE_IV = 0,
                RANDOM_IV,
                UNPREDICTABLE_RANDOM_IV,
                INTERNALLY_GENERATED_IV,
                NOT_RESYNCHRONIZABLE
        };
 
        virtual IV_Requirement IVRequirement() const =0;
 
        bool IsResynchronizable() const {return IVRequirement() < NOT_RESYNCHRONIZABLE;}
 
        bool CanUseRandomIVs() const {return IVRequirement() <= UNPREDICTABLE_RANDOM_IV;}
 
        bool CanUsePredictableIVs() const {return IVRequirement() <= RANDOM_IV;}
 
        bool CanUseStructuredIVs() const {return IVRequirement() <= UNIQUE_IV;}
 
        virtual unsigned int IVSize() const
                {throw NotImplemented(GetAlgorithm().AlgorithmName() + ": this object doesn't support resynchronization");}
 
        unsigned int DefaultIVLength() const {return IVSize();}
 
        virtual unsigned int MinIVLength() const {return IVSize();}
 
        virtual unsigned int MaxIVLength() const {return IVSize();}
 
        virtual void Resynchronize(const byte *iv, int ivLength=-1) {
                CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(ivLength);
                throw NotImplemented(GetAlgorithm().AlgorithmName() + ": this object doesn't support resynchronization");
        }
 
        virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv);
 
protected:
        virtual const Algorithm & GetAlgorithm() const =0;
 
        virtual void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params) =0;
 
        void ThrowIfInvalidKeyLength(size_t length);
 
        void ThrowIfResynchronizable();
 
        void ThrowIfInvalidIV(const byte *iv);
 
        size_t ThrowIfInvalidIVLength(int length);
 
        const byte * GetIVAndThrowIfInvalid(const NameValuePairs &params, size_t &size);
 
        inline void AssertValidKeyLength(size_t length) const
                {CRYPTOPP_UNUSED(length); CRYPTOPP_ASSERT(IsValidKeyLength(length));}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockTransformation : public Algorithm
{
public:
        virtual ~BlockTransformation() {}
 
        virtual void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const =0;
 
        void ProcessBlock(const byte *inBlock, byte *outBlock) const
                {ProcessAndXorBlock(inBlock, NULLPTR, outBlock);}
 
        void ProcessBlock(byte *inoutBlock) const
                {ProcessAndXorBlock(inoutBlock, NULLPTR, inoutBlock);}
 
        virtual unsigned int BlockSize() const =0;
 
        virtual unsigned int OptimalDataAlignment() const;
 
        virtual bool IsPermutation() const {return true;}
 
        virtual bool IsForwardTransformation() const =0;
 
        virtual unsigned int OptimalNumberOfParallelBlocks() const {return 1;}
 
        enum FlagsForAdvancedProcessBlocks {
                BT_InBlockIsCounter=1,
                BT_DontIncrementInOutPointers=2,
                BT_XorInput=4,
                BT_ReverseDirection=8,
                BT_AllowParallel=16};
 
        virtual size_t AdvancedProcessBlocks(const byte *inBlocks, const byte *xorBlocks, byte *outBlocks, size_t length, word32 flags) const;
 
        inline CipherDir GetCipherDirection() const {return IsForwardTransformation() ? ENCRYPTION : DECRYPTION;}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE StreamTransformation : public Algorithm
{
public:
        virtual ~StreamTransformation() {}
 
        StreamTransformation& Ref() {return *this;}
 
        virtual unsigned int MandatoryBlockSize() const {return 1;}
 
        virtual unsigned int OptimalBlockSize() const {return MandatoryBlockSize();}
 
        virtual unsigned int GetOptimalBlockSizeUsed() const {return 0;}
 
        virtual unsigned int OptimalDataAlignment() const;
 
        virtual void ProcessData(byte *outString, const byte *inString, size_t length) =0;
 
        virtual size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength);
 
        virtual unsigned int MinLastBlockSize() const {return 0;}
 
        virtual bool IsLastBlockSpecial() const {return false;}
 
        inline void ProcessString(byte *inoutString, size_t length)
                {ProcessData(inoutString, inoutString, length);}
 
        inline void ProcessString(byte *outString, const byte *inString, size_t length)
                {ProcessData(outString, inString, length);}
 
        inline byte ProcessByte(byte input)
                {ProcessData(&input, &input, 1); return input;}
 
        virtual bool IsRandomAccess() const =0;
 
        virtual void Seek(lword pos)
        {
                CRYPTOPP_UNUSED(pos);
                CRYPTOPP_ASSERT(!IsRandomAccess());
                throw NotImplemented("StreamTransformation: this object doesn't support random access");
        }
 
        virtual bool IsSelfInverting() const =0;
 
        virtual bool IsForwardTransformation() const =0;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE HashTransformation : public Algorithm
{
public:
        virtual ~HashTransformation() {}
 
        HashTransformation& Ref() {return *this;}
 
        virtual void Update(const byte *input, size_t length) =0;
 
        virtual byte * CreateUpdateSpace(size_t &size) {size=0; return NULLPTR;}
 
        virtual void Final(byte *digest)
                {TruncatedFinal(digest, DigestSize());}
 
        virtual void Restart()
                {TruncatedFinal(NULLPTR, 0);}
 
        virtual unsigned int DigestSize() const =0;
 
        unsigned int TagSize() const {return DigestSize();}
 
        virtual unsigned int BlockSize() const {return 0;}
 
        virtual unsigned int OptimalBlockSize() const {return 1;}
 
        virtual unsigned int OptimalDataAlignment() const;
 
        virtual void CalculateDigest(byte *digest, const byte *input, size_t length)
                {Update(input, length); Final(digest);}
 
        virtual bool Verify(const byte *digest)
                {return TruncatedVerify(digest, DigestSize());}
 
        virtual bool VerifyDigest(const byte *digest, const byte *input, size_t length)
                {Update(input, length); return Verify(digest);}
 
        virtual void TruncatedFinal(byte *digest, size_t digestSize) =0;
 
        virtual void CalculateTruncatedDigest(byte *digest, size_t digestSize, const byte *input, size_t length)
                {Update(input, length); TruncatedFinal(digest, digestSize);}
 
        virtual bool TruncatedVerify(const byte *digest, size_t digestLength);
 
        virtual bool VerifyTruncatedDigest(const byte *digest, size_t digestLength, const byte *input, size_t length)
                {Update(input, length); return TruncatedVerify(digest, digestLength);}
 
protected:
        void ThrowIfInvalidTruncatedSize(size_t size) const;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockCipher : public SimpleKeyingInterface, public BlockTransformation
{
protected:
        const Algorithm & GetAlgorithm() const {return *this;}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SymmetricCipher : public SimpleKeyingInterface, public StreamTransformation
{
protected:
        const Algorithm & GetAlgorithm() const {return *this;}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE MessageAuthenticationCode : public SimpleKeyingInterface, public HashTransformation
{
protected:
        const Algorithm & GetAlgorithm() const {return *this;}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AuthenticatedSymmetricCipher : public MessageAuthenticationCode, public StreamTransformation
{
public:
        virtual ~AuthenticatedSymmetricCipher() {}
 
        class BadState : public Exception
        {
        public:
                explicit BadState(const std::string &name, const char *message) : Exception(OTHER_ERROR, name + ": " + message) {}
                explicit BadState(const std::string &name, const char *function, const char *state) : Exception(OTHER_ERROR, name + ": " + function + " was called before " + state) {}
        };
 
        virtual lword MaxHeaderLength() const =0;
 
        virtual lword MaxMessageLength() const =0;
 
        virtual lword MaxFooterLength() const {return 0;}
 
        virtual bool NeedsPrespecifiedDataLengths() const {return false;}
 
        void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0);
 
        virtual void EncryptAndAuthenticate(byte *ciphertext, byte *mac, size_t macSize, const byte *iv, int ivLength, const byte *header, size_t headerLength, const byte *message, size_t messageLength);
 
        virtual bool DecryptAndVerify(byte *message, const byte *mac, size_t macSize, const byte *iv, int ivLength, const byte *header, size_t headerLength, const byte *ciphertext, size_t ciphertextLength);
 
        virtual std::string AlgorithmName() const;
 
        virtual std::string AlgorithmProvider() const {return "C++";}
 
protected:
        const Algorithm & GetAlgorithm() const
                {return *static_cast<const MessageAuthenticationCode *>(this);}
        virtual void UncheckedSpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength)
                {CRYPTOPP_UNUSED(headerLength); CRYPTOPP_UNUSED(messageLength); CRYPTOPP_UNUSED(footerLength);}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomNumberGenerator : public Algorithm
{
public:
        virtual ~RandomNumberGenerator() {}
 
        virtual void IncorporateEntropy(const byte *input, size_t length)
        {
                CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);
                throw NotImplemented("RandomNumberGenerator: IncorporateEntropy not implemented");
        }
 
        virtual bool CanIncorporateEntropy() const {return false;}
 
        virtual byte GenerateByte();
 
        virtual unsigned int GenerateBit();
 
        virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL);
 
        virtual void GenerateBlock(byte *output, size_t size);
 
        virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length);
 
        virtual void DiscardBytes(size_t n);
 
        template <class IT> void Shuffle(IT begin, IT end)
        {
                // TODO: What happens if there are more than 2^32 elements?
                for (; begin != end; ++begin)
                        std::iter_swap(begin, begin + GenerateWord32(0, static_cast<word32>(end-begin-1)));
        }
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE KeyDerivationFunction : public Algorithm
{
public:
        virtual ~KeyDerivationFunction() {}
 
        virtual std::string AlgorithmName() const =0;
 
        virtual size_t MinDerivedKeyLength() const;
 
        virtual size_t MaxDerivedKeyLength() const;
 
        virtual size_t GetValidDerivedLength(size_t keylength) const =0;
 
        virtual bool IsValidDerivedLength(size_t keylength) const {
                return keylength == GetValidDerivedLength(keylength);
        }
 
        virtual size_t DeriveKey(byte *derived, size_t derivedLen, const byte *secret, size_t secretLen, const NameValuePairs& params = g_nullNameValuePairs) const =0;
 
        virtual void SetParameters(const NameValuePairs& params);
 
protected:
        virtual const Algorithm & GetAlgorithm() const =0;
 
        void ThrowIfInvalidDerivedKeyLength(size_t length) const;
};
 
struct PasswordBasedKeyDerivationFunction : public KeyDerivationFunction
{
};
 
CRYPTOPP_DLL RandomNumberGenerator & CRYPTOPP_API NullRNG();
 
class WaitObjectContainer;
class CallStack;
 
class CRYPTOPP_NO_VTABLE Waitable
{
public:
        virtual ~Waitable() {}
 
        virtual unsigned int GetMaxWaitObjectCount() const =0;
 
        virtual void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack) =0;
 
        bool Wait(unsigned long milliseconds, CallStack const& callStack);
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BufferedTransformation : public Algorithm, public Waitable
{
public:
        virtual ~BufferedTransformation() {}
 
        BufferedTransformation() : Algorithm(false) {}
 
        BufferedTransformation& Ref() {return *this;}
 
 
 
                size_t Put(byte inByte, bool blocking=true)
                        {return Put(&inByte, 1, blocking);}
 
                size_t Put(const byte *inString, size_t length, bool blocking=true)
                        {return Put2(inString, length, 0, blocking);}
 
                size_t PutWord16(word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
 
                size_t PutWord32(word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
 
                size_t PutWord64(word64 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
 
                virtual byte * CreatePutSpace(size_t &size)
                        {size=0; return NULLPTR;}
 
                virtual bool CanModifyInput() const
                        {return false;}
 
                size_t PutModifiable(byte *inString, size_t length, bool blocking=true)
                        {return PutModifiable2(inString, length, 0, blocking);}
 
                bool MessageEnd(int propagation=-1, bool blocking=true)
                        {return !!Put2(NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}
 
                size_t PutMessageEnd(const byte *inString, size_t length, int propagation=-1, bool blocking=true)
                        {return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
 
                virtual size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking) =0;
 
                virtual size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
                        {return Put2(inString, length, messageEnd, blocking);}
 
                struct BlockingInputOnly : public NotImplemented
                        {BlockingInputOnly(const std::string &s) : NotImplemented(s + ": Nonblocking input is not implemented by this object.") {}};
 
 
 
                unsigned int GetMaxWaitObjectCount() const;
 
                void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack);
 
 
 
                virtual void IsolatedInitialize(const NameValuePairs &parameters) {
                        CRYPTOPP_UNUSED(parameters);
                        throw NotImplemented("BufferedTransformation: this object can't be reinitialized");
                }
 
                virtual bool IsolatedFlush(bool hardFlush, bool blocking) =0;
 
                virtual bool IsolatedMessageSeriesEnd(bool blocking)
                        {CRYPTOPP_UNUSED(blocking); return false;}
 
                virtual void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1);
 
                virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true);
 
                virtual bool MessageSeriesEnd(int propagation=-1, bool blocking=true);
 
                virtual void SetAutoSignalPropagation(int propagation)
                        {CRYPTOPP_UNUSED(propagation);}
 
                virtual int GetAutoSignalPropagation() const {return 0;}
public:
 
 
 
                virtual lword MaxRetrievable() const;
 
                virtual bool AnyRetrievable() const;
 
                virtual size_t Get(byte &outByte);
 
                virtual size_t Get(byte *outString, size_t getMax);
 
                virtual size_t Peek(byte &outByte) const;
 
                virtual size_t Peek(byte *outString, size_t peekMax) const;
 
                size_t GetWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER);
 
                size_t GetWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER);
 
                size_t GetWord64(word64 &value, ByteOrder order=BIG_ENDIAN_ORDER);
 
                size_t PeekWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
 
                size_t PeekWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
 
                size_t PeekWord64(word64 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
 
 
                lword TransferTo(BufferedTransformation &target, lword transferMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL)
                        {TransferTo2(target, transferMax, channel); return transferMax;}
 
                virtual lword Skip(lword skipMax=LWORD_MAX);
 
                lword CopyTo(BufferedTransformation &target, lword copyMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL) const
                        {return CopyRangeTo(target, 0, copyMax, channel);}
 
                lword CopyRangeTo(BufferedTransformation &target, lword position, lword copyMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL) const
                        {lword i = position; CopyRangeTo2(target, i, i+copyMax, channel); return i-position;}
 
 
 
                virtual lword TotalBytesRetrievable() const;
 
                virtual unsigned int NumberOfMessages() const;
 
                virtual bool AnyMessages() const;
 
                virtual bool GetNextMessage();
 
                virtual unsigned int SkipMessages(unsigned int count=UINT_MAX);
 
                unsigned int TransferMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=DEFAULT_CHANNEL)
                        {TransferMessagesTo2(target, count, channel); return count;}
 
                unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=DEFAULT_CHANNEL) const;
 
                virtual void SkipAll();
 
                void TransferAllTo(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL)
                        {TransferAllTo2(target, channel);}
 
                void CopyAllTo(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL) const;
 
                virtual bool GetNextMessageSeries() {return false;}
                virtual unsigned int NumberOfMessagesInThisSeries() const {return NumberOfMessages();}
                virtual unsigned int NumberOfMessageSeries() const {return 0;}
 
 
 
                // upon return, byteCount contains number of bytes that have finished being transferred,
                // and returns the number of bytes left in the current transfer block
 
                virtual size_t TransferTo2(BufferedTransformation &target, lword &byteCount, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) =0;
 
                // upon return, begin contains the start position of data yet to be finished copying,
                // and returns the number of bytes left in the current transfer block
 
                virtual size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const =0;
 
                // upon return, messageCount contains number of messages that have finished being transferred,
                // and returns the number of bytes left in the current transfer block
 
                size_t TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
 
                // returns the number of bytes left in the current transfer block
 
                size_t TransferAllTo2(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
 
 
 
                struct NoChannelSupport : public NotImplemented
                        {NoChannelSupport(const std::string &name) : NotImplemented(name + ": this object doesn't support multiple channels") {}};
                struct InvalidChannelName : public InvalidArgument
                        {InvalidChannelName(const std::string &name, const std::string &channel) : InvalidArgument(name + ": unexpected channel name \"" + channel + "\"") {}};
 
                size_t ChannelPut(const std::string &channel, byte inByte, bool blocking=true)
                        {return ChannelPut(channel, &inByte, 1, blocking);}
 
                size_t ChannelPut(const std::string &channel, const byte *inString, size_t length, bool blocking=true)
                        {return ChannelPut2(channel, inString, length, 0, blocking);}
 
                size_t ChannelPutModifiable(const std::string &channel, byte *inString, size_t length, bool blocking=true)
                        {return ChannelPutModifiable2(channel, inString, length, 0, blocking);}
 
                size_t ChannelPutWord16(const std::string &channel, word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
 
                size_t ChannelPutWord32(const std::string &channel, word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
 
                size_t ChannelPutWord64(const std::string &channel, word64 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
 
                bool ChannelMessageEnd(const std::string &channel, int propagation=-1, bool blocking=true)
                        {return !!ChannelPut2(channel, NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}
 
                size_t ChannelPutMessageEnd(const std::string &channel, const byte *inString, size_t length, int propagation=-1, bool blocking=true)
                        {return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
 
                virtual byte * ChannelCreatePutSpace(const std::string &channel, size_t &size);
 
                virtual size_t ChannelPut2(const std::string &channel, const byte *inString, size_t length, int messageEnd, bool blocking);
 
                virtual size_t ChannelPutModifiable2(const std::string &channel, byte *inString, size_t length, int messageEnd, bool blocking);
 
                virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true);
 
                virtual bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);
 
                virtual void SetRetrievalChannel(const std::string &channel);
 
 
 
                virtual bool Attachable() {return false;}
 
                virtual BufferedTransformation *AttachedTransformation() {CRYPTOPP_ASSERT(!Attachable()); return NULLPTR;}
 
                virtual const BufferedTransformation *AttachedTransformation() const
                        {return const_cast<BufferedTransformation *>(this)->AttachedTransformation();}
 
                virtual void Detach(BufferedTransformation *newAttachment = NULLPTR) {
                        CRYPTOPP_UNUSED(newAttachment); CRYPTOPP_ASSERT(!Attachable());
                        throw NotImplemented("BufferedTransformation: this object is not attachable");
                }
 
                virtual void Attach(BufferedTransformation *newAttachment);
 
protected:
        static int DecrementPropagation(int propagation)
                {return propagation != 0 ? propagation - 1 : 0;}
 
private:
        // for ChannelPutWord16, ChannelPutWord32 and ChannelPutWord64,
        // to ensure the buffer isn't deallocated before non-blocking
        // operation completes
        byte m_buf[8];
};
 
CRYPTOPP_DLL BufferedTransformation & TheBitBucket();
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoMaterial : public NameValuePairs
{
public:
        class CRYPTOPP_DLL InvalidMaterial : public InvalidDataFormat
        {
        public:
                explicit InvalidMaterial(const std::string &s) : InvalidDataFormat(s) {}
        };
 
        virtual ~CryptoMaterial() {}
 
        virtual void AssignFrom(const NameValuePairs &source) =0;
 
        virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0;
 
        virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
                {if (!Validate(rng, level)) throw InvalidMaterial("CryptoMaterial: this object contains invalid values");}
 
        virtual void Save(BufferedTransformation &bt) const
                {CRYPTOPP_UNUSED(bt); throw NotImplemented("CryptoMaterial: this object does not support saving");}
 
        virtual void Load(BufferedTransformation &bt)
                {CRYPTOPP_UNUSED(bt); throw NotImplemented("CryptoMaterial: this object does not support loading");}
 
        virtual bool SupportsPrecomputation() const {return false;}
 
        virtual void Precompute(unsigned int precomputationStorage) {
                CRYPTOPP_UNUSED(precomputationStorage); CRYPTOPP_ASSERT(!SupportsPrecomputation());
                throw NotImplemented("CryptoMaterial: this object does not support precomputation");
        }
 
        virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
                {CRYPTOPP_UNUSED(storedPrecomputation); CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
 
        virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
                {CRYPTOPP_UNUSED(storedPrecomputation); CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
 
        void DoQuickSanityCheck() const {ThrowIfInvalid(NullRNG(), 0);}
 
#if defined(__SUNPRO_CC)
        // Sun Studio 11/CC 5.8 workaround: it generates incorrect code
        // when casting to an empty virtual base class. JW, 2018: It is
        // still a problem in Sun Studio 12.6/CC 5.15 on i386. Just enable
        // it everywhere in case it affects SPARC (which we don't test).
        char m_sunCCworkaround;
#endif
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE GeneratableCryptoMaterial : virtual public CryptoMaterial
{
public:
        virtual ~GeneratableCryptoMaterial() {}
 
        virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &params = g_nullNameValuePairs) {
                CRYPTOPP_UNUSED(rng); CRYPTOPP_UNUSED(params);
                throw NotImplemented("GeneratableCryptoMaterial: this object does not support key/parameter generation");
        }
 
        void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize);
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PublicKey : virtual public CryptoMaterial
{
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PrivateKey : public GeneratableCryptoMaterial
{
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoParameters : public GeneratableCryptoMaterial
{
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Certificate : virtual public CryptoMaterial
{
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AsymmetricAlgorithm : public Algorithm
{
public:
        virtual ~AsymmetricAlgorithm() {}
 
        virtual CryptoMaterial & AccessMaterial() =0;
 
        virtual const CryptoMaterial & GetMaterial() const =0;
 
#if 0
        void BERDecode(BufferedTransformation &bt)
                {AccessMaterial().Load(bt);}
 
        void DEREncode(BufferedTransformation &bt) const
                {GetMaterial().Save(bt);}
#endif
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PublicKeyAlgorithm : public AsymmetricAlgorithm
{
public:
        virtual ~PublicKeyAlgorithm() {}
 
        // VC60 workaround: no co-variant return type
 
        CryptoMaterial & AccessMaterial()
                {return AccessPublicKey();}
        const CryptoMaterial & GetMaterial() const
                {return GetPublicKey();}
 
        virtual PublicKey & AccessPublicKey() =0;
        virtual const PublicKey & GetPublicKey() const
                {return const_cast<PublicKeyAlgorithm *>(this)->AccessPublicKey();}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PrivateKeyAlgorithm : public AsymmetricAlgorithm
{
public:
        virtual ~PrivateKeyAlgorithm() {}
 
        CryptoMaterial & AccessMaterial() {return AccessPrivateKey();}
        const CryptoMaterial & GetMaterial() const {return GetPrivateKey();}
 
        virtual PrivateKey & AccessPrivateKey() =0;
        virtual const PrivateKey & GetPrivateKey() const {return const_cast<PrivateKeyAlgorithm *>(this)->AccessPrivateKey();}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE KeyAgreementAlgorithm : public AsymmetricAlgorithm
{
public:
        virtual ~KeyAgreementAlgorithm() {}
 
        CryptoMaterial & AccessMaterial() {return AccessCryptoParameters();}
        const CryptoMaterial & GetMaterial() const {return GetCryptoParameters();}
 
        virtual CryptoParameters & AccessCryptoParameters() =0;
        virtual const CryptoParameters & GetCryptoParameters() const {return const_cast<KeyAgreementAlgorithm *>(this)->AccessCryptoParameters();}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_CryptoSystem
{
public:
        virtual ~PK_CryptoSystem() {}
 
        virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0;
 
        virtual size_t CiphertextLength(size_t plaintextLength) const =0;
 
        virtual bool ParameterSupported(const char *name) const =0;
 
        virtual size_t FixedCiphertextLength() const {return 0;}
 
        virtual size_t FixedMaxPlaintextLength() const {return 0;}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Encryptor : public PK_CryptoSystem, public PublicKeyAlgorithm
{
public:
        class CRYPTOPP_DLL InvalidPlaintextLength : public Exception
        {
        public:
                InvalidPlaintextLength() : Exception(OTHER_ERROR, "PK_Encryptor: invalid plaintext length") {}
        };
 
        virtual void Encrypt(RandomNumberGenerator &rng,
                const byte *plaintext, size_t plaintextLength,
                byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const =0;
 
        virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng,
                BufferedTransformation *attachment=NULLPTR, const NameValuePairs &parameters = g_nullNameValuePairs) const;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Decryptor : public PK_CryptoSystem, public PrivateKeyAlgorithm
{
public:
        virtual ~PK_Decryptor() {}
 
        virtual DecodingResult Decrypt(RandomNumberGenerator &rng,
                const byte *ciphertext, size_t ciphertextLength,
                byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const =0;
 
        virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng,
                BufferedTransformation *attachment=NULLPTR, const NameValuePairs &parameters = g_nullNameValuePairs) const;
 
        DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const
                {return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_SignatureScheme
{
public:
        class CRYPTOPP_DLL InvalidKeyLength : public Exception
        {
        public:
                InvalidKeyLength(const std::string &message) : Exception(OTHER_ERROR, message) {}
        };
 
        class CRYPTOPP_DLL KeyTooShort : public InvalidKeyLength
        {
        public:
                KeyTooShort() : InvalidKeyLength("PK_Signer: key too short for this signature scheme") {}
        };
 
        virtual ~PK_SignatureScheme() {}
 
        virtual size_t SignatureLength() const =0;
 
        virtual size_t MaxSignatureLength(size_t recoverablePartLength = 0) const
                {CRYPTOPP_UNUSED(recoverablePartLength); return SignatureLength();}
 
        virtual size_t MaxRecoverableLength() const =0;
 
        virtual size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const =0;
 
        virtual bool IsProbabilistic() const =0;
 
        virtual bool AllowNonrecoverablePart() const =0;
 
        virtual bool SignatureUpfront() const {return false;}
 
        virtual bool RecoverablePartFirst() const =0;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_MessageAccumulator : public HashTransformation
{
public:
        unsigned int DigestSize() const
                {throw NotImplemented("PK_MessageAccumulator: DigestSize() should not be called");}
 
        void TruncatedFinal(byte *digest, size_t digestSize)
        {
                CRYPTOPP_UNUSED(digest); CRYPTOPP_UNUSED(digestSize);
                throw NotImplemented("PK_MessageAccumulator: TruncatedFinal() should not be called");
        }
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Signer : public PK_SignatureScheme, public PrivateKeyAlgorithm
{
public:
        virtual ~PK_Signer() {}
 
        virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0;
 
        virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0;
 
        virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const;
 
        virtual size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0;
 
        virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const;
 
        virtual size_t SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength,
                const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Verifier : public PK_SignatureScheme, public PublicKeyAlgorithm
{
public:
        virtual ~PK_Verifier() {}
 
        virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0;
 
        virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0;
 
        virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const;
 
        virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0;
 
        virtual bool VerifyMessage(const byte *message, size_t messageLen,
                const byte *signature, size_t signatureLen) const;
 
        virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const;
 
        virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0;
 
        virtual DecodingResult RecoverMessage(byte *recoveredMessage,
                const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength,
                const byte *signature, size_t signatureLength) const;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyAgreementDomain : public KeyAgreementAlgorithm
{
public:
        virtual ~SimpleKeyAgreementDomain() {}
 
        virtual unsigned int AgreedValueLength() const =0;
 
        virtual unsigned int PrivateKeyLength() const =0;
 
        virtual unsigned int PublicKeyLength() const =0;
 
        virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
 
        virtual void GeneratePublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
 
        virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
 
        virtual bool Agree(byte *agreedValue, const byte *privateKey, const byte *otherPublicKey, bool validateOtherPublicKey=true) const =0;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AuthenticatedKeyAgreementDomain : public KeyAgreementAlgorithm
{
public:
        virtual ~AuthenticatedKeyAgreementDomain() {}
 
        virtual unsigned int AgreedValueLength() const =0;
 
        virtual unsigned int StaticPrivateKeyLength() const =0;
 
        virtual unsigned int StaticPublicKeyLength() const =0;
 
        virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
 
        virtual void GenerateStaticPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
 
        virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
 
        virtual unsigned int EphemeralPrivateKeyLength() const =0;
 
        virtual unsigned int EphemeralPublicKeyLength() const =0;
 
        virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
 
        virtual void GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
 
        virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
 
        virtual bool Agree(byte *agreedValue,
                const byte *staticPrivateKey, const byte *ephemeralPrivateKey,
                const byte *staticOtherPublicKey, const byte *ephemeralOtherPublicKey,
                bool validateStaticOtherPublicKey=true) const =0;
};
 
// interface for password authenticated key agreement protocols, not implemented yet
#if 0
 
class ProtocolSession
{
public:
        class ProtocolError : public Exception
        {
        public:
                ProtocolError(ErrorType errorType, const std::string &s) : Exception(errorType, s) {}
        };
 
 
        class UnexpectedMethodCall : public Exception
        {
        public:
                UnexpectedMethodCall(const std::string &s) : Exception(OTHER_ERROR, s) {}
        };
 
        virtual ~ProtocolSession() {}
 
        ProtocolSession() : m_rng(NULLPTR), m_throwOnProtocolError(true), m_validState(false) {}
 
        virtual void InitializeSession(RandomNumberGenerator &rng, const NameValuePairs &parameters) =0;
 
        bool GetThrowOnProtocolError() const {return m_throwOnProtocolError;}
        void SetThrowOnProtocolError(bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}
 
        bool HasValidState() const {return m_validState;}
 
        virtual bool OutgoingMessageAvailable() const =0;
        virtual unsigned int GetOutgoingMessageLength() const =0;
        virtual void GetOutgoingMessage(byte *message) =0;
 
        virtual bool LastMessageProcessed() const =0;
        virtual void ProcessIncomingMessage(const byte *message, unsigned int messageLength) =0;
 
protected:
        void HandleProtocolError(Exception::ErrorType errorType, const std::string &s) const;
        void CheckAndHandleInvalidState() const;
        void SetValidState(bool valid) {m_validState = valid;}
 
        RandomNumberGenerator *m_rng;
 
private:
        bool m_throwOnProtocolError, m_validState;
};
 
class KeyAgreementSession : public ProtocolSession
{
public:
        virtual ~KeyAgreementSession() {}
 
        virtual unsigned int GetAgreedValueLength() const =0;
        virtual void GetAgreedValue(byte *agreedValue) const =0;
};
 
class PasswordAuthenticatedKeyAgreementSession : public KeyAgreementSession
{
public:
        virtual ~PasswordAuthenticatedKeyAgreementSession() {}
 
        void InitializePasswordAuthenticatedKeyAgreementSession(RandomNumberGenerator &rng,
                const byte *myId, unsigned int myIdLength,
                const byte *counterPartyId, unsigned int counterPartyIdLength,
                const byte *passwordOrVerifier, unsigned int passwordOrVerifierLength);
};
 
class PasswordAuthenticatedKeyAgreementDomain : public KeyAgreementAlgorithm
{
public:
        virtual ~PasswordAuthenticatedKeyAgreementDomain() {}
 
        virtual bool ValidateDomainParameters(RandomNumberGenerator &rng) const
                {return GetCryptoParameters().Validate(rng, 2);}
 
        virtual unsigned int GetPasswordVerifierLength(const byte *password, unsigned int passwordLength) const =0;
        virtual void GeneratePasswordVerifier(RandomNumberGenerator &rng, const byte *userId, unsigned int userIdLength, const byte *password, unsigned int passwordLength, byte *verifier) const =0;
 
        enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};
 
        virtual bool IsValidRole(unsigned int role) =0;
        virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(unsigned int role) const =0;
};
#endif
 
class CRYPTOPP_DLL BERDecodeErr : public InvalidArgument
{
public:
        BERDecodeErr() : InvalidArgument("BER decode error") {}
        BERDecodeErr(const std::string &s) : InvalidArgument(s) {}
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ASN1Object
{
public:
        virtual ~ASN1Object() {}
 
        virtual void BERDecode(BufferedTransformation &bt) =0;
 
        virtual void DEREncode(BufferedTransformation &bt) const =0;
 
        virtual void BEREncode(BufferedTransformation &bt) const {DEREncode(bt);}
};
 
extern "C" {
        int LibraryVersion(CRYPTOPP_NOINLINE_DOTDOTDOT);
} // C linkage
 
extern "C" {
inline int HeaderVersion()
{
        return CRYPTOPP_VERSION;
}
} // C linkage
 
NAMESPACE_END
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
 
#endif