des.c

des加密解密原程序

#include <stdio.h>
#include <string.h>

#include "des.h"

void Encode_Decode(UINT8 * pkey, UINT8 * pdata, UINT8 flag, UINT8 * psave, UINT32 len);

void Encode_Decode2(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg); 

void main(void)
{
	UINT8 * ptrkey, * ptrdata, * ptrsave;
	UINT32 Length,i;

	memset(inputdata,0,sizeof(inputdata));
	memset(outputdata,0,sizeof(outputdata));
	Length = sizeof(C_Data);
	memcpy(inputdata,C_Data,Length);
	Length = (Length % 8) ? (Length / 8 + 1) * 8 : Length;
	for(i=0;i<Length;i++)  printf("%02x ",inputdata[i]);
	printf("\n");printf("\n");

	ptrkey = (UINT8 *)C_Key;			//encode
	ptrdata = inputdata;
	ptrsave = outputdata;
	encode_decode = 1;
	Encode_Decode(ptrkey,ptrdata,encode_decode,ptrsave,Length);
//Encode_Decode2(ptrdata,ptrsave,ptrkey,encode_decode);
	for(i=0;i<Length;i++)  printf("%02x ",outputdata[i]);
	printf("\n");printf("\n");

	memset(inputdata,0,sizeof(inputdata));
	ptrkey = (UINT8 *)C_Key;			//decode
	ptrdata = outputdata;
	ptrsave = inputdata;
	encode_decode = 0;
	Encode_Decode(ptrkey,ptrdata,encode_decode,ptrsave,Length);
//Encode_Decode2(ptrdata,ptrsave,ptrkey,encode_decode);
	for(i=0;i<Length;i++)  printf("%02x ",inputdata[i]);
	printf("\n");printf("\n");
}

