// cbc.cpp - written and placed in the public domain by Wei Dai

#include "pch.h"
#include "cbc.h"

NAMESPACE_BEGIN(CryptoPP)

CBCPaddedEncryptor::CBCPaddedEncryptor(const BlockTransformation &cipher, const byte *IV, BufferedTransformation *outQueue)
	: Filter(outQueue), CipherMode(cipher, IV), counter(0)
{
}

void CBCPaddedEncryptor::ProcessBuf()
{
	cipher.ProcessBlock(reg);
	outQueue->Put(reg, S);
	counter = 0;
}

void CBCPaddedEncryptor::Put(byte inByte)
{
	reg[counter++] ^= inByte;
	if (counter == S)
		ProcessBuf();
}

void CBCPaddedEncryptor::Put(const byte *inString, unsigned int length)
{
	while (counter && length)
	{
		CBCPaddedEncryptor::Put(*inString++);
		length--;
	}

	while (length >= S)
	{
		xorbuf(reg, inString, S);
		ProcessBuf();
		inString += S;
		length -= S;
	}

	while (length--)
		CBCPaddedEncryptor::Put(*inString++);
}

void CBCPaddedEncryptor::InputFinished()
{
	// pad last block
	byte pad = S-counter;
	do
		Put(pad);
	while (counter != 0);
}

CBCPaddedDecryptor::CBCPaddedDecryptor(const BlockTransformation &cipher, const byte *IV, BufferedTransformation *outQueue)
	: Filter(outQueue), CipherMode(cipher, IV), counter(0), temp(S)
{
}

void CBCPaddedDecryptor::ProcessBuf()
{
	cipher.ProcessBlock(buffer, temp);
	xorbuf(temp, reg, S);
	outQueue->Put(temp, S);
	reg.swap(buffer);
	counter = 0;
}

void CBCPaddedDecryptor::Put(byte inByte)
{
	if (counter == S)
		ProcessBuf();
	buffer[counter++] = inByte;
}

void CBCPaddedDecryptor::Put(const byte *inString, unsigned int length)
{
	while (counter!=S && length)
	{
		CBCPaddedDecryptor::Put(*inString++);
		length--;
	}

	while (length >= S)
	{
		ProcessBuf();
		memcpy(buffer, inString, S);
		counter = S;
		inString += S;
		length -= S;
	}

	while (length--)
		CBCPaddedDecryptor::Put(*inString++);
}

void CBCPaddedDecryptor::InputFinished()
{
	// unpad last block
	cipher.ProcessBlock(buffer);
	xorbuf(buffer, reg, S);
	if (buffer[S-1] > S)
		buffer[S-1] = 0;     // something's wrong with the padding
	outQueue->Put(buffer, S-buffer[S-1]);
}

// ********************************************************

CBC_CTS_Encryptor::CBC_CTS_Encryptor(const BlockTransformation &cipher, const byte *IV, BufferedTransformation *outQueue)
	: Filter(outQueue), CipherMode(cipher, IV), counter(0), bFirstBlock(true)
{
}

void CBC_CTS_Encryptor::ProcessBuf()
{
	if (bFirstBlock)
		bFirstBlock = false;
	else
		outQueue->Put(reg, S);

	cipher.ProcessBlock(buffer, reg);
	counter = 0;
}

void CBC_CTS_Encryptor::Put(byte inByte)
{
	buffer[counter] = reg[counter] ^ inByte;
	if (++counter == S)
		ProcessBuf();
}

void CBC_CTS_Encryptor::Put(const byte *inString, unsigned int length)
{
	while (counter && length)
	{
		CBC_CTS_Encryptor::Put(*inString++);
		length--;
	}

	while (length >= S)
	{
		xorbuf(buffer, inString, reg, S);
		ProcessBuf();
		inString += S;
		length -= S;
	}

	while (length--)
		CBC_CTS_Encryptor::Put(*inString++);
}

void CBC_CTS_Encryptor::InputFinished()
{
	// padded with '\0's if plaintext is too short
	while (bFirstBlock)
		Put('\0');

	if (counter)
	{
		// output last full ciphertext block first
		memcpy(buffer+counter, reg+counter, S-counter);
		cipher.ProcessBlock(buffer);
		outQueue->Put(buffer, S);
		// steal ciphertext from next to last block
		outQueue->Put(reg, counter);
	}
	else
		outQueue->Put(reg, S);	// no need to do ciphertext stealing
}

CBC_CTS_Decryptor::CBC_CTS_Decryptor(const BlockTransformation &cipher, const byte *IV, BufferedTransformation *outQueue)
	: Filter(outQueue), CipherMode(cipher, IV), counter(0), bFirstBlock(true), temp(S), buffer2(S)
{
}

void CBC_CTS_Decryptor::ProcessBuf()
{
	if (bFirstBlock)
		bFirstBlock = false;
	else
	{
		cipher.ProcessBlock(buffer, temp);
		xorbuf(temp, reg, S);
		outQueue->Put(temp, S);
		reg.swap(buffer);
	}

	buffer.swap(buffer2);
	counter = 0;
}

void CBC_CTS_Decryptor::Put(byte inByte)
{
	buffer2[counter++] = inByte;
	if (counter == S)
		ProcessBuf();
}

void CBC_CTS_Decryptor::Put(const byte *inString, unsigned int length)
{
	while (counter && length)
	{
		CBC_CTS_Decryptor::Put(*inString++);
		length--;
	}

	while (length >= S)
	{
		memcpy(buffer2, inString, S);
		ProcessBuf();
		inString += S;
		length -= S;
	}

	while (length--)
		CBC_CTS_Decryptor::Put(*inString++);
}

void CBC_CTS_Decryptor::InputFinished()
{
	if (counter)
	{
		// decrypt last partial plaintext block
		cipher.ProcessBlock(buffer, temp);
		xorbuf(temp, buffer2, counter);

		// decrypt next to last plaintext block
		memcpy(buffer2+counter, temp+counter, S-counter);
		cipher.ProcessBlock(buffer2);
		xorbuf(buffer2, reg, S);

		outQueue->Put(buffer2, S);
		outQueue->Put(temp, counter);
	}
	else
		ProcessBuf();	// no need to do ciphertext stealing
}

NAMESPACE_END