密码学实战：从古典密码到AES的破解与安全实践

1. 项目概述：一次从古至今的密码学实战之旅

“密码学实战：从古典密码到AES，手把手教你破解常见加密算法”这个标题，听起来就充满了动手的乐趣和挑战性。它不是一个枯燥的理论讲座，而是一场穿越密码学历史的实战演练。作为一名在信息安全领域摸爬滚打多年的从业者，我深知密码学是网络安全的基石，但书本上的公式和定理常常让人望而生畏。这个项目的核心价值在于，它通过“破解”这个逆向视角，带你亲手触摸密码算法的“脉搏”，让你在拆解中理解其构建原理。无论是想入门网络安全的新手，还是希望巩固密码学基础的开发者，甚至是CTF（Capture The Flag）竞赛的爱好者，都能从中获得实实在在的收获。我们将从最简单的替换密码开始，一步步深入到现代广泛使用的AES对称加密，在每一次“攻”与“防”的实践中，理解加密算法为何这样设计，以及它的弱点究竟在哪里。这不仅仅是学习破解，更是为了在未来的工作中，能更安全、更明智地使用加密技术。

2. 古典密码学：密码世界的基石与手工破解艺术

古典密码学是现代密码学的源头，其算法通常依赖人工或简单的机械工具实现，安全性基于算法的保密性而非密钥的保密性。理解它们，是理解所有加密思想的基础。我们将从两种最经典的算法入手，亲手实现并破解它们。

2.1 凯撒密码：位移的艺术与频率分析的初现

凯撒密码可能是历史上最著名的密码之一，其原理简单到令人惊讶：将明文中的每个字母在字母表中向后（或向前）移动一个固定的位数，这个位数就是密钥。例如，当密钥为3时，A变成D，B变成E，以此类推。

实操实现（Python示例）：

def caesar_encrypt(text, shift): result = "" for char in text: if char.isupper(): result += chr((ord(char) + shift - 65) % 26 + 65) elif char.islower(): result += chr((ord(char) + shift - 97) % 26 + 97) else: result += char # 非字母字符原样保留 return result plaintext = "HELLO CRYPTO" shift_key = 3 ciphertext = caesar_encrypt(plaintext, shift_key) print(f"密文: {ciphertext}") # 输出: KHOOR FUBSWR

手工破解实战：凯撒密码的密钥空间极小，只有25种可能（移位1-25位，移位0或26等于没加密）。最直接的破解方法就是暴力穷举，也称为“暴力破解”。我们可以写一个简单的程序尝试所有可能的移位。

def caesar_brute_force(ciphertext): for shift in range(1, 26): decrypted = "" for char in ciphertext: if char.isupper(): decrypted += chr((ord(char) - shift - 65) % 26 + 65) elif char.islower(): decrypted += chr((ord(char) - shift - 97) % 26 + 97) else: decrypted += char print(f"Shift {shift:2d}: {decrypted}") ciphertext = "KHOOR FUBSWR" caesar_brute_force(ciphertext)

运行后，你会看到25行输出，其中Shift 3那一行会清晰地显示HELLO CRYPTO。对于人眼来说，从25个结果中识别出有意义的单词或句子是轻而易举的。

注意：在实际的古典密码分析中，当文本足够长时，我们会使用频率分析。在英文中，字母E的出现频率远高于其他字母。通过统计密文中各字母的频率，并与英文字母标准频率分布进行对比，可以更智能地推测出移位量，而不是盲目尝试所有可能。这是密码分析学中第一个重要的统计学思想。

2.2 维吉尼亚密码：多表替代与卡西斯基试验的博弈

凯撒密码的致命弱点是单表替代，即一个明文字母永远对应同一个密文字母。维吉尼亚密码通过引入一个关键词，实现了多表替代，大大增强了安全性。加密时，将关键词重复至与明文等长，然后每个明文字母的移位量由关键词对应字母的顺序值（A=0, B=1...）决定。

例如，明文ATTACKATDAWN，关键词LEMON。 关键词扩展：LEMONLEMONLE加密过程：A（明文） + L（密钥，L=11） = L（密文）；T（19） + E（4） = X（23）... 以此类推。

实操实现：

def vigenere_encrypt(plaintext, key): key = key.upper() key_length = len(key) ciphertext = [] for i, char in enumerate(plaintext.upper()): if char.isalpha(): shift = ord(key[i % key_length]) - 65 encrypted_char = chr((ord(char) - 65 + shift) % 26 + 65) ciphertext.append(encrypted_char) else: ciphertext.append(char) return ''.join(ciphertext) plaintext = "ATTACKATDAWN" key = "LEMON" cipher = vigenere_encrypt(plaintext, key) print(f"密文: {cipher}") # 输出: LXFOPVEFRNHR

