function_e1_e2_e3.cpp

AES快速算法和蓝牙设备中用的E0算法(用于加密)、E1算法、E2算法、E3算法（用于密钥管理和鉴权等）等

		case 4:
		case 7:
		case 8:
		case 11:
		case 12:
		case 15:	*(rand+m)=*(rand+m)^roundkey[16][m];
					break;
		default:	*(rand+m)=(*(rand+m)+roundkey[16][m]) % 256;
					break;
		}
	}
		
	
	
}
///////////////////////////////////////Function Ar/////////////////////////////////////////////////






///////////////////////////////////////Function Ar'///////////////////////////////////////////////
//used in functionE1
//Ar' is simliar to Ar
void function_Ar1(int_8bit* rand, /*int_8bit*  key,*/ int_8bit roundkey[17][16])
{
	int_8bit RAND[16];
	for(int_8bit i=0;i<16;i++)
		RAND[i]=rand[i];
	for(int_8bit k=0;k<8;k++)
	{
		if(k==2)
				
			for(int_8bit m=0;m<16;m++)
			{
				switch(m)
				{
					case 0:	case 3:	case 4:	case 7:
					case 8:	case 11:case 12:case 15:	
						*(rand+m)=*(RAND+m)^(*(rand+m));
						break;
					default:	
						*(rand+m)=(*(RAND+m)+*(rand+m)) % 256;
						break;
				}
			}



		roundencrypt (k, rand, roundkey);
	}

	for( int_8bit m=0;m<16;m++)
	{
	switch(m)
		{
		case 0:
		case 3:
		case 4:
		case 7:
		case 8:
		case 11:
		case 12:
		case 15:	*(rand+m)=*(rand+m)^roundkey[16][m];
					break;
		default:	*(rand+m)=(*(rand+m)+roundkey[16][m]) % 256;
					break;
		}
	}
	
printf("\n  key=0x");
for( int_8bit q=0;q<16;q++)
		printf("%2x",*(rand+q));


}


///////////////////////////////////////Function Ar'///////////////////////////////////////////////



//////////////////////////////////////function_E1///////////////////////////////////////////////////

void function_E1(int_8bit address[6],int_8bit RAND[16],int_8bit K[16] )
{
	int_8bit address128[16];

	/////////////////////////////address expand////////////////
	//expand the address with 48bits to one with 128bits


	for(int_8bit m=0;m<16;m++)		address128[m]=address[m %6];
	/////////////////////////////address expand////////////////


	int_8bit K1[16];

	////////////////////////////function K'/////////////////////////
	K1[0]=(K[0]+233) % 256;   K1[1]=K[1]^229;
	K1[2]=(K[2]+223) % 256;   K1[3]=K[3]^193;
	K1[4]=(K[4]+179) % 256;   K1[5]=K[5]^167;
	K1[6]=(K[6]+149) % 256;   K1[7]=K[7]^131;

	K1[ 8]=K[ 8]^233;   K1[ 9]=(K[ 9]+229) % 256;
	K1[10]=K[10]^223;   K1[11]=(K[11]+193) % 256;
	K1[12]=K[12]^179;   K1[13]=(K[13]+167) % 256;
	K1[14]=K[14]^149;   K1[15]=(K[15]+131) % 256;
	////////////////////////////function K'/////////////////////////

	int_8bit roundkey[17][16],roundkey1[17][16];

	int_8bit rand[16];
	for(m=0;m<16;m++) rand[m]=RAND[m];;

	roundkeygenerate(K, roundkey);


	function_Ar(rand, roundkey);
	for(m=0;m<16;m++) 
	{
		rand[m]=rand[m]^RAND[m];
		rand[m]=(rand[m] + address128[m]) % 256;
	}
	/*int_8bit temp_k[16];
	for(m=0;m<16;m++) temp_k[m]=K1[15-m];*/

	roundkeygenerate(K1,roundkey1);
	function_Ar1(rand, roundkey1);
	for(m=0;m<16;m++) RAND[m]=rand[m];


}

//////////////////////////////////////function_E1///////////////////////////////////////////////////


//////////////////////////////////////function_E21///////////////////////////////////////////////////

int_8bit* function_E21(int_8bit address[6],int_8bit RAND[16])
{

	int_8bit roundkey[17][16];

	//int_8bit rand[16];
	//for(int_8bit m=0;m<16;m++) rand[m]=RAND[m];;

	RAND[15]=RAND[15]^6;
	int_8bit address128[16];

	/////////////////////////////address expand////////////////
	//expand the address with 48bits to one with 128bits

	for( int_8bit m=0;m<16;m++)		address128[m]=address[m %6];
	/////////////////////////////address expand////////////////

	roundkeygenerate(RAND, roundkey);


	function_Ar1(address128, roundkey);
	
	return address128;
}

//////////////////////////////////////function_E21///////////////////////////////////////////////////


//////////////////////////////////////function_E22///////////////////////////////////////////////////

