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 32 #if (defined(__CYGWIN__) || defined(__CYGWIN32__)) && defined(PREFER_WINDOWS_STYLE_SOCKETS) 33 # error Cygwin does not support Windows style sockets. See http://www.cygwin.com/faq.html#faq.api.winsock 42 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE 57 throw SelfTestFailure(
"Cryptographic algorithms are disabled before the power-up self tests are performed.");
60 throw SelfTestFailure(
"Cryptographic algorithms are disabled after a power-up self test failed.");
66 this->ThrowIfInvalidKeyLength(length);
67 this->UncheckedSetKey(key, static_cast<unsigned int>(length), params);
80 void SimpleKeyingInterface::ThrowIfInvalidKeyLength(
size_t length)
86 void SimpleKeyingInterface::ThrowIfResynchronizable()
89 throw InvalidArgument(GetAlgorithm().AlgorithmName() +
": this object requires an IV");
92 void SimpleKeyingInterface::ThrowIfInvalidIV(
const byte *iv)
95 throw InvalidArgument(GetAlgorithm().AlgorithmName() +
": this object cannot use a null IV");
98 size_t SimpleKeyingInterface::ThrowIfInvalidIVLength(
int length)
102 size =
static_cast<size_t>(
IVSize());
108 size =
static_cast<size_t>(length);
113 const byte * SimpleKeyingInterface::GetIVAndThrowIfInvalid(
const NameValuePairs ¶ms,
size_t &size)
116 const byte *iv = NULLPTR;
124 iv = ivWithLength.
begin();
125 ThrowIfInvalidIV(iv);
126 size = ThrowIfInvalidIVLength(static_cast<int>(ivWithLength.
size()));
130 ThrowIfInvalidIV(iv);
131 size =
static_cast<size_t>(
IVSize());
135 ThrowIfResynchronizable();
155 ptrdiff_t xorIncrement = xorBlocks ? blockSize : 0;
160 inBlocks +=
static_cast<ptrdiff_t
>(length) - blockSize;
161 xorBlocks +=
static_cast<ptrdiff_t
>(length) - blockSize;
162 outBlocks +=
static_cast<ptrdiff_t
>(length) - blockSize;
163 inIncrement = 0-inIncrement;
164 xorIncrement = 0-xorIncrement;
165 outIncrement = 0-outIncrement;
169 const bool xorFlag = xorBlocks && (flags &
BT_XorInput);
170 while (length >= blockSize)
175 xorbuf(outBlocks, xorBlocks, inBlocks, blockSize);
185 const_cast<byte *
>(inBlocks)[blockSize-1]++;
187 inBlocks += inIncrement;
188 outBlocks += outIncrement;
189 xorBlocks += xorIncrement;
198 return GetAlignmentOf<word32>();
203 return GetAlignmentOf<word32>();
208 return GetAlignmentOf<word32>();
218 else if (length != 0)
230 outLength = inLength;
233 else if (inLength != 0)
250 UncheckedSpecifyDataLengths(headerLength, messageLength, footerLength);
257 Update(header, headerLength);
266 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);
347 #if defined(CRYPTOPP_DOXYGEN_PROCESSING) 359 CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(size);
360 throw NotImplemented(
"NullRNG: NullRNG should only be passed to functions that don't need to generate random bytes");
363 #if defined(CRYPTOPP_DOXYGEN_PROCESSING) 376 Clonable* Clone ()
const {
return NULLPTR; }
388 ThrowIfInvalidTruncatedSize(digestLength);
394 void HashTransformation::ThrowIfInvalidTruncatedSize(
size_t size)
const 415 CRYPTOPP_UNUSED(propagation);
422 CRYPTOPP_UNUSED(propagation);
429 CRYPTOPP_UNUSED(propagation);
436 byte* space = NULLPTR;
448 size =
Put2(inString, length, messageEnd, blocking);
460 size =
ChannelPut2(channel, inString, length, messageEnd, blocking);
468 result =
Flush(hardFlush, propagation, blocking);
502 result =
Peek(b) != 0;
513 size =
Get(&outByte, 1);
536 size =
Peek(&outByte, 1);
548 size = (size_t)
CopyTo(arraySink, peekMax);
575 unsigned int size = 0;
607 unsigned int size = 0;
621 unsigned int maxMessages = messageCount;
622 for (messageCount=0; messageCount < maxMessages &&
AnyMessages(); messageCount++)
625 lword transferredBytes;
629 transferredBytes = LWORD_MAX;
630 blockedBytes =
TransferTo2(target, transferredBytes, channel, blocking);
631 if (blockedBytes > 0)
647 unsigned int size = 0;
672 unsigned int messageCount;
675 messageCount = UINT_MAX;
680 while (messageCount != 0);
685 byteCount = ULONG_MAX;
686 size_t blockedBytes =
TransferTo2(target, byteCount, channel, blocking);
690 while (byteCount != 0);
715 PutWord(
false, order, m_buf, value);
716 return ChannelPut(channel, m_buf, 2, blocking);
721 PutWord(
false, order, m_buf, value);
722 return ChannelPut(channel, m_buf, 4, blocking);
736 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE 737 # pragma GCC diagnostic push 738 # pragma GCC diagnostic ignored "-Wconversion" 739 # pragma GCC diagnostic ignored "-Wsign-conversion" 744 byte buf[2] = {0, 0};
745 size_t len =
Peek(buf, 2);
748 value = (buf[0] << 8) | buf[1];
750 value = (buf[1] << 8) | buf[0];
757 byte buf[4] = {0, 0, 0, 0};
758 size_t len =
Peek(buf, 4);
761 value = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf [3];
763 value = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf [0];
769 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE 770 # pragma GCC diagnostic pop 800 : m_rng(rng), m_encryptor(encryptor), m_parameters(parameters)
805 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
808 m_plaintextQueue.
Put(inString, length);
813 size_t plaintextLength;
814 if (!
SafeConvert(m_plaintextQueue.CurrentSize(), plaintextLength))
815 throw InvalidArgument(
"PK_DefaultEncryptionFilter: plaintext too long");
819 m_plaintextQueue.
Get(plaintext, plaintextLength);
820 m_ciphertext.
resize(ciphertextLength);
821 m_encryptor.
Encrypt(m_rng, plaintext, plaintextLength, m_ciphertext, m_parameters);
824 FILTER_OUTPUT(1, m_ciphertext, m_ciphertext.
size(), messageEnd);
826 FILTER_END_NO_MESSAGE_END;
845 : m_rng(rng), m_decryptor(decryptor), m_parameters(parameters)
850 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
853 m_ciphertextQueue.
Put(inString, length);
858 size_t ciphertextLength;
859 if (!
SafeConvert(m_ciphertextQueue.CurrentSize(), ciphertextLength))
860 throw InvalidArgument(
"PK_DefaultDecryptionFilter: ciphertext too long");
864 m_ciphertextQueue.
Get(ciphertext, ciphertextLength);
865 m_plaintext.
resize(maxPlaintextLength);
866 m_result = m_decryptor.
Decrypt(m_rng, ciphertext, ciphertextLength, m_plaintext, m_parameters);
871 FILTER_OUTPUT(1, m_plaintext, m_result.
messageLength, messageEnd);
873 FILTER_END_NO_MESSAGE_END;
898 m->
Update(message, messageLen);
903 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength, byte *signature)
const 907 m->
Update(nonrecoverableMessage, nonrecoverableMessageLength);
921 m->
Update(message, messageLen);
932 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
933 const byte *signature,
size_t signatureLength)
const 937 m->
Update(nonrecoverableMessage, nonrecoverableMessageLength);
961 #ifndef CRYPTOPP_BUILD_VERSION 962 # define CRYPTOPP_BUILD_VERSION CRYPTOPP_VERSION 966 return CRYPTOPP_BUILD_VERSION;
971 #endif // CRYPTOPP_IMPORTS Used to pass byte array input as part of a NameValuePairs object.
Standard names for retrieving values by name when working with NameValuePairs.
An invalid argument was detected.
virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a private/public key pair.
container of wait objects
Classes for working with NameValuePairs.
word32 GenerateWord32(word32 min, word32 max)
An implementation that throws NotImplemented.
virtual unsigned int MinIVLength() const
Provides the minimum size of an IV.
bool SafeConvert(T1 from, T2 &to)
Tests whether a conversion from -> to is safe to perform.
Utility functions for the Crypto++ library.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms=g_nullNameValuePairs)
Sets or reset the key of this object.
ByteOrder
Provides the byte ordering.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
size_t size() const
Length of the memory block.
virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const
Check whether messageAccumulator contains a valid signature and message.
virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const
Sign a message.
Exception thrown when an invalid key length is encountered.
void resize(size_type newSize)
Change size and preserve contents.
void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, const byte *xorBlock=NULL)
Access a block of memory.
virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a static private/public key pair.
Interface for public-key encryptors.
byte GenerateByte()
An implementation that throws NotImplemented.
virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL)
Generate a random 32 bit word in the range min to max, inclusive.
Abstract base classes that provide a uniform interface to this library.
virtual void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
Encrypt a byte string.
virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0
Provides the maximum length of plaintext for a given ciphertext length.
Thrown when an unexpected type is encountered.
BufferedTransformation & TheBitBucket()
An input discarding BufferedTransformation.
void GenerateBlock(byte *output, size_t size)
An implementation that throws NotImplemented.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
The self tests were executed via DoPowerUpSelfTest() or DoDllPowerUpSelfTest(), but the result was fa...
Classes for automatic resource management.
void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
An implementation that throws NotImplemented.
Library configuration file.
Interface for random number generators.
virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0
Input a recoverable message to an accumulator.
size_t messageLength
Recovered message length if isValidCoding is true, undefined otherwise.
void SetKeyWithRounds(const byte *key, size_t length, int rounds)
Sets or reset the key of this object.
virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate private/public key pair.
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0
Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulat...
Interface for cloning objects.
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.
std::string AlgorithmName() const
The name of the generator.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
virtual lword MaxHeaderLength() const =0
Provides the maximum length of AAD that can be input.
Classes and functions for secure memory allocations.
bool FIPS_140_2_ComplianceEnabled()
Determines whether the library provides FIPS validated cryptography.
Copy input to a memory buffer.
Returns a decoding results.
Algorithm(bool checkSelfTestStatus=true)
Interface for all crypto algorithms.
virtual IV_Requirement IVRequirement() const =0
Minimal requirement for secure IVs.
Interface for public-key decryptors.
void Shuffle(IT begin, IT end)
An implementation that does nothing.
virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate static private key in this domain.
A method was called which was not implemented.
virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0
Recover a message from its signature.
const byte * begin() const
Pointer to the first byte in the memory block.
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
virtual unsigned int MaxIVLength() const
Provides the maximum size of an IV.
Exception thrown when a crypto algorithm is used after a self test fails.
virtual bool IsValidKeyLength(size_t keylength) const
Returns whether keylength is a valid key length.
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 void Resynchronize(const byte *iv, int ivLength=-1)
Resynchronize with an IV.
#define CRYPTOPP_COMPILE_ASSERT(expr)
Compile time assertion.
T Crop(T value, size_t bits)
Truncates the value to the specified number of bits.
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.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
virtual unsigned int IVSize() const
Returns length of the IV accepted by this object.
unsigned int GenerateBit()
An implementation that throws NotImplemented.
virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new decryption filter.
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 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.
virtual byte GenerateByte()
Generate new random byte and return it.
Data structure used to store byte strings.
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 GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0
Generate ephemeral public key.
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
PowerUpSelfTestStatus GetPowerUpSelfTestStatus()
Provides the current power-up self test status.
Random Number Generator that does not produce random numbers.
Implementation of BufferedTransformation's attachment interface.
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
The self tests have not been performed.
Interface for accumulating messages to be signed or verified.
virtual lword MaxMessageLength() const =0
Provides the maximum length of encrypted data.
virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate private key in this domain.
A decryption filter encountered invalid ciphertext.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength)
Sets or reset the key of this object.
virtual unsigned int GenerateBit()
Generate new random bit and return it.
Base class for unflushable filters.
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new encryption filter.
Classes and functions for the FIPS 140-2 validated library.
virtual size_t CiphertextLength(size_t plaintextLength) const =0
Calculate the length of ciphertext given length of plaintext.
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 xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
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)
Decrypts and verifies a MAC in one call.
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.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
bool VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count)
Performs a near constant-time comparison of two equally sized buffers.
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0
Create a new HashTransformation to accumulate the message to be signed.
virtual size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0
Sign and restart messageAccumulator.
bool isValidCoding
Flag to indicate the decoding is valid.
void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0)
Prespecifies the data lengths.
Acts as an input discarding Filter or Sink.
int LibraryVersion(...)
Specifies the build-time version of the library.
Crypto++ library namespace.
virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0
Generate ephemeral private key.
virtual std::string AlgorithmName() const =0
Provides the name of this algorithm.
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.
virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const
Recover a message from its signature.
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0
Input signature into a message accumulator.
bool CanIncorporateEntropy() const
An implementation that returns false.
void IncorporateEntropy(const byte *input, size_t length)
An implementation that throws NotImplemented.
virtual lword MaxFooterLength() const
Provides the the maximum length of AAD.
void DiscardBytes(size_t n)
An implementation that does nothing.
virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv)
Retrieves a secure IV for the next message.
size_t Get(byte &outByte)
Retrieve a 8-bit byte.
unsigned int BitPrecision(const T &value)
Returns the number of bits required for a value.
size_type size() const
Provides the count of elements in the SecBlock.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
Classes for access to the operating system's random number generators.
Interface for retrieving values given their names.
virtual DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
Decrypt a byte string.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.