解密加密

加密
解密

加密

DES加密算法其实分为两个部分，一部分对密钥进行处理，一部分对明文进行处理。
下面从一个例子说明：
64位明文：

M=00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111

64位密钥：

K=00110001 00110010 00110011 00110100 00110101 00110110 00110111 00111000

密钥

K=00110001 00110010 00110011 00110100 00110101 00110110 00110111 00111000

置换选择

置换选择1（PC_1）8*7矩阵：

int pc_1[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
    };

在密钥当中，前八位00110001，第8位的1是奇偶校验位
这个表有两个作用，一是去掉8个奇偶校验位，二是其他位打乱重排，即得到的56位密钥（64-8）中第1位的数是原来64位的第57位的数，第2位的数是原来的第49位的数。。。
其实不用特意去掉奇偶校验位，因为按PC_1换位置之后剩下来的8位就是奇偶校验位，直接舍去就可以。

经过上面的变换我们就可以得到56位的密钥：

K(56)=0000000 0000000 0011111 1111111 0110011 0011110 001000 00001111

再将前28位存储到C0，后28位存储到D0，即：

C0(28)=0000000 0000000 0011111 1111111
D0(28)=0110011 0011110 001000 00001111

循环左移

为了得到16个子密钥，我们需要有16对C和D。
C1为C0循环左移得到，D1为D0循环左移得到，C2为C1循环左移得到，D2为D1循环左移得到、、、
循环左移的位数如图所示：
在这里插入图片描述
循环左移1位的意思是把第一位保留下来，其他位左移，再将保留的第一位填到最后空出来的1位。
可以得到结果：
第一轮：

C1=0000000 0000000 0111111 1111110
D1=1100110 0111100 0100000 0011110

第二轮：

C2=0000000 0000000 1111111 1111100
D2=1001100 1111000 1000000 0111101

…
第16轮：

C16=0000000 0000000 0011111 1111111
D16=0110011 0011110 0010000 0001111

左移完成后，将每对拼接起来构成56位的密钥

K1(56)=0000000 0000000 0111111 1111110 1100110 0111100 0100000 0011110

接下来进行第二次置换
置换选择2（PC_2）6*8矩阵：

int pc_2[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
    };

将56位变为48位，和PC_1原理一样，最终得到16个子密钥：

k1(48)=010100000010110010101100010101110010101011000010
k2(48)=010100001010110010100100010100001010001101000111
k3(48)=110100001010110000100110111101101000010010001100
k4(48)=111000001010011000100110010010000011011111001011
k5(48)=111000001001011000100110001111101111000000101001
k6(48)=111000001001001001110010011000100101110101100010
k7(48)=101001001101001001110010100011001010100100111010
k8(48)=101001100101001101010010111001010101111001010000
k9(48)=001001100101001101010011110010111001101001000000
k10(48)=001011110101000101010001110100001100011100111100
k11(48)=000011110100000111011001000110010001111010001100
k12(48)=000111110100000110011001110110000111000010110001
k13(48)=000111110000100110001001001000110110101000101101
k14(48)=000110110010100010001101101100100011100110010010
k15(48)=000110010010110010001100101001010000001100110111
k16(48)=010100010010110010001100101001110100001111000000

对密钥的处理完毕，下面开始对明文处理。

明文

M=00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111

IP置换

IP置换表（IP）8*8：

//IP置换表
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
    };

将明文打乱顺序，得到

M_IP(64)=00000000 11111111 11110000 10101010 00000000 11111111 00000000 11001100

再将其分为两部分L0、R0

L0(32)=00000000 11111111 11110000 10101010
R0(32)=00000000 11111111 00000000 11001100

接下来，从L0R0开始推L1R1，一共循环16次，推出L1-L16
根据下面的运算规则：

Ln=R(n-1);
Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 Kn ) ) );

L很好得到，就是L1=R0;L2=R1;L3=R2…

L16R16的运算

拓展置换

为了得到R1，首先执行最里面的E(R0)

选择运算/拓展置换（E）8*6：

//r数组拓展置换表
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
    };

将32位的R0拓展到48位

R0(32)=00000000 11111111 00000000 11001100
R0(48)=00000000 00010111 11111110 10000000 00010110 01011000

接下来进行 E(R0)异或K1(48)

k1(48)=010100000010110010101100010101110010101011000010
E(R0)异或K1(48)=01010000 00111011 01010010 11010111 00111100 10011010

S盒

接下来进行 S(E(R0)异或K1(48))
代替函数S盒（S_box）:

//l数组s盒置换表
int s_box[8][4][16]={
    14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,  //s1
    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,

    15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,  //s2
    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,

    10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,  //s3
    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,

    7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,  //s4
    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,

    2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,  //s5
    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,

    12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,  //s6
    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,

    4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,  //s7
    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,

    13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,  //s8
    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
};

首先将上一步的结果：

E(R0)异或K1(48)=01010000 00111011 01010010 11010111 00111100 10011010

分为8个6位的数据块

1：010100      2：000011     3：101101      4：010010
5：110101      6：110011     7：110010      8：011010

