Python实战线性密码分析：从DES算法破解看现代密码学安全

1. 项目概述：当经典密码学遇上现代脚本

1993年，密码学界发生了一件震动整个行业的大事：日本学者松井充（Mitsuru Matsui）成功利用线性密码分析（Linear Cryptanalysis）在理论上攻破了当时作为全球金融与通信安全基石的DES算法。这不仅仅是宣告了一个特定算法的“退休”，更重要的是，它向世界展示了一种全新的、系统性的密码分析思路。对于很多刚接触密码学的朋友来说，线性密码分析听起来高深莫测，充满了复杂的数学公式和概率统计。但它的核心思想，其实可以用一个更生活化的视角来理解：在一场看似完全随机的抛硬币游戏中，寻找那一点点微乎其微的“偏好”。

这个项目，就是带你亲手用Python这把“手术刀”，去解剖这个经典的密码学案例。我们不会停留在理论公式的推导上，而是通过一行行可运行的代码，去模拟松井教授当年的破译思路。你会发现，所谓的“攻破”，并不是像电影里演的那样瞬间破解密码，而是一个基于大量已知明密文对，通过统计分析，一点点“撬开”算法内部秘密钥匙（密钥）的过程。DES算法虽然如今已不再安全，但其结构清晰，是学习分组密码和密码分析的绝佳教具。通过复现针对它的攻击，你能深刻理解现代密码算法设计为何要抵抗线性分析，以及像AES这样的新算法在哪些关键点上做了加固。

无论你是信息安全专业的学生，对密码学充满好奇的开发者，还是希望深入理解“攻击视角”以更好地进行防御的安全工程师，这个项目都提供了一个绝佳的动手实践机会。你不需要是数学天才，但需要具备基本的Python编程能力和对逻辑推理的热情。我们将从DES的基本结构讲起，一步步构建线性逼近表达式，用Python处理海量数据，最终计算出密钥的部分比特。整个过程，就像完成一次精密的科学实验，数据会告诉你答案。

2. 核心思路拆解：线性密码分析究竟在分析什么？

在深入代码之前，我们必须先抛开畏惧，搞清楚线性密码分析到底想干什么。DES算法是一个对称分组密码，它把64位的明文，通过一个56位的密钥，加密成64位的密文。这个过程中包含了初始置换、16轮Feistel结构迭代、最终置换等步骤，内部还有著名的S盒进行非线性替换。从设计上看，整个加密过程应该是高度复杂和非线性的，理论上，密文的每一位与明文的每一位、密钥的每一位之间的关系应该是随机的，就像完美的抛硬币，正反面概率各50%。

线性密码分析的终极目标，就是在这看似完美的随机性中，寻找一种不完美的、可被利用的“线性关系”。这种关系不是确定性的等式（比如A+B=C），而是一种概率性的倾向。具体来说，它试图找到明文某些比特、密文某些比特和密钥某些比特的一个线性组合（即对这些比特进行异或XOR运算），使得这个组合成立的概率显著地偏离1/2（比如是0.5 + ε，其中ε是一个很小的值，称为偏差）。

2.1 理解“线性逼近”与S盒的脆弱性

为什么会有这种偏差呢？根源在于DES的核心非线性组件——S盒。每个S盒是一个6位输入、4位输出的查找表。虽然S盒整体是非线性的，但密码学家发现，对于某些特定的输入比特组合和输出比特组合，它们之间异或结果为0（或为1）的概率并不是严格的50%，而是存在微弱的偏差。例如，对于DES的第一个S盒（S1），可能有这样的统计规律：输入的第1位与第3位的异或值，等于输出的第2位与第4位的异或值，这个事件发生的概率是12/64 ≈ 0.1875，而不是0.5。这个偏差（0.5 - 0.1875 = 0.3125）就相当大了。

注意：这里提到的具体比特位置和概率值是示例，实际分析中需要查阅DES的S盒线性逼近表（Linear Approximation Table, LAT）来获取所有高偏差的线性逼近。这个表是通过穷举S盒所有可能的输入（64种），统计所有可能的输入/输出线性掩码组合计算出来的，是线性分析的“弹药库”。

一轮DES的线性关系非常微弱，但DES有16轮。线性密码分析的精妙之处在于，可以将每一轮S盒的微弱线性关系，通过密钥加和置换操作“链接”起来，贯穿多轮，最终形成一个连接了部分明文比特、部分密文比特和部分轮密钥比特的线性表达式。这个贯穿多轮的表达式，其偏差会随着轮数的增加而急剧减小（大致按每轮偏差的乘积衰减），但通过选择偏差最大的路径，我们仍然能得到一个可观测的、非随机的概率。

