aes.cpp

这个是关于aes对称加密算法的优化程序

unsigned char j;
	// mixing column 0
	NextState[0] = Xtime2Sbox[State[0]] ^ Xtime3Sbox[State[5]] ^ Sbox[State[10]] ^ Sbox[State[15]];
	NextState[1] = Sbox[State[0]] ^ Xtime2Sbox[State[5]] ^ Xtime3Sbox[State[10]] ^ Sbox[State[15]];
	NextState[2] = Sbox[State[0]] ^ Sbox[State[5]] ^ Xtime2Sbox[State[10]] ^ Xtime3Sbox[State[15]];
	NextState[3] = Xtime3Sbox[State[0]] ^ Sbox[State[5]] ^ Sbox[State[10]] ^ Xtime2Sbox[State[15]];



	// mixing column 1
	NextState[4] = Xtime2Sbox[State[4]] ^ Xtime3Sbox[State[9]] ^ Sbox[State[14]] ^ Sbox[State[3]];
	NextState[5] = Sbox[State[4]] ^ Xtime2Sbox[State[9]] ^ Xtime3Sbox[State[14]] ^ Sbox[State[3]];
	NextState[6] = Sbox[State[4]] ^ Sbox[State[9]] ^ Xtime2Sbox[State[14]] ^ Xtime3Sbox[State[3]];
	NextState[7] = Xtime3Sbox[State[4]] ^ Sbox[State[9]] ^ Sbox[State[14]] ^ Xtime2Sbox[State[3]];


	// mixing column 2
	NextState[8] = Xtime2Sbox[State[8]] ^ Xtime3Sbox[State[13]] ^ Sbox[State[2]] ^ Sbox[State[7]];
	NextState[9] = Sbox[State[8]] ^ Xtime2Sbox[State[13]] ^ Xtime3Sbox[State[2]] ^ Sbox[State[7]];
	NextState[10]  = Sbox[State[8]] ^ Sbox[State[13]] ^ Xtime2Sbox[State[2]] ^ Xtime3Sbox[State[7]];
	NextState[11]  = Xtime3Sbox[State[8]] ^ Sbox[State[13]] ^ Sbox[State[2]] ^ Xtime2Sbox[State[7]];



	// mixing column 3
	NextState[12] = Xtime2Sbox[State[12]] ^ Xtime3Sbox[State[1]] ^ Sbox[State[6]] ^ Sbox[State[11]];
	NextState[13] = Sbox[State[12]] ^ Xtime2Sbox[State[1]] ^ Xtime3Sbox[State[6]] ^ Sbox[State[11]];
	NextState[14] = Sbox[State[12]] ^ Sbox[State[1]] ^ Xtime2Sbox[State[6]] ^ Xtime3Sbox[State[11]];
	NextState[15] = Xtime3Sbox[State[12]] ^ Sbox[State[1]] ^ Sbox[State[6]] ^ Xtime2Sbox[State[11]];

	for(j=0;j<sizeof(NextState);j++)
		*(State+j)=*(NextState+j);



}

// restore and un-mix each row in a column
void InvMixSubColumns (unsigned char *State)
{
unsigned char NextState[4 * Nb];
int i;

	// restore column 0
	NextState[0] = XtimeE[State[0]] ^ XtimeB[State[1]] ^ XtimeD[State[2]] ^ Xtime9[State[3]];
	NextState[5] = Xtime9[State[0]] ^ XtimeE[State[1]] ^ XtimeB[State[2]] ^ XtimeD[State[3]];
	NextState[10] = XtimeD[State[0]] ^ Xtime9[State[1]] ^ XtimeE[State[2]] ^ XtimeB[State[3]];
	NextState[15] = XtimeB[State[0]] ^ XtimeD[State[1]] ^ Xtime9[State[2]] ^ XtimeE[State[3]];

	// restore column 1
	NextState[4] = XtimeE[State[4]] ^ XtimeB[State[5]] ^ XtimeD[State[6]] ^ Xtime9[State[7]];
	NextState[9] = Xtime9[State[4]] ^ XtimeE[State[5]] ^ XtimeB[State[6]] ^ XtimeD[State[7]];
	NextState[14] = XtimeD[State[4]] ^ Xtime9[State[5]] ^ XtimeE[State[6]] ^ XtimeB[State[7]];
	NextState[3] = XtimeB[State[4]] ^ XtimeD[State[5]] ^ Xtime9[State[6]] ^ XtimeE[State[7]];

	// restore column 2
	NextState[8] = XtimeE[State[8]] ^ XtimeB[State[9]] ^ XtimeD[State[10]] ^ Xtime9[State[11]];
	NextState[13] = Xtime9[State[8]] ^ XtimeE[State[9]] ^ XtimeB[State[10]] ^ XtimeD[State[11]];
	NextState[2]  = XtimeD[State[8]] ^ Xtime9[State[9]] ^ XtimeE[State[10]] ^ XtimeB[State[11]];
	NextState[7]  = XtimeB[State[8]] ^ XtimeD[State[9]] ^ Xtime9[State[10]] ^ XtimeE[State[11]];

	// restore column 3
	NextState[12] = XtimeE[State[12]] ^ XtimeB[State[13]] ^ XtimeD[State[14]] ^ Xtime9[State[15]];
	NextState[1] = Xtime9[State[12]] ^ XtimeE[State[13]] ^ XtimeB[State[14]] ^ XtimeD[State[15]];
	NextState[6] = XtimeD[State[12]] ^ Xtime9[State[13]] ^ XtimeE[State[14]] ^ XtimeB[State[15]];
	NextState[11] = XtimeB[State[12]] ^ XtimeD[State[13]] ^ Xtime9[State[14]] ^ XtimeE[State[15]];

	for( i=0; i < 4 * Nb; i++ )
		State[i] = InvSbox[NextState[i]];
}



