cbc.cpp

各种加密算法的集合

#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