idea.cpp

IDEA加密算法

#include "stdafx.h"
#include "IDEA.h"

CIDEA::CIDEA()
{
	wKeySeed[ 0 ] = 0x1dd2;	wKeySeed[ 1 ] = 0x3004;	wKeySeed[ 2 ] = 0x745b;	wKeySeed[ 3 ] = 0x5981;
	wKeySeed[ 4 ] = 0x6abd;	wKeySeed[ 5 ] = 0x2f74;	wKeySeed[ 6 ] = 0x0d0e;	wKeySeed[ 7 ] = 0x1498;
}

CIDEA::~CIDEA()
{

}

//WORD CIDEA:: wKeySeed [ ] = { 0x0102 , 0x0304 , 0x0506 , 0x0708 , 0x090a , 0x0b0c , 0x0d0e , 0x0f10 } ;

/* 两数相加,模65536 */
WORD CIDEA::Addition(WORD wNum1, WORD wNum2)
{
	return ( wNum1 + wNum2 ) ;
}

/* 两数相乘,模65537 */ 
WORD CIDEA::Multiplication(WORD wNum1, WORD wNum2)
{
	if ( ! wNum1 && ! wNum2 ) 
		return 0 ;
	else if ( ! wNum1 ) 
		return ( WORD ) ( (  wNum2 * CARDINALITY ) % ( CARDINALITY + 1 ) ) ;          
	else if ( ! wNum2 ) 
		return ( WORD ) ( (  wNum1 * CARDINALITY ) % ( CARDINALITY + 1 ) ) ;          
	else 
		return ( WORD ) ( ( ( DWORD ) wNum1 * wNum2 ) % ( CARDINALITY + 1 ) ) ;          
}

/* 利用辗转相除法,求一个数模65537的逆 */
WORD CIDEA::Inverse(WORD wNum)
{
	DWORD dwQuotient ;								// 商
	DWORD dwResidual ;								// 余
	DWORD dwDividend = CARDINALITY + 1 ;			// 被除数
	DWORD dwDivisor = ( DWORD ) wNum ;				// 除数
	DWORD dwResult ;								// 结果
	DWORD dwValue1 = 1 , dwValue2 ;					// 中间值	
	
	if ( wNum <=1 ) 
		return wNum ;
	dwResult = dwValue2 = dwDividend / dwDivisor ;
	dwResidual = dwDividend % dwDivisor ;
	dwDividend = dwDivisor ;
	dwDivisor = dwResidual ;
	dwQuotient = dwDividend / dwDivisor ;
	dwResidual = dwDividend % dwDivisor ;
	while ( dwResidual )
	{
		dwResult = dwQuotient * dwValue2 + dwValue1 ;
		dwValue1 = dwValue2 ;
		dwValue2 = dwResult ;
		dwDividend = dwDivisor ;
		dwDivisor = dwResidual ;
		dwQuotient = dwDividend / dwDivisor ;
		dwResidual = dwDividend % dwDivisor ;
	}
	if ( ( ( dwResult * wNum ) % ( CARDINALITY + 1 ) ) == CARDINALITY )
	{
		int nModular = - ( int ) dwResult ;
		while ( ( nModular += ( CARDINALITY + 1 ) ) <= 0 ) ;
		dwResult = nModular ;
	}
	return ( WORD ) dwResult ;
}

/* 循环左移25位,生成一组密钥子块 */
void CIDEA::GenSubKey( )
{
/*	DWORD dwSave , dwTemp ;
	DWORD * pdwShift =( DWORD * ) wKeySeed ;
	short sPos ;
	
	dwSave = pdwShift [ 0 ] >> ( 8 * sizeof ( DWORD ) - SHIFTLEFT ) ;
	for ( sPos = 1 ;sPos < BLOCKSIZE ; sPos ++ )
	{
		dwTemp = dwSave ;
		dwSave = pdwShift [ sPos ] >> ( 8 * sizeof ( DWORD ) - SHIFTLEFT ) ;
		pdwShift [ sPos ] = ( pdwShift [ sPos ] << SHIFTLEFT ) | dwTemp ;
	}
	pdwShift [ 0 ] = ( pdwShift [ 0 ] << SHIFTLEFT ) | dwSave ;
*/
	WORD wSave , wTemp ;
	WORD * pwShift = wKeySeed ;
	short sPos ;

	wSave = pwShift [ 0 ] ;
	wTemp = pwShift [ 1 ] ;
	for ( sPos = 1 ; sPos < ROUND - 1; sPos ++ )
	{
		pwShift [ sPos - 1 ] = ( pwShift [ sPos ]  << 9 ) | ( pwShift [ sPos + 1 ] >> 7 ) ;
	}
    pwShift [ sPos - 1 ] = ( pwShift [ sPos ] << 9 ) | ( wSave >> 7 ) ;
	pwShift [ sPos ] = ( wSave << 9 ) | ( wTemp >> 7 ) ;

}