void Encode_Decode(UINT8 * pkey, UINT8 * pdata, UINT8 flag, UINT8 * psave, UINT32 len)
{
	UINT8 key1[64],key2[56],key3[16][48],i,j;
	UINT32 C[17],D[17];						//28 bits
	UINT32 L[17],R[17];						//32 bits
	UINT8 * ptrtmp;
	UINT32 k;
	UINT8 data1[64],R_tmp1[32],R_tmp2[48],B[8];
	
	memset(C,0,sizeof(C));
	memset(D,0,sizeof(D));
	ptrtmp = key1;
	for(i=0;i<8;i++)						//得到64位密钥
	{
		for(j=0;j<8;j++)
		{
			*ptrtmp++ = (pkey[i] >> (7-j)) & 0x01;
		}
	}
	for(i=0;i<56;i++)						//得到变化后的56位密钥和C[0],D[0]	
	{
		key2[i] = key1[key64_56[i]-1];	
		if(i < 28)
		{
			C[0] <<= 1;
			C[0] |= key2[i];
		}
		else
		{
			D[0] <<= 1;
			D[0] |= key2[i];
		}
	}
	for(i=1;i<=16;i++)						//计算出16个子密钥
	{
		C[i] = ((C[i-1] << rotate_left[i-1]) & 0x0fffffff) | (C[i-1] >> (28 - rotate_left[i-1]));
		D[i] = ((D[i-1] << rotate_left[i-1]) & 0x0fffffff) | (D[i-1] >> (28 - rotate_left[i-1]));
		for(j=0;j<56;j++)
		{
			if(j < 28)
			{
				key2[j] = (UINT8)((C[i] >> (27 - j)) & 0x01);
			}
			else
			{
				key2[j] = (UINT8)((D[i] >> (28 + 27 - j)) & 0x01);
			}
		}
		for(j=0;j<48;j++)
		{
			key3[i-1][j] = key2[key56_48[j]-1];
		}
	}
	
	//对64位数据块的处理
	k = 0;
	while(k < len)
	{
		memset(data1,0,sizeof(data1));
		ptrtmp = data1;
		for(i=0;i<8;i++)						//得到64位数据
		{
			for(j=0;j<8;j++)
			{
				*ptrtmp++ = (pdata[i] >> (7-j)) & 0x01;
			}
		}
		for(i=0;i<64;i++)						//得到变化后的64位数据和L[0],R[0]
		{
			UINT8 tempdata;
			tempdata = data1[data64_64[i]-1];	
			if(i < 32)
			{
				L[0] <<= 1;
				L[0] |= tempdata;
			}
			else
			{
				R[0] <<= 1;
				R[0] |= tempdata;
			}
		}
		
		for(i=1;i<=16;i++)						//用16个子密钥对数据加密
		{
			for(j=0;j<32;j++)
			{
				R_tmp1[j] = (UINT8)((R[i-1] >> (31-j)) & 0x01);
			}
			for(j=0;j<48;j++)
			{
				R_tmp2[j] = R_tmp1[extend32_48[j]-1]; //扩充到48位
				if(flag)
					R_tmp2[j] ^= key3[i-1][j];
				else
					R_tmp2[j] ^= key3[16-i][j];
			}
			memset(B,0,sizeof(B));
			for(j=0;j<8;j++)						//分成8个六位数
			{
				UINT8 m;
				for(m=0;m<6;m++)
				{
					B[j] <<= 1;
					B[j] |= R_tmp2[m + j * 6];
				}
			}
			for(j=0;j<8;j++)						//用S密箱里的值替换B
			{
				UINT8 row,column;
				row = ((B[j] >> 4) & 0x02) + (B[j] & 0x01);
				column = (B[j] >> 1) & 0x0f;
				B[j] = S4[j*64 + row*16 + column];
			}
			for(j=0;j<8;j++)						//把B[0]至B[7] 顺序串联起来得到一个32位数
			{
				R_tmp1[j*4] = (B[j] >> 3) & 0x01;
				R_tmp1[j*4+1] = (B[j] >> 2) & 0x01;
				R_tmp1[j*4+2] = (B[j] >> 1) & 0x01;
				R_tmp1[j*4+3] = (B[j] >> 0) & 0x01;
			}
			for(j=0;j<32;j++)						//对这个数做如下变换
			{
				R_tmp2[j] = R_tmp1[change32_32[j] - 1];
			}
			for(j=0;j<32;j++)						//计算L[i-1]
			{
				R_tmp1[j] = (UINT8)((L[i-1] >> (31-j)) & 0x01);
				R_tmp2[j] ^= R_tmp1[j];
				R[i] <<= 1;
				R[i] |= R_tmp2[j];					//把计算结果賦给R[i]
			}
			L[i] = R[i-1];							//把R[i-1]的值賦给L[i]
		}
		
		//把R[16]和L[16] 顺序串联起来得到一个64位数
		for(i=0;i<64;i++)
		{
			if(i < 32)
			{
				data1[i] = (UINT8)((R[16] >> (31-i)) & 0x01);
			}
			else
			{
				data1[i] = (UINT8)((L[16] >> (32+31-i)) & 0x01);
			}
		}
		//对这个64位数实施逆变换,然后存储
		for(i=0;i<8;i++)
		{
			UINT8 tempdata;
			for(j=0;j<8;j++)
			{
				tempdata = data1[invert64[i*8+j] - 1];
				psave[i] <<= 1;
				psave[i] |= tempdata;
			}
		}
		pdata += 8;
		psave += 8;
		k += 8;
	}
}