2.2 松井（Matsui）算法的两步走策略

松井教授提出的实际攻击方法，是一个分为两步的、非常务实的策略：

1. 第一步：数据收集与统计分析

   • 攻击者需要收集大量的“已知明密文对”（Known Plaintext-Ciphertext Pairs）。也就是说，你知道某一组明文输入是什么，也知道用目标密钥加密后对应的密文输出是什么，但你不知道密钥本身。
   • 对于每一对明密文，代入我们事先找好的、那个贯穿多轮的最终线性逼近表达式。这个表达式里包含了一些密钥比特（称为“相关密钥比特”）。由于我们不知道密钥，表达式可能成立也可能不成立。
   • 但是，如果我们猜测这几位相关密钥比特的值（比如，总共6位密钥比特，有2^6=64种可能），那么对于每一种猜测，我们都可以重新计算这个表达式是否成立。
   • 关键来了：如果我们的密钥猜测是错误的，那么由于密钥加错了，相当于在表达式中引入了额外的随机变量，这会使得整个表达式成立的概率非常接近1/2。如果我们收集了N对明密文，那么表达式成立的次数应该大致在N/2附近波动。
   • 如果我们的密钥猜测是正确的，那么表达式成立的概率就应该等于我们理论计算出的那个有偏差的概率P（比如0.5+ε）。因此，表达式成立的次数会显著地偏离N/2。
   • 因此，第一步的目标就是：遍历所有相关密钥比特的可能取值，统计每种取值下线性表达式成立的次数。成立次数偏离N/2最远的那一个（或几个）密钥猜测，就是最有可能的正确密钥。这一步通常可以恢复出最后一轮子密钥（或第一轮子密钥）的部分比特。

2. 第二步：密钥穷举与验证

   • 第一步通常只能恢复出完整56位密钥中的一部分（比如30-40位）。剩下的密钥比特数量已经大大减少。
   • 此时，攻击者就可以对剩下的密钥空间进行穷举搜索。例如，如果第一步恢复了40位密钥，那么剩下16位未知，只需要尝试2^16=65536种可能性。
   • 对于每一种完整的密钥猜测，用一两对明密文进行验证，很快就能找到唯一正确的密钥。

我们的Python模拟，将重点复现第一步，也就是最体现线性分析精髓的统计攻击部分。通过这个过程，你会直观地感受到，如何从海量数据中“沙里淘金”，利用微弱的统计偏差来撬开密码系统。

3. 环境准备与DES基础实现

在开始模拟攻击之前，我们需要一个能够正常工作的DES加密/解密函数作为我们的“靶子”。虽然Python标准库没有DES，但我们可以利用pycryptodome库，或者为了更透彻地理解，自己实现一个简化版的DES。为了教学清晰，这里我们选择自己实现一个功能完整的DES，但这会涉及大量位操作。在实际项目中，你可以直接使用pycryptodome的DES模块作为攻击目标。

3.1 Python环境与必要库

确保你安装了Python 3.6以上版本。我们主要会用到以下库：

• numpy：用于高效的数值计算和统计。
• itertools：用于生成密钥猜测的组合。
• （可选）tqdm：用于显示进度条，在遍历大量数据时体验更好。

可以通过pip安装：

pip install numpy tqdm

3.2 实现一个用于教学的DES类

为了完全理解攻击过程，自己实现DES是关键一步。这里给出核心结构的框架，你需要填充置换表、S盒等具体数据（这些数据可以在DES标准文档中找到）。