int_8bit* function_E22(int_8bit pin[16],int_8bit RAND[16],int_8bit L)
{

	int_8bit roundkey[17][16];

	//int_8bit rand[16];
	//for(int_8bit m=0;m<16;m++) rand[m]=RAND[m];;

	RAND[15]=RAND[15]^L;

	/////////////////////////////address expand////////////////
	//expand the address with 48bits to one with 128bits

	/////////////////////////////address expand////////////////

	roundkeygenerate(pin, roundkey);


	function_Ar1(RAND, roundkey);

	return RAND;
}

//////////////////////////////////////function_E21///////////////////////////////////////////////////



/////////////////////////////////////function_E3////////////////////////////////////


int_8bit * function_E3(int_8bit K[16],int_8bit RAND[16],int_8bit COF[12], int_8bit L)
{
	int_8bit address128[16];

	/////////////////////////////address expand////////////////
	//expand the address with 48bits to one with 128bits


	for(int_8bit m=0;m<16;m++)		address128[m]=COF[m % L];
	/////////////////////////////address expand////////////////


	int_8bit K1[16];

	////////////////////////////function K'/////////////////////////
	K1[0]=(K[0]+233) % 256;   K1[1]=K[1]^229;
	K1[2]=(K[2]+223) % 256;   K1[3]=K[3]^193;
	K1[4]=(K[4]+179) % 256;   K1[5]=K[5]^167;
	K1[6]=(K[6]+149) % 256;   K1[7]=K[7]^131;

	K1[ 8]=K[ 8]^233;   K1[ 9]=(K[ 9]+229) % 256;
	K1[10]=K[10]^223;   K1[11]=(K[11]+193) % 256;
	K1[12]=K[12]^179;   K1[13]=(K[13]+167) % 256;
	K1[14]=K[14]^149;   K1[15]=(K[15]+131) % 256;
	////////////////////////////function K'/////////////////////////

	int_8bit roundkey[17][16],roundkey1[17][16];

	int_8bit rand[16];
	for(m=0;m<16;m++) rand[m]=RAND[m];;

	roundkeygenerate(K, roundkey);


	function_Ar(rand, roundkey);
	for(m=0;m<16;m++) 
	{
		rand[m]=rand[m]^RAND[m];
		rand[m]=(rand[m] + address128[m]) % 256;
	}
	/*int_8bit temp_k[16];
	for(m=0;m<16;m++) temp_k[m]=K1[15-m];*/

	roundkeygenerate(K1,roundkey1);
	function_Ar1(rand, roundkey1);
	for(m=0;m<16;m++) RAND[m]=rand[m];

	return RAND;
}