/* 生成全部密钥*/
void CIDEA::GenEncryptKey( ) 
{
	short sTimes , sPos , sLength = ROUND ;
	
	for ( sPos = 0 ; sPos < sLength ; sPos ++ )
	{
		pwEncryptKey [ sPos ] =	wKeySeed [ /*ROUND - 1 -*/ sPos ] ;
	}
	for ( sTimes = 1 ; sTimes <= SUBKEYSIZE ; sTimes ++ )
	{
		GenSubKey ( ) ;
		if ( SUBKEYSIZE == sTimes )
			sLength = ROUND / 2 ;
		else
			sLength = ROUND ;
		for ( sPos = 0 ; sPos < sLength ; sPos ++ )
		{
			pwEncryptKey [ sTimes * ROUND + sPos ] = wKeySeed [ /*ROUND - 1 -*/ sPos ] ;
		}
	}
}

/* 单轮迭代 */
void CIDEA::Iteration( short sTurn , bool bCrypt )
{
	short sPos ;
	WORD wSubKey [ SUBKEYSIZE ];
	WORD wMidValue [ 10 ] ;
	WORD * pwKey , * wInputText , * wOutputText;
	
	if ( bCrypt )
	{
		wInputText = wCleartext ;
		pwKey = pwEncryptKey ;
		wOutputText = wCiphertext ;
	}
	else
	{
		wInputText = wCiphertext ;
		pwKey = pwDecryptKey ;
		wOutputText = wCleartext ;
	}
	if ( sTurn < ROUND )
	{
		/* 单轮执行过程 */
		for ( sPos = 0 ; sPos < SUBKEYSIZE ; sPos ++ ) 
		{
			wSubKey [ sPos ] = pwKey [ sTurn * SUBKEYSIZE + sPos ] ;
		}
		wMidValue [ 0 ] = Multiplication ( wInputText [ 0 ] ,wSubKey [ 0 ] ) ;
		wMidValue [ 1 ] = Addition ( wInputText [ 1 ] , wSubKey [ 1 ] ) ;
		wMidValue [ 2 ] = Addition ( wInputText [ 2 ] , wSubKey [ 2 ] ) ;
		wMidValue [ 3 ] = Multiplication ( wInputText [ 3 ] ,wSubKey [ 3 ] ) ;
		wMidValue [ 4 ] = wMidValue [ 0 ] ^ wMidValue [ 2 ] ;
		wMidValue [ 5 ] = wMidValue [ 1 ] ^ wMidValue [ 3 ] ;
		wMidValue [ 6 ] = Multiplication ( wMidValue [ 4 ] , wSubKey [ 4 ] ) ;
		wMidValue [ 7 ] = Addition ( wMidValue [ 5 ] , wMidValue [ 6 ] ) ;
		wMidValue [ 8 ] = Multiplication ( wMidValue [ 7 ] , wSubKey [ 5 ] ) ;
		wMidValue [ 9 ] = Addition ( wMidValue [ 6 ] , wMidValue [ 8 ] ) ;
		
		/* 单轮输出 */
		wInputText [ 0 ] = wMidValue [ 0 ] ^ wMidValue [ 8 ] ;
		wInputText [ 1 ] = wMidValue [ 2 ] ^ wMidValue [ 8 ] ;
		wInputText [ 2 ] = wMidValue [ 1 ] ^ wMidValue [ 9 ] ;
		wInputText [ 3 ] = wMidValue [ 3 ] ^ wMidValue [ 9 ] ;
	}
	else
	{
		/* 最后输出子块 */
		for ( sPos = 0 ; sPos < ROUND / 2 ; sPos ++ ) 
		{
			wSubKey [ sPos ] = pwKey [ sTurn * SUBKEYSIZE + sPos ] ;
		}
		wOutputText [ 0 ] = Multiplication ( wInputText [ 0 ] , wSubKey [ 0 ] ) ;
		wOutputText [ 1 ] = Addition ( wInputText [ 2 ] , wSubKey [ 1 ] ) ;
		wOutputText [ 2 ] = Addition ( wInputText [ 1 ] , wSubKey [ 2 ] ) ;
		wOutputText [ 3 ] = Multiplication ( wInputText [ 3 ] , wSubKey [ 3 ] ) ;
	}
}