class MyDES: # 这里需要定义所有常量：初始置换IP表、逆初始置换IP^-1表、扩展置换E表、 # 置换函数P表、8个S盒（每个是4x16的矩阵）、置换选择PC1、PC2表等。 # 篇幅所限，不在此处完整列出所有64个元素的表。 def __init__(self, key: int): """使用64位整数密钥初始化，实际使用56位（每字节第8位为奇偶校验位）""" self.round_keys = self._generate_round_keys(key) def _generate_round_keys(self, key: int): """生成16轮48位的子密钥""" # 1. 通过PC1置换，从64位中选出56位有效密钥位 # 2. 将这56位分成左右各28位的C0和D0 # 3. 进行16轮循环左移（每轮移位数不同） # 4. 每一轮后，通过PC2置换压缩成48位子密钥 # 5. 返回一个包含16个子密钥（整数）的列表 round_keys = [] # ... 具体实现位操作和查表 ... return round_keys def encrypt(self, plaintext: int) -> int: """加密一个64位的明文块，返回64位密文""" # 1. 初始置换IP state = self._permute(plaintext, self.IP_TABLE, 64) L, R = (state >> 32) & 0xFFFFFFFF, state & 0xFFFFFFFF # 2. 16轮Feistel结构 for i in range(16): new_R = L ^ self._feistel_function(R, self.round_keys[i]) L, R = R, new_R # 3. 最后交换左右32位（第16轮后不交换，但前面循环已经交换了，这里需要再换回来？注意实现细节） # 标准实现是：最后一轮后不交换，所以循环16轮后，结果是(R16, L16) # 我们这里假设循环内已经完成了交换，那么最终组合是 (R, L) combined = (R << 32) | L # 4. 逆初始置换IP^-1 ciphertext = self._permute(combined, self.IP_INV_TABLE, 64) return ciphertext def _feistel_function(self, half_block: int, round_key: int) -> int: """Feistel轮函数，输入32位，输出32位""" # 1. 扩展置换：32位 -> 48位 expanded = self._permute(half_block, self.E_TABLE, 32) # 2. 与轮密钥异或 xored = expanded ^ round_key # 3. S盒替换：48位 -> 32位 sbox_output = 0 for i in range(8): # 取出6位输入 six_bits = (xored >> (42 - i*6)) & 0x3F # 计算S盒的行和列 row = ((six_bits >> 5) << 1) | (six_bits & 0x01) col = (six_bits >> 1) & 0x0F # 查表得到4位输出 sbox_val = self.S_BOXES[i][row][col] sbox_output = (sbox_output << 4) | sbox_val # 4. P置换 result = self._permute(sbox_output, self.P_TABLE, 32) return result def _permute(self, block: int, table: list, input_bits: int) -> int: """通用的置换函数，根据table将input_bits位的block置换""" result = 0 for pos in table: result <<= 1 # table中的位置是从1开始计数的，我们需要取block中对应的比特 bit = (block >> (input_bits - pos)) & 0x01 result |= bit return result # 同样需要实现decrypt解密函数，过程是加密的逆过程。

实操心得：自己实现DES是一个很好的练习，但极易在置换表、S盒索引计算、比特序等细节上出错。一个有效的调试方法是：找一组标准的测试向量（明文、密钥、密文），例如从NIST的文档中获取，确保你的加密函数能得出完全一致的结果。如果只是为了攻击模拟，使用from Crypto.Cipher import DES并确保模式为DES.MODE_ECB会更高效可靠。

4. 构建线性逼近：寻找贯穿DES的脆弱路径

这是线性密码分析中最具技术含量的一步。我们不需要从零开始进行复杂的数学推导，而是可以借鉴松井教授等先驱已经计算好的成果。我们的目标是找到一个针对3轮DES的线性逼近表达式，因为这是构建更多轮攻击的基础。在实际的16轮DES攻击中，松井使用了“1-16-1”或“2-14-2”等结构的线性特征（即攻击首尾几轮，中间多轮作为一个整体考虑其概率）。

为了简化教学，我们模拟一个针对3轮DES的线性分析，这足以阐明所有核心概念。假设我们通过研究S盒的线性逼近表（LAT），找到了一条贯穿3轮的路径，并推导出如下形式的线性表达式：

P[i1] ⊕ P[i2] ⊕ ... ⊕ C[j1] ⊕ C[j2] ⊕ ... ⊕ K[k1] ⊕ K[k2] ⊕ ... = 0(成立概率 p = 1/2 + ε)

其中P代表明文比特，C代表密文比特，K代表密钥比特（可能是轮密钥的某些比特的组合），⊕表示异或运算。等号右边的0表示这个异或链的结果为0的概率是p。

例如，一个高度简化的例子可能是（请注意，这是为了说明而虚构的，并非真实有效的DES逼近）：P[7] ⊕ P[18] ⊕ C[12] ⊕ C[25] ⊕ K[22] ⊕ K[43] = 0，其概率偏差ε = 0.2。

4.1 从S盒逼近到多轮特征

如何得到这样一个表达式呢？过程如下：

