古典密码学完全指南

← 返回指南列表

古典密码学完全指南

古典密码学(Classical Cryptography)是指1970 年代公钥密码学出现之前所使用的一切加密方法。这些密码大多基于字符的替换(Substitution)与换位(Transposition)两种基本操作,虽然在今天几乎全部可被计算机暴力破解,但它们在密码学历史上占据了两千多年的主导地位,是理解现代密码学的重要基础。

学习古典密码学的价值:

  1. 教学价值:它是理解现代对称加密的概念根基(扩散/混淆、频率分析等思想直接影响 DES/AES 的 S-box 设计)
  2. CTF 实战价值:各类 CTF 比赛中古典密码题目是入门级必经之路
  3. 历史价值:Enigma、Bletchley Park、图灵等密码历史
  4. 训练思维:频率分析、穷举、指数吻合度等核心思路仍是现代密码分析的思想源头

一、古典密码学概述

1.1 基本术语

术语 含义
明文(Plaintext / P) 可读的原始消息
密文(Ciphertext / C) 加密后的不可读消息
密钥(Key / K) 加密时使用的秘密信息
加密(Encryption / E) C = E(K, P)
解密(Decryption / D) P = D(K, C)
密码体制 一组加密/解密算法的总称
Kerckhoffs 原则 密码体制的安全应仅依赖密钥,不依赖算法保密

1.2 古典密码分类

CODE
古典密码学
├─ 替换密码 (Substitution Cipher)
│  ├─ 单表替换
│  │  ├─ 凯撒密码 (Caesar Cipher)
│  │  ├─ 移位密码 (Shift Cipher)
│  │  ├─ 仿射密码 (Affine Cipher)
│  │  ├─ 简单替换 (Simple Substitution)
│  │  └─ 单字母替换 (Monoalphabetic)
│  └─ 多表替换
│     ├─ 维吉尼亚密码 (Vigenère Cipher)
│     ├─ Beaufort 密码
│     ├─ Playfair 密码
│     ├─ Hill 密码
│     └─ Enigma 机械密码机
└─ 换位密码 (Transposition Cipher)
   ├─ 栅栏密码 (Rail Fence)
   ├─ 列换位密码 (Columnar Transposition)
   ├─ 栅栏-密钥组合
   └─ ADFGVX 等组合密码

1.3 古典密码的两大弱点

  1. 语言统计特性未被破坏:所有古典密码都无法完全掩盖自然语言的字母频率分布(尤其是字母频率、双字母组、三字母组等统计特性)
  2. 密钥空间过小:即使按当时水平,密钥空间也往往只有几千到几百万,对现代计算机而言只是几分之一秒

二、单表替换密码

2.1 凯撒密码(Caesar Cipher)

原理:字母表整体向右移 3 位。

明文字母 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
密文字母 D E F G H I J K L M N O P Q R S T U V W X Y Z A B C

数学公式:

  • 加密:C = (P + 3) mod 26
  • 解密:P = (C - 3) mod 26

示例:

CODE
明文:  ATTACK AT DAWN
密钥:  3
密文:  DWWDFN DW GDZQ

Python 实现:

PYTHON
def caesar_encrypt(text, shift=3):
    result = []
    for ch in text:
        if ch.isupper():
            result.append(chr((ord(ch) - ord('A') + shift) % 26 + ord('A'))
        elif ch.islower():
            result.append(chr((ord(ch) - ord('a') + shift) % 26 + ord('a'))
        else:
            result.append(ch)
    return ''.join(result)

def caesar_decrypt(text, shift=3):
    return caesar_encrypt(text, -shift)

# 测试
print(caesar_encrypt("ATTACK AT DAWN"))      # DWWDFN DW GDZQ
print(caesar_decrypt("DWWDFN DW GDZQ"))     # ATTACK AT DAWN

凯撒密码的破解——穷举 25 种可能:

PYTHON
def brute_force_caesar(ciphertext):
    results = []
    for shift in range(1, 26):
        plaintext = caesar_decrypt(ciphertext, shift)
        results.append((shift, plaintext))
    return results

for shift, text in brute_force_caesar("KHOOR ZRUOG"):
    print(f"Shift {shift:2d}: {text}")

2.2 移位密码(Shift Cipher)

凯撒密码的推广,移位量 k 可以是任意整数 0~25。

加密:C = (P + k) mod 26
解密:P = (C - k) mod 26

2.3 ROT13

特殊的移位密码,k=13。由于 13×2=26,加密两次即解密。

CODE
明文:  HELLO
密文:  URYYB
再次加密: HELLO

2.4 仿射密码(Affine Cipher)

凯撒密码是仿射密码的子集。仿射密码的密钥由一对整数 (a, b) 组成。

加密:C = (a × P + b) mod 26
解密:P = a⁻¹ × (C - b) mod 26

密钥条件:`gcd(a, 26) = 1(即 a ∈ {1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25}

当 a=1, b=3 时,即为凯撒密码。

**乘法逆元表(模 26):

a 1 3 5 7 9 11 15 17 19 21 23 25
a⁻¹ 1 9 21 15 3 19 7 23 11 5 17 25

Python 实现:

PYTHON
def mod_inverse(a, m=26):
    for x in range(1, m):
        if (a * x) % m == 1:
            return x
    raise ValueError(f"No modular inverse for a={a}")

def affine_encrypt(text, a, b):
    result = []
    for ch in text:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            p = ord(ch) - base
            c = (a * p + b) % 26
            result.append(chr(c + base))
        else:
            result.append(ch)
    return ''.join(result)

def affine_decrypt(text, a, b):
    a_inv = mod_inverse(a)
    result = []
    for ch in text:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            c = ord(ch) - base
            p = (a_inv * (c - b)) % 26
            result.append(chr(p + base))
        else:
            result.append(ch)
    return ''.join(result)

# 测试 (a=5, b=8)
cipher = affine_encrypt("AFFINE CIPHER", 5, 8)
print(cipher)  # IHHWVC ULYQ
print(affine_decrypt(cipher, 5, 8))  # AFFINE CIPHER

仿射密码的密钥空间:12 × 26 = 312 种可能(a 有 12 种选择,b 有 26 种选择)

仿射密码的已知明文攻击:如果知道两对明密文字母对,即可解出 a 和 b。

2.5 简单替换密码

任意字母到字母的映射(任意双射。

CODE
明文:  A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
密文:  D R Y P O L K G C X Q S W N T M B E F V U H Z I J

简单替换密码的密钥空间是 26! ≈ 4×10²⁶,暴力破解看似安全,实际上可以通过频率分析。

字母频率分析破解:

英文文本字母频率分布(统计每 1000 个字母中的平均出现次数):

字母 E T A O I N S H R D L C U M W F G Y P B V K J X Q Z
频率(‰) 127 91 82 75 70 67 63 61 60 43 40 28 28 24 24 22 20 20 19 15 10 2 1 1 1 1
CODE
高频群: E, T, A, O, I, N, S, H, R, 低频群: D, L, C, U, M, W, F, G, Y, P, B, V
极低频群: K, J, X, Q, Z (只有 1~2% 极低频

Python 频率分析函数:

PYTHON
from collections import Counter

def frequency_analysis(ciphertext):
    letters = [c for c in ciphertext.upper() if c.isalpha()]
    counter = Counter(letters)
    total = len(letters)
    return {ch: cnt/total*1000 for ch, cnt in counter.most_common()}

freq = frequency_analysis(ciphertext)
for ch, f in sorted(freq.items(), key=lambda x: -x[1]):
    print(f"{ch}: {f:.1f}‰  {'█' * int(f/5))

**双字母组(Digram)和三字母组(Trigram)频率分析:

| 最常见双字母组: TH, HE, IN, ER, RE, ON, AN, EN, RE, ED, ES, EA, TI, TE, AT, IO, OU, NG, AL, IT
| 最常见三字母组: THE, AND, ING, HER, ERE, ENT, THA, NTH, WAS, ETH, FOR, DTH, HAT, ALL, TIO |

THE 在三字母组中占比最高(约 35‰),是频率分析的突破口。

频率分析攻击步骤:

  1. 统计密文字母频率,与标准频率表比较
  2. 找到最常见字母 → 假设为 E 或 T
  3. 三字母组中 “THE” 最常见
  4. 逐步推断其他字母
  5. 使用双字母组约束验证 → 找到矛盾时回溯

三、多表替换密码

3.1 维吉尼亚密码(Vigenère Cipher)

由法国外交官 Blaise de Vigenère 在 16 世纪发明。使用周期多表替换,密钥周期性使用 26 张凯撒密码表。

**维吉尼亚方阵(Vigenère Square / Tabula Recta):

CODE
行=A B C D E F ...
A: A B C D E F ...
B: B C D E F G ...
C: C D E F G H ...
D: D E F G H I ...
...

加密:Cᵢ = (Pᵢ + Kᵢ) mod 26
解密:Pᵢ = (Cᵢ - Kᵢ) mod 26

示例:

CODE
明文:  ATTACK AT DAWN
密钥:  LEMON LEMO NL
(密钥:  L E M O N L E M O N L E
密文:  LXFOPV EF RNHR

Python 实现:

PYTHON
def vigenere_encrypt(plaintext, key):
    result = []
    key_idx = 0
    for ch in plaintext:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            p = ord(ch) - base
            k = ord(key[key_idx % len(key)].upper()) - ord('A')
            c = (p + k) % 26
            result.append(chr(c + base))
            key_idx += 1
        else:
            result.append(ch)
    return ''.join(result)

def vigenere_decrypt(ciphertext, key):
    result = []
    key_idx = 0
    for ch in ciphertext:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            c = ord(ch) - base
            k = ord(key[key_idx % len(key)].upper()) - ord('A')
            p = (c - k) % 26
            result.append(chr(p + base))
            key_idx += 1
        else:
            result.append(ch)
    return ''.join(result)

# 测试
cipher = vigenere_encrypt("ATTACK AT DAWN", "LEMON")
print(cipher)  # LXFOPVEFRNHR
print(vigenere_decrypt(cipher, "LEMON"))  # ATTACKATDAWN

3.2 维吉尼亚密码的 Kasiski 检验

  1. Kasiski 检验法:寻找密文中重复出现的字符串之间距离的最大公约数可能是密钥长度的倍数。
  2. 重合指数法:

重合指数 IC = Σ fᵢ(fᵢ-1) / (n(n-1)),其中 fᵢ 是每个字母的频数。

英文文本的 IC 约为 0.065,随机文本的 IC 约为 0.038。

**使用步骤:

  1. 将密文按密钥长度 m 分组
  2. 对每组分别计算 IC
  3. 当所有组的 IC 都接近 0.065 时,m 很可能是正确密钥长度
PYTHON
def index_of_coincidence(text):
    letters = [c for c in text.upper() if c.isalpha()]
    n = len(letters)
    if n < 2: return 0.0
    counts = Counter(letters)
    numerator = sum(f * (f - 1) for f in counts.values())
    return numerator / (n * (n - 1))

def find_key_length(ciphertext, max_len=20):
    for m in range(1, max_len+1):
        groups = [ciphertext[i::m] for i in range(m)]
        ics = [index_of_coincidence(g) for g in groups]
        avg_ic = sum(ics) / len(ics)
        if avg_ic > 0.06:
            print(f"长度 {m:2d}: IC = {avg_ic:.4f} (接近英文 0.065)

# 对每个字母的字母频率进行字母频率分析

3.3 密钥恢复

确定密钥长度 m 后,每组视为凯撒密码,使用频率分析分别找到每一组的位移量。

步骤总结:

  1. **Kasiski 检验找到密钥长度
  2. IC 验证密钥长度
  3. 频率分析确定每个密钥字母

维吉尼亚密码在 CTF 实战流程:

CODE
密文: KCCPKBGUFDPHQTYAVINRRTMVGRKDNBVFDETDGILTXRGUDS
→ Kasiski 发现 "VT" 出现 3 次,距离最大公约数为 5
→ IC 验证 m=5 时 IC≈0.063(与英文 IC 0.065
→ 每组使用频率分析:
   → 第1组: IC=0.078 → 位移 3
   → 第2组: IC=0.071 → 位移 11
   → 第3组: IC=0.072 → 位移 12
   → 第4组: IC=0.073 → 位移 7
   → 第5组: IC=0.069 → 位移 14
→ 密钥 = C L M H O
→ 解密得明文

3.4 Beaufort 密码

维吉尼亚密码的变种,加密公式:

  • 加密:Cᵢ = (Kᵢ - Pᵢ) mod 26
  • 解密:Pᵢ = (Kᵢ - Cᵢ) mod 26

3.5 Playfair 密码

使用 5×5 矩阵(I/J 合并),密钥填充矩阵后加密双字母对。

Playfair 加密规则:

  1. 构造 5×5 矩阵,将 I 和 J 合并
  2. 将密钥字母依次填入矩阵
  3. 填充剩余字母
  4. 将明文字母两两分组(相同字母间插入 X)
  5. 双字母在同行 → 右移一格
  6. 双字母在同列 → 下移一格
  7. 双字母在对角 → 交换列
  8. 双字母相同字母→ 相同字母相同字母相同字母相同字母相同字母相同字母相同字母相同字母

Python 实现:

PYTHON
def playfair_encrypt(plaintext, key):
    # 构造 5x5 矩阵
    matrix = []
    seen = set()
    key = key.upper().replace('J', 'I')
    for ch in key + 'ABCDEFGHIKLMNOPQRSTUVWXYZ':
        if ch not in seen and ch.isalpha():
            seen.add(ch)
            matrix.append(ch)
    matrix = [matrix[i:i+5] for i in range(0, 25, 5)]

    # 查找字符位置
    pos = {}
    for i in range(5):
        for j in range(5):
            pos[matrix[i][j]] = (i, j)

    # 明文分组
    pairs = []
    plaintext = plaintext.upper().replace('J', 'I')
    i = 0
    while i < len(plaintext):
        a = plaintext[i]
        if i+1 < len(plaintext) and plaintext[i+1] != a:
            b = plaintext[i+1]
            pairs.append((a, b))
            i += 2
        else:
            pairs.append((a, 'X'))
            i += 1
    if len(pairs) % 2 == 1:
        pairs.append(('X', 'Z'))

    # 加密
    ciphertext = []
    for a, b in pairs:
        ra, ca = pos[a]
        rb, cb = pos[b]
        if ra == rb:  # 同行
            ciphertext.append(matrix[ra][(ca+1) % 5])
            ciphertext.append(matrix[rb][(cb+1) % 5])
        elif ca == cb:  # 同列
            ciphertext.append(matrix[(ra+1) % 5][ca])
            ciphertext.append(matrix[(rb+1) % 5][cb])
        else:  # 矩形对角
            ciphertext.append(matrix[ra][cb])
            ciphertext.append(matrix[rb][ca])
    return ''.join(ciphertext)

3.6 Hill 密码

线性代数密码,使用矩阵乘法。

加密:C = K × P mod 26
解密:P = K⁻¹ × C mod 26

2×2 Hill 密码示例:

CODE
密钥矩阵 K = [[3 5; 7 11]
明文 "HE" = [[7; 4]
密文 = [3×7 + 5×4 mod 26, 7×7 + 11×4 mod 26] = [37, 93 mod 26 = 11, 15 → L, P → LP?

**解密要求矩阵行列式与 26 互质 → det(K) ∈ {1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25}


四、换位密码

4.1 栅栏密码(Rail Fence Cipher)

明文沿对角线排列,然后沿行读取。

2 栏栅栏:

CODE
明文:  WE ARE DISCOVERED FLEE AT ONCE
W . . . A . . . . . . E . . . . .
. E . R . D . S . C . V . R . E . D
. . A . . . . . . . . . . . . . . .

→ 读取行 1: W . . . A . . . . E . . . . . .
→ 读取行 2: . E . R . D . S . C . V . R . E . D
密文: W . A . E . R . D . S . C . V . R . E . D

3 栏栅栏:

CODE
行1: W . . . A . . . . . . E . . . . . . . . .
行2: . E . R . D . S . C . V . R . E . D
行3: . . A . . . . . . . . . . . . . .

密文: W . . A . . . . . . E . . . . . . E . R . D . S . C . V . R . E . D

Python 实现:

PYTHON
def rail_fence_encrypt(plaintext, rails=3):
    """栅栏密码加密
    plaintext = plaintext.replace(' ', '')
    fence = [[] for _ in range(rails)]
    rail = 0
    direction = 1
    for ch in plaintext:
        fence[rail].append(ch))
        rail += direction
        if rail == rails - 1 or rail == 0:
            direction *= -1
    return ''.join(ch for row in fence for ch in row)

def rail_fence_decrypt(ciphertext, rails=3):
    """栅栏密码解密"""
    n = len(ciphertext)
    fence = [[None]*n for _ in range(rails)]
    rail = 0
    direction = 1
    for i in range(n):
        fence[rail][i] = True
        rail += direction
        if rail == rails-1 or rail == 0:
            direction *= -1
    result = []
    idx = 0
    for r in range(rails):
        for c in range(n):
            if fence[r][c]:
                fence[r][c] = ciphertext[idx]
                idx += 1
    rail = 0
    direction = 1
    for i in range(n):
        result.append(fence[rail][i])
        rail += direction
        if rail == rails-1 or rail == 0:
            direction *= -1
    return ''.join(result)

# 测试
cipher = rail_fence_encrypt("WEAREDISCOVEREDFLEEATONCE", 3)
print(cipher)
print(rail_fence_decrypt(cipher, 3))

4.2 列换位密码(Columnar Transposition)

使用密钥词将明文按列写入,按字母顺序读取各列。

示例:

CODE
密钥: ZEBRAS  → 字母顺序: Z(25), E(4), B(1), R(17), A(0), S(18)
排序后顺序: 5, 2, 4, 1, 3, 6
CODE
明文: WE ARE DISCOVERED FLEE AT ONCE

5 2 4 1 3 6
W E A R E D
I S C O V E
R E D F L E
E A T O N C
E

**读取顺序为 1, 2, 3, 4, 5, 6 → 列号顺序 5,2,4,1,3,6 → 按字母顺序:

PYTHON
def columnar_encrypt(plaintext, key):
    key = key.upper()
    n = len(key)
    plaintext = plaintext.replace(' ', '')
    # 生成列顺序
    order = sorted(range(n), key=lambda i: key[i])
    
    # 填充明文
    if len(plaintext) % n != 0:
        plaintext += 'X' * (n - len(plaintext) % n)
    
    cols = [[] for _ in range(n)]
    for i, ch in enumerate(plaintext):
        cols[i % n].append(ch)
    
    result = []
    for idx in sorted(range(n), key=lambda i: key[i]):
        result.extend(cols[idx])
    return ''.join(result)

def columnar_decrypt(ciphertext, key):
    key = key.upper()
    n = len(key)
    rows = len(ciphertext) // n
    cols = [[] for _ in range(n)]
    idx = 0
    for col_idx in sorted(range(n), key=lambda i: key[i]):
        cols[col_idx].extend(ciphertext[idx:idx+rows])
        idx += rows
    result = []
    for row in range(rows):
        for col in range(n):
            result.append(cols[col][row])
    return ''.join(result).rstrip('X')

cipher = columnar_encrypt("WEAREDISCOVEREDFLEEATONCE", "ZEBRAS")
print(cipher)
print(columnar_decrypt(ciphertext, "ZEBRAS"))

五、机械密码机

5.1 Enigma 密码机

二战德国使用 Enigma 密码机。

主要组件:

  1. **输入键盘(26 字母)
  2. **灯泡板(26 灯泡)
  3. 转子(Rotor):3-4 个可旋转圆盘,每按下字母位置不同
  4. 反射器(Reflector):字母对换
  5. 接线板(Plugboard / Steckerbrett):字母对换

加密流程:

CODE
键盘 → 接线板 → 转子1 → 转子2 → 转子3 → 反射器 → 转子3 → 转子2 → 转子1 → 接线板 → 灯泡

加密特点:

  • 每次按键后,至少一个转子旋转(最右侧转子每按一次转动 1/26 圈
  • 反射器保证加密是对合操作(加密两次得原文)
  • 接线板提供额外混淆

Enigma 的密钥空间:

  • 转子选择:5 × 4 × 3 = 60 种
  • 转子初始位置:26 × 26 × 26 = 17,576 种
  • 接线板接线:约 150,738,274,937,250 种(20 对字母对换)
  • **总密钥空间约 10¹⁶ → 当时水平几乎无法暴力破解

Enigma 的弱点:

  1. 字母不会加密到自身(反射器是对合,没有字母映射到自身)
  2. 已知明文攻击(Crib-based Cryptanalysis)
  3. **消息指示器/天气预报等固定格式消息
  4. 密钥重用

Bletchley Park 破解:

  • 1939 年波兰数学家用群论方法破解
  • 1940 年图灵设计 Bombe 机
  • 关键突破:利用 “固定格式消息(如每天早晨的天气预报、天气预报的 “Heil Hitler” 结尾

六、一次性密码本(One-Time Pad, OTP)

唯一理论上绝对安全的加密方案,由 Gilbert Vernam 1917 年发明。

6.1 原理

密钥是与明文等长的完全随机比特流,且永不重复使用**。

加密:C = P ⊕ K(逐位异或)
解密:P = C ⊕ K

6.2 为什么绝对安全?

香农信息论证明:如果密钥是真正随机、与明文等长、不重复,则密文不泄露任何明文信息。

**对任意密文 C,对任意可能明文 P’,存在密钥 K’ 使得 C = P’ ⊕ K’。所有明文等概率。

6.3 Python 实现

PYTHON
import os

def otp_encrypt(plaintext):
    key = os.urandom(len(plaintext))
    ciphertext = bytes(a ^ b for a, b in zip(plaintext.encode(), key))
    return ciphertext, key

def otp_decrypt(ciphertext, key):
    plaintext = bytes(a ^ b for a, b in zip(ciphertext, key))
    return plaintext.decode()

# 测试
cipher, key = otp_encrypt("Hello, OTP!")
print(otp_decrypt(cipher, key))  # Hello, OTP!

6.4 实际困难

  1. 密钥长度问题:密钥必须与明文等长
  2. 密钥分发问题:需要安全信道传输
  3. 密钥随机性问题:需要真随机源
  4. 密钥重用问题:密钥重用导致不安全

七、古典密码学的历史人物与里程碑

时间 事件 意义
公元前 1900 年 古埃及墓穴铭文 最早的加密文字
公元前 100 年 凯撒密码 最早的替换密码
公元 9 世纪 阿拉伯学者发明频率分析 密码学诞生
16 世纪 Vigenère 发明多表替换 多表替换密码
1854 年 Babbage 破解 Vigenère 多表替换被攻破
1917 Vernam 发明一次性密码本 理论绝对安全方案
1918 Friedman 发明重合指数法 频率分析系统化
1920s Enigma 发明机械密码机 机械密码时代
1940 图灵破解 Enigma 计算机辅助密码分析
1949 香农信息论 密码学数学基础

八、CTF 古典密码题目实战

8.1 题目识别特征

特征 可能的密码类型
只有字母,无空格 凯撒 / 简单替换
有空格,看起来有空格,数字和符号保留 维吉尼亚 / 移位密码
字母看起来随机,但双字母组分布均匀 多表替换
只有字母,但字母频率接近英文但整体位移 仿射密码
看起来像是字母但高频字母不是 E/T/A 简单替换
有数字,字母出现 ADFGVX, Polybius, Morse, Bacon

8.2 在线工具

  • **quipqiup.com — 简单替换密码自动破解
  • Crypto Corner — 多古典密码工具
  • dcode.fr — 各种古典密码破解
  • CyberChef — 通用密码分析工具集

九、古典密码学对现代密码学的影响

古典思想 现代应用
替换操作 → DES/AES S-box 扩散/混淆
换位操作 → AES MixColumns 扩散层
多表替换 → 多轮 S-box 现代分组密码
频率分析 → 差分/线性密码分析 现代密码分析

十、总结

密码 密钥空间 安全性 实际用途
凯撒 25 教学 教学演示
仿射 312 教学 教学
简单替换 26! ≈ 4×10²⁶ 理论大,但易频率分析 教学/CTF
维吉尼亚 26ᵏ(k 密钥长度) 易被 Kasiski + 频率分析 CTF 题目
Playfair 25! ≈ 1.55×10²⁵ 教学/CTF 教学
Hill 矩阵行列式 教学 教学
Enigma ≈10¹⁶ 二战期间不可暴力破解 历史
一次性密码本 2ⁿ(与明文等长) 理论绝对安全 高保密通信(间谍、核武控制)

古典密码学是密码学历史的重要基石,是通往现代密码学的必经之路。