/* 对一组明文块进行加密 */
void CIDEA::Ciphering( )
{
	short sTurn ;
	
	for ( sTurn = 0 ; sTurn <= ROUND ; sTurn ++ )
	{
		Iteration  ( sTurn , true ) ;
	}
}

/* 生成解密密钥 */
void CIDEA::GenDecryptKey( )
{
	short sTurn ;

	GenEncryptKey ( ) ;				// 生成加密密钥

	/* 由加密密钥生成解密密钥 */
	for ( sTurn = 0 ; sTurn < ROUND ; sTurn ++ )
	{
		/* 生成8轮迭代解密密钥 */
		pwDecryptKey [ sTurn * SUBKEYSIZE ] = Inverse ( pwEncryptKey [ ( ROUND - sTurn ) * SUBKEYSIZE ] ) ;
		if( sTurn )
		{
			pwDecryptKey [ sTurn * SUBKEYSIZE + 1 ] = - pwEncryptKey [ ( ROUND - sTurn ) * SUBKEYSIZE + 2 ] ;
			pwDecryptKey [ sTurn * SUBKEYSIZE + 2 ] = - pwEncryptKey [ ( ROUND - sTurn ) * SUBKEYSIZE + 1 ] ;
		}
		else
		{
			pwDecryptKey [ sTurn * SUBKEYSIZE + 1 ] = - pwEncryptKey [ ( ROUND - sTurn ) * SUBKEYSIZE + 1 ] ;
			pwDecryptKey [ sTurn * SUBKEYSIZE + 2 ] = - pwEncryptKey [ ( ROUND - sTurn ) * SUBKEYSIZE + 2 ] ;
		}

		pwDecryptKey [ sTurn * SUBKEYSIZE + 3 ] = Inverse ( pwEncryptKey [ ( ROUND - sTurn ) * SUBKEYSIZE + 3 ] ) ;
		pwDecryptKey [ sTurn * SUBKEYSIZE + 4 ] = pwEncryptKey [ ( ROUND - 1 - sTurn ) * SUBKEYSIZE + 4 ] ;
		pwDecryptKey [ sTurn * SUBKEYSIZE + 5 ] = pwEncryptKey [ ( ROUND - 1 - sTurn ) * SUBKEYSIZE + 5 ] ;

	}

	/* 生成输出密钥 */
	pwDecryptKey [ sTurn * SUBKEYSIZE     ] = Inverse ( pwEncryptKey [ 0 ] );
	pwDecryptKey [ sTurn * SUBKEYSIZE + 1 ] = - pwEncryptKey [ 1 ] ;
	pwDecryptKey [ sTurn * SUBKEYSIZE + 2 ] = - pwEncryptKey [ 2 ] ;
	pwDecryptKey [ sTurn * SUBKEYSIZE + 3 ] = Inverse ( pwEncryptKey [ 3 ] );
}

/* 对一组密文块进行解密 */
void CIDEA::Deciphering( )
{
	short sTurn ;

	for ( sTurn = 0 ; sTurn <= ROUND ; sTurn ++ )
	{
		Iteration  ( sTurn , false ) ;			// 单轮迭代
	}

}

void CIDEA::SetNewKey( WORD * pwKeySeed, int nCount )
{
	nCount = min( nCount, ROUND );
	for( int i = 0; i < nCount; i ++ )
	{
		wKeySeed[ i ] = pwKeySeed[ i ];
	}
	GenDecryptKey( );
}