1. 分析单个S盒：对每个S盒，构建其线性逼近表。LAT的每一项(α, β)记录了当输入掩码为α（选择哪些输入比特参与异或）、输出掩码为β（选择哪些输出比特参与异或）时，等式α · X ⊕ β · S(X) = 0成立的次数（或概率），其中·表示点积（即按位与后异或）。偏差大的(α, β)对就是好的线性逼近。
2. 连接单轮：在一轮DES中，轮函数的输出经过P置换后与左半部分异或。因此，需要将S盒输出的线性掩码，通过P置换的逆操作，映射回轮函数的输入位置，再与上一轮的线性关系结合。
3. 堆叠成多轮特征：将多轮的线性关系串联起来。每一轮都会引入该轮使用的轮密钥比特的参与。当两条路径在Feistel结构的左右分支交汇时，需要处理异或操作带来的影响（根据线性关系，(A⊕B)的线性表达式等于A的表达式异或B的表达式）。

这个过程非常繁琐，涉及大量的比特跟踪和概率计算（偏差按每轮特征偏差的乘积衰减）。在我们的Python模拟中，我们将跳过最复杂的推导过程，直接使用一个从文献中获取的、针对简化轮数DES的、已知偏差的线性表达式作为我们的“武器”。我们的重点是学会如何使用这个“武器”。

假设我们通过查阅资料，确定使用以下针对3轮DES的线性特征（具体比特位置是示例）：

• 明文参与比特：P[17], P[18]（比特位置从1开始计数，对应明文的第17、18位）
• 密文参与比特：C[5], C[6], C[7], C[8]（对应3轮加密后密文的第5-8位）
• 相关密钥比特：K1[22], K3[43]（这里K1和K3分别代表第1轮和第3轮的子密钥中的某些比特。注意，子密钥比特需要通过密钥调度算法映射回主密钥比特）。
• 线性表达式：P[17] ⊕ P[18] ⊕ C[5] ⊕ C[6] ⊕ C[7] ⊕ C[8] ⊕ K1[22] ⊕ K3[43] = 0
• 理论偏差ε：假设我们计算或查得这个特征的概率是p = 0.75，那么偏差ε = |p - 0.5| = 0.25。这是一个非常大的偏差，仅用于教学演示，真实攻击中偏差要小得多。

在代码中，我们需要实现函数来提取一个64位整数的特定位，并计算这个线性表达式的值（在给定密钥猜测的情况下）。

def get_bit(data: int, pos: int, total_bits=64) -> int: """获取整数data的第pos位（1-indexed，从左到右或从最高位开始取决于约定）。 通常DES标准中，位1是最高有效位(MSB)。我们这里约定pos=1对应最高位。 """ # 因为整数在内存中是二进制，我们约定位置1是最高位(第63比特位)。 # 所以 pos=1 -> 移位 (total_bits - 1) shift = total_bits - pos return (data >> shift) & 1 def compute_linear_expression(plaintext: int, ciphertext: int, key_guess: int) -> int: """ 计算线性表达式的值（0或1）。 key_guess: 一个整数，其低位比特代表我们对相关密钥比特的猜测。 例如，假设相关密钥比特是2位，那么key_guess=0,1,2,3。 我们需要根据key_guess解析出K1[22]和K3[43]的具体值。 """ # 提取明文比特 p17 = get_bit(plaintext, 17) p18 = get_bit(plaintext, 18) # 提取密文比特 c5 = get_bit(ciphertext, 5) c6 = get_bit(ciphertext, 6) c7 = get_bit(ciphertext, 7) c8 = get_bit(ciphertext, 8) # 从key_guess中解析密钥比特。假设key_guess的最低比特是K1[22]，次低比特是K3[43] k1_bit = (key_guess >> 0) & 1 # 假设key_guess第0位对应K1[22] k3_bit = (key_guess >> 1) & 1 # 假设key_guess第1位对应K3[43] # 计算线性表达式：所有比特异或 result = p17 ^ p18 ^ c5 ^ c6 ^ c7 ^ c8 ^ k1_bit ^ k3_bit return result

有了这个函数，我们就可以对每一对明密文，在给定的密钥猜测下，计算线性表达式是0还是1。

5. 模拟攻击：统计与密钥恢复

现在进入最激动人心的部分：模拟攻击。我们将扮演攻击者，拥有一个用未知密钥加密的DES黑盒（我们的MyDES类实例），并且我们可以获取到大量的明密文对。

5.1 生成测试数据

