【密码学】DES加解密原理及其Java实现算法

DES简介

---

DES(Data Encryption Standard)是对称加解密算法的一种，由IBM公司W.Tuchman和C.Meyer在上个世纪70年代开发。

该算法使用64位密钥（其中包含8位奇偶校验，实际密钥长度为56位）对以64位为单位的块数据加密，产生64位密文数据，然后使用相同的密钥进行解密。

密钥只有通信双方知晓，不对第三方公开。

DES特点

1. 对称算法：加密和解密使用同一秘钥

2. 分组加密算法：以64位为分组。64位明文输入，64位密文输出。

3. 有效秘钥长度为56位秘钥通常表示为64位数，但每个第8位用作奇偶校验，可以忽略。

4. 代替和置换DES算法是两种加密技术的组合：混乱和扩散。先替代后置换。

5. 易于实现：DES算法只是使用了标准的算术和逻辑运算，其作用的数最多也只有64 位，因此用70年代末期的硬件技术很容易实现算法的重复特性使得它可以非常理想地用在一个专用芯片中。

6. 可通过多重加密，提高安全等级

入口参数

Key为7个字节共56位，是DES算法的工作密钥

Data为8个字节64位，是要被加密或被解密的数据

Mode为DES的工作方式,有两种:加密或解密

基本原则

DES设计中使用了分组密码设计的两个原则：混淆（confusion）和扩散(diffusion)，其目的是抗击敌手对密码系统的统计分析。

混淆是使密文的统计特性与密钥的取值之间的关系尽可能复杂化，以使密钥和明文以及密文之间的依赖性对密码分析者来说是无法利用的。

扩散的作用就是将每一位明文的影响尽可能迅速地作用到较多的输出密文位中，以便在大量的密文中消除明文的统计结构，并且使每一位密钥的影响尽可能迅速地扩展到较多的密文位中，以防对密钥进行逐段破译。

算法描述

1. 输入64位明文数据，并进行初始置换IP

2. 在初始置换IP后，明文数据再被分为L0和R0左右两部分，每部分32位

3. 在秘钥的控制下，经过16轮运算(f)

4. 16轮后，左、右两部分交换，并连接再一起，再进行逆置换

5. 输出64位密文

DES算法过程

---

子密钥生成

DES算法由64位密钥产生16轮的48位子密钥。主要过程如下：

1. 把密钥的奇偶校验位忽略不参与计算，即每个字节的第8位，将64位密钥降至56位，然后根据选择置换表PC-1将这56位分成两块C0(28位)和D0(28位)

2. 将C0和D0进行循环左移变化(注：每轮循环左移的位数由轮数决定)，变换后生成C1和D1，然后C1和D1合并，并通过选择置换表PC-2生成子密钥K1(48位)

3. C1和D1再次经过循环左移变换，生成C2和D2，然后C2和D2合并，通过选择置换PC-2生成密钥K2(48位)

4. 以此类推，得到K16(48位)。

PC-1压缩置换

通过压缩置换表PC-1将64位密钥压缩至56位密钥。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  

分成C0和D0

再将56位密钥分成C0(28位)和D0(28位)：

C0(28位)=K57K49K41…K44K36

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

D0(28位)=K63K55K47…K12K4

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

循环左移

根据轮数，将Cn和Dn分别循环左移1位或2位。左移位数如下：

1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1

第一轮是循环左移1位

C0循环左移1位后得到C1如下：

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,57 

D0循环左移1位后得到D1如下：

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,63 

压缩置换

C1和D1合并之后，再经过压缩置换表PC-2生成48位的子密钥K1。PC-2如下：

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

C1和D1再次经过循环左移变换，生成C2和D2，C2和D2合并，通过PC-2生成子秘钥K2

以此类推，得到子秘钥K1~K16

加密过程

数据加密过程将64Bit明文通过密钥加密为密文，主要过程如下：

1. 首先将明文转换为64位的二进制，通过IP表初始置换，再将其分成L0(32位)和R0(32位)

2. 把R0通过位选择表E扩展置换，把扩展后的R0和子密钥K1进行异或，得到48位的二进制串。把该串分成8组，每组6位(b1b2b3b4b5b6)

3. 把每组中的b1b6换算为十进制，b2b3b4b5也换算为十进，通过S盒来收缩。b1b6代表S盒中的行标，b2b3b4b5代表列标

4. 把压缩后的32位的串通过置换函数P的置换，然后与最初64位的左半边异或，接着开始下一轮

5. 通过16轮迭代后，把得到的L15和R15交换位置然后合并得到64位串R15L15，在通过逆置换表IPR得到密文

初始置换

把明文转换成64位的二进制，然后通过初始置换表IP置换。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,

分成L0和R0

把通过初始置换后的64位串分成高32位L0和低32位R0

高32位L0

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,  

低32位R0

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,

扩展置换E

通过扩展置换E，数据的右半部分Rn从32位扩展到48位。

扩展置换改变了位的次序，重复了某些位。

扩展置换的目的：

1. 产生与秘钥相同长度的数据以进行异或运算，R0是32位，子密钥是48位，所以R0要先进行扩展置换之后与子秘钥进行异或运算

2. 提供更长的结果，使得在替代运算时能够进行压缩。

扩展置换表E如下：

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盒压缩

Rn扩展置换之后与子秘钥Kn异或以后的结果作为输入块进行S盒代替运算

功能是把48位数据变为32位数据

代替运算由8个不同的代替盒(S盒)完成。每个S-盒有6位输入，4位输出。

所以48位的输入块被分成8个6位的分组，每一个分组对应一个S-盒代替操作。

经过S-盒代替，形成8个4位分组结果。

注意：每一个S-盒的输入数据是6位，输出数据是4位，但是每个S-盒自身是64位

每个S-和是4行16列的格式，因为二进制4位是0~15。

S1:

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, 

S2:

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,  

S3:

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,  

S4:

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,  

S5:

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,  

S6:

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,  

S7:

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,  

S8:

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盒置换

S-盒代替运算，每一盒得到4位，8盒共得到32位输出。这32位输出作为P盒置换的输入块。

经过P-盒置换的结果与最初64位分组的左半部分异或，然后左右两部分交换，开始下一轮迭代。

P-盒置换表如下：

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,  

逆置换

将初始置换进行16次的迭代，即进行16层的加密变换，这个运算过程我们暂时称为函数f。得到L16和R16，将此作为输入块，进行逆置换得到最终的密文输出块。

逆置换是初始置换的逆运算。从初始置换表中可以看到，原始数据的第1位置换到了第40位，第2位置换到了第8位。则逆置换就是将第40位置换到第1位，第8位置换到第2位，以此类推

逆置换表IPR如下：

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,  

DES解密

---

DES的解密算法与其加密算法使用的算法过程相同。

两者的不同之处在于解密时子密钥Ki的使用顺序与加密时相反，如果子密钥为K1K2…K16,那么解密时子密钥的使用顺序为K16K15…K1,即使用DES解密算法进行解密时，将以64位密文作为输入，第1次迭代运算使用子密钥K16，第2次迭代运算使用子密钥K15，……，第16 次迭代使用子密钥K1，其它的运算与加密算法相同。

这样，最后输出的是64位明文。

Java实现DES加解密

---

public class DES {
    // 置换IP表
    private int[] IP_Table = { 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