CBC模式的DES加密解密程序

#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 CBC[64];
int result[13][64];
int H[208];
char MiWen[208];
int C[832];
int M[13][8];

char choice;                //选择加密还是解密
int t;
int ij;
int klmn;
int r[8]c[8];
int flag=1;

int IP[64]={         //初始换位表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]={            //f函数的扩展换位表：32位扩展到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]={      //f函数的S换位表，S1到S8（6—>4）
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 14 6 3 15 5 1 13 12 7 11 4 2 8 
13 7 0