rijndael.cpp

这个文件中如何在EVC 中c++对注册表的操作。

   Notes          We always need a key before proceed further.
*/
//--------------------------------------------------------------------------
BOOL Rijndael::MakeKey(LPCTSTR _szKey)
{
	BOOL bResult = FALSE;
	try
	{
		if( strlen(_szKey) > 0 )
		{
			int i;
			if(m_Ke != NULL)
			{
				for(i=0; i<=m_iROUNDS; i++)
					delete [] m_Ke[i];
				delete [] m_Ke;
			}
			if(m_Kd != NULL)
			{
				for(i=0; i<=m_iROUNDS; i++)
					delete [] m_Kd[i];
				delete [] m_Kd;
			}
			//Calculate Number of Rounds
			switch(m_KeyLength)
			{
				case 16:
					m_iROUNDS = (m_Block_Size == 16) ? 10 : (m_Block_Size == 24 ? 12 : 14);
					break;
				case 24:
					m_iROUNDS = (m_Block_Size != 32) ? 12 : 14;
					break;
				default: // 32 bytes = 256 bits
					m_iROUNDS = 14;
			}
			int BC = m_Block_Size / 4;
			int j;
			m_Ke = new int*[m_iROUNDS + 1]; //Encryption round keys
			for(i=0; i<=m_iROUNDS; i++)
			{
				m_Ke[i] = new int[BC];
				for(j=0; j<BC; j++)
					m_Ke[i][j] = 0;
			}
			m_Kd = new int*[m_iROUNDS + 1]; //Decryption round keys
			for(i=0; i<=m_iROUNDS; i++)
			{
				m_Kd[i] = new int[BC];
				for(j=0; j<BC; j++)
					m_Kd[i][j] = 0;
			}
			int ROUND_KEY_COUNT = (m_iROUNDS + 1) * BC;
			int KC = m_KeyLength/4;
			int* tk = new int[KC];
			int* pi = tk;
			TCHAR const* pc = _szKey;
			for(i=0; i<KC; i++)
			{
				*pi = (BYTE)*(pc++) << 24;
				*pi |= (BYTE)*(pc++) << 16;
				*pi |= (BYTE)*(pc++) << 8;
				*(pi++) |= (BYTE)*(pc++);
			}
			//Copy values into round key arrays
			int t = 0;
			for(j=0; (j<KC)&&(t<ROUND_KEY_COUNT); j++,t++)
			{
				m_Ke[t/BC][t%BC] = tk[j];
				m_Kd[m_iROUNDS - (t/BC)][t%BC] = tk[j];
			}
			int tt, rconpointer = 0;
			while(t < ROUND_KEY_COUNT)
			{
				//Extrapolate using phi (the round key evolution function)
				tt = tk[KC-1];
				tk[0] ^= (sm_S[(tt >> 16) & 0xFF] & 0xFF) << 24 ^
					(sm_S[(tt >>  8) & 0xFF] & 0xFF) << 16 ^
					(sm_S[ tt & 0xFF] & 0xFF) <<  8 ^
					(sm_S[(tt >> 24) & 0xFF] & 0xFF) ^
					(sm_rcon[rconpointer++]  & 0xFF) << 24;
				if(KC != 8)
					for(i=1, j=0; i<KC;)
						tk[i++] ^= tk[j++];
				else
				{
					for(i=1, j=0; i<KC/2; )
						tk[i++] ^= tk[j++];
					tt = tk[KC/2-1];
					tk[KC/2] ^= (sm_S[ tt & 0xFF] & 0xFF) ^
						(sm_S[(tt >>  8) & 0xFF] & 0xFF) <<  8 ^
						(sm_S[(tt >> 16) & 0xFF] & 0xFF) << 16 ^
						(sm_S[(tt >> 24) & 0xFF] & 0xFF) << 24;
					for(j = KC/2, i=j+1; i<KC; )
						tk[i++] ^= tk[j++];
				}
				//Copy values into round key arrays
				for(j=0; (j<KC) && (t<ROUND_KEY_COUNT); j++, t++)
				{
					m_Ke[t/BC][t%BC] = tk[j];
					m_Kd[m_iROUNDS - (t/BC)][t%BC] = tk[j];
				}
			}
			delete [] tk;
			//Inverse MixColumn where needed
			for(int r=1; r<m_iROUNDS; r++)
				for(j=0; j<BC; j++)
				{
					tt = m_Kd[r][j];
					m_Kd[r][j] = sm_U1[(tt >> 24) & 0xFF] ^
						sm_U2[(tt >> 16) & 0xFF] ^
						sm_U3[(tt >>  8) & 0xFF] ^
						sm_U4[tt & 0xFF];
				}
			m_bKeyInit = TRUE;
			bResult = TRUE;
		}
	}
	catch(...)
	{
		bResult = FALSE;
	}
	return bResult;
}



