Crypto++
8.6
Free C++ class library of cryptographic schemes
|
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;
@ W3C_PADDING
W3C padding added to a block.
@ PKCS_PADDING
PKCS padding added to a block.
@ ZEROS_PADDING
0's padding added to a block
@ PUT_HASH
The hash should be passed to an attached transformation.
const char * HashVerificationFilterFlags()
word32
size_t size() const
Length of the memory block.
virtual size_t PumpMessages2(unsigned int &messageCount, bool blocking=true)=0
Pump messages to attached transformation.
HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1)
Construct a HashVerificationFilter.
@ PUT_RESULT
The result of the verification should be passed to an attached transformation.
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
void ResetMeter()
Resets the meter.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
Pointer that overloads operator ->
A method was called which was not implemented.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
BlockPaddingScheme
Padding schemes used for block ciphers.
bool IsolatedMessageSeriesEnd(bool blocking)
Marks the end of a series of messages, without signal propagation.
void LastPut(const byte *inString, size_t length)
Input the last block of data.
byte * begin() const
Pointer to the first byte in the memory block.
CRYPTOPP_DLL void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
@ PUT_MESSAGE
The message should be passed to an attached transformation.
Filter class that is a proxy for a sink.
Filter(BufferedTransformation *attachment=NULL)
Construct a Filter.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
void SetFilter(Filter *filter)
Sets the OutputProxy filter.
virtual size_t SignatureLength() const =0
Provides the signature length if it only depends on the key.
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.
Used to pass byte array input as part of a NameValuePairs object.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
const char * BlockPaddingScheme()
StreamTransformationFilter::BlockPaddingScheme.
ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
Construct a ProxyFilter.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be negative and incorrectly promoted.
Classes for automatic resource management.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
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.
const char * TruncatedDigestSize()
int
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.
#define SIZE_MAX
The maximum value of a machine word.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
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.
unsigned int word32
32-bit unsigned datatype
@ PUT_SIGNATURE
The signature should be passed to an attached transformation.
bool GetPassSignals() const
Retrieve signal propagation behavior.
@ DEFAULT_PADDING
Default padding scheme.
@ DEFAULT_FLAGS
Default flags using SIGNATURE_AT_BEGIN and PUT_RESULT.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
Implementation of BufferedTransformation's attachment interface.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
const char * OutputBuffer()
ByteArrayParameter.
Standard names for retrieving values by name when working with NameValuePairs.
Utility functions for the Crypto++ library.
BufferedTransformation * AttachedTransformation()
Retrieve attached transformation.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
bool GetNextMessage()
Start retrieving the next message.
Implementation of BufferedTransformation's attachment interface.
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
const char * PutMessage()
bool
int GetAutoSignalPropagation() const
Retrieve automatic signal propagation value.
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
byte * HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize)
Create a working space in a BufferedTransformation.
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
const char * AuthenticatedDecryptionFilterFlags()
word32
void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
@ DEFAULT_FLAGS
Default flags using HASH_AT_BEGIN and PUT_RESULT.
@ DEFAULT_FLAGS
Default flags using THROW_EXCEPTION.
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0
Create a new HashTransformation to accumulate the message to be signed.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
void AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow=true)
Adds a range to skip during processing.
@ HASH_AT_BEGIN
The hash is at the beginning of the message (i.e., concatenation of hash+message)
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
@ THROW_EXCEPTION
The filter should throw a HashVerificationFailed if a failure is encountered.
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 New(size_type newSize)
Change size without preserving contents.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
const char * SignatureVerificationFilterFlags()
word32
@ NO_PADDING
No padding added to a block.
size_type size() const
Provides the count of elements in the SecBlock.
word64 lword
Large word type.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
@ THROW_EXCEPTION
The filter should throw a HashVerificationFailed if a failure is encountered.
InputIt FindIfNot(InputIt first, InputIt last, const T &value)
Finds first element not in a range.
An invalid argument was detected.
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
const char * InputBuffer()
ConstByteArrayParameter.
SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS)
Construct a SignatureVerificationFilter.
const byte * begin() const
Pointer to the first byte in the memory block.
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Interface for public-key signature verifiers.
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.
Data structure used to store messages.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
@ PUT_RESULT
The result of the verification should be passed to an attached transformation.
Crypto++ library namespace.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
void Initialize(const NameValuePairs ¶meters, int propagation)
Initialize or reinitialize this object, with signal propagation.
Classes for an unlimited queue to store messages.
bool GetValue(const char *name, T &value) const
Get a named value.
T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
Rounds a value down to a multiple of a second value.
Library configuration file.
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0
Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulat...
Combines two sets of NameValuePairs.
CRYPTOPP_DLL void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
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.
T1 SaturatingSubtract(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 0.
size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee.
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
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.
@ PUT_MESSAGE
The message should be passed to an attached transformation.
ptrdiff_t PtrDiff(const PTR pointer1, const PTR pointer2)
Determine pointer difference.
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0
Input signature into a message accumulator.
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.
@ ONE_AND_ZEROS_PADDING
1 and 0's padding added to a block
CRYPTOPP_DLL int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
bool IsolatedFlush(bool hardFlush, bool blocking)
Flushes data buffered by this object, without signal propagation.
Interface for retrieving values given their names.
Used to pass byte array input as part of a NameValuePairs object.
@ PASS_EVERYTHING
Pass everything.
@ SIGNATURE_AT_BEGIN
The signature is at the beginning of the message (i.e., concatenation of signature+message)
Interface for authenticated encryption modes of operation.
virtual size_t PumpAll2(bool blocking=true)
Pump all data to attached transformation.
size_t size() const
Length of the memory block.
A decryption filter encountered invalid ciphertext.