aesapi.c

加密算法

	return 0;
}
      
int rijndaelEncrypt (word8 a[4][MAXBC], int keyBits, int blockBits, 
		word8 rk[MAXROUNDS+1][4][MAXBC])
{
	/* Encryption of one block. 
	 */
	int r, BC, ROUNDS;
//	int i,j,k;

//	word8 rk1[MAXROUNDS+1][4][MAXBC];
//	word8 randm[MAXROUNDS+1][4][MAXBC];
	
//	for(i=0;i<MAXROUNDS+1;i++)
//		for(j=0;j<4;j++)
//			for(k=0;k<MAXBC;k++)
//				rk1[i][j][k]=rk[i][j][k] xor 10;

	switch (blockBits) {
	case 128: BC = 4; break;
	case 192: BC = 6; break;
	case 256: BC = 8; break;
	default : return (-2);
	}

	switch (keyBits >= blockBits ? keyBits : blockBits) {
	case 128: ROUNDS = 10; break;
	case 192: ROUNDS = 12; break;
	case 256: ROUNDS = 14; break;
	default : return (-3); /* this cannot happen */
	}

	/* begin with a key addition
	 */
	AddRoundKey(a,rk[0],BC); 

        /* ROUNDS-1 ordinary rounds
	 */
	for(r = 1; r < ROUNDS; r++) {

		Substitution(a,S,BC);
		ShiftRows(a,0,BC);
		MixColumns(a,BC);
		AddRoundKey(a,rk[r],BC);
	}
	
	/* Last round is special: there is no MixColumns
	 */
	Substitution(a,S,BC);
	ShiftRows(a,0,BC);
	AddRoundKey(a,rk[ROUNDS],BC);

	return 0;
}   


int rijndaelDecrypt (word8 a[4][MAXBC], int keyBits, int blockBits, 
		word8 rk[MAXROUNDS+1][4][MAXBC])
{
	int r, BC, ROUNDS;
	
	switch (blockBits) {
	case 128: BC = 4; break;
	case 192: BC = 6; break;
	case 256: BC = 8; break;
	default : return (-2);
	}

	switch (keyBits >= blockBits ? keyBits : blockBits) {
	case 128: ROUNDS = 10; break;
	case 192: ROUNDS = 12; break;
	case 256: ROUNDS = 14; break;
	default : return (-3); /* this cannot happen */
	}

	/* To decrypt: apply the inverse operations of the encrypt routine,
	 *             in opposite order
	 * 
	 * (AddRoundKey is an involution: it 's equal to its inverse)
	 * (the inverse of Substitution with table S is Substitution with 
         *           the inverse table of S)
	 * (the inverse of ShiftRows is ShiftRows over a suitable distance)
	 */

        /* First the special round:
	 *   without InvMixColumns
	 *   with extra AddRoundKey
	 */
	AddRoundKey(a,rk[ROUNDS],BC);
	Substitution(a,Si,BC);
	ShiftRows(a,1,BC);              
	
	/* ROUNDS-1 ordinary rounds
	 */
	for(r = ROUNDS-1; r > 0; r--) {
		AddRoundKey(a,rk[r],BC);
		InvMixColumns(a,BC);      
		Substitution(a,Si,BC);
		ShiftRows(a,1,BC);                
	}
	
	/* End with the extra key addition
	 */
	
	AddRoundKey(a,rk[0],BC);    

	return 0;
}

/* AES Encryption function
 * plain: plain text, 16 bytes
 * KeyLen: 128 bits, 192 bits or 256 bits
 * mode: 0-ECB, 1-CBC
 * IV: valid only in CBC mode, 16 bytes
 * cipher: 16 bytes
 */
void AESEncrypt(U8 *plain, U8 *Key, U16 KeyLen, U8 mode, U8 *iv, U8 *cipher)
{
	int i, j;
	U8 tkey[4][MAXKC], tplain[4][MAXBC], tiv[4][MAXBC];
	U8 W[MAXROUNDS+1][4][MAXBC];

	if(mode == 0)
	{
		// convert plain
		for(i=0;i<4;i++)
	    {
			for(j=0;j<4;j++)
			{
				tplain[j][i] = plain[4*i+j];
			}
		}
		// convert key
		for(i=0;i<8;i++)
	    {
			for(j=0;j<4;j++)
			{
				tkey[j][i] = Key[4*i+j];
			}
		}
		
		// Create the expanded key files for the core 
		rijndaelKeySched(tkey,KeyLen,128,W);
	    // AES Encryption 
	    rijndaelEncrypt(tplain,KeyLen,128,W);
	}
	else if(mode == 1)
	{
		// plain ^ iv
		for(i=0; i<16; i++)
		{
			plain[i] ^= iv[i];
		}
		// convert plain
		for(i=0;i<4;i++)
	    {
			for(j=0;j<4;j++)
			{
				tplain[j][i] = plain[4*i+j];
				tiv[j][i] = iv[4*i+j];
			}
		}	
		// convert key
		for(i=0;i<8;i++)
	    {
			for(j=0;j<4;j++)
			{
				tkey[j][i] = Key[4*i+j];
			}
		}
		
		// Create the expanded key files for the core 
		rijndaelKeySched(tkey,KeyLen,128,W);
	    // AES Encryption 
	    rijndaelEncrypt(tplain,KeyLen,128,W);	
	}

	// convert result
	for(i=0;i<4;i++)
    {
		for(j=0;j<4;j++)
		{
			cipher[4*i+j] = tplain[j][i];
		}
	}

}

/* AES Decryption function
 * cipher: cipher text, 16 bytes
 * KeyLen: 128 bits, 192 bits or 256 bits
 * mode: 0-ECB, 1-CBC
 * IV: valid only in CBC mode
 * plain: 16 bytes
 */
void AESDecrypt(U8 *cipher, U8 *Key, U16 KeyLen, U8 mode, U8 *iv, U8 *plain)
{
	int i, j;
	U8 tkey[4][MAXKC], tplain[4][MAXBC], tiv[4][MAXBC];
	U8 W[MAXROUNDS+1][4][MAXBC];

	if(mode == 0)
	{
		// convert plain
		for(i=0;i<4;i++)
	    {
			for(j=0;j<4;j++)
			{
				tplain[j][i] = cipher[4*i+j];
			}
		}
		// convert key
		for(i=0;i<8;i++)
	    {
			for(j=0;j<4;j++)
			{
				tkey[j][i] = Key[4*i+j];
			}
		}
		
		// Create the expanded key files for the core 
		rijndaelKeySched(tkey,KeyLen,128,W);
	    // AES Encryption 
	    rijndaelDecrypt(tplain,KeyLen,128,W);
	}
	else if(mode == 1)
	{
		// convert plain
		for(i=0;i<4;i++)
	    {
			for(j=0;j<4;j++)
			{
				tplain[j][i] = cipher[4*i+j];
				tiv[j][i] = iv[4*i+j];
			}
		}	
		// convert key
		for(i=0;i<8;i++)
	    {
			for(j=0;j<4;j++)
			{
				tkey[j][i] = Key[4*i+j];
			}
		}	

		// Create the expanded key files for the core 
		rijndaelKeySched(tkey,KeyLen,128,W);
	    // AES Encryption 
	    rijndaelDecrypt(tplain,KeyLen,128,W);
		
	}

	// convert result
	for(i=0;i<4;i++)
    {
		for(j=0;j<4;j++)
		{
			plain[4*i+j] = tplain[j][i];
		}
	}

	if(mode == 1)
	{
		// plain ^ iv
		for(i=0; i<16; i++)
			plain[i] ^= iv[i];
	}
}