6 #if CRYPTOPP_MSC_VERSION
7 # pragma warning(disable: 4100 4189 4355)
10 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
11 # pragma GCC diagnostic ignored "-Wunused-value"
14 #ifndef CRYPTOPP_IMPORTS
27 : m_attachment(attachment), m_inputPosition(0), m_continueAt(0)
38 if (m_attachment.get() == NULLPTR)
39 m_attachment.reset(NewDefaultAttachment());
40 return m_attachment.get();
45 if (m_attachment.get() == NULLPTR)
46 const_cast<Filter *
>(
this)->m_attachment.reset(NewDefaultAttachment());
47 return m_attachment.get();
52 m_attachment.reset(newOut);
55 void Filter::Insert(
Filter *filter)
57 filter->m_attachment.reset(m_attachment.release());
58 m_attachment.reset(filter);
73 m_inputPosition = m_continueAt = 0;
75 PropagateInitialize(parameters, propagation);
78 bool Filter::Flush(
bool hardFlush,
int propagation,
bool blocking)
87 if (OutputFlush(1, hardFlush, propagation, blocking))
104 if (ShouldPropagateMessageSeriesEnd() && OutputMessageSeriesEnd(1, propagation, blocking))
112 void Filter::PropagateInitialize(
const NameValuePairs ¶meters,
int propagation)
118 size_t Filter::OutputModifiable(
int outputSite,
byte *inString,
size_t length,
int messageEnd,
bool blocking,
const std::string &channel)
123 m_continueAt = result ? outputSite : 0;
127 size_t Filter::Output(
int outputSite,
const byte *inString,
size_t length,
int messageEnd,
bool blocking,
const std::string &channel)
132 m_continueAt = result ? outputSite : 0;
136 bool Filter::OutputFlush(
int outputSite,
bool hardFlush,
int propagation,
bool blocking,
const std::string &channel)
140 m_continueAt = outputSite;
147 bool Filter::OutputMessageSeriesEnd(
int outputSite,
int propagation,
bool blocking,
const std::string &channel)
151 m_continueAt = outputSite;
162 m_currentMessageBytes = m_totalBytes = m_currentSeriesMessages = m_totalMessages = m_totalMessageSeries = 0;
163 m_rangesToSkip.clear();
168 MessageRange r = {message, position, size};
169 m_rangesToSkip.push_back(r);
171 std::sort(m_rangesToSkip.begin(), m_rangesToSkip.end());
174 size_t MeterFilter::PutMaybeModifiable(
byte *begin,
size_t length,
int messageEnd,
bool blocking,
bool modifiable)
185 while (m_length > 0 || messageEnd)
187 if (m_length > 0 && !m_rangesToSkip.empty() && m_rangesToSkip.front().message == m_totalMessages && m_currentMessageBytes + m_length > m_rangesToSkip.front().position)
189 FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (
size_t)
SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes),
false, modifiable);
192 m_begin =
PtrAdd(m_begin, t);
194 m_currentMessageBytes += t;
197 if (m_currentMessageBytes + m_length < m_rangesToSkip.front().position + m_rangesToSkip.front().size)
201 t = (size_t)
SaturatingSubtract(m_rangesToSkip.front().position + m_rangesToSkip.front().size, m_currentMessageBytes);
203 m_rangesToSkip.pop_front();
206 m_begin =
PtrAdd(m_begin, t);
208 m_currentMessageBytes += t;
213 FILTER_OUTPUT_MAYBE_MODIFIABLE(2, m_begin, m_length, messageEnd, modifiable);
215 m_currentMessageBytes += m_length;
216 m_totalBytes += m_length;
221 m_currentMessageBytes = 0;
222 m_currentSeriesMessages++;
229 FILTER_END_NO_MESSAGE_END;
232 size_t MeterFilter::Put2(
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
234 return PutMaybeModifiable(
const_cast<byte *
>(begin), length, messageEnd, blocking,
false);
239 return PutMaybeModifiable(begin, length, messageEnd, blocking,
true);
244 CRYPTOPP_UNUSED(blocking);
245 m_currentMessageBytes = 0;
246 m_currentSeriesMessages = 0;
247 m_totalMessageSeries++;
253 void FilterWithBufferedInput::BlockQueue::ResetQueue(
size_t blockSize,
size_t maxBlocks)
255 m_buffer.New(blockSize * maxBlocks);
256 m_blockSize = blockSize;
257 m_maxBlocks = maxBlocks;
262 byte *FilterWithBufferedInput::BlockQueue::GetBlock()
264 if (m_size >= m_blockSize)
267 if ((m_begin =
PtrAdd(m_begin, m_blockSize)) == m_buffer.end())
269 m_size -= m_blockSize;
276 byte *FilterWithBufferedInput::BlockQueue::GetContigousBlocks(
size_t &numberOfBytes)
278 numberOfBytes =
STDMIN(numberOfBytes, STDMIN<size_t>(
PtrDiff(m_buffer.end(), m_begin), m_size));
280 m_begin =
PtrAdd(m_begin, numberOfBytes);
281 m_size -= numberOfBytes;
282 if (m_size == 0 || m_begin == m_buffer.end())
287 size_t FilterWithBufferedInput::BlockQueue::GetAll(
byte *outString)
290 if (!outString)
return 0;
292 size_t size = m_size;
293 size_t numberOfBytes = m_maxBlocks*m_blockSize;
294 const byte *ptr = GetContigousBlocks(numberOfBytes);
295 memcpy(outString, ptr, numberOfBytes);
296 memcpy(
PtrAdd(outString, numberOfBytes), m_begin, m_size);
301 void FilterWithBufferedInput::BlockQueue::Put(
const byte *inString,
size_t length)
304 if (!inString || !length)
return;
307 byte *end = (m_size < static_cast<size_t>(
PtrDiff(m_buffer.end(), m_begin)) ?
308 PtrAdd(m_begin, m_size) :
PtrAdd(m_begin, m_size - m_buffer.size()));
309 size_t len =
STDMIN(length,
size_t(m_buffer.end()-end));
310 memcpy(end, inString, len);
312 memcpy(m_buffer,
PtrAdd(inString, len), length-len);
317 :
Filter(attachment), m_firstSize(
SIZE_MAX), m_blockSize(0), m_lastSize(
SIZE_MAX), m_firstInputDone(false)
322 :
Filter(attachment), m_firstSize(firstSize), m_blockSize(blockSize), m_lastSize(lastSize), m_firstInputDone(false)
327 m_queue.ResetQueue(1, m_firstSize);
332 InitializeDerivedAndReturnNewSizes(parameters, m_firstSize, m_blockSize, m_lastSize);
335 m_queue.ResetQueue(1, m_firstSize);
336 m_firstInputDone =
false;
342 throw BlockingInputOnly(
"FilterWithBufferedInput");
351 size_t FilterWithBufferedInput::PutMaybeModifiable(
byte *inString,
size_t length,
int messageEnd,
bool blocking,
bool modifiable)
354 throw BlockingInputOnly(
"FilterWithBufferedInput");
358 size_t newLength = m_queue.CurrentSize() + length;
360 if (!m_firstInputDone && newLength >= m_firstSize)
362 size_t len = m_firstSize - m_queue.CurrentSize();
363 m_queue.Put(inString, len);
364 FirstPut(m_queue.GetContigousBlocks(m_firstSize));
366 m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
368 inString =
PtrAdd(inString, len);
369 newLength -= m_firstSize;
370 m_firstInputDone =
true;
373 if (m_firstInputDone)
375 if (m_blockSize == 1)
377 while (newLength > m_lastSize && m_queue.CurrentSize() > 0)
379 size_t len = newLength - m_lastSize;
380 byte *ptr = m_queue.GetContigousBlocks(len);
381 NextPutModifiable(ptr, len);
385 if (newLength > m_lastSize)
387 size_t len = newLength - m_lastSize;
388 NextPutMaybeModifiable(inString, len, modifiable);
389 inString =
PtrAdd(inString, len);
395 while (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() >= m_blockSize)
397 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
398 newLength -= m_blockSize;
401 if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
404 size_t len = m_blockSize - m_queue.CurrentSize();
405 m_queue.Put(inString, len);
406 inString =
PtrAdd(inString, len);
407 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
408 newLength -= m_blockSize;
411 if (newLength >= m_blockSize + m_lastSize)
414 NextPutMaybeModifiable(inString, len, modifiable);
415 inString =
PtrAdd(inString, len);
421 m_queue.Put(inString, newLength - m_queue.CurrentSize());
426 if (!m_firstInputDone && m_firstSize==0)
430 m_queue.GetAll(temp);
431 LastPut(temp, temp.size());
433 m_firstInputDone =
false;
434 m_queue.ResetQueue(1, m_firstSize);
437 (void)Output(1, NULLPTR, 0, messageEnd, blocking);
444 if (!m_firstInputDone)
449 while (m_queue.CurrentSize() >= m_blockSize)
450 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
455 while ((len = m_queue.CurrentSize()) > 0)
456 NextPutModifiable(m_queue.GetContigousBlocks(len), len);
460 void FilterWithBufferedInput::NextPutMultiple(
const byte *inString,
size_t length)
466 NextPutSingle(inString);
467 inString =
PtrAdd(inString, m_blockSize);
468 length -= m_blockSize;
480 m_target->
Initialize(parameters, propagation);
494 return m_filter.get() ? m_filter->
Flush(hardFlush, -1, blocking) :
false;
499 m_filter.reset(filter);
505 m_filter->
Attach(temp.release());
509 void ProxyFilter::NextPutMultiple(
const byte *s,
size_t len)
512 m_filter->
Put(s, len);
515 void ProxyFilter::NextPutModifiable(
byte *s,
size_t len)
530 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
535 size_t ArraySink::Put2(
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
537 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
545 memmove(
PtrAdd(m_buf, m_total), begin, copied);
548 return length - copied;
554 return PtrAdd(m_buf, m_total);
562 m_buf = array.
begin();
563 m_size = array.
size();
566 size_t ArrayXorSink::Put2(
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
568 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
578 return length - copied;
586 CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
589 if (authenticatedFilter)
590 throw InvalidArgument(
"StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
593 m_mandatoryBlockSize = m_cipher.MandatoryBlockSize();
594 m_optimalBufferSize = m_cipher.OptimalBlockSize();
595 m_isSpecial = m_cipher.IsLastBlockSpecial() && m_mandatoryBlockSize > 1;
596 m_reservedBufferSize =
STDMAX(2*m_mandatoryBlockSize, m_optimalBufferSize);
607 if (!authenticatedFilter)
609 CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
612 if (authenticatedFilter && !authenticated)
613 throw InvalidArgument(
"StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
616 m_mandatoryBlockSize = m_cipher.MandatoryBlockSize();
617 m_optimalBufferSize = m_cipher.OptimalBlockSize();
618 m_isSpecial = m_cipher.IsLastBlockSpecial() && m_mandatoryBlockSize > 1;
619 m_reservedBufferSize =
STDMAX(2*m_mandatoryBlockSize, m_optimalBufferSize);
628 if (c.MinLastBlockSize() > 0)
629 return c.MinLastBlockSize();
630 else if (c.MandatoryBlockSize() > 1 && !c.IsForwardTransformation() && padding !=
NO_PADDING && padding !=
ZEROS_PADDING)
631 return c.MandatoryBlockSize();
636 void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
639 bool isBlockCipher = (m_mandatoryBlockSize > 1 && m_cipher.
MinLastBlockSize() == 0);
657 blockSize = m_mandatoryBlockSize;
658 lastSize = LastBlockSize(m_cipher, m_padding);
661 void StreamTransformationFilter::FirstPut(
const byte* inString)
663 CRYPTOPP_UNUSED(inString);
664 m_optimalBufferSize = STDMAX<unsigned int>(m_optimalBufferSize,
RoundDownToMultipleOf(4096U, m_optimalBufferSize));
667 void StreamTransformationFilter::NextPutMultiple(
const byte *inString,
size_t length)
675 size_t len = m_optimalBufferSize;
679 if (len == m_optimalBufferSize)
687 inString =
PtrAdd(inString, len);
693 void StreamTransformationFilter::NextPutModifiable(
byte *inString,
size_t length)
699 void StreamTransformationFilter::LastPut(
const byte *inString,
size_t length)
723 const size_t leftOver = length % m_mandatoryBlockSize;
732 inString =
PtrAdd(inString, length);
738 length = m_cipher.
ProcessLastBlock(space, m_reservedBufferSize, inString, leftOver);
744 length = m_cipher.
ProcessLastBlock(space, m_reservedBufferSize, NULLPTR, 0);
760 if (isForwardTransformation && m_padding ==
ZEROS_PADDING && (minLastBlockSize == 0 || length < minLastBlockSize))
763 size_t blockSize =
STDMAX(minLastBlockSize, (
size_t)m_mandatoryBlockSize);
765 if (inString) {memcpy(space, inString, length);}
766 memset(
PtrAdd(space, length), 0, blockSize - length);
767 size_t used = m_cipher.
ProcessLastBlock(space, blockSize, space, blockSize);
772 if (minLastBlockSize == 0)
774 if (isForwardTransformation)
775 throw InvalidDataFormat(
"StreamTransformationFilter: plaintext length is not a multiple of block size and NO_PADDING is specified");
777 throw InvalidCiphertext(
"StreamTransformationFilter: ciphertext length is not a multiple of block size");
792 s = m_mandatoryBlockSize;
798 if (inString) {memcpy(space, inString, length);}
802 byte pad =
static_cast<byte>(s-length);
803 memset(
PtrAdd(space, length), pad, s-length);
808 memset(
PtrAdd(space, length), 0, s-length-1);
809 space[s-1] =
static_cast<byte>(s-length);
813 space[length] = 0x80;
814 memset(
PtrAdd(space, length+1), 0, s-length-1);
822 throw InvalidCiphertext(
"StreamTransformationFilter: ciphertext length is not a multiple of block size");
826 byte pad = space[s-1];
828 throw InvalidCiphertext(
"StreamTransformationFilter: invalid PKCS #7 block padding found");
833 byte pad = space[s - 1];
834 if (pad < 1 || pad > s)
835 throw InvalidCiphertext(
"StreamTransformationFilter: invalid W3C block padding found");
840 while (length > 1 && space[length-1] == 0)
842 if (space[--length] != 0x80)
843 throw InvalidCiphertext(
"StreamTransformationFilter: invalid ones-and-zeros padding found");
857 : m_hashModule(hm), m_putMessage(putMessage), m_digestSize(0), m_space(NULLPTR)
858 , m_messagePutChannel(messagePutChannel), m_hashPutChannel(hashPutChannel)
860 m_digestSize = truncatedDigestSize < 0 ? m_hashModule.DigestSize() : truncatedDigestSize;
868 m_digestSize = s < 0 ? m_hashModule.
DigestSize() : s;
871 size_t HashFilter::Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
875 FILTER_OUTPUT3(1, 0, inString, length, 0, m_messagePutChannel);
876 if (inString && length)
877 m_hashModule.
Update(inString, length);
885 FILTER_OUTPUT3(2, 0, m_space, m_digestSize, messageEnd, m_hashPutChannel);
887 FILTER_END_NO_MESSAGE_END;
894 , m_hashModule(hm), m_flags(0), m_digestSize(0), m_verified(false)
902 void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
906 m_digestSize = s < 0 ? m_hashModule.
DigestSize() : s;
913 void HashVerificationFilter::FirstPut(
const byte *inString)
917 m_expectedHash.
New(m_digestSize);
918 if (inString) {memcpy(m_expectedHash, inString, m_expectedHash.
size());}
924 void HashVerificationFilter::NextPutMultiple(
const byte *inString,
size_t length)
926 m_hashModule.
Update(inString, length);
931 void HashVerificationFilter::LastPut(
const byte *inString,
size_t length)
936 m_verified = m_hashModule.
TruncatedVerify(m_expectedHash, m_digestSize);
940 m_verified = (length==m_digestSize && m_hashModule.
TruncatedVerify(inString, length));
949 throw HashVerificationFailed();
955 bool putAAD,
int truncatedDigestSize,
const std::string &macChannel,
BlockPaddingScheme padding)
976 throw InvalidChannelName(
"AuthenticatedEncryptionFilter", channel);
985 return m_hf.
Put2(begin, length, 0, blocking);
987 throw InvalidChannelName(
"AuthenticatedEncryptionFilter", channel);
992 StreamTransformationFilter::LastPut(inString, length);
1000 , m_hashVerifier(c, new
OutputProxy(*this, false))
1001 , m_streamFilter(c, new
OutputProxy(*this, false), padding, true)
1011 void AuthenticatedDecryptionFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
1018 firstSize = m_hashVerifier.m_firstSize;
1020 lastSize = m_hashVerifier.m_lastSize;
1025 if (channel.empty())
1031 throw InvalidChannelName(
"AuthenticatedDecryptionFilter", channel);
1036 if (channel.empty())
1044 return m_hashVerifier.
Put2(begin, length, 0, blocking);
1046 throw InvalidChannelName(
"AuthenticatedDecryptionFilter", channel);
1049 void AuthenticatedDecryptionFilter::FirstPut(
const byte *inString)
1051 m_hashVerifier.
Put(inString, m_firstSize);
1054 void AuthenticatedDecryptionFilter::NextPutMultiple(
const byte *inString,
size_t length)
1056 m_streamFilter.
Put(inString, length);
1059 void AuthenticatedDecryptionFilter::LastPut(
const byte *inString,
size_t length)
1073 size_t SignerFilter::Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
1076 m_messageAccumulator->
Update(inString, length);
1078 FILTER_OUTPUT(1, inString, length, 0);
1082 m_signer.
Sign(m_rng, m_messageAccumulator.release(), m_buf);
1083 FILTER_OUTPUT(2, m_buf, m_buf.
size(), messageEnd);
1086 FILTER_END_NO_MESSAGE_END;
1091 , m_verifier(verifier), m_flags(0), m_verified(0)
1098 void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
1110 void SignatureVerificationFilter::FirstPut(
const byte *inString)
1119 if (inString) {memcpy(m_signature, inString, m_signature.
size());}
1131 void SignatureVerificationFilter::NextPutMultiple(
const byte *inString,
size_t length)
1133 m_messageAccumulator->
Update(inString, length);
1138 void SignatureVerificationFilter::LastPut(
const byte *inString,
size_t length)
1148 m_verifier.
InputSignature(*m_messageAccumulator, inString, length);
1158 throw SignatureVerificationFailed();
1165 unsigned int messageCount = UINT_MAX;
1168 }
while(messageCount == UINT_MAX);
1184 unsigned int Store::CopyMessagesTo(
BufferedTransformation &target,
unsigned int count,
const std::string &channel)
const
1186 if (m_messageEnd || count == 0)
1190 CopyTo(target, ULONG_MAX, channel);
1197 void StringStore::StoreInitialize(
const NameValuePairs ¶meters)
1202 m_store = array.
begin();
1203 m_length = array.
size();
1210 size_t blockedBytes =
CopyRangeTo2(target, position, transferBytes, channel, blocking);
1211 m_count +=
static_cast<size_t>(position);
1212 transferBytes = position;
1213 return blockedBytes;
1220 size_t blockedBytes = target.
ChannelPut2(channel,
PtrAdd(m_store, i), len, 0, blocking);
1222 begin =
PtrAdd(begin, len);
1223 return blockedBytes;
1226 void RandomNumberStore::StoreInitialize(
const NameValuePairs ¶meters)
1237 throw NotImplemented(
"RandomNumberStore: nonblocking transfer is not implemented by this object");
1239 transferBytes =
UnsignedMin(transferBytes, m_length - m_count);
1241 m_count += transferBytes;
1248 static const byte nullBytes[128] = {0};
1251 size_t len = (size_t)
STDMIN(end-begin,
lword(128));
1252 size_t blockedBytes = target.
ChannelPut2(channel, nullBytes, len, 0, blocking);
1254 return blockedBytes;
1255 begin =
PtrAdd(begin, len);
1264 transferBytes = begin; m_size -= begin;
1265 return blockedBytes;
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.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
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.
@ DEFAULT_FLAGS
Default flags using THROW_EXCEPTION.
AuthenticatedDecryptionFilter(AuthenticatedSymmetricCipher &c, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1, BlockPaddingScheme padding=DEFAULT_PADDING)
Construct a AuthenticatedDecryptionFilter.
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing on a channel.
size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing on a channel.
void LastPut(const byte *inString, size_t length)
Input the last block of data.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
AuthenticatedEncryptionFilter(AuthenticatedSymmetricCipher &c, BufferedTransformation *attachment=NULL, bool putAAD=false, int truncatedDigestSize=-1, const std::string &macChannel=DEFAULT_CHANNEL, BlockPaddingScheme padding=DEFAULT_PADDING)
Construct a AuthenticatedEncryptionFilter.
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Interface for authenticated encryption modes of operation.
int GetAutoSignalPropagation() const
Retrieve automatic signal propagation value.
Used to pass byte array input as part of a NameValuePairs object.
size_t size() const
Length of the memory block.
byte * begin() const
Pointer to the first byte in the memory block.
Combines two sets of NameValuePairs.
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.
Implementation of BufferedTransformation's attachment interface.
void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
Filter(BufferedTransformation *attachment=NULL)
Construct a Filter.
BufferedTransformation * AttachedTransformation()
Retrieve attached transformation.
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const
Copy bytes from this object to another BufferedTransformation.
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
HashFilter(HashTransformation &hm, BufferedTransformation *attachment=NULL, bool putMessage=false, int truncatedDigestSize=-1, const std::string &messagePutChannel=DEFAULT_CHANNEL, const std::string &hashPutChannel=DEFAULT_CHANNEL)
Construct a HashFilter.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1)
Construct a HashVerificationFilter.
@ DEFAULT_FLAGS
Default flags using HASH_AT_BEGIN and PUT_RESULT.
@ HASH_AT_BEGIN
The hash is at the beginning of the message (i.e., concatenation of hash+message)
@ THROW_EXCEPTION
The filter should throw a HashVerificationFailed if a failure is encountered.
@ PUT_HASH
The hash should be passed to an attached transformation.
@ PUT_MESSAGE
The message should be passed to an attached transformation.
@ PUT_RESULT
The result of the verification should be passed to an attached transformation.
An invalid argument was detected.
A decryption filter encountered invalid ciphertext.
size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee.
void AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow=true)
Adds a range to skip during processing.
void ResetMeter()
Resets the meter.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
bool IsolatedMessageSeriesEnd(bool blocking)
Marks the end of a series of messages, without signal propagation.
Interface for retrieving values given their names.
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
bool GetValue(const char *name, T &value) const
Get a named value.
CRYPTOPP_DLL int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
CRYPTOPP_DLL void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
A method was called which was not implemented.
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const
Copy bytes from this object to another BufferedTransformation.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Filter class that is a proxy for a sink.
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
virtual size_t SignatureLength() const =0
Provides the signature length if it only depends on the key.
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0
Create a new HashTransformation to accumulate the message to be signed.
Interface for public-key signature verifiers.
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0
Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulat...
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0
Input signature into a message accumulator.
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
Construct a ProxyFilter.
void SetFilter(Filter *filter)
Sets the OutputProxy filter.
bool IsolatedFlush(bool hardFlush, bool blocking)
Flushes data buffered by this object, without signal propagation.
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
@ PASS_EVERYTHING
Pass everything.
bool GetPassSignals() const
Retrieve signal propagation behavior.
void Initialize(const NameValuePairs ¶meters, int propagation)
Initialize or reinitialize this object, with signal propagation.
void New(size_type newSize)
Change size without preserving contents.
size_type size() const
Provides the count of elements in the SecBlock.
@ SIGNATURE_AT_BEGIN
The signature is at the beginning of the message (i.e., concatenation of signature+message)
@ THROW_EXCEPTION
The filter should throw a HashVerificationFailed if a failure is encountered.
@ DEFAULT_FLAGS
Default flags using SIGNATURE_AT_BEGIN and PUT_RESULT.
@ PUT_MESSAGE
The message should be passed to an attached transformation.
@ PUT_RESULT
The result of the verification should be passed to an attached transformation.
@ PUT_SIGNATURE
The signature should be passed to an attached transformation.
SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS)
Construct a SignatureVerificationFilter.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
virtual size_t PumpMessages2(unsigned int &messageCount, bool blocking=true)=0
Pump messages to attached transformation.
virtual size_t PumpAll2(bool blocking=true)
Pump all data to attached transformation.
bool GetNextMessage()
Start retrieving the next message.
CRYPTOPP_DLL size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const
Copy bytes from this object to another BufferedTransformation.
CRYPTOPP_DLL size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Pointer that overloads operator ->
Library configuration file.
unsigned int word32
32-bit unsigned datatype
word64 lword
Large word type.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
Implementation of BufferedTransformation's attachment interface.
Utility functions for the Crypto++ library.
T1 SaturatingSubtract(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 0.
#define SIZE_MAX
The maximum value of a machine word.
ptrdiff_t PtrDiff(const PTR pointer1, const PTR pointer2)
Determine pointer difference.
T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
Rounds a value down to a multiple of a second value.
InputIt FindIfNot(InputIt first, InputIt last, const T &value)
Finds first element not in a range.
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
CRYPTOPP_DLL void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
Crypto++ library namespace.
const char * TruncatedDigestSize()
int
const char * AuthenticatedDecryptionFilterFlags()
word32
const char * BlockPaddingScheme()
StreamTransformationFilter::BlockPaddingScheme.
const char * OutputBuffer()
ByteArrayParameter.
const char * HashVerificationFilterFlags()
word32
const char * PutMessage()
bool
const char * InputBuffer()
ConstByteArrayParameter.
const char * SignatureVerificationFilterFlags()
word32
Classes for automatic resource management.
BlockPaddingScheme
Padding schemes used for block ciphers.
@ DEFAULT_PADDING
Default padding scheme.
@ W3C_PADDING
W3C padding added to a block.
@ PKCS_PADDING
PKCS padding added to a block.
@ ONE_AND_ZEROS_PADDING
1 and 0's padding added to a block
@ NO_PADDING
No padding added to a block.
@ ZEROS_PADDING
0's padding added to a block
byte * HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize)
Create a working space in a BufferedTransformation.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.