破解实战：卡西斯基试验与频率分析结合破解维吉尼亚密码的关键在于确定密钥长度。卡西斯基试验基于一个观察：明文中相同的单词或短语（如“THE”）被相同的关键词片段加密后，会产生相同的密文片段。在密文中寻找重复的片段，计算它们之间的距离，这些距离的最大公约数很可能就是密钥长度。

1. 寻找重复片段：在密文中人工或编程寻找长度至少为3的重复字符序列，记录其出现位置。
2. 计算间距：计算每对重复序列起始位置的距离。
3. 推测密钥长度：所有这些间距的公约数（特别是最大公约数）很可能是密钥长度。

确定密钥长度n后，密文可以被分解为n组，每组都是由单一凯撒密码加密的（因为每组都使用同一个密钥字母）。然后，对每一组单独使用针对凯撒密码的频率分析，推测出该组使用的密钥字母。将n个密钥字母组合起来，就得到了完整的关键词。

实操心得：对于很短的密文，卡西斯基试验可能失效，因为可能没有足够的重复序列。此时，可以使用重合指数法。重合指数是文本中随机抽取两个字母相同的概率。英文纯文本的重合指数大约为0.065，而随机文本约为0.038。通过计算密文在不同假设密钥长度下分组的重合指数，接近0.065的那个长度就是最可能的密钥长度。这是古典密码分析中一个非常精巧的统计学工具。

3. 现代密码学入门：从DES到AES的演进与核心概念

古典密码在计算机面前不堪一击，现代密码学建立在严格的数学原理之上，并且遵循一个核心原则：算法的安全性应仅依赖于密钥的保密，而算法本身可以公开。这被称为柯克霍夫原则。我们从DES开始，理解分组密码的基本结构。

3.1 DES算法：Feistel网络结构与密钥空间危机

DES是历史上第一个被广泛采用的标准化加密算法。它将64位明文分组加密为64位密文分组，使用56位密钥（实际64位，其中8位用于奇偶校验）。其核心结构是Feistel网络。

Feistel网络精讲：这是一种非常巧妙的设计，它使得加密和解密过程可以使用几乎相同的结构。对于一个分组，将其分为左半部分（L0）和右半部分（R0）。在每一轮（共16轮）中：

1. 将右半部分（Ri-1）通过一个轮函数F处理，轮函数的输入还包括本轮的子密钥Ki。
2. 将F函数的输出与左半部分（Li-1）进行异或（XOR）操作，得到新的右半部分（Ri）。
3. 旧的右半部分（Ri-1）直接成为新的左半部分（Li）。

公式表达为：Li = Ri-1Ri = Li-1 XOR F(Ri-1, Ki)

经过多轮迭代后，最后再将左右部分交换一次，输出密文。解密过程与加密完全相同，只需逆序使用子密钥。这种对称性极大地简化了硬件和软件的实现。

DES的破解与3DES：DES的56位密钥长度在现代计算能力下已经太短。1998年，电子前沿基金会耗资25万美元打造的“深 crack”机器，在56小时内成功暴力破解了DES密钥。这直接宣判了DES的死刑。为了应对，出现了3DES，即用两个或三个不同的DES密钥对数据进行三次DES加密（加密-解密-加密，EDE模式）。这虽然将有效密钥长度提升到了112或168位，但速度慢了三倍，只是一种临时过渡方案。

注意事项：绝对不要在任何新系统中使用DES或甚至3DES。它们已经过时，仅存在于历史研究和遗留系统中。学习DES的价值在于理解Feistel结构和分组密码的基本设计思想。

3.2 AES算法：Rijndael的胜利与SPN结构解析

1997年，美国国家标准与技术研究院发起AES选拔赛，旨在寻找DES的替代者。最终，由两位比利时密码学家设计的Rijndael算法胜出。AES是分组密码的新标杆，它采用了与Feistel不同的SPN结构。

AES核心参数：AES的分组长度固定为128位，密钥长度可以是128位、192位或256位，分别称为AES-128, AES-192, AES-256。轮数取决于密钥长度：128位密钥对应10轮，192位对应12轮，256位对应14轮。

一轮AES加密详解（以128位为例）：每一轮操作都在一个4x4的字节矩阵（称为状态矩阵）上进行，包含四个步骤：