首先，我们生成一个随机的56位密钥（实际上用64位整数表示，但每字节第8位是奇偶位），并创建加密实例。然后，随机生成N个明文，并加密得到对应的密文。

import random import itertools def generate_test_data(num_pairs, true_key): """ 生成已知明密文对。 true_key: 真实的DES密钥（64位整数，含奇偶位）。 """ des = MyDES(true_key) data = [] for _ in range(num_pairs): plaintext = random.getrandbits(64) # 随机生成64位明文 ciphertext = des.encrypt(plaintext) data.append((plaintext, ciphertext)) return data

5.2 实施线性分析统计

根据松井的第一步算法，我们对所有可能的密钥猜测进行统计。在我们的例子中，相关密钥比特是K1[22]和K3[43]，共2位，所以有4种可能的猜测（0, 1, 2, 3）。

def linear_cryptanalysis_attack(data): """ 执行线性密码分析。 data: 列表，包含多个(plaintext, ciphertext)元组。 返回最可能的密钥猜测及其统计量。 """ num_key_guesses = 4 # 2位密钥比特 -> 4种猜测 # 初始化一个计数器，记录每个密钥猜测下，线性表达式成立（结果为0）的次数 count_zero = [0] * num_key_guesses for plaintext, ciphertext in data: for key_guess in range(num_key_guesses): expr_value = compute_linear_expression(plaintext, ciphertext, key_guess) if expr_value == 0: count_zero[key_guess] += 1 # 计算每个猜测对应的“成立次数”与期望值（N/2）的绝对偏差 N = len(data) expected = N / 2.0 deviations = [abs(count - expected) for count in count_zero] # 找到偏差最大的密钥猜测 best_guess = deviations.index(max(deviations)) best_deviation = max(deviations) return best_guess, best_deviation, count_zero, deviations

5.3 运行攻击并分析结果

现在，让我们运行整个模拟，看看需要多少明密文对才能可靠地恢复出这2位密钥。

def main(): # 1. 设置真实密钥（示例） true_key = 0x133457799BBCDFF1 # 这是一个标准的DES测试密钥 # 注意：我们需要知道在这个真实密钥下，我们攻击的K1[22]和K3[43]的真实值是多少。 # 这需要通过密钥调度算法计算出来。这里我们假设通过计算得知真实值为 key_guess = 2 (二进制10)。 true_partial_key = 2 # 2. 尝试不同数量的明密文对 test_sizes = [100, 1000, 5000, 10000, 50000] results = [] for N in test_sizes: print(f"\n=== 使用 {N} 对明密文进行攻击 ===") data = generate_test_data(N, true_key) best_guess, best_dev, counts, devs = linear_cryptanalysis_attack(data) print(f" 每个密钥猜测下表达式成立次数: {counts}") print(f" 与期望值{N/2}的偏差: {devs}") print(f" 最可能的密钥猜测: {best_guess} (二进制: {bin(best_guess)[2:].zfill(2)})") print(f" 最大偏差: {best_dev:.2f}") print(f" 猜测是否正确: {best_guess == true_partial_key}") results.append((N, best_guess, best_dev, best_guess == true_partial_key)) # 3. 分析结果 print("\n=== 攻击结果总结 ===") for N, guess, dev, correct in results: status = "成功" if correct else "失败" print(f"N={N:6d}: 猜测={guess}, 偏差={dev:7.1f}, 状态={status}")

运行这段代码，你会观察到随着明密文对数量N的增加，统计结果会越来越清晰。当N较小时（如100对），由于随机噪声，错误的密钥猜测也可能产生较大的偏差，导致攻击失败。当N增大到数千或上万时，正确密钥猜测对应的偏差会显著地、稳定地高于其他错误猜测，从而使攻击成功。

核心原理解读：为什么正确猜测的偏差会更大？因为当密钥猜测正确时，我们计算的线性表达式P[...]⊕C[...]⊕K[...]实际上等于我们理论推导出的那个有偏差的线性关系（其值为0的概率是p=0.5+ε）。因此，它成立的次数会围绕N * p波动。而当密钥猜测错误时，错误的密钥比特相当于在表达式中引入了一个随机的偏移（因为K_wrong ⊕ K_right是一个未知的固定值，但它会改变整个表达式的概率，使其趋近于1/2），因此成立的次数会围绕N/2波动。N越大，根据大数定律，这两种情况的区分度就越明显。

5.4 扩展到更多密钥比特与完整攻击

