xorbuf(m_buf+m_total, begin, STDMIN(length, SaturatingSubtract(m_size, m_total)));	m_total += length;	return 0;}// *************************************************************unsigned int StreamTransformationFilter::LastBlockSize(StreamTransformation &c, BlockPaddingScheme padding){	if (c.MinLastBlockSize() > 0)		return c.MinLastBlockSize();	else if (c.MandatoryBlockSize() > 1 && !c.IsForwardTransformation() && padding != NO_PADDING && padding != ZEROS_PADDING)		return c.MandatoryBlockSize();	else		return 0;}StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment, BlockPaddingScheme padding)   : FilterWithBufferedInput(0, c.MandatoryBlockSize(), LastBlockSize(c, padding), attachment)	, m_cipher(c){	assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());	bool isBlockCipher = (c.MandatoryBlockSize() > 1 && c.MinLastBlockSize() == 0);	if (padding == DEFAULT_PADDING)	{		if (isBlockCipher)			m_padding = PKCS_PADDING;		else			m_padding = NO_PADDING;	}	else		m_padding = padding;	if (!isBlockCipher && (m_padding == PKCS_PADDING || m_padding == ONE_AND_ZEROS_PADDING))		throw InvalidArgument("StreamTransformationFilter: PKCS_PADDING and ONE_AND_ZEROS_PADDING cannot be used with " + c.AlgorithmName());}void StreamTransformationFilter::FirstPut(const byte *inString){	m_optimalBufferSize = m_cipher.OptimalBlockSize();	m_optimalBufferSize = STDMAX(m_optimalBufferSize, RoundDownToMultipleOf(4096U, m_optimalBufferSize));}void StreamTransformationFilter::NextPutMultiple(const byte *inString, unsigned int length){	if (!length)		return;	unsigned int s = m_cipher.MandatoryBlockSize();	do	{		unsigned int len = m_optimalBufferSize;		byte *space = HelpCreatePutSpace(*AttachedTransformation(), NULL_CHANNEL, s, length, len);		if (len < length)		{			if (len == m_optimalBufferSize)				len -= m_cipher.GetOptimalBlockSizeUsed();			len = RoundDownToMultipleOf(len, s);		}		else			len = length;		m_cipher.ProcessString(space, inString, len);		AttachedTransformation()->PutModifiable(space, len);		inString += len;		length -= len;	}	while (length > 0);}void StreamTransformationFilter::NextPutModifiable(byte *inString, unsigned int length){	m_cipher.ProcessString(inString, length);	AttachedTransformation()->PutModifiable(inString, length);}void StreamTransformationFilter::LastPut(const byte *inString, unsigned int length){	byte *space = NULL;		switch (m_padding)	{	case NO_PADDING:	case ZEROS_PADDING:		if (length > 0)		{			unsigned int minLastBlockSize = m_cipher.MinLastBlockSize();			bool isForwardTransformation = m_cipher.IsForwardTransformation();			if (isForwardTransformation && m_padding == ZEROS_PADDING && (minLastBlockSize == 0 || length < minLastBlockSize))			{				// do padding				unsigned int blockSize = STDMAX(minLastBlockSize, m_cipher.MandatoryBlockSize());				space = HelpCreatePutSpace(*AttachedTransformation(), NULL_CHANNEL, blockSize);				memcpy(space, inString, length);				memset(space + length, 0, blockSize - length);				m_cipher.ProcessLastBlock(space, space, blockSize);				AttachedTransformation()->Put(space, blockSize);			}			else			{				if (minLastBlockSize == 0)				{					if (isForwardTransformation)						throw InvalidDataFormat("StreamTransformationFilter: plaintext length is not a multiple of block size and NO_PADDING is specified");					else						throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");				}				space = HelpCreatePutSpace(*AttachedTransformation(), NULL_CHANNEL, length, m_optimalBufferSize);				m_cipher.ProcessLastBlock(space, inString, length);				AttachedTransformation()->Put(space, length);			}		}		break;	case PKCS_PADDING:	case ONE_AND_ZEROS_PADDING:		unsigned int s;		s = m_cipher.MandatoryBlockSize();		assert(s > 1);		space = HelpCreatePutSpace(*AttachedTransformation(), NULL_CHANNEL, s, m_optimalBufferSize);		if (m_cipher.IsForwardTransformation())		{			assert(length < s);			memcpy(space, inString, length);			if (m_padding == PKCS_PADDING)			{				assert(s < 256);				byte pad = s-length;				memset(space+length, pad, s-length);			}			else			{				space[length] = 1;				memset(space+length+1, 0, s-length-1);			}			m_cipher.ProcessData(space, space, s);			AttachedTransformation()->Put(space, s);		}		else		{			if (length != s)				throw InvalidCiphertext("StreamTransformationFilter: ciphertext length is not a multiple of block size");			m_cipher.ProcessData(space, inString, s);			if (m_padding == PKCS_PADDING)			{				byte pad = space[s-1];				if (pad < 1 || pad > s || std::find_if(space+s-pad, space+s, std::bind2nd(std::not_equal_to<byte>(), pad)) != space+s)					throw InvalidCiphertext("StreamTransformationFilter: invalid PKCS #7 block padding found");				length = s-pad;			}			else			{				while (length > 1 && space[length-1] == '\0')					--length;				if (space[--length] != '\1')					throw InvalidCiphertext("StreamTransformationFilter: invalid ones-and-zeros padding found");			}			AttachedTransformation()->Put(space, length);		}		break;	default:		assert(false);	}}// *************************************************************void HashFilter::IsolatedInitialize(const NameValuePairs &parameters){	m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);	m_hashModule.Restart();}unsigned int HashFilter::Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking){	FILTER_BEGIN;	m_hashModule.Update(inString, length);	if (m_putMessage)		FILTER_OUTPUT(1, inString, length, 0);	if (messageEnd)	{		{			unsigned int size, digestSize = m_hashModule.DigestSize();			m_space = HelpCreatePutSpace(*AttachedTransformation(), NULL_CHANNEL, digestSize, digestSize, size = digestSize);			m_hashModule.Final(m_space);		}		FILTER_OUTPUT(2, m_space, m_hashModule.DigestSize(), messageEnd);	}	FILTER_END_NO_MESSAGE_END;}// *************************************************************HashVerificationFilter::HashVerificationFilter(HashTransformation &hm, BufferedTransformation *attachment, word32 flags)	: FilterWithBufferedInput(attachment)	, m_hashModule(hm){	IsolatedInitialize(MakeParameters(Name::HashVerificationFilterFlags(), flags));}void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned int &blockSize, unsigned int &lastSize){	m_flags = parameters.GetValueWithDefault(Name::HashVerificationFilterFlags(), (word32)DEFAULT_FLAGS);	m_hashModule.Restart();	unsigned int size = m_hashModule.DigestSize();	m_verified = false;	firstSize = m_flags & HASH_AT_BEGIN ? size : 0;	blockSize = 1;	lastSize = m_flags & HASH_AT_BEGIN ? 0 : size;}void HashVerificationFilter::FirstPut(const byte *inString){	if (m_flags & HASH_AT_BEGIN)	{		m_expectedHash.New(m_hashModule.DigestSize());		memcpy(m_expectedHash, inString, m_expectedHash.size());		if (m_flags & PUT_HASH)			AttachedTransformation()->Put(inString, m_expectedHash.size());	}}void HashVerificationFilter::NextPutMultiple(const byte *inString, unsigned int length){	m_hashModule.Update(inString, length);	if (m_flags & PUT_MESSAGE)		AttachedTransformation()->Put(inString, length);}void HashVerificationFilter::LastPut(const byte *inString, unsigned int length){	if (m_flags & HASH_AT_BEGIN)	{		assert(length == 0);		m_verified = m_hashModule.Verify(m_expectedHash);	}	else	{		m_verified = (length==m_hashModule.DigestSize() && m_hashModule.Verify(inString));		if (m_flags & PUT_HASH)			AttachedTransformation()->Put(inString, length);	}	if (m_flags & PUT_RESULT)		AttachedTransformation()->Put(m_verified);	if ((m_flags & THROW_EXCEPTION) && !m_verified)		throw HashVerificationFailed();}// *************************************************************void SignerFilter::IsolatedInitialize(const NameValuePairs &parameters){	m_putMessage = parameters.GetValueWithDefault(Name::PutMessage(), false);	m_messageAccumulator.reset(m_signer.NewSignatureAccumulator());}unsigned int SignerFilter::Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking){	FILTER_BEGIN;	m_messageAccumulator->Update(inString, length);	if (m_putMessage)		FILTER_OUTPUT(1, inString, length, 0);	if (messageEnd)	{		m_buf.New(m_signer.SignatureLength());		m_signer.Sign(m_rng, m_messageAccumulator.release(), m_buf);		FILTER_OUTPUT(2, m_buf, m_buf.size(), messageEnd);		m_messageAccumulator.reset(m_signer.NewSignatureAccumulator());	}	FILTER_END_NO_MESSAGE_END;}SignatureVerificationFilter::SignatureVerificationFilter(const PK_Verifier &verifier, BufferedTransformation *attachment, word32 flags)	: FilterWithBufferedInput(attachment)	, m_verifier(verifier){	IsolatedInitialize(MakeParameters(Name::SignatureVerificationFilterFlags(), flags));}void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValuePairs &parameters, unsigned int &firstSize, unsigned int &blockSize, unsigned int &lastSize){	m_flags = parameters.GetValueWithDefault(Name::SignatureVerificationFilterFlags(), (word32)DEFAULT_FLAGS);	m_messageAccumulator.reset(m_verifier.NewVerificationAccumulator());	unsigned int size =	m_verifier.SignatureLength();	assert(size != 0);	// TODO: handle recoverable signature scheme	m_verified = false;	firstSize = m_flags & SIGNATURE_AT_BEGIN ? size : 0;	blockSize = 1;	lastSize = m_flags & SIGNATURE_AT_BEGIN ? 0 : size;}void SignatureVerificationFilter::FirstPut(const byte *inString){	if (m_flags & SIGNATURE_AT_BEGIN)	{		if (m_verifier.SignatureUpfront())			m_verifier.InputSignature(*m_messageAccumulator, inString, m_verifier.SignatureLength());		else		{			m_signature.New(m_verifier.SignatureLength());			memcpy(m_signature, inString, m_signature.size());		}		if (m_flags & PUT_SIGNATURE)			AttachedTransformation()->Put(inString, m_signature.size());	}	else	{		assert(!m_verifier.SignatureUpfront());	}}void SignatureVerificationFilter::NextPutMultiple(const byte *inString, unsigned int length){	m_messageAccumulator->Update(inString, length);	if (m_flags & PUT_MESSAGE)		AttachedTransformation()->Put(inString, length);}void SignatureVerificationFilter::LastPut(const byte *inString, unsigned int length){	if (m_flags & SIGNATURE_AT_BEGIN)	{		assert(length == 0);		m_verifier.InputSignature(*m_messageAccumulator, m_signature, m_signature.size());		m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);	}	else	{		m_verifier.InputSignature(*m_messageAccumulator, inString, length);		m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);		if (m_flags & PUT_SIGNATURE)			AttachedTransformation()->Put(inString, length);	}	if (m_flags & PUT_RESULT)		AttachedTransformation()->Put(m_verified);	if ((m_flags & THROW_EXCEPTION) && !m_verified)		throw SignatureVerificationFailed();}// *************************************************************unsigned int Source::PumpAll2(bool blocking){	// TODO: switch length type	unsigned long i = UINT_MAX;	RETURN_IF_NONZERO(Pump2(i, blocking));	unsigned int j = UINT_MAX;	return PumpMessages2(j, blocking);}bool Store::GetNextMessage(){	if (!m_messageEnd && !AnyRetrievable())	{		m_messageEnd=true;		return true;	}	else		return false;}unsigned int Store::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const{	if (m_messageEnd || count == 0)		return 0;	else	{		CopyTo(target, ULONG_MAX, channel);		if (GetAutoSignalPropagation())			target.ChannelMessageEnd(channel, GetAutoSignalPropagation()-1);		return 1;	}}void StringStore::StoreInitialize(const NameValuePairs &parameters){	ConstByteArrayParameter array;	if (!parameters.GetValue(Name::InputBuffer(), array))		throw InvalidArgument("StringStore: missing InputBuffer argument");	m_store = array.begin();	m_length = array.size();	m_count = 0;}unsigned int StringStore::TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel, bool blocking){	unsigned long position = 0;	unsigned int blockedBytes = CopyRangeTo2(target, position, transferBytes, channel, blocking);	m_count += position;	transferBytes = position;	return blockedBytes;}unsigned int StringStore::CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end, const std::string &channel, bool blocking) const{	unsigned int i = (unsigned int)STDMIN((unsigned long)m_count+begin, (unsigned long)m_length);	unsigned int len = (unsigned int)STDMIN((unsigned long)m_length-i, end-begin);	unsigned int blockedBytes = target.ChannelPut2(channel, m_store+i, len, 0, blocking);	if (!blockedBytes)		begin += len;	return blockedBytes;}unsigned int RandomNumberStore::TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel, bool blocking){	if (!blocking)		throw NotImplemented("RandomNumberStore: nonblocking transfer is not implemented by this object");	unsigned long transferMax = transferBytes;	for (transferBytes = 0; transferBytes<transferMax && m_count < m_length; ++transferBytes, ++m_count)		target.ChannelPut(channel, m_rng.GenerateByte());	return 0;}unsigned int NullStore::CopyRangeTo2(BufferedTransformation &target, unsigned long &begin, unsigned long end, const std::string &channel, bool blocking) const{	static const byte nullBytes[128] = {0};	while (begin < end)	{		unsigned int len = STDMIN(end-begin, 128UL);		unsigned int blockedBytes = target.ChannelPut2(channel, nullBytes, len, 0, blocking);		if (blockedBytes)			return blockedBytes;		begin += len;	}	return 0;}unsigned int NullStore::TransferTo2(BufferedTransformation &target, unsigned long &transferBytes, const std::string &channel, bool blocking){	unsigned long begin = 0;	unsigned int blockedBytes = NullStore::CopyRangeTo2(target, begin, transferBytes, channel, blocking);	transferBytes = begin;	m_size -= begin;	return blockedBytes;}NAMESPACE_END