1. SubBytes（字节替换）：通过一个非线性的S盒查找表，将状态中的每一个字节替换为另一个字节。这是AES提供混淆特性的主要来源，打破了明文与密文之间的线性关系。
2. ShiftRows（行移位）：将状态矩阵的每一行进行循环左移。第一行不移位，第二行左移1字节，第三行左移2字节，第四行左移3字节。这一步提供了扩散，使得一个字节的变化能在多轮后影响到整个状态矩阵。
3. MixColumns（列混合）：将状态矩阵的每一列视为在有限域GF(2^8)上的多项式，与一个固定的多项式进行模乘运算。这一步极大地增强了扩散效果。
4. AddRoundKey（轮密钥加）：将当前状态矩阵与本轮的子密钥进行逐比特的异或操作。子密钥是由初始密钥通过密钥扩展算法派生出来的。

在最后一轮中，会省略MixColumns步骤。解密过程则是这些逆操作的逆序执行。

为什么AES是安全的？AES的安全性建立在严谨的数学基础上，其S盒和列混合变换的设计能够有效抵抗已知的密码分析攻击，如差分分析和线性分析。目前，对AES最有效的攻击仍然是暴力破解。对于AES-128，需要尝试2^128种可能的密钥，这是一个天文数字（约3.4×10^38），即使用上全世界的计算资源，也需要远超宇宙年龄的时间才能完成。AES-192和AES-256则更加安全。

4. 实战演练：使用Python破解弱密钥AES-ECB模式

在CTF比赛或一些安全评估中，我们有时会遇到因错误使用AES而导致的脆弱场景。这里我们模拟一个经典场景：AES-ECB模式 + 已知部分明文/密文对。ECB模式是最简单的分组密码工作模式，它将每个明文分组独立加密，相同的明文分组会产生相同的密文分组。这是一个致命弱点。

4.1 场景构建与攻击原理

假设我们有一个“加密预言机”：它是一个网络服务或一段程序，允许我们输入任意数据，它会在我们输入的数据前加上一个固定的、未知的秘密前缀（SECRET_PREFIX），然后使用固定的、未知的AES-128-ECB密钥进行加密，并返回密文。 即：Ciphertext = AES-ECB-Encrypt(SECRET_PREFIX + User_Input)

我们的目标是：逐步揭示出这个未知的SECRET_PREFIX。

攻击原理（字节填充攻击的一种）：由于ECB模式的特性和AES的分组大小（16字节），我们可以通过精心构造输入，进行“字节对齐”和“字典爆破”。

1. 确定前缀长度：我们发送不同长度的输入（例如，从发送1个‘A’开始，逐渐增加），观察密文长度的变化。当密文长度突然增加一个分组（16字节）时，说明我们发送的输入刚好让(前缀+输入)的总长度跨越了一个分组的边界。通过计算，可以精确推算出前缀的长度。

