Crypto++  5.6.3
Free C++ class library of cryptographic schemes
filters.cpp
1 // filters.cpp - 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)
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 
24 NAMESPACE_BEGIN(CryptoPP)
25 
27  : m_attachment(attachment), m_inputPosition(0), m_continueAt(0)
28 {
29 }
30 
31 BufferedTransformation * Filter::NewDefaultAttachment() const
32 {
33  return new MessageQueue;
34 }
35 
37 {
38  if (m_attachment.get() == NULL)
39  m_attachment.reset(NewDefaultAttachment());
40  return m_attachment.get();
41 }
42 
44 {
45  if (m_attachment.get() == NULL)
46  const_cast<Filter *>(this)->m_attachment.reset(NewDefaultAttachment());
47  return m_attachment.get();
48 }
49 
51 {
52  m_attachment.reset(newOut);
53 }
54 
55 void Filter::Insert(Filter *filter)
56 {
57  filter->m_attachment.reset(m_attachment.release());
58  m_attachment.reset(filter);
59 }
60 
61 size_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 
66 size_t Filter::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
67 {
68  return AttachedTransformation()->TransferTo2(target, transferBytes, channel, blocking);
69 }
70 
71 void Filter::Initialize(const NameValuePairs &parameters, int propagation)
72 {
73  m_inputPosition = m_continueAt = 0;
74  IsolatedInitialize(parameters);
75  PropagateInitialize(parameters, propagation);
76 }
77 
78 bool 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 
95 bool 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 
112 void Filter::PropagateInitialize(const NameValuePairs &parameters, int propagation)
113 {
114  if (propagation)
115  AttachedTransformation()->Initialize(parameters, propagation-1);
116 }
117 
118 size_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 
127 size_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 
136 bool 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 
147 bool 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 
166 void 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 
174 size_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  assert(t < m_length);
192  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  assert(t <= m_length);
203  m_rangesToSkip.pop_front();
204  }
205 
206  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 
232 size_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 
237 size_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 
253 void 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 
262 byte *FilterWithBufferedInput::BlockQueue::GetBlock()
263 {
264  if (m_size >= m_blockSize)
265  {
266  byte *ptr = m_begin;
267  if ((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 NULL;
274 }
275 
276 byte *FilterWithBufferedInput::BlockQueue::GetContigousBlocks(size_t &numberOfBytes)
277 {
278  numberOfBytes = STDMIN(numberOfBytes, STDMIN(size_t(m_buffer.end()-m_begin), m_size));
279  byte *ptr = m_begin;
280  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 
287 size_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(outString+numberOfBytes, m_begin, m_size);
297  m_size = 0;
298  return size;
299 }
300 
301 void FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t length)
302 {
303  // Avoid passing NULL pointer to memcpy
304  if (!inString || !length) return;
305 
306  assert(m_size + length <= m_buffer.size());
307  byte *end = (m_size < size_t(m_buffer.end()-m_begin)) ? m_begin + m_size : m_begin + m_size - m_buffer.size();
308  size_t len = STDMIN(length, size_t(m_buffer.end()-end));
309  memcpy(end, inString, len);
310  if (len < length)
311  memcpy(m_buffer, inString+len, length-len);
312  m_size += length;
313 }
314 
315 #if !defined(CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562)
317  : Filter(), m_firstSize(SIZE_MAX), m_blockSize(0), m_lastSize(SIZE_MAX), m_firstInputDone(false)
318 {
319 }
320 #endif
321 
323  : Filter(attachment), m_firstSize(SIZE_MAX), m_blockSize(0), m_lastSize(SIZE_MAX), m_firstInputDone(false)
324 {
325 }
326 
327 FilterWithBufferedInput::FilterWithBufferedInput(size_t firstSize, size_t blockSize, size_t lastSize, BufferedTransformation *attachment)
328  : Filter(attachment), m_firstSize(firstSize), m_blockSize(blockSize), m_lastSize(lastSize), m_firstInputDone(false)
329 {
330  if (m_firstSize == SIZE_MAX || m_blockSize < 1 || m_lastSize == SIZE_MAX)
331  throw InvalidArgument("FilterWithBufferedInput: invalid buffer size");
332 
333  m_queue.ResetQueue(1, m_firstSize);
334 }
335 
337 {
338  InitializeDerivedAndReturnNewSizes(parameters, m_firstSize, m_blockSize, m_lastSize);
339  if (m_firstSize == SIZE_MAX || m_blockSize < 1 || m_lastSize == SIZE_MAX)
340  throw InvalidArgument("FilterWithBufferedInput: invalid buffer size");
341  m_queue.ResetQueue(1, m_firstSize);
342  m_firstInputDone = false;
343 }
344 
345 bool FilterWithBufferedInput::IsolatedFlush(bool hardFlush, bool blocking)
346 {
347  if (!blocking)
348  throw BlockingInputOnly("FilterWithBufferedInput");
349 
350  if (hardFlush)
351  ForceNextPut();
352  FlushDerived();
353 
354  return false;
355 }
356 
357 size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length, int messageEnd, bool blocking, bool modifiable)
358 {
359  if (!blocking)
360  throw BlockingInputOnly("FilterWithBufferedInput");
361 
362  if (length != 0)
363  {
364  size_t newLength = m_queue.CurrentSize() + length;
365 
366  if (!m_firstInputDone && newLength >= m_firstSize)
367  {
368  size_t len = m_firstSize - m_queue.CurrentSize();
369  m_queue.Put(inString, len);
370  FirstPut(m_queue.GetContigousBlocks(m_firstSize));
371  assert(m_queue.CurrentSize() == 0);
372  m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
373 
374  inString += len;
375  newLength -= m_firstSize;
376  m_firstInputDone = true;
377  }
378 
379  if (m_firstInputDone)
380  {
381  if (m_blockSize == 1)
382  {
383  while (newLength > m_lastSize && m_queue.CurrentSize() > 0)
384  {
385  size_t len = newLength - m_lastSize;
386  byte *ptr = m_queue.GetContigousBlocks(len);
387  NextPutModifiable(ptr, len);
388  newLength -= len;
389  }
390 
391  if (newLength > m_lastSize)
392  {
393  size_t len = newLength - m_lastSize;
394  NextPutMaybeModifiable(inString, len, modifiable);
395  inString += len;
396  newLength -= len;
397  }
398  }
399  else
400  {
401  while (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() >= m_blockSize)
402  {
403  NextPutModifiable(m_queue.GetBlock(), m_blockSize);
404  newLength -= m_blockSize;
405  }
406 
407  if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
408  {
409  assert(m_queue.CurrentSize() < m_blockSize);
410  size_t len = m_blockSize - m_queue.CurrentSize();
411  m_queue.Put(inString, len);
412  inString += len;
413  NextPutModifiable(m_queue.GetBlock(), m_blockSize);
414  newLength -= m_blockSize;
415  }
416 
417  if (newLength >= m_blockSize + m_lastSize)
418  {
419  size_t len = RoundDownToMultipleOf(newLength - m_lastSize, m_blockSize);
420  NextPutMaybeModifiable(inString, len, modifiable);
421  inString += len;
422  newLength -= len;
423  }
424  }
425  }
426 
427  m_queue.Put(inString, newLength - m_queue.CurrentSize());
428  }
429 
430  if (messageEnd)
431  {
432  if (!m_firstInputDone && m_firstSize==0)
433  FirstPut(NULL);
434 
435  SecByteBlock temp(m_queue.CurrentSize());
436  m_queue.GetAll(temp);
437  LastPut(temp, temp.size());
438 
439  m_firstInputDone = false;
440  m_queue.ResetQueue(1, m_firstSize);
441 
442  // Cast to void to supress Coverity finding
443  (void)Output(1, NULL, 0, messageEnd, blocking);
444  }
445  return 0;
446 }
447 
449 {
450  if (!m_firstInputDone)
451  return;
452 
453  if (m_blockSize > 1)
454  {
455  while (m_queue.CurrentSize() >= m_blockSize)
456  NextPutModifiable(m_queue.GetBlock(), m_blockSize);
457  }
458  else
459  {
460  size_t len;
461  while ((len = m_queue.CurrentSize()) > 0)
462  NextPutModifiable(m_queue.GetContigousBlocks(len), len);
463  }
464 }
465 
466 void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t length)
467 {
468  assert(m_blockSize > 1); // m_blockSize = 1 should always override this function
469  while (length > 0)
470  {
471  assert(length >= m_blockSize);
472  NextPutSingle(inString);
473  inString += m_blockSize;
474  length -= m_blockSize;
475  }
476 }
477 
478 // *************************************************************
479 
480 void Redirector::Initialize(const NameValuePairs &parameters, int propagation)
481 {
482  m_target = parameters.GetValueWithDefault("RedirectionTargetPointer", (BufferedTransformation*)NULL);
483  m_behavior = parameters.GetIntValueWithDefault("RedirectionBehavior", PASS_EVERYTHING);
484 
485  if (m_target && GetPassSignals())
486  m_target->Initialize(parameters, propagation);
487 }
488 
489 // *************************************************************
490 
491 ProxyFilter::ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
492  : FilterWithBufferedInput(firstSize, 1, lastSize, attachment), m_filter(filter)
493 {
494  if (m_filter.get())
495  m_filter->Attach(new OutputProxy(*this, false));
496 }
497 
498 bool ProxyFilter::IsolatedFlush(bool hardFlush, bool blocking)
499 {
500  return m_filter.get() ? m_filter->Flush(hardFlush, -1, blocking) : false;
501 }
502 
504 {
505  m_filter.reset(filter);
506  if (filter)
507  {
508  OutputProxy *proxy;
509  member_ptr<OutputProxy> temp(proxy = new OutputProxy(*this, false));
510  m_filter->TransferAllTo(*proxy);
511  m_filter->Attach(temp.release());
512  }
513 }
514 
515 void ProxyFilter::NextPutMultiple(const byte *s, size_t len)
516 {
517  if (m_filter.get())
518  m_filter->Put(s, len);
519 }
520 
521 void ProxyFilter::NextPutModifiable(byte *s, size_t len)
522 {
523  if (m_filter.get())
524  m_filter->PutModifiable(s, len);
525 }
526 
527 // *************************************************************
528 
530 {
531  parameters.GetRequiredParameter("RandomNumberSink", "RandomNumberGeneratorPointer", m_rng);
532 }
533 
534 size_t RandomNumberSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
535 {
536  CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
537  m_rng->IncorporateEntropy(begin, length);
538  return 0;
539 }
540 
541 size_t ArraySink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
542 {
543  CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
544 
545  // Avoid passing NULL pointer to memcpy. Using memmove due to
546  // Valgrind finding on overlapping buffers.
547  size_t copied = 0;
548  if (m_buf && begin)
549  {
550  copied = STDMIN(length, SaturatingSubtract(m_size, m_total));
551  memmove(m_buf+m_total, begin, copied);
552  }
553  m_total += copied;
554  return length - copied;
555 }
556 
557 byte * ArraySink::CreatePutSpace(size_t &size)
558 {
559  size = SaturatingSubtract(m_size, m_total);
560  return m_buf + m_total;
561 }
562 
564 {
565  ByteArrayParameter array;
566  if (!parameters.GetValue(Name::OutputBuffer(), array))
567  throw InvalidArgument("ArraySink: missing OutputBuffer argument");
568  m_buf = array.begin();
569  m_size = array.size();
570 }
571 
572 size_t ArrayXorSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
573 {
574  CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
575 
576  // Avoid passing NULL pointer to xorbuf
577  size_t copied = 0;
578  if (m_buf && begin)
579  {
580  copied = STDMIN(length, SaturatingSubtract(m_size, m_total));
581  xorbuf(m_buf+m_total, begin, copied);
582  }
583  m_total += copied;
584  return length - copied;
585 }
586 
587 // *************************************************************
588 
590  : FilterWithBufferedInput(attachment)
591  , m_cipher(c), m_padding(DEFAULT_PADDING), m_optimalBufferSize(0)
592 {
593  assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
594 
595  if (!allowAuthenticatedSymmetricCipher && dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != 0)
596  throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
597 
599 }
600 
601 size_t StreamTransformationFilter::LastBlockSize(StreamTransformation &c, BlockPaddingScheme padding)
602 {
603  if (c.MinLastBlockSize() > 0)
604  return c.MinLastBlockSize();
605  else if (c.MandatoryBlockSize() > 1 && !c.IsForwardTransformation() && padding != NO_PADDING && padding != ZEROS_PADDING)
606  return c.MandatoryBlockSize();
607  else
608  return 0;
609 }
610 
611 void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
612 {
614  bool isBlockCipher = (m_cipher.MandatoryBlockSize() > 1 && m_cipher.MinLastBlockSize() == 0);
615 
616  if (padding == DEFAULT_PADDING)
617  m_padding = isBlockCipher ? PKCS_PADDING : NO_PADDING;
618  else
619  m_padding = padding;
620 
621  if (!isBlockCipher && (m_padding == PKCS_PADDING || m_padding == ONE_AND_ZEROS_PADDING))
622  throw InvalidArgument("StreamTransformationFilter: PKCS_PADDING and ONE_AND_ZEROS_PADDING cannot be used with " + m_cipher.AlgorithmName());
623 
624  firstSize = 0;
625  blockSize = m_cipher.MandatoryBlockSize();
626  lastSize = LastBlockSize(m_cipher, m_padding);
627 }
628 
629 void StreamTransformationFilter::FirstPut(const byte* inString)
630 {
631  CRYPTOPP_UNUSED(inString);
632  m_optimalBufferSize = m_cipher.OptimalBlockSize();
633  m_optimalBufferSize = (unsigned int)STDMAX(m_optimalBufferSize, RoundDownToMultipleOf(4096U, m_optimalBufferSize));
634 }
635 
636 void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t length)
637 {
638  if (!length)
639  return;
640 
641  size_t s = m_cipher.MandatoryBlockSize();
642 
643  do
644  {
645  size_t len = m_optimalBufferSize;
646  byte *space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, length, len);
647  if (len < length)
648  {
649  if (len == m_optimalBufferSize)
650  len -= m_cipher.GetOptimalBlockSizeUsed();
651  len = RoundDownToMultipleOf(len, s);
652  }
653  else
654  len = length;
655  m_cipher.ProcessString(space, inString, len);
656  AttachedTransformation()->PutModifiable(space, len);
657  inString += len;
658  length -= len;
659  }
660  while (length > 0);
661 }
662 
663 void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length)
664 {
665  m_cipher.ProcessString(inString, length);
666  AttachedTransformation()->PutModifiable(inString, length);
667 }
668 
669 void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
670 {
671  byte *space = NULL;
672 
673  switch (m_padding)
674  {
675  case NO_PADDING:
676  case ZEROS_PADDING:
677  if (length > 0)
678  {
679  size_t minLastBlockSize = m_cipher.MinLastBlockSize();
680  bool isForwardTransformation = m_cipher.IsForwardTransformation();
681 
682  if (isForwardTransformation && m_padding == ZEROS_PADDING && (minLastBlockSize == 0 || length < minLastBlockSize))
683  {
684  // do padding
685  size_t blockSize = STDMAX(minLastBlockSize, (size_t)m_cipher.MandatoryBlockSize());
687  if (inString) {memcpy(space, inString, length);}
688  memset(space + length, 0, blockSize - length);
689  m_cipher.ProcessLastBlock(space, space, blockSize);
690  AttachedTransformation()->Put(space, blockSize);
691  }
692  else
693  {
694  if (minLastBlockSize == 0)
695  {
696  if (isForwardTransformation)
697  throw InvalidDataFormat("StreamTransformationFilter: plaintext length is not a multiple of block size and NO_PADDING is specified");
698  else
699  throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");
700  }
701 
702  space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, length, m_optimalBufferSize);
703  m_cipher.ProcessLastBlock(space, inString, length);
704  AttachedTransformation()->Put(space, length);
705  }
706  }
707  break;
708 
709  case PKCS_PADDING:
711  unsigned int s;
712  s = m_cipher.MandatoryBlockSize();
713  assert(s > 1);
714  space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, m_optimalBufferSize);
715  if (m_cipher.IsForwardTransformation())
716  {
717  assert(length < s);
718  if (inString) {memcpy(space, inString, length);}
719  if (m_padding == PKCS_PADDING)
720  {
721  assert(s < 256);
722  byte pad = byte(s-length);
723  memset(space+length, pad, s-length);
724  }
725  else
726  {
727  space[length] = 0x80;
728  memset(space+length+1, 0, s-length-1);
729  }
730  m_cipher.ProcessData(space, space, s);
731  AttachedTransformation()->Put(space, s);
732  }
733  else
734  {
735  if (length != s)
736  throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");
737  m_cipher.ProcessData(space, inString, s);
738  if (m_padding == PKCS_PADDING)
739  {
740  byte pad = space[s-1];
741  if (pad < 1 || pad > s || std::find_if(space+s-pad, space+s, std::bind2nd(std::not_equal_to<byte>(), pad)) != space+s)
742  throw InvalidCiphertext("StreamTransformationFilter: invalid PKCS #7 block padding found");
743  length = s-pad;
744  }
745  else
746  {
747  while (length > 1 && space[length-1] == 0)
748  --length;
749  if (space[--length] != 0x80)
750  throw InvalidCiphertext("StreamTransformationFilter: invalid ones-and-zeros padding found");
751  }
752  AttachedTransformation()->Put(space, length);
753  }
754  break;
755 
756  default:
757  assert(false);
758  }
759 }
760 
761 // *************************************************************
762 
763 HashFilter::HashFilter(HashTransformation &hm, BufferedTransformation *attachment, bool putMessage, int truncatedDigestSize, const std::string &messagePutChannel, const std::string &hashPutChannel)
764  : m_hashModule(hm), m_putMessage(putMessage), m_digestSize(0), m_space(NULL)
765  , m_messagePutChannel(messagePutChannel), m_hashPutChannel(hashPutChannel)
766 {
767  m_digestSize = truncatedDigestSize < 0 ? m_hashModule.DigestSize() : truncatedDigestSize;
768  Detach(attachment);
769 }
770 
772 {
773  m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);
774  int s = parameters.GetIntValueWithDefault(Name::TruncatedDigestSize(), -1);
775  m_digestSize = s < 0 ? m_hashModule.DigestSize() : s;
776 }
777 
778 size_t HashFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
779 {
780  FILTER_BEGIN;
781  if (m_putMessage)
782  FILTER_OUTPUT3(1, 0, inString, length, 0, m_messagePutChannel);
783  if (inString && length)
784  m_hashModule.Update(inString, length);
785  if (messageEnd)
786  {
787  {
788  size_t size;
789  m_space = HelpCreatePutSpace(*AttachedTransformation(), m_hashPutChannel, m_digestSize, m_digestSize, size = m_digestSize);
790  m_hashModule.TruncatedFinal(m_space, m_digestSize);
791  }
792  FILTER_OUTPUT3(2, 0, m_space, m_digestSize, messageEnd, m_hashPutChannel);
793  }
794  FILTER_END_NO_MESSAGE_END;
795 }
796 
797 // *************************************************************
798 
799 HashVerificationFilter::HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment, word32 flags, int truncatedDigestSize)
800  : FilterWithBufferedInput(attachment)
801  , m_hashModule(hm), m_flags(0), m_digestSize(0), m_verified(false)
802 {
804 }
805 
806 void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
807 {
809  int s = parameters.GetIntValueWithDefault(Name::TruncatedDigestSize(), -1);
810  m_digestSize = s < 0 ? m_hashModule.DigestSize() : s;
811  m_verified = false;
812  firstSize = m_flags & HASH_AT_BEGIN ? m_digestSize : 0;
813  blockSize = 1;
814  lastSize = m_flags & HASH_AT_BEGIN ? 0 : m_digestSize;
815 }
816 
817 void HashVerificationFilter::FirstPut(const byte *inString)
818 {
819  if (m_flags & HASH_AT_BEGIN)
820  {
821  m_expectedHash.New(m_digestSize);
822  if (inString) {memcpy(m_expectedHash, inString, m_expectedHash.size());}
823  if (m_flags & PUT_HASH)
824  AttachedTransformation()->Put(inString, m_expectedHash.size());
825  }
826 }
827 
828 void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
829 {
830  m_hashModule.Update(inString, length);
831  if (m_flags & PUT_MESSAGE)
832  AttachedTransformation()->Put(inString, length);
833 }
834 
835 void HashVerificationFilter::LastPut(const byte *inString, size_t length)
836 {
837  if (m_flags & HASH_AT_BEGIN)
838  {
839  assert(length == 0);
840  m_verified = m_hashModule.TruncatedVerify(m_expectedHash, m_digestSize);
841  }
842  else
843  {
844  m_verified = (length==m_digestSize && m_hashModule.TruncatedVerify(inString, length));
845  if (m_flags & PUT_HASH)
846  AttachedTransformation()->Put(inString, length);
847  }
848 
849  if (m_flags & PUT_RESULT)
850  AttachedTransformation()->Put(m_verified);
851 
852  if ((m_flags & THROW_EXCEPTION) && !m_verified)
853  throw HashVerificationFailed();
854 }
855 
856 // *************************************************************
857 
859  bool putAAD, int truncatedDigestSize, const std::string &macChannel, BlockPaddingScheme padding)
860  : StreamTransformationFilter(c, attachment, padding, true)
861  , m_hf(c, new OutputProxy(*this, false), putAAD, truncatedDigestSize, AAD_CHANNEL, macChannel)
862 {
863  assert(c.IsForwardTransformation());
864 }
865 
867 {
868  m_hf.IsolatedInitialize(parameters);
870 }
871 
872 byte * AuthenticatedEncryptionFilter::ChannelCreatePutSpace(const std::string &channel, size_t &size)
873 {
874  if (channel.empty())
876 
877  if (channel == AAD_CHANNEL)
878  return m_hf.CreatePutSpace(size);
879 
880  throw InvalidChannelName("AuthenticatedEncryptionFilter", channel);
881 }
882 
883 size_t AuthenticatedEncryptionFilter::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
884 {
885  if (channel.empty())
886  return StreamTransformationFilter::Put2(begin, length, messageEnd, blocking);
887 
888  if (channel == AAD_CHANNEL)
889  return m_hf.Put2(begin, length, 0, blocking);
890 
891  throw InvalidChannelName("AuthenticatedEncryptionFilter", channel);
892 }
893 
894 void AuthenticatedEncryptionFilter::LastPut(const byte *inString, size_t length)
895 {
896  StreamTransformationFilter::LastPut(inString, length);
897  m_hf.MessageEnd();
898 }
899 
900 // *************************************************************
901 
903  : FilterWithBufferedInput(attachment)
904  , m_hashVerifier(c, new OutputProxy(*this, false))
905  , m_streamFilter(c, new OutputProxy(*this, false), padding, true)
906 {
907  assert(!c.IsForwardTransformation() || c.IsSelfInverting());
909 }
910 
911 void AuthenticatedDecryptionFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
912 {
913  word32 flags = parameters.GetValueWithDefault(Name::AuthenticatedDecryptionFilterFlags(), (word32)DEFAULT_FLAGS);
914 
916  m_streamFilter.Initialize(parameters);
917 
918  firstSize = m_hashVerifier.m_firstSize;
919  blockSize = 1;
920  lastSize = m_hashVerifier.m_lastSize;
921 }
922 
923 byte * AuthenticatedDecryptionFilter::ChannelCreatePutSpace(const std::string &channel, size_t &size)
924 {
925  if (channel.empty())
926  return m_streamFilter.CreatePutSpace(size);
927 
928  if (channel == AAD_CHANNEL)
929  return m_hashVerifier.CreatePutSpace(size);
930 
931  throw InvalidChannelName("AuthenticatedDecryptionFilter", channel);
932 }
933 
934 size_t AuthenticatedDecryptionFilter::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
935 {
936  if (channel.empty())
937  {
938  if (m_lastSize > 0)
939  m_hashVerifier.ForceNextPut();
940  return FilterWithBufferedInput::Put2(begin, length, messageEnd, blocking);
941  }
942 
943  if (channel == AAD_CHANNEL)
944  return m_hashVerifier.Put2(begin, length, 0, blocking);
945 
946  throw InvalidChannelName("AuthenticatedDecryptionFilter", channel);
947 }
948 
949 void AuthenticatedDecryptionFilter::FirstPut(const byte *inString)
950 {
951  m_hashVerifier.Put(inString, m_firstSize);
952 }
953 
954 void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t length)
955 {
956  m_streamFilter.Put(inString, length);
957 }
958 
959 void AuthenticatedDecryptionFilter::LastPut(const byte *inString, size_t length)
960 {
961  m_streamFilter.MessageEnd();
962  m_hashVerifier.PutMessageEnd(inString, length);
963 }
964 
965 // *************************************************************
966 
968 {
969  m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);
970  m_messageAccumulator.reset(m_signer.NewSignatureAccumulator(m_rng));
971 }
972 
973 size_t SignerFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
974 {
975  FILTER_BEGIN;
976  m_messageAccumulator->Update(inString, length);
977  if (m_putMessage)
978  FILTER_OUTPUT(1, inString, length, 0);
979  if (messageEnd)
980  {
981  m_buf.New(m_signer.SignatureLength());
982  m_signer.Sign(m_rng, m_messageAccumulator.release(), m_buf);
983  FILTER_OUTPUT(2, m_buf, m_buf.size(), messageEnd);
984  m_messageAccumulator.reset(m_signer.NewSignatureAccumulator(m_rng));
985  }
986  FILTER_END_NO_MESSAGE_END;
987 }
988 
990  : FilterWithBufferedInput(attachment)
991  , m_verifier(verifier), m_flags(0), m_verified(0)
992 {
994 }
995 
996 void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
997 {
998  m_flags = parameters.GetValueWithDefault(Name::SignatureVerificationFilterFlags(), (word32)DEFAULT_FLAGS);
999  m_messageAccumulator.reset(m_verifier.NewVerificationAccumulator());
1000  size_t size = m_verifier.SignatureLength();
1001  assert(size != 0); // TODO: handle recoverable signature scheme
1002  m_verified = false;
1003  firstSize = m_flags & SIGNATURE_AT_BEGIN ? size : 0;
1004  blockSize = 1;
1005  lastSize = m_flags & SIGNATURE_AT_BEGIN ? 0 : size;
1006 }
1007 
1008 void SignatureVerificationFilter::FirstPut(const byte *inString)
1009 {
1010  if (m_flags & SIGNATURE_AT_BEGIN)
1011  {
1012  if (m_verifier.SignatureUpfront())
1013  m_verifier.InputSignature(*m_messageAccumulator, inString, m_verifier.SignatureLength());
1014  else
1015  {
1016  m_signature.New(m_verifier.SignatureLength());
1017  if (inString) {memcpy(m_signature, inString, m_signature.size());}
1018  }
1019 
1020  if (m_flags & PUT_SIGNATURE)
1021  AttachedTransformation()->Put(inString, m_signature.size());
1022  }
1023  else
1024  {
1025  assert(!m_verifier.SignatureUpfront());
1026  }
1027 }
1028 
1029 void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
1030 {
1031  m_messageAccumulator->Update(inString, length);
1032  if (m_flags & PUT_MESSAGE)
1033  AttachedTransformation()->Put(inString, length);
1034 }
1035 
1036 void SignatureVerificationFilter::LastPut(const byte *inString, size_t length)
1037 {
1038  if (m_flags & SIGNATURE_AT_BEGIN)
1039  {
1040  assert(length == 0);
1041  m_verifier.InputSignature(*m_messageAccumulator, m_signature, m_signature.size());
1042  m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
1043  }
1044  else
1045  {
1046  m_verifier.InputSignature(*m_messageAccumulator, inString, length);
1047  m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
1048  if (m_flags & PUT_SIGNATURE)
1049  AttachedTransformation()->Put(inString, length);
1050  }
1051 
1052  if (m_flags & PUT_RESULT)
1053  AttachedTransformation()->Put(m_verified);
1054 
1055  if ((m_flags & THROW_EXCEPTION) && !m_verified)
1056  throw SignatureVerificationFailed();
1057 }
1058 
1059 // *************************************************************
1060 
1061 size_t Source::PumpAll2(bool blocking)
1062 {
1063  unsigned int messageCount = UINT_MAX;
1064  do {
1065  RETURN_IF_NONZERO(PumpMessages2(messageCount, blocking));
1066  } while(messageCount == UINT_MAX);
1067 
1068  return 0;
1069 }
1070 
1072 {
1073  if (!m_messageEnd && !AnyRetrievable())
1074  {
1075  m_messageEnd=true;
1076  return true;
1077  }
1078  else
1079  return false;
1080 }
1081 
1082 unsigned int Store::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const
1083 {
1084  if (m_messageEnd || count == 0)
1085  return 0;
1086  else
1087  {
1088  CopyTo(target, ULONG_MAX, channel);
1089  if (GetAutoSignalPropagation())
1090  target.ChannelMessageEnd(channel, GetAutoSignalPropagation()-1);
1091  return 1;
1092  }
1093 }
1094 
1095 void StringStore::StoreInitialize(const NameValuePairs &parameters)
1096 {
1098  if (!parameters.GetValue(Name::InputBuffer(), array))
1099  throw InvalidArgument("StringStore: missing InputBuffer argument");
1100  m_store = array.begin();
1101  m_length = array.size();
1102  m_count = 0;
1103 }
1104 
1105 size_t StringStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
1106 {
1107  lword position = 0;
1108  size_t blockedBytes = CopyRangeTo2(target, position, transferBytes, channel, blocking);
1109  m_count += (size_t)position;
1110  transferBytes = position;
1111  return blockedBytes;
1112 }
1113 
1114 size_t StringStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
1115 {
1116  size_t i = UnsignedMin(m_length, m_count+begin);
1117  size_t len = UnsignedMin(m_length-i, end-begin);
1118  size_t blockedBytes = target.ChannelPut2(channel, m_store+i, len, 0, blocking);
1119  if (!blockedBytes)
1120  begin += len;
1121  return blockedBytes;
1122 }
1123 
1124 void RandomNumberStore::StoreInitialize(const NameValuePairs &parameters)
1125 {
1126  parameters.GetRequiredParameter("RandomNumberStore", "RandomNumberGeneratorPointer", m_rng);
1127  int length;
1128  parameters.GetRequiredIntParameter("RandomNumberStore", "RandomNumberStoreSize", length);
1129  m_length = length;
1130 }
1131 
1132 size_t RandomNumberStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
1133 {
1134  if (!blocking)
1135  throw NotImplemented("RandomNumberStore: nonblocking transfer is not implemented by this object");
1136 
1137  transferBytes = UnsignedMin(transferBytes, m_length - m_count);
1138  m_rng->GenerateIntoBufferedTransformation(target, channel, transferBytes);
1139  m_count += transferBytes;
1140 
1141  return 0;
1142 }
1143 
1144 size_t NullStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
1145 {
1146  static const byte nullBytes[128] = {0};
1147  while (begin < end)
1148  {
1149  size_t len = (size_t)STDMIN(end-begin, lword(128));
1150  size_t blockedBytes = target.ChannelPut2(channel, nullBytes, len, 0, blocking);
1151  if (blockedBytes)
1152  return blockedBytes;
1153  begin += len;
1154  }
1155  return 0;
1156 }
1157 
1158 size_t NullStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
1159 {
1160  lword begin = 0;
1161  size_t blockedBytes = NullStore::CopyRangeTo2(target, begin, transferBytes, channel, blocking);
1162  transferBytes = begin;
1163  m_size -= begin;
1164  return blockedBytes;
1165 }
1166 
1167 NAMESPACE_END
1168 
1169 #endif
virtual void ProcessLastBlock(byte *outString, const byte *inString, size_t length)
Encrypt or decrypt the last block of data.
Definition: cryptlib.cpp:247
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:29
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:232
Standard names for retrieving values by name when working with NameValuePairs.
An invalid argument was detected.
Definition: cryptlib.h:182
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:475
Indicates the hash is at the beginning of the message (i.e., concatenation of hash+message) ...
Definition: filters.h:554
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:763
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0
Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulat...
virtual bool AnyRetrievable() const
Determines whether bytes are ready for retrieval.
Definition: cryptlib.cpp:507
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:529
void AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow=true)
Adds a range to skip during processing.
Definition: filters.cpp:166
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:778
void GetRequiredParameter(const char *className, const char *name, T &value) const
Retrieves a required name/value pair.
Definition: cryptlib.h:406
virtual void ProcessData(byte *outString, const byte *inString, size_t length)=0
Encrypt or decrypt an array of bytes.
Utility functions for the Crypto++ library.
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:934
virtual size_t PumpAll2(bool blocking=true)
Pump all data to attached transformation.
Definition: filters.cpp:1061
BlockPaddingScheme
Padding schemes used for block ciphers.
Definition: filters.h:459
Interface for one direction (encryption or decryption) of a stream cipher or block cipher mode with a...
Definition: cryptlib.h:1117
T GetValueWithDefault(const char *name, T defaultValue) const
Get a named value.
Definition: cryptlib.h:348
Indicates the filter should throw a HashVerificationFailed if a failure is encountered.
Definition: filters.h:562
Message Queue.
Definition: mqueue.h:14
Indicates the result of the verification should be passed to an attached transformation.
Definition: filters.h:560
const char * HashVerificationFilterFlags()
word32
Definition: argnames.h:52
virtual void TruncatedFinal(byte *digest, size_t digestSize)=0
Computes the hash of the current message.
virtual void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: cryptlib.h:1505
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:336
const char * AuthenticatedDecryptionFilterFlags()
word32
Definition: argnames.h:53
const char * SignatureVerificationFilterFlags()
word32
Definition: argnames.h:54
const char * BlockPaddingScheme()
StreamTransformationFilter::BlockPaddingScheme.
Definition: argnames.h:51
Default padding scheme.
Definition: filters.h:469
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
Definition: filters.cpp:95
AuthenticatedDecryptionFilter(AuthenticatedSymmetricCipher &c, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1, BlockPaddingScheme padding=DEFAULT_PADDING)
Construct a AuthenticatedDecryptionFilter.
Definition: filters.cpp:902
size_type size() const
Provides the count of elements in the SecBlock.
Definition: secblock.h:523
void ResetMeter()
Resets the meter.
Definition: filters.cpp:160
Indicates the filter should throw a HashVerificationFailed if a failure is encountered.
Definition: filters.h:720
StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment=NULL, BlockPaddingScheme padding=DEFAULT_PADDING, bool allowAuthenticatedSymmetricCipher=false)
Construct a StreamTransformationFilter.
Definition: filters.cpp:589
Classes for automatic resource management.
size_t size() const
Length of the memory block.
Definition: algparam.h:93
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.
Library configuration file.
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Definition: filters.cpp:872
void ProcessString(byte *inoutString, size_t length)
Encrypt or decrypt a string of bytes.
Definition: cryptlib.h:869
bool GetNextMessage()
Start retrieving the next message.
Definition: filters.cpp:1071
void New(size_type newSize)
Change size without preserving contents.
Definition: secblock.h:646
Combines two sets of NameValuePairs.
Definition: algparam.h:135
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:483
virtual bool TruncatedVerify(const byte *digest, size_t digestLength)
Verifies the hash of the current message.
Definition: cryptlib.cpp:411
SecBlock typedef.
Definition: secblock.h:730
Used to pass byte array input as part of a NameValuePairs object.
Definition: algparam.h:104
Interface for buffered transformations.
Definition: cryptlib.h:1352
const byte * begin() const
Pointer to the first byte in the memory block.
Definition: algparam.h:89
SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS)
Construct a SignatureVerificationFilter.
Definition: filters.cpp:989
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0
Create a new HashTransformation to accumulate the message to be signed.
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:967
Pointer that overloads operator→
Definition: smartptr.h:39
virtual unsigned int GetOptimalBlockSizeUsed() const
Provides the number of bytes used in the current block when processing at optimal block size...
Definition: cryptlib.h:841
size_t PutModifiable(byte *inString, size_t length, bool blocking=true)
Input multiple bytes that may be modified by callee.
Definition: cryptlib.h:1428
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:866
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
1 and 0's padding added to a block
Definition: filters.h:467
HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment=NULL, word32 flags=DEFAULT_FLAGS, int truncatedDigestSize=-1)
Construct a HashVerificationFilter.
Definition: filters.cpp:799
bool MessageEnd(int propagation=-1, bool blocking=true)
Signals the end of messages to the object.
Definition: cryptlib.h:1436
bool GetValue(const char *name, T &value) const
Get a named value.
Definition: cryptlib.h:335
virtual void Attach(BufferedTransformation *newAttachment)
Add newAttachment to the end of attachment chain.
Definition: cryptlib.cpp:763
int GetIntValueWithDefault(const char *name, int defaultValue) const
Get a named value with type int, with default.
Definition: cryptlib.h:380
A method was called which was not implemented.
Definition: cryptlib.h:203
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:541
size_t Put(byte inByte, bool blocking=true)
Input a byte for processing.
Definition: cryptlib.h:1378
virtual unsigned int OptimalBlockSize() const
Provides the input block size most efficient for this cipher.
Definition: cryptlib.h:837
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:973
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
Definition: filters.cpp:50
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
Definition: cryptlib.cpp:41
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Definition: algparam.h:554
virtual bool IsForwardTransformation() const =0
Determines if the cipher is being operated in its forward direction.
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:491
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:1144
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0
Create a new HashTransformation to accumulate the message to be verified.
virtual unsigned int MandatoryBlockSize() const
Provides the mandatory block size of the cipher.
Definition: cryptlib.h:830
virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
Definition: cryptlib.cpp:445
BufferedTransformation * AttachedTransformation()
Retrieve attached transformation.
Definition: filters.cpp:36
const char * PutMessage()
bool
Definition: argnames.h:49
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
Indicates the message should be passed to an attached transformation.
Definition: filters.h:556
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:883
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Definition: filters.cpp:923
Exception thrown when a filter does not recognize a named channel.
Definition: cryptlib.h:1849
byte * begin() const
Pointer to the first byte in the memory block.
Definition: algparam.h:119
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Definition: filters.cpp:557
const char * InputBuffer()
ConstByteArrayParameter.
Definition: argnames.h:55
virtual std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: cryptlib.h:518
T1 SaturatingSubtract(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 0.
Definition: misc.h:865
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
Definition: misc.h:433
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:467
Indicates the hash should be passed to an attached transformation.
Definition: filters.h:558
bool IsolatedMessageSeriesEnd(bool blocking)
Marks the end of a series of messages, without signal propagation.
Definition: filters.cpp:242
size_t size() const
Length of the memory block.
Definition: algparam.h:123
void GetRequiredIntParameter(const char *className, const char *name, int &value) const
Retrieves a required name/value pair.
Definition: cryptlib.h:421
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:572
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:563
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:1158
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
Sign and delete the messageAccumulator.
Definition: cryptlib.cpp:869
Interface for the data processing portion of stream ciphers.
Definition: cryptlib.h:816
Divides an input stream into discrete blocks.
Definition: filters.h:315
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
Definition: misc.h:397
virtual bool IsolatedMessageSeriesEnd(bool blocking)
Marks the end of a series of messages, without signal propagation.
Definition: cryptlib.h:1519
virtual bool IsolatedFlush(bool hardFlush, bool blocking)=0
Flushes data buffered by this object, without signal propagation.
Implementation of BufferedTransformation's attachment interface.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.cpp:534
A decryption filter encountered invalid ciphertext.
Definition: cryptlib.h:196
const char * OutputBuffer()
ByteArrayParameter.
Definition: argnames.h:56
Exception thrown by objects that have not implemented nonblocking input processing.
Definition: cryptlib.h:1472
Filter wrapper for StreamTransformation.
Definition: filters.h:476
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
virtual unsigned int DigestSize() const =0
Provides the digest size of the hash.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Definition: filters.h:523
FilterWithBufferedInput(BufferedTransformation *attachment)
Construct a FilterWithBufferedInput with an attached transformation.
Definition: filters.cpp:322
void TransferAllTo(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL)
Transfer all bytes from this object to another BufferedTransformation.
Definition: cryptlib.h:1757
Interface for public-key signature verifiers.
Definition: cryptlib.h:2601
ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
Construct a ProxyFilter.
Definition: filters.cpp:491
void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
Definition: misc.cpp:28
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:1132
virtual bool SignatureUpfront() const
Determines whether the signature must be input before the message.
Definition: cryptlib.h:2504
Interface for hash functions and data processing part of MACs.
Definition: cryptlib.h:922
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:1114
virtual byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Definition: cryptlib.h:1413
bool IsolatedFlush(bool hardFlush, bool blocking)
Definition: filters.cpp:498
0's padding added to a block
Definition: filters.h:463
const char * TruncatedDigestSize()
int
Definition: argnames.h:50
Implementation of BufferedTransformation's attachment interface.
Definition: filters.h:36
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
Definition: misc.h:407
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:1449
No padding added to a block.
Definition: filters.h:461
void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
Definition: filters.cpp:71
Crypto++ library namespace.
void Initialize(const NameValuePairs &parameters, int propagation)
Initialize or reinitialize this object, with signal propagation.
Definition: filters.cpp:480
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:1105
PKCS #5 padding added to a block.
Definition: filters.h:465
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:1673
Indicates the signature is at the beginning of the message (i.e., concatenation of signature+message)...
Definition: filters.h:712
Indicates the signature should be passed to an attached transformation.
Definition: filters.h:716
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:858
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.
const std::string AAD_CHANNEL
Channel for additional authenticated data.
Definition: cryptlib.cpp:63
bool IsolatedFlush(bool hardFlush, bool blocking)
Definition: filters.cpp:345
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:177
virtual size_t PumpMessages2(unsigned int &messageCount, bool blocking=true)=0
Pump messages to attached transformation.
virtual void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
Definition: cryptlib.cpp:438
Input data was received that did not conform to expected format.
Definition: cryptlib.h:189
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Definition: filters.h:337
void SetFilter(Filter *filter)
Sets the OutputProxy filter.
Definition: filters.cpp:503
virtual bool IsSelfInverting() const =0
Determines whether the cipher is self-inverting.
Pass everything.
Definition: filters.h:770
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
Definition: filters.cpp:78
virtual void Update(const byte *input, size_t length)=0
Updates a hash with additional input.
virtual unsigned int MinLastBlockSize() const
returns the minimum size of the last block, 0 indicating the last block is not special ...
Definition: cryptlib.h:863
T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
Rounds a value down to a multiple of a second value.
Definition: misc.h:753
Default flags using HASH_AT_BEGIN and PUT_RESULT.
Definition: filters.h:564
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
Generate random bytes into a BufferedTransformation.
Definition: cryptlib.cpp:347
virtual void IncorporateEntropy(const byte *input, size_t length)
Update RNG state with additional unpredictable values.
Definition: cryptlib.h:1201
bool ChannelMessageEnd(const std::string &channel, int propagation=-1, bool blocking=true)
Signal the end of a message.
Definition: cryptlib.h:1907
#define SIZE_MAX
The maximum value of a machine word.
Definition: misc.h:74
void IsolatedInitialize(const NameValuePairs &parameters)
Initialize or reinitialize this object, without signal propagation.
Definition: filters.cpp:771
Interface for retrieving values given their names.
Definition: cryptlib.h:277
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0
Input signature into a message accumulator.
virtual size_t SignatureLength() const =0
Provides the signature length if it only depends on the key.