//-METHOD IMPLEMENTATION----------------------------------------------------
//
// Method Name:   EncryptBlock
//
/*!Access:        Public

   Parameters

   IN             Description

   <LPCTSTR>      The string to be encrypted.

   <LPTSTR>       The encrypted string.

   OUT            Description

   <BOOL>         TRUE if succeeded else FALSE.

   Notes
*/
//--------------------------------------------------------------------------
BOOL Rijndael::EncryptBlock(LPCTSTR _szString, LPTSTR _szResult)
{
	BOOL bResult = FALSE;
	try
	{
		if( m_bKeyInit )
		{
			//** Fill Output
			strcpy(_szResult, "\0");
			int* Ker = m_Ke[0];
			int t0 = ((unsigned char)*(_szString++) << 24);
			t0 |= ((unsigned char)*(_szString++) << 16);
			t0 |= ((unsigned char)*(_szString++) << 8);
			(t0 |= (unsigned char)*(_szString++)) ^= Ker[0];
			int t1 = ((unsigned char)*(_szString++) << 24);
			t1 |= ((unsigned char)*(_szString++) << 16);
			t1 |= ((unsigned char)*(_szString++) << 8);
			(t1 |= (unsigned char)*(_szString++)) ^= Ker[1];
			int t2 = ((unsigned char)*(_szString++) << 24);
			t2 |= ((unsigned char)*(_szString++) << 16);
			t2 |= ((unsigned char)*(_szString++) << 8);
			(t2 |= (unsigned char)*(_szString++)) ^= Ker[2];
			int t3 = ((unsigned char)*(_szString++) << 24);
			t3 |= ((unsigned char)*(_szString++) << 16);
			t3 |= ((unsigned char)*(_szString++) << 8);
			(t3 |= (unsigned char)*(_szString++)) ^= Ker[3];
			int a0, a1, a2, a3;
			//Apply Round Transforms
			for (int r = 1; r < m_iROUNDS; r++)
			{
				Ker = m_Ke[r];
				a0 = (sm_T1[(t0 >> 24) & 0xFF] ^
					sm_T2[(t1 >> 16) & 0xFF] ^
					sm_T3[(t2 >>  8) & 0xFF] ^
					sm_T4[t3 & 0xFF]) ^ Ker[0];
				a1 = (sm_T1[(t1 >> 24) & 0xFF] ^
					sm_T2[(t2 >> 16) & 0xFF] ^
					sm_T3[(t3 >>  8) & 0xFF] ^
					sm_T4[t0 & 0xFF]) ^ Ker[1];
				a2 = (sm_T1[(t2 >> 24) & 0xFF] ^
					sm_T2[(t3 >> 16) & 0xFF] ^
					sm_T3[(t0 >>  8) & 0xFF] ^
					sm_T4[t1 & 0xFF]) ^ Ker[2];
				a3 = (sm_T1[(t3 >> 24) & 0xFF] ^
					sm_T2[(t0 >> 16) & 0xFF] ^
					sm_T3[(t1 >>  8) & 0xFF] ^
					sm_T4[t2 & 0xFF]) ^ Ker[3];
				t0 = a0;
				t1 = a1;
				t2 = a2;
				t3 = a3;
			}
			//Last Round is special
			Ker = m_Ke[m_iROUNDS];
			int tt = Ker[0];
			_szResult[0] = sm_S[(t0 >> 24) & 0xFF] ^ (tt >> 24);
			_szResult[1] = sm_S[(t1 >> 16) & 0xFF] ^ (tt >> 16);
			_szResult[2] = sm_S[(t2 >>  8) & 0xFF] ^ (tt >>  8);
			_szResult[3] = sm_S[t3 & 0xFF] ^ tt;
			tt = Ker[1];
			_szResult[4] = sm_S[(t1 >> 24) & 0xFF] ^ (tt >> 24);
			_szResult[5] = sm_S[(t2 >> 16) & 0xFF] ^ (tt >> 16);
			_szResult[6] = sm_S[(t3 >>  8) & 0xFF] ^ (tt >>  8);
			_szResult[7] = sm_S[t0 & 0xFF] ^ tt;
			tt = Ker[2];
			_szResult[8] = sm_S[(t2 >> 24) & 0xFF] ^ (tt >> 24);
			_szResult[9] = sm_S[(t3 >> 16) & 0xFF] ^ (tt >> 16);
			_szResult[10] = sm_S[(t0 >>  8) & 0xFF] ^ (tt >>  8);
			_szResult[11] = sm_S[t1 & 0xFF] ^ tt;
			tt = Ker[3];
			_szResult[12] = sm_S[(t3 >> 24) & 0xFF] ^ (tt >> 24);
			_szResult[13] = sm_S[(t0 >> 16) & 0xFF] ^ (tt >> 16);
			_szResult[14] = sm_S[(t1 >>  8) & 0xFF] ^ (tt >>  8);
			_szResult[15] = sm_S[t2 & 0xFF] ^ tt;
			bResult = TRUE;
		}
	}
	catch(...)
	{
		bResult = FALSE;
	}
	return bResult;
}



