6 #if CRYPTOPP_MSC_VERSION
7 # pragma warning(disable: 4127 4189 4459)
10 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
11 # pragma GCC diagnostic ignored "-Wunused-value"
12 # pragma GCC diagnostic ignored "-Wunused-variable"
13 # pragma GCC diagnostic ignored "-Wunused-parameter"
16 #ifndef CRYPTOPP_IMPORTS
36 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
51 throw SelfTestFailure(
"Cryptographic algorithms are disabled before the power-up self tests are performed.");
54 throw SelfTestFailure(
"Cryptographic algorithms are disabled after a power-up self test failed.");
60 this->ThrowIfInvalidKeyLength(length);
61 this->UncheckedSetKey(key,
static_cast<unsigned int>(length), params);
74 void SimpleKeyingInterface::ThrowIfInvalidKeyLength(
size_t length)
80 void SimpleKeyingInterface::ThrowIfResynchronizable()
83 throw InvalidArgument(GetAlgorithm().AlgorithmName() +
": this object requires an IV");
86 void SimpleKeyingInterface::ThrowIfInvalidIV(
const byte *iv)
89 throw InvalidArgument(GetAlgorithm().AlgorithmName() +
": this object cannot use a null IV");
92 size_t SimpleKeyingInterface::ThrowIfInvalidIVLength(
int length)
96 size =
static_cast<size_t>(
IVSize());
102 size =
static_cast<size_t>(length);
107 const byte * SimpleKeyingInterface::GetIVAndThrowIfInvalid(
const NameValuePairs ¶ms,
size_t &size)
110 const byte *iv = NULLPTR;
118 iv = ivWithLength.
begin();
119 ThrowIfInvalidIV(iv);
120 size = ThrowIfInvalidIVLength(
static_cast<int>(ivWithLength.
size()));
124 ThrowIfInvalidIV(iv);
125 size =
static_cast<size_t>(
IVSize());
129 ThrowIfResynchronizable();
147 const unsigned int blockSize =
BlockSize();
149 size_t xorIncrement = xorBlocks ? blockSize : 0;
154 inBlocks =
PtrAdd(inBlocks, length - blockSize);
155 xorBlocks =
PtrAdd(xorBlocks, length - blockSize);
156 outBlocks =
PtrAdd(outBlocks, length - blockSize);
157 inIncrement = 0-inIncrement;
158 xorIncrement = 0-xorIncrement;
159 outIncrement = 0-outIncrement;
163 const bool xorFlag = xorBlocks && (flags &
BT_XorInput);
164 while (length >= blockSize)
169 xorbuf(outBlocks, xorBlocks, inBlocks, blockSize);
179 const_cast<byte *
>(inBlocks)[blockSize-1]++;
181 inBlocks =
PtrAdd(inBlocks, inIncrement);
182 outBlocks =
PtrAdd(outBlocks, outIncrement);
183 xorBlocks =
PtrAdd(xorBlocks, xorIncrement);
192 return GetAlignmentOf<word32>();
197 return GetAlignmentOf<word32>();
202 return GetAlignmentOf<word32>();
212 else if (length != 0)
224 outLength = inLength;
227 else if (inLength != 0)
244 UncheckedSpecifyDataLengths(headerLength, messageLength, footerLength);
251 Update(header, headerLength);
260 Update(header, headerLength);
285 const word32 range = max-min;
293 value =
Crop(value, maxBits);
294 }
while (value > range);
313 CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);
331 (void)target.
ChannelPut(channel, buffer, len);
343 return static_cast<size_t>(-1);
346 void KeyDerivationFunction::ThrowIfInvalidDerivedLength(
size_t length)
const
353 CRYPTOPP_UNUSED(params);
367 #if defined(CRYPTOPP_DOXYGEN_PROCESSING)
379 CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(size);
380 throw NotImplemented(
"NullRNG: NullRNG should only be passed to functions that don't need to generate random bytes");
383 #if defined(CRYPTOPP_DOXYGEN_PROCESSING)
396 Clonable* Clone ()
const {
return NULLPTR; }
408 ThrowIfInvalidTruncatedSize(digestLength);
414 void HashTransformation::ThrowIfInvalidTruncatedSize(
size_t size)
const
435 CRYPTOPP_UNUSED(propagation);
442 CRYPTOPP_UNUSED(propagation);
449 CRYPTOPP_UNUSED(propagation);
456 byte* space = NULLPTR;
468 size =
Put2(inString, length, messageEnd, blocking);
480 size =
ChannelPut2(channel, inString, length, messageEnd, blocking);
488 result =
Flush(hardFlush, propagation, blocking);
522 result =
Peek(b) != 0;
533 size =
Get(&outByte, 1);
556 size =
Peek(&outByte, 1);
568 size = (size_t)
CopyTo(arraySink, peekMax);
595 unsigned int size = 0;
627 unsigned int size = 0;
641 unsigned int maxMessages = messageCount;
642 for (messageCount=0; messageCount < maxMessages &&
AnyMessages(); messageCount++)
645 lword transferredBytes;
649 transferredBytes = LWORD_MAX;
650 blockedBytes =
TransferTo2(target, transferredBytes, channel, blocking);
651 if (blockedBytes > 0)
667 unsigned int size = 0;
692 unsigned int messageCount;
695 messageCount = UINT_MAX;
700 while (messageCount != 0);
705 byteCount = ULONG_MAX;
706 size_t blockedBytes =
TransferTo2(target, byteCount, channel, blocking);
710 while (byteCount != 0);
735 PutWord(
false, order, m_buf, value);
736 return ChannelPut(channel, m_buf, 2, blocking);
741 PutWord(
false, order, m_buf, value);
742 return ChannelPut(channel, m_buf, 4, blocking);
756 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
757 # pragma GCC diagnostic push
758 # pragma GCC diagnostic ignored "-Wconversion"
759 # pragma GCC diagnostic ignored "-Wsign-conversion"
764 byte buf[2] = {0, 0};
765 size_t len =
Peek(buf, 2);
768 value = (buf[0] << 8) | buf[1];
770 value = (buf[1] << 8) | buf[0];
777 byte buf[4] = {0, 0, 0, 0};
778 size_t len =
Peek(buf, 4);
781 value = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf [3];
783 value = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf [0];
789 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
790 # pragma GCC diagnostic pop
820 : m_rng(rng), m_encryptor(encryptor), m_parameters(parameters)
825 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
828 m_plaintextQueue.
Put(inString, length);
833 size_t plaintextLength;
834 if (!
SafeConvert(m_plaintextQueue.CurrentSize(), plaintextLength))
835 throw InvalidArgument(
"PK_DefaultEncryptionFilter: plaintext too long");
839 m_plaintextQueue.
Get(plaintext, plaintextLength);
840 m_ciphertext.
resize(ciphertextLength);
841 m_encryptor.
Encrypt(m_rng, plaintext, plaintextLength, m_ciphertext, m_parameters);
844 FILTER_OUTPUT(1, m_ciphertext, m_ciphertext.
size(), messageEnd);
846 FILTER_END_NO_MESSAGE_END;
865 : m_rng(rng), m_decryptor(decryptor), m_parameters(parameters)
870 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
873 m_ciphertextQueue.
Put(inString, length);
878 size_t ciphertextLength;
879 if (!
SafeConvert(m_ciphertextQueue.CurrentSize(), ciphertextLength))
880 throw InvalidArgument(
"PK_DefaultDecryptionFilter: ciphertext too long");
884 m_ciphertextQueue.
Get(ciphertext, ciphertextLength);
885 m_plaintext.
resize(maxPlaintextLength);
886 m_result = m_decryptor.
Decrypt(m_rng, ciphertext, ciphertextLength, m_plaintext, m_parameters);
891 FILTER_OUTPUT(1, m_plaintext, m_result.
messageLength, messageEnd);
893 FILTER_END_NO_MESSAGE_END;
918 m->
Update(message, messageLen);
923 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
byte *signature)
const
927 m->
Update(nonrecoverableMessage, nonrecoverableMessageLength);
941 m->
Update(message, messageLen);
952 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
953 const byte *signature,
size_t signatureLength)
const
957 m->
Update(nonrecoverableMessage, nonrecoverableMessageLength);
981 #ifndef CRYPTOPP_BUILD_VERSION
982 # define CRYPTOPP_BUILD_VERSION CRYPTOPP_VERSION
986 return CRYPTOPP_BUILD_VERSION;
993 bool GetVoidValue(
const char *name,
const std::type_info &valueType,
void *pValue)
const
994 {CRYPTOPP_UNUSED(name); CRYPTOPP_UNUSED(valueType); CRYPTOPP_UNUSED(pValue);
return false;}
997 #if HAVE_GCC_INIT_PRIORITY
998 const std::string
DEFAULT_CHANNEL __attribute__ ((init_priority (CRYPTOPP_INIT_PRIORITY + 25))) =
"";
999 const std::string
AAD_CHANNEL __attribute__ ((init_priority (CRYPTOPP_INIT_PRIORITY + 26))) =
"AAD";
1000 const NullNameValuePairs s_nullNameValuePairs __attribute__ ((init_priority (CRYPTOPP_INIT_PRIORITY + 27)));
1002 #elif HAVE_MSC_INIT_PRIORITY
1003 #pragma warning(disable: 4073)
1004 #pragma init_seg(lib)
1009 #pragma warning(default: 4073)
1010 #elif HAVE_XLC_INIT_PRIORITY
1011 #pragma priority(260)
Classes for working with NameValuePairs.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Standard names for retrieving values by name when working with NameValuePairs.
Algorithm(bool checkSelfTestStatus=true)
Interface for all crypto algorithms.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
Copy input to a memory buffer.
virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate static private key in this domain.
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 GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0
Generate ephemeral public key.
virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate ephemeral private key.
virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate private/public key pair.
virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a static private/public key pair.
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.
virtual lword MaxHeaderLength() const =0
Provides the maximum length of AAD that can be input.
virtual lword MaxFooterLength() const
Provides the the maximum length of AAD.
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 SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0)
Prescribes the data lengths.
virtual lword MaxMessageLength() const =0
Provides the maximum length of encrypted data.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
Acts as an input discarding Filter or Sink.
Data structure used to store byte strings.
size_t Get(byte &outByte)
Retrieve a 8-bit byte.
Random Number Generator that does not produce random numbers.
void IncorporateEntropy(const byte *input, size_t length)
An implementation that throws NotImplemented.
void GenerateBlock(byte *output, size_t size)
An implementation that throws NotImplemented.
bool CanIncorporateEntropy() const
An implementation that returns false.
std::string AlgorithmName() const
The name of the generator.
void Shuffle(IT begin, IT end)
An implementation that does nothing.
word32 GenerateWord32(word32 min, word32 max)
An implementation that throws NotImplemented.
void DiscardBytes(size_t n)
An implementation that does nothing.
unsigned int GenerateBit()
An implementation that throws NotImplemented.
void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
An implementation that throws NotImplemented.
byte GenerateByte()
An implementation that throws NotImplemented.
Interface for cloning objects.
Used to pass byte array input as part of a NameValuePairs object.
size_t size() const
Length of the memory block.
const byte * begin() const
Pointer to the first byte in the memory block.
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize)
Generate a random key or crypto parameters.
virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs ¶ms=g_nullNameValuePairs)
Generate a random key or crypto parameters.
An invalid argument was detected.
A decryption filter encountered invalid ciphertext.
Exception thrown when an invalid derived key length is encountered.
Exception thrown when an invalid key length is encountered.
virtual size_t MaxDerivedLength() const
Determine maximum number of bytes.
virtual void SetParameters(const NameValuePairs ¶ms)
Set or change parameters.
virtual size_t MinDerivedLength() const
Determine minimum number of bytes.
virtual bool IsValidDerivedLength(size_t keylength) const
Returns whether keylength is a valid key length.
virtual std::string AlgorithmName() const =0
Provides the name of this algorithm.
Thrown when an unexpected type is encountered.
Interface for retrieving values given their names.
bool GetValue(const char *name, T &value) const
Get a named value.
A method was called which was not implemented.
bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
Get a named value.
virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0
Provides the maximum length of plaintext for a given ciphertext length.
virtual size_t CiphertextLength(size_t plaintextLength) const =0
Calculate the length of ciphertext given length of plaintext.
Interface for public-key decryptors.
virtual DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
Decrypt a byte string.
virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new decryption filter.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Interface for public-key encryptors.
virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new encryption filter.
virtual void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
Encrypt a byte string.
Interface for accumulating messages to be signed or verified.
virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const
Sign a message.
virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0
Input a recoverable message to an accumulator.
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
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 size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0
Sign and restart messageAccumulator.
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0
Create a new HashTransformation to accumulate the message to be signed.
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 DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const
Recover a message from its signature.
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0
Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulat...
virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const
Check whether messageAccumulator contains a valid signature and message.
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0
Input signature into a message accumulator.
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.
virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0
Recover a message from its signature.
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
Interface for random number generators.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL)
Generate a random 32 bit word in the range min to max, inclusive.
virtual unsigned int GenerateBit()
Generate new random bit and return it.
virtual byte GenerateByte()
Generate new random byte and return it.
size_type size() const
Provides the count of elements in the SecBlock.
void resize(size_type newSize)
Change size and preserve contents.
Exception thrown when a crypto algorithm is used after a self test fails.
virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a private/public key pair.
virtual void GeneratePublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0
Generate a public key from a private key in this domain.
virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate private key in this domain.
void SetKeyWithRounds(const byte *key, size_t length, int rounds)
Sets or reset the key of this object.
virtual bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength)
Sets or reset the key of this object.
bool IsResynchronizable() const
Determines if the object can be resynchronized.
virtual IV_Requirement IVRequirement() const =0
Minimal requirement for secure IVs.
@ UNPREDICTABLE_RANDOM_IV
The IV must be random and unpredictable.
virtual unsigned int MaxIVLength() const
Provides the maximum size of an IV.
virtual unsigned int MinIVLength() const
Provides the minimum size of an IV.
virtual unsigned int IVSize() const
Returns length of the IV accepted by this object.
virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv)
Retrieves a secure IV for the next message.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms=g_nullNameValuePairs)
Sets or reset the key of this object.
virtual void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
Base class for unflushable filters.
Manages resources for a single object.
Library configuration file.
Abstract base classes that provide a uniform interface to this library.
RandomNumberGenerator & NullRNG()
Random Number Generator that does not produce random numbers.
int LibraryVersion(...)
Specifies the build-time version of the library.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
ByteOrder
Provides the byte ordering.
BufferedTransformation & TheBitBucket()
An input discarding BufferedTransformation.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
Implementation of BufferedTransformation's attachment interface.
Classes and functions for the FIPS 140-2 validated library.
PowerUpSelfTestStatus GetPowerUpSelfTestStatus()
Provides the current power-up self test status.
@ POWER_UP_SELF_TEST_NOT_DONE
The self tests have not been performed.
@ POWER_UP_SELF_TEST_FAILED
The self tests were executed via DoPowerUpSelfTest() or DoDllPowerUpSelfTest(), but the result was fa...
bool FIPS_140_2_ComplianceEnabled()
Determines whether the library provides FIPS validated cryptography.
Utility functions for the Crypto++ library.
unsigned int BitPrecision(const T &value)
Returns the number of bits required for a value.
T Crop(T value, size_t bits)
Truncates the value to the specified number of bits.
void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
#define CRYPTOPP_COMPILE_ASSERT(expr)
Compile time assertion.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
bool SafeConvert(T1 from, T2 &to)
Tests whether a conversion from -> to is safe to perform.
bool VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count)
Performs a near constant-time comparison of two equally sized buffers.
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, const byte *xorBlock=NULL)
Access a block of memory.
Crypto++ library namespace.
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
Classes for access to the operating system's random number generators.
Classes and functions for secure memory allocations.
Classes for automatic resource management.
Returns a decoding results.
bool isValidCoding
Flag to indicate the decoding is valid.
size_t messageLength
Recovered message length if isValidCoding is true, undefined otherwise.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.