83 #ifndef CRYPTOPP_CRYPTLIB_H 84 #define CRYPTOPP_CRYPTLIB_H 89 #if CRYPTOPP_MSC_VERSION 90 # pragma warning(push) 91 # pragma warning(disable: 4127 4189 4702) 114 template <
typename ENUM_TYPE,
int VALUE>
117 static ENUM_TYPE ToEnum() {
return (ENUM_TYPE)VALUE;}
166 const char *
what()
const throw() {
return (m_what.c_str());}
168 const std::string &
GetWhat()
const {
return m_what;}
170 void SetWhat(
const std::string &s) {m_what = s;}
220 OS_Error(
ErrorType errorType,
const std::string &s,
const std::string& operation,
int errorCode)
221 :
Exception(errorType, s), m_operation(operation), m_errorCode(errorCode) {}
230 std::string m_operation;
261 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 262 operator size_t()
const {
return isValidCoding ? messageLength : 0;}
292 ValueTypeMismatch(
const std::string &name,
const std::type_info &stored,
const std::type_info &retrieving)
293 :
InvalidArgument(
"NameValuePairs: type mismatch for '" + name +
"', stored '" + stored.name() +
"', trying to retrieve '" + retrieving.name() +
"'")
294 , m_stored(stored), m_retrieving(retrieving) {}
305 const std::type_info &m_stored;
306 const std::type_info &m_retrieving;
315 return GetValue((std::string(
"ThisObject:")+
typeid(T).name()).c_str(),
object);
324 return GetValue((std::string(
"ThisPointer:")+
typeid(T).name()).c_str(), ptr);
337 return GetVoidValue(name,
typeid(T), &value);
351 bool result = GetValue(name, value);
353 if (result) {
return value;}
361 {std::string result; GetValue(
"ValueNames", result);
return result;}
372 {
return GetValue(name, value);}
381 {
return GetValueWithDefault(name, defaultValue);}
392 CRYPTOPP_DLL
static void CRYPTOPP_API
ThrowIfTypeMismatch(
const char *name,
const std::type_info &stored,
const std::type_info &retrieving)
408 if (!GetValue(name, value))
409 throw InvalidArgument(std::string(className) +
": missing required parameter '" + name +
"'");
423 if (!GetIntValue(name, value))
424 throw InvalidArgument(std::string(className) +
": missing required parameter '" + name +
"'");
437 CRYPTOPP_DLL
virtual bool GetVoidValue(
const char *name,
const std::type_info &valueType,
void *pValue)
const =0;
440 #if CRYPTOPP_DOXYGEN_PROCESSING 449 DOCUMENTED_NAMESPACE_BEGIN(
Name)
451 DOCUMENTED_NAMESPACE_END
466 DOCUMENTED_NAMESPACE_BEGIN(
Weak)
468 DOCUMENTED_NAMESPACE_END
498 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 510 Algorithm(
bool checkSelfTestStatus =
true);
530 virtual size_t MinKeyLength()
const =0;
532 virtual size_t MaxKeyLength()
const =0;
534 virtual size_t DefaultKeyLength()
const =0;
539 virtual size_t GetValidKeyLength(
size_t n)
const =0;
546 {
return keylength == GetValidKeyLength(keylength);}
563 void SetKeyWithRounds(
const byte *key,
size_t length,
int rounds);
573 void SetKeyWithIV(
const byte *key,
size_t length,
const byte *iv,
size_t ivLength);
583 {SetKeyWithIV(key, length, iv, IVSize());}
632 {
throw NotImplemented(GetAlgorithm().AlgorithmName() +
": this object doesn't support resynchronization");}
654 CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(ivLength);
655 throw NotImplemented(GetAlgorithm().AlgorithmName() +
": this object doesn't support resynchronization");
672 virtual const Algorithm & GetAlgorithm()
const =0;
679 virtual void UncheckedSetKey(
const byte *key,
unsigned int length,
const NameValuePairs ¶ms) =0;
684 void ThrowIfInvalidKeyLength(
size_t length);
691 void ThrowIfResynchronizable();
700 void ThrowIfInvalidIV(
const byte *iv);
705 size_t ThrowIfInvalidIVLength(
int length);
712 const byte * GetIVAndThrowIfInvalid(
const NameValuePairs ¶ms,
size_t &size);
716 inline void AssertValidKeyLength(
size_t length)
const 717 {CRYPTOPP_UNUSED(length); assert(IsValidKeyLength(length));}
728 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 741 virtual void ProcessAndXorBlock(
const byte *inBlock,
const byte *xorBlock, byte *outBlock)
const =0;
752 {ProcessAndXorBlock(inBlock, NULL, outBlock);}
761 {ProcessAndXorBlock(inoutBlock, NULL, inoutBlock);}
765 virtual unsigned int BlockSize()
const =0;
769 virtual unsigned int OptimalDataAlignment()
const;
777 virtual bool IsForwardTransformation()
const =0;
787 BT_InBlockIsCounter=1,
789 BT_DontIncrementInOutPointers=2,
793 BT_ReverseDirection=8,
795 BT_AllowParallel=16};
805 virtual size_t AdvancedProcessBlocks(
const byte *inBlocks,
const byte *xorBlocks, byte *outBlocks,
size_t length, word32 flags)
const;
819 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 845 virtual unsigned int OptimalDataAlignment()
const;
852 virtual void ProcessData(byte *outString,
const byte *inString,
size_t length) =0;
860 virtual void ProcessLastBlock(byte *outString,
const byte *inString,
size_t length);
870 {ProcessData(inoutString, inoutString, length);}
877 inline void ProcessString(byte *outString,
const byte *inString,
size_t length)
878 {ProcessData(outString, inString, length);}
884 {ProcessData(&input, &input, 1);
return input;}
888 virtual bool IsRandomAccess()
const =0;
897 CRYPTOPP_UNUSED(pos);
898 assert(!IsRandomAccess());
899 throw NotImplemented(
"StreamTransformation: this object doesn't support random access");
906 virtual bool IsSelfInverting()
const =0;
911 virtual bool IsForwardTransformation()
const =0;
925 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 937 virtual void Update(
const byte *input,
size_t length) =0;
960 {TruncatedFinal(NULL, 0);}
986 virtual unsigned int OptimalDataAlignment()
const;
998 {Update(input, length); Final(digest);}
1010 {
return TruncatedVerify(digest,
DigestSize());}
1025 virtual bool VerifyDigest(
const byte *digest,
const byte *input,
size_t length)
1026 {Update(input, length);
return Verify(digest);}
1035 virtual void TruncatedFinal(byte *digest,
size_t digestSize) =0;
1048 {Update(input, length); TruncatedFinal(digest, digestSize);}
1060 virtual bool TruncatedVerify(
const byte *digest,
size_t digestLength);
1077 {Update(input, length);
return TruncatedVerify(digest, digestLength);}
1084 void ThrowIfInvalidTruncatedSize(
size_t size)
const;
1094 const Algorithm & GetAlgorithm()
const {
return *
this;}
1102 const Algorithm & GetAlgorithm()
const {
return *
this;}
1110 const Algorithm & GetAlgorithm()
const {
return *
this;}
1120 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 1130 explicit BadState(
const std::string &name,
const char *message) :
Exception(OTHER_ERROR, name +
": " + message) {}
1131 explicit BadState(
const std::string &name,
const char *
function,
const char *state) :
Exception(OTHER_ERROR, name +
": " +
function +
" was called before " + state) {}
1136 virtual lword MaxHeaderLength()
const =0;
1139 virtual lword MaxMessageLength()
const =0;
1152 void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0);
1157 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);
1162 virtual bool DecryptAndVerify(byte *message,
const byte *mac,
size_t macLength,
const byte *iv,
int ivLength,
const byte *header,
size_t headerLength,
const byte *ciphertext,
size_t ciphertextLength);
1169 virtual std::string AlgorithmName()
const =0;
1174 virtual void UncheckedSpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength)
1175 {CRYPTOPP_UNUSED(headerLength); CRYPTOPP_UNUSED(messageLength); CRYPTOPP_UNUSED(footerLength);}
1178 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 1189 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 1203 CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);
1204 throw NotImplemented(
"RandomNumberGenerator: IncorporateEntropy not implemented");
1216 virtual byte GenerateByte();
1223 virtual unsigned int GenerateBit();
1233 virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL);
1242 virtual void GenerateBlock(byte *output,
size_t size);
1254 virtual void GenerateIntoBufferedTransformation(
BufferedTransformation &target,
const std::string &channel, lword length);
1258 virtual void DiscardBytes(
size_t n);
1264 template <
class IT>
void Shuffle(IT begin, IT end)
1267 for (; begin != end; ++begin)
1268 std::iter_swap(begin, begin + GenerateWord32(0, end-begin-1));
1271 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 1272 byte
GetByte() {
return GenerateByte();}
1273 unsigned int GetBit() {
return GenerateBit();}
1274 word32 GetLong(word32 a=0, word32 b=0xffffffffL) {
return GenerateWord32(a, b);}
1275 word16 GetShort(word16 a=0, word16 b=0xffff) {
return (word16)GenerateWord32(a, b);}
1276 void GetBlock(byte *output,
size_t size) {GenerateBlock(output, size);}
1302 virtual unsigned int GetMaxWaitObjectCount()
const =0;
1318 bool Wait(
unsigned long milliseconds,
CallStack const& callStack);
1327 extern CRYPTOPP_DLL
const std::string
AAD_CHANNEL;
1356 static const std::string &NULL_CHANNEL;
1358 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 1378 size_t Put(byte inByte,
bool blocking=
true)
1379 {
return Put(&inByte, 1, blocking);}
1387 size_t Put(
const byte *inString,
size_t length,
bool blocking=
true)
1388 {
return Put2(inString, length, 0, blocking);}
1414 {size=0;
return NULL;}
1429 {
return PutModifiable2(inString, length, 0, blocking);}
1437 {
return !!Put2(NULL, 0, propagation < 0 ? -1 : propagation+1, blocking);}
1449 size_t PutMessageEnd(
const byte *inString,
size_t length,
int propagation=-1,
bool blocking=
true)
1450 {
return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
1458 virtual size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking) =0;
1466 virtual size_t PutModifiable2(byte *inString,
size_t length,
int messageEnd,
bool blocking)
1467 {
return Put2(inString, length, messageEnd, blocking);}
1479 unsigned int GetMaxWaitObjectCount()
const;
1506 CRYPTOPP_UNUSED(parameters);
1507 throw NotImplemented(
"BufferedTransformation: this object can't be reinitialized");
1514 virtual bool IsolatedFlush(
bool hardFlush,
bool blocking) =0;
1520 {CRYPTOPP_UNUSED(blocking);
return false;}
1546 virtual bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true);
1556 virtual bool MessageSeriesEnd(
int propagation=-1,
bool blocking=
true);
1563 {CRYPTOPP_UNUSED(propagation);}
1571 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 1572 void Close() {MessageEnd();}
1583 virtual lword MaxRetrievable()
const;
1587 virtual bool AnyRetrievable()
const;
1593 virtual size_t Get(byte &outByte);
1600 virtual size_t Get(byte *outString,
size_t getMax);
1607 virtual size_t Peek(byte &outByte)
const;
1615 virtual size_t Peek(byte *outString,
size_t peekMax)
const;
1657 {TransferTo2(target, transferMax, channel);
return transferMax;}
1669 virtual lword Skip(lword skipMax=LWORD_MAX);
1681 {
return CopyRangeTo(target, 0, copyMax, channel);}
1694 {lword i = position; CopyRangeTo2(target, i, i+copyMax, channel);
return i-position;}
1696 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 1697 unsigned long MaxRetrieveable()
const {
return MaxRetrievable();}
1706 virtual lword TotalBytesRetrievable()
const;
1712 virtual unsigned int NumberOfMessages()
const;
1717 virtual bool AnyMessages()
const;
1723 virtual bool GetNextMessage();
1730 virtual unsigned int SkipMessages(
unsigned int count=UINT_MAX);
1742 {TransferMessagesTo2(target, count, channel);
return count;}
1756 virtual void SkipAll();
1765 {TransferAllTo2(target, channel);}
1865 size_t ChannelPut(
const std::string &channel, byte inByte,
bool blocking=
true)
1866 {
return ChannelPut(channel, &inByte, 1, blocking);}
1875 size_t ChannelPut(
const std::string &channel,
const byte *inString,
size_t length,
bool blocking=
true)
1876 {
return ChannelPut2(channel, inString, length, 0, blocking);}
1886 {
return ChannelPutModifiable2(channel, inString, length, 0, blocking);}
1895 size_t ChannelPutWord16(
const std::string &channel, word16 value,
ByteOrder order=
BIG_ENDIAN_ORDER,
bool blocking=
true);
1904 size_t ChannelPutWord32(
const std::string &channel, word32 value,
ByteOrder order=
BIG_ENDIAN_ORDER,
bool blocking=
true);
1915 {
return !!ChannelPut2(channel, NULL, 0, propagation < 0 ? -1 : propagation+1, blocking);}
1926 size_t ChannelPutMessageEnd(
const std::string &channel,
const byte *inString,
size_t length,
int propagation=-1,
bool blocking=
true)
1927 {
return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
1940 virtual byte * ChannelCreatePutSpace(
const std::string &channel,
size_t &size);
1949 virtual size_t ChannelPut2(
const std::string &channel,
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
1958 virtual size_t ChannelPutModifiable2(
const std::string &channel, byte *inString,
size_t length,
int messageEnd,
bool blocking);
1968 virtual bool ChannelFlush(
const std::string &channel,
bool hardFlush,
int propagation=-1,
bool blocking=
true);
1979 virtual bool ChannelMessageSeriesEnd(
const std::string &channel,
int propagation=-1,
bool blocking=
true);
1984 virtual void SetRetrievalChannel(
const std::string &channel);
2018 CRYPTOPP_UNUSED(newAttachment); assert(!Attachable());
2019 throw NotImplemented(
"BufferedTransformation: this object is not attachable");
2030 static int DecrementPropagation(
int propagation)
2031 {
return propagation != 0 ? propagation - 1 : 0;}
2046 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2084 {
if (!Validate(rng, level))
throw InvalidMaterial(
"CryptoMaterial: this object contains invalid values");}
2096 {CRYPTOPP_UNUSED(bt);
throw NotImplemented(
"CryptoMaterial: this object does not support saving");}
2113 {CRYPTOPP_UNUSED(bt);
throw NotImplemented(
"CryptoMaterial: this object does not support loading");}
2129 CRYPTOPP_UNUSED(precomputationStorage); assert(!SupportsPrecomputation());
2130 throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");
2138 {CRYPTOPP_UNUSED(storedPrecomputation); assert(!SupportsPrecomputation());
throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");}
2144 {CRYPTOPP_UNUSED(storedPrecomputation); assert(!SupportsPrecomputation());
throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");}
2150 #if (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) 2152 char m_sunCCworkaround;
2161 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2172 CRYPTOPP_UNUSED(rng); CRYPTOPP_UNUSED(params);
2173 throw NotImplemented(
"GeneratableCryptoMaterial: this object does not support key/parameter generation");
2204 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2220 {AccessMaterial().Load(bt);}
2226 {GetMaterial().Save(bt);}
2233 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2242 {
return AccessPublicKey();}
2246 {
return GetPublicKey();}
2250 virtual PublicKey & AccessPublicKey() =0;
2261 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2274 virtual PrivateKey & AccessPrivateKey() =0;
2284 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2297 virtual CryptoParameters & AccessCryptoParameters() =0;
2314 virtual size_t MaxPlaintextLength(
size_t ciphertextLength)
const =0;
2319 virtual size_t CiphertextLength(
size_t plaintextLength)
const =0;
2326 virtual bool ParameterSupported(
const char *name)
const =0;
2341 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 2342 size_t MaxPlainTextLength(
size_t cipherTextLength)
const {
return MaxPlaintextLength(cipherTextLength);}
2343 size_t CipherTextLength(
size_t plainTextLength)
const {
return CiphertextLength(plainTextLength);}
2370 const byte *plaintext,
size_t plaintextLength,
2388 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2407 const byte *ciphertext,
size_t ciphertextLength,
2433 {
return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);}
2436 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 2473 virtual size_t SignatureLength()
const =0;
2481 {CRYPTOPP_UNUSED(recoverablePartLength);
return SignatureLength();}
2487 virtual size_t MaxRecoverableLength()
const =0;
2495 virtual size_t MaxRecoverableLengthFromSignatureLength(
size_t signatureLength)
const =0;
2501 virtual bool IsProbabilistic()
const =0;
2505 virtual bool AllowNonrecoverablePart()
const =0;
2517 virtual bool RecoverablePartFirst()
const =0;
2529 {
throw NotImplemented(
"PK_MessageAccumulator: DigestSize() should not be called");}
2534 CRYPTOPP_UNUSED(digest); CRYPTOPP_UNUSED(digestSize);
2535 throw NotImplemented(
"PK_MessageAccumulator: TruncatedFinal() should not be called");
2544 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2559 virtual void InputRecoverableMessage(
PK_MessageAccumulator &messageAccumulator,
const byte *recoverableMessage,
size_t recoverableMessageLength)
const =0;
2586 virtual size_t SignMessage(
RandomNumberGenerator &rng,
const byte *message,
size_t messageLen, byte *signature)
const;
2597 virtual size_t SignMessageWithRecovery(
RandomNumberGenerator &rng,
const byte *recoverableMessage,
size_t recoverableMessageLength,
2598 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength, byte *signature)
const;
2611 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2625 virtual void InputSignature(
PK_MessageAccumulator &messageAccumulator,
const byte *signature,
size_t signatureLength)
const =0;
2645 virtual bool VerifyMessage(
const byte *message,
size_t messageLen,
2646 const byte *signature,
size_t signatureLen)
const;
2673 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
2674 const byte *signature,
size_t signatureLength)
const;
2685 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2691 virtual unsigned int AgreedValueLength()
const =0;
2695 virtual unsigned int PrivateKeyLength()
const =0;
2699 virtual unsigned int PublicKeyLength()
const =0;
2712 virtual void GeneratePublicKey(
RandomNumberGenerator &rng,
const byte *privateKey, byte *publicKey)
const =0;
2735 virtual bool Agree(byte *agreedValue,
const byte *privateKey,
const byte *otherPublicKey,
bool validateOtherPublicKey=
true)
const =0;
2737 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 2739 {
return GetCryptoParameters().Validate(rng, 2);}
2750 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2756 virtual unsigned int AgreedValueLength()
const =0;
2760 virtual unsigned int StaticPrivateKeyLength()
const =0;
2764 virtual unsigned int StaticPublicKeyLength()
const =0;
2777 virtual void GenerateStaticPublicKey(
RandomNumberGenerator &rng,
const byte *privateKey, byte *publicKey)
const =0;
2786 virtual void GenerateStaticKeyPair(
RandomNumberGenerator &rng, byte *privateKey, byte *publicKey)
const;
2790 virtual unsigned int EphemeralPrivateKeyLength()
const =0;
2794 virtual unsigned int EphemeralPublicKeyLength()
const =0;
2807 virtual void GenerateEphemeralPublicKey(
RandomNumberGenerator &rng,
const byte *privateKey, byte *publicKey)
const =0;
2814 virtual void GenerateEphemeralKeyPair(
RandomNumberGenerator &rng, byte *privateKey, byte *publicKey)
const;
2832 virtual bool Agree(byte *agreedValue,
2833 const byte *staticPrivateKey,
const byte *ephemeralPrivateKey,
2834 const byte *staticOtherPublicKey,
const byte *ephemeralOtherPublicKey,
2835 bool validateStaticOtherPublicKey=
true)
const =0;
2837 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 2839 {
return GetCryptoParameters().Validate(rng, 2);}
2866 class ProtocolSession
2873 ProtocolError(ErrorType errorType,
const std::string &s) :
Exception(errorType, s) {}
2878 class UnexpectedMethodCall :
public Exception 2881 UnexpectedMethodCall(
const std::string &s) :
Exception(OTHER_ERROR, s) {}
2884 ProtocolSession() : m_rng(NULL), m_throwOnProtocolError(
true), m_validState(
false) {}
2885 virtual ~ProtocolSession() {}
2889 bool GetThrowOnProtocolError()
const {
return m_throwOnProtocolError;}
2890 void SetThrowOnProtocolError(
bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}
2892 bool HasValidState()
const {
return m_validState;}
2894 virtual bool OutgoingMessageAvailable()
const =0;
2895 virtual unsigned int GetOutgoingMessageLength()
const =0;
2896 virtual void GetOutgoingMessage(byte *message) =0;
2898 virtual bool LastMessageProcessed()
const =0;
2899 virtual void ProcessIncomingMessage(
const byte *message,
unsigned int messageLength) =0;
2903 void CheckAndHandleInvalidState()
const;
2904 void SetValidState(
bool valid) {m_validState = valid;}
2909 bool m_throwOnProtocolError, m_validState;
2912 class KeyAgreementSession :
public ProtocolSession
2915 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2916 virtual ~KeyAgreementSession() {}
2919 virtual unsigned int GetAgreedValueLength()
const =0;
2920 virtual void GetAgreedValue(byte *agreedValue)
const =0;
2923 class PasswordAuthenticatedKeyAgreementSession :
public KeyAgreementSession
2926 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2927 virtual ~PasswordAuthenticatedKeyAgreementSession() {}
2931 const byte *myId,
unsigned int myIdLength,
2932 const byte *counterPartyId,
unsigned int counterPartyIdLength,
2933 const byte *passwordOrVerifier,
unsigned int passwordOrVerifierLength);
2939 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 2940 virtual ~PasswordAuthenticatedKeyAgreementDomain() {}
2945 {
return GetCryptoParameters().Validate(rng, 2);}
2947 virtual unsigned int GetPasswordVerifierLength(
const byte *password,
unsigned int passwordLength)
const =0;
2948 virtual void GeneratePasswordVerifier(
RandomNumberGenerator &rng,
const byte *userId,
unsigned int userIdLength,
const byte *password,
unsigned int passwordLength, byte *verifier)
const =0;
2950 enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};
2952 virtual bool IsValidRole(
unsigned int role) =0;
2953 virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(
unsigned int role)
const =0;
2991 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY 2999 #if CRYPTOPP_MSC_VERSION 3000 # pragma warning(pop) Base class for all exceptions thrown by the library.
Exception thrown when invalid crypto material is detected.
virtual void Precompute(unsigned int precomputationStorage)
Perform precomputation.
virtual const PublicKey & GetPublicKey() const
Retrieves a reference to a Public Key.
the cipher is performing decryption
const char * DigestSize()
int, in bytes
An invalid argument was detected.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv)
Sets or reset the key of this object.
bool GetThisObject(T &object) const
Get a copy of this object or subobject.
bool CanUseRandomIVs() const
Determines if the object can use random IVs.
const char * what() const
Retrieves a C-string describing the exception.
Interface for message authentication codes.
ErrorType
Error types or categories.
container of wait objects
virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
Save precomputation for later use.
Interface for asymmetric algorithms.
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
Interface for public-key encryptors and decryptors.
ByteOrder
Provides the byte ordering.
The IV is set by the object.
The operating system reported an error.
Interface for one direction (encryption or decryption) of a stream cipher or block cipher mode with a...
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
virtual void Load(BufferedTransformation &bt)
Loads a key from a BufferedTransformation.
Exception(ErrorType errorType, const std::string &s)
Construct a new Exception.
ErrorType GetErrorType() const
Retrieves the error type for the exception.
virtual bool NeedsPrespecifiedDataLengths() const
Determines if data lengths must be specified prior to inputting data.
bool operator!=(const DecodingResult &rhs) const
Compare two DecodingResult.
Exception thrown when the object is in the wrong state for the operation.
Interface for public-key signers.
virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
Check this object for errors.
Interface for public-key encryptors.
Converts a typename to an enumerated value.
CipherDir
Specifies a direction for a cipher to operate.
void BERDecode(BufferedTransformation &bt)
Loads this object from a BufferedTransformation.
Flush(true) was called but it can't completely flush its buffers.
virtual void Save(BufferedTransformation &bt) const
Saves a key to a BufferedTransformation.
Thrown when an unexpected type is encountered.
CryptoMaterial & AccessMaterial()
Retrieves a reference to a Private Key.
Interface for asymmetric algorithms using private keys.
BufferedTransformation & TheBitBucket()
An input discarding BufferedTransformation.
bool operator==(const DecodingResult &rhs) const
Compare two DecodingResult.
virtual bool SupportsPrecomputation() const
Determines whether the object supports precomputation.
const std::string & GetWhat() const
Retrieves a string describing the exception.
ValueTypeMismatch(const std::string &name, const std::type_info &stored, const std::type_info &retrieving)
Construct a ValueTypeMismatch.
EnumToType< ByteOrder, LITTLE_ENDIAN_ORDER > LittleEndian
Provides a constant for LittleEndian.
Library configuration file.
virtual bool CanIncorporateEntropy() const
Determines if a generator can accept additional entropy.
std::string GetValueNames() const
Get a list of value names that can be retrieved.
Interface for random number generators.
size_t messageLength
Recovered message length if isValidCoding is true, undefined otherwise.
virtual lword MaxFooterLength() const
Provides the the maximum length of AAD.
Interface for private keys.
Interface for cloning objects.
virtual unsigned int MinIVLength() const
Provides the minimum size of an IV.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to a Private Key.
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
const std::type_info & GetRetrievingTypeInfo() const
Provides the retrieveing type.
bool GetIntValue(const char *name, int &value) const
Get a named value with type int.
Data integerity check, such as CRC or MAC, failed.
byte order is little-endian
Interface for one direction (encryption or decryption) of a block cipher.
void SetWhat(const std::string &s)
Sets the error string for the exception.
Interface for objects that can be waited on.
the cipher is performing encryption
const std::string & GetOperation() const
Retrieve the operating system API that reported the error.
Interface for domains of simple key agreement protocols.
Returns a decoding results.
virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
Retrieve previously saved precomputation.
Exception thrown when trying to encrypt plaintext of invalid length.
bool CanUsePredictableIVs() const
Determines if the object can use random but possibly predictable IVs.
DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Decrypt a fixed size ciphertext.
Input data was received that did not conform to expected format.
bool GetValue(const char *name, T &value) const
Get a named value.
Interface for public-key decryptors.
bool GetThisPointer(T *&ptr) const
Get a pointer to this object.
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
A method was called which was not implemented.
Exception throw when the private or public key is too short to sign or verify.
virtual size_t FixedCiphertextLength() const
Provides the fixed ciphertext length, if one exists.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
bool IsResynchronizable() const
Determines if the object can be resynchronized.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to Crypto Parameters.
const std::type_info & GetStoredTypeInfo() const
Provides the stored type.
Interface for encoding and decoding ASN1 objects.
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
virtual size_t MaxSignatureLength(size_t recoverablePartLength=0) const
Provides the maximum signature length produced given the length of the recoverable message part...
DecodingResult()
Constructs a DecodingResult.
bool CanUseStructuredIVs() const
Determines if the object can use structured IVs returns whether the object can use structured IVs...
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode...
Multiple precision integer with arithmetic operations.
DecodingResult(size_t len)
Constructs a DecodingResult.
Exception throw when the private or public key has a length that can't be used.
Interface for algorithms that take byte strings as keys.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
virtual const CryptoParameters & GetCryptoParameters() const
Retrieves a reference to Crypto Parameters.
Interface for asymmetric algorithms using public keys.
virtual size_t FixedMaxPlaintextLength() const
Provides the maximum plaintext length given a fixed ciphertext length.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to a Public Key.
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
unsigned int DigestSize() const
void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
Interface for public-key signers and verifiers.
int GetErrorCode() const
Retrieve the error code returned by the operating system.
virtual const PrivateKey & GetPrivateKey() const
Retrieves a reference to a Private Key.
RandomNumberGenerator & NullRNG()
Random Number Generator that does not produce random numbers.
const char * BlockSize()
int, in bytes
const unsigned long INFINITE_TIME
Represents infinite time.
virtual unsigned int MaxIVLength() const
Provides the maximum size of an IV.
Interface for all crypto algorithms.
unsigned int DefaultIVLength() const
Provides the default size of an IV.
virtual bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
virtual void BEREncode(BufferedTransformation &bt) const
Encode this object into a BufferedTransformation.
Interface for accumulating messages to be signed or verified.
virtual Clonable * Clone() const
Copies this object.
A decryption filter encountered invalid ciphertext.
Interface for key agreement algorithms.
static void ThrowIfTypeMismatch(const char *name, const std::type_info &stored, const std::type_info &retrieving)
Ensures an expected name and type is present.
IV_Requirement
Secure IVs requirements as enumerated values.
CryptoMaterial & AccessMaterial()
Retrieves a reference to a Public Key.
Interface for public-key signature verifiers.
void Shuffle(IT begin, IT end)
Randomly shuffle the specified array.
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
Interface for crypto material, such as public and private keys, and crypto parameters.
virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs ¶ms=g_nullNameValuePairs)
Generate a random key or crypto parameters.
void DEREncode(BufferedTransformation &bt) const
Saves this object to a BufferedTransformation.
Access a block of memory.
CryptoMaterial & AccessMaterial()
Retrieves a reference to Crypto Parameters.
An invalid argument was detected.
Interface for generatable crypto material, such as private keys and crypto parameters.
Interface for crypto prameters.
bool isValidCoding
Flag to indicate the decoding is valid.
Namespace containing value name definitions.
BufferedTransformation received a Flush(true) signal but can't flush buffers.
void SetErrorType(ErrorType errorType)
Sets the error type for the exceptions.
Interface for public keys.
Crypto++ library namespace.
The IV must be random and unpredictable.
Interface for domains of authenticated key agreement protocols.
void TruncatedFinal(byte *digest, size_t digestSize)
A method was called which was not implemented.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
Error reading from input device or writing to output device.
unsigned int GetByte(ByteOrder order, T value, unsigned int index)
Gets a byte from a value.
virtual unsigned int IVSize() const
Returns length of the IV accepted by this object.
EnumToType< ByteOrder, BIG_ENDIAN_ORDER > BigEndian
Provides a constant for BigEndian.
Namespace containing weak and wounded algorithms.
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
Interface for retrieving values given their names.
Exception thrown when an ASN.1 BER decoing error is encountered.
The IV must be random and possibly predictable.
void DoQuickSanityCheck() const
Perform a quick sanity check.