2. 逐字节破解：假设我们已知前缀长度为plen，并且我们已经知道了前缀的前n个字节，现在想获取第n+1个字节。

   • 我们构造一个输入P，其长度为15 - (plen % 16) + (plen // 16)*16。这样做的目的是让前缀 + P的长度恰好是16字节的整数倍少1字节。具体来说，我们填充P，使得SECRET_PREFIX + P的最后一个分组，只缺少最后一个字节（即我们想破解的那个字节）。
   • 然后，我们构建一个字典：遍历所有可能的256个字节值b，将P + known_prefix + b（其中known_prefix是我们已经知道的部分）发送给预言机加密，但只取最后一个分组的密文（因为我们构造的输入让目标字节位于分组的末尾），将密文与字节值b建立映射关系。
   • 最后，我们向预言机发送真实的P（不加我们猜测的字节），获取密文，并取出对应的最后一个分组。将这个分组密文与我们刚才构建的字典进行比对，匹配到的b就是SECRET_PREFIX的第n+1个字节。
   • 重复此过程，即可逐个字节地恢复出整个秘密前缀。

4.2 Python代码实现模拟攻击

下面我们用Python模拟一个存在此漏洞的服务端和攻击客户端。

服务端（漏洞模拟）：

from Crypto.Cipher import AES from Crypto.Util.Padding import pad import os # 模拟未知的密钥和秘密前缀 SECRET_KEY = os.urandom(16) # 随机生成的16字节AES密钥 SECRET_PREFIX = b"FLAG{This_Is_A_Secret_Prefix}" # 我们要破解的目标 def encryption_oracle(user_input): """加密预言机：在用户输入前添加秘密前缀，然后用AES-ECB加密""" data = SECRET_PREFIX + user_input # ECB模式，不需要IV cipher = AES.new(SECRET_KEY, AES.MODE_ECB) # 使用PKCS#7填充 ciphertext = cipher.encrypt(pad(data, AES.block_size)) return ciphertext # 示例：获取一下密文长度，观察规律 print(f"[Server] Secret Prefix Length: {len(SECRET_PREFIX)}") print(f"[Server] Example ciphertext length for input 'A': {len(encryption_oracle(b'A'))}")

攻击客户端：

from pwn import * # 使用pwntools库方便交互，也可用socket模拟 import string def find_prefix_length(oracle): """确定秘密前缀的长度""" cipher_len0 = len(oracle(b'')) # 空输入的密文长度 for i in range(1, 32): # 假设前缀不会超过32字节，可调整 cipher_len_i = len(oracle(b'A' * i)) if cipher_len_i != cipher_len0: # 密文长度变化，说明填充后总长度跨越了分组边界 # 计算前缀长度: plen = (blocks-1)*16 - i block_size = 16 extra_blocks = (cipher_len_i - cipher_len0) // block_size prefix_len = cipher_len0 - i - (extra_blocks * block_size) # 更精确的方法：通过寻找两个相同输入导致相同密文分组的点 # 这里简化处理，返回一个估算值，实际攻击中需要更精确的方法 print(f"[*] Detected ciphertext length changed at input length {i}") print(f"[*] Estimated prefix length: {prefix_len}") return prefix_len return None def byte_at_a_time_ecb_decrypt(oracle, prefix_len): """逐字节解密秘密前缀""" known_bytes = b"" block_size = 16 # 计算我们需要填充多少字节，使得 (prefix + padding) 的长度是 block_size 的整数倍 # 这样我们控制的输入就能从下一个分组的开头开始 # 简化攻击：假设我们可以直接控制一个完整分组的输入 # 更通用的方法需要处理前缀长度非16倍数的情况 # 这里我们采用一种更直观的方法（假设前缀长度已知且较短）： # 1. 先确定使 (prefix + input) 对齐到块边界所需的填充长度 offset = (block_size - (prefix_len % block_size)) % block_size print(f"[*] Need {offset} bytes of offset to align prefix to block boundary.") # 我们要破解的字节索引从0到prefix_len-1 for target_idx in range(prefix_len): # 计算当前目标字节在哪个分组中，以及在该分组中的位置 target_block = (prefix_len - target_idx - 1) // block_size target_pos_in_block = (prefix_len - target_idx - 1) % block_size # 构造输入，使得我们猜测的字节位于一个分组的末尾 # 我们创建一个输入，其长度为：使得 (prefix + input) 的 target_block 分组中， # 只有最后一个字节是我们未知的，前面都是我们已知或可控的。 # 这通常需要动态构造填充 # 简化：我们构建一个字典，爆破一个字节 # 创建一个填充，使得未知字节位于我们可探测的位置 padding_length = block_size - (target_pos_in_block + 1) controlled_input = b'A' * padding_length # 制作字典：遍历所有可能的字节 dictionary = {} for guess in range(256): guess_byte = bytes([guess]) # 我们发送的完整数据是：prefix + controlled_input + known_bytes + guess_byte # 但由于我们无法直接控制prefix，我们发送的是：controlled_input + known_bytes + guess_byte # 预言机会自动加上prefix test_payload = controlled_input + known_bytes + guess_byte ciphertext = oracle(test_payload) # 提取我们感兴趣的那个分组（target_block） start_block = target_block * block_size end_block = start_block + block_size block_cipher = ciphertext[start_block:end_block] dictionary[block_cipher] = guess_byte # 现在发送真实的探测输入（不带猜测字节） probe_payload = controlled_input + known_bytes probe_ciphertext = oracle(probe_payload) probe_block = probe_ciphertext[target_block*block_size : (target_block+1)*block_size] if probe_block in dictionary: found_byte = dictionary[probe_block] known_bytes = found_byte + known_bytes # 新发现的字节加到已知部分前面 print(f"[+] Found byte at position {target_idx}: {found_byte} (known so far: {known_bytes})") else: print(f"[-] Failed to find byte at position {target_idx}. Might be padding issue.") break return known_bytes # 假设我们有一个可以交互的oracle函数，这里用本地模拟 def local_oracle(user_input): # 这里调用之前定义的encryption_oracle，但为了模拟远程，我们直接使用 from server_simulation import encryption_oracle # 假设server_simulation是上面的代码 return encryption_oracle(user_input) # 主攻击流程 if __name__ == "__main__": print("[*] Starting ECB Byte-at-a-Time Attack Simulation...") plen = find_prefix_length(local_oracle) if plen: print(f"[*] Prefix length determined to be: {plen}") print("[*] Beginning byte-by-byte decryption...") result = byte_at_a_time_ecb_decrypt(local_oracle, plen) print(f"[+] Decrypted Secret Prefix: {result.decode()}") else: print("[-] Could not determine prefix length.")

重要提示与避坑指南：

1. 上述代码是概念验证：实际的ECB字节填充攻击需要更精细地处理填充和分组对齐，上述简化代码可能无法直接运行于所有场景，但它清晰地阐述了攻击的每一步逻辑。在真实CTF中，你需要根据具体的预言机行为调整填充逻辑。
2. PKCS#7填充的影响：如果服务端使用了标准的PKCS#7填充，当我们的输入恰好使总长度为分组的整数倍时，会额外增加一个完整的填充分组。在计算长度和构造输入时必须考虑这一点，否则会导致对齐错误。
3. 攻击前提：此攻击成功的关键在于AES采用ECB模式，且我们可以反复调用加密预言机。这再次证明了ECB模式不适合加密结构化数据。在实际应用中，应使用更安全的模式，如CBC（需确保IV随机且不可预测）、CTR或GCM（认证加密）。
4. 工具使用：在实战中，可以使用pwntools库与远程服务交互，使用Crypto.Cipher进行本地加密验证。理解原理比套用工具更重要。

5. 常见加密算法问题排查与安全实践要点

在实际开发和渗透测试中，遇到加密相关的问题和错误非常普遍。这里整理了一份从开发、部署到攻击视角的常见问题清单。

5.1 开发与配置中的典型错误

5.2 渗透测试与CTF中的密码学线索

在安全评估或CTF比赛中，密码学挑战往往有一些“气味”可以识别：

1. 编码而非加密：数据看起来杂乱但字符集有限（如只有A-Z, a-z, 0-9, +, /, =）。这很可能是Base64编码。遇到=填充是典型标志。类似还有Hex编码（0-9, a-f）、二进制转ASCII等。第一步总是尝试各种解码。
2. 经典密码特征：密文全部由字母组成，且长度适中。可以尝试词频分析（在线工具如quipqiup），或检查是否有重复的固定长度片段（提示维吉尼亚密码）。
3. RSA相关错误：
   • 非常小的模数n：可以直接分解（用factordb.com或yafu工具）。
   • 相同的n，不同的e和密文：可能是共模攻击。
   • 相同的明文，不同的n和e：可能是低加密指数广播攻击（中国剩余定理）。
   • 密钥生成时p和q很接近：可能导致费马分解法有效。
4. AES ECB模式：如前所述，如果密文很长，且观察到有重复的16字节或32字节块，极有可能是ECB模式。可以尝试块重排、字节填充等攻击。
5. 弱随机数：如果IV或随机数不是真正随机的（如使用时间戳、计数器），可能导致流密码（如RC4）或CBC模式被攻击。

5.3 安全实践黄金法则

1. 选用正确的算法和模式：
   • 对称加密：首选AES-GCM，它同时提供保密性和认证。次选AES-CBC（必须搭配HMAC进行认证）或AES-CTR。
   • 非对称加密/签名：首选RSA-OAEP（加密）和RSA-PSS（签名），绝对不要用旧的PKCS#1 v1.5填充。椭圆曲线算法（如ECDSA, ECDH）在相同安全强度下密钥更短，效率更高。
   • 哈希：用于完整性校验用SHA-256或SHA-3。用于密码存储用Argon2id。
2. 密钥管理是关键：
   • 使用足够长度的随机密钥（AES-128足够，追求更高用AES-256）。
   • 密钥必须安全存储，绝不能硬编码在代码中。使用密钥管理服务或硬件安全模块。
   • 定期轮换密钥。
3. 正确使用IV/Nonce：
   • CBC模式的IV必须密码学安全随机且每次加密都不同。
   • CTR和GCM模式的Nonce必须唯一，重复使用Nonce对GCM是灾难性的。
4. 理解并验证库的默认行为：
   • 不同语言的密码学库默认设置可能不同（如填充方式、工作模式）。永远不要假设，要明确指定参数。
   • 使用高级的、不易误用的API（如cryptography库的Fernet）。
5. 不要混淆加密与编码：Base64不是加密，它只是编码，任何人都可以解码。不能用于保护数据机密性。

密码学的实践之路，始于理解这些基础算法的“所以然”，并时刻对“如何用错”保持警惕。亲手破解这些古典和现代密码的过程，就像在解构一座座精妙的安全堡垒，能让你在未来构建自己的系统时，清楚地知道每一块砖应该放在哪里，以及哪些地方最容易产生裂缝。真正的安全，来自于对攻击的深刻理解。