encrypt.cpp

IDEA加密算法

#include "StdAfx.h"
#include <memory>
#include "Encrypt.h"
 
CEncrypt::CEncrypt(void)
{
	GenDecryptKey ( ) ;
}

CEncrypt::~CEncrypt(void)
{
}

PVOID CEncrypt::AllocMemory ( DWORD dwSize )
{
	return ( PVOID ) new BYTE [ dwSize ] ;
}

HRESULT CEncrypt::Dencrypt ( PVOID pEncryptBuf , DWORD dwEncryptBufSize , PVOID * ppRowBuf , DWORD * pdwRowBufSize) 
{
	DWORD dwRestSize = dwEncryptBufSize ;
	WORD * pwReadGroup = ( WORD * ) pEncryptBuf , * pwWriteGroup ;
	
	ASSERT ( pEncryptBuf != NULL ) ;
	ASSERT ( dwEncryptBufSize > 0 ) ;
	if ( dwEncryptBufSize % 8 )
		return E_FAIL ;
	
	/*设置解密内存块的大小*/
	* pdwRowBufSize = dwEncryptBufSize ;
	
	/*分配解密内存块*/
	if ( pEncryptBuf != * ppRowBuf )
	{
		* ppRowBuf = AllocMemory ( * pdwRowBufSize ) ;
		if ( NULL == * ppRowBuf )
			return E_OUTOFMEMORY ;
	}
	pwWriteGroup = ( WORD * ) ( * ppRowBuf ) ; 
	
	/*对密文内存块解密*/
	while ( dwRestSize )
	{
		/*读入密文子块*/
		ReadBlock ( pwReadGroup , false ) ;
		pwReadGroup += BLOCKSIZE ;
		dwRestSize = dwEncryptBufSize - ( DWORD ) ( ( BYTE * ) pwReadGroup - ( BYTE * ) pEncryptBuf ) ;
		/*解密*/
		Deciphering ( ) ;
		/*写出解密后的子块*/
		WriteBlock ( pwWriteGroup , false ) ; 
		pwWriteGroup += BLOCKSIZE ;
	}
	return S_OK ;

}

HRESULT CEncrypt::Encrypt ( PVOID pRowBuf , DWORD dwRowBufSize , PVOID * ppEncryptBuf , DWORD * pdwEncryptBufSize) 
{
	DWORD dwRestSize = dwRowBufSize ;
	WORD * pwReadGroup = ( WORD * ) pRowBuf , * pwWriteGroup ; 
	
	ASSERT ( pRowBuf != NULL  ) ;
	ASSERT ( dwRowBufSize > 0 ) ;
	
	/*设置解密内存块的大小*/
	if ( dwRowBufSize % 8 )
		* pdwEncryptBufSize = ( dwRowBufSize / 8 + 1) * 8 ;
	else
		* pdwEncryptBufSize = dwRowBufSize ;
	
	/*分配加密内存块*/
	if ( * ppEncryptBuf == pRowBuf )
	{
		if ( dwRowBufSize % 8 )
			return E_OUTOFMEMORY ;
	}
	else 
	{
		* ppEncryptBuf = AllocMemory ( * pdwEncryptBufSize ) ;
		if ( NULL == * ppEncryptBuf )
			return E_OUTOFMEMORY ;
	}
	pwWriteGroup = ( WORD * ) ( * ppEncryptBuf ) ;

	/*对明文内存块加密*/
	while ( dwRestSize >= BLOCKSIZE * sizeof ( WORD ) )
	{
		/*读入明文子块*/
		ReadBlock ( pwReadGroup , true ) ;
		pwReadGroup += BLOCKSIZE ;
		dwRestSize = dwRowBufSize - ( DWORD ) ( ( BYTE * ) pwReadGroup - ( BYTE * ) pRowBuf ) ;
		/*加密*/
		Ciphering ( ) ;
		/*写出加密后的子块*/
		WriteBlock ( pwWriteGroup , true ) ; 
		pwWriteGroup += BLOCKSIZE ;
	}

	/*若明文子块长度不足64个字节，补0后加密*/
	if ( dwRestSize )
	{
		ReadBlock ( pwReadGroup , true , dwRestSize ) ;
		Ciphering ( ) ;
		WriteBlock ( pwWriteGroup , true ) ;
	}
	return S_OK ;
}

void CEncrypt::FreeMemory ( PVOID * ppBuf) 
{
	delete [ ] ( * ppBuf ) ;
	* ppBuf = NULL ;
}

void CEncrypt::ReadBlock ( WORD * pwBlockBuf , bool bEncrypt , DWORD wBlockSize )
{
	if ( wBlockSize > BLOCKSIZE * sizeof ( WORD ) )
		return ;
	if ( bEncrypt)
	{
		memset ( wCleartext , 0 , sizeof ( WORD) * BLOCKSIZE ) ;
		memcpy ( wCleartext , pwBlockBuf , wBlockSize ) ;
	}
	else
	{
		memset ( wCiphertext , 0 ,sizeof ( WORD ) * BLOCKSIZE ) ;
		memcpy ( wCiphertext , pwBlockBuf , wBlockSize ) ;
	}

}

void CEncrypt::WriteBlock ( WORD * pwBlockBuf , bool bEncrypt )
{
	if ( bEncrypt )
		memcpy ( pwBlockBuf , wCiphertext , BLOCKSIZE * sizeof ( WORD ) ) ;
	else
		memcpy ( pwBlockBuf , wCleartext , BLOCKSIZE * sizeof ( WORD ) ) ;
}