对第1块处理，将6位中的第1位和第6位组成一个二进制数00，转为十进制数X=0*2+0=0 。再将中间四位1010组成二进制数，转为十进制Y=1*8+0*4+1*2+0*1=10 。X作为行数，Y作为列数，第几块就去找第几盒，那这个块的结果就是S1的0行10列，即S_box[0][0][10]，结果为6，将6转为二进制0110 。
再对其余7块处理完成后，可以得到4*8=32位的结果：

S(E(R0)异或K1(48))(32)=01101101 10000010 00001110 11110000

P置换

再进行P(S(E(R0)异或K1(48)))
置换运算（P）8*4：

//P盒置换
int p[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
};

这个跟置换选择就一样了，可以得到结果：

P(S(E(R0)异或K1(48))(32))(32)=00010010 01111000 11000111 00011001

最后将这个结果和L0进行异或操作：

R1 = L0 异或 P(S(E(R0)异或K1(48))(32))(32)
L0(32)=00000000 11111111 11110000 10101010

R1(32)=00010010 10000111 00110111 10110011
L1(32)=R0=00000000 11111111 00000000 11001100

按照拓展置换、S置换、P置换的顺序退出来L16和R16：

N=1
L1=00000000111111110000000011001100
R1=00010010100001110011011110110011
N=2
L2=00010010100001110011011110110011
R2=11100001100111001000011010001010
N=3
L3=11100001100111001000011010001010
R3=11010110001011101111011101100101
N=4
L4=11010110001011101111011101100101
R4=00011110111001010111111100100110
N=5
L5=00011110111001010111111100100110
R5=01011000010000001110001001011100
N=6
L6=01011000010000001110001001011100
R6=00011010011000000110100000101100
N=7
L7=00011010011000000110100000101100
R7=11010001011100100100110001010100
N=8
L8=11010001011100100100110001010100
R8=01101001101101100001001111111010
N=9
L9=01101001101101100001001111111010
R9=10101110100001011111100010000110
N=10
L10=10101110100001011111100010000110
R10=00010101101110011000100100011001
N=11
L11=00010101101110011000100100011001
R11=00010011011001010001111111011000
N=12
L12=00010011011001010001111111011000
R12=11110000111011000111011010001110
N=13
L13=11110000111011000111011010001110
R13=00100111110111000010101111001011
N=14
L14=00100111110111000010101111001011
R14=00011000111101010110001110010100
N=15
L15=00011000111101010110001110010100
R15=00110011111101101010110101000101
N=16
L16=00110011111101101010110101000101
R16=11010100000101101000101010100001

我们需要的就是L16和R16，将它们按R16L16的顺序拼接在一起组成64位数据。

(64)1101010000010110100010101010000100110011111101101010110101000101

IP逆置换

//IP逆置换表
int IP_[64]={
    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
    };

按此表对上步结果进行最后的置换，得到最终的密文：

C(64)=10001011 10110100 01111010 00001100 11110000 10101001 01100010 01101101

解密

解密过程其实跟加密过程一样，就是把明文换成密文，密钥不变，再按这个顺序来一遍，但有一点不同的地方
首先根据密文来获得16个子密钥，不过这16个子密钥跟你明文加密过程中得到的是一样的；
然后对密文进行操作，IP置换，获得L0R0，在进行16次递推运算时有不同，
明文加密的运算规则是：

Ln=R(n-1);
Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 Kn ) ) );

密文解密的运算规则是：

Ln=R(n-1);
Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 K(16-n+1) ) ) );

即明文在获取R1时，使用的是子密钥K1
密文在获取R1时，使用的是子密钥K16，获取R2使用K15
然后依次进行S盒、P置换、IP逆置换可以得到明文

N=1
L1=00110011111101101010110101000101
R1=00011000111101010110001110010100
N=2
L2=00011000111101010110001110010100
R2=00100111110111000010101111001011
N=3
L3=00100111110111000010101111001011
R3=11110000111011000111011010001110
N=4
L4=11110000111011000111011010001110
R4=00010011011001010001111111011000
N=5
L5=00010011011001010001111111011000
R5=00010101101110011000100100011001
N=6
L6=00010101101110011000100100011001
R6=10101110100001011111100010000110
N=7
L7=10101110100001011111100010000110
R7=01101001101101100001001111111010
N=8
L8=01101001101101100001001111111010
R8=11010001011100100100110001010100
N=9
L9=11010001011100100100110001010100
R9=00011010011000000110100000101100
N=10
L10=00011010011000000110100000101100
R10=01011000010000001110001001011100
N=11
L11=01011000010000001110001001011100
R11=00011110111001010111111100100110
N=12
L12=00011110111001010111111100100110
R12=11010110001011101111011101100101
N=13
L13=11010110001011101111011101100101
R13=11100001100111001000011010001010
N=14
L14=11100001100111001000011010001010
R14=00010010100001110011011110110011
N=15
L15=00010010100001110011011110110011
R15=00000000111111110000000011001100
N=16
L16=00000000111111110000000011001100
R16=00000000111111111111000010101010
解密后的明文为：
00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111

对比明文

M=00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111

结果正确

代码：C语言DES加密解密代码

原文链接：https://blog.csdn.net/yiersan__/article/details/115672898