加密
算法
1.输入64比特明文，化为二进制进行初始置换
2.输入初始密钥化为二进制进行PC1置换
3.进入16轮循环，首先生成子密钥
4.将PC1置换后的密钥作为第一轮输入，并分为C,D两部分
5.对C,D两部分分别进行左循环移位，然后进行PC2置换得到子密钥，移位后的数据作为下一轮输入重复4，5步
6.子密钥生成后进入轮结构，首先将初始置换后的明文作为第一轮输入，然后将其分为L0,R0左右两部分
7.对右半部分R0进行E扩展运算，然后与子密钥异或，异或后再进行S盒代换压缩，接下来是P置换，置换后与左半异或得到R1
8.将R0赋给L1，L1与R1组合作为下一轮的输入重复6,7,8步
9.16轮循环后将最终结果左右交换并进行逆初始置换，然后化为16进制输出即为密文
初始置换
#include<stdio.h>
#include<string.h>
int main()
{
char str[8];
int i,j,n,a[8],b[64]={},c[64]={};
printf("明文： ");
for(i=0;i<8;i++)
{
scanf("%c",&str[i]);
a[i]=str[i]; //把明文存入数组a[8]
}
for(i=0;i<8;i++) //将明文化为二进制，并存入数组b[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
b[n]=a[i]%2;
a[i]=a[i]/2;
}while(a[i]!=0);
}
printf("二进制： ");
for(i=0;i<64;i++)
{
printf("%d",b[i]);
}
printf(" ");
int sl[16]={}; //将二进制数据16进制化，并存入sl[16]
for(i=0;i<16;i++)
{
sl[i]=b[i*4]*8+b[i*4+1]*4+b[i*4+2]*2+b[i*4+3];
if(sl[i]>=10){
switch(sl[i]){
case 10 : sl[i]='A'; break;
case 11 : sl[i]='B'; break;
case 12 : sl[i]='C'; break;
case 13 : sl[i]='D'; break;
case 14 : sl[i]='E'; break;
case 15 : sl[i]='F'; break;
}
}
}
for(i=0;i<16;i++)
{
if(i==2||i==4||i==6||i==8||i==10||i==12||i==14)
{
if(sl[i]>=10)
printf("-%c",sl[i]);
else
printf("-%d",sl[i]);
}
else
{
if(sl[i]>=10)
printf("%c",sl[i]);
else
printf("%d",sl[i]);
}
}
printf("\n");
printf("初始置换后：");
int IP[8][8]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
{
c[i*8+j]=b[IP[i][j]-1]; //初始置换并将数据存入c[64]
}
}
for(i=0;i<64;i++)
{
printf("%d",c[i]);
}
printf(" ");
int slz[16]={}; //将置换后的数据16进制化
for(i=0;i<16;i++)
{
slz[i]=c[i*4]*8+c[i*4+1]*4+c[i*4+2]*2+c[i*4+3];
if(slz[i]>=10){
switch(slz[i]){
case 10 : slz[i]='A'; break;
case 11 : slz[i]='B'; break;
case 12 : slz[i]='C'; break;
case 13 : slz[i]='D'; break;
case 14 : slz[i]='E'; break;
case 15 : slz[i]='F'; break;
}
}
}
for(i=0;i<16;i++)
{
if(i==2||i==4||i==6||i==8||i==10||i==12||i==14)
{
if(slz[i]>=10)
printf("-%c",slz[i]);
else
printf("-%d",slz[i]);
}
else
{
if(slz[i]>=10)
printf("%c",slz[i]);
else
printf("%d",slz[i]);
}
}
}明文： iloveyou
二进制： 0110100101101100011011110111011001100101011110010110111101110101 69-6C-6F-76-65-79-6F-75
初始置换后：1111111110101000110111101111010100000000111111110110011101001100 FF-A8-DE-F5-00-FF-67-4C
子密钥生成
#include<stdio.h>
#include<string.h>
int main(void)
{
char str[8];
int i,j,n,a[8],b[64]={},c[56]={};
printf("初始密钥： ");
for(i=0;i<8;i++)
{
scanf("%c",&str[i]);
a[i]=str[i]; //把初始密钥存入数组a[8]
}
for(i=0;i<8;i++) //将初始密钥化为二进制，并存入数组b[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
b[n]=a[i]%2;
a[i]=a[i]/2;
}while(a[i]!=0);
}
printf("二进制： ");
for(i=0;i<64;i++)
{
printf("%d",b[i]);
}
printf(" ");
int sl[16]={}; //将二进制数据16进制化，并存入sl[16]
for(i=0;i<16;i++)
{
sl[i]=b[i*4]*8+b[i*4+1]*4+b[i*4+2]*2+b[i*4+3];
if(sl[i]>=10){
switch(sl[i]){
case 10 : sl[i]='A'; break;
case 11 : sl[i]='B'; break;
case 12 : sl[i]='C'; break;
case 13 : sl[i]='D'; break;
case 14 : sl[i]='E'; break;
case 15 : sl[i]='F'; break;
}
}
}
for(i=0;i<16;i++)
{
if(i==2||i==4||i==6||i==8||i==10||i==12||i==14)
{
if(sl[i]>=10)
printf("-%c",sl[i]);
else
printf("-%d",sl[i]);
}
else
{
if(sl[i]>=10)
printf("%c",sl[i]);
else
printf("%d",sl[i]);
}
}
printf("\n");
printf("PC1置换后：");
int PCYT[8][7]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<7;j++)
{
c[i*7+j]=b[PCYT[i][j]-1]; //PC1置换并将数据存入c[56]
}
}
for(i=0;i<56;i++)
{
printf("%d",c[i]);
}
printf(" ");
int slz[14]={}; //将置换后的数据16进制化
for(i=0;i<14;i++)
{
slz[i]=c[i*4]*8+c[i*4+1]*4+c[i*4+2]*2+c[i*4+3];
if(slz[i]>=10){
switch(slz[i]){
case 10 : slz[i]='A'; break;
case 11 : slz[i]='B'; break;
case 12 : slz[i]='C'; break;
case 13 : slz[i]='D'; break;
case 14 : slz[i]='E'; break;
case 15 : slz[i]='F'; break;
}
}
}
for(i=0;i<14;i++)
{
if(i==2||i==4||i==6||i==8||i==10||i==12)
{
if(slz[i]>=10)
printf("-%c",slz[i]);
else
printf("-%d",slz[i]);
}
else
{
if(slz[i]>=10)
printf("%c",slz[i]);
else
printf("%d",slz[i]);
}
}
printf("\n");
int PCET[8][6]={{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}},l[56]={},m[56]={},k[48]={},d[28]={},e[28]={},dl[29]={},el[29]={},dlm[30]={},elm[30]={};
for(i=0;i<56;i++)
m[i]=c[i];
for(i=0;i<16;i++) //16轮循环得到16把子密钥
{
printf("第 %d 轮： ",i+1);
for(j=0;j<56;j++)
{
l[j]=m[j]; //先将c[56]的数据存入移位数组m[56],再将移位组作为下一轮输入
printf("%d",l[j]);
}
printf(" ");
for(j=0;j<14;j++) //将每一轮的输入化为16进制
{
slz[j]=l[j*4]*8+l[j*4+1]*4+l[j*4+2]*2+l[j*4+3];
if(slz[j]>=10){
switch(slz[j]){
case 10 : slz[j]='A'; break;
case 11 : slz[j]='B'; break;
case 12 : slz[j]='C'; break;
case 13 : slz[j]='D'; break;
case 14 : slz[j]='E'; break;
case 15 : slz[j]='F'; break;
}
}
}
for(j=0;j<14;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12)
{
if(slz[j]>=10)
printf("-%c",slz[j]);
else
printf("-%d",slz[j]);
}
else
{
if(slz[j]>=10)
printf("%c",slz[j]);
else
printf("%d",slz[j]);
}
}
printf("\n");
printf("移位后： ");
for(j=0;j<28;j++) //将每一轮的输入的前28位与后28位分成两个数组
{
d[j]=l[j];
e[j]=l[j+28];
}
for(j=0;j<28;j++)
{
dl[j]=d[j];
dlm[j]=d[j];
el[j]=e[j];
elm[j]=e[j];
}
dl[28]=d[0];
el[28]=e[0];
dlm[28]=d[0];
dlm[29]=d[1];
elm[28]=e[0];
elm[29]=e[1];
for(j=0;j<28;j++) //将得到的两个数组分别移位，然后拼接为m[56]
{
if(i+1==1||i+1==2||i+1==9||i+1==16)
{
d[j]=dl[j+1];
e[j]=el[j+1];
}
else
{
d[j]=dlm[j+2];
e[j]=elm[j+2];
}
}
for(j=0;j<28;j++)
{
m[j]=d[j];
m[j+28]=e[j];
}
for(j=0;j<56;j++)
printf("%d",m[j]);
printf(" ");
for(j=0;j<14;j++) //将拼接好的数据化为16进制
{
slz[j]=m[j*4]*8+m[j*4+1]*4+m[j*4+2]*2+m[j*4+3];
if(slz[j]>=10){
switch(slz[j]){
case 10 : slz[j]='A'; break;
case 11 : slz[j]='B'; break;
case 12 : slz[j]='C'; break;
case 13 : slz[j]='D'; break;
case 14 : slz[j]='E'; break;
case 15 : slz[j]='F'; break;
}
}
}
for(j=0;j<14;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12)
{
if(slz[j]>=10)
printf("-%c",slz[j]);
else
printf("-%d",slz[j]);
}
else
{
if(slz[j]>=10)
printf("%c",slz[j]);
else
printf("%d",slz[j]);
}
}
printf("\n");
printf("PC2置换后：");
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
k[n*6+j]=m[PCET[n][j]-1]; //PC2置换，将置换好的数据存入k[48]
}
}
for(j=0;j<48;j++)
{
printf("%d",k[j]);
}
printf(" ");
int ezsl[12]={};
for(j=0;j<12;j++) // 将子密钥化为16进制
{
ezsl[j]=k[j*4]*8+k[j*4+1]*4+k[j*4+2]*2+k[j*4+3];
if(ezsl[j]>=10){
switch(ezsl[j]){
case 10 : ezsl[j]='A'; break;
case 11 : ezsl[j]='B'; break;
case 12 : ezsl[j]='C'; break;
case 13 : ezsl[j]='D'; break;
case 14 : ezsl[j]='E'; break;
case 15 : ezsl[j]='F'; break;
}
}
}
for(j=0;j<12;j++)
{
if(j==2||j==4||j==6||j==8||j==10)
{
if(ezsl[j]>=10)
printf("-%c",ezsl[j]);
else
printf("-%d",ezsl[j]);
}
else
{
if(ezsl[j]>=10)
printf("%c",ezsl[j]);
else
printf("%d",ezsl[j]);
}
}
printf("\n");
}
}初始密钥： 12345678
二进制： 0011000100110010001100110011010000110101001101100011011100111000 31-32-33-34-35-36-37-38
PC1置换后：00000000000000001111111111110110011001111000100000001111 00-00-FF-F6-67-88-0F
第 1 轮： 00000000000000001111111111110110011001111000100000001111 00-00-FF-F6-67-88-0F
移位后： 00000000000000011111111111101100110011110001000000011110 00-01-FF-EC-CF-10-1E
PC2置换后：010100000010110010101100010101110010101011000010 50-2C-AC-57-2A-C2
第 2 轮： 00000000000000011111111111101100110011110001000000011110 00-01-FF-EC-CF-10-1E
移位后： 00000000000000111111111111001001100111100010000000111101 00-03-FF-C9-9E-20-3D
PC2置换后：010100001010110010100100010100001010001101000111 50-AC-A4-50-A3-47
第 3 轮： 00000000000000111111111111001001100111100010000000111101 00-03-FF-C9-9E-20-3D
移位后： 00000000000011111111111100000110011110001000000011110110 00-0F-FF-06-78-80-F6
PC2置换后：110100001010110000100110111101101000010010001100 D0-AC-26-F6-84-8C
第 4 轮： 00000000000011111111111100000110011110001000000011110110 00-0F-FF-06-78-80-F6
移位后： 00000000001111111111110000001001111000100000001111011001 00-3F-FC-09-E2-03-D9
PC2置换后：111000001010011000100110010010000011011111001011 E0-A6-26-48-37-CB
第 5 轮： 00000000001111111111110000001001111000100000001111011001 00-3F-FC-09-E2-03-D9
移位后： 00000000111111111111000000000111100010000000111101100110 00-FF-F0-07-88-0F-66
PC2置换后：111000001001011000100110001111101111000000101001 E0-96-26-3E-F0-29
第 6 轮： 00000000111111111111000000000111100010000000111101100110 00-FF-F0-07-88-0F-66
移位后： 00000011111111111100000000001110001000000011110110011001 03-FF-C0-0E-20-3D-99
PC2置换后：111000001001001001110010011000100101110101100010 E0-92-72-62-5D-62
第 7 轮： 00000011111111111100000000001110001000000011110110011001 03-FF-C0-0E-20-3D-99
移位后： 00001111111111110000000000001000100000001111011001100111 0F-FF-00-08-80-F6-67
PC2置换后：101001001101001001110010100011001010100100111010 A4-D2-72-8C-A9-3A
第 8 轮： 00001111111111110000000000001000100000001111011001100111 0F-FF-00-08-80-F6-67
移位后： 00111111111111000000000000000010000000111101100110011110 3F-FC-00-02-03-D9-9E
PC2置换后：101001100101001101010010111001010101111001010000 A6-53-52-E5-5E-50
第 9 轮： 00111111111111000000000000000010000000111101100110011110 3F-FC-00-02-03-D9-9E
移位后： 01111111111110000000000000000100000001111011001100111100 7F-F8-00-04-07-B3-3C
PC2置换后：001001100101001101010011110010111001101001000000 26-53-53-CB-9A-40
第 10 轮： 01111111111110000000000000000100000001111011001100111100 7F-F8-00-04-07-B3-3C
移位后： 11111111111000000000000000010000000111101100110011110001 FF-E0-00-10-1E-CC-F1
PC2置换后：001011110101000101010001110100001100011100111100 2F-51-51-D0-C7-3C
第 11 轮： 11111111111000000000000000010000000111101100110011110001 FF-E0-00-10-1E-CC-F1
移位后： 11111111100000000000000001110000011110110011001111000100 FF-80-00-70-7B-33-C4
PC2置换后：000011110100000111011001000110010001111010001100 0F-41-D9-19-1E-8C
第 12 轮： 11111111100000000000000001110000011110110011001111000100 FF-80-00-70-7B-33-C4
移位后： 11111110000000000000000111110001111011001100111100010000 FE-00-01-F1-EC-CF-10
PC2置换后：000111110100000110011001110110000111000010110001 1F-41-99-D8-70-B1
第 13 轮： 11111110000000000000000111110001111011001100111100010000 FE-00-01-F1-EC-CF-10
移位后： 11111000000000000000011111110111101100110011110001000000 F8-00-07-F7-B3-3C-40
PC2置换后：000111110000100110001001001000110110101000101101 1F-09-89-23-6A-2D
第 14 轮： 11111000000000000000011111110111101100110011110001000000 F8-00-07-F7-B3-3C-40
移位后： 11100000000000000001111111111110110011001111000100000001 E0-00-1F-FE-CC-F1-01
PC2置换后：000110110010100010001101101100100011100110010010 1B-28-8D-B2-39-92
第 15 轮： 11100000000000000001111111111110110011001111000100000001 E0-00-1F-FE-CC-F1-01
移位后： 10000000000000000111111111111011001100111100010000000111 80-00-7F-FB-33-C4-07
PC2置换后：000110010010110010001100101001010000001100110111 19-2C-8C-A5-03-37
第 16 轮： 10000000000000000111111111111011001100111100010000000111 80-00-7F-FB-33-C4-07
移位后： 00000000000000001111111111110110011001111000100000001111 00-00-FF-F6-67-88-0F
PC2置换后：010100010010110010001100101001110100001111000000 51-2C-8C-A7-43-C0
轮结构
#include<stdio.h>
#include<string.h>
int main(void)
{
char str1[8];
int i,j,n,wa[8],wb[64]={},mw[64]={},my[56]={},ll[64]={}; //ll作为明文轮结构每一轮的开始，后续的lr是密钥的每一轮的开始
printf("明文： ");
for(i=0;i<8;i++)
{
scanf("%c",&str1[i]);
wa[i]=str1[i]; //把明文存入数组wa[8]
}
for(i=0;i<8;i++) //将明文化为二进制，并存入数组wb[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
wb[n]=wa[i]%2;
wa[i]=wa[i]/2;
}while(wa[i]!=0);
}
int IP[8][8]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
{
mw[i*8+j]=wb[IP[i][j]-1]; //初始置换并将数据存入mw[64]
}
}
char str2[8];
int ya[8],yb[64]={};
printf("初始密钥： ");
while(getchar()!='\n'); //吸收掉第一个scanf留下的空格
for(i=0;i<8;i++) //把初始密钥存入数组ya[8]
{
scanf("%c",&str2[i]);
ya[i]=str2[i];
}
for(i=0;i<8;i++) //将初始密钥化为二进制，并存入数组yb[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
yb[n]=ya[i]%2;
ya[i]=ya[i]/2;
}while(ya[i]!=0);
}
int PCYT[8][7]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<7;j++)
{
my[i*7+j]=yb[PCYT[i][j]-1]; //PC1置换并将数据存入my[56]
}
}
int PCET[8][6]={{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}},lr[56]={},m[56]={},k[48]={},c[28]={},d[28]={},cl[29]={},dl[29]={},clm[30]={},dlm[30]={};
for(i=0;i<56;i++)
m[i]=my[i]; //循环移位是每一轮密钥的输入
int rrekspl[64]={};
for(i=0;i<64;i++)
rrekspl[i]=mw[i]; //rrekspl作为轮结构每一轮的输入
for(i=0;i<16;i++) //16轮循环得到16把子密钥
{
printf("第 %d 轮： ",i+1);
for(j=0;j<56;j++)
lr[j]=m[j];
for(j=0;j<28;j++) //将每一轮的输入的前28位与后28位分成两个数组
{
c[j]=lr[j];
d[j]=lr[j+28];
}
for(j=0;j<28;j++)
{
cl[j]=c[j];
clm[j]=c[j];
dl[j]=d[j];
dlm[j]=d[j];
}
cl[28]=c[0];
dl[28]=d[0];
clm[28]=c[0];
clm[29]=c[1];
dlm[28]=d[0];
dlm[29]=d[1];
for(j=0;j<28;j++) //将得到的两个数组分别移位，然后拼接为m[56]
{
if(i+1==1||i+1==2||i+1==9||i+1==16)
{
c[j]=cl[j+1];
d[j]=dl[j+1];
}
else
{
c[j]=clm[j+2];
d[j]=dlm[j+2];
}
}
for(j=0;j<28;j++)
{
m[j]=c[j];
m[j+28]=d[j];
}
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
k[n*6+j]=m[PCET[n][j]-1]; //PC2置换，将置换好的数据存入k[48]
}
}
for(j=0;j<64;j++) //将初始置换后的明文存入ll[64]
{
ll[j]=rrekspl[j];
printf("%d",ll[j]);
}
printf(" ");
int sl[16]={}; //将二进制数据16进制化，并存入sl[16]
for(j=0;j<16;j++)
{
sl[j]=ll[j*4]*8+ll[j*4+1]*4+ll[j*4+2]*2+ll[j*4+3];
if(sl[j]>=10){
switch(sl[j]){
case 10 : sl[j]='A'; break;
case 11 : sl[j]='B'; break;
case 12 : sl[j]='C'; break;
case 13 : sl[j]='D'; break;
case 14 : sl[j]='E'; break;
case 15 : sl[j]='F'; break;
}
}
}
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(sl[j]>=10)
printf("-%c",sl[j]);
else
printf("-%d",sl[j]);
}
else
{
if(sl[j]>=10)
printf("%c",sl[j]);
else
printf("%d",sl[j]);
}
}
printf("\n");
printf("扩展后：");
int l[32]={},r[32]={},re[48]={},lre[80]={},rek[48]={},lrek[80]={};
for(j=0;j<32;j++)
{
l[j]=ll[j]; //将ll分为l和r两部分
r[j]=ll[j+32];
}
int e[8][6]={{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}};
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
re[n*6+j]=r[e[n][j]-1]; //右边部分进行扩展运算得到re
}
}
for(j=0;j<32;j++)
{
lre[j]=l[j];
lre[j+32]=re[j]; //扩展后与左半组合得到lre
}
for(j=0;j<16;j++)
lre[j+64]=re[j+32];
for(j=0;j<80;j++)
printf("%d",lre[j]);
printf(" ");
int lresl[20]={};
for(j=0;j<20;j++)
{
lresl[j]=lre[j*4]*8+lre[j*4+1]*4+lre[j*4+2]*2+lre[j*4+3]; //lre16进制化
if(lresl[j]>=10){
switch(lresl[j]){
case 10 : lresl[j]='A'; break;
case 11 : lresl[j]='B'; break;
case 12 : lresl[j]='C'; break;
case 13 : lresl[j]='D'; break;
case 14 : lresl[j]='E'; break;
case 15 : lresl[j]='F'; break;
}
}
}
for(j=0;j<20;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14||j==16||j==18)
{
if(lresl[j]>=10)
printf("-%c",lresl[j]);
else
printf("-%d",lresl[j]);
}
else
{
if(lresl[j]>=10)
printf("%c",lresl[j]);
else
printf("%d",lresl[j]);
}
}
printf("\n");
printf("与子密钥异或后：");
for(j=0;j<48;j++)
{
rek[j]=re[j]^k[j]; //re与子密钥异或得到rek
}
for(j=0;j<32;j++)
{
lrek[j]=l[j];
lrek[j+32]=rek[j];
}
for(j=0;j<16;j++)
lrek[j+64]=rek[j+32];
for(j=0;j<80;j++)
printf("%d",lrek[j]);
printf("\n");
printf(" ");
int lreksl[20]={};
for(j=0;j<20;j++)
{
lreksl[j]=lrek[j*4]*8+lrek[j*4+1]*4+lrek[j*4+2]*2+lrek[j*4+3];
if(lreksl[j]>=10){
switch(lreksl[j]){
case 10 : lreksl[j]='A'; break;
case 11 : lreksl[j]='B'; break;
case 12 : lreksl[j]='C'; break;
case 13 : lreksl[j]='D'; break;
case 14 : lreksl[j]='E'; break;
case 15 : lreksl[j]='F'; break;
}
}
}
for(j=0;j<20;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14||j==16||j==18)
{
if(lreksl[j]>=10)
printf("-%c",lreksl[j]);
else
printf("-%d",lreksl[j]);
}
else
{
if(lreksl[j]>=10)
printf("%c",lreksl[j]);
else
printf("%d",lreksl[j]);
}
}
printf("\n");
printf("S代换盒压缩后：");
int son[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 stw[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 sth[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 sfo[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 sfi[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 ssi[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 sse[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 sei[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}};
int z,slf[16]={},smf[32]={},slfs[8]={},smfs[8]={},rekss[8]={},reks[32]={},lreks[64]={},lrekssl[16]={};
for(j=0;j<8;j++)
{
slf[2*j]=rek[j*6]; //z类似与i，slf存六位数的前后两位
slf[2*j+1]=rek[j*6+5];
}
for(j=0;j<8;j++)
{
for(n=0;n<4;n++)
{
smf[j*4+n]=rek[j*6+n+1]; //smf存六位数的中间四位
}
}
for(j=0;j<8;j++)
{
slfs[j]=slf[2*j]*2+slf[2*j+1];
smfs[j]=smf[4*j]*8+smf[4*j+1]*4+smf[4*j+2]*2+smf[4*j+3]; //将这两个数组化为十进制
}
rekss[0]=son[slfs[0]][smfs[0]];
rekss[1]=stw[slfs[1]][smfs[1]];
rekss[2]=sth[slfs[2]][smfs[2]];
rekss[3]=sfo[slfs[3]][smfs[3]];
rekss[4]=sfi[slfs[4]][smfs[4]]; //rekss存S盒里的十进制数,slfs对应行,smfs对应列
rekss[5]=ssi[slfs[5]][smfs[5]];
rekss[6]=sse[slfs[6]][smfs[6]];
rekss[7]=sei[slfs[7]][smfs[7]];
for(z=0;z<8;z++)
{
j=4;
do
{
j=j-1;
n=4*z+j;
reks[n]=rekss[z]%2;
rekss[z]=rekss[z]/2; //化为二进制存入reks
}while(rekss[z]!=0);
}
for(j=0;j<32;j++)
{
lreks[j]=l[j];
lreks[j+32]=reks[j];
}
for(j=0;j<64;j++)
printf("%d",lreks[j]);
printf(" ");
for(j=0;j<16;j++)
{
lrekssl[j]=lreks[j*4]*8+lreks[j*4+1]*4+lreks[j*4+2]*2+lreks[j*4+3];
if(lrekssl[j]>=10){
switch(lrekssl[j]){
case 10 : lrekssl[j]='A'; break;
case 11 : lrekssl[j]='B'; break;
case 12 : lrekssl[j]='C'; break;
case 13 : lrekssl[j]='D'; break;
case 14 : lrekssl[j]='E'; break;
case 15 : lrekssl[j]='F'; break;
}
}
}
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(lrekssl[j]>=10)
printf("-%c",lrekssl[j]);
else
printf("-%d",lrekssl[j]);
}
else
{
if(lrekssl[j]>=10)
printf("%c",lrekssl[j]);
else
printf("%d",lrekssl[j]);
}
}
printf("\n");
printf("置换P后： ");
int p[8][4]={{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}},reksp[32]={},lreksp[64]={},lrekspsl[16]={};
for(n=0;n<8;n++)
{
for(j=0;j<4;j++)
{
reksp[n*4+j]=reks[p[n][j]-1]; //置换P并将数据存入reksp[32]
}
}
for(j=0;j<32;j++)
{
lreksp[j]=l[j];
lreksp[j+32]=reksp[j];
}
for(j=0;j<64;j++)
printf("%d",lreksp[j]);
printf(" ");
for(j=0;j<16;j++)
{
lrekspsl[j]=lreksp[j*4]*8+lreksp[j*4+1]*4+lreksp[j*4+2]*2+lreksp[j*4+3];
if(lrekspsl[j]>=10){
switch(lrekspsl[j]){
case 10 : lrekspsl[j]='A'; break;
case 11 : lrekspsl[j]='B'; break;
case 12 : lrekspsl[j]='C'; break;
case 13 : lrekspsl[j]='D'; break;
case 14 : lrekspsl[j]='E'; break;
case 15 : lrekspsl[j]='F'; break;
}
}
}
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(lrekspsl[j]>=10)
printf("-%c",lrekspsl[j]);
else
printf("-%d",lrekspsl[j]);
}
else
{
if(lrekspsl[j]>=10)
printf("%c",lrekspsl[j]);
else
printf("%d",lrekspsl[j]);
}
}
printf("\n");
printf("与左半异或后：");
int rekspl[32]={},lrekspl[64]={},lreksplsl[16]={};
for(j=0;j<32;j++)
{
rekspl[j]=reksp[j]^l[j]; //与左半异或得到rekspl
}
for(j=0;j<32;j++)
{
lrekspl[j]=l[j];
lrekspl[j+32]=rekspl[j];
}
for(j=0;j<64;j++)
printf("%d",lrekspl[j]);
printf(" ");
for(j=0;j<16;j++)
{
lreksplsl[j]=lrekspl[j*4]*8+lrekspl[j*4+1]*4+lrekspl[j*4+2]*2+lrekspl[j*4+3];
if(lreksplsl[j]>=10){
switch(lreksplsl[j]){
case 10 : lreksplsl[j]='A'; break;
case 11 : lreksplsl[j]='B'; break;
case 12 : lreksplsl[j]='C'; break;
case 13 : lreksplsl[j]='D'; break;
case 14 : lreksplsl[j]='E'; break;
case 15 : lreksplsl[j]='F'; break;
}
}
}
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(lreksplsl[j]>=10)
printf("-%c",lreksplsl[j]);
else
printf("-%d",lreksplsl[j]);
}
else
{
if(lreksplsl[j]>=10)
printf("%c",lreksplsl[j]);
else
printf("%d",lreksplsl[j]);
}
}
printf("\n");
for(j=0;j<32;j++)
l[j]=r[j]; //最开始的右半给左半，将异或后的给右半，再组合作为下一轮输入
for(j=0;j<32;j++)
r[j]=rekspl[j];
for(j=0;j<32;j++)
{
rrekspl[j]=l[j];
rrekspl[j+32]=r[j];
}
}
printf("\n");
printf("16轮的输出结果：");
int rreksplsl[16]={};
for(i=0;i<64;i++)
printf("%d",rrekspl[i]);
printf(" ");
for(j=0;j<16;j++)
{
rreksplsl[j]=rrekspl[j*4]*8+rrekspl[j*4+1]*4+rrekspl[j*4+2]*2+rrekspl[j*4+3];
if(rreksplsl[j]>=10){
switch(rreksplsl[j]){
case 10 : rreksplsl[j]='A'; break;
case 11 : rreksplsl[j]='B'; break;
case 12 : rreksplsl[j]='C'; break;
case 13 : rreksplsl[j]='D'; break;
case 14 : rreksplsl[j]='E'; break;
case 15 : rreksplsl[j]='F'; break;
}
}
}
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(rreksplsl[j]>=10)
printf("-%c",rreksplsl[j]);
else
printf("-%d",rreksplsl[j]);
}
else
{
if(rreksplsl[j]>=10)
printf("%c",rreksplsl[j]);
else
printf("%d",rreksplsl[j]);
}
}
printf("\n");
printf("左右交换后： ");
int jh[64]={},jhsl[16]={};
for(i=0;i<32;i++)
{
jh[i]=rrekspl[i+32]; //将最终结果左右交换
jh[i+32]=rrekspl[i];
}
for(i=0;i<64;i++)
printf("%d",jh[i]);
printf(" ");
for(j=0;j<16;j++)
{
jhsl[j]=jh[j*4]*8+jh[j*4+1]*4+jh[j*4+2]*2+jh[j*4+3];
if(jhsl[j]>=10){
switch(jhsl[j]){
case 10 : jhsl[j]='A'; break;
case 11 : jhsl[j]='B'; break;
case 12 : jhsl[j]='C'; break;
case 13 : jhsl[j]='D'; break;
case 14 : jhsl[j]='E'; break;
case 15 : jhsl[j]='F'; break;
}
}
}
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(jhsl[j]>=10)
printf("-%c",jhsl[j]);
else
printf("-%d",jhsl[j]);
}
else
{
if(jhsl[j]>=10)
printf("%c",jhsl[j]);
else
printf("%d",jhsl[j]);
}
}
}明文： iloveyou
初始密钥： 12345678
第 1 轮： 1111111110101000110111101111010100000000111111110110011101001100 FF-A8-DE-F5-00-FF-67-4C
扩展后：11111111101010001101111011110101000000000001011111111110101100001110101001011000 FF-A8-DE-F5-00-17-FE-B0-EA-58
与子密钥异或后：11111111101010001101111011110101010100000011101101010010111001111100000010011010
FF-A8-DE-F5-50-3B-52-E7-C0-9A
S代换盒压缩后：1111111110101000110111101111010101101101100000101010101110110000 FF-A8-DE-F5-6D-82-AB-B0
置换P后： 1111111110101000110111101111010100010011011010001110011110010001 FF-A8-DE-F5-13-68-E7-91
与左半异或后：1111111110101000110111101111010111101100110000000011100101100100 FF-A8-DE-F5-EC-C0-39-64
第 2 轮： 0000000011111111011001110100110011101100110000000011100101100100 00-FF-67-4C-EC-C0-39-64
扩展后：00000000111111110110011101001100011101011001011000000000000111110010101100001001 00-FF-67-4C-75-96-00-1F-2B-09
与子密钥异或后：00000000111111110110011101001100001001010011101010100100010011111000100001001110
00-FF-67-4C-25-3A-A4-4F-88-4E
S代换盒压缩后：0000000011111111011001110100110011100000111110010000000101100001 00-FF-67-4C-E0-F9-01-61
置换P后： 0000000011111111011001110100110010000100100100011010111101000100 00-FF-67-4C-84-91-AF-44
与左半异或后：0000000011111111011001110100110010000100011011101100100000001000 00-FF-67-4C-84-6E-C8-08
第 3 轮： 1110110011000000001110010110010010000100011011101100100000001000 EC-C0-39-64-84-6E-C8-08
扩展后：11101100110000000011100101100100010000001000001101011101011001010000000001010001 EC-C0-39-64-40-83-5D-65-00-51
与子密钥异或后：11101100110000000011100101100100100100000010111101111011100100111000010011011101
EC-C0-39-64-90-2F-7B-93-84-DD
S代换盒压缩后：1110110011000000001110010110010011100001001001110001000100111001 EC-C0-39-64-E1-27-11-39
置换P后： 1110110011000000001110010110010010101010110000001111111000000100 EC-C0-39-64-AA-C0-FE-04
与左半异或后：1110110011000000001110010110010001000110000000001100011101100000 EC-C0-39-64-46-00-C7-60
第 4 轮： 1000010001101110110010000000100001000110000000001100011101100000 84-6E-C8-08-46-00-C7-60
扩展后：10000100011011101100100000001000001000001100000000000001011000001110101100000000 84-6E-C8-08-20-C0-01-60-EB-00
与子密钥异或后：10000100011011101100100000001000110000000110011000100111001010001101110011001011
84-6E-C8-08-C0-66-27-28-DC-CB
S代换盒压缩后：1000010001101110110010000000100011111110101101101010100101010011 84-6E-C8-08-FE-B6-A9-53
置换P后： 1000010001101110110010000000100001010111110110101011101110010110 84-6E-C8-08-57-DA-BB-96
与左半异或后：1000010001101110110010000000100011010011101101000111001110011110 84-6E-C8-08-D3-B4-73-9E
第 5 轮： 0100011000000000110001110110000011010011101101000111001110011110 46-00-C7-60-D3-B4-73-9E
扩展后：01000110000000001100011101100000011010100111110110101000001110100111110011111101 46-00-C7-60-6A-7D-A8-3A-7C-FD
与子密钥异或后：01000110000000001100011101100000100010101110101110001110000001001000110011010100
46-00-C7-60-8A-EB-8E-04-8C-D4
S代换盒压缩后：0100011000000000110001110110000000010001000010101110100101010011 46-00-C7-60-11-0A-E9-53
置换P后： 0100011000000000110001110110000000010011010101100110100011000010 46-00-C7-60-13-56-68-C2
与左半异或后：0100011000000000110001110110000001010101010101101010111110100010 46-00-C7-60-55-56-AF-A2
第 6 轮： 1101001110110100011100111001111001010101010101101010111110100010 D3-B4-73-9E-55-56-AF-A2
扩展后：11010011101101000111001110011110001010101010101010101101010101011111110100000100 D3-B4-73-9E-2A-AA-AD-55-FD-04
与子密钥异或后：11010011101101000111001110011110110010100011100011011111001101111010000001100110
D3-B4-73-9E-CA-38-DF-37-A0-66
S代换盒压缩后：1101001110110100011100111001111011001000101010011101110111010001 D3-B4-73-9E-C8-A9-DD-D1
置换P后： 1101001110110100011100111001111010110011100111001010100101001101 D3-B4-73-9E-B3-9C-A9-4D
与左半异或后：1101001110110100011100111001111001100000001010001101101011010011 D3-B4-73-9E-60-28-DA-D3
第 7 轮： 0101010101010110101011111010001001100000001010001101101011010011 55-56-AF-A2-60-28-DA-D3
扩展后：01010101010101101010111110100010101100000000000101010001011011110101011010100110 55-56-AF-A2-B0-01-51-6F-56-A6
与子密钥异或后：01010101010101101010111110100010000101001101001100100011111000111111111110011100
55-56-AF-A2-14-D3-23-E3-FF-9C
S代换盒压缩后：0101010101010110101011111010001001111000111111110110110100101100 55-56-AF-A2-78-FF-6D-2C
置换P后： 0101010101010110101011111010001010011100010011011011011111101110 55-56-AF-A2-9C-4D-B7-EE
与左半异或后：0101010101010110101011111010001011001001000110110001100001001100 55-56-AF-A2-C9-1B-18-4C
第 8 轮： 0110000000101000110110101101001111001001000110110001100001001100 60-28-DA-D3-C9-1B-18-4C
扩展后：01100000001010001101101011010011011001010010100011110110100011110000001001011001 60-28-DA-D3-65-28-F6-8F-02-59
与子密钥异或后：01100000001010001101101011010011110000110111101110100100011010100101110000001001
60-28-DA-D3-C3-7B-A4-6A-5C-09
S代换盒压缩后：0110000000101000110110101101001111111100000010010000001010101010 60-28-DA-D3-FC-09-02-AA
置换P后： 0110000000101000110110101101001110001000101010101000011001010011 60-28-DA-D3-88-AA-86-53
与左半异或后：0110000000101000110110101101001111101000100000100101110010000000 60-28-DA-D3-E8-82-5C-80
第 9 轮： 1100100100011011000110000100110011101000100000100101110010000000 C9-1B-18-4C-E8-82-5C-80
扩展后：11001001000110110001100001001100011101010001010000000100001011111001010000000001 C9-1B-18-4C-75-14-04-2F-94-01
与子密钥异或后：11001001000110110001100001001100010100110100011101010111111001000000111001000001
C9-1B-18-4C-53-47-57-E4-0E-41
S代换盒压缩后：1100100100011011000110000100110001101100111111001010110011100001 C9-1B-18-4C-6C-FC-AC-E1
置换P后： 1100100100011011000110000100110000010101000110011001111111011101 C9-1B-18-4C-15-19-9F-DD
与左半异或后：1100100100011011000110000100110011011100000000101000011110010001 C9-1B-18-4C-DC-02-87-91
第 10 轮： 1110100010000010010111001000000011011100000000101000011110010001 E8-82-5C-80-DC-02-87-91
扩展后：11101000100000100101110010000000111011111000000000000101010000001111110010100011 E8-82-5C-80-EF-80-05-40-FC-A3
与子密钥异或后：11101000100000100101110010000000110000001101000101010100100100000011101110011111
E8-82-5C-80-C0-D1-54-90-3B-9F
S代换盒压缩后：1110100010000010010111001000000011111000000010000001111111100010 E8-82-5C-80-F8-08-1F-E2
置换P后： 1110100010000010010111001000000000110000101110101010011001001011 E8-82-5C-80-30-BA-A6-4B
与左半异或后：1110100010000010010111001000000011011000001110001111101011001011 E8-82-5C-80-D8-38-FA-CB
第 11 轮： 1101110000000010100001111001000111011000001110001111101011001011 DC-02-87-91-D8-38-FA-CB
扩展后：11011100000000101000011110010001111011110000000111110001011111110101011001010111 DC-02-87-91-EF-01-F1-7F-56-57
与子密钥异或后：11011100000000101000011110010001111000000100000000101000011001100100100011011011
DC-02-87-91-E0-40-28-66-48-DB
S代换盒压缩后：1101110000000010100001111001000100111000101011000011111110111110 DC-02-87-91-38-AC-3F-BE
置换P后： 1101110000000010100001111001000100111010001010100011011111101111 DC-02-87-91-3A-2A-37-EF
与左半异或后：1101110000000010100001111001000111100110001010001011000001111110 DC-02-87-91-E6-28-B0-7E
第 12 轮： 1101100000111000111110101100101111100110001010001011000001111110 D8-38-FA-CB-E6-28-B0-7E
扩展后：11011000001110001111101011001011011100001100000101010001010110100000001111111101 D8-38-FA-CB-70-C1-51-5A-03-FD
与子密钥异或后：11011000001110001111101011001011011011111000000011001000100000100111001101001100
D8-38-FA-CB-6F-80-C8-82-73-4C
S代换盒压缩后：1101100000111000111110101100101101011001011100000100110000011011 D8-38-FA-CB-59-70-4C-1B
置换P后： 1101100000111000111110101100101100011110000011111100100000001110 D8-38-FA-CB-1E-0F-C8-0E
与左半异或后：1101100000111000111110101100101111000110001101110011001011000101 D8-38-FA-CB-C6-37-32-C5
第 13 轮： 1110011000101000101100000111111011000110001101110011001011000101 E6-28-B0-7E-C6-37-32-C5
扩展后：11100110001010001011000001111110111000001100000110101110100110100101011000001011 E6-28-B0-7E-E0-C1-AE-9A-56-0B
与子密钥异或后：11100110001010001011000001111110111111111100100000100111101110010011110000100110
E6-28-B0-7E-FF-C8-27-B9-3C-26
S代换盒压缩后：1110011000101000101100000111111011010010110101101000000110100001 E6-28-B0-7E-D2-D6-81-A1
置换P后： 1110011000101000101100000111111001000101110000011011110100000011 E6-28-B0-7E-45-C1-BD-03
与左半异或后：1110011000101000101100000111111010100011111010010000110101111101 E6-28-B0-7E-A3-E9-0D-7D
第 14 轮： 1100011000110111001100101100010110100011111010010000110101111101 C6-37-32-C5-A3-E9-0D-7D
扩展后：11000110001101110011001011000101110100000111111101010010100001011010101111111011 C6-37-32-C5-D0-7F-52-85-AB-FB
与子密钥异或后：11000110001101110011001011000101110010110101011111011111001101111001001001101001
C6-37-32-C5-CB-57-DF-37-92-69
S代换盒压缩后：1100011000110111001100101100010111000111000110011101011001000100 C6-37-32-C5-C7-19-D6-44
置换P后： 1100011000110111001100101100010111100101101101001100000001111000 C6-37-32-C5-E5-B4-C0-78
与左半异或后：1100011000110111001100101100010100100011100000111111001010111101 C6-37-32-C5-23-83-F2-BD
第 15 轮： 1010001111101001000011010111110100100011100000111111001010111101 A3-E9-0D-7D-23-83-F2-BD
扩展后：10100011111010010000110101111101100100000111110000000111111110100101010111111010 A3-E9-0D-7D-90-7C-07-FA-55-FA
与子密钥异或后：10100011111010010000110101111101100010010101000010001011010111110101011011001101
A3-E9-0D-7D-89-50-8B-5F-56-CD
S代换盒压缩后：1010001111101001000011010111110100010001000011111010000111110111 A3-E9-0D-7D-11-0F-A1-F7
置换P后： 1010001111101001000011010111110110000011010100100111110011100011 A3-E9-0D-7D-83-52-7C-E3
与左半异或后：1010001111101001000011010111110100100000101110110111000110011110 A3-E9-0D-7D-20-BB-71-9E
第 16 轮： 0010001110000011111100101011110100100000101110110111000110011110 23-83-F2-BD-20-BB-71-9E
扩展后：00100011100000111111001010111101000100000001010111110110101110100011110011111100 23-83-F2-BD-10-15-F6-BA-3C-FC
与子密钥异或后：00100011100000111111001010111101010000010011100101111010000111010111111100111100
23-83-F2-BD-41-39-7A-1D-7F-3C
S代换盒压缩后：0010001110000011111100101011110100110000110100101100111010010101 23-83-F2-BD-30-D2-CE-95
置换P后： 0010001110000011111100101011110100010111011001010000101100101011 23-83-F2-BD-17-65-0B-2B
与左半异或后：0010001110000011111100101011110100110100111001101111100110010110 23-83-F2-BD-34-E6-F9-96
16轮的输出结果：0010000010111011011100011001111000110100111001101111100110010110 20-BB-71-9E-34-E6-F9-96
左右交换后： 0011010011100110111110011001011000100000101110110111000110011110 34-E6-F9-96-20-BB-71-9E
逆初始置换
与初始置换原理相同
加密代码实现
#include<stdio.h>
#include<string.h>
int main(void)
{
char str1[8];
int i,j,n,wa[8],wb[64]={},mw[64]={},my[56]={};
printf("明文： ");
for(i=0;i<8;i++)
{
scanf("%c",&str1[i]);
wa[i]=str1[i]; //把明文存入数组wa[8]
}
for(i=0;i<8;i++) //将明文化为二进制，并存入数组wb[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
wb[n]=wa[i]%2;
wa[i]=wa[i]/2;
}while(wa[i]!=0);
}
int IP[8][8]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
{
mw[i*8+j]=wb[IP[i][j]-1]; //初始置换并将数据存入mw[64]
}
}
char str2[8];
int ya[8],yb[64]={};
printf("初始密钥：");
while(getchar()!='\n'); //getchar吸收掉上一个scanf留在缓冲区的空格
for(i=0;i<8;i++) //把初始密钥存入数组ya[8]
{
scanf("%c",&str2[i]);
ya[i]=str2[i];
}
for(i=0;i<8;i++) //将初始密钥化为二进制，并存入数组yb[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
yb[n]=ya[i]%2;
ya[i]=ya[i]/2;
}while(ya[i]!=0);
}
int PCYT[8][7]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<7;j++)
{
my[i*7+j]=yb[PCYT[i][j]-1]; //PC1置换并将密钥存入my[56]
}
}
int PCET[8][6]={{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}},ll[64]={},lr[56]={},m[56]={},k[48]={},c[28]={},d[28]={},cl[29]={},dl[29]={},clm[30]={},dlm[30]={};
for(i=0;i<56;i++)
m[i]=my[i]; //ll为轮结构每一轮的输入，lr为子密钥生成循环结构每一轮的输入，m存放循环移位后的值，k存放子密钥
int rrekspl[64]={}; //rrekspl为轮结构每一轮的输入，在下文会赋给ll，同时也是每一轮最后得到的结果
for(i=0;i<64;i++)
rrekspl[i]=mw[i];
for(i=0;i<16;i++) //16轮循环得到16把子密钥 这里是子密钥生成循环体
{
for(j=0;j<56;j++)
lr[j]=m[j];
for(j=0;j<28;j++) //将每一轮的输入的前28位与后28位分成两个数组
{
c[j]=lr[j];
d[j]=lr[j+28];
}
for(j=0;j<28;j++)
{
cl[j]=c[j];
clm[j]=c[j];
dl[j]=d[j];
dlm[j]=d[j];
}
cl[28]=c[0];
dl[28]=d[0];
clm[28]=c[0];
clm[29]=c[1];
dlm[28]=d[0];
dlm[29]=d[1];
for(j=0;j<28;j++) //将得到的两个数组分别移位，然后拼接在一起得到m
{
if(i+1==1||i+1==2||i+1==9||i+1==16)
{
c[j]=cl[j+1];
d[j]=dl[j+1];
}
else
{
c[j]=clm[j+2];
d[j]=dlm[j+2];
}
}
for(j=0;j<28;j++)
{
m[j]=c[j];
m[j+28]=d[j];
}
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
k[n*6+j]=m[PCET[n][j]-1]; //PC2置换，将置换好的数据存入k[48] 每一轮的密钥生成完毕，现在进入轮结构
}
}
for(j=0;j<64;j++) //将初始置换后的明文存入ll[64]
ll[j]=rrekspl[j];
int l[32]={},r[32]={},re[48]={},rek[48]={};
for(j=0;j<32;j++)
{
l[j]=ll[j]; //将ll分为左右两半
r[j]=ll[j+32];
}
int e[8][6]={{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}};
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
re[n*6+j]=r[e[n][j]-1]; //右半进行扩展运算E
}
}
for(j=0;j<48;j++)
{
rek[j]=re[j]^k[j]; //与子密钥异或
}
int son[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 stw[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 sth[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 sfo[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 sfi[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 ssi[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 sse[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 sei[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}};
int z,slf[16]={},smf[32]={},slfs[8]={},smfs[8]={},rekss[8]={},reks[32]={};
for(j=0;j<8;j++)
{
slf[2*j]=rek[j*6];
slf[2*j+1]=rek[j*6+5]; //S盒代换压缩运算
} //z的用法同i,j,n，异或后的数据分8组，每组六位，slf存前后两位，smf存中间四位并化为十进制
for(j=0;j<8;j++)
{
for(n=0;n<4;n++)
{
smf[j*4+n]=rek[j*6+n+1];
}
}
for(j=0;j<8;j++)
{
slfs[j]=slf[2*j]*2+slf[2*j+1];
smfs[j]=smf[4*j]*8+smf[4*j+1]*4+smf[4*j+2]*2+smf[4*j+3];
}
rekss[0]=son[slfs[0]][smfs[0]];
rekss[1]=stw[slfs[1]][smfs[1]];
rekss[2]=sth[slfs[2]][smfs[2]];
rekss[3]=sfo[slfs[3]][smfs[3]];
rekss[4]=sfi[slfs[4]][smfs[4]];
rekss[5]=ssi[slfs[5]][smfs[5]];
rekss[6]=sse[slfs[6]][smfs[6]];
rekss[7]=sei[slfs[7]][smfs[7]];
for(z=0;z<8;z++)
{
j=4;
do
{
j=j-1;
n=4*z+j;
reks[n]=rekss[z]%2; //s盒代换压缩后的数据化为二进制
rekss[z]=rekss[z]/2;
}while(rekss[z]!=0);
}
int p[8][4]={{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}},reksp[32]={};
for(n=0;n<8;n++)
{
for(j=0;j<4;j++)
{
reksp[n*4+j]=reks[p[n][j]-1]; //P置换并将数据存入reksp[56]
}
}
int rekspl[32]={};
for(j=0;j<32;j++)
{
rekspl[j]=reksp[j]^l[j]; //与左半异或
}
for(j=0;j<32;j++)
l[j]=r[j];
for(j=0;j<32;j++) //将r赋给l,将rekspl赋给r
r[j]=rekspl[j];
for(j=0;j<32;j++)
{
rrekspl[j]=l[j]; //rrekspl作为下一轮输入
rrekspl[j+32]=r[j];
}
}
int jh[64]={};
for(i=0;i<32;i++)
{
jh[i]=rrekspl[i+32]; //左右交换
jh[i+32]=rrekspl[i];
}
int nip[8][8]={{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}};
int ncszh[64]={},ncszhsl[16]={};
for(n=0;n<8;n++)
{
for(j=0;j<8;j++)
{
ncszh[n*8+j]=jh[nip[n][j]-1]; //逆初始置换并将数据存入ncszh[64]
}
}
printf("密文： ");
for(j=0;j<16;j++)
{
ncszhsl[j]=ncszh[j*4]*8+ncszh[j*4+1]*4+ncszh[j*4+2]*2+ncszh[j*4+3];
if(ncszhsl[j]>=10){
switch(ncszhsl[j]){
case 10 : ncszhsl[j]='A'; break;
case 11 : ncszhsl[j]='B'; break;
case 12 : ncszhsl[j]='C'; break;
case 13 : ncszhsl[j]='D'; break;
case 14 : ncszhsl[j]='E'; break;
case 15 : ncszhsl[j]='F'; break;
}
}
} //将密文作为16进制输出
for(j=0;j<16;j++)
{
if(j==2||j==4||j==6||j==8||j==10||j==12||j==14)
{
if(ncszhsl[j]>=10)
printf("-%c",ncszhsl[j]);
else
printf("-%d",ncszhsl[j]);
}
else
{
if(ncszhsl[j]>=10)
printf("%c",ncszhsl[j]);
else
printf("%d",ncszhsl[j]);
}
}
}
解密
算法
输入密文与初始密钥，将初始密钥化为二进制并进行PC1置换，也就是通过加密算法里的子密钥生成程序得到16把子密钥，子密钥使用顺序与加密算法相反，对密文的处理同加密算法，将最终逆初始置换后所得值转为字符输出即可得到明文
代码实现
#include<stdio.h>
#include<string.h>
int main(void)
{
char str1[16],mwa[16];
int i,j,n,mwas[16]={},mwase[64]={},mwaseip[64]={};
printf("密文： ");
for(i=0;i<16;i++)
{
scanf("%c",&str1[i]);
mwa[i]=str1[i]; //把密文存入数组mwa[16]
}
char str2[8];
int a[8]={},b[64]={},c[56]={},dk[16][48]={}; //dk存放16把子密钥用以倒过来使用
while(getchar()!='\n');
printf("初始密钥：");
for(i=0;i<8;i++)
{
scanf("%c",&str2[i]);
a[i]=str2[i]; //把初始密钥存入数组a[8]
}
for(i=0;i<8;i++) //将初始密钥化为二进制，并存入数组b[64]
{
j=8;
do
{
j=j-1;
n=8*i+j;
b[n]=a[i]%2;
a[i]=a[i]/2;
}while(a[i]!=0);
}
int PCYT[8][7]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<7;j++)
{
c[i*7+j]=b[PCYT[i][j]-1]; //PC1置换并将数据存入c[56]
}
}
int PCET[8][6]={{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}},l[56]={},m[56]={},k[48]={},d[28]={},e[28]={},dl[29]={},el[29]={},dlm[30]={},elm[30]={};
for(i=0;i<56;i++)
m[i]=c[i];
for(i=0;i<16;i++) //16轮循环得到16把子密钥
{
for(j=0;j<56;j++)
{
l[j]=m[j];
}
for(j=0;j<28;j++)
{
d[j]=l[j];
e[j]=l[j+28];
}
for(j=0;j<28;j++)
{
dl[j]=d[j];
dlm[j]=d[j];
el[j]=e[j];
elm[j]=e[j];
}
dl[28]=d[0];
el[28]=e[0];
dlm[28]=d[0];
dlm[29]=d[1];
elm[28]=e[0];
elm[29]=e[1];
for(j=0;j<28;j++) //将得到的两个数组分别移位，然后拼接在一起
{
if(i+1==1||i+1==2||i+1==9||i+1==16)
{
d[j]=dl[j+1];
e[j]=el[j+1];
}
else
{
d[j]=dlm[j+2];
e[j]=elm[j+2];
}
}
for(j=0;j<28;j++)
{
m[j]=d[j];
m[j+28]=e[j];
}
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
k[n*6+j]=m[PCET[n][j]-1]; //PC2置换，将置换好的数据存入k[48]
}
}
int sk[1][48]={};
for(j=0;j<48;j++)
sk[0][j]=k[j];
for(j=0;j<48;j++) //将16把子密钥存入dk
{
dk[i][j]=sk[0][j];
}
}
for(i=0;i<16;i++)
{
if(mwa[i]=='A')
mwas[i]=10;
else if(mwa[i]=='B')
mwas[i]=11;
else if(mwa[i]=='C')
mwas[i]=12;
else if(mwa[i]=='D') //将密文化为十进制
mwas[i]=13;
else if(mwa[i]=='E')
mwas[i]=14;
else if(mwa[i]=='F')
mwas[i]=15;
else
mwas[i]=mwa[i]-48;
}
for(i=0;i<16;i++) //将密文化为二进制，并存入数组mwase[64]
{
j=4;
do
{
j=j-1;
n=4*i+j;
mwase[n]=mwas[i]%2;
mwas[i]=mwas[i]/2;
}while(mwas[i]!=0);
}
int IP[8][8]={{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}};
for(i=0;i<8;i++)
{
for(j=0;j<8;j++)
{
mwaseip[i*8+j]=mwase[IP[i][j]-1]; //初始置换并将数据存入mwaseip[64]
}
}
int ll[64]={},rrekspl[64]={}; //将置换后的数据作为第一轮输入，进入轮结构程序
for(i=0;i<64;i++)
rrekspl[i]=mwaseip[i];
for(i=0;i<16;i++)
{
for(j=0;j<64;j++) //将初始置换后的密文存入ll[64]
{
ll[j]=rrekspl[j];
}
int l[32]={},r[32]={},re[48]={},rek[48]={};
for(j=0;j<32;j++)
{
l[j]=ll[j]; //ll分为左右两部分
r[j]=ll[j+32];
}
int e[8][6]={{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}};
for(n=0;n<8;n++)
{
for(j=0;j<6;j++)
{
re[n*6+j]=r[e[n][j]-1]; //扩展运算E
}
}
for(j=0;j<48;j++)
{
rek[j]=re[j]^dk[15-i][j]; //与倒序的子密钥异或
} //S盒代换压缩
int son[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 stw[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 sth[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 sfo[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 sfi[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 ssi[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 sse[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 sei[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}};
int z,slf[16]={},smf[32]={},slfs[8]={},smfs[8]={},rekss[8]={},reks[32]={};
for(j=0;j<8;j++)
{
slf[2*j]=rek[j*6];
slf[2*j+1]=rek[j*6+5];
}
for(j=0;j<8;j++)
{
for(n=0;n<4;n++)
{
smf[j*4+n]=rek[j*6+n+1];
}
}
for(j=0;j<8;j++)
{
slfs[j]=slf[2*j]*2+slf[2*j+1];
smfs[j]=smf[4*j]*8+smf[4*j+1]*4+smf[4*j+2]*2+smf[4*j+3];
}
rekss[0]=son[slfs[0]][smfs[0]];
rekss[1]=stw[slfs[1]][smfs[1]];
rekss[2]=sth[slfs[2]][smfs[2]];
rekss[3]=sfo[slfs[3]][smfs[3]];
rekss[4]=sfi[slfs[4]][smfs[4]];
rekss[5]=ssi[slfs[5]][smfs[5]];
rekss[6]=sse[slfs[6]][smfs[6]];
rekss[7]=sei[slfs[7]][smfs[7]];
for(z=0;z<8;z++)
{
j=4;
do
{
j=j-1;
n=4*z+j;
reks[n]=rekss[z]%2;
rekss[z]=rekss[z]/2;
}while(rekss[z]!=0);
}
int p[8][4]={{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}},reksp[32]={};
for(n=0;n<8;n++)
{
for(j=0;j<4;j++)
{
reksp[n*4+j]=reks[p[n][j]-1]; //P置换并将数据存入reksp[32]
}
}
int rekspl[32]={};
for(j=0;j<32;j++)
{
rekspl[j]=reksp[j]^l[j]; //与左半异或
}
for(j=0;j<32;j++)
l[j]=r[j]; //将右半赋给左半，将异或后的结果赋给右半，组合后作为下一轮输入
for(j=0;j<32;j++)
r[j]=rekspl[j];
for(j=0;j<32;j++)
{
rrekspl[j]=l[j];
rrekspl[j+32]=r[j];
}
} //左右交换
int jh[64]={},jhsl[16]={};
for(i=0;i<32;i++)
{
jh[i]=rrekspl[i+32];
jh[i+32]=rrekspl[i];
}
int nip[8][8]={{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}};
int ncszh[64]={},ncszhsl[16]={};
for(n=0;n<8;n++)
{
for(j=0;j<8;j++)
{
ncszh[n*8+j]=jh[nip[n][j]-1]; //逆初始置换并将数据存入ncszh[64]
}
}
for(j=0;j<16;j++)
{
ncszhsl[j]=ncszh[j*4]*8+ncszh[j*4+1]*4+ncszh[j*4+2]*2+ncszh[j*4+3];
if(ncszhsl[j]>=10){
switch(ncszhsl[j]){
case 10 : ncszhsl[j]='A'; break;
case 11 : ncszhsl[j]='B'; break;
case 12 : ncszhsl[j]='C'; break;
case 13 : ncszhsl[j]='D'; break;
case 14 : ncszhsl[j]='E'; break;
case 15 : ncszhsl[j]='F'; break;
}
}
}
int fh[16],asci[8];
printf("明文： ");
for(i=0;i<16;i++) //将逆初始置换后的结果化为十进制作为字符输出即可得到明文
{
if(ncszhsl[i]=='A')
fh[i]=10;
else if(ncszhsl[i]=='B')
fh[i]=11;
else if(ncszhsl[i]=='C')
fh[i]=12;
else if(ncszhsl[i]=='D')
fh[i]=13;
else if(ncszhsl[i]=='E')
fh[i]=14;
else if(ncszhsl[i]=='F')
fh[i]=15;
else
fh[i]=ncszhsl[i];
}
for(i=0;i<8;i++)
{
asci[i]=fh[2*i]*16+fh[2*i+1];
printf("%c",asci[i]);
}
}
注意事项
1.连续使用scanf函数时要用getchar吸收掉上一个scanf留在缓冲区的空格，否则结果不对，使用while(getchar()!='\n');即可实现
2.明文为64比特，密钥为56比特
3.使用十六进制更易查看结果，二进制眼睛就看花了
4.解密与加密的轮结构一样，也要先进行初始置换，最后进行左右交换与逆初始置换，不同于加密的是解密的16把子密钥要倒过来使用，即第一轮解密使用加密算法里的第十六轮的密钥
5.DES使用分组密码，也即对称密钥密码，加密密钥与解密密钥相同或者解密密钥与加密密钥之间存在关联
扫一扫
1629
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
