00001
00002
00003 #include "pch.h"
00004
00005 #ifndef CRYPTOPP_IMPORTS
00006
00007 #include "filters.h"
00008 #include "mqueue.h"
00009 #include "fltrimpl.h"
00010 #include "argnames.h"
00011 #include <memory>
00012 #include <functional>
00013
00014 NAMESPACE_BEGIN(CryptoPP)
00015
00016 Filter::Filter(BufferedTransformation *attachment)
00017 : m_attachment(attachment), m_continueAt(0)
00018 {
00019 }
00020
00021 BufferedTransformation * Filter::NewDefaultAttachment() const
00022 {
00023 return new MessageQueue;
00024 }
00025
00026 BufferedTransformation * Filter::AttachedTransformation()
00027 {
00028 if (m_attachment.get() == NULL)
00029 m_attachment.reset(NewDefaultAttachment());
00030 return m_attachment.get();
00031 }
00032
00033 const BufferedTransformation *Filter::AttachedTransformation() const
00034 {
00035 if (m_attachment.get() == NULL)
00036 const_cast<Filter *>(this)->m_attachment.reset(NewDefaultAttachment());
00037 return m_attachment.get();
00038 }
00039
00040 void Filter::Detach(BufferedTransformation *newOut)
00041 {
00042 m_attachment.reset(newOut);
00043 }
00044
00045 void Filter::Insert(Filter *filter)
00046 {
00047 filter->m_attachment.reset(m_attachment.release());
00048 m_attachment.reset(filter);
00049 }
00050
00051 size_t Filter::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
00052 {
00053 return AttachedTransformation()->CopyRangeTo2(target, begin, end, channel, blocking);
00054 }
00055
00056 size_t Filter::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
00057 {
00058 return AttachedTransformation()->TransferTo2(target, transferBytes, channel, blocking);
00059 }
00060
00061 void Filter::Initialize(const NameValuePairs ¶meters, int propagation)
00062 {
00063 m_continueAt = 0;
00064 IsolatedInitialize(parameters);
00065 PropagateInitialize(parameters, propagation);
00066 }
00067
00068 bool Filter::Flush(bool hardFlush, int propagation, bool blocking)
00069 {
00070 switch (m_continueAt)
00071 {
00072 case 0:
00073 if (IsolatedFlush(hardFlush, blocking))
00074 return true;
00075 case 1:
00076 if (OutputFlush(1, hardFlush, propagation, blocking))
00077 return true;
00078 }
00079 return false;
00080 }
00081
00082 bool Filter::MessageSeriesEnd(int propagation, bool blocking)
00083 {
00084 switch (m_continueAt)
00085 {
00086 case 0:
00087 if (IsolatedMessageSeriesEnd(blocking))
00088 return true;
00089 case 1:
00090 if (ShouldPropagateMessageSeriesEnd() && OutputMessageSeriesEnd(1, propagation, blocking))
00091 return true;
00092 }
00093 return false;
00094 }
00095
00096 void Filter::PropagateInitialize(const NameValuePairs ¶meters, int propagation)
00097 {
00098 if (propagation)
00099 AttachedTransformation()->Initialize(parameters, propagation-1);
00100 }
00101
00102 size_t Filter::OutputModifiable(int outputSite, byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel)
00103 {
00104 if (messageEnd)
00105 messageEnd--;
00106 size_t result = AttachedTransformation()->ChannelPutModifiable2(channel, inString, length, messageEnd, blocking);
00107 m_continueAt = result ? outputSite : 0;
00108 return result;
00109 }
00110
00111 size_t Filter::Output(int outputSite, const byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel)
00112 {
00113 if (messageEnd)
00114 messageEnd--;
00115 size_t result = AttachedTransformation()->ChannelPut2(channel, inString, length, messageEnd, blocking);
00116 m_continueAt = result ? outputSite : 0;
00117 return result;
00118 }
00119
00120 bool Filter::OutputFlush(int outputSite, bool hardFlush, int propagation, bool blocking, const std::string &channel)
00121 {
00122 if (propagation && AttachedTransformation()->ChannelFlush(channel, hardFlush, propagation-1, blocking))
00123 {
00124 m_continueAt = outputSite;
00125 return true;
00126 }
00127 m_continueAt = 0;
00128 return false;
00129 }
00130
00131 bool Filter::OutputMessageSeriesEnd(int outputSite, int propagation, bool blocking, const std::string &channel)
00132 {
00133 if (propagation && AttachedTransformation()->ChannelMessageSeriesEnd(channel, propagation-1, blocking))
00134 {
00135 m_continueAt = outputSite;
00136 return true;
00137 }
00138 m_continueAt = 0;
00139 return false;
00140 }
00141
00142
00143
00144 void MeterFilter::ResetMeter()
00145 {
00146 m_currentMessageBytes = m_totalBytes = m_currentSeriesMessages = m_totalMessages = m_totalMessageSeries = 0;
00147 m_rangesToSkip.clear();
00148 }
00149
00150 void MeterFilter::AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow)
00151 {
00152 MessageRange r = {message, position, size};
00153 m_rangesToSkip.push_back(r);
00154 if (sortNow)
00155 std::sort(m_rangesToSkip.begin(), m_rangesToSkip.end());
00156 }
00157
00158 size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEnd, bool blocking, bool modifiable)
00159 {
00160 if (!m_transparent)
00161 return 0;
00162
00163 size_t t;
00164 FILTER_BEGIN;
00165
00166 m_begin = begin;
00167 m_length = length;
00168
00169 while (m_length > 0 || messageEnd)
00170 {
00171 if (m_length > 0 && !m_rangesToSkip.empty() && m_rangesToSkip.front().message == m_totalMessages && m_currentMessageBytes + m_length > m_rangesToSkip.front().position)
00172 {
00173 FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes), false, modifiable);
00174
00175 assert(t < m_length);
00176 m_begin += t;
00177 m_length -= t;
00178 m_currentMessageBytes += t;
00179 m_totalBytes += t;
00180
00181 if (m_currentMessageBytes + m_length < m_rangesToSkip.front().position + m_rangesToSkip.front().size)
00182 t = m_length;
00183 else
00184 {
00185 t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position + m_rangesToSkip.front().size, m_currentMessageBytes);
00186 assert(t <= m_length);
00187 m_rangesToSkip.pop_front();
00188 }
00189
00190 m_begin += t;
00191 m_length -= t;
00192 m_currentMessageBytes += t;
00193 m_totalBytes += t;
00194 }
00195 else
00196 {
00197 FILTER_OUTPUT_MAYBE_MODIFIABLE(2, m_begin, m_length, messageEnd, modifiable);
00198
00199 m_currentMessageBytes += m_length;
00200 m_totalBytes += m_length;
00201 m_length = 0;
00202
00203 if (messageEnd)
00204 {
00205 m_currentMessageBytes = 0;
00206 m_currentSeriesMessages++;
00207 m_totalMessages++;
00208 messageEnd = false;
00209 }
00210 }
00211 }
00212
00213 FILTER_END_NO_MESSAGE_END;
00214 }
00215
00216 size_t MeterFilter::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00217 {
00218 return PutMaybeModifiable(const_cast<byte *>(begin), length, messageEnd, blocking, false);
00219 }
00220
00221 size_t MeterFilter::PutModifiable2(byte *begin, size_t length, int messageEnd, bool blocking)
00222 {
00223 return PutMaybeModifiable(begin, length, messageEnd, blocking, true);
00224 }
00225
00226 bool MeterFilter::IsolatedMessageSeriesEnd(bool blocking)
00227 {
00228 m_currentMessageBytes = 0;
00229 m_currentSeriesMessages = 0;
00230 m_totalMessageSeries++;
00231 return false;
00232 }
00233
00234
00235
00236 void FilterWithBufferedInput::BlockQueue::ResetQueue(size_t blockSize, size_t maxBlocks)
00237 {
00238 m_buffer.New(blockSize * maxBlocks);
00239 m_blockSize = blockSize;
00240 m_maxBlocks = maxBlocks;
00241 m_size = 0;
00242 m_begin = m_buffer;
00243 }
00244
00245 byte *FilterWithBufferedInput::BlockQueue::GetBlock()
00246 {
00247 if (m_size >= m_blockSize)
00248 {
00249 byte *ptr = m_begin;
00250 if ((m_begin+=m_blockSize) == m_buffer.end())
00251 m_begin = m_buffer;
00252 m_size -= m_blockSize;
00253 return ptr;
00254 }
00255 else
00256 return NULL;
00257 }
00258
00259 byte *FilterWithBufferedInput::BlockQueue::GetContigousBlocks(size_t &numberOfBytes)
00260 {
00261 numberOfBytes = STDMIN(numberOfBytes, STDMIN(size_t(m_buffer.end()-m_begin), m_size));
00262 byte *ptr = m_begin;
00263 m_begin += numberOfBytes;
00264 m_size -= numberOfBytes;
00265 if (m_size == 0 || m_begin == m_buffer.end())
00266 m_begin = m_buffer;
00267 return ptr;
00268 }
00269
00270 size_t FilterWithBufferedInput::BlockQueue::GetAll(byte *outString)
00271 {
00272 size_t size = m_size;
00273 size_t numberOfBytes = m_maxBlocks*m_blockSize;
00274 const byte *ptr = GetContigousBlocks(numberOfBytes);
00275 memcpy(outString, ptr, numberOfBytes);
00276 memcpy(outString+numberOfBytes, m_begin, m_size);
00277 m_size = 0;
00278 return size;
00279 }
00280
00281 void FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t length)
00282 {
00283 assert(m_size + length <= m_buffer.size());
00284 byte *end = (m_size < size_t(m_buffer.end()-m_begin)) ? m_begin + m_size : m_begin + m_size - m_buffer.size();
00285 size_t len = STDMIN(length, size_t(m_buffer.end()-end));
00286 memcpy(end, inString, len);
00287 if (len < length)
00288 memcpy(m_buffer, inString+len, length-len);
00289 m_size += length;
00290 }
00291
00292 FilterWithBufferedInput::FilterWithBufferedInput(BufferedTransformation *attachment)
00293 : Filter(attachment)
00294 {
00295 }
00296
00297 FilterWithBufferedInput::FilterWithBufferedInput(size_t firstSize, size_t blockSize, size_t lastSize, BufferedTransformation *attachment)
00298 : Filter(attachment), m_firstSize(firstSize), m_blockSize(blockSize), m_lastSize(lastSize)
00299 , m_firstInputDone(false)
00300 {
00301 if (m_firstSize < 0 || m_blockSize < 1 || m_lastSize < 0)
00302 throw InvalidArgument("FilterWithBufferedInput: invalid buffer size");
00303
00304 m_queue.ResetQueue(1, m_firstSize);
00305 }
00306
00307 void FilterWithBufferedInput::IsolatedInitialize(const NameValuePairs ¶meters)
00308 {
00309 InitializeDerivedAndReturnNewSizes(parameters, m_firstSize, m_blockSize, m_lastSize);
00310 if (m_firstSize < 0 || m_blockSize < 1 || m_lastSize < 0)
00311 throw InvalidArgument("FilterWithBufferedInput: invalid buffer size");
00312 m_queue.ResetQueue(1, m_firstSize);
00313 m_firstInputDone = false;
00314 }
00315
00316 bool FilterWithBufferedInput::IsolatedFlush(bool hardFlush, bool blocking)
00317 {
00318 if (!blocking)
00319 throw BlockingInputOnly("FilterWithBufferedInput");
00320
00321 if (hardFlush)
00322 ForceNextPut();
00323 FlushDerived();
00324
00325 return false;
00326 }
00327
00328 size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length, int messageEnd, bool blocking, bool modifiable)
00329 {
00330 if (!blocking)
00331 throw BlockingInputOnly("FilterWithBufferedInput");
00332
00333 if (length != 0)
00334 {
00335 size_t newLength = m_queue.CurrentSize() + length;
00336
00337 if (!m_firstInputDone && newLength >= m_firstSize)
00338 {
00339 size_t len = m_firstSize - m_queue.CurrentSize();
00340 m_queue.Put(inString, len);
00341 FirstPut(m_queue.GetContigousBlocks(m_firstSize));
00342 assert(m_queue.CurrentSize() == 0);
00343 m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
00344
00345 inString += len;
00346 newLength -= m_firstSize;
00347 m_firstInputDone = true;
00348 }
00349
00350 if (m_firstInputDone)
00351 {
00352 if (m_blockSize == 1)
00353 {
00354 while (newLength > m_lastSize && m_queue.CurrentSize() > 0)
00355 {
00356 size_t len = newLength - m_lastSize;
00357 byte *ptr = m_queue.GetContigousBlocks(len);
00358 NextPutModifiable(ptr, len);
00359 newLength -= len;
00360 }
00361
00362 if (newLength > m_lastSize)
00363 {
00364 size_t len = newLength - m_lastSize;
00365 NextPutMaybeModifiable(inString, len, modifiable);
00366 inString += len;
00367 newLength -= len;
00368 }
00369 }
00370 else
00371 {
00372 while (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() >= m_blockSize)
00373 {
00374 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
00375 newLength -= m_blockSize;
00376 }
00377
00378 if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
00379 {
00380 assert(m_queue.CurrentSize() < m_blockSize);
00381 size_t len = m_blockSize - m_queue.CurrentSize();
00382 m_queue.Put(inString, len);
00383 inString += len;
00384 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
00385 newLength -= m_blockSize;
00386 }
00387
00388 if (newLength >= m_blockSize + m_lastSize)
00389 {
00390 size_t len = RoundDownToMultipleOf(newLength - m_lastSize, m_blockSize);
00391 NextPutMaybeModifiable(inString, len, modifiable);
00392 inString += len;
00393 newLength -= len;
00394 }
00395 }
00396 }
00397
00398 m_queue.Put(inString, newLength - m_queue.CurrentSize());
00399 }
00400
00401 if (messageEnd)
00402 {
00403 if (!m_firstInputDone && m_firstSize==0)
00404 FirstPut(NULL);
00405
00406 SecByteBlock temp(m_queue.CurrentSize());
00407 m_queue.GetAll(temp);
00408 LastPut(temp, temp.size());
00409
00410 m_firstInputDone = false;
00411 m_queue.ResetQueue(1, m_firstSize);
00412
00413 Output(1, NULL, 0, messageEnd, blocking);
00414 }
00415 return 0;
00416 }
00417
00418 void FilterWithBufferedInput::ForceNextPut()
00419 {
00420 if (!m_firstInputDone)
00421 return;
00422
00423 if (m_blockSize > 1)
00424 {
00425 while (m_queue.CurrentSize() >= m_blockSize)
00426 NextPutModifiable(m_queue.GetBlock(), m_blockSize);
00427 }
00428 else
00429 {
00430 size_t len;
00431 while ((len = m_queue.CurrentSize()) > 0)
00432 NextPutModifiable(m_queue.GetContigousBlocks(len), len);
00433 }
00434 }
00435
00436 void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t length)
00437 {
00438 assert(m_blockSize > 1);
00439 while (length > 0)
00440 {
00441 assert(length >= m_blockSize);
00442 NextPutSingle(inString);
00443 inString += m_blockSize;
00444 length -= m_blockSize;
00445 }
00446 }
00447
00448
00449
00450 void Redirector::Initialize(const NameValuePairs ¶meters, int propagation)
00451 {
00452 m_target = parameters.GetValueWithDefault("RedirectionTargetPointer", (BufferedTransformation*)NULL);
00453 m_behavior = parameters.GetIntValueWithDefault("RedirectionBehavior", PASS_EVERYTHING);
00454
00455 if (m_target && GetPassSignals())
00456 m_target->Initialize(parameters, propagation);
00457 }
00458
00459
00460
00461 ProxyFilter::ProxyFilter(BufferedTransformation *filter, size_t firstSize, size_t lastSize, BufferedTransformation *attachment)
00462 : FilterWithBufferedInput(firstSize, 1, lastSize, attachment), m_filter(filter)
00463 {
00464 if (m_filter.get())
00465 m_filter->Attach(new OutputProxy(*this, false));
00466 }
00467
00468 bool ProxyFilter::IsolatedFlush(bool hardFlush, bool blocking)
00469 {
00470 return m_filter.get() ? m_filter->Flush(hardFlush, -1, blocking) : false;
00471 }
00472
00473 void ProxyFilter::SetFilter(Filter *filter)
00474 {
00475 m_filter.reset(filter);
00476 if (filter)
00477 {
00478 OutputProxy *proxy;
00479 std::auto_ptr<OutputProxy> temp(proxy = new OutputProxy(*this, false));
00480 m_filter->TransferAllTo(*proxy);
00481 m_filter->Attach(temp.release());
00482 }
00483 }
00484
00485 void ProxyFilter::NextPutMultiple(const byte *s, size_t len)
00486 {
00487 if (m_filter.get())
00488 m_filter->Put(s, len);
00489 }
00490
00491 void ProxyFilter::NextPutModifiable(byte *s, size_t len)
00492 {
00493 if (m_filter.get())
00494 m_filter->PutModifiable(s, len);
00495 }
00496
00497
00498
00499 void RandomNumberSink::IsolatedInitialize(const NameValuePairs ¶meters)
00500 {
00501 parameters.GetRequiredParameter("RandomNumberSink", "RandomNumberGeneratorPointer", m_rng);
00502 }
00503
00504 size_t RandomNumberSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00505 {
00506 m_rng->IncorporateEntropy(begin, length);
00507 return 0;
00508 }
00509
00510 size_t ArraySink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00511 {
00512 if (m_buf+m_total != begin)
00513 memcpy(m_buf+m_total, begin, STDMIN(length, SaturatingSubtract(m_size, m_total)));
00514 m_total += length;
00515 return 0;
00516 }
00517
00518 byte * ArraySink::CreatePutSpace(size_t &size)
00519 {
00520 size = SaturatingSubtract(m_size, m_total);
00521 return m_buf + m_total;
00522 }
00523
00524 void ArraySink::IsolatedInitialize(const NameValuePairs ¶meters)
00525 {
00526 ByteArrayParameter array;
00527 if (!parameters.GetValue(Name::OutputBuffer(), array))
00528 throw InvalidArgument("ArraySink: missing OutputBuffer argument");
00529 m_buf = array.begin();
00530 m_size = array.size();
00531 m_total = 0;
00532 }
00533
00534 size_t ArrayXorSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00535 {
00536 xorbuf(m_buf+m_total, begin, STDMIN(length, SaturatingSubtract(m_size, m_total)));
00537 m_total += length;
00538 return 0;
00539 }
00540
00541
00542
00543 StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment, BlockPaddingScheme padding, bool allowAuthenticatedSymmetricCipher)
00544 : FilterWithBufferedInput(attachment)
00545 , m_cipher(c)
00546 {
00547 assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
00548
00549 if (!allowAuthenticatedSymmetricCipher && dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != 0)
00550 throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
00551
00552 IsolatedInitialize(MakeParameters(Name::BlockPaddingScheme(), padding));
00553 }
00554
00555 size_t StreamTransformationFilter::LastBlockSize(StreamTransformation &c, BlockPaddingScheme padding)
00556 {
00557 if (c.MinLastBlockSize() > 0)
00558 return c.MinLastBlockSize();
00559 else if (c.MandatoryBlockSize() > 1 && !c.IsForwardTransformation() && padding != NO_PADDING && padding != ZEROS_PADDING)
00560 return c.MandatoryBlockSize();
00561 else
00562 return 0;
00563 }
00564
00565 void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs ¶meters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
00566 {
00567 BlockPaddingScheme padding = parameters.GetValueWithDefault(Name::BlockPaddingScheme(), DEFAULT_PADDING);
00568 bool isBlockCipher = (m_cipher.MandatoryBlockSize() > 1 && m_cipher.MinLastBlockSize() == 0);
00569
00570 if (padding == DEFAULT_PADDING)
00571 m_padding = isBlockCipher ? PKCS_PADDING : NO_PADDING;
00572 else
00573 m_padding = padding;
00574
00575 if (!isBlockCipher && (m_padding == PKCS_PADDING || m_padding == ONE_AND_ZEROS_PADDING))
00576 throw InvalidArgument("StreamTransformationFilter: PKCS_PADDING and ONE_AND_ZEROS_PADDING cannot be used with " + m_cipher.AlgorithmName());
00577
00578 firstSize = 0;
00579 blockSize = m_cipher.MandatoryBlockSize();
00580 lastSize = LastBlockSize(m_cipher, m_padding);
00581 }
00582
00583 void StreamTransformationFilter::FirstPut(const byte *inString)
00584 {
00585 m_optimalBufferSize = m_cipher.OptimalBlockSize();
00586 m_optimalBufferSize = (unsigned int)STDMAX(m_optimalBufferSize, RoundDownToMultipleOf(4096U, m_optimalBufferSize));
00587 }
00588
00589 void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t length)
00590 {
00591 if (!length)
00592 return;
00593
00594 size_t s = m_cipher.MandatoryBlockSize();
00595
00596 do
00597 {
00598 size_t len = m_optimalBufferSize;
00599 byte *space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, length, len);
00600 if (len < length)
00601 {
00602 if (len == m_optimalBufferSize)
00603 len -= m_cipher.GetOptimalBlockSizeUsed();
00604 len = RoundDownToMultipleOf(len, s);
00605 }
00606 else
00607 len = length;
00608 m_cipher.ProcessString(space, inString, len);
00609 AttachedTransformation()->PutModifiable(space, len);
00610 inString += len;
00611 length -= len;
00612 }
00613 while (length > 0);
00614 }
00615
00616 void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length)
00617 {
00618 m_cipher.ProcessString(inString, length);
00619 AttachedTransformation()->PutModifiable(inString, length);
00620 }
00621
00622 void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
00623 {
00624 byte *space = NULL;
00625
00626 switch (m_padding)
00627 {
00628 case NO_PADDING:
00629 case ZEROS_PADDING:
00630 if (length > 0)
00631 {
00632 size_t minLastBlockSize = m_cipher.MinLastBlockSize();
00633 bool isForwardTransformation = m_cipher.IsForwardTransformation();
00634
00635 if (isForwardTransformation && m_padding == ZEROS_PADDING && (minLastBlockSize == 0 || length < minLastBlockSize))
00636 {
00637
00638 size_t blockSize = STDMAX(minLastBlockSize, (size_t)m_cipher.MandatoryBlockSize());
00639 space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, blockSize);
00640 memcpy(space, inString, length);
00641 memset(space + length, 0, blockSize - length);
00642 m_cipher.ProcessLastBlock(space, space, blockSize);
00643 AttachedTransformation()->Put(space, blockSize);
00644 }
00645 else
00646 {
00647 if (minLastBlockSize == 0)
00648 {
00649 if (isForwardTransformation)
00650 throw InvalidDataFormat("StreamTransformationFilter: plaintext length is not a multiple of block size and NO_PADDING is specified");
00651 else
00652 throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");
00653 }
00654
00655 space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, length, m_optimalBufferSize);
00656 m_cipher.ProcessLastBlock(space, inString, length);
00657 AttachedTransformation()->Put(space, length);
00658 }
00659 }
00660 break;
00661
00662 case PKCS_PADDING:
00663 case ONE_AND_ZEROS_PADDING:
00664 unsigned int s;
00665 s = m_cipher.MandatoryBlockSize();
00666 assert(s > 1);
00667 space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, m_optimalBufferSize);
00668 if (m_cipher.IsForwardTransformation())
00669 {
00670 assert(length < s);
00671 memcpy(space, inString, length);
00672 if (m_padding == PKCS_PADDING)
00673 {
00674 assert(s < 256);
00675 byte pad = byte(s-length);
00676 memset(space+length, pad, s-length);
00677 }
00678 else
00679 {
00680 space[length] = 0x80;
00681 memset(space+length+1, 0, s-length-1);
00682 }
00683 m_cipher.ProcessData(space, space, s);
00684 AttachedTransformation()->Put(space, s);
00685 }
00686 else
00687 {
00688 if (length != s)
00689 throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");
00690 m_cipher.ProcessData(space, inString, s);
00691 if (m_padding == PKCS_PADDING)
00692 {
00693 byte pad = space[s-1];
00694 if (pad < 1 || pad > s || std::find_if(space+s-pad, space+s, std::bind2nd(std::not_equal_to<byte>(), pad)) != space+s)
00695 throw InvalidCiphertext("StreamTransformationFilter: invalid PKCS #7 block padding found");
00696 length = s-pad;
00697 }
00698 else
00699 {
00700 while (length > 1 && space[length-1] == 0)
00701 --length;
00702 if (space[--length] != 0x80)
00703 throw InvalidCiphertext("StreamTransformationFilter: invalid ones-and-zeros padding found");
00704 }
00705 AttachedTransformation()->Put(space, length);
00706 }
00707 break;
00708
00709 default:
00710 assert(false);
00711 }
00712 }
00713
00714
00715
00716 HashFilter::HashFilter(HashTransformation &hm, BufferedTransformation *attachment, bool putMessage, int truncatedDigestSize, const std::string &messagePutChannel, const std::string &hashPutChannel)
00717 : m_hashModule(hm), m_putMessage(putMessage), m_messagePutChannel(messagePutChannel), m_hashPutChannel(hashPutChannel)
00718 {
00719 m_digestSize = truncatedDigestSize < 0 ? m_hashModule.DigestSize() : truncatedDigestSize;
00720 Detach(attachment);
00721 }
00722
00723 void HashFilter::IsolatedInitialize(const NameValuePairs ¶meters)
00724 {
00725 m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);
00726 int s = parameters.GetIntValueWithDefault(Name::TruncatedDigestSize(), -1);
00727 m_digestSize = s < 0 ? m_hashModule.DigestSize() : s;
00728 }
00729
00730 size_t HashFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
00731 {
00732 FILTER_BEGIN;
00733 if (m_putMessage)
00734 FILTER_OUTPUT3(1, 0, inString, length, 0, m_messagePutChannel);
00735 m_hashModule.Update(inString, length);
00736 if (messageEnd)
00737 {
00738 {
00739 size_t size;
00740 m_space = HelpCreatePutSpace(*AttachedTransformation(), m_hashPutChannel, m_digestSize, m_digestSize, size = m_digestSize);
00741 m_hashModule.TruncatedFinal(m_space, m_digestSize);
00742 }
00743 FILTER_OUTPUT3(2, 0, m_space, m_digestSize, messageEnd, m_hashPutChannel);
00744 }
00745 FILTER_END_NO_MESSAGE_END;
00746 }
00747
00748
00749
00750 HashVerificationFilter::HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment, word32 flags, int truncatedDigestSize)
00751 : FilterWithBufferedInput(attachment)
00752 , m_hashModule(hm)
00753 {
00754 IsolatedInitialize(MakeParameters(Name::HashVerificationFilterFlags(), flags)(Name::TruncatedDigestSize(), truncatedDigestSize));
00755 }
00756
00757 void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs ¶meters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
00758 {
00759 m_flags = parameters.GetValueWithDefault(Name::HashVerificationFilterFlags(), (word32)DEFAULT_FLAGS);
00760 int s = parameters.GetIntValueWithDefault(Name::TruncatedDigestSize(), -1);
00761 m_digestSize = s < 0 ? m_hashModule.DigestSize() : s;
00762 m_verified = false;
00763 firstSize = m_flags & HASH_AT_BEGIN ? m_digestSize : 0;
00764 blockSize = 1;
00765 lastSize = m_flags & HASH_AT_BEGIN ? 0 : m_digestSize;
00766 }
00767
00768 void HashVerificationFilter::FirstPut(const byte *inString)
00769 {
00770 if (m_flags & HASH_AT_BEGIN)
00771 {
00772 m_expectedHash.New(m_digestSize);
00773 memcpy(m_expectedHash, inString, m_expectedHash.size());
00774 if (m_flags & PUT_HASH)
00775 AttachedTransformation()->Put(inString, m_expectedHash.size());
00776 }
00777 }
00778
00779 void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
00780 {
00781 m_hashModule.Update(inString, length);
00782 if (m_flags & PUT_MESSAGE)
00783 AttachedTransformation()->Put(inString, length);
00784 }
00785
00786 void HashVerificationFilter::LastPut(const byte *inString, size_t length)
00787 {
00788 if (m_flags & HASH_AT_BEGIN)
00789 {
00790 assert(length == 0);
00791 m_verified = m_hashModule.TruncatedVerify(m_expectedHash, m_digestSize);
00792 }
00793 else
00794 {
00795 m_verified = (length==m_digestSize && m_hashModule.TruncatedVerify(inString, length));
00796 if (m_flags & PUT_HASH)
00797 AttachedTransformation()->Put(inString, length);
00798 }
00799
00800 if (m_flags & PUT_RESULT)
00801 AttachedTransformation()->Put(m_verified);
00802
00803 if ((m_flags & THROW_EXCEPTION) && !m_verified)
00804 throw HashVerificationFailed();
00805 }
00806
00807
00808
00809 AuthenticatedEncryptionFilter::AuthenticatedEncryptionFilter(AuthenticatedSymmetricCipher &c, BufferedTransformation *attachment,
00810 bool putAAD, int truncatedDigestSize, const std::string &macChannel, BlockPaddingScheme padding)
00811 : StreamTransformationFilter(c, attachment, padding, true)
00812 , m_hf(c, new OutputProxy(*this, false), putAAD, truncatedDigestSize, AAD_CHANNEL, macChannel)
00813 {
00814 assert(c.IsForwardTransformation());
00815 }
00816
00817 void AuthenticatedEncryptionFilter::IsolatedInitialize(const NameValuePairs ¶meters)
00818 {
00819 m_hf.IsolatedInitialize(parameters);
00820 StreamTransformationFilter::IsolatedInitialize(parameters);
00821 }
00822
00823 byte * AuthenticatedEncryptionFilter::ChannelCreatePutSpace(const std::string &channel, size_t &size)
00824 {
00825 if (channel.empty())
00826 return StreamTransformationFilter::CreatePutSpace(size);
00827
00828 if (channel == AAD_CHANNEL)
00829 return m_hf.CreatePutSpace(size);
00830
00831 throw InvalidChannelName("AuthenticatedEncryptionFilter", channel);
00832 }
00833
00834 size_t AuthenticatedEncryptionFilter::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
00835 {
00836 if (channel.empty())
00837 return StreamTransformationFilter::Put2(begin, length, messageEnd, blocking);
00838
00839 if (channel == AAD_CHANNEL)
00840 return m_hf.Put2(begin, length, 0, blocking);
00841
00842 throw InvalidChannelName("AuthenticatedEncryptionFilter", channel);
00843 }
00844
00845 void AuthenticatedEncryptionFilter::LastPut(const byte *inString, size_t length)
00846 {
00847 StreamTransformationFilter::LastPut(inString, length);
00848 m_hf.MessageEnd();
00849 }
00850
00851
00852
00853 AuthenticatedDecryptionFilter::AuthenticatedDecryptionFilter(AuthenticatedSymmetricCipher &c, BufferedTransformation *attachment, word32 flags, int truncatedDigestSize, BlockPaddingScheme padding)
00854 : FilterWithBufferedInput(attachment)
00855 , m_hashVerifier(c, new OutputProxy(*this, false))
00856 , m_streamFilter(c, new OutputProxy(*this, false), padding, true)
00857 {
00858 assert(!c.IsForwardTransformation() || c.IsSelfInverting());
00859 IsolatedInitialize(MakeParameters(Name::BlockPaddingScheme(), padding)(Name::AuthenticatedDecryptionFilterFlags(), flags)(Name::TruncatedDigestSize(), truncatedDigestSize));
00860 }
00861
00862 void AuthenticatedDecryptionFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs ¶meters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
00863 {
00864 word32 flags = parameters.GetValueWithDefault(Name::AuthenticatedDecryptionFilterFlags(), (word32)DEFAULT_FLAGS);
00865
00866 m_hashVerifier.Initialize(CombinedNameValuePairs(parameters, MakeParameters(Name::HashVerificationFilterFlags(), flags)));
00867 m_streamFilter.Initialize(parameters);
00868
00869 firstSize = m_hashVerifier.m_firstSize;
00870 blockSize = 1;
00871 lastSize = m_hashVerifier.m_lastSize;
00872 }
00873
00874 byte * AuthenticatedDecryptionFilter::ChannelCreatePutSpace(const std::string &channel, size_t &size)
00875 {
00876 if (channel.empty())
00877 return m_streamFilter.CreatePutSpace(size);
00878
00879 if (channel == AAD_CHANNEL)
00880 return m_hashVerifier.CreatePutSpace(size);
00881
00882 throw InvalidChannelName("AuthenticatedDecryptionFilter", channel);
00883 }
00884
00885 size_t AuthenticatedDecryptionFilter::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
00886 {
00887 if (channel.empty())
00888 {
00889 if (m_lastSize > 0)
00890 m_hashVerifier.ForceNextPut();
00891 return FilterWithBufferedInput::Put2(begin, length, messageEnd, blocking);
00892 }
00893
00894 if (channel == AAD_CHANNEL)
00895 return m_hashVerifier.Put2(begin, length, 0, blocking);
00896
00897 throw InvalidChannelName("AuthenticatedDecryptionFilter", channel);
00898 }
00899
00900 void AuthenticatedDecryptionFilter::FirstPut(const byte *inString)
00901 {
00902 m_hashVerifier.Put(inString, m_firstSize);
00903 }
00904
00905 void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t length)
00906 {
00907 m_streamFilter.Put(inString, length);
00908 }
00909
00910 void AuthenticatedDecryptionFilter::LastPut(const byte *inString, size_t length)
00911 {
00912 m_streamFilter.MessageEnd();
00913 m_hashVerifier.PutMessageEnd(inString, length);
00914 }
00915
00916
00917
00918 void SignerFilter::IsolatedInitialize(const NameValuePairs ¶meters)
00919 {
00920 m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);
00921 m_messageAccumulator.reset(m_signer.NewSignatureAccumulator(m_rng));
00922 }
00923
00924 size_t SignerFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
00925 {
00926 FILTER_BEGIN;
00927 m_messageAccumulator->Update(inString, length);
00928 if (m_putMessage)
00929 FILTER_OUTPUT(1, inString, length, 0);
00930 if (messageEnd)
00931 {
00932 m_buf.New(m_signer.SignatureLength());
00933 m_signer.Sign(m_rng, m_messageAccumulator.release(), m_buf);
00934 FILTER_OUTPUT(2, m_buf, m_buf.size(), messageEnd);
00935 m_messageAccumulator.reset(m_signer.NewSignatureAccumulator(m_rng));
00936 }
00937 FILTER_END_NO_MESSAGE_END;
00938 }
00939
00940 SignatureVerificationFilter::SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment, word32 flags)
00941 : FilterWithBufferedInput(attachment)
00942 , m_verifier(verifier)
00943 {
00944 IsolatedInitialize(MakeParameters(Name::SignatureVerificationFilterFlags(), flags));
00945 }
00946
00947 void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs ¶meters, size_t &firstSize, size_t &blockSize, size_t &lastSize)
00948 {
00949 m_flags = parameters.GetValueWithDefault(Name::SignatureVerificationFilterFlags(), (word32)DEFAULT_FLAGS);
00950 m_messageAccumulator.reset(m_verifier.NewVerificationAccumulator());
00951 size_t size = m_verifier.SignatureLength();
00952 assert(size != 0);
00953 m_verified = false;
00954 firstSize = m_flags & SIGNATURE_AT_BEGIN ? size : 0;
00955 blockSize = 1;
00956 lastSize = m_flags & SIGNATURE_AT_BEGIN ? 0 : size;
00957 }
00958
00959 void SignatureVerificationFilter::FirstPut(const byte *inString)
00960 {
00961 if (m_flags & SIGNATURE_AT_BEGIN)
00962 {
00963 if (m_verifier.SignatureUpfront())
00964 m_verifier.InputSignature(*m_messageAccumulator, inString, m_verifier.SignatureLength());
00965 else
00966 {
00967 m_signature.New(m_verifier.SignatureLength());
00968 memcpy(m_signature, inString, m_signature.size());
00969 }
00970
00971 if (m_flags & PUT_SIGNATURE)
00972 AttachedTransformation()->Put(inString, m_signature.size());
00973 }
00974 else
00975 {
00976 assert(!m_verifier.SignatureUpfront());
00977 }
00978 }
00979
00980 void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
00981 {
00982 m_messageAccumulator->Update(inString, length);
00983 if (m_flags & PUT_MESSAGE)
00984 AttachedTransformation()->Put(inString, length);
00985 }
00986
00987 void SignatureVerificationFilter::LastPut(const byte *inString, size_t length)
00988 {
00989 if (m_flags & SIGNATURE_AT_BEGIN)
00990 {
00991 assert(length == 0);
00992 m_verifier.InputSignature(*m_messageAccumulator, m_signature, m_signature.size());
00993 m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
00994 }
00995 else
00996 {
00997 m_verifier.InputSignature(*m_messageAccumulator, inString, length);
00998 m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
00999 if (m_flags & PUT_SIGNATURE)
01000 AttachedTransformation()->Put(inString, length);
01001 }
01002
01003 if (m_flags & PUT_RESULT)
01004 AttachedTransformation()->Put(m_verified);
01005
01006 if ((m_flags & THROW_EXCEPTION) && !m_verified)
01007 throw SignatureVerificationFailed();
01008 }
01009
01010
01011
01012 size_t Source::PumpAll2(bool blocking)
01013 {
01014 unsigned int messageCount = UINT_MAX;
01015 do {
01016 RETURN_IF_NONZERO(PumpMessages2(messageCount, blocking));
01017 } while(messageCount == UINT_MAX);
01018
01019 return 0;
01020 }
01021
01022 bool Store::GetNextMessage()
01023 {
01024 if (!m_messageEnd && !AnyRetrievable())
01025 {
01026 m_messageEnd=true;
01027 return true;
01028 }
01029 else
01030 return false;
01031 }
01032
01033 unsigned int Store::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const
01034 {
01035 if (m_messageEnd || count == 0)
01036 return 0;
01037 else
01038 {
01039 CopyTo(target, ULONG_MAX, channel);
01040 if (GetAutoSignalPropagation())
01041 target.ChannelMessageEnd(channel, GetAutoSignalPropagation()-1);
01042 return 1;
01043 }
01044 }
01045
01046 void StringStore::StoreInitialize(const NameValuePairs ¶meters)
01047 {
01048 ConstByteArrayParameter array;
01049 if (!parameters.GetValue(Name::InputBuffer(), array))
01050 throw InvalidArgument("StringStore: missing InputBuffer argument");
01051 m_store = array.begin();
01052 m_length = array.size();
01053 m_count = 0;
01054 }
01055
01056 size_t StringStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
01057 {
01058 lword position = 0;
01059 size_t blockedBytes = CopyRangeTo2(target, position, transferBytes, channel, blocking);
01060 m_count += (size_t)position;
01061 transferBytes = position;
01062 return blockedBytes;
01063 }
01064
01065 size_t StringStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
01066 {
01067 size_t i = UnsignedMin(m_length, m_count+begin);
01068 size_t len = UnsignedMin(m_length-i, end-begin);
01069 size_t blockedBytes = target.ChannelPut2(channel, m_store+i, len, 0, blocking);
01070 if (!blockedBytes)
01071 begin += len;
01072 return blockedBytes;
01073 }
01074
01075 void RandomNumberStore::StoreInitialize(const NameValuePairs ¶meters)
01076 {
01077 parameters.GetRequiredParameter("RandomNumberStore", "RandomNumberGeneratorPointer", m_rng);
01078 int length;
01079 parameters.GetRequiredIntParameter("RandomNumberStore", "RandomNumberStoreSize", length);
01080 m_length = length;
01081 }
01082
01083 size_t RandomNumberStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
01084 {
01085 if (!blocking)
01086 throw NotImplemented("RandomNumberStore: nonblocking transfer is not implemented by this object");
01087
01088 transferBytes = UnsignedMin(transferBytes, m_length - m_count);
01089 m_rng->GenerateIntoBufferedTransformation(target, channel, transferBytes);
01090 m_count += transferBytes;
01091
01092 return 0;
01093 }
01094
01095 size_t NullStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const
01096 {
01097 static const byte nullBytes[128] = {0};
01098 while (begin < end)
01099 {
01100 size_t len = (size_t)STDMIN(end-begin, lword(128));
01101 size_t blockedBytes = target.ChannelPut2(channel, nullBytes, len, 0, blocking);
01102 if (blockedBytes)
01103 return blockedBytes;
01104 begin += len;
01105 }
01106 return 0;
01107 }
01108
01109 size_t NullStore::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)
01110 {
01111 lword begin = 0;
01112 size_t blockedBytes = NullStore::CopyRangeTo2(target, begin, transferBytes, channel, blocking);
01113 transferBytes = begin;
01114 m_size -= begin;
01115 return blockedBytes;
01116 }
01117
01118 NAMESPACE_END
01119
01120 #endif