99 #ifndef CRYPTOPP_CRYPTLIB_H 100 #define CRYPTOPP_CRYPTLIB_H 106 #if CRYPTOPP_MSC_VERSION 107 # pragma warning(push) 108 # pragma warning(disable: 4127 4189 4505 4702) 131 template <
typename ENUM_TYPE,
int VALUE>
134 static ENUM_TYPE ToEnum() {
return (ENUM_TYPE)VALUE;}
183 const char *
what()
const throw() {
return (m_what.c_str());}
185 const std::string &
GetWhat()
const {
return m_what;}
187 void SetWhat(
const std::string &s) {m_what = s;}
194 ErrorType m_errorType;
238 OS_Error(
ErrorType errorType,
const std::string &s,
const std::string& operation,
int errorCode)
239 :
Exception(errorType, s), m_operation(operation), m_errorCode(errorCode) {}
247 std::string m_operation;
304 ValueTypeMismatch(
const std::string &name,
const std::type_info &stored,
const std::type_info &retrieving)
305 :
InvalidArgument(
"NameValuePairs: type mismatch for '" + name +
"', stored '" + stored.name() +
"', trying to retrieve '" + retrieving.name() +
"'")
306 , m_stored(stored), m_retrieving(retrieving) {}
317 const std::type_info &m_stored;
318 const std::type_info &m_retrieving;
327 return GetValue((std::string(
"ThisObject:")+
typeid(T).name()).c_str(),
object);
336 return GetValue((std::string(
"ThisPointer:")+
typeid(T).name()).c_str(), ptr);
363 bool result =
GetValue(name, value);
365 if (result) {
return value;}
373 {std::string result;
GetValue(
"ValueNames", result);
return result;}
404 CRYPTOPP_DLL
static void CRYPTOPP_API
ThrowIfTypeMismatch(
const char *name,
const std::type_info &stored,
const std::type_info &retrieving)
421 throw InvalidArgument(std::string(className) +
": missing required parameter '" + name +
"'");
436 throw InvalidArgument(std::string(className) +
": missing required parameter '" + name +
"'");
449 CRYPTOPP_DLL
virtual bool GetVoidValue(
const char *name,
const std::type_info &valueType,
void *pValue)
const =0;
465 bool GetVoidValue(
const char *name,
const std::type_info &valueType,
void *pValue)
const 466 {CRYPTOPP_UNUSED(name); CRYPTOPP_UNUSED(valueType); CRYPTOPP_UNUSED(pValue);
return false;}
471 ANONYMOUS_NAMESPACE_BEGIN
473 ANONYMOUS_NAMESPACE_END
476 #if CRYPTOPP_DOXYGEN_PROCESSING 498 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130) 513 #if CRYPTOPP_DOXYGEN_PROCESSING 521 DOCUMENTED_NAMESPACE_BEGIN(
Name)
523 DOCUMENTED_NAMESPACE_END
537 DOCUMENTED_NAMESPACE_BEGIN(
Weak)
539 DOCUMENTED_NAMESPACE_END
544 DOCUMENTED_NAMESPACE_BEGIN(
NaCl)
546 DOCUMENTED_NAMESPACE_END
551 DOCUMENTED_NAMESPACE_BEGIN(
Test)
553 DOCUMENTED_NAMESPACE_END
587 Algorithm(
bool checkSelfTestStatus =
true);
607 virtual size_t MinKeyLength()
const =0;
610 virtual size_t MaxKeyLength()
const =0;
613 virtual size_t DefaultKeyLength()
const =0;
623 virtual size_t GetValidKeyLength(
size_t keylength)
const =0;
630 {
return keylength == GetValidKeyLength(keylength);}
647 void SetKeyWithRounds(
const byte *key,
size_t length,
int rounds);
657 void SetKeyWithIV(
const byte *key,
size_t length,
const byte *iv,
size_t ivLength);
667 {SetKeyWithIV(key, length, iv, IVSize());}
689 virtual IV_Requirement IVRequirement()
const =0;
717 {
throw NotImplemented(GetAlgorithm().AlgorithmName() +
": this object doesn't support resynchronization");}
739 CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(ivLength);
740 throw NotImplemented(GetAlgorithm().AlgorithmName() +
": this object doesn't support resynchronization");
757 virtual const Algorithm & GetAlgorithm()
const =0;
764 virtual void UncheckedSetKey(
const byte *key,
unsigned int length,
const NameValuePairs ¶ms) =0;
769 void ThrowIfInvalidKeyLength(
size_t length);
776 void ThrowIfResynchronizable();
785 void ThrowIfInvalidIV(
const byte *iv);
790 size_t ThrowIfInvalidIVLength(
int length);
797 const byte * GetIVAndThrowIfInvalid(
const NameValuePairs ¶ms,
size_t &size);
801 inline void AssertValidKeyLength(
size_t length)
const 824 virtual void ProcessAndXorBlock(
const byte *inBlock,
const byte *xorBlock, byte *outBlock)
const =0;
835 {ProcessAndXorBlock(inBlock, NULLPTR, outBlock);}
844 {ProcessAndXorBlock(inoutBlock, NULLPTR, inoutBlock);}
848 virtual unsigned int BlockSize()
const =0;
853 virtual unsigned int OptimalDataAlignment()
const;
862 virtual bool IsForwardTransformation()
const =0;
872 BT_InBlockIsCounter=1,
874 BT_DontIncrementInOutPointers=2,
878 BT_ReverseDirection=8,
880 BT_AllowParallel=16};
890 virtual size_t AdvancedProcessBlocks(
const byte *inBlocks,
const byte *xorBlocks, byte *outBlocks,
size_t length, word32 flags)
const;
936 virtual unsigned int OptimalDataAlignment()
const;
945 virtual void ProcessData(byte *outString,
const byte *inString,
size_t length) =0;
959 virtual size_t ProcessLastBlock(byte *outString,
size_t outLength,
const byte *inString,
size_t inLength);
1016 {ProcessData(inoutString, inoutString, length);}
1024 {ProcessData(outString, inString, length);}
1030 {ProcessData(&input, &input, 1);
return input;}
1034 virtual bool IsRandomAccess()
const =0;
1043 CRYPTOPP_UNUSED(pos);
1045 throw NotImplemented(
"StreamTransformation: this object doesn't support random access");
1052 virtual bool IsSelfInverting()
const =0;
1057 virtual bool IsForwardTransformation()
const =0;
1080 virtual void Update(
const byte *input,
size_t length) =0;
1103 {TruncatedFinal(NULLPTR, 0);}
1130 virtual unsigned int OptimalDataAlignment()
const;
1142 {Update(input, length); Final(digest);}
1154 {
return TruncatedVerify(digest,
DigestSize());}
1169 virtual bool VerifyDigest(
const byte *digest,
const byte *input,
size_t length)
1170 {Update(input, length);
return Verify(digest);}
1177 virtual void TruncatedFinal(byte *digest,
size_t digestSize) =0;
1190 {Update(input, length); TruncatedFinal(digest, digestSize);}
1202 virtual bool TruncatedVerify(
const byte *digest,
size_t digestLength);
1219 {Update(input, length);
return TruncatedVerify(digest, digestLength);}
1226 void ThrowIfInvalidTruncatedSize(
size_t size)
const;
1234 const Algorithm & GetAlgorithm()
const {
return *
this;}
1242 const Algorithm & GetAlgorithm()
const {
return *
this;}
1250 const Algorithm & GetAlgorithm()
const {
return *
this;}
1280 explicit BadState(
const std::string &name,
const char *message) :
Exception(OTHER_ERROR, name +
": " + message) {}
1281 explicit BadState(
const std::string &name,
const char *
function,
const char *state) :
Exception(OTHER_ERROR, name +
": " +
function +
" was called before " + state) {}
1286 virtual lword MaxHeaderLength()
const =0;
1289 virtual lword MaxMessageLength()
const =0;
1302 void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0);
1306 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);
1311 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);
1323 virtual void UncheckedSpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength)
1324 {CRYPTOPP_UNUSED(headerLength); CRYPTOPP_UNUSED(messageLength); CRYPTOPP_UNUSED(footerLength);}
1345 CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);
1346 throw NotImplemented(
"RandomNumberGenerator: IncorporateEntropy not implemented");
1358 virtual byte GenerateByte();
1365 virtual unsigned int GenerateBit();
1375 virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL);
1384 virtual void GenerateBlock(byte *output,
size_t size);
1396 virtual void GenerateIntoBufferedTransformation(
BufferedTransformation &target,
const std::string &channel, lword length);
1400 virtual void DiscardBytes(
size_t n);
1406 template <
class IT>
void Shuffle(IT begin, IT end)
1409 for (; begin != end; ++begin)
1410 std::iter_swap(begin, begin + GenerateWord32(0, static_cast<word32>(end-begin-1)));
1433 virtual unsigned int GetMaxWaitObjectCount()
const =0;
1449 bool Wait(
unsigned long milliseconds,
CallStack const& callStack);
1497 size_t Put(byte inByte,
bool blocking=
true)
1498 {
return Put(&inByte, 1, blocking);}
1507 size_t Put(
const byte *inString,
size_t length,
bool blocking=
true)
1508 {
return Put2(inString, length, 0, blocking);}
1537 {size=0;
return NULLPTR;}
1552 {
return PutModifiable2(inString, length, 0, blocking);}
1560 {
return !!Put2(NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}
1573 size_t PutMessageEnd(
const byte *inString,
size_t length,
int propagation=-1,
bool blocking=
true)
1574 {
return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
1584 virtual size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking) =0;
1594 virtual size_t PutModifiable2(byte *inString,
size_t length,
int messageEnd,
bool blocking)
1595 {
return Put2(inString, length, messageEnd, blocking);}
1633 CRYPTOPP_UNUSED(parameters);
1634 throw NotImplemented(
"BufferedTransformation: this object can't be reinitialized");
1641 virtual bool IsolatedFlush(
bool hardFlush,
bool blocking) =0;
1647 {CRYPTOPP_UNUSED(blocking);
return false;}
1673 virtual bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true);
1683 virtual bool MessageSeriesEnd(
int propagation=-1,
bool blocking=
true);
1690 {CRYPTOPP_UNUSED(propagation);}
1705 virtual lword MaxRetrievable()
const;
1709 virtual bool AnyRetrievable()
const;
1715 virtual size_t Get(byte &outByte);
1722 virtual size_t Get(byte *outString,
size_t getMax);
1729 virtual size_t Peek(byte &outByte)
const;
1737 virtual size_t Peek(byte *outString,
size_t peekMax)
const;
1779 {TransferTo2(target, transferMax, channel);
return transferMax;}
1792 virtual lword Skip(lword skipMax=LWORD_MAX);
1804 {
return CopyRangeTo(target, 0, copyMax, channel);}
1817 {lword i = position; CopyRangeTo2(target, i, i+copyMax, channel);
return i-position;}
1825 virtual lword TotalBytesRetrievable()
const;
1831 virtual unsigned int NumberOfMessages()
const;
1836 virtual bool AnyMessages()
const;
1842 virtual bool GetNextMessage();
1849 virtual unsigned int SkipMessages(
unsigned int count=UINT_MAX);
1861 {TransferMessagesTo2(target, count, channel);
return count;}
1875 virtual void SkipAll();
1883 {TransferAllTo2(target, channel);}
1983 size_t ChannelPut(
const std::string &channel, byte inByte,
bool blocking=
true)
1984 {
return ChannelPut(channel, &inByte, 1, blocking);}
1993 size_t ChannelPut(
const std::string &channel,
const byte *inString,
size_t length,
bool blocking=
true)
1994 {
return ChannelPut2(channel, inString, length, 0, blocking);}
2004 {
return ChannelPutModifiable2(channel, inString, length, 0, blocking);}
2013 size_t ChannelPutWord16(
const std::string &channel, word16 value,
ByteOrder order=
BIG_ENDIAN_ORDER,
bool blocking=
true);
2022 size_t ChannelPutWord32(
const std::string &channel, word32 value,
ByteOrder order=
BIG_ENDIAN_ORDER,
bool blocking=
true);
2033 {
return !!ChannelPut2(channel, NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}
2044 size_t ChannelPutMessageEnd(
const std::string &channel,
const byte *inString,
size_t length,
int propagation=-1,
bool blocking=
true)
2045 {
return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
2058 virtual byte * ChannelCreatePutSpace(
const std::string &channel,
size_t &size);
2067 virtual size_t ChannelPut2(
const std::string &channel,
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
2076 virtual size_t ChannelPutModifiable2(
const std::string &channel, byte *inString,
size_t length,
int messageEnd,
bool blocking);
2086 virtual bool ChannelFlush(
const std::string &channel,
bool hardFlush,
int propagation=-1,
bool blocking=
true);
2097 virtual bool ChannelMessageSeriesEnd(
const std::string &channel,
int propagation=-1,
bool blocking=
true);
2102 virtual void SetRetrievalChannel(
const std::string &channel);
2137 throw NotImplemented(
"BufferedTransformation: this object is not attachable");
2148 static int DecrementPropagation(
int propagation)
2149 {
return propagation != 0 ? propagation - 1 : 0;}
2199 {
if (!Validate(rng, level))
throw InvalidMaterial(
"CryptoMaterial: this object contains invalid values");}
2211 {CRYPTOPP_UNUSED(bt);
throw NotImplemented(
"CryptoMaterial: this object does not support saving");}
2228 {CRYPTOPP_UNUSED(bt);
throw NotImplemented(
"CryptoMaterial: this object does not support loading");}
2244 CRYPTOPP_UNUSED(precomputationStorage);
CRYPTOPP_ASSERT(!SupportsPrecomputation());
2245 throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");
2253 {CRYPTOPP_UNUSED(storedPrecomputation);
CRYPTOPP_ASSERT(!SupportsPrecomputation());
throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");}
2260 {CRYPTOPP_UNUSED(storedPrecomputation);
CRYPTOPP_ASSERT(!SupportsPrecomputation());
throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");}
2266 #if (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) 2268 char m_sunCCworkaround;
2285 CRYPTOPP_UNUSED(rng); CRYPTOPP_UNUSED(params);
2286 throw NotImplemented(
"GeneratableCryptoMaterial: this object does not support key/parameter generation");
2337 {AccessMaterial().
Load(bt);}
2344 {GetMaterial().Save(bt);}
2359 {
return AccessPublicKey();}
2363 {
return GetPublicKey();}
2367 virtual PublicKey & AccessPublicKey() =0;
2427 virtual size_t MaxPlaintextLength(
size_t ciphertextLength)
const =0;
2432 virtual size_t CiphertextLength(
size_t plaintextLength)
const =0;
2439 virtual bool ParameterSupported(
const char *name)
const =0;
2477 const byte *plaintext,
size_t plaintextLength,
2511 const byte *ciphertext,
size_t ciphertextLength,
2624 {
throw NotImplemented(
"PK_MessageAccumulator: DigestSize() should not be called");}
2629 CRYPTOPP_UNUSED(digest); CRYPTOPP_UNUSED(digestSize);
2630 throw NotImplemented(
"PK_MessageAccumulator: TruncatedFinal() should not be called");
2651 virtual void InputRecoverableMessage(
PK_MessageAccumulator &messageAccumulator,
const byte *recoverableMessage,
size_t recoverableMessageLength)
const =0;
2678 virtual size_t SignMessage(
RandomNumberGenerator &rng,
const byte *message,
size_t messageLen, byte *signature)
const;
2689 virtual size_t SignMessageWithRecovery(
RandomNumberGenerator &rng,
const byte *recoverableMessage,
size_t recoverableMessageLength,
2690 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength, byte *signature)
const;
2714 virtual void InputSignature(
PK_MessageAccumulator &messageAccumulator,
const byte *signature,
size_t signatureLength)
const =0;
2734 virtual bool VerifyMessage(
const byte *message,
size_t messageLen,
2735 const byte *signature,
size_t signatureLen)
const;
2762 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
2763 const byte *signature,
size_t signatureLength)
const;
2778 virtual unsigned int AgreedValueLength()
const =0;
2782 virtual unsigned int PrivateKeyLength()
const =0;
2786 virtual unsigned int PublicKeyLength()
const =0;
2799 virtual void GeneratePublicKey(
RandomNumberGenerator &rng,
const byte *privateKey, byte *publicKey)
const =0;
2822 virtual bool Agree(byte *agreedValue,
const byte *privateKey,
const byte *otherPublicKey,
bool validateOtherPublicKey=
true)
const =0;
2837 virtual unsigned int AgreedValueLength()
const =0;
2841 virtual unsigned int StaticPrivateKeyLength()
const =0;
2845 virtual unsigned int StaticPublicKeyLength()
const =0;
2858 virtual void GenerateStaticPublicKey(
RandomNumberGenerator &rng,
const byte *privateKey, byte *publicKey)
const =0;
2867 virtual void GenerateStaticKeyPair(
RandomNumberGenerator &rng, byte *privateKey, byte *publicKey)
const;
2871 virtual unsigned int EphemeralPrivateKeyLength()
const =0;
2875 virtual unsigned int EphemeralPublicKeyLength()
const =0;
2888 virtual void GenerateEphemeralPublicKey(
RandomNumberGenerator &rng,
const byte *privateKey, byte *publicKey)
const =0;
2895 virtual void GenerateEphemeralKeyPair(
RandomNumberGenerator &rng, byte *privateKey, byte *publicKey)
const;
2913 virtual bool Agree(byte *agreedValue,
2914 const byte *staticPrivateKey,
const byte *ephemeralPrivateKey,
2915 const byte *staticOtherPublicKey,
const byte *ephemeralOtherPublicKey,
2916 bool validateStaticOtherPublicKey=
true)
const =0;
2942 class ProtocolSession
2949 ProtocolError(ErrorType errorType,
const std::string &s) :
Exception(errorType, s) {}
2954 class UnexpectedMethodCall :
public Exception 2957 UnexpectedMethodCall(
const std::string &s) :
Exception(OTHER_ERROR, s) {}
2960 virtual ~ProtocolSession() {}
2962 ProtocolSession() : m_rng(NULLPTR), m_throwOnProtocolError(true), m_validState(false) {}
2966 bool GetThrowOnProtocolError()
const {
return m_throwOnProtocolError;}
2967 void SetThrowOnProtocolError(
bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}
2969 bool HasValidState()
const {
return m_validState;}
2971 virtual bool OutgoingMessageAvailable()
const =0;
2972 virtual unsigned int GetOutgoingMessageLength()
const =0;
2973 virtual void GetOutgoingMessage(byte *message) =0;
2975 virtual bool LastMessageProcessed()
const =0;
2976 virtual void ProcessIncomingMessage(
const byte *message,
unsigned int messageLength) =0;
2980 void CheckAndHandleInvalidState()
const;
2981 void SetValidState(
bool valid) {m_validState = valid;}
2986 bool m_throwOnProtocolError, m_validState;
2989 class KeyAgreementSession :
public ProtocolSession
2992 virtual ~KeyAgreementSession() {}
2994 virtual unsigned int GetAgreedValueLength()
const =0;
2995 virtual void GetAgreedValue(byte *agreedValue)
const =0;
2998 class PasswordAuthenticatedKeyAgreementSession :
public KeyAgreementSession
3001 virtual ~PasswordAuthenticatedKeyAgreementSession() {}
3004 const byte *myId,
unsigned int myIdLength,
3005 const byte *counterPartyId,
unsigned int counterPartyIdLength,
3006 const byte *passwordOrVerifier,
unsigned int passwordOrVerifierLength);
3014 virtual ~PasswordAuthenticatedKeyAgreementDomain() {}
3020 virtual unsigned int GetPasswordVerifierLength(
const byte *password,
unsigned int passwordLength)
const =0;
3021 virtual void GeneratePasswordVerifier(
RandomNumberGenerator &rng,
const byte *userId,
unsigned int userIdLength,
const byte *password,
unsigned int passwordLength, byte *verifier)
const =0;
3023 enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};
3025 virtual bool IsValidRole(
unsigned int role) =0;
3026 virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(
unsigned int role)
const =0;
3130 return CRYPTOPP_VERSION;
3136 #if CRYPTOPP_MSC_VERSION 3137 # pragma warning(pop)
bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
Get a named value.
Base class for all exceptions thrown by the library.
int HeaderVersion()
Specifies the runtime version of the library.
Exception thrown when invalid crypto material is detected.
virtual void Precompute(unsigned int precomputationStorage)
Perform precomputation.
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
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.
Interface for message authentication codes.
ErrorType
Error types or categories.
container of wait objects
Interface for asymmetric algorithms.
virtual unsigned int MinIVLength() const
Provides the minimum size of an IV.
Namespace containing NaCl library functions.
virtual bool NeedsPrespecifiedDataLengths() const
Determines if data lengths must be specified prior to inputting data.
Interface for public-key encryptors and decryptors.
ByteOrder
Provides the byte ordering.
const char * what() const
Retrieves a C-string describing the exception.
virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
Check this object for errors.
The IV is set by the object.
The operating system reported an error.
Interface for authenticated encryption modes of operation.
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
const std::type_info & GetStoredTypeInfo() const
Provides the stored type.
virtual void Load(BufferedTransformation &bt)
Loads a key from a BufferedTransformation.
Exception(ErrorType errorType, const std::string &s)
Construct a new Exception.
Exception thrown when the object is in the wrong state for the operation.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to Crypto Parameters.
Interface for public-key signers.
Interface for public-key encryptors.
Converts an enumeration to a type suitable for use as a template parameter.
bool GetThisObject(T &object) const
Get a copy of this object or subobject.
bool CanUseRandomIVs() const
Determines if the object can use random IVs.
CipherDir
Specifies a direction for a cipher to operate.
DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Decrypt a fixed size ciphertext.
Flush(true) was called but it can't completely flush its buffers.
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.
virtual bool IsProbabilistic() const =0
Determines whether a signature scheme requires a random number generator.
ValueTypeMismatch(const std::string &name, const std::type_info &stored, const std::type_info &retrieving)
Construct a ValueTypeMismatch.
virtual bool AllowNonrecoverablePart() const =0
Determines whether the non-recoverable message part can be signed.
virtual Clonable * Clone() const
Copies this object.
EnumToType< ByteOrder, LITTLE_ENDIAN_ORDER > LittleEndian
Provides a constant for LittleEndian.
Library configuration file.
Interface for random number generators.
size_t messageLength
Recovered message length if isValidCoding is true, undefined otherwise.
virtual const PublicKey & GetPublicKey() const
Retrieves a reference to a Public Key.
virtual size_t SignatureLength() const =0
Provides the signature length if it only depends on the key.
Interface for private keys.
Interface for cloning objects.
virtual size_t FixedCiphertextLength() const
Provides the fixed ciphertext length, if one exists.
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
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
virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
Save precomputation for later use.
const std::type_info & GetRetrievingTypeInfo() const
Provides the retrieveing type.
virtual size_t MaxRecoverableLength() const =0
Provides the length of longest message that can be recovered.
void DoQuickSanityCheck() const
Perform a quick sanity check.
Interface for domains of simple key agreement protocols.
virtual unsigned int GetMaxWaitObjectCount() const =0
Maximum number of wait objects that this object can return.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to a Private Key.
bool CanUsePredictableIVs() const
Determines if the object can use random but possibly predictable IVs.
Returns a decoding results.
virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
Retrieve previously saved precomputation.
Exception thrown when trying to encrypt plaintext of invalid length.
Input data was received that did not conform to expected format.
Interface for public-key decryptors.
virtual void GetWaitObjects(WaitObjectContainer &container, CallStack const &callStack)=0
Retrieves waitable objects.
A method was called which was not implemented.
Exception throw when the private or public key is too short to sign or verify.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0
Check this object for errors.
bool operator!=(const DecodingResult &rhs) const
Compare two DecodingResult.
virtual unsigned int MaxIVLength() const
Provides the maximum size of an IV.
unsigned int DigestSize() const
virtual bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
Interface for encoding and decoding ASN1 objects.
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
DecodingResult()
Constructs a DecodingResult.
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.
bool operator==(const DecodingResult &rhs) const
Compare two DecodingResult.
Interface for asymmetric algorithms using public keys.
virtual unsigned int IVSize() const
Returns length of the IV accepted by this object.
virtual size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const =0
Provides the length of longest message that can be recovered from a signature of given length...
virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0
Get a named value.
Namespace containing testing and benchmark classes.
virtual bool CanIncorporateEntropy() const
Determines if a generator can accept additional entropy.
bool CanUseStructuredIVs() const
Determines if the object can use structured IVs.
Interface for public-key signers and verifiers.
const std::string & GetOperation() const
Retrieve the operating system API that reported the error.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
RandomNumberGenerator & NullRNG()
Random Number Generator that does not produce random numbers.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
int GetErrorCode() const
Retrieve the error code returned by the operating system.
const char * BlockSize()
int, in bytes
const unsigned long INFINITE_TIME
Represents infinite time.
ErrorType GetErrorType() const
Retrieves the error type for the exception.
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
Interface for all crypto algorithms.
Interface for accumulating messages to be signed or verified.
unsigned int DefaultIVLength() const
Provides the default size of an IV.
A decryption filter encountered invalid ciphertext.
Interface for key agreement algorithms.
Interface for retrieving values given their names.
const NameValuePairs g_nullNameValuePairs
An empty set of name-value pairs.
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.
virtual const CryptoParameters & GetCryptoParameters() const
Retrieves a reference to Crypto Parameters.
Interface for public-key signature verifiers.
void Shuffle(IT begin, IT end)
Randomly shuffle the specified array.
Debugging and diagnostic assertions.
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.
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.
virtual bool RecoverablePartFirst() const =0
Determines whether the recoverable part must be input before the non-recoverable part.
Interface for crypto prameters.
bool GetThisPointer(T *&ptr) const
Get a pointer to this object.
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.
int LibraryVersion(...)
Specifies the build-time version of the library.
Interface for public keys.
Crypto++ library namespace.
bool GetValue(const char *name, T &value) const
Get a named value.
The IV must be random and unpredictable.
bool IsResynchronizable() const
Determines if the object can be resynchronized.
Interface for domains of authenticated key agreement protocols.
void TruncatedFinal(byte *digest, size_t digestSize)
A method was called which was not implemented.
bool GetIntValue(const char *name, int &value) const
Get a named value with type int.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
virtual void BEREncode(BufferedTransformation &bt) const
Encode this object into a BufferedTransformation.
Error reading from input device or writing to output device.
virtual void Save(BufferedTransformation &bt) const
Saves a key to a BufferedTransformation.
virtual bool SupportsPrecomputation() const
Determines whether the object supports precomputation.
virtual lword MaxFooterLength() const
Provides the the maximum length of AAD.
virtual const PrivateKey & GetPrivateKey() const
Retrieves a reference to a Private Key.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to a Public Key.
virtual size_t MaxSignatureLength(size_t recoverablePartLength=0) const
Provides the maximum signature length produced given the length of the recoverable message part...
EnumToType< ByteOrder, BIG_ENDIAN_ORDER > BigEndian
Provides a constant for BigEndian.
void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
Namespace containing weak and wounded algorithms.
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
std::string GetValueNames() const
Get a list of value names that can be retrieved.
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
virtual size_t FixedMaxPlaintextLength() const
Provides the maximum plaintext length given a fixed ciphertext length.
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.
const std::string & GetWhat() const
Retrieves a string describing the exception.