四 、密码函数F
密码函数F的输入接收两个输入，32位的用户输入的需要加密的数据和48位对应的子密钥。F函数过程如下：
1、先将数据的右半部分Ri通过扩展置换E从32位扩展道48位。
2、扩展后48位与48位的密钥进行异或运算。
3、异或运算后在进行S盒置换，将48位的数据变为32位的数据。
4、经过（3）后的32位数据进行一个P盒置换。
5、再将这个32位的数据与左边的数据进行异或运算。
6、经过（5）过后的数据作为一下轮右边的数据Li+1，右边的Ri变为下一轮左边的数据Ri+1。
1、扩展置换
右半部分的32位明文数据需要扩展成为48位的数据，这样的好处有：
1、可以与48位的子密钥进行异或运算。
2、提供更长的结果，让下一步中可以进行压缩。
3、产生雪崩效应。这个是最主要的目的。输出对输入的依赖性将传播的更快。
其扩展的方法与前面的IP置换，PC-1置换方法一样，知识表不同而已，通过表可以看出，他只是让某些位重复出现而已，原理非常简单。
2、异或运算
扩展后48位与48位的密钥进行异或运算。
如果a、b两个值不相同，则异或结果为1。如果a、b两个值相同，异或结果为0。
3、S盒置换
S盒是DES最重要的部分，这个部分是非线性，其他的部分都是线性的，易于分析。让DES更加安全。
将异或得到的48位结果分成8个六位的快，6位输入，4位输出。这8个快就是8个盒。最终得到32位的输出成为P盒置换的输入。
S盒置换原理：根据第1位和最后1位组成的2位值找到表6中的行号，而根据中间剩下的4位来确定表6中的列号。
这行与列是从0开始的。
假设S-盒8的输入为110011。
第1位和最后一位组合形成了11(二进制)，对应S-盒8的第3行（从0开始的，也就是最后一行）。中间的4位组成形成1001(二进制),对应S-盒8的第9列。所以对应S-盒8第3行第9列值是12。则S-盒输出是1100(二进制)。
将8个盒的运算结果排在一起就是下一个的输入。
4、P盒置换
使用方法跟前面的IP置换相同，置换表如下：
5、异或
6、经过（5）过后的数据作为一下轮右边的数据Li+1，右边的Ri变为下一轮左边的数据Ri+1。
如下图：
C语言实现
主要函数有：
1、将IP置换后的数据分成两部分Li，Ri 左右分：void divideAfterIP()
2、扩展置换：void toExpand()
3、扩展后与密钥异或：void toAfterExpandXor(int n)
4、S盒置换：void SSSS()
5、P盒置换：void PP()
6、P盒置换后与Li异或 得到第n轮加密数据：void toAfterPPXor(int n）
#include<stdio.h>
#include<stdlib.h>//要使用malloc是要包含此头文件
#include <memory.h>//要使用memset是要包含此头文件
int plaintextBinary[64]; //明文二进制
int inputBinary[64];
int outputBinary[64];
int keyBinary64[64]; //二进制key
int temporary[56]={0}; //置换过后的key 以及第n轮移位后的key
//char keyBinary56[16][64]; //i轮的子密钥
int subKeyBinary[16][48]; //子密钥
int lefeLi[32]; //左半部分
int rightRi[32]; //右半部分
int expand[48]; //扩展后的
int xor[48]; //异或后的
int temp[32]; //临时放左右部分的数据 或者s盒时的数据
int temp1[32]; //临时放数据 无实际意义
// 正向置换表
int DES_IP[] =
{
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 DES_NIP[] =
{
40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25
};
//PC-1置换表
int DES_PC_1[]=
{
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 shift[]=
{
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};
//压缩表PC-2
int condense[]=
{
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 expands[]=
{
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
};
//s盒
int 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}
};
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,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}
};
int 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}
};
int 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}
};
int 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}
};
int 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}
};
int 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}
};
//P盒置换表
int PPP[32]=
{
16,7,20,21,
29,12,28,17,
1,15,23,26,
5,18,31,10,
2,8,24,14,
32,27,3,9,
19,13,30,6,
22,11,4,25
};
//PKCS7Padding 填充方式
//对加密数据字节长度对8取余为r，如r大于0，
//则补8-r个字节，字节为8-r的值；如果r等于0，则补8个字节8。
//比如：
//加密字符串为为AAA，则补位为AAA55555;
//加密字符串为BBBBBB，则补位为BBBBBB22；
//加密字符串为CCCCCCCC，则补位为CCCCCCCC88888888
//在这里为了简单，如果r=0，就不补充
char *Padding(char *p,int m)
{
int n=8-m;
int i;
if(m==8)
return p;
else
{
for(i=m;i<8;i++)
{
p[i]=(char)('0'+n);
}
printf("\n填充过后的：");
for (i=0;i<8;i++)//数组赋值
{
printf("%c",p[i]);
}
return p;
}
}
//将用户的输入转换位二进制
void *toPlainTextBinary(char *p)
{
int temp; //临时存放
int a =1; //二进制时的余数
int m=0;
int i,j,k; //用于循环
int b[8]={0}; //存放每个字符二进制
printf("\n");
for(i =0;i<8;i++)
{
temp = p[i];
for(j=0;j<8;j++)
{
a=(int)temp%2;
temp=temp/2;
b[j]=a;
}
for(j=7;j>=0;j--)
{
inputBinary[m++]=b[j];
}
}
printf("该数二进制为:");
for(j=0;j<64;j++)
{
if(j%8==0)
printf("\n");
printf("%d",inputBinary[j]);
}
printf("\n");
}
//置换函数IP
void IP()
{
int i;
printf("IP置换后的明文：\n");
for(i=0;i<64;i++)
{
plaintextBinary[i]=inputBinary[DES_IP[i]-1];
}
for(i=0;i<64;i++)
{
if(i%8==0&&i!=0)
printf("\n");
printf("%d",plaintextBinary[i]);
}
}
//将用户的输入的密钥转换位二进制
void *toKeytBinary(char *key)
{
int temp; //临时存放
int a =1; //二进制时的余数
int m=0;
int i,j,k; //用于循环
int b[8]={0}; //存放每个字符二进制
printf("\n");
for(i =0;i<8;i++)
{
temp = key[i];
for(j=0;j<8;j++)
{
a=(int)temp%2;
temp=temp/2;
b[j]=a;
}
for(j=7;j>=0;j--)
{
keyBinary64[m++]=b[j];
}
}
printf("该数二进制为:");
for(j=0;j<64;j++)
{
if(j%8==0)
printf("\n");
printf("%d",keyBinary64[j]);
}
printf("\n");
}
//置换函数PC-1
void displace()
{
int i,j=0,m=0;
//置换
for(i=0;i<56;i++)
{
temporary[i]=keyBinary64[DES_PC_1[i]-1];
}
printf("PC-1置换后的key:");
for(i=0;i<56;i++)
{
if(i%7==0)
printf("\n");
printf("%d",temporary[i]);
}
printf("\n");
}
//第n次移位运算 得到的结果是压缩置换的输入即两部分经过移位后合在一起
void leftShift(int n)
{
int i;
//保存前两个数据 这里是分成里前后两个部分
int temporary0=temporary[0];
int temporary1=temporary[1];
int temporary28=temporary[28];
int temporary29=temporary[29];
for(i=0;i<28;i++)
{
temporary[i]=temporary[i+shift[n-1]];
if(i>=26)
continue;
temporary[i+28]=temporary[i+shift[n-1]+28];
}
if(shift[n-1]==1)
{
temporary[27]=temporary0;
temporary[55]=temporary28;
}
else if(shift[n-1]==2)
{
temporary[26]=temporary0;
temporary[27]=temporary1;
temporary[54]=temporary28;
temporary[55]=temporary29;
}
printf("\n第%d轮移位后的：",n);
for(i=0;i<56;i++)
{
if(i%7==0)
printf("\n");
printf("%d",temporary[i]);
}
}
//压缩 得到的结果就是密钥Ki
void condenseBinary(int n)
{
int i;
for(i=0;i<48;i++)
{
subKeyBinary[n-1][i]=temporary[condense[i]-1];
}
printf("\n第%d轮子密钥：\n",n);
for(i=0;i<48;i++)
{
if(i%6==0&&i!=0)
printf("\n");
printf("%d",subKeyBinary[n-1][i]);
}
}
//将IP置换后的数据分成两部分Li，Ri 左右分
void divideAfterIP()
{
int i,j,m1=0,m2=0,n=0;
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
{
if(j<4)
lefeLi[m1++]=plaintextBinary[n++];
else
rightRi[m2++]=plaintextBinary[n++];
}
}
printf("\n左右两部分：");
printf("\n左边：\n");
for(i=0;i<32;i++)
{
if(i%4==0&&i!=0)
printf("\n");
printf("%d",lefeLi[i]);
}
printf("\n右边：\n");
for(i=0;i<32;i++)
{
if(i%4==0&&i!=0)
printf("\n");
printf("%d",rightRi[i]);
}
}
//扩展置换
void toExpand()
{
int i;
for(i=0;i<48;i++)
{
expand[i]=rightRi[expands[i]-1];
}
printf("\n扩展置换后：\n");
for(i=0;i<48;i++)
{
if(i%6==0&&i!=0)
printf("\n");
printf("%d",expand[i]);
}
}
//扩展后与密钥异或
void toAfterExpandXor(int n)
{
int i;
for(i=0;i<48;i++)
{
if(expand[i]==subKeyBinary[n-1][i])
xor[i]=0;
else
xor[i]=1;
}
printf("\n第%d轮key：\n",n);
for(i=0;i<48;i++)
{
if(i%6==0&&i!=0)
printf("\n");
printf("%d",subKeyBinary[n-1][i]);
}
printf("\n第%d轮异或：\n",n);
for(i=0;i<48;i++)
{
if(i%6==0&&i!=0)
printf("\n");
printf("%d",xor[i]);
}
}
//S盒置换
void SSSS()
{
int i,j;
int row,col;
int t,a; //临时放S盒中的十进制数
for(i=0;i<8;i++)
{
row=2*xor[6*i]+xor[6*i+5];
col=8*xor[6*i+1]+4*xor[6*i+2]+2*xor[6*i+3]+xor[6*i+4];
switch(i)
{
case 0:t=S1[row][col];break;
case 1:t=S2[row][col];break;
case 2:t=S3[row][col];break;
case 3:t=S4[row][col];break;
case 4:t=S5[row][col];break;
case 5:t=S6[row][col];break;
case 6:t=S7[row][col];break;
case 7:t=S8[row][col];break;
}
printf("\nt=%d",t);
for(j=3;j>=0;j--)
{
a=(int)t%2;
t=t/2;
temp[i*4+j ]=a;
}
}
printf("\ns盒运算后：\n");
for(i=0;i<32;i++)
{
if(i%4==0&&i!=0)
printf("\n");
printf("%d",temp[i]);
}
}
//P盒置换
void PP()
{
int i;
for(i=0;i<32;i++)
{
temp1[i]=temp[PPP[i]-1];
}
printf("\nP置换后：\n");
for(i=0;i<32;i++)
{
if(i%4==0&&i!=0)
printf("\n");
printf("%d",temp1[i]);
}
}
//P盒置换后与Li异或 得到第n轮加密数据
void toAfterPPXor(int n)
{
int i,j,x=0,y1=0,y2=0;
//先把右边的保存下来
for(i=0;i<32;i++)
{
temp[i]=rightRi[i];
}
//P置换的temp与左边异或 直接等于右边作为下一个输出
for(i=0;i<32;i++)
{
if(rightRi[i]==temp1[i])
rightRi[i]=0;
else
rightRi[i]=1;
}
//将保存好的右边数据不做任何处理给左边
for(i=0;i<32;i++)
{
lefeLi[i]=temp[i];
}
//合在一起
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
{
if(j<4)
outputBinary[x++]=lefeLi[y1++];
else
outputBinary[x++]=rightRi[y2++];
}
}
printf("\n第%d轮的加密数据：\n",n);
for(i=0;i<64;i++)
{
if(i%8==0&&i!=0)
printf("\n");
printf("%d",outputBinary[i]);
}
}
int main()
{
int m; //为方便 只能输入英文且为8个以内
int i; //用作循环
char *p;
char *key;
//用户输入的密钥
//可以是64个0 1数字，越随机越安全 为方便直接设置与明文一样的八个字节的英文字母
//超出只取前8个
printf("输入密钥（8个字母或者数字）：");
key=(char*)malloc(10*(sizeof(char)));
memset(key,0,10);
gets(key);
printf("密钥：%s",key);
toKeytBinary(key);
displace();
for(i=0;i<16;i++)
{
leftShift(i+1);
condenseBinary(i+1);
}
//用户输入的要加密的明文
printf("\n你要加密的英文字母或者数字个数（8个以内）：");
scanf("%d",&m);//scanf只是遇到回车符的时候结束，并没有把回车符输入，因此输入流中还有一个回车符
getchar();//把输入流中的回车符读走
p = (char*)malloc(8*(sizeof(char)));//动态申请内存
memset(p,0,8);//初始化，每个元素都为零
for (i=0;i<m; i++)//数组赋值
{
scanf("%c",&p[i]);
}
for (i=0;i<8;i++)//数组赋值
{
printf("%c",p[i]);
}
toPlainTextBinary(Padding(p,m));
IP();
divideAfterIP();
toExpand();
toAfterExpandXor(1);
SSSS();
PP();
toAfterPPXor(1);
free(p);
free(key);
return 0;
}
