Crypto++ 8.2
Free C&
filters.cpp
1// filters.cpp - originally written and placed in the public domain by Wei Dai
2
3#include "pch.h"
4#include "config.h"
5
6#if CRYPTOPP_MSC_VERSION
7# pragma warning(disable: 4100 4189 4355)
8#endif
9
10#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
11# pragma GCC diagnostic ignored "-Wunused-value"
12#endif
13
14#ifndef CRYPTOPP_IMPORTS
15
16#include "filters.h"
17#include "mqueue.h"
18#include "fltrimpl.h"
19#include "argnames.h"
20#include "smartptr.h"
21#include "stdcpp.h"
22#include "misc.h"
23
24NAMESPACE_BEGIN(CryptoPP)
25
27 : m_attachment(attachment), m_inputPosition(0), m_continueAt(0)
28{
29}
30
31BufferedTransformation * Filter::NewDefaultAttachment() const
32{
33 return new MessageQueue;
34}
35
37{
38 if (m_attachment.get() == NULLPTR)
39 m_attachment.reset(NewDefaultAttachment());
40 return m_attachment.get();
41}
42
44{
45 if (m_attachment.get() == NULLPTR)
46 const_cast<Filter *>(this)->m_attachment.reset(NewDefaultAttachment());
47 return m_attachment.get();
48}
49
51{
52 m_attachment.reset(newOut);
53}
54
55void Filter::Insert(Filter *filter)
56{
57 filter->m_attachment.reset(m_attachment.release());
58 m_attachment.reset(filter);
59}
60
61size_t Filter::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
62{
63 return AttachedTransformation()->CopyRangeTo2(target, begin, end, channel, blocking);
64}
65
66size_t Filter::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
67{
68 return AttachedTransformation()->TransferTo2(target, transferBytes, channel, blocking);
69}
70
71void Filter::Initialize(const NameValuePairs &parameters, int propagation)
72{
73 m_inputPosition = m_continueAt = 0;
74 IsolatedInitialize(parameters);
75 PropagateInitialize(parameters, propagation);
76}
77
78bool Filter::Flush(bool hardFlush, int propagation, bool blocking)
79{
80 switch (m_continueAt)
81 {
82 case 0:
83 if (IsolatedFlush(hardFlush, blocking))
84 return true;
85 // fall through
86 case 1:
87 if (OutputFlush(1, hardFlush, propagation, blocking))
88 return true;
89 // fall through
90 default: ;;
91 }
92 return false;
93}
94
95bool Filter::MessageSeriesEnd(int propagation, bool blocking)
96{
97 switch (m_continueAt)
98 {
99 case 0:
100 if (IsolatedMessageSeriesEnd(blocking))
101 return true;
102 // fall through
103 case 1:
104 if (ShouldPropagateMessageSeriesEnd() && OutputMessageSeriesEnd(1, propagation, blocking))
105 return true;
106 // fall through
107 default: ;;
108 }
109 return false;
110}
111
112void Filter::PropagateInitialize(const NameValuePairs &parameters, int propagation)
113{
114 if (propagation)
115 AttachedTransformation()->Initialize(parameters, propagation-1);
116}
117
118size_t Filter::OutputModifiable(int outputSite, byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel)
119{
120 if (messageEnd)
121 messageEnd--;
122 size_t result = AttachedTransformation()->ChannelPutModifiable2(channel, inString, length, messageEnd, blocking);
123 m_continueAt = result ? outputSite : 0;
124 return result;
125}
126
127size_t Filter::Output(int outputSite, const byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel)
128{
129 if (messageEnd)
130 messageEnd--;
131 size_t result = AttachedTransformation()->ChannelPut2(channel, inString, length, messageEnd, blocking);
132 m_continueAt = result ? outputSite : 0;
133 return result;
134}
135
136bool Filter::OutputFlush(int outputSite, bool hardFlush, int propagation, bool blocking, const std::string &channel)
137{
138 if (propagation && AttachedTransformation()->ChannelFlush(channel, hardFlush, propagation-1, blocking))
139 {
140 m_continueAt = outputSite;
141 return true;
142 }
143 m_continueAt = 0;
144 return false;
145}
146
147bool Filter::OutputMessageSeriesEnd(int outputSite, int propagation, bool blocking, const std::string &channel)
148{
149 if (propagation && AttachedTransformation()->ChannelMessageSeriesEnd(channel, propagation-1, blocking))
150 {
151 m_continueAt = outputSite;
152 return true;
153 }
154 m_continueAt = 0;
155 return false;
156}
157
158// *************************************************************
159
161{
162 m_currentMessageBytes = m_totalBytes = m_currentSeriesMessages = m_totalMessages = m_totalMessageSeries = 0;
163 m_rangesToSkip.clear();
164}
165
166void MeterFilter::AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow)
167{
168 MessageRange r = {message, position, size};
169 m_rangesToSkip.push_back(r);
170 if (sortNow)
171 std::sort(m_rangesToSkip.begin(), m_rangesToSkip.end());
172}
173
174size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEnd, bool blocking, bool modifiable)
175{
176 if (!m_transparent)
177 return 0;
178
179 size_t t;
180 FILTER_BEGIN;
181
182 m_begin = begin;
183 m_length = length;
184
185 while (m_length > 0 || messageEnd)
186 {
187 if (m_length > 0 && !m_rangesToSkip.empty() && m_rangesToSkip.front().message == m_totalMessages && m_currentMessageBytes + m_length > m_rangesToSkip.front().position)
188 {
189 FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes), false, modifiable);
190
191 CRYPTOPP_ASSERT(t < m_length);
192 m_begin = PtrAdd(m_begin, t);
193 m_length -= t;
194 m_currentMessageBytes += t;
195 m_totalBytes += t;
196
197 if (m_currentMessageBytes + m_length < m_rangesToSkip.front().position + m_rangesToSkip.front().size)
198 t = m_length;
199 else
200 {
201 t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position + m_rangesToSkip.front().size, m_currentMessageBytes);
202 CRYPTOPP_ASSERT(t <= m_length);
203 m_rangesToSkip.pop_front();
204 }
205
206 m_begin = PtrAdd(m_begin, t);
207 m_length -= t;
208 m_currentMessageBytes += t;
209 m_totalBytes += t;
210 }
211 else
212 {
213 FILTER_OUTPUT_MAYBE_MODIFIABLE(2, m_begin, m_length, messageEnd, modifiable);
214
215 m_currentMessageBytes += m_length;
216 m_totalBytes += m_length;
217 m_length = 0;
218
219 if (messageEnd)
220 {
221 m_currentMessageBytes = 0;
222 m_currentSeriesMessages++;
223 m_totalMessages++;
224 messageEnd = false;
225 }
226 }
227 }
228
229 FILTER_END_NO_MESSAGE_END;
230}
231
232size_t MeterFilter::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
233{
234 return PutMaybeModifiable(const_cast<byte *>(begin), length, messageEnd, blocking, false);
235}
236
237size_t MeterFilter::PutModifiable2(byte *begin, size_t length, int messageEnd, bool blocking)
238{
239 return PutMaybeModifiable(begin, length, messageEnd, blocking, true);
240}
241
243{
244 CRYPTOPP_UNUSED(blocking);
245 m_currentMessageBytes = 0;
246 m_currentSeriesMessages = 0;
247 m_totalMessageSeries++;
248 return false;
249}
250
251// *************************************************************
252
253void FilterWithBufferedInput::BlockQueue::ResetQueue(size_t blockSize, size_t maxBlocks)
254{
255 m_buffer.New(blockSize * maxBlocks);
256 m_blockSize = blockSize;
257 m_maxBlocks = maxBlocks;
258 m_size = 0;
259 m_begin = m_buffer;
260}
261
262byte *FilterWithBufferedInput::BlockQueue::GetBlock()
263{
264 if (m_size >= m_blockSize)
265 {
266 byte *ptr = m_begin;
267 if ((m_begin = PtrAdd(m_begin, m_blockSize)) == m_buffer.end())
268 m_begin = m_buffer;
269 m_size -= m_blockSize;
270 return ptr;
271 }
272 else
273 return NULLPTR;
274}
275
276byte *FilterWithBufferedInput::BlockQueue::GetContigousBlocks(size_t &numberOfBytes)
277{
278 numberOfBytes = STDMIN(numberOfBytes, STDMIN<size_t>(PtrDiff(m_buffer.end(), m_begin), m_size));
279 byte *ptr = m_begin;
280 m_begin = PtrAdd(m_begin, numberOfBytes);
281 m_size -= numberOfBytes;
282 if (m_size == 0 || m_begin == m_buffer.end())
283 m_begin = m_buffer;
284 return ptr;
285}
286
287size_t FilterWithBufferedInput::BlockQueue::GetAll(byte *outString)
288{
289 // Avoid passing NULL pointer to memcpy
290 if (!outString) return 0;
291
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);
297 m_size = 0;
298 return size;
299}
300
301void FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t length)
302{
303 // Avoid passing NULL pointer to memcpy
304 if (!inString || !length) return;
305
306 CRYPTOPP_ASSERT(m_size + length <= m_buffer.size());
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);
311 if (len < length)
312 memcpy(m_buffer, PtrAdd(inString, len), length-len);
313 m_size += length;
314}
315
317 : Filter(attachment), m_firstSize(SIZE_MAX), m_blockSize(0), m_lastSize(SIZE_MAX), m_firstInputDone(false)
318{
319}
320
321FilterWithBufferedInput::FilterWithBufferedInput(size_t firstSize, size_t blockSize, size_t lastSize, BufferedTransformation *attachment)
322 : Filter(attachment), m_firstSize(firstSize), m_blockSize(blockSize), m_lastSize(lastSize), m_firstInputDone(false)
323{
324 if (m_firstSize == SIZE_MAX || m_blockSize < 1 || m_lastSize == SIZE_MAX)
325 throw InvalidArgument("FilterWithBufferedInput: invalid buffer size");
326
327 m_queue.ResetQueue(1, m_firstSize);
328}
329
331{
332 InitializeDerivedAndReturnNewSizes(parameters, m_firstSize, m_blockSize, m_lastSize);
333 if (m_firstSize == SIZE_MAX || m_blockSize < 1 || m_lastSize == SIZE_MAX)
334 throw InvalidArgument("FilterWithBufferedInput: invalid buffer size");
335 m_queue.ResetQueue(1, m_firstSize);
336 m_firstInputDone = false;
337}
338
339bool FilterWithBufferedInput::IsolatedFlush(bool hardFlush, bool blocking)
340{
341 if (!blocking)
342 throw BlockingInputOnly("FilterWithBufferedInput");
343
344 if (hardFlush)
345 ForceNextPut();
346 FlushDerived();
347
348 return false;
349}
350
351size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length, int messageEnd, bool blocking, bool modifiable)
352{
353 if (!blocking)
354 throw BlockingInputOnly("FilterWithBufferedInput");
355
356 if (length != 0)
357 {
358 size_t newLength = m_queue.CurrentSize() + length;
359
360 if (!m_firstInputDone && newLength >= m_firstSize)
361 {
362 size_t len = m_firstSize - m_queue.CurrentSize();
363 m_queue.Put(inString, len);
364 FirstPut(m_queue.GetContigousBlocks(m_firstSize));
365 CRYPTOPP_ASSERT(m_queue.CurrentSize() == 0);
366 m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
367
368 inString = PtrAdd(inString, len);
369 newLength -= m_firstSize;
370 m_firstInputDone = true;
371 }
372
373 if (m_firstInputDone)
374 {
375 if (m_blockSize == 1)
376 {
377 while (newLength > m_lastSize && m_queue.CurrentSize() > 0)
378 {
379 size_t len = newLength - m_lastSize;
380 byte *ptr = m_queue.GetContigousBlocks(len);
381 NextPutModifiable(ptr, len);
382 newLength -= len;
383 }
384
385 if (newLength > m_lastSize)
386 {
387 size_t len = newLength - m_lastSize;
388 NextPutMaybeModifiable(inString, len, modifiable);
389 inString = PtrAdd(inString, len);
390 newLength -= len;
391 }
392 }
393 else
394 {
395 while (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() >= m_blockSize)
396 {
397 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
398 newLength -= m_blockSize;
399 }
400
401 if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
402 {
403 CRYPTOPP_ASSERT(m_queue.CurrentSize() < m_blockSize);
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;
409 }
410
411 if (newLength >= m_blockSize + m_lastSize)
412 {
413 size_t len = RoundDownToMultipleOf(newLength - m_lastSize, m_blockSize);
414 NextPutMaybeModifiable(inString, len, modifiable);
415 inString = PtrAdd(inString, len);
416 newLength -= len;
417 }
418 }
419 }
420
421 m_queue.Put(inString, newLength - m_queue.CurrentSize());
422 }
423
424 if (messageEnd)
425 {
426 if (!m_firstInputDone && m_firstSize==0)
427 FirstPut(NULLPTR);
428
429 SecByteBlock temp(m_queue.CurrentSize());
430 m_queue.GetAll(temp);
431 LastPut(temp, temp.size());
432
433 m_firstInputDone = false;
434 m_queue.ResetQueue(1, m_firstSize);
435
436 // Cast to void to suppress Coverity finding
437 (void)Output(1, NULLPTR, 0, messageEnd, blocking);
438 }
439 return 0;
440}
441
443{
444 if (!m_firstInputDone)
445 return;
446
447 if (m_blockSize > 1)
448 {
449 while (m_queue.CurrentSize() >= m_blockSize)
450 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
451 }
452 else
453 {
454 size_t len;
455 while ((len = m_queue.CurrentSize()) > 0)
456 NextPutModifiable(m_queue.GetContigousBlocks(len), len);
457 }
458}
459
460void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t length)
461{
462 CRYPTOPP_ASSERT(m_blockSize > 1); // m_blockSize = 1 should always override this function
463 while (length > 0)
464 {
465 CRYPTOPP_ASSERT(length >= m_blockSize);
466 NextPutSingle(inString);
467 inString = PtrAdd(inString, m_blockSize);
468 length -= m_blockSize;
469 }
470}
471
472// *************************************************************
473
474void Redirector::Initialize(const NameValuePairs &parameters, int propagation)
475{
476 m_target = parameters.GetValueWithDefault("RedirectionTargetPointer", (BufferedTransformation*)NULLPTR);
477 m_behavior = parameters.GetIntValueWithDefault("RedirectionBehavior", PASS_EVERYTHING);
478
479 if (m_target && GetPassSignals())
480 m_target->Initialize(parameters, propagation);
481}
482
483// *************************************************************
484
485ProxyFilter::ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
486 : FilterWithBufferedInput(firstSize, 1, lastSize, attachment), m_filter(filter)
487{
488 if (m_filter.get())
489 m_filter->Attach(new OutputProxy(*this, false));
490}
491
492bool ProxyFilter::IsolatedFlush(bool hardFlush, bool blocking)
493{
494 return m_filter.get() ? m_filter->Flush(hardFlush, -1, blocking) : false;
495}
496
498{
499 m_filter.reset(filter);
500 if (filter)
501 {
502 OutputProxy *proxy;
503 member_ptr<OutputProxy> temp(proxy = new OutputProxy(*this, false));
504 m_filter->TransferAllTo(*proxy);
505 m_filter->Attach(temp.release());
506 }
507}
508
509void ProxyFilter::NextPutMultiple(const byte *s, size_t len)
510{
511 if (m_filter.get())
512 m_filter->Put(s, len);
513}
514
515void ProxyFilter::NextPutModifiable(byte *s, size_t len)
516{
517 if (m_filter.get())
518 m_filter->PutModifiable(s, len);
519}
520
521// *************************************************************
522
524{
525 parameters.GetRequiredParameter("RandomNumberSink", "RandomNumberGeneratorPointer", m_rng);
526}
527
528size_t RandomNumberSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
529{
530 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
531 m_rng->IncorporateEntropy(begin, length);
532 return 0;
533}
534
535size_t ArraySink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
536{
537 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
538
539 // Avoid passing NULL pointer to memcpy. Using memmove due to
540 // Valgrind finding on overlapping buffers.
541 size_t copied = 0;
542 if (m_buf && begin)
543 {
544 copied = STDMIN(length, SaturatingSubtract(m_size, m_total));
545 memmove(PtrAdd(m_buf, m_total), begin, copied);
546 }
547 m_total += copied;
548 return length - copied;
549}
550
551byte * ArraySink::CreatePutSpace(size_t &size)
552{
553 size = SaturatingSubtract(m_size, m_total);
554 return PtrAdd(m_buf, m_total);
555}
556
558{
559 ByteArrayParameter array;
560 if (!parameters.GetValue(Name::OutputBuffer(), array))
561 throw InvalidArgument("ArraySink: missing OutputBuffer argument");
562 m_buf = array.begin();
563 m_size = array.size();
564}
565
566size_t ArrayXorSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
567{
568 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
569
570 // Avoid passing NULL pointer to xorbuf
571 size_t copied = 0;
572 if (m_buf && begin)
573 {
574 copied = STDMIN(length, SaturatingSubtract(m_size, m_total));
575 xorbuf(PtrAdd(m_buf, m_total), begin, copied);
576 }
577 m_total += copied;
578 return length - copied;
579}
580
581// *************************************************************
582
584 : FilterWithBufferedInput(attachment), m_cipher(c), m_padding(DEFAULT_PADDING)
585{
586 CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
587
588 const bool authenticatedFilter = dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != NULLPTR;
589 if (authenticatedFilter)
590 throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
591
592 // InitializeDerivedAndReturnNewSizes may override some of these
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);
597
599}
600
601StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment, BlockPaddingScheme padding, bool authenticated)
602 : FilterWithBufferedInput(attachment), m_cipher(c), m_padding(DEFAULT_PADDING)
603{
604 const bool authenticatedFilter = dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != NULLPTR;
605 if (!authenticatedFilter)
606 {
607 CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
608 }
609
610 if (authenticatedFilter && !authenticated)
611 throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
612
613 // InitializeDerivedAndReturnNewSizes may override some of these
614 m_mandatoryBlockSize = m_cipher.MandatoryBlockSize();
615 m_optimalBufferSize = m_cipher.OptimalBlockSize();
616 m_isSpecial = m_cipher.IsLastBlockSpecial() && m_mandatoryBlockSize > 1;
617 m_reservedBufferSize = STDMAX(2*m_mandatoryBlockSize, m_optimalBufferSize);
618
620}
621
622size_t StreamTransformationFilter::LastBlockSize(StreamTransformation &c, BlockPaddingScheme padding)
623{
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();
628
629 return 0;
630}
631
632void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
633{
635 bool isBlockCipher = (m_mandatoryBlockSize > 1 && m_cipher.MinLastBlockSize() == 0);
636
637 if (padding == DEFAULT_PADDING)
638 m_padding = isBlockCipher ? PKCS_PADDING : NO_PADDING;
639 else
640 m_padding = padding;
641
642 if (!isBlockCipher)
643 {
644 if (m_padding == PKCS_PADDING)
645 throw InvalidArgument("StreamTransformationFilter: PKCS_PADDING cannot be used with " + m_cipher.AlgorithmName());
646 else if (m_padding == W3C_PADDING)
647 throw InvalidArgument("StreamTransformationFilter: W3C_PADDING cannot be used with " + m_cipher.AlgorithmName());
648 else if (m_padding == ONE_AND_ZEROS_PADDING)
649 throw InvalidArgument("StreamTransformationFilter: ONE_AND_ZEROS_PADDING cannot be used with " + m_cipher.AlgorithmName());
650 }
651
652 firstSize = 0;
653 blockSize = m_mandatoryBlockSize;
654 lastSize = LastBlockSize(m_cipher, m_padding);
655}
656
657void StreamTransformationFilter::FirstPut(const byte* inString)
658{
659 CRYPTOPP_UNUSED(inString);
660 m_optimalBufferSize = STDMAX<unsigned int>(m_optimalBufferSize, RoundDownToMultipleOf(4096U, m_optimalBufferSize));
661}
662
663void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t length)
664{
665 if (!length)
666 {return;}
667
668 const size_t s = m_cipher.MandatoryBlockSize();
669 do
670 {
671 size_t len = m_optimalBufferSize;
672 byte *space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, length, len);
673 if (len < length)
674 {
675 if (len == m_optimalBufferSize)
676 len -= m_cipher.GetOptimalBlockSizeUsed();
677 len = RoundDownToMultipleOf(len, s);
678 }
679 else
680 len = length;
681 m_cipher.ProcessString(space, inString, len);
683 inString = PtrAdd(inString, len);
684 length -= len;
685 }
686 while (length > 0);
687}
688
689void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length)
690{
691 m_cipher.ProcessString(inString, length);
692 AttachedTransformation()->PutModifiable(inString, length);
693}
694
695void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
696{
697 // This block is new to StreamTransformationFilter. It is somewhat of a hack and was
698 // added for OCB mode; see GitHub Issue 515. The rub with OCB is, its a block cipher
699 // and the last block size can be 0. However, "last block = 0" is not the 0 predicated
700 // in the original code. In the orginal code 0 means "nothing special" so
701 // DEFAULT_PADDING is applied. OCB's 0 literally means a final block size can be 0 or
702 // non-0; and no padding is needed in either case because OCB has its own scheme (see
703 // handling of P_* and A_*).
704 // Stream ciphers have policy objects to convey how to operate the cipher. The Crypto++
705 // framework operates well when MinLastBlockSize() is 1. However, it did not appear to
706 // cover the OCB case either because we can't stream OCB. It needs full block sizes. In
707 // response we hacked a IsLastBlockSpecial(). When true StreamTransformationFilter
708 // defers to the mode for processing of the last block.
709 // The behavior supplied when IsLastBlockSpecial() will likely have to evolve to capture
710 // more complex cases from different authenc modes. I suspect it will have to change
711 // from a simple bool to something that conveys more information, like "last block
712 // no padding" or "custom padding applied by cipher".
713 // In some respect we have already hit the need for more information. For example, OCB
714 // calculates the checksum on the cipher text at the same time, so we don't need the
715 // disjoint behavior of calling "EncryptBlock" followed by a separate "AuthenticateBlock".
716 // Additional information may allow us to avoid the two separate calls.
717 if (m_isSpecial)
718 {
719 const size_t leftOver = length % m_mandatoryBlockSize;
720 byte* space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, m_reservedBufferSize);
721 length -= leftOver;
722
723 if (length)
724 {
725 // Process full blocks
726 m_cipher.ProcessData(space, inString, length);
727 AttachedTransformation()->Put(space, length);
728 inString = PtrAdd(inString, length);
729 }
730
731 if (leftOver)
732 {
733 // Process final partial block
734 length = m_cipher.ProcessLastBlock(space, m_reservedBufferSize, inString, leftOver);
735 AttachedTransformation()->Put(space, length);
736 }
737 else
738 {
739 // Process final empty block
740 length = m_cipher.ProcessLastBlock(space, m_reservedBufferSize, NULLPTR, 0);
741 AttachedTransformation()->Put(space, length);
742 }
743
744 return;
745 }
746
747 switch (m_padding)
748 {
749 case NO_PADDING:
750 case ZEROS_PADDING:
751 if (length > 0)
752 {
753 const size_t minLastBlockSize = m_cipher.MinLastBlockSize();
754 const bool isForwardTransformation = m_cipher.IsForwardTransformation();
755
756 if (isForwardTransformation && m_padding == ZEROS_PADDING && (minLastBlockSize == 0 || length < minLastBlockSize))
757 {
758 // do padding
759 size_t blockSize = STDMAX(minLastBlockSize, (size_t)m_mandatoryBlockSize);
760 byte* space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, blockSize);
761 if (inString) {memcpy(space, inString, length);}
762 memset(PtrAdd(space, length), 0, blockSize - length);
763 size_t used = m_cipher.ProcessLastBlock(space, blockSize, space, blockSize);
764 AttachedTransformation()->Put(space, used);
765 }
766 else
767 {
768 if (minLastBlockSize == 0)
769 {
770 if (isForwardTransformation)
771 throw InvalidDataFormat("StreamTransformationFilter: plaintext length is not a multiple of block size and NO_PADDING is specified");
772 else
773 throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");
774 }
775
776 byte* space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, length, m_optimalBufferSize);
777 size_t used = m_cipher.ProcessLastBlock(space, length, inString, length);
778 AttachedTransformation()->Put(space, used);
779 }
780 }
781 break;
782
783 case PKCS_PADDING:
784 case W3C_PADDING:
786 unsigned int s;
787 byte* space;
788 s = m_mandatoryBlockSize;
789 CRYPTOPP_ASSERT(s > 1);
790 space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, m_optimalBufferSize);
791 if (m_cipher.IsForwardTransformation())
792 {
793 CRYPTOPP_ASSERT(length < s);
794 if (inString) {memcpy(space, inString, length);}
795 if (m_padding == PKCS_PADDING)
796 {
797 CRYPTOPP_ASSERT(s < 256);
798 byte pad = static_cast<byte>(s-length);
799 memset(PtrAdd(space, length), pad, s-length);
800 }
801 else if (m_padding == W3C_PADDING)
802 {
803 CRYPTOPP_ASSERT(s < 256);
804 memset(PtrAdd(space, length), 0, s-length-1);
805 space[s-1] = static_cast<byte>(s-length);
806 }
807 else
808 {
809 space[length] = 0x80;
810 memset(PtrAdd(space, length+1), 0, s-length-1);
811 }
812 m_cipher.ProcessData(space, space, s);
813 AttachedTransformation()->Put(space, s);
814 }
815 else
816 {
817 if (length != s)
818 throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");
819 m_cipher.ProcessData(space, inString, s);
820 if (m_padding == PKCS_PADDING)
821 {
822 byte pad = space[s-1];
823 if (pad < 1 || pad > s || FindIfNot(PtrAdd(space, s-pad), PtrAdd(space, s), pad) != PtrAdd(space, s))
824 throw InvalidCiphertext("StreamTransformationFilter: invalid PKCS #7 block padding found");
825 length = s-pad;
826 }
827 else if (m_padding == W3C_PADDING)
828 {
829 byte pad = space[s - 1];
830 if (pad < 1 || pad > s)
831 throw InvalidCiphertext("StreamTransformationFilter: invalid W3C block padding found");
832 length = s - pad;
833 }
834 else
835 {
836 while (length > 1 && space[length-1] == 0)
837 --length;
838 if (space[--length] != 0x80)
839 throw InvalidCiphertext("StreamTransformationFilter: invalid ones-and-zeros padding found");
840 }
841 AttachedTransformation()->Put(space, length);
842 }
843 break;
844
845 default:
846 CRYPTOPP_ASSERT(false);
847 }
848}
849
850// *************************************************************
851
852HashFilter::HashFilter(HashTransformation &hm, BufferedTransformation *attachment, bool putMessage, int truncatedDigestSize, const std::string &messagePutChannel, const std::string &hashPutChannel)
853 : m_hashModule(hm), m_putMessage(putMessage), m_digestSize(0), m_space(NULLPTR)
854 , m_messagePutChannel(messagePutChannel), m_hashPutChannel(hashPutChannel)
855{
856 m_digestSize = truncatedDigestSize < 0 ? m_hashModule.DigestSize() : truncatedDigestSize;
857 Detach(attachment);
858}
859
861{
862 m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);
863 int s = parameters.GetIntValueWithDefault(Name::TruncatedDigestSize(), -1);
864 m_digestSize = s < 0 ? m_hashModule.DigestSize() : s;
865}
866
867size_t HashFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
868{
869 FILTER_BEGIN;
870 if (m_putMessage)
871 FILTER_OUTPUT3(1, 0, inString, length, 0, m_messagePutChannel);
872 if (inString && length)
873 m_hashModule.Update(inString, length);
874 if (messageEnd)
875 {
876 {
877 size_t size;
878 m_space = HelpCreatePutSpace(*AttachedTransformation(), m_hashPutChannel, m_digestSize, m_digestSize, size = m_digestSize);
879 m_hashModule.TruncatedFinal(m_space, m_digestSize);
880 }
881 FILTER_OUTPUT3(2, 0, m_space, m_digestSize, messageEnd, m_hashPutChannel);
882 }
883 FILTER_END_NO_MESSAGE_END;
884}
885
886// *************************************************************
887
889 : FilterWithBufferedInput(attachment)
890 , m_hashModule(hm), m_flags(0), m_digestSize(0), m_verified(false)
891{
893}
894
895void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
896{
898 int s = parameters.GetIntValueWithDefault(Name::TruncatedDigestSize(), -1);
899 m_digestSize = s < 0 ? m_hashModule.DigestSize() : s;
900 m_verified = false;
901 firstSize = m_flags & HASH_AT_BEGIN ? m_digestSize : 0;
902 blockSize = 1;
903 lastSize = m_flags & HASH_AT_BEGIN ? 0 : m_digestSize;
904}
905
906void HashVerificationFilter::FirstPut(const byte *inString)
907{
908 if (m_flags & HASH_AT_BEGIN)
909 {
910 m_expectedHash.New(m_digestSize);
911 if (inString) {memcpy(m_expectedHash, inString, m_expectedHash.size());}
912 if (m_flags & PUT_HASH)
913 AttachedTransformation()->Put(inString, m_expectedHash.size());
914 }
915}
916
917void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
918{
919 m_hashModule.Update(inString, length);
920 if (m_flags & PUT_MESSAGE)
921 AttachedTransformation()->Put(inString, length);
922}
923
924void HashVerificationFilter::LastPut(const byte *inString, size_t length)
925{
926 if (m_flags & HASH_AT_BEGIN)
927 {
928 CRYPTOPP_ASSERT(length == 0);
929 m_verified = m_hashModule.TruncatedVerify(m_expectedHash, m_digestSize);
930 }
931 else
932 {
933 m_verified = (length==m_digestSize && m_hashModule.TruncatedVerify(inString, length));
934 if (m_flags & PUT_HASH)
935 AttachedTransformation()->Put(inString, length);
936 }
937
938 if (m_flags & PUT_RESULT)
939 AttachedTransformation()->Put(m_verified);
940
941 if ((m_flags & THROW_EXCEPTION) && !m_verified)
942 throw HashVerificationFailed();
943}
944
945// *************************************************************
946
948 bool putAAD, int truncatedDigestSize, const std::string &macChannel, BlockPaddingScheme padding)
949 : StreamTransformationFilter(c, attachment, padding, true)
950 , m_hf(c, new OutputProxy(*this, false), putAAD, truncatedDigestSize, AAD_CHANNEL, macChannel)
951{
952 CRYPTOPP_ASSERT(c.IsForwardTransformation());
953}
954
956{
957 m_hf.IsolatedInitialize(parameters);
959}
960
961byte * AuthenticatedEncryptionFilter::ChannelCreatePutSpace(const std::string &channel, size_t &size)
962{
963 if (channel.empty())
965
966 if (channel == AAD_CHANNEL)
967 return m_hf.CreatePutSpace(size);
968
969 throw InvalidChannelName("AuthenticatedEncryptionFilter", channel);
970}
971
972size_t AuthenticatedEncryptionFilter::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
973{
974 if (channel.empty())
975 return StreamTransformationFilter::Put2(begin, length, messageEnd, blocking);
976
977 if (channel == AAD_CHANNEL)
978 return m_hf.Put2(begin, length, 0, blocking);
979
980 throw InvalidChannelName("AuthenticatedEncryptionFilter", channel);
981}
982
983void AuthenticatedEncryptionFilter::LastPut(const byte *inString, size_t length)
984{
985 StreamTransformationFilter::LastPut(inString, length);
986 m_hf.MessageEnd();
987}
988
989// *************************************************************
990
992 : FilterWithBufferedInput(attachment)
993 , m_hashVerifier(c, new OutputProxy(*this, false))
994 , m_streamFilter(c, new OutputProxy(*this, false), padding, true)
995{
996 CRYPTOPP_ASSERT(!c.IsForwardTransformation() || c.IsSelfInverting());
998}
999
1000void AuthenticatedDecryptionFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
1001{
1003
1005 m_streamFilter.Initialize(parameters);
1006
1007 firstSize = m_hashVerifier.m_firstSize;
1008 blockSize = 1;
1009 lastSize = m_hashVerifier.m_lastSize;
1010}
1011
1012byte * AuthenticatedDecryptionFilter::ChannelCreatePutSpace(const std::string &channel, size_t &size)
1013{
1014 if (channel.empty())
1015 return m_streamFilter.CreatePutSpace(size);
1016
1017 if (channel == AAD_CHANNEL)
1018 return m_hashVerifier.CreatePutSpace(size);
1019
1020 throw InvalidChannelName("AuthenticatedDecryptionFilter", channel);
1021}
1022
1023size_t AuthenticatedDecryptionFilter::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
1024{
1025 if (channel.empty())
1026 {
1027 if (m_lastSize > 0)
1028 m_hashVerifier.ForceNextPut();
1029 return FilterWithBufferedInput::Put2(begin, length, messageEnd, blocking);
1030 }
1031
1032 if (channel == AAD_CHANNEL)
1033 return m_hashVerifier.Put2(begin, length, 0, blocking);
1034
1035 throw InvalidChannelName("AuthenticatedDecryptionFilter", channel);
1036}
1037
1038void AuthenticatedDecryptionFilter::FirstPut(const byte *inString)
1039{
1040 m_hashVerifier.Put(inString, m_firstSize);
1041}
1042
1043void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t length)
1044{
1045 m_streamFilter.Put(inString, length);
1046}
1047
1048void AuthenticatedDecryptionFilter::LastPut(const byte *inString, size_t length)
1049{
1050 m_streamFilter.MessageEnd();
1051 m_hashVerifier.PutMessageEnd(inString, length);
1052}
1053
1054// *************************************************************
1055
1057{
1058 m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);
1059 m_messageAccumulator.reset(m_signer.NewSignatureAccumulator(m_rng));
1060}
1061
1062size_t SignerFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
1063{
1064 FILTER_BEGIN;
1065 m_messageAccumulator->Update(inString, length);
1066 if (m_putMessage)
1067 FILTER_OUTPUT(1, inString, length, 0);
1068 if (messageEnd)
1069 {
1070 m_buf.New(m_signer.SignatureLength());
1071 m_signer.Sign(m_rng, m_messageAccumulator.release(), m_buf);
1072 FILTER_OUTPUT(2, m_buf, m_buf.size(), messageEnd);
1073 m_messageAccumulator.reset(m_signer.NewSignatureAccumulator(m_rng));
1074 }
1075 FILTER_END_NO_MESSAGE_END;
1076}
1077
1079 : FilterWithBufferedInput(attachment)
1080 , m_verifier(verifier), m_flags(0), m_verified(0)
1081{
1083}
1084
1085void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
1086{
1088 m_messageAccumulator.reset(m_verifier.NewVerificationAccumulator());
1089 size_t size = m_verifier.SignatureLength();
1090 CRYPTOPP_ASSERT(size != 0); // TODO: handle recoverable signature scheme
1091 m_verified = false;
1092 firstSize = m_flags & SIGNATURE_AT_BEGIN ? size : 0;
1093 blockSize = 1;
1094 lastSize = m_flags & SIGNATURE_AT_BEGIN ? 0 : size;
1095}
1096
1097void SignatureVerificationFilter::FirstPut(const byte *inString)
1098{
1099 if (m_flags & SIGNATURE_AT_BEGIN)
1100 {
1101 if (m_verifier.SignatureUpfront())
1102 m_verifier.InputSignature(*m_messageAccumulator, inString, m_verifier.SignatureLength());
1103 else
1104 {
1105 m_signature.New(m_verifier.SignatureLength());
1106 if (inString) {memcpy(m_signature, inString, m_signature.size());}
1107 }
1108
1109 if (m_flags & PUT_SIGNATURE)
1110 AttachedTransformation()->Put(inString, m_signature.size());
1111 }
1112 else
1113 {
1114 CRYPTOPP_ASSERT(!m_verifier.SignatureUpfront());
1115 }
1116}
1117
1118void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
1119{
1120 m_messageAccumulator->Update(inString, length);
1121 if (m_flags & PUT_MESSAGE)
1122 AttachedTransformation()->Put(inString, length);
1123}
1124
1125void SignatureVerificationFilter::LastPut(const byte *inString, size_t length)
1126{
1127 if (m_flags & SIGNATURE_AT_BEGIN)
1128 {
1129 CRYPTOPP_ASSERT(length == 0);
1130 m_verifier.InputSignature(*m_messageAccumulator, m_signature, m_signature.size());
1131 m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
1132 }
1133 else
1134 {
1135 m_verifier.InputSignature(*m_messageAccumulator, inString, length);
1136 m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
1137 if (m_flags & PUT_SIGNATURE)
1138 AttachedTransformation()->Put(inString, length);
1139 }
1140
1141 if (m_flags & PUT_RESULT)
1142 AttachedTransformation()->Put(m_verified);
1143
1144 if ((m_flags & THROW_EXCEPTION) && !m_verified)
1145 throw SignatureVerificationFailed();
1146}
1147
1148// *************************************************************
1149
1150size_t Source::PumpAll2(bool blocking)
1151{
1152 unsigned int messageCount = UINT_MAX;
1153 do {
1154 RETURN_IF_NONZERO(PumpMessages2(messageCount, blocking));
1155 } while(messageCount == UINT_MAX);
1156
1157 return 0;
1158}
1159
1161{
1162 if (!m_messageEnd && !AnyRetrievable())
1163 {
1164 m_messageEnd=true;
1165 return true;
1166 }
1167 else
1168 return false;
1169}
1170
1171unsigned int Store::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const
1172{
1173 if (m_messageEnd || count == 0)
1174 return 0;
1175 else
1176 {
1177 CopyTo(target, ULONG_MAX, channel);
1178 if (GetAutoSignalPropagation())
1179 target.ChannelMessageEnd(channel, GetAutoSignalPropagation()-1);
1180 return 1;
1181 }
1182}
1183
1184void StringStore::StoreInitialize(const NameValuePairs &parameters)
1185{
1187 if (!parameters.GetValue(Name::InputBuffer(), array))
1188 throw InvalidArgument("StringStore: missing InputBuffer argument");
1189 m_store = array.begin();
1190 m_length = array.size();
1191 m_count = 0;
1192}
1193
1194size_t StringStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
1195{
1196 lword position = 0;
1197 size_t blockedBytes = CopyRangeTo2(target, position, transferBytes, channel, blocking);
1198 m_count += static_cast<size_t>(position);
1199 transferBytes = position;
1200 return blockedBytes;
1201}
1202
1203size_t StringStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
1204{
1205 size_t i = UnsignedMin(m_length, m_count+begin);
1206 size_t len = UnsignedMin(m_length-i, end-begin);
1207 size_t blockedBytes = target.ChannelPut2(channel, PtrAdd(m_store, i), len, 0, blocking);
1208 if (!blockedBytes)
1209 begin = PtrAdd(begin, len);
1210 return blockedBytes;
1211}
1212
1213void RandomNumberStore::StoreInitialize(const NameValuePairs &parameters)
1214{
1215 parameters.GetRequiredParameter("RandomNumberStore", "RandomNumberGeneratorPointer", m_rng);
1216 int length;
1217 parameters.GetRequiredIntParameter("RandomNumberStore", "RandomNumberStoreSize", length);
1218 m_length = length;
1219}
1220
1221size_t RandomNumberStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
1222{
1223 if (!blocking)
1224 throw NotImplemented("RandomNumberStore: nonblocking transfer is not implemented by this object");
1225
1226 transferBytes = UnsignedMin(transferBytes, m_length - m_count);
1227 m_rng->GenerateIntoBufferedTransformation(target, channel, transferBytes);
1228 m_count += transferBytes;
1229
1230 return 0;
1231}
1232
1233size_t NullStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
1234{
1235 static const byte nullBytes[128] = {0};
1236 while (begin < end)
1237 {
1238 size_t len = (size_t)STDMIN(end-begin, lword(128));
1239 size_t blockedBytes = target.ChannelPut2(channel, nullBytes, len, 0, blocking);
1240 if (blockedBytes)
1241 return blockedBytes;
1242 begin = PtrAdd(begin, len);
1243 }
1244 return 0;
1245}
1246
1247size_t NullStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
1248{
1249 lword begin = 0;
1250 size_t blockedBytes = NullStore::CopyRangeTo2(target, begin, transferBytes, channel, blocking);
1251 transferBytes = begin; m_size -= begin;
1252 return blockedBytes;
1253}
1254
1255NAMESPACE_END
1256
1257#endif
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Definition: algparam.h:502
Standard names for retrieving values by name when working with NameValuePairs.
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: cryptlib.h:591
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:557
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Definition: filters.cpp:551
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:535
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:566
@ DEFAULT_FLAGS
Default flags using THROW_EXCEPTION.
Definition: filters.h:699
AuthenticatedDecryptionFilter(AuthenticatedSymmetricCipher &c, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1, BlockPaddingScheme padding=DEFAULT_PADDING)
Construct a AuthenticatedDecryptionFilter.
Definition: filters.cpp:991
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.
Definition: filters.cpp:1023
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Definition: filters.cpp:1012
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.
Definition: filters.cpp:972
void LastPut(const byte *inString, size_t length)
Input the last block of data.
Definition: filters.cpp:983
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Definition: filters.cpp:961
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:955
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.
Definition: filters.cpp:947
Interface for authenticated encryption modes of operation.
Definition: cryptlib.h:1289
Interface for buffered transformations.
Definition: cryptlib.h:1599
virtual void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
Definition: cryptlib.cpp:433
bool MessageEnd(int propagation=-1, bool blocking=true)
Signals the end of messages to the object.
Definition: cryptlib.h:1682
virtual size_t TransferTo2(BufferedTransformation &target, lword &byteCount, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)=0
Transfer bytes from this object to another BufferedTransformation.
virtual bool IsolatedFlush(bool hardFlush, bool blocking)=0
Flushes data buffered by this object, without signal propagation.
virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output on a channel.
Definition: cryptlib.cpp:484
lword CopyTo(BufferedTransformation &target, lword copyMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL) const
copy copyMax bytes of the buffered output to target as input
Definition: cryptlib.h:1926
virtual void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: cryptlib.h:1755
virtual size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const =0
Copy bytes from this object to another BufferedTransformation.
void TransferAllTo(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL)
Transfer all bytes from this object to another BufferedTransformation.
Definition: cryptlib.h:2005
virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
Definition: cryptlib.cpp:440
virtual byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Definition: cryptlib.h:1659
virtual bool AnyRetrievable() const
Determines whether bytes are ready for retrieval.
Definition: cryptlib.cpp:514
virtual void Attach(BufferedTransformation *newAttachment)
Add newAttachment to the end of attachment chain.
Definition: cryptlib.cpp:803
size_t PutMessageEnd(const byte *inString, size_t length, int propagation=-1, bool blocking=true)
Input multiple bytes for processing and signal the end of a message.
Definition: cryptlib.h:1696
virtual bool IsolatedMessageSeriesEnd(bool blocking)
Marks the end of a series of messages, without signal propagation.
Definition: cryptlib.h:1769
virtual size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)=0
Input multiple bytes for processing.
virtual size_t ChannelPutModifiable2(const std::string &channel, byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee on a channel.
Definition: cryptlib.cpp:474
bool ChannelMessageEnd(const std::string &channel, int propagation=-1, bool blocking=true)
Signal the end of a message.
Definition: cryptlib.h:2155
virtual bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true)
Marks the end of a series of messages on a channel.
Definition: cryptlib.cpp:494
size_t PutModifiable(byte *inString, size_t length, bool blocking=true)
Input multiple bytes that may be modified by callee.
Definition: cryptlib.h:1674
virtual size_t ChannelPut2(const std::string &channel, const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing on a channel.
Definition: cryptlib.cpp:464
size_t Put(byte inByte, bool blocking=true)
Input a byte for processing.
Definition: cryptlib.h:1620
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:95
byte * begin() const
Pointer to the first byte in the memory block.
Definition: algparam.h:109
size_t size() const
Length of the memory block.
Definition: algparam.h:113
Combines two sets of NameValuePairs.
Definition: algparam.h:125
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:21
const byte * begin() const
Pointer to the first byte in the memory block.
Definition: algparam.h:80
size_t size() const
Length of the memory block.
Definition: algparam.h:84
Implementation of BufferedTransformation's attachment interface.
Definition: filters.h:36
void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
Definition: filters.cpp:71
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
Definition: filters.cpp:50
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.
Definition: filters.cpp:61
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
Definition: filters.cpp:95
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Definition: filters.cpp:66
BufferedTransformation * AttachedTransformation()
Retrieve attached transformation.
Definition: filters.cpp:36
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
Definition: filters.cpp:78
Divides an input stream into discrete blocks.
Definition: filters.h:312
bool IsolatedFlush(bool hardFlush, bool blocking)
Flushes data buffered by this object, without signal propagation.
Definition: filters.cpp:339
FilterWithBufferedInput(BufferedTransformation *attachment)
Construct a FilterWithBufferedInput with an attached transformation.
Definition: filters.cpp:316
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.h:329
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:330
void ForceNextPut()
Flushes data buffered by this object.
Definition: filters.cpp:442
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Definition: filters.h:567
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.
Definition: filters.cpp:852
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:867
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:860
Interface for hash functions and data processing part of MACs.
Definition: cryptlib.h:1085
virtual bool TruncatedVerify(const byte *digest, size_t digestLength)
Verifies the hash of the current message.
Definition: cryptlib.cpp:406
virtual void TruncatedFinal(byte *digest, size_t digestSize)=0
Computes the hash of the current message.
virtual unsigned int DigestSize() const =0
Provides the digest size of the hash.
virtual void Update(const byte *input, size_t length)=0
Updates a hash with additional input.
HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1)
Construct a HashVerificationFilter.
Definition: filters.cpp:888
@ DEFAULT_FLAGS
Default flags using HASH_AT_BEGIN and PUT_RESULT.
Definition: filters.h:609
@ HASH_AT_BEGIN
Indicates the hash is at the beginning of the message (i.e., concatenation of hash+message)
Definition: filters.h:599
@ THROW_EXCEPTION
Indicates the filter should throw a HashVerificationFailed if a failure is encountered.
Definition: filters.h:607
@ PUT_HASH
Indicates the hash should be passed to an attached transformation.
Definition: filters.h:603
@ PUT_MESSAGE
Indicates the message should be passed to an attached transformation.
Definition: filters.h:601
@ PUT_RESULT
Indicates the result of the verification should be passed to an attached transformation.
Definition: filters.h:605
An invalid argument was detected.
Definition: cryptlib.h:203
A decryption filter encountered invalid ciphertext.
Definition: cryptlib.h:217
Input data was received that did not conform to expected format.
Definition: cryptlib.h:210
Message Queue.
Definition: mqueue.h:15
size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee.
Definition: filters.cpp:237
void AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow=true)
Adds a range to skip during processing.
Definition: filters.cpp:166
void ResetMeter()
Resets the meter.
Definition: filters.cpp:160
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:232
bool IsolatedMessageSeriesEnd(bool blocking)
Marks the end of a series of messages, without signal propagation.
Definition: filters.cpp:242
Interface for retrieving values given their names.
Definition: cryptlib.h:294
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
Definition: cryptlib.h:363
bool GetValue(const char *name, T &value) const
Get a named value.
Definition: cryptlib.h:350
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
Definition: cryptlib.h:395
void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
Definition: cryptlib.h:454
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
Definition: cryptlib.h:439
A method was called which was not implemented.
Definition: cryptlib.h:224
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.
Definition: filters.cpp:1233
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Definition: filters.cpp:1247
Filter class that is a proxy for a sink.
Definition: filters.h:929
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
Definition: cryptlib.h:2733
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.
Definition: cryptlib.cpp:909
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.
Definition: cryptlib.h:2826
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
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.
ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
Construct a ProxyFilter.
Definition: filters.cpp:485
void SetFilter(Filter *filter)
Sets the OutputProxy filter.
Definition: filters.cpp:497
bool IsolatedFlush(bool hardFlush, bool blocking)
Flushes data buffered by this object, without signal propagation.
Definition: filters.cpp:492
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
Definition: cryptlib.cpp:324
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
Definition: cryptlib.h:1396
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:523
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:528
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Definition: filters.cpp:1221
@ PASS_EVERYTHING
Pass everything.
Definition: filters.h:848
void Initialize(const NameValuePairs &parameters, int propagation)
Initialize or reinitialize this object, with signal propagation.
Definition: filters.cpp:474
void New(size_type newSize)
Change size without preserving contents.
Definition: secblock.h:965
size_type size() const
Provides the count of elements in the SecBlock.
Definition: secblock.h:797
SecBlock<byte> typedef.
Definition: secblock.h:1058
@ SIGNATURE_AT_BEGIN
Indicates the signature is at the beginning of the message (i.e., concatenation of signature+message)
Definition: filters.h:790
@ THROW_EXCEPTION
Indicates the filter should throw a HashVerificationFailed if a failure is encountered.
Definition: filters.h:798
@ DEFAULT_FLAGS
Default flags using SIGNATURE_AT_BEGIN and PUT_RESULT.
Definition: filters.h:800
@ PUT_MESSAGE
Indicates the message should be passed to an attached transformation.
Definition: filters.h:792
@ PUT_RESULT
Indicates the result of the verification should be passed to an attached transformation.
Definition: filters.h:796
@ PUT_SIGNATURE
Indicates the signature should be passed to an attached transformation.
Definition: filters.h:794
SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS)
Construct a SignatureVerificationFilter.
Definition: filters.cpp:1078
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:1062
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:1056
virtual size_t PumpAll2(bool blocking=true)
Pump all data to attached transformation.
Definition: filters.cpp:1150
virtual size_t PumpMessages2(unsigned int &messageCount, bool blocking=true)=0
Pump messages to attached transformation.
bool GetNextMessage()
Start retrieving the next message.
Definition: filters.cpp:1160
Filter wrapper for StreamTransformation.
Definition: filters.h:501
StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment=NULL, BlockPaddingScheme padding=DEFAULT_PADDING)
Construct a StreamTransformationFilter.
Definition: filters.cpp:583
Interface for the data processing portion of stream ciphers.
Definition: cryptlib.h:918
virtual unsigned int MinLastBlockSize() const
Provides the size of the last block.
Definition: cryptlib.h:993
virtual void ProcessData(byte *outString, const byte *inString, size_t length)=0
Encrypt or decrypt an array of bytes.
virtual bool IsForwardTransformation() const =0
Determines if the cipher is being operated in its forward direction.
virtual bool IsLastBlockSpecial() const
Determines if the last block receives special processing.
Definition: cryptlib.h:1026
virtual unsigned int GetOptimalBlockSizeUsed() const
Provides the number of bytes used in the current block when processing at optimal block size.
Definition: cryptlib.h:948
void ProcessString(byte *inoutString, size_t length)
Encrypt or decrypt a string of bytes.
Definition: cryptlib.h:1032
virtual unsigned int MandatoryBlockSize() const
Provides the mandatory block size of the cipher.
Definition: cryptlib.h:937
virtual size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength)
Encrypt or decrypt the last block of data.
Definition: cryptlib.cpp:217
virtual unsigned int OptimalBlockSize() const
Provides the input block size most efficient for this cipher.
Definition: cryptlib.h:944
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.
Definition: filters.cpp:1203
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Definition: filters.cpp:1194
Pointer that overloads operator ->
Definition: smartptr.h:37
Library configuration file.
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.
Definition: misc.h:1004
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
Definition: misc.h:578
#define SIZE_MAX
The maximum value of a machine word.
Definition: misc.h:86
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
Definition: misc.h:567
ptrdiff_t PtrDiff(const PTR pointer1, const PTR pointer2)
Determine pointer difference.
Definition: misc.h:371
T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
Rounds a value down to a multiple of a second value.
Definition: misc.h:1055
InputIt FindIfNot(InputIt first, InputIt last, const T &value)
Finds first element not in a range.
Definition: misc.h:2670
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
Definition: misc.h:343
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
Definition: misc.h:606
Crypto++ library namespace.
const char * InputBuffer()
ConstByteArrayParameter.
Definition: argnames.h:56
const char * TruncatedDigestSize()
int
Definition: argnames.h:51
const char * AuthenticatedDecryptionFilterFlags()
word32
Definition: argnames.h:54
const char * PutMessage()
bool
Definition: argnames.h:50
const char * OutputBuffer()
ByteArrayParameter.
Definition: argnames.h:57
const char * HashVerificationFilterFlags()
word32
Definition: argnames.h:53
const char * BlockPaddingScheme()
StreamTransformationFilter::BlockPaddingScheme.
Definition: argnames.h:52
const char * SignatureVerificationFilterFlags()
word32
Definition: argnames.h:55
Precompiled header file.
Classes for automatic resource management.
Common C++ header files.
BlockPaddingScheme
Padding schemes used for block ciphers.
Definition: filters.h:470
@ DEFAULT_PADDING
Default padding scheme.
Definition: filters.h:490
@ W3C_PADDING
W3C padding added to a block.
Definition: filters.h:487
@ PKCS_PADDING
PKCS padding added to a block.
Definition: filters.h:479
@ ONE_AND_ZEROS_PADDING
1 and 0's padding added to a block
Definition: filters.h:482
@ NO_PADDING
No padding added to a block.
Definition: filters.h:473
@ ZEROS_PADDING
0's padding added to a block
Definition: filters.h:476
Exception thrown by objects that have not implemented nonblocking input processing.
Definition: cryptlib.h:1723
Exception thrown when a filter does not recognize a named channel.
Definition: cryptlib.h:2098
byte * HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize)
Create a working space in a BufferedTransformation.
Definition: filters.h:175
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:69