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)
76 if (!IsValidKeyLength(length))
80 void SimpleKeyingInterface::ThrowIfResynchronizable()
82 if (IsResynchronizable())
86 void SimpleKeyingInterface::ThrowIfInvalidIV(
const byte *iv)
88 if (!iv && IVRequirement() == UNPREDICTABLE_RANDOM_IV)
92 size_t SimpleKeyingInterface::ThrowIfInvalidIVLength(
int length)
96 size =
static_cast<size_t>(IVSize());
97 else if ((
size_t)length < MinIVLength())
99 else if ((
size_t)length > MaxIVLength())
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();
148 size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize;
149 size_t xorIncrement = xorBlocks ? blockSize : 0;
150 size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize;
152 if (flags & BT_ReverseDirection)
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);
170 ProcessBlock(outBlocks);
175 ProcessAndXorBlock(inBlocks, xorBlocks, outBlocks);
178 if (flags & BT_InBlockIsCounter)
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>();
210 if (length == MandatoryBlockSize())
211 ProcessData(outString, inString, length);
212 else if (length != 0)
222 if (inLength == MandatoryBlockSize())
224 outLength = inLength;
225 ProcessData(outString, inString, inLength);
227 else if (inLength != 0)
235 if (headerLength > MaxHeaderLength())
238 if (messageLength > MaxMessageLength())
241 if (footerLength > MaxFooterLength())
244 UncheckedSpecifyDataLengths(headerLength, messageLength, footerLength);
249 Resynchronize(iv, ivLength);
250 SpecifyDataLengths(headerLength, messageLength);
251 Update(header, headerLength);
252 ProcessString(ciphertext, message, messageLength);
253 TruncatedFinal(mac, macSize);
258 Resynchronize(iv, ivLength);
259 SpecifyDataLengths(headerLength, ciphertextLength);
260 Update(header, headerLength);
261 ProcessString(message, ciphertext, ciphertextLength);
262 return TruncatedVerify(mac, macLength);
273 return GenerateByte() & 1;
279 GenerateBlock(&b, 1);
285 const word32 range = max-min;
292 GenerateBlock((
byte *)&value,
sizeof(value));
293 value =
Crop(value, maxBits);
294 }
while (value > range);
313 CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);
330 GenerateBlock(buffer, len);
331 (void)target.
ChannelPut(channel, buffer, len);
343 return static_cast<size_t>(-1);
346 void KeyDerivationFunction::ThrowIfInvalidDerivedKeyLength(
size_t length)
const 348 if (!IsValidDerivedLength(length))
353 CRYPTOPP_UNUSED(params);
367 #if defined(CRYPTOPP_DOXYGEN_PROCESSING) 369 byte GenerateByte () {}
371 unsigned int GenerateBit () {}
377 void GenerateBlock(
byte *output,
size_t size)
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) 387 void IncorporateEntropy (
const byte *input,
size_t length) {}
389 bool CanIncorporateEntropy ()
const {}
391 void DiscardBytes (
size_t n) {}
393 void Shuffle (IT begin, IT end) {}
402 static ClassNullRNG s_nullRNG;
409 ThrowIfInvalidTruncatedSize(digestLength);
410 SecByteBlock calculated(digestLength ? digestLength : 1);
411 TruncatedFinal(calculated, digestLength);
415 void HashTransformation::ThrowIfInvalidTruncatedSize(
size_t size)
const 436 CRYPTOPP_UNUSED(propagation);
438 IsolatedInitialize(parameters);
443 CRYPTOPP_UNUSED(propagation);
445 return IsolatedFlush(hardFlush, blocking);
450 CRYPTOPP_UNUSED(propagation);
452 return IsolatedMessageSeriesEnd(blocking);
457 byte* space = NULLPTR;
459 space = CreatePutSpace(size);
469 size = Put2(inString, length, messageEnd, blocking);
479 size = PutModifiable2(inString, length, messageEnd, blocking);
481 size = ChannelPut2(channel, inString, length, messageEnd, blocking);
489 result = Flush(hardFlush, propagation, blocking);
499 result = MessageSeriesEnd(propagation, blocking);
508 if (AttachedTransformation())
509 size = AttachedTransformation()->MaxRetrievable();
518 if (AttachedTransformation())
519 result = AttachedTransformation()->AnyRetrievable();
523 result = Peek(b) != 0;
531 if (AttachedTransformation())
532 size = AttachedTransformation()->Get(outByte);
534 size = Get(&outByte, 1);
541 if (AttachedTransformation())
542 size = AttachedTransformation()->Get(outString, getMax);
546 size = (size_t)TransferTo(arraySink, getMax);
554 if (AttachedTransformation())
555 size = AttachedTransformation()->Peek(outByte);
557 size = Peek(&outByte, 1);
564 if (AttachedTransformation())
565 size = AttachedTransformation()->Peek(outString, peekMax);
569 size = (size_t)CopyTo(arraySink, peekMax);
577 if (AttachedTransformation())
578 size = AttachedTransformation()->Skip(skipMax);
587 if (AttachedTransformation())
588 size = AttachedTransformation()->TotalBytesRetrievable();
590 size = MaxRetrievable();
596 unsigned int size = 0;
597 if (AttachedTransformation())
598 size = AttachedTransformation()->NumberOfMessages();
607 if (AttachedTransformation())
608 result = AttachedTransformation()->AnyMessages();
610 result = NumberOfMessages() != 0;
617 if (AttachedTransformation())
618 result = AttachedTransformation()->GetNextMessage();
628 unsigned int size = 0;
629 if (AttachedTransformation())
630 size = AttachedTransformation()->SkipMessages(count);
638 if (AttachedTransformation())
639 return AttachedTransformation()->TransferMessagesTo2(target, messageCount, channel, blocking);
642 unsigned int maxMessages = messageCount;
643 for (messageCount=0; messageCount < maxMessages && AnyMessages(); messageCount++)
646 lword transferredBytes;
648 while (AnyRetrievable())
655 transferredBytes = MaxRetrievable();
656 blockedBytes = TransferTo2(target, transferredBytes, channel, blocking);
657 if (blockedBytes > 0)
664 bool result = GetNextMessage();
673 unsigned int size = 0;
674 if (AttachedTransformation())
675 size = AttachedTransformation()->CopyMessagesTo(target, count, channel);
681 if (AttachedTransformation())
682 AttachedTransformation()->SkipAll();
685 while (SkipMessages()) {}
692 if (AttachedTransformation())
693 return AttachedTransformation()->TransferAllTo2(target, channel, blocking);
698 unsigned int messageCount;
701 messageCount = UINT_MAX;
702 size_t blockedBytes = TransferMessagesTo2(target, messageCount, channel, blocking);
706 while (messageCount != 0);
711 byteCount = ULONG_MAX;
712 size_t blockedBytes = TransferTo2(target, byteCount, channel, blocking);
716 while (byteCount != 0);
724 if (AttachedTransformation())
725 AttachedTransformation()->CopyAllTo(target, channel);
729 while (CopyMessagesTo(target, UINT_MAX, channel)) {}
735 if (AttachedTransformation())
736 AttachedTransformation()->SetRetrievalChannel(channel);
741 PutWord(
false, order, m_buf, value);
742 return ChannelPut(channel, m_buf, 2, blocking);
747 PutWord(
false, order, m_buf, value);
748 return ChannelPut(channel, m_buf, 4, blocking);
753 PutWord(
false, order, m_buf, value);
754 return ChannelPut(channel, m_buf, 8, blocking);
774 byte buf[2] = {0, 0};
775 size_t len = Peek(buf, 2);
778 value =
word16((buf[0] << 8) | buf[1]);
780 value =
word16((buf[1] << 8) | buf[0]);
787 byte buf[4] = {0, 0, 0, 0};
788 size_t len = Peek(buf, 4);
791 value =
word32((buf[0] << 24) | (buf[1] << 16) |
792 (buf[2] << 8) | (buf[3] << 0));
794 value =
word32((buf[3] << 24) | (buf[2] << 16) |
795 (buf[1] << 8) | (buf[0] << 0));
802 byte buf[8] = {0, 0, 0, 0, 0, 0, 0, 0};
803 size_t len = Peek(buf, 8);
819 return (
size_t)Skip(PeekWord16(value, order));
824 return (
size_t)Skip(PeekWord32(value, order));
829 return (
size_t)Skip(PeekWord64(value, order));
834 if (AttachedTransformation() && AttachedTransformation()->Attachable())
835 AttachedTransformation()->Attach(newAttachment);
837 Detach(newAttachment);
845 class PK_DefaultEncryptionFilter :
public Unflushable<Filter>
849 : m_rng(rng), m_encryptor(encryptor), m_parameters(parameters)
854 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
857 m_plaintextQueue.Put(inString, length);
862 size_t plaintextLength;
863 if (!
SafeConvert(m_plaintextQueue.CurrentSize(), plaintextLength))
864 throw InvalidArgument(
"PK_DefaultEncryptionFilter: plaintext too long");
865 size_t ciphertextLength = m_encryptor.CiphertextLength(plaintextLength);
868 m_plaintextQueue.Get(plaintext, plaintextLength);
869 m_ciphertext.resize(ciphertextLength);
870 m_encryptor.Encrypt(m_rng, plaintext, plaintextLength, m_ciphertext, m_parameters);
873 FILTER_OUTPUT(1, m_ciphertext, m_ciphertext.size(), messageEnd);
875 FILTER_END_NO_MESSAGE_END;
887 return new PK_DefaultEncryptionFilter(rng, *
this, attachment, parameters);
890 class PK_DefaultDecryptionFilter :
public Unflushable<Filter>
894 : m_rng(rng), m_decryptor(decryptor), m_parameters(parameters)
899 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
902 m_ciphertextQueue.Put(inString, length);
907 size_t ciphertextLength;
908 if (!
SafeConvert(m_ciphertextQueue.CurrentSize(), ciphertextLength))
909 throw InvalidArgument(
"PK_DefaultDecryptionFilter: ciphertext too long");
910 size_t maxPlaintextLength = m_decryptor.MaxPlaintextLength(ciphertextLength);
913 m_ciphertextQueue.Get(ciphertext, ciphertextLength);
914 m_plaintext.resize(maxPlaintextLength);
915 m_result = m_decryptor.Decrypt(m_rng, ciphertext, ciphertextLength, m_plaintext, m_parameters);
916 if (!m_result.isValidCoding)
920 FILTER_OUTPUT(1, m_plaintext, m_result.messageLength, messageEnd);
922 FILTER_END_NO_MESSAGE_END;
935 return new PK_DefaultDecryptionFilter(rng, *
this, attachment, parameters);
941 return SignAndRestart(rng, *m, signature,
false);
947 m->Update(message, messageLen);
948 return SignAndRestart(rng, *m, signature,
false);
952 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
byte *signature)
const 955 InputRecoverableMessage(*m, recoverableMessage, recoverableMessageLength);
956 m->Update(nonrecoverableMessage, nonrecoverableMessageLength);
957 return SignAndRestart(rng, *m, signature,
false);
963 return VerifyAndRestart(*m);
969 InputSignature(*m, signature, signatureLen);
970 m->Update(message, messageLen);
971 return VerifyAndRestart(*m);
977 return RecoverAndRestart(recoveredMessage, *m);
981 const byte *nonrecoverableMessage,
size_t nonrecoverableMessageLength,
982 const byte *signature,
size_t signatureLength)
const 985 InputSignature(*m, signature, signatureLength);
986 m->Update(nonrecoverableMessage, nonrecoverableMessageLength);
987 return RecoverAndRestart(recoveredMessage, *m);
992 GeneratePrivateKey(rng, privateKey);
993 GeneratePublicKey(rng, privateKey, publicKey);
998 GenerateStaticPrivateKey(rng, privateKey);
999 GenerateStaticPublicKey(rng, privateKey, publicKey);
1004 GenerateEphemeralPrivateKey(rng, privateKey);
1005 GenerateEphemeralPublicKey(rng, privateKey, publicKey);
1010 #ifndef CRYPTOPP_BUILD_VERSION 1011 # define CRYPTOPP_BUILD_VERSION CRYPTOPP_VERSION 1015 return CRYPTOPP_BUILD_VERSION;
1021 NullNameValuePairs() {}
1022 bool GetVoidValue(
const char *name,
const std::type_info &valueType,
void *pValue)
const 1023 {CRYPTOPP_UNUSED(name); CRYPTOPP_UNUSED(valueType); CRYPTOPP_UNUSED(pValue);
return false;}
1026 #if HAVE_GCC_INIT_PRIORITY 1027 const std::string
DEFAULT_CHANNEL __attribute__ ((init_priority (CRYPTOPP_INIT_PRIORITY + 25))) =
"";
1028 const std::string
AAD_CHANNEL __attribute__ ((init_priority (CRYPTOPP_INIT_PRIORITY + 26))) =
"AAD";
1029 const NullNameValuePairs s_nullNameValuePairs __attribute__ ((init_priority (CRYPTOPP_INIT_PRIORITY + 27)));
1031 #elif HAVE_MSC_INIT_PRIORITY 1032 #pragma warning(disable: 4073) 1033 #pragma init_seg(lib) 1036 const NullNameValuePairs s_nullNameValuePairs;
1037 const NameValuePairs& g_nullNameValuePairs = s_nullNameValuePairs;
1038 #pragma warning(default: 4073) 1039 #elif HAVE_XLC_INIT_PRIORITY 1040 #pragma priority(260) 1041 const std::string DEFAULT_CHANNEL =
"";
1042 const std::string AAD_CHANNEL =
"AAD";
1043 const NullNameValuePairs s_nullNameValuePairs;
1044 const NameValuePairs& g_nullNameValuePairs = s_nullNameValuePairs;
1046 const std::string DEFAULT_CHANNEL =
"";
1047 const std::string AAD_CHANNEL =
"AAD";
1049 const NameValuePairs &g_nullNameValuePairs = *s_pNullNameValuePairs.m_p;
1054 #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.
const char * DigestSize()
int, in bytes
An invalid argument was detected.
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.
Classes for working with NameValuePairs.
bool SafeConvert(T1 from, T2 &to)
Tests whether a conversion from -> to is safe to perform.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms=g_nullNameValuePairs)
Sets or reset the key of this object.
Utility functions for the Crypto++ library.
word128 dword
Double word used for multiprecision integer arithmetic.
ByteOrder
Provides the byte ordering.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
virtual byte GenerateByte()
Generate new random byte and return it.
virtual size_t MaxDerivedKeyLength() const
Determine maximum number of bytes.
size_t size() const
Length of the memory block.
Exception thrown when an invalid key length is encountered.
void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, const byte *xorBlock=NULL)
Access a block of memory.
unsigned int word32
32-bit unsigned datatype
Interface for public-key encryptors.
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.
Abstract base classes that provide a uniform interface to this library.
Thrown when an unexpected type is encountered.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
virtual size_t MinDerivedKeyLength() const
Determine minimum number of bytes.
virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new decryption filter.
The self tests were executed via DoPowerUpSelfTest() or DoDllPowerUpSelfTest(), but the result was fa...
Classes for automatic resource management.
virtual Clonable * Clone() const
Copies this object.
Library configuration file.
Interface for random number generators.
void SetKeyWithRounds(const byte *key, size_t length, int rounds)
Sets or reset the key of this object.
virtual DecodingResult RecoverMessage(byte *recoveredMessage, const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, const byte *signature, size_t signatureLength) const
Recover a message from its signature.
Interface for cloning objects.
virtual void SetParameters(const NameValuePairs ¶ms)
Set or change parameters.
virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const
Sign a message.
Classes and functions for secure memory allocations.
virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a static private/public key pair.
Copy input to a memory buffer.
Returns a decoding results.
Algorithm(bool checkSelfTestStatus=true)
Interface for all crypto algorithms.
virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters=g_nullNameValuePairs) const
Create a new encryption filter.
CRYPTOPP_DLL RandomNumberGenerator & NullRNG()
Random Number Generator that does not produce random numbers.
Interface for public-key decryptors.
A method was called which was not implemented.
const byte * begin() const
Pointer to the first byte in the memory block.
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.
Manages resources for a single object.
Exception thrown when a crypto algorithm is used after a self test fails.
word64 word
Full word used for multiprecision integer arithmetic.
virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate private/public key pair.
unsigned long long word64
64-bit unsigned datatype
#define CRYPTOPP_COMPILE_ASSERT(expr)
Compile time assertion.
virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv)
Retrieves a secure IV for the next message.
T Crop(T value, size_t bits)
Truncates the value to the specified number of bits.
virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const
Recover a message from its signature.
CRYPTOPP_DLL void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
virtual unsigned int GenerateBit()
Generate new random bit and return it.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Data structure used to store byte strings.
const char * BlockSize()
int, in bytes
Implementation of BufferedTransformation's attachment interface.
CRYPTOPP_DLL bool FIPS_140_2_ComplianceEnabled()
Determines whether the library provides FIPS validated cryptography.
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
The self tests have not been performed.
unsigned short word16
16-bit unsigned datatype
Interface for accumulating messages to be signed or verified.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
word64 lword
Large word type.
A decryption filter encountered invalid ciphertext.
unsigned char byte
8-bit unsigned datatype
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.
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength)
Sets or reset the key of this object.
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
CRYPTOPP_DLL PowerUpSelfTestStatus GetPowerUpSelfTestStatus()
Provides the current power-up self test status.
Base class for unflushable filters.
Classes and functions for the FIPS 140-2 validated library.
void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize)
Generate a random key or crypto parameters.
Exception thrown when an invalid derived key length is encountered.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
CRYPTOPP_DLL BufferedTransformation & TheBitBucket()
An input discarding BufferedTransformation.
void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0)
Prescribes the data lengths.
Acts as an input discarding Filter or Sink.
virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
Generate a private/public key pair.
CRYPTOPP_DLL bool VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count)
Performs a near constant-time comparison of two equally sized buffers.
int LibraryVersion(...)
Specifies the build-time version of the library.
Crypto++ library namespace.
bool GetValue(const char *name, T &value) const
Get a named value.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL)
Generate a random 32 bit word in the range min to max, inclusive.
virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const
Check whether messageAccumulator contains a valid signature and message.
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
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.
Classes for access to the operating system's random number generators.
Interface for retrieving values given their names.
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.