Crypto++
8.4
Free C++ class library of cryptographic schemes
|
Go to the documentation of this file.
102 #ifndef CRYPTOPP_CRYPTLIB_H
103 #define CRYPTOPP_CRYPTLIB_H
109 #if CRYPTOPP_MSC_VERSION
110 # pragma warning(push)
111 # pragma warning(disable: 4127 4189 4505 4702)
134 template <
typename ENUM_TYPE,
int VALUE>
137 static ENUM_TYPE ToEnum() {
return static_cast<ENUM_TYPE
>(VALUE);}
186 const char *
what()
const throw() {
return (m_what.c_str());}
188 const std::string &
GetWhat()
const {
return m_what;}
190 void SetWhat(
const std::string &s) {m_what = s;}
197 ErrorType m_errorType;
263 OS_Error(
ErrorType errorType,
const std::string &s,
const std::string& operation,
int errorCode)
264 :
Exception(errorType, s), m_operation(operation), m_errorCode(errorCode) {}
272 std::string m_operation;
336 ValueTypeMismatch(
const std::string &name,
const std::type_info &stored,
const std::type_info &retrieving)
337 :
InvalidArgument(
"NameValuePairs: type mismatch for '" + name +
"', stored '" + stored.name() +
"', trying to retrieve '" + retrieving.name() +
"'")
338 , m_stored(stored), m_retrieving(retrieving) {}
349 const std::type_info &m_stored;
350 const std::type_info &m_retrieving;
359 return GetValue((std::string(
"ThisObject:")+
typeid(T).name()).c_str(),
object);
368 return GetValue((std::string(
"ThisPointer:")+
typeid(T).name()).c_str(), ptr);
395 bool result =
GetValue(name, value);
397 if (result) {
return value;}
405 {std::string result;
GetValue(
"ValueNames", result);
return result;}
471 throw InvalidArgument(std::string(className) +
": missing required parameter '" + name +
"'");
486 throw InvalidArgument(std::string(className) +
": missing required parameter '" + name +
"'");
499 CRYPTOPP_DLL
virtual bool GetVoidValue(
const char *name,
const std::type_info &valueType,
void *pValue)
const =0;
503 #if CRYPTOPP_DOXYGEN_PROCESSING
538 #if CRYPTOPP_DOXYGEN_PROCESSING
546 DOCUMENTED_NAMESPACE_BEGIN(
Name)
548 DOCUMENTED_NAMESPACE_END
561 DOCUMENTED_NAMESPACE_BEGIN(
Weak)
563 DOCUMENTED_NAMESPACE_END
568 DOCUMENTED_NAMESPACE_BEGIN(
NaCl)
570 DOCUMENTED_NAMESPACE_END
575 DOCUMENTED_NAMESPACE_BEGIN(
Test)
577 DOCUMENTED_NAMESPACE_END
673 {
return keylength == GetValidKeyLength(keylength);}
699 void SetKeyWithIV(
const byte *key,
size_t length,
const byte *iv,
size_t ivLength);
709 {SetKeyWithIV(key, length, iv, IVSize());}
762 {
throw NotImplemented(GetAlgorithm().AlgorithmName() +
": this object doesn't support resynchronization");}
784 CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(ivLength);
785 throw NotImplemented(GetAlgorithm().AlgorithmName() +
": this object doesn't support resynchronization");
802 virtual const Algorithm & GetAlgorithm()
const =0;
809 virtual void UncheckedSetKey(
const byte *key,
unsigned int length,
const NameValuePairs ¶ms) =0;
814 void ThrowIfInvalidKeyLength(
size_t length);
821 void ThrowIfResynchronizable();
830 void ThrowIfInvalidIV(
const byte *iv);
835 size_t ThrowIfInvalidIVLength(
int length);
842 const byte * GetIVAndThrowIfInvalid(
const NameValuePairs ¶ms,
size_t &size);
846 inline void AssertValidKeyLength(
size_t length)
const
880 {ProcessAndXorBlock(inBlock, NULLPTR, outBlock);}
889 {ProcessAndXorBlock(inoutBlock, NULLPTR, inoutBlock);}
917 BT_InBlockIsCounter=1,
919 BT_DontIncrementInOutPointers=2,
923 BT_ReverseDirection=8,
925 BT_AllowParallel=16};
990 virtual void ProcessData(
byte *outString,
const byte *inString,
size_t length) =0;
1004 virtual size_t ProcessLastBlock(
byte *outString,
size_t outLength,
const byte *inString,
size_t inLength);
1061 {ProcessData(inoutString, inoutString, length);}
1069 {ProcessData(outString, inString, length);}
1075 {ProcessData(&input, &input, 1);
return input;}
1088 CRYPTOPP_UNUSED(pos);
1090 throw NotImplemented(
"StreamTransformation: this object doesn't support random access");
1125 virtual void Update(
const byte *input,
size_t length) =0;
1148 {TruncatedFinal(NULLPTR, 0);}
1189 {Update(input, length); Final(digest);}
1201 {
return TruncatedVerify(digest,
DigestSize());}
1216 virtual bool VerifyDigest(
const byte *digest,
const byte *input,
size_t length)
1217 {Update(input, length);
return Verify(digest);}
1239 {Update(input, length); TruncatedFinal(digest, digestSize);}
1270 {Update(input, length);
return TruncatedVerify(digest, digestLength);}
1277 void ThrowIfInvalidTruncatedSize(
size_t size)
const;
1285 const Algorithm & GetAlgorithm()
const {
return *
this;}
1293 const Algorithm & GetAlgorithm()
const {
return *
this;}
1301 const Algorithm & GetAlgorithm()
const {
return *
this;}
1331 explicit BadState(
const std::string &name,
const char *message) :
Exception(OTHER_ERROR, name +
": " + message) {}
1332 explicit BadState(
const std::string &name,
const char *
function,
const char *state) :
Exception(OTHER_ERROR, name +
": " +
function +
" was called before " + state) {}
1377 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);
1394 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);
1406 virtual void UncheckedSpecifyDataLengths(
lword headerLength,
lword messageLength,
lword footerLength)
1407 {CRYPTOPP_UNUSED(headerLength); CRYPTOPP_UNUSED(messageLength); CRYPTOPP_UNUSED(footerLength);}
1432 CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);
1433 throw NotImplemented(
"RandomNumberGenerator: IncorporateEntropy not implemented");
1493 template <
class IT>
void Shuffle(IT begin, IT end)
1496 for (; begin != end; ++begin)
1497 std::iter_swap(begin, begin + GenerateWord32(0,
static_cast<word32>(end-begin-1)));
1532 return keylength == GetValidDerivedLength(keylength);
1559 virtual const Algorithm & GetAlgorithm()
const =0;
1564 void ThrowIfInvalidDerivedKeyLength(
size_t length)
const;
1581 class WaitObjectContainer;
1602 virtual void GetWaitObjects(WaitObjectContainer &container, CallStack
const& callStack) =0;
1608 bool Wait(
unsigned long milliseconds, CallStack
const& callStack);
1656 size_t Put(
byte inByte,
bool blocking=
true)
1657 {
return Put(&inByte, 1, blocking);}
1666 size_t Put(
const byte *inString,
size_t length,
bool blocking=
true)
1667 {
return Put2(inString, length, 0, blocking);}
1704 {size=0;
return NULLPTR;}
1719 {
return PutModifiable2(inString, length, 0, blocking);}
1727 {
return !!Put2(NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}
1740 size_t PutMessageEnd(
const byte *inString,
size_t length,
int propagation=-1,
bool blocking=
true)
1741 {
return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
1751 virtual size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking) =0;
1761 virtual size_t PutModifiable2(
byte *inString,
size_t length,
int messageEnd,
bool blocking)
1762 {
return Put2(inString, length, messageEnd, blocking);}
1800 CRYPTOPP_UNUSED(parameters);
1801 throw NotImplemented(
"BufferedTransformation: this object can't be reinitialized");
1816 {CRYPTOPP_UNUSED(blocking);
return false;}
1847 virtual bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true);
1865 {CRYPTOPP_UNUSED(propagation);}
1894 virtual size_t Get(
byte &outByte);
1901 virtual size_t Get(
byte *outString,
size_t getMax);
1908 virtual size_t Peek(
byte &outByte)
const;
1916 virtual size_t Peek(
byte *outString,
size_t peekMax)
const;
1975 {TransferTo2(target, transferMax, channel);
return transferMax;}
1997 {
return CopyRangeTo(target, 0, copyMax, channel);}
2010 {
lword i = position; CopyRangeTo2(target, i, i+copyMax, channel);
return i-position;}
2055 {TransferMessagesTo2(target, count, channel);
return count;}
2077 {TransferAllTo2(target, channel);}
2177 size_t ChannelPut(
const std::string &channel,
byte inByte,
bool blocking=
true)
2178 {
return ChannelPut(channel, &inByte, 1, blocking);}
2187 size_t ChannelPut(
const std::string &channel,
const byte *inString,
size_t length,
bool blocking=
true)
2188 {
return ChannelPut2(channel, inString, length, 0, blocking);}
2198 {
return ChannelPutModifiable2(channel, inString, length, 0, blocking);}
2236 {
return !!ChannelPut2(channel, NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}
2247 size_t ChannelPutMessageEnd(
const std::string &channel,
const byte *inString,
size_t length,
int propagation=-1,
bool blocking=
true)
2248 {
return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
2270 virtual size_t ChannelPut2(
const std::string &channel,
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
2279 virtual size_t ChannelPutModifiable2(
const std::string &channel,
byte *inString,
size_t length,
int messageEnd,
bool blocking);
2289 virtual bool ChannelFlush(
const std::string &channel,
bool hardFlush,
int propagation=-1,
bool blocking=
true);
2341 throw NotImplemented(
"BufferedTransformation: this object is not attachable");
2352 static int DecrementPropagation(
int propagation)
2353 {
return propagation != 0 ? propagation - 1 : 0;}
2411 {
if (!Validate(rng, level))
throw InvalidMaterial(
"CryptoMaterial: this object contains invalid values");}
2423 {CRYPTOPP_UNUSED(bt);
throw NotImplemented(
"CryptoMaterial: this object does not support saving");}
2440 {CRYPTOPP_UNUSED(bt);
throw NotImplemented(
"CryptoMaterial: this object does not support loading");}
2456 CRYPTOPP_UNUSED(precomputationStorage);
CRYPTOPP_ASSERT(!SupportsPrecomputation());
2457 throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");
2465 {CRYPTOPP_UNUSED(storedPrecomputation);
CRYPTOPP_ASSERT(!SupportsPrecomputation());
throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");}
2472 {CRYPTOPP_UNUSED(storedPrecomputation);
CRYPTOPP_ASSERT(!SupportsPrecomputation());
throw NotImplemented(
"CryptoMaterial: this object does not support precomputation");}
2478 #if defined(__SUNPRO_CC)
2483 char m_sunCCworkaround;
2504 CRYPTOPP_UNUSED(rng); CRYPTOPP_UNUSED(params);
2505 throw NotImplemented(
"GeneratableCryptoMaterial: this object does not support key/parameter generation");
2561 {AccessMaterial().
Load(bt);}
2568 {GetMaterial().Save(bt);}
2583 {
return AccessPublicKey();}
2587 {
return GetPublicKey();}
2701 const byte *plaintext,
size_t plaintextLength,
2735 const byte *ciphertext,
size_t ciphertextLength,
2848 {
throw NotImplemented(
"PK_MessageAccumulator: DigestSize() should not be called");}
2853 CRYPTOPP_UNUSED(digest); CRYPTOPP_UNUSED(digestSize);
2854 throw NotImplemented(
"PK_MessageAccumulator: TruncatedFinal() should not be called");
2914 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
byte *signature)
const;
2959 const byte *signature,
size_t signatureLen)
const;
2986 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
2987 const byte *signature,
size_t signatureLength)
const;
3046 virtual bool Agree(
byte *agreedValue,
const byte *privateKey,
const byte *otherPublicKey,
bool validateOtherPublicKey=
true)
const =0;
3138 const byte *staticPrivateKey,
const byte *ephemeralPrivateKey,
3139 const byte *staticOtherPublicKey,
const byte *ephemeralOtherPublicKey,
3140 bool validateStaticOtherPublicKey=
true)
const =0;
3166 class ProtocolSession
3173 ProtocolError(ErrorType errorType,
const std::string &s) :
Exception(errorType, s) {}
3178 class UnexpectedMethodCall :
public Exception
3181 UnexpectedMethodCall(
const std::string &s) :
Exception(OTHER_ERROR, s) {}
3184 virtual ~ProtocolSession() {}
3186 ProtocolSession() : m_rng(NULLPTR), m_throwOnProtocolError(true), m_validState(false) {}
3190 bool GetThrowOnProtocolError()
const {
return m_throwOnProtocolError;}
3191 void SetThrowOnProtocolError(
bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}
3193 bool HasValidState()
const {
return m_validState;}
3195 virtual bool OutgoingMessageAvailable()
const =0;
3196 virtual unsigned int GetOutgoingMessageLength()
const =0;
3197 virtual void GetOutgoingMessage(
byte *message) =0;
3199 virtual bool LastMessageProcessed()
const =0;
3200 virtual void ProcessIncomingMessage(
const byte *message,
unsigned int messageLength) =0;
3204 void CheckAndHandleInvalidState()
const;
3205 void SetValidState(
bool valid) {m_validState = valid;}
3210 bool m_throwOnProtocolError, m_validState;
3213 class KeyAgreementSession :
public ProtocolSession
3216 virtual ~KeyAgreementSession() {}
3218 virtual unsigned int GetAgreedValueLength()
const =0;
3219 virtual void GetAgreedValue(
byte *agreedValue)
const =0;
3222 class PasswordAuthenticatedKeyAgreementSession :
public KeyAgreementSession
3225 virtual ~PasswordAuthenticatedKeyAgreementSession() {}
3228 const byte *myId,
unsigned int myIdLength,
3229 const byte *counterPartyId,
unsigned int counterPartyIdLength,
3230 const byte *passwordOrVerifier,
unsigned int passwordOrVerifierLength);
3238 virtual ~PasswordAuthenticatedKeyAgreementDomain() {}
3244 virtual unsigned int GetPasswordVerifierLength(
const byte *password,
unsigned int passwordLength)
const =0;
3245 virtual void GeneratePasswordVerifier(
RandomNumberGenerator &rng,
const byte *userId,
unsigned int userIdLength,
const byte *password,
unsigned int passwordLength,
byte *verifier)
const =0;
3247 enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};
3249 virtual bool IsValidRole(
unsigned int role) =0;
3250 virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(
unsigned int role)
const =0;
3358 #if CRYPTOPP_MSC_VERSION
3359 # pragma warning(pop)
bool Wait(unsigned long milliseconds, CallStack const &callStack)
Wait on this object.
virtual void BEREncode(BufferedTransformation &bt) const
Encode this object into a BufferedTransformation.
CannotFlush(const std::string &s)
Construct an CannotFlush.
Interface for asymmetric algorithms.
Interface for public-key encryptors.
virtual lword MaxHeaderLength() const =0
Provides the maximum length of AAD that can be input.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms=g_nullNameValuePairs)
Sets or reset the key of this object.
Algorithm(bool checkSelfTestStatus=true)
Interface for all crypto algorithms.
@ UNPREDICTABLE_RANDOM_IV
The IV must be random and unpredictable.
bool GetThisObject(T &object) const
Get a copy of this object or subobject.
virtual size_t FixedMaxPlaintextLength() const
Provides the maximum plaintext length given a fixed ciphertext length.
virtual const CryptoMaterial & GetMaterial() const =0
Retrieves a reference to CryptoMaterial.
virtual unsigned int PublicKeyLength() const =0
Provides the size of the public key.
Interface for private keys.
Converts an enumeration to a type suitable for use as a template parameter.
Interface for public-key encryptors and decryptors.
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
A method was called which was not implemented.
virtual unsigned int EphemeralPrivateKeyLength() const =0
Provides the size of ephemeral private key.
Interface for public-key signers and verifiers.
const std::type_info & GetStoredTypeInfo() const
Provides the stored type.
ErrorType GetErrorType() const
Retrieves the error type for the exception.
Interface for crypto prameters.
Interface for domains of simple key agreement protocols.
virtual unsigned int AgreedValueLength() const =0
Provides the size of the agreed value.
CRYPTOPP_DLL void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
The operating system reported an error.
@ BIG_ENDIAN_ORDER
byte order is big-endian
Debugging and diagnostic assertions.
virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv)
Retrieves a secure IV for the next message.
Interface for encoding and decoding ASN1 objects.
@ DECRYPTION
the cipher is performing decryption
const CryptoMaterial & GetMaterial() const
Retrieves a reference to a Private Key.
virtual unsigned int StaticPublicKeyLength() const =0
Provides the size of the static public key.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to Crypto Parameters.
virtual size_t MinDerivedKeyLength() const
Determine minimum number of bytes.
virtual size_t SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength, const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const
Sign a recoverable message.
virtual bool AllowNonrecoverablePart() const =0
Determines whether the non-recoverable message part can be signed.
const unsigned long INFINITE_TIME
Represents infinite time.
Interface for all crypto algorithms.
CryptoMaterial & AccessMaterial()
Retrieves a reference to a Private Key.
virtual CRYPTOPP_DLL bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0
Get a named value.
CRYPTOPP_DLL std::string GetValueNames() const
Get a list of value names that can be retrieved.
Exception thrown when the object is in the wrong state for the operation.
virtual IV_Requirement IVRequirement() const =0
Minimal requirement for secure IVs.
static CRYPTOPP_DLL void ThrowIfTypeMismatch(const char *name, const std::type_info &stored, const std::type_info &retrieving)
Ensures an expected name and type is present.
virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
Check this object for errors.
virtual size_t SignatureLength() const =0
Provides the signature length if it only depends on the key.
CRYPTOPP_DLL bool GetWord64Value(const char *name, word64 &value) const
Get a named value with type word64.
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode.
Interface for algorithms that take byte strings as keys.
const char * DigestSize()
int, in bytes
Interface for cloning objects.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
virtual bool VerifyMessage(const byte *message, size_t messageLen, const byte *signature, size_t signatureLen) const
Check whether input signature is a valid signature for input message.
Exception thrown when trying to encrypt plaintext of invalid length.
virtual unsigned int MaxIVLength() const
Provides the maximum size of an IV.
virtual DecodingResult RecoverMessage(byte *recoveredMessage, const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, const byte *signature, size_t signatureLength) const
Recover a message from its signature.
virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0
Provides the maximum length of plaintext for a given ciphertext length.
const char * what() const
Retrieves a C-string describing the exception.
ValueTypeMismatch(const std::string &name, const std::type_info &stored, const std::type_info &retrieving)
Construct a ValueTypeMismatch.
CRYPTOPP_DLL RandomNumberGenerator & NullRNG()
Random Number Generator that does not produce random numbers.
virtual bool IsProbabilistic() const =0
Determines whether a signature scheme requires a random number generator.
unsigned int DigestSize() const
void TruncatedFinal(byte *digest, size_t digestSize)
@ LITTLE_ENDIAN_ORDER
byte order is little-endian
Interface for public-key decryptors.
virtual void Precompute(unsigned int precomputationStorage)
Perform precomputation.
@ INVALID_DATA_FORMAT
Input data was received that did not conform to expected format.
@ ENCRYPTION
the cipher is performing encryption
virtual bool ParameterSupported(const char *name) const =0
Determines whether this object supports the use of a named parameter.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
virtual size_t DefaultKeyLength() const =0
Returns default key length.
virtual size_t MinKeyLength() const =0
Returns smallest valid key length.
Interface for objects that can be waited on.
unsigned long long word64
64-bit unsigned datatype
virtual void GetWaitObjects(WaitObjectContainer &container, CallStack const &callStack)=0
Retrieves waitable objects.
Exception throw when the private or public key is too short to sign or verify.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate private/public key pair.
void DoQuickSanityCheck() const
Perform a quick sanity check.
unsigned int word32
32-bit unsigned datatype
Interface for domains of authenticated key agreement protocols.
virtual bool CanIncorporateEntropy() const
Determines if a generator can accept additional entropy.
int LibraryVersion(...)
Specifies the build-time version of the library.
@ INVALID_ARGUMENT
An invalid argument was detected.
virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
Retrieve previously saved precomputation.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
virtual bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
virtual unsigned int StaticPrivateKeyLength() const =0
Provides the size of the static private key.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
CRYPTOPP_DLL BufferedTransformation & TheBitBucket()
An input discarding BufferedTransformation.
virtual Clonable * Clone() const
Copies this object.
virtual size_t GetValidDerivedLength(size_t keylength) const =0
Returns a valid key length for the derivation function.
Interface for random number generators.
CipherDir
Specifies a direction for a cipher to operate.
void SetErrorType(ErrorType errorType)
Sets the error type for the exceptions.
const std::type_info & GetRetrievingTypeInfo() const
Provides the retrieveing type.
IV_Requirement
Secure IVs requirements as enumerated values.
Exception throw when the private or public key has a length that can't be used.
virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0
Check this object for errors.
size_t messageLength
Recovered message length if isValidCoding is true, undefined otherwise.
virtual size_t MaxRecoverableLength() const =0
Provides the length of longest message that can be recovered.
Interface for public-key signers.
virtual size_t MaxDerivedKeyLength() const
Determine maximum number of bytes.
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
virtual unsigned int GenerateBit()
Generate new random bit and return it.
Thrown when an unexpected type is encountered.
virtual size_t MaxKeyLength() const =0
Returns largest valid key length.
Interface for key agreement algorithms.
Base class for all exceptions thrown by the library.
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
virtual void BERDecode(BufferedTransformation &bt)=0
Decode this object from a BufferedTransformation.
virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const
Sign a message.
InvalidCiphertext(const std::string &s)
Construct an InvalidCiphertext.
Interface for asymmetric algorithms using private keys.
virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
Save precomputation for later use.
virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a static private/public key pair.
int HeaderVersion()
Specifies the runtime version of the library.
ErrorType
Error types or categories.
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)
Decrypts and verifies a MAC in one call.
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
virtual CryptoParameters & AccessCryptoParameters()=0
Retrieves a reference to Crypto Parameters.
EnumToType< ByteOrder, BIG_ENDIAN_ORDER > BigEndian
Provides a constant for BigEndian.
const CryptoMaterial & GetMaterial() const
Retrieves a reference to a Public Key.
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 size_t DeriveKey(byte *derived, size_t derivedLen, const byte *secret, size_t secretLen, const NameValuePairs ¶ms=g_nullNameValuePairs) const =0
Derive a key from a seed.
Interface for public keys.
Interface for accumulating messages to be signed or verified.
virtual bool SupportsPrecomputation() const
Determines whether the object supports precomputation.
Returns a decoding results.
virtual DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
Decrypt a byte string.
bool IsResynchronizable() const
Determines if the object can be resynchronized.
DecodingResult()
Constructs a DecodingResult.
@ INTERNALLY_GENERATED_IV
The IV is set by the object.
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0
Create a new HashTransformation to accumulate the message to be signed.
Namespace containing NaCl library functions.
virtual unsigned int IVSize() const
Returns length of the IV accepted by this object.
@ DATA_INTEGRITY_CHECK_FAILED
Data integerity check, such as CRC or MAC, failed.
virtual void SetParameters(const NameValuePairs ¶ms)
Set or change parameters.
ByteOrder
Provides the byte ordering.
DecodingResult(size_t len)
Constructs a DecodingResult.
virtual size_t FixedCiphertextLength() const
Provides the fixed ciphertext length, if one exists.
virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0
Input a recoverable message to an accumulator.
virtual bool NeedsPrespecifiedDataLengths() const
Determines if data lengths must be specified prior to inputting data.
bool operator==(const DecodingResult &rhs) const
Compare two DecodingResult.
CRYPTOPP_DLL bool GetIntValue(const char *name, int &value) const
Get a named value with type int.
OS_Error(ErrorType errorType, const std::string &s, const std::string &operation, int errorCode)
Construct an OS_Error.
Namespace containing testing and benchmark classes.
bool operator!=(const DecodingResult &rhs) const
Compare two DecodingResult.
void SetKeyWithRounds(const byte *key, size_t length, int rounds)
Sets or reset the key of this object.
CryptoMaterial & AccessMaterial()
Retrieves a reference to Crypto Parameters.
CRYPTOPP_DLL word64 GetWord64ValueWithDefault(const char *name, word64 defaultValue) const
Get a named value with type word64, with default.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Decrypt a fixed size ciphertext.
const std::string & GetWhat() const
Retrieves a string describing the exception.
int GetErrorCode() const
Retrieve the error code returned by the operating system.
CryptoMaterial & AccessMaterial()
Retrieves a reference to a Public Key.
virtual void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
Encrypt a byte string.
bool CanUsePredictableIVs() const
Determines if the object can use random but possibly predictable IVs.
virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL)
Generate a random 32 bit word in the range min to max, inclusive.
virtual size_t GetValidKeyLength(size_t keylength) const =0
Returns a valid key length for the algorithm.
virtual bool IsValidDerivedLength(size_t keylength) const
Returns whether keylength is a valid key length.
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
virtual bool Agree(byte *agreedValue, const byte *staticPrivateKey, const byte *ephemeralPrivateKey, const byte *staticOtherPublicKey, const byte *ephemeralOtherPublicKey, bool validateStaticOtherPublicKey=true) const =0
Derive agreed value.
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)
Encrypts and calculates a MAC in one call.
void Shuffle(IT begin, IT end)
Randomly shuffle the specified array.
virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const
Recover a message from its signature.
#define CRYPTOPP_VERSION
Full library version.
word64 lword
Large word type.
virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs ¶ms=g_nullNameValuePairs)
Generate a random key or crypto parameters.
void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize)
Generate a random key or crypto parameters.
EnumToType< ByteOrder, LITTLE_ENDIAN_ORDER > LittleEndian
Provides a constant for LittleEndian.
Interface for asymmetric algorithms using public keys.
@ CANNOT_FLUSH
BufferedTransformation received a Flush(true) signal but can't flush buffers.
virtual const CryptoParameters & GetCryptoParameters() const
Retrieves a reference to Crypto Parameters.
virtual void GeneratePublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0
Generate a public key from a private key in this domain.
virtual std::string AlgorithmName() const =0
Provides the name of this algorithm.
An invalid argument was detected.
bool CanUseStructuredIVs() const
Determines if the object can use structured IVs.
Interface for key derivation functions.
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
Interface for crypto material.
Interface for certificates.
virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate static private key in this domain.
virtual unsigned int MinIVLength() const
Provides the minimum size of an IV.
virtual void AssignFrom(const NameValuePairs &source)=0
Assign values to this object.
void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0)
Prescribes the data lengths.
virtual const PublicKey & GetPublicKey() const
Retrieves a reference to a Public Key.
virtual bool RecoverablePartFirst() const =0
Determines whether the recoverable part must be input before the non-recoverable part.
virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new decryption filter.
Interface for public-key signature verifiers.
@ IO_ERROR
Error reading from input device or writing to output device.
const std::string & GetOperation() const
Retrieve the operating system API that reported the error.
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
virtual byte GenerateByte()
Generate new random byte and return it.
Namespace containing value name definitions.
Crypto++ library namespace.
unsigned int DefaultIVLength() const
Provides the default size of an IV.
virtual size_t CiphertextLength(size_t plaintextLength) const =0
Calculate the length of ciphertext given length of plaintext.
virtual lword MaxFooterLength() const
Provides the the maximum length of AAD.
virtual void GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0
Generate ephemeral public key.
virtual lword MaxMessageLength() const =0
Provides the maximum length of encrypted data.
bool GetValue(const char *name, T &value) const
Get a named value.
void SetWhat(const std::string &s)
Sets the error string for the exception.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength)
Sets or reset the key of this object.
#define CRYPTOPP_API
Win32 calling convention.
@ NOT_IMPLEMENTED
A method was called which was not implemented.
InvalidArgument(const std::string &s)
Construct an InvalidArgument.
Interface for crypto material.
Library configuration file.
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0
Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulat...
Interface for one direction (encryption or decryption) of a block cipher.
virtual const PrivateKey & GetPrivateKey() const
Retrieves a reference to a Private Key.
virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a private/public key pair.
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
virtual void Load(BufferedTransformation &bt)
Loads a key from a BufferedTransformation.
bool isValidCoding
Flag to indicate the decoding is valid.
Exception thrown when invalid crypto material is detected.
virtual void GenerateStaticPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0
Generate a static public key from a private key in this domain.
virtual void Save(BufferedTransformation &bt) const
Saves a key to a BufferedTransformation.
Interface for message authentication codes.
virtual CryptoMaterial & AccessMaterial()=0
Retrieves a reference to CryptoMaterial.
Exception thrown when an ASN.1 BER decoing error is encountered.
virtual std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0
Input signature into a message accumulator.
Exception(ErrorType errorType, const std::string &s)
Construct a new Exception.
virtual unsigned int GetMaxWaitObjectCount() const =0
Maximum number of wait objects that this object can return.
virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0
Recover a message from its signature.
CRYPTOPP_DLL int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
virtual bool Agree(byte *agreedValue, const byte *privateKey, const byte *otherPublicKey, bool validateOtherPublicKey=true) const =0
Derive agreed value.
virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const
Check whether messageAccumulator contains a valid signature and message.
virtual unsigned int EphemeralPublicKeyLength() const =0
Provides the size of ephemeral public key.
virtual void DEREncode(BufferedTransformation &bt) const =0
Encode this object into a BufferedTransformation.
Namespace containing weak and wounded algorithms.
virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate ephemeral private key.
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
bool CanUseRandomIVs() const
Determines if the object can use random IVs.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv)
Sets or reset the key of this object.
virtual PublicKey & AccessPublicKey()=0
Retrieves a reference to a Public Key.
const lword LWORD_MAX
Large word type max value.
Interface for retrieving values given their names.
unsigned short word16
16-bit unsigned datatype
virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new encryption filter.
virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate private key in this domain.
bool GetThisPointer(T *&ptr) const
Get a pointer to this object.
virtual unsigned int AgreedValueLength() const =0
Provides the size of the agreed value.
virtual size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0
Sign and restart messageAccumulator.
virtual unsigned int PrivateKeyLength() const =0
Provides the size of the private key.
Multiple precision integer with arithmetic operations.
NotImplemented(const std::string &s)
Construct an NotImplemented.
@ RANDOM_IV
The IV must be random and possibly predictable.
Flush(true) was called but it can't completely flush its buffers.
virtual PrivateKey & AccessPrivateKey()=0
Retrieves a reference to a Private Key.
Interface for password based key derivation functions.
virtual size_t MaxSignatureLength(size_t recoverablePartLength=0) const
Provides the maximum signature length produced given the length of the recoverable message part.
Interface for authenticated encryption modes of operation.
A decryption filter encountered invalid ciphertext.