标准数据加密(DES)及其备选
数据加密标准从出现到现在的 30 年一直都是最流行的块运算加密。即便它的密钥太短，现在不认为是一种安全的算法，在落后的应用里，它依然有应用市场。另外，基于 DES 的 3DES 是一种安全的算法，现在依然有广泛地应用。DES 是大众最熟悉的对称算法，它的设计原则激励了很多现代算法。
3.1 DES 介绍
3.1.1 混乱与扩散
在介绍详细介绍 DES 之前，需要看一下实现强加密的一些步骤。通过信息论之父香农的理论，有两个构建强加密算法的操作：
- 混乱 是一个加密动作，用以掩盖密钥与密文之间的关系，最常见的一种方式是替换，这在 DES 以及 AES 中使用
- 扩散 是一个加密动作，用以将原文扩散到更多的密文中，掩盖静态的原文特性，一个简单的方式是置换，在 DES 中频繁使用
只进行混乱的运算，比如移位运算，是不安全的。只进行扩散的运算，也是不安全的。将二者串联的运算，可以构建一个安全性较强的运算。量多种加密操作串联在一起是由香农提出的。
现今的块运算具有很好的扩散属性，在运算层级，这意味着修改原文的一个比特，将会导致接近一半的比特的修改，变化后的密文与前一个密文看起来是完全独立的。
例3.1 我们假设一个小的块运算，具有 8 比特块长度。加密两个原文 $$x_1$$ 以及 $$x_2$$，它们二者只有一个比特不同，但是会得到完全不同的结果：
\[x_1 = 0010 1011 \quad (块运算) \quad y_1 = 1011 1001 \\ x_2 = 0000 1011 \quad (块运算) \quad y_2 = 0110 1100 \]
注意到，现代块运算具有 64 或 128 比特长，也具有上面这样的特性。
3.2 DES 算法总览
DES 运算加密块长度为 64 比特，密钥长度 56 比特长。
DES 是一个对称运算，既加密与解密使用相同的密钥。DES 也是一种迭代算法。对于每一个运算块，会进行 16 轮的独立操作。每一轮的不同子密钥都是从主密钥 k 中得到。
在 DES 内部结构是 Feistel 网络，Feistel 网络加密与解密使用相同的操作。解密只需要使用相反的密钥过程，这在软件与硬件实现上都是一个优势。
在对原文 x 进行初始化的比特置换 IP 后，原文分为 $$L_0$$ 以及 $$R_0$$。这是两个 32 位的 Feistel 网络输入，这些一共有 16 轮。右半拉 $$R_i$$ 给到函数 $$f$$。$$f$$ 函数的输出与左半拉 $$L_i$$ 进行异或。最后，右半拉与左半拉交换。这个过程在下一轮重复：
\[L_i = R_{i-1} \\ R_i = L_{i-1} \oplus f(R_{i-1}，k_i) \]
其中 $$i = 1，...，16$$。在第 16 轮后，32位的 $$L_{16}$$ 以及 $$R_{16}$$ 再次交换，最后的置换 $$IP^{-1}$$ 是 DES 的最后一个操作。最后的置换是最初置换 $$IP$$ 的逆。在每一轮的密钥 $$k_i$$ 是从 56 位的主密钥通过密钥调度生成。
Feistel 结构每一轮只对一半输入加密，输入的左半边加密，右半边保持到下一轮。右半边不通过 $$f$$ 函数加密。为了更好的理解 Feistel 运算，下面的解释可能有帮助：考虑 $$f$$ 函数是一个伪随机数生成器，这个随机数生成器有两个输入 $$R_{i-1}$$ 以及 $$k_i$$，伪随机数的输出之后通过异或用来加密左半边的 $$L_{i-1}$$。就像在第二章中介绍的，如果 $$f$$ 函数对于攻击者而言是不可预测的，那么这个加密结果就是强安全的。
前面提到了基础的运算操作，混乱与扩散，是通过 $$f$$ 函数实现的。为了挫败分析攻击，$$f$$ 函数必须小心地设计。
3.3 DES 内部结构
DES 的构建的块有初始与最终置换，真正的 DES 轮是它的核心，$$f$$ 函数以及密钥策略。
3.3.1 初始与最终置换
初始化置换 $$IP$$ 以及最终的置换 $$IP^{-1}$$ 都是按位置换。有趣的是，按位置换通过硬件十分容易实现，而通过软件效率并不高。注意到，两次置换并不会增加 DES 的安全性，这两个置换存在的具体原因我们不知道，最初的意图好像是准备原文、密文并令数据数据更容易通过 8 位数据总线提取，这在 19 世纪 70 年代是寄存器的尺寸。
下表是 \(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 |
下表是 \(IP^{-1}\)
\(IP^{-1}\) | |||||||
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 |
3.3.2 $$f$$函数
就像之前提到的，\(f\) 函数在 DES 的安全性中是至关重要的。在第 \(i\) 轮中，它取用前一轮输出的右半边的 \(R_{i-1}\) 以及当前轮的密钥 \(k_i\) 做为输入。\(f\) 函数的输出用作加密左半边输入 \(L_{i-1}\)
首先通过将 4 位的块扩展得到 6 位的块，将 32 位的输入扩展到 48 位。这是在 E 盒中发生，它是一种特殊的置换。
从下表中可以看到，32 位输入其中的 16 位在输出中出现了两次。相同的位不会在同一个 6 位输出中出现两次。E 盒是一种扩散行为。
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 |
接下来，48 位的结果与对应轮的密钥 \(k_i\) 做异或操作，然后这八个 6 位块给到 8 个不同的替换盒 S 盒。每一个 S 盒都是个查询表，可以将 6 位输入映射位 4 位输出。八个 \(4\times6\) 的表，每一个 S 盒包含 \(2^6 = 64\)
\(S_1\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 14 | 04 | 13 | 01 | 02 | 15 | 11 | 08 | 03 | 10 | 06 | 12 | 05 | 09 | 00 | 07 |
1 | 00 | 15 | 07 | 04 | 14 | 02 | 13 | 01 | 10 | 06 | 12 | 11 | 09 | 05 | 03 | 08 |
2 | 04 | 01 | 14 | 08 | 13 | 06 | 02 | 11 | 15 | 12 | 09 | 07 | 03 | 10 | 05 | 00 |
3 | 15 | 12 | 08 | 02 | 04 | 09 | 01 | 07 | 05 | 11 | 03 | 14 | 10 | 00 | 06 | 13 |
\(S_2\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 15 | 01 | 08 | 14 | 06 | 11 | 03 | 04 | 09 | 07 | 02 | 13 | 12 | 00 | 05 | 10 |
1 | 03 | 13 | 04 | 07 | 15 | 02 | 08 | 14 | 12 | 00 | 01 | 10 | 06 | 09 | 11 | 05 |
2 | 00 | 14 | 07 | 11 | 10 | 04 | 13 | 01 | 05 | 08 | 12 | 06 | 09 | 03 | 02 | 15 |
3 | 13 | 08 | 10 | 01 | 03 | 15 | 04 | 02 | 11 | 06 | 07 | 12 | 00 | 05 | 14 | 09 |
\(S_3\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 10 | 00 | 09 | 14 | 06 | 03 | 15 | 05 | 01 | 13 | 12 | 07 | 11 | 04 | 02 | 08 |
1 | 13 | 07 | 00 | 09 | 03 | 04 | 06 | 10 | 02 | 08 | 05 | 14 | 12 | 11 | 15 | 01 |
2 | 13 | 06 | 04 | 09 | 08 | 15 | 03 | 00 | 11 | 01 | 02 | 12 | 05 | 10 | 14 | 07 |
3 | 01 | 10 | 13 | 00 | 06 | 09 | 08 | 07 | 04 | 15 | 14 | 03 | 11 | 05 | 02 | 12 |
\(S_4\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 07 | 13 | 14 | 03 | 00 | 06 | 09 | 10 | 01 | 02 | 08 | 05 | 11 | 12 | 04 | 15 |
1 | 13 | 08 | 11 | 05 | 06 | 15 | 00 | 03 | 04 | 07 | 02 | 12 | 01 | 10 | 14 | 09 |
2 | 10 | 06 | 09 | 00 | 12 | 11 | 07 | 13 | 15 | 01 | 03 | 14 | 05 | 02 | 08 | 04 |
3 | 03 | 15 | 00 | 06 | 10 | 01 | 13 | 08 | 09 | 04 | 05 | 11 | 12 | 07 | 02 | 14 |
\(S_5\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 02 | 12 | 04 | 01 | 07 | 10 | 11 | 06 | 08 | 05 | 03 | 15 | 13 | 00 | 14 | 09 |
1 | 14 | 11 | 02 | 12 | 04 | 07 | 13 | 01 | 05 | 00 | 15 | 10 | 03 | 09 | 08 | 06 |
2 | 04 | 02 | 01 | 11 | 10 | 13 | 07 | 08 | 15 | 09 | 12 | 05 | 06 | 03 | 00 | 14 |
3 | 11 | 08 | 12 | 07 | 01 | 14 | 02 | 13 | 06 | 15 | 00 | 09 | 10 | 04 | 05 | 03 |
\(S_6\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 12 | 01 | 10 | 15 | 09 | 02 | 06 | 08 | 00 | 13 | 03 | 04 | 14 | 07 | 05 | 11 |
1 | 10 | 15 | 04 | 02 | 07 | 12 | 09 | 05 | 06 | 01 | 13 | 14 | 00 | 11 | 03 | 08 |
2 | 09 | 14 | 15 | 05 | 02 | 08 | 12 | 03 | 07 | 00 | 04 | 10 | 01 | 13 | 11 | 06 |
3 | 04 | 03 | 02 | 12 | 09 | 05 | 15 | 10 | 11 | 14 | 01 | 07 | 06 | 00 | 08 | 13 |
\(S_7\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 04 | 11 | 02 | 14 | 15 | 00 | 08 | 13 | 03 | 12 | 09 | 07 | 05 | 10 | 06 | 01 |
1 | 13 | 00 | 11 | 07 | 04 | 09 | 01 | 10 | 14 | 03 | 05 | 12 | 02 | 15 | 08 | 06 |
2 | 01 | 04 | 11 | 13 | 12 | 03 | 07 | 14 | 10 | 15 | 06 | 08 | 00 | 05 | 09 | 02 |
3 | 06 | 11 | 13 | 08 | 01 | 04 | 10 | 07 | 09 | 05 | 00 | 15 | 14 | 02 | 03 | 12 |
\(S_8\) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
0 | 13 | 02 | 08 | 04 | 06 | 15 | 11 | 01 | 10 | 09 | 03 | 14 | 05 | 00 | 12 | 07 |
1 | 01 | 15 | 13 | 08 | 10 | 03 | 07 | 04 | 12 | 05 | 06 | 11 | 00 | 14 | 09 | 02 |
2 | 07 | 11 | 04 | 01 | 09 | 12 | 14 | 02 | 00 | 06 | 10 | 13 | 15 | 03 | 05 | 08 |
3 | 02 | 01 | 14 | 07 | 04 | 10 | 08 | 13 | 15 | 12 | 09 | 00 | 03 | 05 | 06 | 11 |
例 3.2 S 盒输入 \(b = (100101)_2\) 表示行为 \(11_2 = 3\) 既第四行，\(0010_2 = 2\) 既第三列。如果输入 b 给到 S 盒 \(S_1\)
\[S_1(37 = 100101_2) = 8 = 1000_2 \]
S 盒在加密强度上是 DES 核。它们在算法中是非线性元素，并提供混乱属性。S 盒按照下面列出的标准设计：
- 每一个 S 盒具有六比特输入与四比特输出
- 单个的输出比特不能靠得太近现得是个输入比特的线性组合似的
- 如果输入的最低位与最高位比特固定中间的四位比特变化，每一个可能的 4 比特输出值只能出现一次
- 如果 S 盒的两个输入只有一个比特不同，它们的输出至少有两比特不同
- 如果 S 盒的两个输入的中间两个比特不同，它们输出至少有两个比特不同
- 如果 S 盒的两个输入的前两个比特不同，而后两个比特相同，输出不同
- 问题
- 八个 S 盒的 32 位输出冲突，只有三个毗邻的 S 盒出现
S 盒是 DES 中最关键的组成部分，因为它们为运算引入了非线性元素，既：
\[S(a)\oplus S(b) \ne S(a \oplus b) \]
如果没有非线性块，攻击者可以在密钥未知的情况下使用一组线性方程来表示 DES 输入与输出的关系，这样的系统是很容易被攻击的。
最后，32 位的输出通过 P 置换进行按位置换。与初始化置换 \(IP\) 及其逆 \(IP^{-1}\)
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 |
3.3.3 密钥策略
密钥策略生成 16 轮的密钥 \(k_i\)，每一轮的密钥都原始的 56 位密钥生成 48 位密钥。首先，注意到 DES 输入密钥通常是以 64 位的形式给出的，其中每第八位用作其余七位的奇偶校验位。八个奇偶校验位不是密钥的实际组成部分，并且不会增加安全性。DES 是一个 56 位的运算而非 64 位运算。
初始密钥置换 PC - 1：
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 | 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 |
得到的 56 位的密钥分割成两半块 \(C_0\) 以及 \(D_0\)，这两半块会进行循环移位，并依赖于下面的规则：
- 在 \(i = 1，2，9，16\)
- 在其他轮 \(i \ne 1，2，9，16\)，这两半密钥循环左移两位
注意到，循环移位只会在左半密钥或右半密钥中的其中一个进行。总的移动位置为 \(4 \cdot 1 + 12 \cdot 2 = 28\)。这会有 \(C_0 = C_{16}\) 及 \(D_0 = D_{16}\)。
为了得到 48 位的密钥 \(k_i\)，这两半会使用 PC - 2 进行按位置换。PC - 2 置换采用 \(C_i\) 及 \(D_i\)
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 |
注意到，每一轮的密钥是从输入密钥 k 中提取出经置换后的 48 位密钥。
3.4 解密
DES 的一个优点是，解密函数与加密函数是一致的。这是因为 DES 是基于 Feistel 网络。与加密过程相比，解密的密钥策略是正好相反的，及在解密的第一轮使用的密钥是第 16 轮的加密密钥，在第二轮，解密密钥用的第 15 轮的加密密钥，以此类推。
反向密钥策略
我们第一个问题是，给到 DES 的初始密钥 k 如何可以轻松得到 \(K_16\)。注意到，我们看到上面的 \(C_0 = C_{16}\) 且 \(D_0 = D_{16}\)，因此 \(k_{16}\)
\[k_{16} = PC - 2(C_{16}，D_{16})\\ = PC - 2(C_0，D_0) \\ = PC - 2(PC - 1(k)) \]
为了计算 \(k_{15}\) 我们需要计算中间变量 \(C_{15}\) 及 \(D_{15}\)，这是可以通过 \(C_{16}\) 及 \(D_{16}\)
\[k_{15} = PC - 2(C_{15}，D_{15}) \\ = PC - 2(RS_2(C_{16})，RS_2(D_{16})) \\ = PC - 2(RS_2(C_0)，RS_2(D_0)) \]
其他轮的子密钥按照相似的方式通过循环右移得到，并遵循下面的规则：
- 第一轮解密，密钥没有移位
- 在解密轮 2，9 以及 16 两半密钥都循环右移一位
- 在其他轮，两半循环右移两位
Feistel 网络中的解密
为什么解密与加密使用相同的函数。基础的思想是解密函数以一轮一轮的方式对 DES 加密逆计算。这意味着，第一轮解密是第十六轮的逆，解密的第二轮是第十五轮的逆，以此类推。 注意到在最有一轮的 DES 中，左半边与右半边进行了交换：
\[(L_0^d，R_0^d) = IP(Y) = IP(IP^{-1}(R_{16}，L_{16})) = (R_{16}，L_{16}) \]
因此有：
\[L_0^d = R_{16} \\ R_0^d = L_{16} = R_{15} \]
我们在所有解密轮对应的变量上都待有 d 标识。我们现在可以看一下第一个解密轮对最后一个加密轮做逆操作。首先，我们将第一轮解密的输出值表示为\((L_1^d，R_1^d)\)，并将解密最后一轮的输入值表示为 \((L_{15}，R_{15})\)。有：
\[L_1^d = R_0^d = L_{16} = R_{15} \]
现在可以看一下 \(R_1^d\)
\[R_1^d = L_0^d \oplus f(R_0^d，k_{16}) = R_{16} \oplus f(L_{16}，k_{16}) \\ R_1^d = [L_{15} \oplus f(R_{15}，k_{16})] \oplus f(R_{15}，k_{16}) \\ R_1^d = L_{15} \oplus [f(R_{15}，k_{16}) \oplus f(R_{15}，k_{16})] = L_{15} \]
关键的步骤在上述最后一个等式中表示，\(f\) 函数与 \(L_{15}\) 进行两次异或，\(f\) 就被消掉了，因此有 \(R_1^d = L_{15}\)。后面的 15 轮解密可以表示为：
\[L_i^d = R_{16 - i}，\\ R_i^d = L_{16 - i} \]
其中 \(i = 0，1，...，16\)，在最后一轮解密轮有：
\[L_{16}^d = R{16 - 16} = R_0 \\ R_{16}^d = L_0 \]
在解密的最后过程，我们进行初始置换的逆：
\[IP^{-1}(R_{16}^d，L_{16}^d) = IP^{-1}(L_0，R_0) = IP^{-1}(IP(x)) = x \]
\(x\)
3.5 DES 安全性
就像我们之前讨论过的，加密运算会可能会受到多种方式攻击。在 DES 提出后，已经有两个大家比较担心的点：
- 密钥空间太小，既比较容易被暴力破解
- S 盒设计标准是保密的，因此可能存在分析攻击
后面会介绍两周类型的攻击手段。我们先将结论放在这里：在 DES 的声明周期中，分析攻击是低效的，但是 DES 现在可以轻松通过穷举密钥的方式攻击，因此单纯的 DES 不再适合当前大部分的应用了。
3.5.1 穷举密钥搜索
最初由 IBM 提出的运算具有 128 位密钥长度，但是后来降为 56 位。官方通告是，这样的运算可以在 1974 年的单片机上简单实现。使用穷举法暴力破解的原则：
定义3.5.1 DES 穷举密钥搜索，输入至少是一对原文-密文对(x，y)，输出： k，这样有：
\[y = DES_k(x) \]
攻击：穷举所有可能的 \(2^{56}\)
\[DES_{k_i}^{-1}(y) = x，i = 0，1，...，2^{56} - 1 \]
有 \(1/2^{16}\)
DES 暴力破解攻击随着硬件价格的下降，成本变得越来越低。在 2006 年，COPACOBANA: Cost-Optimized Parallel Code-Breaker 机基于商业集成电路，破解 DES 平均使用时间少于 7 天，构建硬件只需要一万美圆。
总而言之，在今天 56 位的密钥长度还是太短了。因此，单 DES 只在短期安全应用中使用(可能只需保密几小时)，或者待加密的数据价值非常低。不过 DES 的变体，尤其是 3DES 依旧是安全的。
3.5.2 分析攻击
就像第一章中介绍的那样，分析攻击是十分强劲的手段。不过无论是由 Eli Biham & Adi Shamir 发明的微分解密分析(DC: Differential crypt-analysis)还是由 Mitsuru Matsui 发明的线性解密分析(LC: Linear cryptanalysis)的解密能力都取决于 S 盒的设计。
无论使用 DC 还是使用 LC，攻击者都需要海量的原文-密文对，这显然是不现实的。
3.6 软件与硬件实现
软件
直接使用软件实现 DES 的性能会特别差，这是因为 DES 中有大量的位运算，尤其是 E 与 P 置换。相似的，S 盒使用硬件实现也更高效。实现 DES 一般方法是将预计算的值组成表，需要时直接查表。经优化后，在 32 位 CPU 上加密一块数据需要 240 周期。在一个 2 GHz 的 CPU 可以达到 533 Mbps 的性能。3DES，相较于 DES 更加安全，但是只能以 1/3 DES 的速度运行。没有优化的实现会更慢，通常低于 100 Mbps。
硬件
硬件实现 DES 是十分高效的。置换如 \(E，P，IP，IP^{-1}\) 等使用硬件实现十分简单。小的 \(6\times 4\)
实现一轮的 DES 可能需要消耗 3000 个逻辑门。使用硬件实现的 DES 运算是十分快速的，大概能够跑到 100 Gbps。
3.7 DES 备选
存在很多其他的块运算加密算法。
3.7.1 高级加密标准 (AES) 以及 AES 最终加密
现今，很多的应用都选择使用 AES: Advanced Encryption Standard 算法。AES 为防止暴力破解有三种密钥长度，分别为 128、192、256 位，目前为止，没有有效的分析攻击能够有效破解算法。
3.7.2 三重 DES(3DES) 以及 DESX
AES 的备选方案是 3DES: triple DES，3DES 由三重子 DES 加密组成:
\[y = DES_{k_3}(DES_{k_2}(DES_{k_1}(x))) \]
这三重 DES 使用不同的密钥。
3DES 现在尚可以有效方式暴力破解与分析攻击。
另一个版本的 3DES 是：
\[y = DES_{k_3}(DES_{k_2}^{-1}(DES_{k_1}(x))) \]
3DES 使用硬件实现是十分高效的。
3.7.3 轻量级加密 PRESENT
略
