一个完整的des算法的c语言实现

#include
#include
void main（）
{
								//声明变量
	char MingWen[104];		    //存放原始的明文
	char target[8];             //将明文断成8个字符的一个分组
	char InputKey[8];           //存放字符型的八位密钥
	int text[64];               //存放一个分组转成二进制后的数据
	int text_ip[64];            //存放第一次初始换位的结果
	int L0[32]Li[32];          //将64位分成左右各32位进行迭代
	int R0[32]Ri[32];
	int RE0[48];                //存放右半部分经过E表扩展换位后的48位数据
	int key[64];                //存放密钥的二进制形式
	int keyPC1[56];             //存放密钥key经过PC1换位表后变成的56位二进制
	int A[28];                  //将keyPC1分成左右两部分，左部A，右部B，各28位，以便进行循环左移
	int B[28];
	int keyAB[56];              //将循环左移后两部分的结果合并起来
	int K[16][48];              //存放16次循环左移产生的子密钥
	int RK[48];                 //存放RE和K异或运算后的结果
	int RKS[8];                 //存放经过查找8个S表后得到的8个十进制结果
	int SP[32];                 //将RKS表中的十进制数化成二进制
	int RKSP[32];               //存放SP表经过P盒换位后的结果
	int text_end[64];           //存放经过左右32位换位后的结果
	int text_out[14][64];       //存放初始化向量和所有经过DES的分组的二进制
	char init[9]={“HTmadeit“};  //设置初始化向量为“HTmadeit”
	int result[13][64];
	int H[208];
	char MiWen[208];
	int C[832];
	int M[13][8];
	
	char a;
	int t;
	int ij;
	int klmn;
	int r[8]c[8];
	int flag=1;
	
	int IP[64]={         //初始换位表
			58 50 42 34 26 18 10 2 
			60 52 44 36 28 20 12 4 
			62 54 46 38 30 22 14 6 
			64 56 48 40 32 24 16 8 
			57 49 41 33 25 17 9 1 
			59 51 43 35 27 19 11 3 
			61 53 45 37 29 21 13 5 
			63 55 47 39 31 23 15 7
	};
	
	int E[48]={            //扩展换位表
			32 1 2 3 4 5 
			4 5 6 7 8 9 
			8 9 10 11 12 13 
			12 13 14 15 16 17 
			16 17 18 19 20 21 
			20 21 22 23 24 25 
			24 25 26 27 28 29 
			28 29 30 31 32 1 };
		
	int PC1[56]={          //PC1换位表（64—>56）
			57 49 41 33 25 17 9 
			1 58 50 42 34 26 18 
			10 2 59 51 43 35 27 
			19 11 3 60 52 44 36 
			63 55 47 39 31 23 15 
			7 62 54 46 38 30 22 
			14 6 61 53 45 37 29 
			21 13 5 28 20 12 4 };
			
	int move[16]={			//循环移位表
			1122222212222221};
				
	int PC2[48]={  		   //PC2换位表（56—>48）
			14 17 11 24 1 5 
			3 28 15 6 21 10 
			23 19 12 4 26 8 
			16 7 27 20 13 2 
			41 52 31 37 47 55 
			30 40 51 45 33 48 
			44 49 39 56 34 53 
			46 42 50 36 29 32 }; 
					
	int S1[4][16]={      //S换位表
			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
			};
	int 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
			};
	int S3[4][16]={
			10 0 9