6 #if CRYPTOPP_MSC_VERSION
7 # pragma warning(disable: 4189 4355)
10 #ifndef CRYPTOPP_IMPORTS
23 : m_attachment(attachment), m_inputPosition(0), m_continueAt(0)
34 if (m_attachment.get() == NULLPTR)
35 m_attachment.reset(NewDefaultAttachment());
36 return m_attachment.get();
41 if (m_attachment.get() == NULLPTR)
42 const_cast<Filter *
>(
this)->m_attachment.reset(NewDefaultAttachment());
43 return m_attachment.get();
48 m_attachment.reset(newOut);
51 void Filter::Insert(
Filter *filter)
53 filter->m_attachment.reset(m_attachment.release());
54 m_attachment.reset(filter);
69 m_inputPosition = m_continueAt = 0;
71 PropagateInitialize(parameters, propagation);
74 bool Filter::Flush(
bool hardFlush,
int propagation,
bool blocking)
83 if (OutputFlush(1, hardFlush, propagation, blocking))
100 if (ShouldPropagateMessageSeriesEnd() && OutputMessageSeriesEnd(1, propagation, blocking))
108 void Filter::PropagateInitialize(
const NameValuePairs ¶meters,
int propagation)
114 size_t Filter::OutputModifiable(
int outputSite,
byte *inString,
size_t length,
int messageEnd,
bool blocking,
const std::string &channel)
119 m_continueAt = result ? outputSite : 0;
123 size_t Filter::Output(
int outputSite,
const byte *inString,
size_t length,
int messageEnd,
bool blocking,
const std::string &channel)
128 m_continueAt = result ? outputSite : 0;
132 bool Filter::OutputFlush(
int outputSite,
bool hardFlush,
int propagation,
bool blocking,
const std::string &channel)
136 m_continueAt = outputSite;
143 bool Filter::OutputMessageSeriesEnd(
int outputSite,
int propagation,
bool blocking,
const std::string &channel)
147 m_continueAt = outputSite;
158 m_currentMessageBytes = m_totalBytes = m_currentSeriesMessages = m_totalMessages = m_totalMessageSeries = 0;
159 m_rangesToSkip.clear();
164 MessageRange r = {message, position, size};
165 m_rangesToSkip.push_back(r);
167 std::sort(m_rangesToSkip.begin(), m_rangesToSkip.end());
170 size_t MeterFilter::PutMaybeModifiable(
byte *begin,
size_t length,
int messageEnd,
bool blocking,
bool modifiable)
181 while (m_length > 0 || messageEnd)
183 if (m_length > 0 && !m_rangesToSkip.empty() && m_rangesToSkip.front().message == m_totalMessages && m_currentMessageBytes + m_length > m_rangesToSkip.front().position)
185 FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (
size_t)
SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes),
false, modifiable);
188 m_begin =
PtrAdd(m_begin, t);
190 m_currentMessageBytes += t;
193 if (m_currentMessageBytes + m_length < m_rangesToSkip.front().position + m_rangesToSkip.front().size)
197 t = (size_t)
SaturatingSubtract(m_rangesToSkip.front().position + m_rangesToSkip.front().size, m_currentMessageBytes);
199 m_rangesToSkip.pop_front();
202 m_begin =
PtrAdd(m_begin, t);
204 m_currentMessageBytes += t;
209 FILTER_OUTPUT_MAYBE_MODIFIABLE(2, m_begin, m_length, messageEnd, modifiable);
211 m_currentMessageBytes += m_length;
212 m_totalBytes += m_length;
217 m_currentMessageBytes = 0;
218 m_currentSeriesMessages++;
225 FILTER_END_NO_MESSAGE_END;
228 size_t MeterFilter::Put2(
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
230 return PutMaybeModifiable(
const_cast<byte *
>(begin), length, messageEnd, blocking,
false);
235 return PutMaybeModifiable(begin, length, messageEnd, blocking,
true);
240 CRYPTOPP_UNUSED(blocking);
241 m_currentMessageBytes = 0;
242 m_currentSeriesMessages = 0;
243 m_totalMessageSeries++;
249 void FilterWithBufferedInput::BlockQueue::ResetQueue(
size_t blockSize,
size_t maxBlocks)
251 m_buffer.New(blockSize * maxBlocks);
252 m_blockSize = blockSize;
253 m_maxBlocks = maxBlocks;
258 byte *FilterWithBufferedInput::BlockQueue::GetBlock()
260 if (m_size >= m_blockSize)
263 if ((m_begin =
PtrAdd(m_begin, m_blockSize)) == m_buffer.end())
265 m_size -= m_blockSize;
272 byte *FilterWithBufferedInput::BlockQueue::GetContigousBlocks(
size_t &numberOfBytes)
274 numberOfBytes =
STDMIN(numberOfBytes, STDMIN<size_t>(
PtrDiff(m_buffer.end(), m_begin), m_size));
276 m_begin =
PtrAdd(m_begin, numberOfBytes);
277 m_size -= numberOfBytes;
278 if (m_size == 0 || m_begin == m_buffer.end())
283 size_t FilterWithBufferedInput::BlockQueue::GetAll(
byte *outString)
286 if (!outString)
return 0;
288 size_t size = m_size;
289 size_t numberOfBytes = m_maxBlocks*m_blockSize;
290 const byte *ptr = GetContigousBlocks(numberOfBytes);
291 std::memcpy(outString, ptr, numberOfBytes);
292 std::memcpy(
PtrAdd(outString, numberOfBytes), m_begin, m_size);
297 void FilterWithBufferedInput::BlockQueue::Put(
const byte *inString,
size_t length)
300 if (!inString || !length)
return;
303 byte *end = (m_size < static_cast<size_t>(
PtrDiff(m_buffer.end(), m_begin)) ?
304 PtrAdd(m_begin, m_size) :
PtrAdd(m_begin, m_size - m_buffer.size()));
305 size_t len =
STDMIN(length,
size_t(m_buffer.end()-end));
306 std::memcpy(end, inString, len);
308 std::memcpy(m_buffer,
PtrAdd(inString, len), length-len);
313 :
Filter(attachment), m_firstSize(
SIZE_MAX), m_blockSize(0), m_lastSize(
SIZE_MAX), m_firstInputDone(false)
318 :
Filter(attachment), m_firstSize(firstSize), m_blockSize(blockSize), m_lastSize(lastSize), m_firstInputDone(false)
323 m_queue.ResetQueue(1, m_firstSize);
328 InitializeDerivedAndReturnNewSizes(parameters, m_firstSize, m_blockSize, m_lastSize);
331 m_queue.ResetQueue(1, m_firstSize);
332 m_firstInputDone =
false;
338 throw BlockingInputOnly(
"FilterWithBufferedInput");
347 size_t FilterWithBufferedInput::PutMaybeModifiable(
byte *inString,
size_t length,
int messageEnd,
bool blocking,
bool modifiable)
350 throw BlockingInputOnly(
"FilterWithBufferedInput");
354 size_t newLength = m_queue.CurrentSize() + length;
356 if (!m_firstInputDone && newLength >= m_firstSize)
358 size_t len = m_firstSize - m_queue.CurrentSize();
359 m_queue.Put(inString, len);
360 FirstPut(m_queue.GetContigousBlocks(m_firstSize));
362 m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
364 inString =
PtrAdd(inString, len);
365 newLength -= m_firstSize;
366 m_firstInputDone =
true;
369 if (m_firstInputDone)
371 if (m_blockSize == 1)
373 while (newLength > m_lastSize && m_queue.CurrentSize() > 0)
375 size_t len = newLength - m_lastSize;
376 byte *ptr = m_queue.GetContigousBlocks(len);
377 NextPutModifiable(ptr, len);
381 if (newLength > m_lastSize)
383 size_t len = newLength - m_lastSize;
384 NextPutMaybeModifiable(inString, len, modifiable);
385 inString =
PtrAdd(inString, len);
391 while (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() >= m_blockSize)
393 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
394 newLength -= m_blockSize;
397 if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
400 size_t len = m_blockSize - m_queue.CurrentSize();
401 m_queue.Put(inString, len);
402 inString =
PtrAdd(inString, len);
403 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
404 newLength -= m_blockSize;
407 if (newLength >= m_blockSize + m_lastSize)
410 NextPutMaybeModifiable(inString, len, modifiable);
411 inString =
PtrAdd(inString, len);
417 m_queue.Put(inString, newLength - m_queue.CurrentSize());
422 if (!m_firstInputDone && m_firstSize==0)
426 m_queue.GetAll(temp);
427 LastPut(temp, temp.size());
429 m_firstInputDone =
false;
430 m_queue.ResetQueue(1, m_firstSize);
433 (void)Output(1, NULLPTR, 0, messageEnd, blocking);
440 if (!m_firstInputDone)
445 while (m_queue.CurrentSize() >= m_blockSize)
446 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
451 while ((len = m_queue.CurrentSize()) > 0)
452 NextPutModifiable(m_queue.GetContigousBlocks(len), len);
456 void FilterWithBufferedInput::NextPutMultiple(
const byte *inString,
size_t length)
462 NextPutSingle(inString);
463 inString =
PtrAdd(inString, m_blockSize);
464 length -= m_blockSize;
476 m_target->
Initialize(parameters, propagation);
490 return m_filter.get() ? m_filter->
Flush(hardFlush, -1, blocking) :
false;
495 m_filter.reset(filter);
501 m_filter->
Attach(temp.release());
505 void ProxyFilter::NextPutMultiple(
const byte *s,
size_t len)
508 m_filter->
Put(s, len);
511 void ProxyFilter::NextPutModifiable(
byte *s,
size_t len)
526 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
531 size_t ArraySink::Put2(
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
533 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
541 std::memmove(
PtrAdd(m_buf, m_total), begin, copied);
544 return length - copied;
550 return PtrAdd(m_buf, m_total);
556 if (!parameters.
GetValue(Name::OutputBuffer(), array))
558 m_buf = array.
begin();
559 m_size = array.
size();
562 size_t ArrayXorSink::Put2(
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
564 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
574 return length - copied;
582 CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
585 if (authenticatedFilter)
586 throw InvalidArgument(
"StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
589 m_mandatoryBlockSize = m_cipher.MandatoryBlockSize();
590 m_optimalBufferSize = m_cipher.OptimalBlockSize();
591 m_isSpecial = m_cipher.IsLastBlockSpecial() && m_mandatoryBlockSize > 1;
592 m_reservedBufferSize =
STDMAX(2*m_mandatoryBlockSize, m_optimalBufferSize);
596 (Name::BlockPaddingScheme(), padding));
603 if (!authenticatedFilter)
605 CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
608 if (authenticatedFilter && !authenticated)
609 throw InvalidArgument(
"StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
612 m_mandatoryBlockSize = m_cipher.MandatoryBlockSize();
613 m_optimalBufferSize = m_cipher.OptimalBlockSize();
614 m_isSpecial = m_cipher.IsLastBlockSpecial() && m_mandatoryBlockSize > 1;
615 m_reservedBufferSize =
STDMAX(2*m_mandatoryBlockSize, m_optimalBufferSize);
619 (Name::BlockPaddingScheme(), padding));
622 size_t StreamTransformationFilter::LastBlockSize(
StreamTransformation &c, BlockPaddingScheme padding)
624 if (c.MinLastBlockSize() > 0)
625 return c.MinLastBlockSize();
626 else if (c.MandatoryBlockSize() > 1 && !c.IsForwardTransformation() && padding !=
NO_PADDING && padding !=
ZEROS_PADDING)
627 return c.MandatoryBlockSize();
632 void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
635 bool isBlockCipher = (m_mandatoryBlockSize > 1 && m_cipher.
MinLastBlockSize() == 0);
653 blockSize = m_mandatoryBlockSize;
654 lastSize = LastBlockSize(m_cipher, m_padding);
657 void StreamTransformationFilter::FirstPut(
const byte* inString)
659 CRYPTOPP_UNUSED(inString);
660 m_optimalBufferSize = STDMAX<unsigned int>(m_optimalBufferSize,
RoundDownToMultipleOf(4096U, m_optimalBufferSize));
663 void StreamTransformationFilter::NextPutMultiple(
const byte *inString,
size_t length)
671 size_t len = m_optimalBufferSize;
675 if (len == m_optimalBufferSize)
683 inString =
PtrAdd(inString, len);
689 void StreamTransformationFilter::NextPutModifiable(
byte *inString,
size_t length)
695 void StreamTransformationFilter::LastPut(
const byte *inString,
size_t length)
719 const size_t leftOver = length % m_mandatoryBlockSize;
728 inString =
PtrAdd(inString, length);
734 length = m_cipher.
ProcessLastBlock(space, m_reservedBufferSize, inString, leftOver);
740 length = m_cipher.
ProcessLastBlock(space, m_reservedBufferSize, NULLPTR, 0);
756 if (isForwardTransformation && m_padding ==
ZEROS_PADDING && (minLastBlockSize == 0 || length < minLastBlockSize))
759 size_t blockSize =
STDMAX(minLastBlockSize, (
size_t)m_mandatoryBlockSize);
761 if (inString) {std::memcpy(space, inString, length);}
762 std::memset(
PtrAdd(space, length), 0, blockSize - length);
763 size_t used = m_cipher.
ProcessLastBlock(space, blockSize, space, blockSize);
768 if (minLastBlockSize == 0)
770 if (isForwardTransformation)
771 throw InvalidDataFormat(
"StreamTransformationFilter: plaintext length is not a multiple of block size and NO_PADDING is specified");
773 throw InvalidCiphertext(
"StreamTransformationFilter: ciphertext length is not a multiple of block size");
788 s = m_mandatoryBlockSize;
794 if (inString) {std::memcpy(space, inString, length);}
798 byte pad =
static_cast<byte>(s-length);
799 std::memset(
PtrAdd(space, length), pad, s-length);
804 std::memset(
PtrAdd(space, length), 0, s-length-1);
805 space[s-1] =
static_cast<byte>(s-length);
809 space[length] = 0x80;
810 std::memset(
PtrAdd(space, length+1), 0, s-length-1);
818 throw InvalidCiphertext(
"StreamTransformationFilter: ciphertext length is not a multiple of block size");
822 byte pad = space[s-1];
824 throw InvalidCiphertext(
"StreamTransformationFilter: invalid PKCS #7 block padding found");
829 byte pad = space[s - 1];
830 if (pad < 1 || pad > s)
831 throw InvalidCiphertext(
"StreamTransformationFilter: invalid W3C block padding found");
836 while (length > 1 && space[length-1] == 0)
838 if (space[--length] != 0x80)
839 throw InvalidCiphertext(
"StreamTransformationFilter: invalid ones-and-zeros padding found");
853 : m_hashModule(hm), m_putMessage(putMessage), m_digestSize(0), m_space(NULLPTR)
854 , m_messagePutChannel(messagePutChannel), m_hashPutChannel(hashPutChannel)
856 m_digestSize = truncatedDigestSize < 0 ? m_hashModule.DigestSize() : truncatedDigestSize;
864 m_digestSize = s < 0 ? m_hashModule.
DigestSize() : s;
867 size_t HashFilter::Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
871 FILTER_OUTPUT3(1, 0, inString, length, 0, m_messagePutChannel);
872 if (inString && length)
873 m_hashModule.
Update(inString, length);
881 FILTER_OUTPUT3(2, 0, m_space, m_digestSize, messageEnd, m_hashPutChannel);
883 FILTER_END_NO_MESSAGE_END;
890 , m_hashModule(hm), m_flags(0), m_digestSize(0), m_verified(false)
894 (Name::HashVerificationFilterFlags(), flags)
895 (Name::TruncatedDigestSize(), truncatedDigestSize));
898 void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
902 m_digestSize = s < 0 ? m_hashModule.
DigestSize() : s;
909 void HashVerificationFilter::FirstPut(
const byte *inString)
913 m_expectedHash.
New(m_digestSize);
914 if (inString) {std::memcpy(m_expectedHash, inString, m_expectedHash.
size());}
920 void HashVerificationFilter::NextPutMultiple(
const byte *inString,
size_t length)
922 m_hashModule.
Update(inString, length);
927 void HashVerificationFilter::LastPut(
const byte *inString,
size_t length)
932 m_verified = m_hashModule.
TruncatedVerify(m_expectedHash, m_digestSize);
936 m_verified = (length==m_digestSize && m_hashModule.
TruncatedVerify(inString, length));
945 throw HashVerificationFailed();
951 bool putAAD,
int truncatedDigestSize,
const std::string &macChannel, BlockPaddingScheme padding)
972 throw InvalidChannelName(
"AuthenticatedEncryptionFilter", channel);
981 return m_hf.
Put2(begin, length, 0, blocking);
983 throw InvalidChannelName(
"AuthenticatedEncryptionFilter", channel);
988 StreamTransformationFilter::LastPut(inString, length);
997 , m_streamFilter(c, new
OutputProxy(*this, false), padding, true)
1002 (Name::BlockPaddingScheme(), padding)
1003 (Name::AuthenticatedDecryptionFilterFlags(), flags)
1004 (Name::TruncatedDigestSize(), truncatedDigestSize));
1007 void AuthenticatedDecryptionFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
1014 firstSize = m_hashVerifier.m_firstSize;
1016 lastSize = m_hashVerifier.m_lastSize;
1021 if (channel.empty())
1027 throw InvalidChannelName(
"AuthenticatedDecryptionFilter", channel);
1032 if (channel.empty())
1040 return m_hashVerifier.
Put2(begin, length, 0, blocking);
1042 throw InvalidChannelName(
"AuthenticatedDecryptionFilter", channel);
1045 void AuthenticatedDecryptionFilter::FirstPut(
const byte *inString)
1047 m_hashVerifier.
Put(inString, m_firstSize);
1050 void AuthenticatedDecryptionFilter::NextPutMultiple(
const byte *inString,
size_t length)
1052 m_streamFilter.
Put(inString, length);
1055 void AuthenticatedDecryptionFilter::LastPut(
const byte *inString,
size_t length)
1069 size_t SignerFilter::Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
1072 m_messageAccumulator->
Update(inString, length);
1074 FILTER_OUTPUT(1, inString, length, 0);
1078 m_signer.
Sign(m_rng, m_messageAccumulator.release(), m_buf);
1079 FILTER_OUTPUT(2, m_buf, m_buf.
size(), messageEnd);
1082 FILTER_END_NO_MESSAGE_END;
1087 , m_verifier(verifier), m_flags(0), m_verified(0)
1091 (Name::SignatureVerificationFilterFlags(), flags));
1094 void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
1106 void SignatureVerificationFilter::FirstPut(
const byte *inString)
1115 if (inString) {std::memcpy(m_signature, inString, m_signature.
size());}
1127 void SignatureVerificationFilter::NextPutMultiple(
const byte *inString,
size_t length)
1129 m_messageAccumulator->
Update(inString, length);
1134 void SignatureVerificationFilter::LastPut(
const byte *inString,
size_t length)
1144 m_verifier.
InputSignature(*m_messageAccumulator, inString, length);
1154 throw SignatureVerificationFailed();
1161 unsigned int messageCount = UINT_MAX;
1164 }
while(messageCount == UINT_MAX);
1180 unsigned int Store::CopyMessagesTo(
BufferedTransformation &target,
unsigned int count,
const std::string &channel)
const
1182 if (m_messageEnd || count == 0)
1186 CopyTo(target, ULONG_MAX, channel);
1193 void StringStore::StoreInitialize(
const NameValuePairs ¶meters)
1196 if (!parameters.
GetValue(Name::InputBuffer(), array))
1198 m_store = array.
begin();
1199 m_length = array.
size();
1206 size_t blockedBytes =
CopyRangeTo2(target, position, transferBytes, channel, blocking);
1207 m_count +=
static_cast<size_t>(position);
1208 transferBytes = position;
1209 return blockedBytes;
1216 size_t blockedBytes = target.
ChannelPut2(channel,
PtrAdd(m_store, i), len, 0, blocking);
1218 begin =
PtrAdd(begin, len);
1219 return blockedBytes;
1222 void RandomNumberStore::StoreInitialize(
const NameValuePairs ¶meters)
1233 throw NotImplemented(
"RandomNumberStore: nonblocking transfer is not implemented by this object");
1235 transferBytes =
UnsignedMin(transferBytes, m_length - m_count);
1237 m_count += transferBytes;
1244 static const byte nullBytes[128] = {0};
1247 size_t len = (size_t)
STDMIN(end-begin,
lword(128));
1248 size_t blockedBytes = target.
ChannelPut2(channel, nullBytes, len, 0, blocking);
1250 return blockedBytes;
1251 begin =
PtrAdd(begin, len);
1260 transferBytes = begin; m_size -= begin;
1261 return blockedBytes;