我们模拟的只是2位密钥比特。在真实的DES线性攻击中，松井的第一步通常针对最后轮（或首轮）的子密钥的多个S盒的有效位进行攻击，可能涉及30位以上的密钥比特。此时，密钥猜测空间会急剧扩大（2^30约10亿），不能简单地遍历。

优化策略：

1. 分而治之：DES的轮函数是8个S盒并行工作的。每个S盒的输入依赖于6位子密钥和扩展后的6位数据。线性分析可以针对每个S盒独立进行。因为一个好的线性特征通常只涉及少数几个S盒的输入输出。我们可以分别攻击这少数几个S盒所依赖的子密钥比特（每个S盒最多6位），大大降低了每次需要遍历的密钥空间（例如，攻击3个S盒，最多18位，2^18=262k，是可遍历的）。
2. 使用更高效的统计量：除了直接统计成立次数，还可以计算|count - N/2|，或者使用平方和、似然函数等作为判断依据。
3. 利用多个线性特征：可以同时使用多个偏差较大的线性特征进行攻击，综合它们的结果来提高成功率或减少所需数据量。

在第一步成功恢复出部分轮密钥比特后，第二步就是穷举剩余的主密钥比特。因为DES密钥调度算法是确定的，已知部分轮密钥比特可以反向推导出主密钥的部分比特，并对未知部分进行穷举。例如，如果第一步恢复了30位，剩下26位未知，只需穷举2^26 ≈ 6700万次，这在现代计算机上是完全可行的。

6. 常见问题、调试技巧与深度思考

在实际编写和运行这个模拟程序时，你几乎一定会遇到各种问题。下面是我在复现过程中踩过的坑和总结的经验。

6.1 问题排查清单

6.2 关键调试技巧

1. 从小处着手，逐步验证：不要一开始就运行万级别的攻击。先用一个你知道部分密钥的实例（比如，你设定密钥，并计算出相关密钥比特的真实值），用10对、100对数据跑一下，看看正确密钥猜测的计数是否如预期般有“苗头”。
2. 打印中间结果：在compute_linear_expression函数里，临时打印出明文、密文、密钥猜测下的各个比特值，手动验算几组，确保异或逻辑正确。
3. 可视化偏差：将不同N值下的最大偏差绘制成图，可以看到偏差随着N增长而增大的趋势（对于正确猜测），而错误猜测的偏差则围绕0随机波动。这能给你直观的信心。
4. 使用已知的库作为“靶子”：为了排除DES实现错误的干扰，在初步验证攻击逻辑时，可以使用pycryptodome的DES实现作为被攻击对象。确保你的攻击脚本能对你已知的密钥生效。

6.3 线性密码分析的局限与现代启示

通过这次模拟，你应该深刻感受到了线性密码分析的威力与代价。它的威力在于，这是一种唯密文攻击（理论上）的通用方法，但已知明密文攻击效率更高。它不依赖于算法的任何实现缺陷，只依赖于算法本身数学结构上的微小不平衡。它的代价在于，需要海量的已知数据，并且分析过程复杂。

DES被攻破直接导致了3DES的过渡和AES的征集。AES在设计时，其S盒和整体结构就专门针对线性密码分析和差分密码分析进行了强化，使得任何线性特征的偏差都极小，从而将所需的数据复杂度提升到完全不现实的程度（例如2^100以上）。

对于开发者而言，这个项目的启示是：

• 不要自己发明密码算法：设计一个能抵抗线性分析等高级分析的算法极其困难。
• 使用经过时间检验的标准算法：如AES-256。
• 正确使用密码学：即使算法本身安全，错误的使用模式（如ECB模式）、弱密钥、不恰当的IV等也会引入漏洞。
• 理解攻击思维：学习攻击方法不是为了攻击，而是为了更深刻地理解如何防御。知道线性分析的存在，你就会明白为什么算法的非线性部件如此关键。

最后，这个Python模拟项目就像一个密码学显微镜，让你亲眼看到统计规律如何战胜看似坚固的复杂系统。当你看到随着数据量增加，那条代表正确密钥的统计曲线脱颖而出时，那种感觉，正是密码学研究的魅力所在。你可以尝试修改代码，使用更真实的、偏差更小的线性特征，体验一下需要多少数据才能成功；或者尝试将攻击扩展到更多轮DES，感受一下密码分析学家在数据复杂度和计算复杂度之间所做的精妙权衡。