void main()
{
	int temp;
	//Realize function e and l as a table;
	for (int i=0;i <=255; i++)
	{
		temp =  e(i);
		etable[i] = temp;
		ltable[temp] = i;
	}




///////////////////////////////////////////Funciton E1///////////////////////////////////////////////////////////
//Sample data1
/*

int_8bit address[6]={0x00,0x00,0x00,0x00,0x00,0x00};
int_8bit rand[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
int_8bit key[16] ={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

*/

//sample data2 
/*

int_8bit address[6]={0x7c,0xa8,0x9b,0x23,0x3c,0x2d};
int_8bit rand[16]={0xbc,0x3f,0x30,0x68,0x96,0x47,0xc8,0xd7,0xc5,0xa0,0x3c,0xa8,0x0a,0x91,0xec,0xeb};

int_8bit key[16] ={0x15,0x9d,0xd9,0xf4,0x3f,0xc3,0xd3,0x28,0xef,0xba,0x0c,0xd8,0xa8,0x61,0xfa,0x57};
*/

	

//sample data3 
/*
int_8bit address[6]={0xc6,0x2f,0x19,0xf6,0xce,0x98};
int_8bit rand[16]={0x08,0x91,0xca,0xee,0x06,0x3f,0x5d,0xa1,0x80,0x95,0x77,0xff,0x94,0xcc,0xdc,0xfb};

int_8bit key[16] ={0x45,0x29,0x8d,0x06,0xe4,0x6b,0xac,0x21,0x42,0x1d,0xdf,0xbe,0xd9,0x4c,0x03,0x2b};
*/

//sample data4 

//*

int_8bit address[6]={0xf4,0x28,0xf0,0xe6,0x24,0xb3};
int_8bit rand[16]={0x0e,0xcd,0x61,0x78,0x2b,0x41,0x28,0x48,0x0c,0x05,0xdc,0x45,0x54,0x2b,0x1b,0x8c};

int_8bit key[16] ={0x35,0x94,0x9a,0x91,0x42,0x25,0xfa,0xba,0xd9,0x19,0x95,0xd2,0x26,0xde,0x1d,0x92};	
	
function_E1(address,rand,key);
printf("\n SRES=0x");
for(int_8bit p=0;p<4;p++)
		printf("%2x",*(rand+p));

printf("\n  ACO=0x");
for( p=4;p<16;p++)
		printf("%2x",*(rand+p));
getchar();
getchar();

//*/
/////////////////////////////////////////Function E1////////////////////////////////////////////////

	
/////////////////////////////////////////Function E21////////////////////////////////////////////
//sample data1
/*
int_8bit address[6]={0x00,0x00,0x00,0x00,0x00,0x00};
int_8bit rand[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
*/
//sample data2
/*
int_8bit address[6]={0xca,0xc4,0x36,0x43,0x03,0xb6};
int_8bit rand[16]={0x2d,0xd9,0xa5,0x50,0x34,0x31,0x91,0x30,0x40,0x13,0xb2,0xd7,0xe1,0x18,0x9d,0x09};
*/
//sample data3  
/*
int_8bit address[6]={0x02,0xf8,0xfd,0x4c,0xd6,0x61};
int_8bit rand[16]={0xda,0xb3,0xcf,0xfe,0x9d,0x57,0x39,0xd1,0xb7,0xbf,0x4a,0x66,0x7a,0xe5,0xee,0x24};
*/
/*
//sample data4  
int_8bit address[6]={0x98,0x46,0xc5,0xea,0xd4,0xd9};
int_8bit rand[16]={0x13,0xec,0xad,0x08,0xad,0x63,0xc3,0x7f,0x8a,0x54,0xdc,0x56,0xe8,0x2f,0x4d,0xc1};
int_8bit *rand1;
rand1=function_E21(address,rand);
//*/


//////////////////////////////////////////Function E21//////////////////////////////////////////////


//*
//////////////////////////////////////////Function E22//////////////////////////////////////////////

//sample data1

//int_8bit  pin[16]={0xd5,0xa5,0x10,0x83,0xa0,0x4a,0x19,0x71,0xf1,0x86,0x49,0xea,0x8b,0x79,0x31,0x1a};
//int_8bit rand[16]={0x00,0x1d,0xe1,0x69,0x24,0x88,0x50,0x24,0x5a,0x5f,0x7c,0xc7,0xf0,0xd6,0xd6,0x33};


//sample data2
//int_8bit  pin[16]={0x78,0x85,0xb5,0x15,0xe8,0x4b,0x1f,0x08,0x2c,0xc4,0x99,0x97,0x6f,0x17,0x25,0xce};
//int_8bit rand[16]={0x67,0xed,0x56,0xbf,0xcf,0x99,0x82,0x5f,0x0c,0x6b,0x34,0x93,0x69,0xda,0x30,0xab};


//sample data3
//int_8bit pin[16]={0x1c,0xe4,0x48,0x39,0xba,0xdd,0xe3,0x03,0x96,0xd0,0x3c,0x4c,0x36,0xf2,0x30,0x06};
//int_8bit rand[16]={0x40,0xa9,0x45,0x09,0x23,0x86,0x64,0xf2,0x44,0xff,0x8e,0x3d,0x13,0xb1,0x19,0xd3};


//function_E22(pin,rand,16);

//////////////////////////////////////////Function E22//////////////////////////////////////////////

//*/



////////////////////////////////////////Function E3////////////////////////////////////
//sample data1
/*
int_8bit  key[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
int_8bit rand[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
int_8bit COF [12]={0x48,0xaf,0xcd,0xd4,0xbd,0x40,0xfe,0xf7,0x66,0x93,0xb1,0x13};
//*/

//sample data2
/*
int_8bit  key[16]={0x34,0xe8,0x69,0x15,0xd2,0x0c,0x48,0x50,0x90,0xa6,0x97,0x79,0x31,0xf9,0x6d,0xf5};
int_8bit rand[16]={0x95,0x0e,0x60,0x4e,0x65,0x5e,0xa3,0x80,0x0f,0xe3,0xeb,0x4a,0x28,0x91,0x80,0x87};
int_8bit COF [12]={0x68,0xf4,0xf4,0x72,0xb5,0x58,0x6a,0xc5,0x85,0x0f,0x5f,0x74};
//*/

//sample data3
/*
int_8bit  key[16]={0x35,0xcf,0x77,0xb3,0x33,0xc2,0x94,0x67,0x1d,0x42,0x6f,0xa7,0x99,0x93,0xa1,0x33};
int_8bit rand[16]={0x6a,0x8e,0xbc,0xf5,0xe6,0xe4,0x71,0x50,0x5b,0xe6,0x8d,0x5e,0xb8,0xa3,0x20,0x0c};
int_8bit COF [12]={0x65,0x8d,0x79,0x1a,0x95,0x54,0xb7,0x7c,0x0b,0x2f,0x7b,0x9f};
//*/

//sample data4
/*
int_8bit  key[16]={0xb9,0xf9,0x0c,0x53,0x20,0x67,0x92,0xb1,0x82,0x68,0x38,0xb4,0x35,0xb8,0x7d,0x4d};
int_8bit rand[16]={0x5e,0xcd,0x6d,0x75,0xdb,0x32,0x2c,0x75,0xb6,0xaf,0xbd,0x79,0x9c,0xb1,0x86,0x68};
int_8bit COF [12]={0x63,0xf7,0x01,0xc7,0x01,0x32,0x38,0xbb,0xf8,0x87,0x14,0xee};
//*/



//int_8bit *rand1;
//rand1=
//function_E3(key,rand,COF,12);


}