Crypto++
5.6.5
Free C++ class library of cryptographic schemes
|
Go to the documentation of this file.
6 #ifndef CRYPTOPP_FILTERS_H
7 #define CRYPTOPP_FILTERS_H
11 #if CRYPTOPP_MSC_VERSION
12 # pragma warning(push)
13 # pragma warning(disable: 4127 4189 4514)
39 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
78 bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true);
79 bool MessageSeriesEnd(
int propagation=-1,
bool blocking=
true);
83 void Insert(
Filter *nextFilter);
85 virtual bool ShouldPropagateMessageEnd()
const {
return true;}
86 virtual bool ShouldPropagateMessageSeriesEnd()
const {
return true;}
88 void PropagateInitialize(
const NameValuePairs ¶meters,
int propagation);
98 size_t Output(
int outputSite,
const byte *inString,
size_t length,
int messageEnd,
bool blocking,
const std::string &channel=
DEFAULT_CHANNEL);
108 size_t OutputModifiable(
int outputSite,
byte *inString,
size_t length,
int messageEnd,
bool blocking,
const std::string &channel=
DEFAULT_CHANNEL);
118 bool OutputMessageEnd(
int outputSite,
int propagation,
bool blocking,
const std::string &channel=
DEFAULT_CHANNEL);
137 bool OutputFlush(
int outputSite,
bool hardFlush,
int propagation,
bool blocking,
const std::string &channel=
DEFAULT_CHANNEL);
150 bool OutputMessageSeriesEnd(
int outputSite,
int propagation,
bool blocking,
const std::string &channel=
DEFAULT_CHANNEL);
156 size_t m_inputPosition;
180 if (m_tempSpace.size() < minSize)
183 if (desiredSize >= minSize)
185 bufferSize = desiredSize;
188 m_tempSpace.New(bufferSize);
191 bufferSize = m_tempSpace.size();
192 return m_tempSpace.begin();
201 {
return HelpCreatePutSpace(target, channel, minSize, minSize, minSize);}
210 {
return HelpCreatePutSpace(target, channel, minSize, minSize, bufferSize);}
229 : m_transparent(transparent), m_currentMessageBytes(0), m_totalBytes(0)
230 , m_currentSeriesMessages(0), m_totalMessages(0), m_totalMessageSeries(0)
231 , m_begin(NULL), m_length(0) {Detach(attachment); ResetMeter();}
244 void AddRangeToSkip(
unsigned int message, lword position, lword size,
bool sortNow =
true);
252 {CRYPTOPP_UNUSED(parameters); ResetMeter();}
254 lword GetCurrentMessageBytes()
const {
return m_currentMessageBytes;}
255 lword GetTotalBytes()
const {
return m_totalBytes;}
256 unsigned int GetCurrentSeriesMessages()
const {
return m_currentSeriesMessages;}
257 unsigned int GetTotalMessages()
const {
return m_totalMessages;}
258 unsigned int GetTotalMessageSeries()
const {
return m_totalMessageSeries;}
261 {
return AttachedTransformation()->CreatePutSpace(size);}
262 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
263 size_t PutModifiable2(
byte *inString,
size_t length,
int messageEnd,
bool blocking);
264 bool IsolatedMessageSeriesEnd(
bool blocking);
267 size_t PutMaybeModifiable(
byte *inString,
size_t length,
int messageEnd,
bool blocking,
bool modifiable);
268 bool ShouldPropagateMessageEnd()
const {
return m_transparent;}
269 bool ShouldPropagateMessageSeriesEnd()
const {
return m_transparent;}
273 inline bool operator<(
const MessageRange &b)
const
274 {
return message < b.message || (message == b.message && position < b.position);}
275 unsigned int message; lword position; lword size;
279 lword m_currentMessageBytes, m_totalBytes;
280 unsigned int m_currentSeriesMessages, m_totalMessages, m_totalMessageSeries;
281 std::deque<MessageRange> m_rangesToSkip;
319 #if !defined(CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562)
337 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
339 return PutMaybeModifiable(
const_cast<byte *
>(inString), length, messageEnd, blocking,
false);
341 size_t PutModifiable2(
byte *inString,
size_t length,
int messageEnd,
bool blocking)
343 return PutMaybeModifiable(inString, length, messageEnd, blocking,
true);
359 virtual bool DidFirstPut()
const {
return m_firstInputDone;}
360 virtual size_t GetFirstPutSize()
const {
return m_firstSize;}
361 virtual size_t GetBlockPutSize()
const {
return m_blockSize;}
362 virtual size_t GetLastPutSize()
const {
return m_lastSize;}
364 virtual void InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize)
365 {CRYPTOPP_UNUSED(parameters); CRYPTOPP_UNUSED(firstSize); CRYPTOPP_UNUSED(blockSize); CRYPTOPP_UNUSED(lastSize); InitializeDerived(parameters);}
367 {CRYPTOPP_UNUSED(parameters);}
371 virtual void FirstPut(
const byte *inString) =0;
373 virtual void NextPutSingle(
const byte *inString)
377 virtual void NextPutMultiple(
const byte *inString,
size_t length);
379 virtual void NextPutModifiable(
byte *inString,
size_t length)
380 {NextPutMultiple(inString, length);}
385 virtual void LastPut(
const byte *inString,
size_t length) =0;
386 virtual void FlushDerived() {}
389 size_t PutMaybeModifiable(
byte *begin,
size_t length,
int messageEnd,
bool blocking,
bool modifiable);
390 void NextPutMaybeModifiable(
byte *inString,
size_t length,
bool modifiable)
392 if (modifiable) NextPutModifiable(inString, length);
393 else NextPutMultiple(inString, length);
398 virtual int NextPut(
const byte *inString,
size_t length)
399 {CRYPTOPP_UNUSED(inString); CRYPTOPP_UNUSED(length);
CRYPTOPP_ASSERT(
false);
return 0;}
404 void ResetQueue(
size_t blockSize,
size_t maxBlocks);
406 byte *GetContigousBlocks(
size_t &numberOfBytes);
407 size_t GetAll(
byte *outString);
408 void Put(
const byte *inString,
size_t length);
409 size_t CurrentSize()
const {
return m_size;}
410 size_t MaxSize()
const {
return m_buffer.size();}
414 size_t m_blockSize, m_maxBlocks, m_size;
418 size_t m_firstSize, m_blockSize, m_lastSize;
419 bool m_firstInputDone;
435 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
440 m_inQueue.Put(inString, length);
443 IsolatedMessageEnd(blocking);
444 Output(0, NULL, 0, messageEnd, blocking);
450 virtual bool IsolatedMessageEnd(
bool blocking) =0;
452 {CRYPTOPP_UNUSED(parameters); m_inQueue.Clear();}
498 void InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize);
499 void FirstPut(
const byte *inString);
500 void NextPutMultiple(
const byte *inString,
size_t length);
501 void NextPutModifiable(
byte *inString,
size_t length);
502 void LastPut(
const byte *inString,
size_t length);
507 BlockPaddingScheme m_padding;
508 unsigned int m_optimalBufferSize;
511 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
531 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
532 byte *
CreatePutSpace(
size_t &size) {
return m_hashModule.CreateUpdateSpace(size);}
537 unsigned int m_digestSize;
539 std::string m_messagePutChannel, m_hashPutChannel;
553 :
Exception(DATA_INTEGRITY_CHECK_FAILED,
"HashVerificationFilter: message hash or MAC not valid") {}
573 DEFAULT_FLAGS = HASH_AT_BEGIN | PUT_RESULT
585 bool GetLastResult()
const {
return m_verified;}
588 void InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize);
589 void FirstPut(
const byte *inString);
590 void NextPutMultiple(
const byte *inString,
size_t length);
591 void LastPut(
const byte *inString,
size_t length);
598 unsigned int m_digestSize;
623 size_t ChannelPut2(
const std::string &channel,
const byte *begin,
size_t length,
int messageEnd,
bool blocking);
624 void LastPut(
const byte *inString,
size_t length);
647 DEFAULT_FLAGS = THROW_EXCEPTION
662 size_t ChannelPut2(
const std::string &channel,
const byte *begin,
size_t length,
int messageEnd,
bool blocking);
663 bool GetLastResult()
const {
return m_hashVerifier.GetLastResult();}
666 void InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize);
667 void FirstPut(
const byte *inString);
668 void NextPutMultiple(
const byte *inString,
size_t length);
669 void LastPut(
const byte *inString,
size_t length);
686 : m_rng(rng), m_signer(signer), m_messageAccumulator(signer.NewSignatureAccumulator(rng)), m_putMessage(putMessage) {Detach(attachment);}
691 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
711 :
Exception(DATA_INTEGRITY_CHECK_FAILED,
"VerifierFilter: digital signature not valid") {}
721 SIGNATURE_AT_BEGIN=1,
731 DEFAULT_FLAGS = SIGNATURE_AT_BEGIN | PUT_RESULT
747 void InitializeDerivedAndReturnNewSizes(
const NameValuePairs ¶meters,
size_t &firstSize,
size_t &blockSize,
size_t &lastSize);
748 void FirstPut(
const byte *inString);
749 void NextPutMultiple(
const byte *inString,
size_t length);
750 void LastPut(
const byte *inString,
size_t length);
776 PASS_WAIT_OBJECTS = 0x02,
779 PASS_EVERYTHING = PASS_SIGNALS | PASS_WAIT_OBJECTS
783 Redirector() : m_target(NULL), m_behavior(PASS_EVERYTHING) {}
789 : m_target(&target), m_behavior(behavior) {}
797 Behavior GetBehavior() {
return (Behavior) m_behavior;}
798 void SetBehavior(Behavior behavior) {m_behavior=behavior;}
799 bool GetPassSignals()
const {
return (m_behavior & PASS_SIGNALS) != 0;}
800 void SetPassSignals(
bool pass) {
if (pass) m_behavior |= PASS_SIGNALS;
else m_behavior &= ~(word32) PASS_SIGNALS; }
801 bool GetPassWaitObjects()
const {
return (m_behavior & PASS_WAIT_OBJECTS) != 0;}
802 void SetPassWaitObjects(
bool pass) {
if (pass) m_behavior |= PASS_WAIT_OBJECTS;
else m_behavior &= ~(word32) PASS_WAIT_OBJECTS; }
805 {
return m_target ? m_target->CanModifyInput() :
false;}
807 void Initialize(
const NameValuePairs ¶meters,
int propagation);
811 return m_target->CreatePutSpace(size);
818 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
819 {
return m_target ? m_target->Put2(inString, length, GetPassSignals() ? messageEnd : 0, blocking) : 0;}
820 bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true)
821 {
return m_target && GetPassSignals() ? m_target->Flush(hardFlush, propagation, blocking) :
false;}
823 {
return m_target && GetPassSignals() ? m_target->MessageSeriesEnd(propagation, blocking) :
false;}
828 return m_target->ChannelCreatePutSpace(channel, size);
835 size_t ChannelPut2(
const std::string &channel,
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
836 {
return m_target ? m_target->ChannelPut2(channel, begin, length, GetPassSignals() ? messageEnd : 0, blocking) : 0;}
838 {
return m_target ? m_target->ChannelPutModifiable2(channel, begin, length, GetPassSignals() ? messageEnd : 0, blocking) : 0;}
839 bool ChannelFlush(
const std::string &channel,
bool completeFlush,
int propagation=-1,
bool blocking=
true)
840 {
return m_target && GetPassSignals() ? m_target->ChannelFlush(channel, completeFlush, propagation, blocking) :
false;}
842 {
return m_target && GetPassSignals() ? m_target->ChannelMessageSeriesEnd(channel, propagation, blocking) :
false;}
845 {
return m_target && GetPassWaitObjects() ? m_target->GetMaxWaitObjectCount() : 0; }
847 {
if (m_target && GetPassWaitObjects()) m_target->GetWaitObjects(container, callStack); }
860 bool GetPassSignal()
const {
return m_passSignal;}
861 void SetPassSignal(
bool passSignal) {m_passSignal = passSignal;}
864 {
return m_owner.AttachedTransformation()->CreatePutSpace(size);}
865 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
866 {
return m_owner.AttachedTransformation()->Put2(inString, length, m_passSignal ? messageEnd : 0, blocking);}
868 {
return m_owner.AttachedTransformation()->PutModifiable2(begin, length, m_passSignal ? messageEnd : 0, blocking);}
870 {
if (m_passSignal) m_owner.AttachedTransformation()->Initialize(parameters, propagation);}
871 bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true)
872 {
return m_passSignal ? m_owner.AttachedTransformation()->Flush(hardFlush, propagation, blocking) :
false;}
874 {
return m_passSignal ? m_owner.AttachedTransformation()->MessageSeriesEnd(propagation, blocking) :
false;}
877 {
return m_owner.AttachedTransformation()->ChannelCreatePutSpace(channel, size);}
878 size_t ChannelPut2(
const std::string &channel,
const byte *begin,
size_t length,
int messageEnd,
bool blocking)
879 {
return m_owner.AttachedTransformation()->ChannelPut2(channel, begin, length, m_passSignal ? messageEnd : 0, blocking);}
881 {
return m_owner.AttachedTransformation()->ChannelPutModifiable2(channel, begin, length, m_passSignal ? messageEnd : 0, blocking);}
882 bool ChannelFlush(
const std::string &channel,
bool completeFlush,
int propagation=-1,
bool blocking=
true)
883 {
return m_passSignal ? m_owner.AttachedTransformation()->ChannelFlush(channel, completeFlush, propagation, blocking) :
false;}
885 {
return m_passSignal ? m_owner.AttachedTransformation()->ChannelMessageSeriesEnd(channel, propagation, blocking) :
false;}
908 void SetFilter(
Filter *filter);
909 void NextPutMultiple(
const byte *s,
size_t len);
910 void NextPutModifiable(
byte *inString,
size_t length);
927 void FirstPut(
const byte * inString)
928 {CRYPTOPP_UNUSED(inString);}
929 void LastPut(
const byte *inString,
size_t length)
930 {CRYPTOPP_UNUSED(inString), CRYPTOPP_UNUSED(length); m_filter->MessageEnd();}
972 typedef typename T::traits_type::char_type char_type;
980 {
if (!parameters.
GetValue(
"OutputStringPointer", m_output))
throw InvalidArgument(
"StringSink: OutputStringPointer not specified");}
982 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
984 CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
987 typename T::size_type size = m_output->size();
988 if (length < size && size + length > m_output->capacity())
989 m_output->reserve(2*size);
990 m_output->append((
const char_type *)inString, (
const char_type *)inString+length);
1017 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
1032 : m_buf(NULL), m_size(0), m_total(0) {IsolatedInitialize(parameters);}
1038 : m_buf(buf), m_size(size), m_total(0) {}
1049 byte * CreatePutSpace(
size_t &size);
1050 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
1069 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking);
1099 CRYPTOPP_DLL
void StoreInitialize(
const NameValuePairs ¶meters);
1101 const byte *m_store;
1102 size_t m_length, m_count;
1110 : m_rng(NULL), m_length(0), m_count(0) {}
1113 : m_rng(&rng), m_length(length), m_count(0) {}
1121 CRYPTOPP_UNUSED(target); CRYPTOPP_UNUSED(begin); CRYPTOPP_UNUSED(end); CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(blocking);
1122 throw NotImplemented(
"RandomNumberStore: CopyRangeTo2() is not supported by this store");
1129 lword m_length, m_count;
1136 NullStore(lword size = ULONG_MAX) : m_size(size) {}
1138 {CRYPTOPP_UNUSED(parameters);}
1160 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
1179 {Pump2(pumpMax);
return pumpMax;}
1186 {PumpMessages2(count);
return count;}
1200 virtual size_t Pump2(lword &byteCount,
bool blocking=
true) =0;
1206 virtual size_t PumpMessages2(
unsigned int &messageCount,
bool blocking=
true) =0;
1211 virtual size_t PumpAll2(
bool blocking=
true);
1215 virtual bool SourceExhausted()
const =0;
1220 void SourceInitialize(
bool pumpAll,
const NameValuePairs ¶meters)
1222 IsolatedInitialize(parameters);
1241 {m_store.IsolatedInitialize(parameters);}
1242 size_t Pump2(lword &byteCount,
bool blocking=
true)
1249 {
return !m_store.AnyRetrievable() && !m_store.AnyMessages();}
1251 {m_store.SetAutoSignalPropagation(propagation);}
1253 {
return m_store.GetAutoSignalPropagation();}
1292 {SourceInitialize(pumpAll,
MakeParameters(
"RandomNumberGeneratorPointer", &rng)(
"RandomNumberStoreSize", length));}
1297 #if CRYPTOPP_MSC_VERSION
1298 # pragma warning(pop)
void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1)
Initialize or reinitialize this object, with signal propagation.
@ PKCS_PADDING
PKCS #5 padding added to a block.
@ ZEROS_PADDING
0's padding added to a block
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.
Interface for public-key encryptors.
PK_DecryptorFilter(RandomNumberGenerator &rng, const PK_Decryptor &decryptor, BufferedTransformation *attachment=NULL)
Construct a PK_DecryptorFilter.
ArraySink(const NameValuePairs ¶meters=g_nullNameValuePairs)
Construct an ArraySink.
std::string AlgorithmName() const
Provides the name of this algorithm.
StringStore(const T &string)
Construct a StringStore.
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Filter wrapper for PK_Signer.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
std::string AlgorithmName() const
Provides the name of this algorithm.
Create a working space in a BufferedTransformation.
byte * HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize)
Create a working space in a BufferedTransformation.
std::string AlgorithmName() const
Provides the name of this algorithm.
A method was called which was not implemented.
size_t Pump2(lword &byteCount, bool blocking=true)
Pump data to attached transformation.
BlockPaddingScheme
Padding schemes used for block ciphers.
SecByteBlock m_tempSpace
Temporay working space.
size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee on a channel.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
A non-transparent MeterFilter.
ArraySink(byte *buf, size_t size)
Construct an ArraySink.
StringSinkTemplate(T &output)
Construct a StringSinkTemplate.
StringSource(const byte *string, size_t length, bool pumpAll, BufferedTransformation *attachment=NULL)
binary byte array as source
Implementation of BufferedTransformation's attachment interface.
Data structure used to store byte strings.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
Xor input to a memory buffer.
String-based implementation of Store interface.
size_t PutModifiable2(byte *begin, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee.
bool Attachable()
Determine if attachable.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
lword TotalPutLength()
Provides the number of bytes written to the Sink.
Classes and functions for secure memory allocations.
RandomNumberSink(RandomNumberGenerator &rng)
Construct a RandomNumberSink.
Append input to a string object.
Filter wrapper for PK_Decryptor.
lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
Proxy filter that doesn't modify the underlying filter's input or output.
MeterFilter(BufferedTransformation *attachment=NULL, bool transparent=true)
Construct a MeterFilter.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
A transparent MeterFilter.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Acts as a Source for pre-existing, static data.
Classes for automatic resource management.
StringSource(const std::string &string, bool pumpAll, BufferedTransformation *attachment=NULL)
std::string as source
Interface for public-key decryptors.
#define SIZE_MAX
The maximum value of a machine word.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing on a channel.
unsigned int GetMaxWaitObjectCount() const
Retrieves the maximum number of waitable objects.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
Filter wrapper for HashTransformation.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
Base class for Filter classes that are proxies for a chain of other filters.
Redirector(BufferedTransformation &target, Behavior behavior=PASS_EVERYTHING)
Construct a Redirector.
TransparentFilter(BufferedTransformation *attachment=NULL)
Construct a TransparentFilter.
bool operator<(const OID &lhs, const OID &rhs)
Compare two OIDs for ordering.
@ DEFAULT_PADDING
Default padding scheme.
std::string AlgorithmName() const
Provides the name of this algorithm.
Filter wrapper for PK_Encryptor.
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.
StringSource(BufferedTransformation *attachment=NULL)
Construct a StringSource.
Exception thrown when a data integrity check failure is encountered.
Provides interface for initialization of derived filters.
Interface for random number generators.
size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee on a channel.
Classes providing basic library services.
Incorporates input into RNG as additional entropy.
size_t AvailableSize()
Provides the size remaining in the Sink.
Access a block of memory.
Interface for public-key signers.
bool AnyRetrievable() const
Determines whether bytes are ready for retrieval.
int GetAutoSignalPropagation() const
Retrieve automatic signal propagation value.
Base class for all exceptions thrown by the library.
Utility functions for the Crypto++ library.
void PumpAll()
Pump all data to attached transformation.
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
Implementation of BufferedTransformation's attachment interface.
lword Pump(lword pumpMax=(size_t) ...)
Pump data to attached transformation.
unsigned int PumpMessages(unsigned int count=UINT_MAX)
Pump messages to attached transformation.
Padding schemes used for block ciphers.
Ensures an object is not copyable.
bool GetLastResult() const
Retrieves the result of the last verification.
Copy input to a memory buffer.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
byte * HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize)
Create a working space in a BufferedTransformation.
Redirector()
Construct a Redirector.
RandomNumberSink()
Construct a RandomNumberSink.
void SetTransparent(bool transparent)
Set or change the transparent mode of this object.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
void SetAutoSignalPropagation(int propagation)
Set propagation of automatically generated and transferred signals.
bool SourceExhausted() const
Determines if the Source is exhausted.
SignerFilter(RandomNumberGenerator &rng, const PK_Signer &signer, BufferedTransformation *attachment=NULL, bool putMessage=false)
Construct a SignerFilter.
bool CanModifyInput() const
Determines whether input can be modifed by the callee.
Filter wrapper for HashTransformation.
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
Base class for unflushable filters.
Classes for an unlimited queue to store bytes.
void Detach(BufferedTransformation *newAttachment=NULL)
Replace an attached transformation.
RNG-based implementation of Source interface.
Source(BufferedTransformation *attachment=NULL)
Construct a Source.
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
OpaqueFilter(BufferedTransformation *attachment=NULL)
Construct an OpaqueFilter.
bool ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output on a channel.
StringStore(const byte *string, size_t length)
Construct a StringStore.
size_t PumpAll2(bool blocking=true)
Pump all data to attached transformation.
Base class for bufferless filters.
@ NO_PADDING
No padding added to a block.
void StopRedirection()
Stop redirecting input.
Flags
Flags controlling filter behavior.
bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true)
Marks the end of a series of messages on a channel.
An invalid argument was detected.
Exception thrown when an invalid signature is encountered.
Flags
Flags controlling filter behavior.
Behavior
Controls signal propagation behavior.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
byte * HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t bufferSize)
Create a working space in a BufferedTransformation.
Interface for public-key signature verifiers.
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
BufferedTransformation * AttachedTransformation()
Retrieve attached transformation.
PK_EncryptorFilter(RandomNumberGenerator &rng, const PK_Encryptor &encryptor, BufferedTransformation *attachment=NULL)
Construct a PK_EncryptorFilter.
ArrayXorSink(byte *buf, size_t size)
Construct an ArrayXorSink.
Crypto++ library namespace.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
bool GetValue(const char *name, T &value) const
Get a named value.
Flags
Flags controlling filter behavior.
bool ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output on a channel.
T1 SaturatingSubtract(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 0.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
void Redirect(BufferedTransformation &target)
Redirect input to another BufferedTransformation.
byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
Request space which can be written into by the caller.
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
@ ONE_AND_ZEROS_PADDING
1 and 0's padding added to a block
Filter wrapper for decrypting with AuthenticatedSymmetricCipher.
Transform a Store into a Source.
container of wait objects
Filter wrapper for PK_Verifier.
bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true)
Marks the end of a series of messages on a channel.
Filter wrapper for encrypting with AuthenticatedSymmetricCipher.
StringSource(const char *string, bool pumpAll, BufferedTransformation *attachment=NULL)
Construct a StringSource.
std::string AlgorithmName() const
Provides the name of this algorithm.
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.
size_t PumpMessages2(unsigned int &messageCount, bool blocking=true)
Pump messages to attached transformation.
Interface for retrieving values given their names.
Abstract base classes that provide a uniform interface to this library.
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
Used to pass byte array input as part of a NameValuePairs object.
Redirect input to another BufferedTransformation without owning it.
Classes for working with NameValuePairs.
lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
SimpleProxyFilter(BufferedTransformation *filter, BufferedTransformation *attachment)
Construct a SimpleProxyFilter.
Measure how many bytes and messages pass through the filter.
void GetWaitObjects(WaitObjectContainer &container, CallStack const &callStack)
Retrieves waitable objects.
StringStore(const char *string=NULL)
Construct a StringStore.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
RNG-based implementation of Source interface.
Interface for one direction (encryption or decryption) of a stream cipher or block cipher mode with a...