void AddRoundKey (unsigned *State, unsigned *Key)
{
int i;

	for( i = 0; i < 4; i++ )
		State[i] ^= Key[i];
}

unsigned char Rcon[11] = {
0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36};

// produce Nk bytes for each round
void ExpandKey (unsigned char *key, unsigned char *ExpKey)
{
unsigned char tmp0, tmp1, tmp2, tmp3, tmp4;
unsigned idx;

	for( idx = 0; idx < Nk; idx++ ) {
		ExpKey[4*idx+0] = key[4 * idx + 0];
		ExpKey[4*idx+1] = key[4 * idx + 1];
		ExpKey[4*idx+2] = key[4 * idx + 2];
		ExpKey[4*idx+3] = key[4 * idx + 3];
	}

	for( idx = Nk; idx < Nb * (Nr + 1); idx++ ) {
		tmp0 = ExpKey[4*idx - 4];
		tmp1 = ExpKey[4*idx - 3];
		tmp2 = ExpKey[4*idx - 2];
		tmp3 = ExpKey[4*idx - 1];
		if( !(idx % Nk) ) {
			tmp4 = tmp3;
			tmp3 = Sbox[tmp0];
			tmp0 = Sbox[tmp1] ^ Rcon[idx/Nk];
			tmp1 = Sbox[tmp2];
			tmp2 = Sbox[tmp4];
		}

		//  convert from longs to bytes

		ExpKey[4*idx+0] = ExpKey[4*idx - 4*Nk + 0] ^ tmp0;
		ExpKey[4*idx+1] = ExpKey[4*idx - 4*Nk + 1] ^ tmp1;
		ExpKey[4*idx+2] = ExpKey[4*idx - 4*Nk + 2] ^ tmp2;
		ExpKey[4*idx+3] = ExpKey[4*idx - 4*Nk + 3] ^ tmp3;
	}
}

// encrypt one 128 bit block
void Encrypt (unsigned char *InText, unsigned char *ExpKey, unsigned char *OutText)
{
unsigned round, idx;
unsigned char State[Nb * 4];

	for( idx = 0; idx < Nb; idx++ ) {
		State[4*idx+0] = *InText++;
		State[4*idx+1] = *InText++;
		State[4*idx+2] = *InText++;
		State[4*idx+3] = *InText++;
	}

	AddRoundKey ((unsigned *)State, (unsigned *)ExpKey);

	for( round = 1; round < Nr + 1; round++ ) {
		if( round < Nr )
			MixSubColumns (State);
		else
			ShiftRows (State);

		AddRoundKey ((unsigned *)State, (unsigned *)ExpKey + round * Nb);
	}

	for( idx = 0; idx < Nb; idx++ ) {
		*OutText++ = State[4*idx+0];
		*OutText++ = State[4*idx+1];
		*OutText++ = State[4*idx+2];
		*OutText++ = State[4*idx+3];
	}
}

void Decrypt (unsigned char *InText, unsigned char *ExpKey, unsigned char *OutText)
{
unsigned idx, round;
unsigned char State[Nb * 4];

	for( idx = 0; idx < Nb; idx++ ) {
		State[4*idx+0] = *InText++;
		State[4*idx+1] = *InText++;
		State[4*idx+2] = *InText++;
		State[4*idx+3] = *InText++;
	}

	AddRoundKey ((unsigned *)State, (unsigned *)ExpKey + Nr * Nb);
	round = Nr;

	InvShiftRows(State);

	while( round-- )
	{
		AddRoundKey ((unsigned *)State, (unsigned *)ExpKey + round * Nb);
		if( round )
			InvMixSubColumns (State);
	} 

	for( idx = 0; idx < Nb; idx++ ) {
		*OutText++ = State[4*idx+0];
		*OutText++ = State[4*idx+1];
		*OutText++ = State[4*idx+2];
		*OutText++ = State[4*idx+3];
	}
}

void main()
{

unsigned char in[16]={0x32,0x43,0xf6,0xad,0x88,0x5a,0x30,0x8d,0x31,0x31,0x98,0xa2,0xe0,0x37,0x07,0x34};
unsigned char key1[16]={0x2b,0x7e,0x15,0x16,0x28,0xae,0xd2,0xa6,0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c};

unsigned char OutText[16];
unsigned char ExpKey[4*Nb*(Nr+1)];
 unsigned char i;
ExpandKey(key1,ExpKey);
Encrypt(in,ExpKey,OutText);
for(i=0;i<16;i++)
{
  printf("%x ",in[i]);
  
  }
printf("\n");
printf("encrypt\n");
  for(i=0;i<16;i++)
  {
  printf("%#x ",OutText[i]);
  
  }
  printf("\n");
  ExpandKey(key1,ExpKey);
  Decrypt (OutText, ExpKey, in);
	printf("密文：");
    for(i=0;i<16;i++)
  {
  printf("%#x ",OutText[i]);
 
  }
	printf("\n");
	printf("明文：");
  for(i=0;i<16;i++)
  {
  printf("%#x ",in[i]);
 
  }
   printf("\n");
}