//-METHOD IMPLEMENTATION----------------------------------------------------
//
// Method Name:   DecryptBlock
//
/*!Access:        Public

   Parameters

   IN             Description

   <LPCTSTR>      The String to decrypt.

   <LPTSTR>       The decrypted string.

   OUT            Description

   <BOOL>         TRUE if succeeded else FALSE.

   Notes          
*/
//--------------------------------------------------------------------------
BOOL Rijndael::DecryptBlock(LPCTSTR _szDataIn, LPTSTR _szDataOut)
{
	BOOL bResult = FALSE;
	if( m_bKeyInit )
	{
		//** Fill Output
		strcpy(_szDataOut, "\0");
		int* Kdr = m_Kd[0];
		int t0 = ((BYTE)*(_szDataIn++) << 24);
		t0 = t0 | ((BYTE)*(_szDataIn++) << 16);
		t0 |= ((BYTE)*(_szDataIn++) << 8);
		(t0 |= (BYTE)*(_szDataIn++)) ^= Kdr[0];
		int t1 = ((BYTE)*(_szDataIn++) << 24);
		t1 |= ((BYTE)*(_szDataIn++) << 16);
		t1 |= ((BYTE)*(_szDataIn++) << 8);
		(t1 |= (BYTE)*(_szDataIn++)) ^= Kdr[1];
		int t2 = ((BYTE)*(_szDataIn++) << 24);
		t2 |= ((BYTE)*(_szDataIn++) << 16);
		t2 |= ((BYTE)*(_szDataIn++) << 8);
		(t2 |= (BYTE)*(_szDataIn++)) ^= Kdr[2];
		int t3 = ((BYTE)*(_szDataIn++) << 24);
		t3 |= ((BYTE)*(_szDataIn++) << 16);
		t3 |= ((BYTE)*(_szDataIn++) << 8);
		(t3 |= (BYTE)*(_szDataIn++)) ^= Kdr[3];
		int a0, a1, a2, a3;
		for(int r = 1; r < m_iROUNDS; r++) // apply round transforms
		{
			Kdr = m_Kd[r];
			a0 = (sm_T5[(t0 >> 24) & 0xFF] ^
				sm_T6[(t3 >> 16) & 0xFF] ^
				sm_T7[(t2 >>  8) & 0xFF] ^
				sm_T8[ t1        & 0xFF] ) ^ Kdr[0];
			a1 = (sm_T5[(t1 >> 24) & 0xFF] ^
				sm_T6[(t0 >> 16) & 0xFF] ^
				sm_T7[(t3 >>  8) & 0xFF] ^
				sm_T8[ t2        & 0xFF] ) ^ Kdr[1];
			a2 = (sm_T5[(t2 >> 24) & 0xFF] ^
				sm_T6[(t1 >> 16) & 0xFF] ^
				sm_T7[(t0 >>  8) & 0xFF] ^
				sm_T8[ t3        & 0xFF] ) ^ Kdr[2];
			a3 = (sm_T5[(t3 >> 24) & 0xFF] ^
				sm_T6[(t2 >> 16) & 0xFF] ^
				sm_T7[(t1 >>  8) & 0xFF] ^
				sm_T8[ t0        & 0xFF] ) ^ Kdr[3];
			t0 = a0;
			t1 = a1;
			t2 = a2;
			t3 = a3;
		}
		//Last Round is special
		Kdr = m_Kd[m_iROUNDS];
		int tt = Kdr[0];
		_szDataOut[ 0] = sm_Si[(t0 >> 24) & 0xFF] ^ (tt >> 24);
		_szDataOut[ 1] = sm_Si[(t3 >> 16) & 0xFF] ^ (tt >> 16);
		_szDataOut[ 2] = sm_Si[(t2 >>  8) & 0xFF] ^ (tt >>  8);
		_szDataOut[ 3] = sm_Si[ t1 & 0xFF] ^ tt;
		tt = Kdr[1];
		_szDataOut[ 4] = sm_Si[(t1 >> 24) & 0xFF] ^ (tt >> 24);
		_szDataOut[ 5] = sm_Si[(t0 >> 16) & 0xFF] ^ (tt >> 16);
		_szDataOut[ 6] = sm_Si[(t3 >>  8) & 0xFF] ^ (tt >>  8);
		_szDataOut[ 7] = sm_Si[ t2 & 0xFF] ^ tt;
		tt = Kdr[2];
		_szDataOut[ 8] = sm_Si[(t2 >> 24) & 0xFF] ^ (tt >> 24);
		_szDataOut[ 9] = sm_Si[(t1 >> 16) & 0xFF] ^ (tt >> 16);
		_szDataOut[10] = sm_Si[(t0 >>  8) & 0xFF] ^ (tt >>  8);
		_szDataOut[11] = sm_Si[ t3 & 0xFF] ^ tt;
		tt = Kdr[3];
		_szDataOut[12] = sm_Si[(t3 >> 24) & 0xFF] ^ (tt >> 24);
		_szDataOut[13] = sm_Si[(t2 >> 16) & 0xFF] ^ (tt >> 16);
		_szDataOut[14] = sm_Si[(t1 >>  8) & 0xFF] ^ (tt >>  8);
		_szDataOut[15] = sm_Si[ t0 & 0xFF] ^ tt;
		bResult = TRUE;
	}
	return bResult;
}