void Encode_Decode2(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg) 
{ 
unsigned char bufout[64], 
kwork[56], worka[48], kn[48], buffer[64], key[64], 
nbrofshift, temp1, temp2; 
int valindex; 
register i, j, k, iter; 

/* INITIALIZE THE TABLES */ 
/* Table - s1 */ 
static unsigned char s1[4][16] = { 
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0, 
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 }; 

/* Table - s2 */ 
static unsigned char s2[4][16] = { 
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15, 
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 }; 

/* Table - s3 */ 
static unsigned char s3[4][16] = { 
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7, 
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 }; 

/* Table - s4 */ 
static unsigned char s4[4][16] = { 
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4, 
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 }; 

/* Table - s5 */ 
static unsigned char s5[4][16] = { 
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14, 
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 }; 

/* Table - s6 */ 
static unsigned char s6[4][16] = { 
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6, 
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 }; 

/* Table - s7 */ 
static unsigned char s7[4][16] = { 
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2, 
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 }; 

/* Table - s8 */ 
static unsigned char s8[4][16] = { 
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8, 
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 }; 


/* Table - Shift */ 
static unsigned char shift[16] = { 
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 }; 


/* Table - Binary */ 
static unsigned char binary[64] = { 
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 
1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 
1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 }; 

/* MAIN PROCESS */ 
/* Convert from 64-bit key into 64-byte key */ 
for (i = 0; i < 8; i++) { 
key[8*i] = ((j = *(inkey + i)) / 128) % 2; 
key[8*i+1] = (j / 64) % 2; 
key[8*i+2] = (j / 32) % 2; 
key[8*i+3] = (j / 16) % 2; 
key[8*i+4] = (j / 8) % 2; 
key[8*i+5] = (j / 4) % 2; 
key[8*i+6] = (j / 2) % 2; 
key[8*i+7] = j % 2; 
} 

/* Convert from 64-bit data into 64-byte data */ 
for (i = 0; i < 8; i++) { 
buffer[8*i] = ((j = *(source + i)) / 128) % 2; 
buffer[8*i+1] = (j / 64) % 2; 
buffer[8*i+2] = (j / 32) % 2; 
buffer[8*i+3] = (j / 16) % 2; 
buffer[8*i+4] = (j / 8) % 2; 
buffer[8*i+5] = (j / 4) % 2; 
buffer[8*i+6] = (j / 2) % 2; 
buffer[8*i+7] = j % 2; 
} 

/* Initial Permutation of Data */ 
bufout[ 0] = buffer[57]; 
bufout[ 1] = buffer[49]; 
bufout[ 2] = buffer[41]; 
bufout[ 3] = buffer[33]; 
bufout[ 4] = buffer[25]; 
bufout[ 5] = buffer[17]; 
bufout[ 6] = buffer[ 9]; 
bufout[ 7] = buffer[ 1]; 
bufout[ 8] = buffer[59]; 
bufout[ 9] = buffer[51]; 
bufout[10] = buffer[43]; 
bufout[11] = buffer[35]; 
bufout[12] = buffer[27]; 
bufout[13] = buffer[19]; 
bufout[14] = buffer[11]; 
bufout[15] = buffer[ 3]; 
bufout[16] = buffer[61]; 
bufout[17] = buffer[53]; 
bufout[18] = buffer[45]; 
bufout[19] = buffer[37]; 
bufout[20] = buffer[29]; 
bufout[21] = buffer[21]; 
bufout[22] = buffer[13]; 
bufout[23] = buffer[ 5]; 
bufout[24] = buffer[63]; 
bufout[25] = buffer[55]; 
bufout[26] = buffer[47]; 
bufout[27] = buffer[39]; 
bufout[28] = buffer[31]; 
bufout[29] = buffer[23]; 
bufout[30] = buffer[15]; 
bufout[31] = buffer[ 7]; 
bufout[32] = buffer[56]; 
bufout[33] = buffer[48]; 
bufout[34] = buffer[40]; 
bufout[35] = buffer[32]; 
bufout[36] = buffer[24]; 
bufout[37] = buffer[16]; 
bufout[38] = buffer[ 8]; 
bufout[39] = buffer[ 0]; 
bufout[40] = buffer[58]; 
bufout[41] = buffer[50]; 
bufout[42] = buffer[42]; 
bufout[43] = buffer[34]; 
bufout[44] = buffer[26]; 
bufout[45] = buffer[18]; 
bufout[46] = buffer[10]; 
bufout[47] = buffer[ 2]; 
bufout[48] = buffer[60]; 
bufout[49] = buffer[52]; 
bufout[50] = buffer[44]; 
bufout[51] = buffer[36]; 
bufout[52] = buffer[28]; 
bufout[53] = buffer[20]; 
bufout[54] = buffer[12]; 
bufout[55] = buffer[ 4]; 
bufout[56] = buffer[62]; 
bufout[57] = buffer[54]; 
bufout[58] = buffer[46]; 
bufout[59] = buffer[38]; 
bufout[60] = buffer[30]; 
bufout[61] = buffer[22]; 
bufout[62] = buffer[14]; 
bufout[63] = buffer[ 6]; 

/* Initial Permutation of Key */ 
kwork[ 0] = key[56]; 
kwork[ 1] = key[48]; 
kwork[ 2] = key[40]; 
kwork[ 3] = key[32];