24739 字
124 分钟
【密码学】学习笔记

前言#

WARNING

本章存在大量 LaTeX 公式渲染,可能存在一些浏览器加载卡顿或卡死。建议使用新的内核访问。

这段时间学习了密码学和信息安全相关内容,这一部分有些理论还是有些抽象,我会按照我自己的理解来记录。个人笔记记录,可能会存在些许错漏,如有错误欢迎评论。

笔记将遵循教科书:《密码学原理与实践》第三版,点此进入豆瓣介绍页

NOTE

教材信息:

数学基础#

带余除法#

从小学数学开始,老师教过我们带余数的除法,例如 7÷3=217 ÷ 3 = 2…1。它的正式定义如下:

对于任意整数 aa 和正整数 nn,存在唯一的整数 qq(商)和 rr(余数),使得:a=n×q+r,0r<na = n \times q + r, \quad 0 \leq r < n

这里要求 余数必须是非负的,且必须小于除数。数学上可以有负余数,但在计算机和密码学标准里,我们通常要求 r0r \ge 0

所以根据这个原理,17mod5=?-17 \mod 5 = ? 因为余数是非负的,所以 17=5×(4)+3-17 = 5 \times (-4) + 3,余数是 33, 而不是 2-2。面对负数 aa 取余数的情况,我们可以直接加除数 nnqq 倍,直到为正数,剩余的部分即为余数,即 r=a+n×q,a<0r = a + n \times q, \quad a<0

因为 0r<n0 \le r<n,可能会出现余数相同的情况,例如 6÷5=116 \div 5 = 1 \dots 1, 11÷5=1111 \div 5 = 1 \dots 1。于是我们定义:

如果在除以同一个数 nn 时,两个整数 aabb 的余数相同,则称 aabbnn 同余,记作:ab(modn)a \equiv b \pmod{n}

例如:

  • 172(mod5)17 \equiv 2 \pmod{5} ✓ (都余 2)
  • 232(mod7)23 \equiv 2 \pmod{7} ✓ (都余 2)
  • 1002(mod7)100 \equiv 2 \pmod{7} ✓ (100÷7=14 余 2)

例如 116(mod5)11 \equiv 6 \pmod 5,我们可以将其写回带余除法的形式:

  • 11=5×2+111 = 5 \times 2 + 1
  • 6=5×1+16 = 5 \times 1 + 1 它们只是商不同,除数 nn 和余数 rr 都相同。那我们看看 11611 - 6 的形式:
116=5×2+1(5×1+1)=5×25×1+(11)=5×1\begin{align*} 11 - 6 &= 5 \times 2 + 1 - (5 \times 1 + 1) \\ &= 5 \times 2 - 5 \times 1 + (1 - 1) \\ &= 5 \times 1 \end{align*}

我们可以发现,余数已经消失了,所以可以得到同余的一个推论:

如果在除以同一个数 nn 时,两个整数 aabb 的余数相同,则 nn 能整除它们的差,记作:n(ab)n \mid (a - b)

对于除数 nn,我们按照除 nn 的余数对被除数 aa 进行分类。因为 0r<n0 \leq r < n,所以按照余数分类可以分成 nn 种类型,我们把每一种分类称为一个 剩余类 (Residue Classes)。它的正式定义如下:

对于正整数 nn,所有除以 nn 余数相同的整数构成一个 剩余类。余数为 rr 的剩余类记作:[r]n[r]_nrˉ\bar{r}

为什么我们还要折腾这些余数呢?我想一个合理的解释是计算机的存储是有限的。如果不取模,数字不断相乘会变得巨大无比,撑爆内存。通过取模,无论怎么算,结果永远在 00n1n-1 之间。

此外,密码学需要把原来的信息(明文)弄得面目全非(密文)。模运算是一种很好的“搅拌机”。它很难逆向推导(比如我知道余数是 3,除数是 5,但我不知道原来的数是 3 还是 13 还是 10008)。这种 不可逆性(在某些条件下)是公钥密码学(如 RSA)的基础。

我们前面推导减法规则:(ab)modn=0(a - b) \mod n = 0,那如果是加法和乘法呢?我们尝试进行推理:

(a+b)modn=((n×qa+ra)+(n×qb+rb))modn=(n×qa+n×qb+ra+rb)modn=(ra+rb)modn=[(amodn)+(bmodn)]modn\begin{align*} (a + b) \mod &n = ((n \times q_a+r_a) + (n \times q_b+r_b)) \mod n \\ &= (n \times q_a + n \times q_b + r_a + r_b) \mod n \\ &= (r_a + r_b) \mod n \\ &= [(a \mod n) + (b \mod n)] \mod n \end{align*}

同理,可以得到乘法:(a×b)modn=[(amodn)×(bmodn)]modn(a \times b) \mod n = [(a \mod n) \times (b \mod n)] \mod n

群、环、域#

我们重新回顾数学中的基础概念:

  • 集合 (Set):一堆数字(或其他元素)的合集。例如:整数集合 Z\mathbb{Z}
  • 运算 (Operation):一种处理元素的方法。例如:加法 (++) 或乘法 (×\times)。

我们现在要重新定义一个集合中的运算及其遵守的规则。以 整数集合和加法运算 为例,定义如下的规则:

  1. 封闭性 (Closure):整数加整数还是整数,即对于任意的 a,bZa,b \in \mathbb{Z},有 a+bZa+b \in \mathbb{Z}
  2. 结合律 (Associativity):对于任意的 a,b,cZa,b,c \in \mathbb{Z},有 (a+b)+c=a+(b+c)(a+b)+c = a+(b+c)
  3. 逆元 (Inverse):对于任意的 aZa \in \mathbb{Z},存在一个 加法逆元 a-a,使得 a+(a)=0a + (-a) = 0 , 00加法单位元

当满足了如上的加法运算规则后,我们就称其为 加法群 (Additive Group)。我们的整数集合 Z\mathbb{Z} 正好满足这些要求。我们把满足一个运算的应有规则的集合 RR 称为 群 (Group)

当然,回顾小学数学,我们知道加法有三大规则:交换律、结合率和分配率。如果一个整数加法群 Zm\mathbb{Z}_m 满足交换律,即对于任意的 a,bZa,b \in \mathbb{Z},有 a+b=b+aa+b = b+a ,则称这个群为 阿贝尔群 (Abelian Group) 或交换群。

同理,我们在整数集合上定义乘法及其规则:

  1. 封闭性 (Closure):整数乘整数还是整数,即对于任意的 a,bZa,b \in \mathbb{Z},有 abZab \in \mathbb{Z}
  2. 结合律 (Associativity):对于任意的 a,b,cZa,b,c \in \mathbb{Z},有 (ab)c=a(bc)(ab)c = a(bc)
  3. 交换律 (Commutative),即对于任意的 a,bZa,b \in \mathbb{Z},有 ab=baab = ba

整数集合在满足乘法的这些要求上,还能满足加法与乘法之间的分配率,即对于任意的 a,b,cZa,b,c \in \mathbb{Z},有 a(b+c)=ab+aca(b+c) = ab + ac

此时你发现,怎么乘法的规则里面没有逆元这一条。因为整数之间的除法不一定能得到整数,可能会出现分数。

整数集合 Z\mathbb{Z} 同时满足了加法的 4 条规则和乘法的 2 条规则, 以及加法和乘法的分配率。我们称一个集合 RR 同时满足 两个运算 的规则时,它是一个 环 (Rings)。所以,整数集合 Z\mathbb{Z} 是一个整数环。

Zm\mathbb{Z}_m 上,你可以随意加减乘,得到的还是整数。但是你不能随意除(比如 5÷25 \div 2 不是整数)。

注意,此时整数集合在乘法上,并不是群,因为其不满足一定有逆元在整数域中。

当一个集合,在 加法 上是一个群,去掉 00 元素后,它在 乘法 上也是一个群(意味着每个非零元素都有倒数),则称为 域 (Field)

此时乘法也满足了群的特征,即其逆元也在集合中。例如我们最常见的 实数域 R\mathbb{R},或 有理数域 Q\mathbb{Q}

我们在电脑里做加密,不能用无限的实数,必须用 有限 的整数。但是普通的整数集合 Z\mathbb{Z} 只是环,不能除。我们需要构造一个 既是有限的,又能做除法 的系统。这就是 有限域 (Finitefield) 或伽罗瓦域(Galoisfield),通常记作 GF(p)GF(p)Fp\mathbb{F}_p

例如我们之前学到的 模 7 的剩余类 Z7\mathbb{Z}_7, 它的集合是 {0,1,2,3,4,5,6}\{0,1,2,3,4,5,6\}。在这个集合里,每个非零数字都有逆元 a1a^{-1},使得 aa1=1aa^{-1} = 1

例如:3×5=153 \times 5 = 1515mod7=115 \mod 7 = 1, 所以 5533 的逆元。同理我们一个个尝试,可以得到 Z7\mathbb{Z}_7 中每一个非零数字的逆元,且在 Z7\mathbb{Z}_7 中。所以它是一个

但是,并非所有的模剩余类都是域,例如 模 12 的剩余类 Z12\mathbb{Z}_{12} 。尝试找 2 的乘法逆元,会发现在 Z12\mathbb{Z}_{12} 中无法找到。

一般而言,模 mm 的剩余类的集合 Zm={0,1,,m1}\mathbb{Z}_m = \{0,1,\dots,m-1\} 中,mm 为质数 (素数) 时,Zm\mathbb{Z}_m 是伽罗瓦域。具体证明比较繁杂,在计算机课程中就不涉及了。

总的来说,我将群、环、域总结为一张表以供参考:

结构包含运算逆元情况典型例子
群 (Group)1种 (如 ++)可以减时钟算法, 椭圆曲线点集
环 (Ring)2种 (+,×+, \times)可以减, 不一定能除整数 Z\mathbb{Z}, 多项式
域 (Field)2种 (+,×+, \times)可以减, 可以除实数 R\mathbb{R}, 有限域 GF(p)GF(p)

古典密码体系#

在这一章节中,将简单介绍几个的古典密码体系,用于了解密码的发展。这一章中,一个密码系统必须满足:dK(eK(x))=xd_K(e_K(x))=xeKe_K 表示加密方法,dKd_K 则是解密方法。

移位密码#

因为英文有 26 个字母,我们将每一个字母都看作 Z26\mathbb{Z}_{26} 中的元素,例如: A -> 0, B -> 1, ..., Z ->25Z26\mathbb{Z}_{26} 是一个环,里面的元素满足加法和乘法的结果均属于这个环,且加法存在逆元。加法、减法、乘法都要 mod 26 以保证其在 Z26\mathbb{Z}_{26} 中。

移位密码 (Shift Cipher) 运用了环的特性,在 Z26\mathbb{Z}_{26} 的基础上,将每个字母整体平移 KK 位后得到密文,具体来说定义为:

Shift Cipher

设明文空间 PP、密文空间 CC 和密钥空间 KK 均为 Z26\mathbb{Z}_{26} 。对于 K{0,25}K \in \{0,25\},任意 x,yZ26x,y \in \mathbb{Z}_{26},定义:

  • eK(x)=(x+K)mod26e_K(x) = (x+K) \mod 26
  • dK(y)=(yK)mod26d_K(y) = (y-K) \mod 26

当 K=3K=3 时,这个密码就是凯撒密码 (Caesar Cipher)。接下来通过一个例子去演示这个过程:

设移位密码的密钥为 K=11K=11,明文为:wewillmeetatmidnight,使用移位密码去加密它。

  1. 首先我们将明文按照字母表转为数字序列:22, 4, 22, 8…
  2. 然后将每个数都与 11 相加,再对其和取模 26 运算:例如 22+11=337(mod26)22 + 11 = 33 \equiv 7 \pmod{26},对应字母 H。
  3. 经过全部转换,我们得到密文:HPHTWWXPPELEXTOYTRSE

如果需要解密时,每个密文字母转成数字后减 11 即可。

移位密码的安全性非常有限,因为其密钥空间仅有 26 个可能的取值,攻击者 Oscar 可以穷举所有 KK 值,直到出现有意义的英文。

代换密码#

另一个比较有名的古典密码体制是 代换密码(Substitution Cipher)。代换密码不再使用固定的移位,而是用一个完全随机的密码本替换字母表。

Substitution Cipher

在替换密码中,明文空间和密文空间 P=C=Z26P = C = \mathbb{Z}_{26}。密钥空间 KK 是由 26 个元素的所有可能排列(Permutations)构成的集合 π\pi。对于任意 x,yZ26x,y \in \mathbb{Z}_{26},定义:

  • eπ(x)=π(x)e_{\pi}(x) = \pi(x)
  • dπ(y)=π1(y)d_{\pi}(y) = \pi^{-1}(y)

π1\pi^{-1} 表示置换 π\pi 的逆置换。

例如有如下置换规则 π\pi

通过这种随机映射,明文中的每一个字母都被替换成密钥表中对应的另一个字母。解密函数是其相应的逆置换。

代换密码的密钥空间极大(26!26!),暴力破解难以奏效。那代换密码就安全了吗,显然不是。它依然无法掩盖自然语言的统计特性。攻击者可以通过频率分析法,统计密文中各个字母出现的概率并与标准英文频率对比,从而快速推断出替换规则并破解密文。

仿射密码#

从前面我们看到,移位密码是代换密码的一种特殊情形,其只包含了 26 种置换情况。另一个代换密码的特殊情形是 仿射密码(Affine Cipher)。它的置换规则由一个线性方程决定。

Affine Cipher

P=C=Z26P = C = \mathbb{Z}_{26},若有密钥 K={(a,b)Z26×Z26:gcd(a,26)=1}K=\{(a,b) \in \mathbb{Z}_{26} \times \mathbb{Z}_{26}: \gcd(a,26)=1\},其中 xx 是明文字母对应的数字,则定义:

  • 加密函数为:e(x)=(ax+b)mod26e(x)=(ax+b) \mod 26
  • 解密函数为:d(y)=a1(yb)mod26d(y)=a^{-1}(y - b) \mod 26

如果密码能被解密,加密函数必须一一对应,否则两个明文字母可能加密成同一个密文字母,解密时就不知道还原成哪一个。即 ax+bax+b 必须是一个单射函数(指向唯一值),它与 yZ26y \in \mathbb{Z}_{26} 同余:ax+by(mod26)ax+b \equiv y \pmod {26}。分析这个仿射函数的解密,只要 yZ26y \in \mathbb{Z}_{26},则 ybZ26y-b \in \mathbb{Z}_{26}。所以是否能解密主要专注于 aa 是否有乘法逆元 a1a^{-1}。对于 aZma \in \mathbb{Z}_m,若存在 a1Zma^{-1} \in \mathbb{Z}_m,使得 aa1a1a1(modm)aa^{-1} \equiv a^{-1}a \equiv 1 \pmod{m},则 a1a^{-1} 称为 aaZm\mathbb{Z}_m 上的乘法逆元,记作:a1modma^{-1} \mod m.

aa 有逆元的 唯一条件 是:aa 必须与 m=26m=26 互素,即最大公约数 gcd(a,26)=1\gcd(a,26)=1。例如 a=2a=2gcd(2,26)=2\gcd(2, 26) = 2。此时加密字母 a (对应数字为 0) 和 n (对应数字为 13) 时:

  • e(0)=b(mod26)e(0) = b \pmod {26}
  • e(13)=2×13+b=26+bb(mod26)e(13) = 2 \times 13 + b = 26 + b \equiv b \pmod {26}

两个不同字母映射到了同一个结果,这导致了加密不可逆。所以仿射密码有解的充分必要条件是:gcd(a,26)=1\gcd (a, 26)=1。那么 aa 该如何取值使得其与 m=26m=26 互素呢?下面是严谨一些的数学推导

欧拉函数 (Euler’s totient function) φ(m)\varphi (m) 表示 aZm={0,1,,m1}a \in \mathbb Z_m=\{0,1,\dots,m-1\} 里,有多少个数和 mm 互素,即 gcd(a,m)=1\gcd(a,m)=1. 例如在 Z10\mathbb Z_{10} 中,φ(10)=4\varphi (10) = 4,分别是:1,3,7,91,3,7,9。接下来我们分类讨论 mm 的不同情况:

  1. 如果 mm 本身就是一个素数,那么除了它自己外,{1,2,,m1}\{1,2,\dots,m-1\} 全部和它互素。φ(m)=m1\varphi(m) = m-1。例如 p=7p=7,因为 7 是素数,除了它自己,前面的 1, 2, 3, 4, 5, 6 全部和它互素, φ(7)=71=6\varphi(7) = 7 - 1 = 6.
  2. 如果 mm 是一个素数的次方,例如 m=pem = p^e,你会发现 除了那些包含因子 pp 的数外 的数均与 mm 互素。例如:p=3, e=3, m=33=27p=3,\ e=3,\ m=3^3=27。只有那些包含因子 3 的数和 27 不互素,也就是 3 的倍数:3, 6, 9, 12, 15, 18, 21, 24, 27。因为每 pp 个数里面就有一个 pp 的倍数,所以非互素的数量是:m÷p=pe1m \div p = p^{e-1}. 例子中则是 27÷3=927 \div 3 = 9 个。那么与 mm 互素的数就可以计算为:φ(m)=pepe1\varphi(m) = p^e - p^{e-1}.
  3. 现实情况中,mm 往往很复杂。我们学过一个重要的数学定理:任何一个整数都可以拆分成几个素数的乘积,这称为 质因数分解 (Prime Factorization)。这里简单复习一下,我们一般使用短除法来解决。例如 m=67500m=67500 , 遵循如下的短除法算法对其进行质因数分解:
    def prime_factors(n):
    factors = {}
    i = 2
    while i * i <= n:
    while n % i == 0:
    factors[i] = factors.get(i, 0) + 1
    n = n // i
    i += 1
    if n > 1:
    factors[n] = 1
    return factors
    先从 2 开始试,依次尝试每一个素数因子,直到最后的商为 1。最后我们可以得到这样的素数组合:m=67500=22×33×54m = 67500 = 2^2 \times 3^3 \times 5^4. 所以我们可以将 mm 表示为, m=i=1npiei m=\prod_{i=1}^n p_i^{e_i} 接下来我们计算与 mm 互素的数的个数,即 φ(m)\varphi (m)。根据上述第二点的结论,与 mm 不互素的只有组成 mm 的各个素数因子的倍数。因为这些素数是完全独立的,只需要把每个独立的 φ\varphi 值乘起来就组成了 mmφ\varphi 值。 φ(m)=i=1n(pieipiei1) \varphi (m)=\prod_{i=1}^n \left (p_i^{e_i}-p_i^{e_i-1}\right) 我们举一个例子来理解一般情况下的欧拉公式:例如 m=100=22×52m = 100 = 2^2 \times 5^2,与 100100 互素的数有 φ(100)=(2221)×(5251)=40\varphi (100) = (2^2-2^1) \times (5^2-5^1) = 40 个。

回到仿射密码。对于英文字母表 m=26m=26,其质因数分解为 26=21×13126 = 2^1 \times 13^1,与它互素的数,即使得仿射密码有解的 aa 的值有 φ(26)=(2120)×(131130)=1×12=12\varphi(26) = (2^1-2^0) \times (13^1-13^0) = 1 \times 12 = 12 个。

拓展到任意的 mm,对于仿射函数 ax+bax+bbbmm 种选择(因为其只是平移量,符合 Zm\mathbb{Z}_m 的加法性质),aaφ(m)\varphi(m) 种选择。则 仿射密码的密钥空间 K=(a,b)K = (a,b) 的大小为:m×φ(m)m \times \varphi(m)

在解密仿射密码时,需要知道 aa 的乘法逆元 a1a^{-1},乘法逆元可以通过 拓展欧几里得算法 (Extended Euclidean Algorithm, EEA) 求得,在后续例子之后补充。在 m=26m=26 下,乘法逆元如下:

下面是一个仿射密码解密的例子:

假设仿射密码的密钥为 K=(7,3)K=(7,3),已知 7115(mod26)7^{-1}\equiv 15 \pmod{26}。加密函数为:eK(x)=7x+3e_K(x) = 7x+3,解密密文:AXG

我们先将其转换为数字:y={0,23,6}y = \{0,23,6\},使用解密函数:dK(y)=71(y3)mod26d_K(y) = 7^{-1} (y-3) \mod 26, 代入密文可以得到:

  • 15(03)=45715(0-3)=-45 \equiv 7,还原为 h
  • 15(233)=3001415(23-3)=300\equiv14,还原为 o
  • 15(63)=451915(6-3)=45\equiv19,还原为 t

通过上述步骤,密文 AXG 成功解密为明文 hot

补充:计算乘法逆元的方法 扩展欧几里得算法 (Extended Euclidean Algorithm, EEA)。在模运算里,求 7 在模 26 下的乘法逆元,就是要找一个数 xx,使得:7x1(mod26)7x \equiv 1 \pmod{26},也就是对于整数 y, k, y=ky,\ k,\ y=-k,存在 7x=1+26k    7x26k=1    7x+26y=17x = 1 + 26k \implies 7x - 26k = 1 \implies 7x + 26y = 1

先使用欧几里得算法 (辗转相除法) 计算 gcd(a,b)\gcd(a, b):反复用大数除以小数,取余数,直到余数为 0。以 gcd(7,26)\gcd (7, 26) 为例:

步骤运算余数
126=3×7+526 = 3 \times 7 + 5r=5r = 5
27=1×5+27 = 1 \times 5 + 2r=2r = 2
35=2×2+15 = 2 \times 2 + 1r=1r = 1
42=2×1+02 = 2 \times 1 + 0r=0r = 0
最后一个非零余数是 11,所以我们可以得出 26 和 7 的最大公约数 gcd(7,26)=1\gcd(7,26) = 1

接下来,我们可以通过逆推上述步骤,找到整数 xxyy,使得 ax+by=gcd(a,b)ax + by = \gcd(a, b)

步骤运算余数表达式
126=3×7+526 = 3 \times 7 + 55=263×75 = 26 - 3 \times 7
27=1×5+27 = 1 \times 5 + 22=71×52 = 7 - 1 \times 5
35=2×2+15 = 2 \times 2 + 11=52×21 = 5 - 2 \times 2

现在我们要把 11 写成 77 和 2626 的组合。

  1. 从第 3 步开始:5=2×2+15 = 2\times 2 + 1,移项得到:1=52×21 = 5 - 2\times 2,接着将第 2 步中得到的余数表达式代入此式:1=52(75)1 = 5 - 2(7-5),展开得到:1=52×7+2×51 = 5 - 2\times 7 + 2\times 5,观察到之前的步骤中存在余数 55, 我们整理为带有上一步骤余数的形式:1=3×52×71 = 3\times 5 - 2\times 7
  2. 接着继续将第 1 步的余数表达式 5=263×75 = 26 - 3\times 7 代入:1=3(263×7)2×71 = 3(26-3\times 7)-2\times 7,展开得到:1=3×269×72×71 = 3\times 26 - 9\times 7 - 2\times 7,合并保留 77 和 2626 的组合:1=11×7+3×261 = -11\times 7 + 3\times 26
  3. 现在对等式两边模 m=26m=26:因为 11×7+3×26=1-11\times 7 + 3\times 26 = 1, 3×260(mod26)3\times 26 \equiv 0 \pmod{26},所以 11×71(mod26)-11\times 7 \equiv 1 \pmod{26}。这说明 11-11772626 下的乘法逆元,写作 7111(mod26)7^{-1}\equiv -11 \pmod{26}。但是乘法逆元需要 Z26\in \mathbb{Z}_{26}, 所以 711115(mod26)7^{-1}\equiv -11\equiv 15\pmod{26}

维吉尼亚密码#

在前面介绍的移位密码和代换密码中,一旦密钥被选定,则每个字母对应的数字都被加密变换成对应的唯一数字,这种密码体制我们一般称为单表代换密码。维吉尼亚密码 (Vigenère Cipher) 是一种多表替换密码 (Polyalphabetic cryptosystem),同一个明文字母在不同位置会被加密成不同的密文字母,从而抵抗简单的词频分析。

维吉尼亚密码 主要使用了一个维度为 mm 的密钥向量,这个密钥是一组基于位置的密码表,让每个字母的移位不再和字母本身锁定,而是会随着位置的改变而改变。它的定义如下:

Vigenère Cipher

对于正整数 mm,定义 P=C=K=(Z26)mP=C=K=(\mathbb{Z}_{26})^m。对于任意以 mm 维度向量表示的密钥 K=(k1,k2,,km)K = (k_1,k_2,\dots,k_m),定义:

  • 加密函数:eK(x1,x2,,xm)=(x1+k1,x2+k2,,xm+km)(mod26)e_K(x_1,x_2,\dots,x_m) = (x_1+k_1, x_2+k_2, \dots, x_m+k_m) \pmod {26}
  • 解密函数:dK(y1,y2,,ym)=(y1k1,y2k2,,ymkm)(mod26)d_K(y_1,y_2,\dots,y_m) = (y_1-k_1, y_2-k_2, \dots, y_m-k_m) \pmod {26}

实际上维吉尼亚密码算是移位密码的拓展,接下来通过一个简单的例子来展示维吉尼亚密码的过程。

m=6m=6,密钥字为 CIPHER,其对应于如下的数字串 K=(2,8,15,7,4,17)K=(2,8,15,7,4,17)。加密:thiscryptosystemisnotsecure

首先我们将明文串转化为对应的数字。KK 是一个维度为 m=6m=6 的向量,它表示这套密码有 6 个不同的移动规则。我们将明文按 m=6m=6 个字符进行分组得到:

  • thiscr
  • yptosy
  • stemis
  • notsec
  • ure:这一组不满 6 个就保留即可。

对于每一组中,第 ii 个字母的偏移量为 kik_i。例如 thiscr 这一组中,第 11 个字母 t 的偏移量为 k1=2k_1=2,第 22 个字母 h 的偏移量为 k2=8k_2=8,依此类推。然后在下一组中重复。于是对于 thiscr 这一组,我们应用密钥 KK 可以得到如下的表格:

步骤第1位第2位第3位第4位第5位第6位
1. 明文字母thiscr
2. 明文数字 (P)197818217
3. 密钥字母CIPHER
4. 密钥数字 (K)28157417
5. 相加 (P+K)21152325634
6. 取模 (mod 26)2115232568
7. 密文字母 (C)VPXZGI
加密后 thiscr 变成了 VPXZGI

解密同理,只需要将密钥的移位量减去即可,下面的表格记录了如何将 VPXZGI 解密回 thiscr 的过程:

步骤第1位第2位第3位第4位第5位第6位
1. 密文字母VPXZGI
2. 密文数字 (C)2115232568
3. 密钥字母CIPHER
4. 密钥数字 (K)28157417
5. 相减 (C - K)1978182-9
6. 调整取模 (mod 26)197818217
7. 还原明文字母 (P)thiscr

维吉尼亚密码的密钥空间大小为 26m26^m。维吉尼亚密码比移位密码更难手工破解,但如果用于加解密的密钥 KK 重复使用,就会产生周期性结构。只要猜出密钥长度 kk,维吉尼亚密码就退化为 kk 个独立的移位密码。

希尔密码#

在维吉尼亚密码中,我们使用多表替换,同一个字母可能会变成不同的字母。但它的缺点也很明显,它是逐个字母加密的,如果破解者能猜出密钥的长度(比如长度是 6),他们就可以把密文分成 6 组,每组单独使用词频分析法来破解。

为了解决这个问题,希尔密码 (Hill Cipher) 采用了分组加密的思想。它利用线性代数中的矩阵乘法,mm 个明文字母组成的向量同时进行变换。由于加密过程涉及到多个字母的线性组合,这使得密文不仅取决于当前的明文字母,还取决于与其同组的其他字母,从而更有效地抵御频率分析。

简单来说:希尔密码把几个字母打包成一个向量,然后用矩阵把它们混合起来。

Hill Cipher

m2m \ge 2 是正整数,定义 P=C=(Z26)mP=C=(\mathbb{Z}_{26})^mK={m×m invertible matrices over Z26}K = \{m \times m\ \text{invertible matrices over } \mathbb{Z}_{26}\}x=(x1,x2,,xm)x=(x_1, x_2,\dots, x_m)(y1,y2,,ym)(y_1, y_2, \dots, y_m) 为密文向量。对于任意的密钥矩阵 KK 则定义:

  • eK(x)=xK(mod26)e_K(x) = xK \pmod {26}
  • dK(y)=yK1(mod26)d_K(y) = yK^{-1} \pmod {26}

接下来同样通过一个例子去解析这个过程。

设一次性处理 m=2m=2 个字母,密钥 K=(11837)K = \begin{pmatrix} 11 & 8 \\ 3 & 7 \end{pmatrix}, K1=(7182311)K^{-1} = \begin{pmatrix} 7 & 18 \\ 23 & 11 \end{pmatrix},需要加密的明文为 july。使用希尔密码进行加密。

根据 mm 的值将明文分为两组,并将其转换为一组向量:

  • ju: (9,20)(9, 20)
  • ly: (11,24)(11, 24)

接下来我们使用密钥矩阵对明文进行加密,在 ju 这一组中,让明文向量乘密钥矩阵(矩阵乘法,第一行乘第一列,第二行乘第二列):

(9,20)×(11837)=((9×11)+(20×3),(9×8)+(20×7))=(159,212)\begin{align*} (9, 20) \times \begin{pmatrix} 11 & 8 \\ 3 & 7 \end{pmatrix}&=((9 \times 11) + (20 \times 3), (9 \times 8) + (20 \times 7)) \\ &=(159, 212) \end{align*}

然后将其放回 Z26\mathbb{Z}_{26} 中,即 (mod26)\pmod{26}。得到 (3,4)(3,4),转换回字母得到 DE

同理可以对第二组 ly 进行加密:

(11,24)×(11837)=(11×11+24×3,11×8+24×7)=(193,256)\begin{align*} (11, 24) \times \begin{pmatrix} 11 & 8 \\ 3 & 7 \end{pmatrix} &= (11 \times 11 + 24 \times 3, 11 \times 8 + 24 \times 7) \\ &= (193, 256) \end{align*}

计算 193(mod26)=11L193 \pmod{26} = 11 \rightarrow \text{L}, 256(mod26)=22W256 \pmod{26} = 22 \rightarrow \text{W}。最终,明文 july 被成功加密成了密文 DELW

既然加密是乘以矩阵 KK,那解密自然就是乘以 KK 的逆矩阵 (K1K^{-1})。刚才例子中,以及给出了 K1K^{-1}。通过将密文转换的向量与逆矩阵相乘再取模就可以恢复明文了。例如解密 DE

所以密文向量是:(3,4)(3,4),相乘:(3,4)(7182311)=(37+423, 318+411)=(113, 98)(3,4) \begin{pmatrix} 7 & 18\\ 23 & 11 \end{pmatrix} = (3\cdot 7+4\cdot 23,\ 3\cdot 18+4\cdot 11) =(113,\ 98)。再模上 26 可以得到 (113,98)(9,20)(mod26)(113,98)\equiv (9,20)\pmod{26},转回字母可以解出 DEju\text{DE}\rightarrow \text{ju}

我们学习线性代数知道,不是所有的矩阵都有逆。KK 可逆是完成解密的必要条件,即 det(K)0\det (K) \neq 0det(K)\det (K) 是密钥矩阵 KK 的行列式,det(A)=a11C11+a12C12+a13C13\det(A) = a_{11}C_{11} + a_{12}C_{12} + a_{13}C_{13},其中 CijC_{ij} 是代数余子式(删掉第 ii 行第 jj 列后剩余矩阵的行列式,它的符号由行列决定,为 (1)i+j(-1)^{i+j})。下面是一个简单的例子:

A=(213045106)A = \begin{pmatrix} 2 & 1 & 3 \\ 0 & 4 & 5 \\ 1 & 0 & 6 \end{pmatrix} 如果我们按行展开:

det(A)=2×det(4506)1×det(0516)+3×det(0410)=2×(240)1×(05)+3×(04)=48+512=41\begin{align*} \det(A) &= 2 \times \det\begin{pmatrix} 4 & 5 \\ 0 & 6 \end{pmatrix} - 1 \times \det\begin{pmatrix} 0 & 5 \\ 1 & 6 \end{pmatrix} + 3 \times \det\begin{pmatrix} 0 & 4 \\ 1 & 0 \end{pmatrix} \\ &= 2 \times (24 - 0) - 1 \times (0 - 5) + 3 \times (0 - 4) \\ &= 48 + 5 - 12 = 41 \end{align*}

求逆还需要伴随矩阵 adj(A)\text{adj}(A),它是所有代数余子式组成的矩阵再转置。例如对上述的 AA 矩阵,第一步:计算每个位置的代数余子式 CijC_{ij} 得到:

位置删行删列后的子矩阵MijM_{ij}(1)i+j(-1)^{i+j}CijC_{ij}
(1,1)(1,1)(4506)\begin{pmatrix} 4 & 5 \\ 0 & 6 \end{pmatrix}240=2424-0=24++24
(1,2)(1,2)(0516)\begin{pmatrix} 0 & 5 \\ 1 & 6 \end{pmatrix}05=50-5=-5-5
(1,3)(1,3)(0410)\begin{pmatrix} 0 & 4 \\ 1 & 0 \end{pmatrix}04=40-4=-4++-4
(2,1)(2,1)(1306)\begin{pmatrix} 1 & 3 \\ 0 & 6 \end{pmatrix}60=66-0=6--6
(2,2)(2,2)(2316)\begin{pmatrix} 2 & 3 \\ 1 & 6 \end{pmatrix}123=912-3=9++9
(2,3)(2,3)(2110)\begin{pmatrix} 2 & 1 \\ 1 & 0 \end{pmatrix}01=10-1=-1-1
(3,1)(3,1)(1345)\begin{pmatrix} 1 & 3 \\ 4 & 5 \end{pmatrix}512=75-12=-7++-7
(3,2)(3,2)(2305)\begin{pmatrix} 2 & 3 \\ 0 & 5 \end{pmatrix}100=1010-0=10--10
(3,3)(3,3)(2104)\begin{pmatrix} 2 & 1 \\ 0 & 4 \end{pmatrix}80=88-0=8++8
第二步:组成代数余子式矩阵
C=(24546917108)C = \begin{pmatrix} 24 & 5 & -4 \\ -6 & 9 & 1 \\ -7 & -10 & 8 \end{pmatrix}

第三步:转置 → 得到伴随矩阵

adj(A)=CT=(24675910418)\text{adj}(A) = C^T = \begin{pmatrix} 24 & -6 & -7 \\ 5 & 9 & -10 \\ -4 & 1 & 8 \end{pmatrix}

有了行列式 det(A)\det (A) 和伴随矩阵 adj(A)\text{adj}(A) 后,我们可以通过如下公式求逆:

A1=1det(A)adj(A)A^{-1} = \frac{1}{\det(A)} \cdot \text{adj}(A)

在希尔密码中,矩阵的逆通常是在模 2626 的情况下求出来的。有一个定理:当行列式与 2626 不互素时,矩阵在模 2626 下没有逆矩阵。例如刚才的例子中,det(A)=41\det (A) = 41, gcd(41,26)=1\gcd(41,26) = 1, 所以这个例子在 (mod26)\pmod {26} 下存在逆矩阵。

所以 det(A)\det (A)(mod26)\pmod {26} 下,4115(mod26)41 \equiv 15 \pmod{26},而 1det(A)=det1(A)\frac{1}{\det(A)} = \det^{-1}(A). 根据我们之前提到的扩展欧几里得法,可以计算出 1517(mod26)15^{-1} \equiv 7 \pmod{26}。所以 AA 的逆是:

A1=7adj(A)(mod26)=(1210391182474)\begin{align*} A^{-1} &= 7 \cdot \text{adj}(A) \pmod{26} \\ &= \begin{pmatrix} 12 & 10 & 3 \\ 9 & 11 & 8 \\ 24 & 7 & 4 \end{pmatrix} \end{align*}

置换密码#

在我们之前学习的密码中,它们都有一个共同点:核心逻辑是通过特定的映射规则将明文字符替换为另一个字符,从而改变字符的取值。如果你截获了一段密文,你可以笃定里面的字母都不是它原本的意思。

置换密码(Permutation Cipher) 反其道而行。它又称换位密码,其核心思想是 保持明文字符集不变,通过 改变字符在序列中的位置 来达到加密目的。与代换密码不同,它不改变字符本身的取值,仅对其进行重新排列。

置换密码首先将密码进行分组(类似希尔密码的分组),每 mm 个字母切成一小块。在每一组中,规定一个固定的位置置换顺序。我们有如下置换密码的定义:

Permutation Cipher

mm 是一个正整数,定义 P=C=(Z26)mP = C = (\mathbb{Z}_{26})^m。密钥 K=πK = \pi 是由定义在集合集合 {1,2,,m}\{1, 2, \dots, m\} 上的一组置换组成。

  • 加密函数:eπ(x1,x2,,xm)=(xπ(1),xπ(2),,xπ(m))e_\pi(x_1, x_2, \dots, x_m) = (x_{\pi(1)}, x_{\pi(2)}, \dots, x_{\pi(m)})
  • 解密函数:dπ(y1,y2,,ym)=(yπ1(1),yπ1(2),,yπ1(m))d_\pi(y_1, y_2, \dots, y_m) = (y_{\pi^{-1}(1)}, y_{\pi^{-1}(2)}, \dots, y_{\pi^{-1}(m)}) 其中 π1\pi^{-1}π\pi 的逆置换。

置换密码实际上是希尔密码的一种特殊情况。如果希尔密码中的密钥矩阵 KK 是一个 置换矩阵(即矩阵的每一行和每一列有且只有一个 11,其余元素均为 00),那么该希尔密码就等价于置换密码。

接下来通过一个例子来演示加密和解密过程。

m=6m=6,密钥置换 π\pi 定义为: x123456π(x)351642\begin{array}{c|cccccc} x & 1 & 2 & 3 & 4 & 5 & 6\\ \hline \pi(x) & 3 & 5 & 1 & 6 & 4 & 2 \end{array} 这意味着:第 1 位换成原先的第 3 位,第 2 位换成原先的第 5 位,以此类推。需要加密的明文为:shesellsseashellsbytheseashore

将明文按 m=6m=6 分组,得到 shesellsseashellsbytheseashore

加密第一组 shesel:明文向量为 (x1,x2,x3,x4,x5,x6)=(s, h, e, s, e, l)(x_1, x_2, x_3, x_4, x_5, x_6) = (\text{s, h, e, s, e, l})。接下来根据 π\pi 进行位置映射:

密文位置置换位置置换后
1(x3)(x_3)e
2(x5)(x_5)e
3(x1)(x_1)s
4(x6)(x_6)l
5(x4)(x_4)s
6(x2)(x_2)h
所以:shesel → EESLSH。字母还是 s、h、e、s、e、l 这些字母,只是顺序变了。

解密过程需要用到逆置换 π1\pi^{-1}。根据 π\pi 的定义,我们可以推导出 π1\pi^{-1}

  • 因为 π(1)=3\pi(1)=3,所以 π1(3)=1\pi^{-1}(3)=1
  • 因为 π(2)=5\pi(2)=5,所以 π1(5)=2\pi^{-1}(5)=2
  • 因为 π(3)=1\pi(3)=1,所以 π1(1)=3\pi^{-1}(1)=3
  • 因为 π(4)=6\pi(4)=6,所以 π1(6)=4\pi^{-1}(6)=4
  • 因为 π(5)=4\pi(5)=4,所以 π1(4)=5\pi^{-1}(4)=5
  • 因为 π(6)=2\pi(6)=2,所以 π1(2)=6\pi^{-1}(2)=6

整理得到逆置换:

x123456π1(x)361524\begin{array}{c|cccccc} x & 1 & 2 & 3 & 4 & 5 & 6\\ \hline \pi^{-1}(x) & 3 & 6 & 1 & 5 & 2 & 4 \end{array}

使用 π1\pi^{-1} 对密文 EESLSH 进行解密即移动位置,即可还原回 shesel

分组密码与高级加密标准#

介绍分组密码之前,可以简单给加密算法进行分类。根据密钥的使用方式,加密算法可分为两大类:

  • 对称加密 (Symmetric Encryption):加密和解密用的是同一串密钥。
  • 非对称加密 (Asymmetric Cipher):加密与解密使用不同的密钥。

对称加密因其速度快、适合处理大量数据而广泛用于数据传输,但其只能保障数据的机密性;而非对称加密虽然速度慢,但可以同时保障数据的机密性、身份认证和不可否认性。

分组密码 (Block Ciphers) 是一种经典的 对称加密 (Symmetric Encryption) 算法。其基本原理是将明文数据按照固定长度的分组进行加密。

替换—置换网络#

替换—置换网络 (Substitution-Permutation Network, SPN) 可以想象为我们之前学习的替换密码和置换密码的组合网络。它的核心思想很简单:一次简单操作不够安全,那就把 替换位置置换 反复做很多轮。

它由两个重要组件组成:

  • S盒(S-box, Substitution,代换/混淆):类似替换密码,通过替换改变数据的值。它的目的是打断明文和密文之间的直接联系,让关系混淆。
  • P盒(P-box, Permutation,置换/扩散): 通过位置置换,改变数据的位置。它的目的是让明文中一个比特的影响迅速扩散到整个密文中。

如果只有 S 盒和 P 盒,如果这些规则是公开的,那么任何人都能照着做加密和解密。所以在 SPN 中,每一轮执行 S 和 P 操作时,都需要加入一个 轮密钥 (Round Key)。与每轮都使用同样的密钥不同,轮密钥使用密钥编排算法生成一组密钥编排方案 (K1,K2,,KNr+1)(K^1,K^2,\dots,K^{N_r+1})。在每一轮中,将与上一轮 P 盒的结果进行 异或 (XOR) 计算 以混合加密数据。解密时,混合模块不需要重新设计。只要拿出同一把轮密钥再做一次 XOR,数据就还原了。

SPN 的定义如下:

Substitution-Permutation Network, SPN

设明文和密文都是长度为 m\ell m 的二进制向量 ({0,1}\{0,1\}^{\ell}),存在 S-box πS:{0,1}{0,1}\pi_S:\{0,1\}^{\ell}\rightarrow \{0,1\}^{\ell},和 P-box πP:{1,,m}{1,,m}\pi_P:\{1,\dots,\ell m\}\rightarrow \{1,\dots,\ell m\}。密钥 K({0,1})Nr+1K \subseteq (\{0,1\}^{\ell})^{N_r+1} 由初始密钥 K 用密钥编排算法生成的所有可能的密钥编排方案的集合,对一个密钥编排方案 (K1,K2,,KNr+1)(K^1,K^2,\dots,K^{N_r+1}),使用如下的过程加密明文 xx

其中,\ell 表示每个 S-box 处理多少 bit,mm 表示每轮有多少个 S-box,m\ell m 则表示整个明文分块的大小。

在每轮中,有如下符号:

  • wr1w^{r-1}: 表示第 r1r-1 轮结束后的状态。初始化时为 w0w^0,初始值为明文 xx 的明文分块形式。
  • KrK^r:表示第 rr 轮的轮密钥。
  • ur=wr1Kru^r=w^{r-1}\oplus K^ruru^r 是第 rr 轮 S-box 的输入,它由上一轮的状态和轮密钥异或计算得到。
  • vrv^r:表示第 rr 轮 S-box 的输出。
  • wrw^r:表示第 rr 轮经过 P-box 重新排列后输出的状态。wr=πP(vr)w^r=\pi_P(v^r)

假设我们要循环 NN 次(称为 NN 轮,Round):

  1. 初始化:把明文加入算法 (w0xw_0 \leftarrow x)。
  2. N1N-1 轮循环:
    1. 密钥混合:把当前状态和这一轮的轮密钥进行 XOR (urwr1Kru_r \leftarrow w_{r-1} \oplus K_r)。
    2. 替换:把数据切成小块,分别送进 S-box 进行替换 (vrπS(ur)v_r \leftarrow \pi_S(u_r))。
    3. 位置置换:把 S-box 的输出,按 P-box 的规则打乱位置 (wrπP(vr)w_r \leftarrow \pi_P(v_r))。
  3. 最后一轮 (第 NN 轮) 的特殊处理:
    1. 密钥混合:把倒数第二轮的状态和最后一轮的轮密钥进行 XOR (uNwN1KNu_N \leftarrow w_{N-1} \oplus K_N)。
    2. 替换:把数据切成小块,分别送进 S-box 进行替换 (vNπS(uN)v_N \leftarrow \pi_S(u_N))。
    3. 不进行替换,再次进行密钥混合:yvNKN+1y \leftarrow v_N \oplus K_{N+1}。这是为了让加密和解密的电路是对称的,最后再加一次密钥,是为了防止破解者轻易剥离掉最后一轮的 S-box。这种首尾都加密钥的设计叫白化 (Whitening)。

算法的伪代码如图:

471

接下来通过一个例子来解析这个过程。

给出如下的 SPN 设置:设 =m=Nr=4\ell=m=N_r=4,S-box 的输入 zz 与其输出 πS(z)\pi_S(z) 都是使用十六进制表示。

S-box (十六进制对照): 类似一个字典。

(z)(z)0123456789ABCDEF
(πS(z))(\pi_S(z))E4D12FB83A6C5907

P-box: 表示输出 ww 的第 ii 位,取输入 vv 的第 πP(i)\pi_P(i) 位。

(z)(z)12345678910111213141516
(πP(z))(\pi_P(z))15913261014371115481216

密钥 K=0011 1010 1001 0100 1101 0110 0011 1111K=0011\ 1010\ 1001\ 0100\ 1101\ 0110\ 0011\ 1111,通过一些编排算法后得到如下的轮密钥:

  • K1=0011 1010 1001 0100K^1=0011\ 1010\ 1001\ 0100
  • K2=1010 1001 0100 1101K^2=1010\ 1001\ 0100\ 1101
  • K3=1001 0100 1101 0110K^3=1001\ 0100\ 1101\ 0110
  • K4=0100 1101 0110 0011K^4=0100\ 1101\ 0110\ 0011
  • K5=1101 0110 0011 1111K^5=1101\ 0110\ 0011\ 1111

明文是 x=0010 0110 1011 0111x=0010\ 0110\ 1011\ 0111。接下来我们开始这个流程:

  1. 初始化:w0=x=0010 0110 1011 0111w^0=x=0010\ 0110\ 1011\ 0111
  2. 11 轮:
    1. 密钥混合:已知 K1=0011 1010 1001 0100K^1=0011\ 1010\ 1001\ 0100,将其与 w0w^0 逐位异或可以得到 u1=w0K1=0001 1100 0010 0011=1 C 2 3u^1=w^0\oplus K^1 = 0001\ 1100\ 0010\ 0011 = 1\ C\ 2\ 3564
    2. 替换:把 u1u^1 分成 mm 组,每组刚好四个 bit,将其转换会十六进制,对每组查表替换:14, C5, 2D, 311\rightarrow 4, \ C\rightarrow 5,\ 2\rightarrow D, \ 3\rightarrow 1v1=4 5 D 1=0100 0101 1101 0001v^1=4\ 5\ D\ 1=0100\ 0101\ 1101\ 0001 565
    3. 位置置换:应用 P-box 规则,例如 w1w^1 的第 11 位是 u1u^1 的第 11 位,第 22 位是 u1u^1 的第 55 位… w1=0010 1110 0000 0111w^1=0010\ 1110\ 0000\ 0111 567
  3. 接下来是第 2 ~ 3 轮,过程类似。
  4. 在第 4 轮中,
    1. 密钥混合: w3=1110 0100 0110 1110w^3=1110\ 0100\ 0110\ 1110, K4=0100 1101 0110 0011K^4=0100\ 1101\ 0110\ 0011, u4=w3K4=1010 1001 0000 1101u^4=w^3\oplus K^4=1010\ 1001\ 0000\ 1101
    2. S-box 替换:v4=0110 1010 1110 1001v^4=0110\ 1010\ 1110\ 1001
    3. 白化:再次进行一轮密钥混合,y=v4K5y=v^4\oplus K^5, K5=1101 0110 0011 1111K^5=1101\ 0110\ 0011\ 1111,所以 y=1011 1100 1101 0110y=1011\ 1100\ 1101\ 0110,将其转换为十六进制是 BCD6\boxed{BCD6}

过程对照表如下:

阶段
w0=xw^0=x0010 0110 1011 0111
K1K^10011 1010 1001 0100
u1u^10001 1100 0010 0011
v1v^10100 0101 1101 0001
w1w^10010 1110 0000 0111
K2K^21010 1001 0100 1101
u2u^21000 0111 0100 1010
v2v^20011 1000 0010 0110
w2w^20100 0001 1011 1000
K3K^31001 0100 1101 0110
u3u^31101 0101 0110 1110
v3v^31001 1111 1011 0000
w3w^31110 0100 0110 1110
K4K^40100 1101 0110 0011
u4u^41010 1001 0000 1101
v4v^40110 1010 1110 1001
K5K^51101 0110 0011 1111
yy1011 1100 1101 0110

DES#

在刚才学习的 SPN 网络中,有一个隐藏的问题:为了能让密文解密还原回明文,我们在 SPN 里使用的 S-box 必须是可逆的。然而在数学上,设计一个高安全度且可逆的 S-box 很困难。为了解决这个问题,密码学家提出了 Feistel 结构,并设计了 DES (Data Encryption Standard)。在这种结构中,每一轮的轮函数 (S-box) 并不要求是可逆的,因为其解密过程是通过 结构自身的对称性 来实现的。这使得 S 盒的设计更加灵活,可以使用更复杂的非线性映射来增强安全性,而无需担心解密时的可逆性限制。

Feistel 结构的基本原理是将输入的明文平分成左右两部分。具体而言:

  1. 每一轮把当前状态分成两半:ui=LiRiu_i = L_iR_iLiL_i 表示左半边,RiR_i 表示右半边。对于第 ii 轮而言,它的输入是 Li1,Ri1L_{i-1}, R_{i-1}
  2. 在第 ii 轮中:
    1. 将右半边的 Ri1R_{i-1} 复制一份,直接等于下一轮的左半边:Li=Ri1L_i = R_{i-1}
    2. 将右半边的 Ri1R_{i-1} 和当前这一轮的轮密钥 KiK_i 一起加入一个搅拌函数 ff 中得到一个加密数据:f(Ri1,Ki)f(R_{i-1}, K_i)
    3. 最后将这个加密数据与原本的左半边 Li1L_{i-1} 进行 异或 (\oplus) 运算,得到的结果成为了下一轮的右半边:Ri=Li1f(Ri1,Ki)R_i = L_{i-1} \oplus f(R_{i-1}, K_i)

下图展示了 Feistel 结构的基础架构:

328

这个结构同时也是 DES 加密过程中的一轮。DES 是一个 16 轮的 Feistel 网络,处理 64 比特 的数据块,用一个 56 比特 的密钥(另有 8 比特奇偶校验,实际存储 64 比特)。

DES 的大致流程是:

  1. 先对明文 xx 做一个固定的 初始置换 IP (Initial Permutation),记为 IP(x)=L0R0\text{IP}(x)=L^0R^0
  2. 经过如上的 16 轮 Feistel 结构加密,得到 L16R16L_{16}R_{16},将其 交换顺序 得到:R16L16R_{16}L_{16}
  3. 将交换顺序后的密文做一个固定的 逆置换 IP1IP^{-1},得到最后加密的密文 yy,即 y=IP1(R16L16)y=\text{IP}^{-1}(R_{16}L_{16})

其中初始置换及其逆置换没有密码学意义,仅是为了适应当时的硬件设计。

那 DES 的设计为什么能解决要求轮函数可逆的问题呢?它运用了异或运算的数学性质:一个数据被同一个值异或两次,就会回到原值 ABB=AA \oplus B \oplus B = A

假设你拿到了第 ii 轮结束后的密文结果 (Li,Ri)(L_i, R_i)

  • LiL_i 就是上一轮的 Ri1R_{i-1},所以可以得到 Ri1=LiR_{i-1} = L_i
  • 当你知道当前这一轮的密钥 KiK_i 时,你同时也知道上一轮的右半边 Ri1R_{i-1},你可以代入加密函数重构它的值 f(Ri1,Ki)f (R_{i-1}, K_i)
  • 接下来就可以通过异或的性质得到上一轮的左半边 Li1L_{i-1}Ri=Li1f(Ri1,Ki)    Li1=Rif(Ri1,Ki)R_i = L_{i-1} \oplus f(R_{i-1}, K_i) \implies L_{i-1} = R_i \oplus f(R_{i-1}, K_i)

在 DES 中,我们 根本不需要去逆向破解 ff 函数。只需要重新运行它一次,利用异或运算的还原能力,就能把数据完美还原。DES 的加密和解密算法是完全相同的,解密时只需将相同的输入跑一遍,并把子密钥的调度顺序反过来即可。

你可能会好奇它的加密函数 ff 内的样子,和 SPN 类似吗?下图展示了其加密函数的架构。

477

DES ff 函数的输入是:f(Ri1,Ki):{0,1}32×{0,1}48{0,1}32f (R_{i-1}, K_i):\{0,1\}^{32}\times\{0,1\}^{48}\rightarrow \{0,1\}^{32},它包含 32 位的右半边和 48 位的轮密钥,最后产生一个 32 位的结果。

  1. 在其中,ff 函数使用扩展函数 EE 重新排列 32 位的右半边输入,并将其中的 16 位复制一遍,扩展成 48 位拉伸后的数据 E(A)E(A)
  2. 将其与轮密钥逐位异或:E(A)KiE(A) \oplus K_i,并将运算结果分成 8 个小组(B1B_1B8B_8),每组包含 6 个比特。
  3. 将这 8 个组分别送入 8 个不同的 S 盒(S1S_1S8S_8),经过查表替换,每个 S 盒得到 4 个比特Si:{0,1}6{0,1}4S_i: \{0,1\}^6 \rightarrow \{0,1\}^4.
  4. 将其输出拼在一起得到 32 位的 CC,然后送进置换函数 PP 中进行置换。置换后输出的 P(C)P(C),就是 ff 函数的最终产物。

AES#

DES 为了避开设计可逆 S 盒的难题,使用了 Feistel 结构,代价是 每轮只能加密一半的数据。密码学家利用高级的数学工具(有限域/伽罗瓦域)制造出了 SPN 中的完美可逆 S 盒。AES (Advanced Encryption Standard) 抛弃了 Feistel 结构,全面回归了 SPN 结构。这使得 AES 每轮能把所有数据都加密一遍,效率提高。

AES 中,标准的数据块是 128 bits。它不再把这 128 bits 看作一条序列,而是把它切成 16 个 Byte(1 byte = 8 bits),然后转换成一个 4 x 4 的矩阵。这个矩阵在 AES 中被称为 状态矩阵 (State),其表达式如下(Byte 按 列顺序 摆出)。

s0,0s0,1s0,2s0,3s1,0s1,1s1,2s1,3s2,0s2,1s2,2s2,3s3,0s3,1s3,2s3,3=x0x4x8x12x1x5x9x13x2x6x10x14x3x7x11x15\begin{matrix} s_{0,0} & s_{0,1} & s_{0,2} & s_{0,3}\\ s_{1,0} & s_{1,1} & s_{1,2} & s_{1,3}\\ s_{2,0} & s_{2,1} & s_{2,2} & s_{2,3}\\ s_{3,0} & s_{3,1} & s_{3,2} & s_{3,3} \end{matrix} = \begin{matrix} x_0 & x_4 & x_8 & x_{12}\\ x_1 & x_5 & x_9 & x_{13}\\ x_2 & x_6 & x_{10} & x_{14}\\ x_3 & x_7 & x_{11} & x_{15} \end{matrix}

AES 会根据不同的密钥长度定义不同的轮数,一般来说 AES-128 是 10 轮,AES-192 是 12 轮,AES-256 是 14 轮。

N1N-1 轮中,都包含如下四步:

  1. 字节代换 (SubBytes):将状态矩阵通过一个 16 x 16 的固定 S 盒,每个 byte 通过 S-box 替换。如图是一个 S 表的例子。 458
  2. 行移位 (ShiftRows):它会将每一行循环左移不同距离,相当于行置换。第 i=0,1,2,3i=0,1,2,3 行整体向左移动 ii 格。例如第 0 行移动 0 格(不变),第 1 行经过上一步后的输出为:s1,0,s1,1,s1,2,s1,3s_{1,0}, s_{1,1}, s_{1,2}, s_{1,3},经过 ShiftRows 向左移动 1 格后变为:s1,1,s1,2,s1,3,s1,0s_{1,1}, s_{1,2}, s_{1,3}, s_{1,0}
  3. 列混淆 (MixColumns):将每一列内部混合。它每次处理矩阵的一列。它把这 4 个字节当作多项式的系数,去乘以一个固定的矩阵。经过极度复杂的运算后,输出全新的 4 个字节。
  4. 轮密钥加 (AddRoundKey):最后,把这一轮的 128 位轮密钥也拆分为字节,排成一个 4x4 的矩阵,跟我们刚才搅拌好的状态矩阵进行简单的 异或 (\oplus) 运算

NN 轮时则没有 MixColumns 这个操作

AES 的轮密钥是通过 密钥拓展 (Key Expansion) 生成的,这一过程将初始密钥按 字 (Word) (1 Word = 4 Bytes) 扩展为一个更大的密钥序列,确保每一轮迭代都使用唯一的子密钥。例如 AES-128 需要将 128 位的初始密钥扩展为 11 组轮密钥,128 位的密钥对应 16 个 Byte,即 4 Words。Key Expansion 会生成 11×4=4411 \times 4 = 44 个 Word,每轮 AddRoundKey 使用其中 4 个 Word。

Hash 函数#

Hash 函数和 MAC#

之前学习的加密算法都在尝试各种方法将一段信息加密为其他人看不懂的内容,在现实世界中,只有机密性是不够的。其他人就算看不懂密文,但他如果把密文拦截下来,随便篡改几个字节都会导致你解密失败。或者是黑客假冒你的身份发了一条指令,这时解密者不知道是否是你发的。

这时候我们就需要解决两个新问题:

  1. 完整性 (Integrity):数据在传输过程中,有没有被改动过。
  2. 认证 (Authentication):这数据是否是你本人发出来的。

一个很简单的方法就是:添加指纹 (fingerprint)。

哈希函数 (Hash Function) 是一种给信息添加指纹的方法。它的输入可以是任意长度的消息(一个文件、一句话、一部电影),输出则是固定长度的无规律字符串,也就是数字指纹,也被称为 消息摘要 (message digest)。比如常见的 MD5 或 SHA-256 就是 Hash 算法。这个指纹是公开可计算的,任何人拿到消息,都能通过同样的 Hash 函数算出一样的指纹。Hash 函数具有如下的特性:

  • 不可逆:无法通过 Hash 值推导出原信息是什么。
  • 雪崩效应 (Avalanche Effect):信息发生任何的改动都会导致 Hash 值的变化。
  • 抗碰稳固:很难找到两份内容不同但 Hash 值却一样的文件。

一个非常常见的 Hash 函数的应用就是 软件完整性验证:官网发布软件时,同时公布它的 Hash 值。个人下载软件后自己算一遍 Hash 值,对比官网的值,就知道文件有没有被篡改或损坏。

Hash 算法是没有密钥的,每个人都可以算。而在此基础上,消息认证码 (MAC) 则是加上了一个密钥。MAC 的计算不仅依赖于文件内容,还依赖于一个 只有通信双方才知道的秘密密钥 (KK)。黑客就算篡改了文件,想重新算一个合法的 MAC,但他 没有密钥,所以算不出来。

Hash 函数解决了数据有没有变的问题,而 MAC 更进一步,不仅解决了数据有没有变,还提供了密钥认证,以确定计算者的身份,保证数据是你发的。

Merkle-Damgård 结构#

我们知道,哈希函数具有输入为任意长度的信息,输出为固定长度的信息摘要的特点。这样的特性是怎么设计的呢?在密码学里,数学家们非常擅长使用 压缩函数 (Compression Function,通常记为 ff),它只可以接受固定长度的输入,并输出固定长度的信息。密码学家设计了一种 Merkle-Damgård (MD) 结构,将压缩函数 ff 扩展成一个 可以处理任意长消息 的 Hash 函数。

MD 结构的核心思想是:用一个只能处理固定长度输入的压缩函数 ff反复处理长消息 xXx \in X 的每一块;每一轮的输出变成下一轮的状态,最后一个状态就是 hash 值。这样的过程类似于递归求解。

首先我们设定一个碰撞稳固的压缩函数:compress:{0,1}m+t{0,1}m\text{compress}:\{0,1\}^{m+t}\rightarrow \{0,1\}^{m},它的输入是 m+tm+t bits,输出是 mm bits。这个 mm 也是多轮递归处理时的状态长度(因为上一轮的输出一定是 mm),同时最后生成的 Hash 值也是长度为 mm 的消息摘要。tt 表示除了状态以外还能吃进去的额外空间相关参数。我们用 n=xn=|x| 记录整体输入信息的长度。

我们需要构造这样的 Hash 函数:h:X{0,1}mh:X\rightarrow \{0,1\}^{m},其中 XX 是足够长的有限比特字符串的集合。现在问题是:真实的输入 xXx \in X 可能很长,而压缩函数只能处理固定长度 m+tm+t bits。所以 MD 结构设计了这样的链式结构:

初始状态 → 吃第 1 块 → 新状态
新状态 → 吃第 2 块 → 新状态
新状态 → 吃第 3 块 → 新状态
...
最终状态 = hash 消息摘要

在第 ii 轮可以写作:gi=compress(gi1yi)g_i = \text{compress}(g_{i-1}\|y_i)gig_i 表示第 ii 轮后的状态;yiy_i 表示第 ii 个信息块,\| 表示拼接。我们可以把每一轮的状态 gig_i 理解为前 ii 个消息块共同留下来的 累计指纹,因为我们不是分块单独压缩,而是基于前面的分块再加上当前分块的链式压缩。所以每一轮压缩函数都必须带上上一次的状态 gi1g_{i-1},这也类似于递归中的值的传递。每一轮的压缩本质上是把前面的内容压缩成一个固定长度状态。

那我们已经知道,第 i1i-1 轮压缩后的状态 gi1g_{i-1}mm 位的。而下一轮的压缩函数只能输入 m+tm+t 位,直觉上第 ii 轮可以吃 t 位的信息块,但实际上还需要在上一轮状态和这一轮的信息块之间 加入 1 bit 的固定标记 11。这是为了防止 内部碰撞,即如果攻击者能找到某个状态与消息块的组合碰撞,他就可以在两个长度不同的消息间制造相同的哈希值。

所以 信息块的长度 应该设置为:t1t-1. 那么根据这个长度,我们可以将初始的输入 xx 分为长度为 t1t-1 的若干块,所需要的块数是:k=nt1k=\left\lceil \frac{n}{t-1}\right\rceil。此时得到:x=x1x2xkx=x_1\|x_2\|\cdots\|x_k

因此,可能会存在最后一个块 xkx_k 的长度小于 t1t-1 bits. 例如每块长度是 t1=4t-1 = 4 bits,消息长度是 n=14n=14 bits,那么:k=14/4=4k=\lceil 14/4\rceil=4,最后一块 xk=2<t1|x_k|=2 < t-1. 遇到这种情况的时候,我们一般会给它后面补 dd00, d=(t1)×knd = (t-1) \times k - n

此外,我们 还要额外记录补 0 的个数 dd,用 yk+1y_{k+1} 来表示 dd 的二进制。如果只补 0,不记录补了几个 0,会产生歧义。如果刚好有其他的信息二进制与补 0 后的信息相同,那么它们的 hash 值也会相同,这就存在碰撞。

算法的过程如下:

Algorithm 5.6: MERKLE-DAMGARD(x)
external compress
comment: compress : {0,1}^{m+t} -> {0,1}^m, where t >= 2
n <- |x| // 原始的长度
k <- ceil(n / (t - 1)) // 分块的数量
d <- k(t - 1) - n // 需要补 0 的个数
for i <- 1 to k - 1: // 遍历 k-1 个分块,用 y 表示每个分块,长度都是 t-1 bits
y_i <- x_i // x_i 是消息 x 已经切好的分块,在 k-1 时直接赋值
y_k <- x_k || 0^d // 给最后一块 x_k 补 0,让它变成 t-1 bits
y_{k+1} <- binary representation of d // 记录补 0 的数量,用于消除编码歧义
z_1 <- 0^{m+1} || y_1 // 补充初始状态和标志位,均为 0
g_1 <- compress(z_1) // 进行第一次压缩,得到第 1 轮的状态
for i <- 1 to k: // 循环压缩,直到压缩完所有分块
z_{i+1} <- g_i || 1 || y_{i+1} // 补充输入
g_{i+1} <- compress(z_{i+1}) // 压缩第 i+1 轮
h(x) <- g_{k+1} // 包含处理最后的 y_k+1
return h(x)
  1. MD 结构首先将输入的 xx 按固定大小切块,得到 x=x1x2xkx=x_1\|x_2\|\cdots\|x_k。设长度块 yiy_i 为 MD 算法中用到的信息块,在 k1k-1 块内,yi=xiy_i=x_i;在第 kk 块中,可能需要进行补 0;同时再用一个 yk+1y_{k+1} 来表示补 0 的个数。现在原消息 xx 被变成了一串 yy 信息块:y1,y2,,yk,yk+1y_1,y_2,\dots,y_k,y_{k+1},每一个的长度都是 t1t-1 bits。
  2. 我们使用 ziz_i 表示第 ii 轮应该输入给压缩函数的输入,根据我们之前的分析,它应该包含 上一轮的状态 | 分隔标志位 | 信息块。在初始情况下,z1z_1 没有上一轮的状态,理论上也不需要标志位,所以需要在前面补 (m+1)(m+1) 个 0: z10m+1y1z_1 \leftarrow 0^{m+1} || y_1。在之后的第 i+1i+1 轮的输入中,zi+1=gi1yi+1z_{i+1}=g_i\|1\|y_{i+1},就需要加上上一轮的状态和分隔标志位 11 了。
  3. 循环处理压缩,直到压缩完所有分块。

我们这个算法的设计是有逻辑链的,如下描述可以帮助理解:

  1. x=x1x2xkx=x_1\|x_2\|\cdots\|x_k: 长消息太长 → 必须切块
  2. ykxk0dy_{k} \leftarrow x_k || 0^d: 最后一块可能不满 → 右侧补 0
  3. yk+1y_{k+1}: 只补 0 会有歧义 → 额外记录补了几个 0
  4. 压缩一次只能吃一个固定长度输入 → 必须多轮处理
  5. 每轮要记住前面处理结果 → 用 gig_i 作为链式状态
  6. 第一轮和后续轮要区分 → 用 0/1 作为结构标记
  7. 最后一个状态 gk+1g_{k+1} → 就是 hash 值

MD 结构是 抗冲突的 (collision resistant)。如果两个不同消息 xxx\ne x', 最后得到同一个 hash h(x)=h(x)h (x)=h (x'),这说明 gk+1=gk+1g_{k+1}=g'_{k'+1}

  • 如果发现 zzz\ne z',那我们就发现了是压缩函数产生了冲突。
  • 如果发现 z=zz=z',那说明上一轮状态和当前块都一样:gi=gjg_i = g'_j, yi+1=yj+1y_{i+1} = y'_{j+1}。最后只有可能在某一轮找到了压缩函数的冲突,或者是 yy 值都一样。
  • 但如果是所有的 yy 都一样,因为 yk+1y_{k+1} 记录了补 0 的长度,所以可以唯一还原原始 xx。这就会推出:x=xx = x',这与我们的假设逻辑冲突。

所以,如果能找到 hh 的冲突,那么就能找到压缩函数的冲突;因此压缩函数是抗冲突的,构造出的 hash 函数也抗冲突。

我们刚才处理的情况中,压缩函数除了长度为 mm 的状态外,还能处理多出的 t1t-1 bits 的信息块。但如果在极端情况下,压缩函数只能处理 m+1m+1 bits 的输入,此时我们不能将原信息分成 t1t-1 bits 了,因为 t1=0t-1=0. 那么在这种情况下如何将一整条长消息加入压缩函数呢?

此时需要特殊处理,算法如下:

Algorithm 5.7: MERKLE-DAMGARD 2(x)
external compress
comment: compress : {0,1}^{m+1} → {0,1}^m
n ← |x| // 原信息的长度
y ← 11 || f(x1) || f(x2) || ... || f(xn) // 使用编码函数转换原始信息为 y
denote y = y1 || y2 || ... || yk, // 把编码后的 y 看成一串单独的 bit。
where yi ∈ {0,1}, 1 ≤ i ≤ k
g1 ← compress(0^m || y1) // 补充初始状态和第 1 个 bit 作为输入
for i ← 1 to k − 1: // 链式压缩
gi+1 ← compress(gi || yi+1)
return gk

它的思路是:先把原消息重新编码成 yy,然后逐 bit 链式压缩。

  1. 假设原消息是:x=x1x2xnx=x_1x_2\cdots x_n,注意这里的每一个 xix_i 都是 1 bit 的,xi{0,1}x_i\in\{0,1\}
  2. 它定义了一个 特殊编码函数 f: f(0)=0; f(1)=01f:\ f(0) = 0;\ f(1)=01。通过这个编码函数,我们将原始消息 xx 转换为一个新的比特串 yy。我们还需要在 yy 前面加上一个 前缀 1111, 用来标记编码的开始(因为不存在连续的 1)。例如二进制下 x=101x = 101f(x1)  f(x2)  f(x3)=01  0  01=01001f (x_1)\ ||\ f (x_2)\ ||\ f (x_3) = 01\ ||\ 0\ ||\ 01 = 01001y=11  01001=1101001y = 11\ ||\ 01001 = 1101001
  3. 接下来,把 yy 拆成单个 bit。例如 y=1101001y = 1101001,那就可以分成 k=7k=7 个 bit。这个 kk 与之前的算法中的 kk 不同
  4. 开始压缩,压缩的输入需要由上一轮的状态 gi1g_{i-1}当前轮的单个 bit 组成。初始状态为 0m0^m

既然每轮只能吃 1 bit,那为什么不直接把 x=x1x2xnx=x_1x_2\cdots x_n 逐位吃入进行压缩,而是要使用一个转换后的 yy 呢?这样 不能很好地处理不同长度消息之间的安全证明。假设两个不同长度的消息最终 hash 一样:h(x)=h(x)h (x)=h (x'),和我们之前的分析一样,可能会推出 短消息的 bit 串等于长消息 bit 串的后缀 这样的逻辑矛盾。例如 x=101; x=00101x = 101;\ x' = 00101。我们加入了前缀 1111 后就可以解决这个问题,因为编码主体不存在两个连续的 11。如果两个编码长度不同,那么在没有找到压缩函数冲突的情况下,会推出一个编码是另一个编码的后缀,但这产生了逻辑矛盾。

Sponge 结构#

海绵结构 (Sponge Construction) 是 Hash 函数设计里的另一条路线。SHA-3 就是基于海绵结构设计的。它不再使用 Merkle-Damgård 那种输出固定长度的压缩函数,而是使用一个 固定长度到固定长度 的函数 f:{0,1}b{0,1}bf:\{0,1\}^b\to\{0,1\}^b,使得它不仅能 吃进任意长度 的数据,还能 吐出任意长度 的结果。

海绵结构的设计思路是:先把消息一块块吸进去,再从内部状态里挤出需要长度的输出。

海绵结构内部有一个固定大小的内存空间,我们称之为 状态 (State),总长度设为 bb bits (width)。这 bb 个比特的空间,被划分成了上下两个区域,分别是:

  • rr (bitrate,速率/吞吐量):这是海绵的表层。用于衡量每次能吸收 / 输出多少 bits。rr 越大,每次吸收越多,速度越快。
  • cc (Capacity,容量/安全区): 这是海绵的深层核心。不直接接触消息和输出,为了在内部把数据搅乱,提供绝对的安全性。cc 越大,内部隐藏部分越多,安全性越强。

如图,我们知道 b=r+cb = r + c。此外,空间中还存在很多个搅拌机 ff,负责把 bb(也就是 r+cr+c )里面的数据彻底打乱融合。

503

跟着这张图,下面展示海绵结构如何得到 hash 值的过程。首先是 吸收阶段 (Absorbing Phase)

  1. 输入消息 MM:原始消息 MM 先进入 pad\text{pad} 中,将其切成 rr bits 个分块,得到:M=m1m2mkM=m_1\|m_2\|\cdots\|m_k,每个 mim_i 都是 rr bits。
  2. 初始化状态:在左侧设置一个初始状态:x0=0r,y0=0cx_0=0^r,\quad y_0=0^c
  3. 吸收第 1 块:第一块 m1m_1  和 state 上半部分 (x0x_0) 进行异或计算:x0m1x_0\oplus m_1, 然后整个状态进入 ff 中执行搅拌,输出 x1y1x_1\|y_1
  4. 吸收后续块:接下来把第 2 个数据块 m2m_2,与现在全新的表层 rr (x1x_1) 异或,再加入 ff 中搅拌得到第 2 轮的状态 x2y2x_2\|y_2。循环往复,直到所有的数据块 m1m_1mkm_k 全部被吸入并搅拌完毕。

接下来是 **挤出阶段 (Squeezing Phase)。

  1. 挤出第 1 次:直接把当前海绵表层 rr 的数据读出来,输出给用户。这就是你的第一段 Hash 值(长度为 rr)。
  2. 再次挤出直到结束:如果发现输出不够长,则对当前状态进行内部搅拌 ff 后,再次把变幻后的表层 rr 读出来,拼接到刚才的输出后面,直到挤出的总长度满足你的需求。

最后把挤出的输出块拼起来,只保留前  bits,这就是最终的信息摘要。

下表是两种结构的对比:MD 是把消息压短;Sponge 是把消息吸进一个大状态,再从状态中挤出输出

Merkle-DamgårdSponge
基本组件压缩函数固定长度的搅拌函数
组件形式{0,1}m+t{0,1}m\{0,1\}^{m+t}\to\{0,1\}^m{0,1}b{0,1}b\{0,1\}^b\to\{0,1\}^b
处理消息方式每轮压缩成较短的状态每轮把消息 XOR 进当前状态,再搅拌
内部状态通常就是最终输出长度附近b=r+cb=r+c
输出长度通常固定可以任意长度
典型代表SHA-1, SHA-2 类结构SHA-3 / Keccak

RSA#

我们之前学的古典密码以及分组密码,都有一个致命的弱点:Alice 和 Bob 必须在通信之前共享一个秘密密钥。但是有一个严重的问题:如何在一个无法保证完全安全的信道中,把这把钥匙安全地交到对方手里?

这种困境促使了 公钥密码学 (Public-key Cryptography) 的诞生。1976 年,Diffie 和 Hellman 提出了公钥加密的思想,而 RSA 算法则是第一个真正意义上实用的公钥加密系统。

RSA (Rivest, Shamir, Adleman, 1977) 使用非对称密钥——公钥 (Public key) 和私钥 (Private key),巧妙地解决了在不安全信道下分发密钥的难题。

RSA 的安全性基于一个“单向函数”的 数学陷阱将两个大的素数相乘在计算上是非常容易的,但要将它们的乘积重新分解回原来的因数在计算上是几乎不可能的

RSA 数学基础#

在学习 RSA 之前,再次复习本篇之前提到的一些数学基础:

对于正整数 aa 和正整数 bb最大公约数 GCD (Greatest Common Divisor) 可以通过 欧几里得算法 (Euclidean Algorithm) 计算:gcd(a,b)=gcd(b,a mod b)\gcd(a, b) = \gcd(b, a\ \text{mod}\ b)。当 gcd(a,b)=1\gcd(a,b)=1 时,我们认为 aabb 是互质 (素) 的,即它们没有共同的因子。

在模数空间中,如果存在 ab1(modn)ab \equiv 1 \pmod{n},我们可以称 bbaa模逆 (Modular Inverse)(即之前仿射密码中提到的乘法逆)当且仅当 gcd(a,n)=1\gcd(a,n)=1. 此时可以写作 b=a1modnb = a^{-1} \mod n。若 aa 在模数空间 Zn\mathbb{Z}_{n} 存在模逆 bbbb 可以通过 扩展欧几里得算法 (Extended Euclidean Algorithm, EEA) 计算得到。前面的仿射密码处我们已经给出了一个例子

欧拉函数 (Euler’s totient function) φ(m)\varphi (m) 表示 aZm={0,1,,m1}a \in \mathbb Z_m=\{0,1,\dots,m-1\} 里,有多少个数和 mm 互素,即 gcd(a,m)=1\gcd(a,m)=1. 根据我们之前在仿射密码中证明的,如果把 mm 通过质因数分解为若干个质数次方的乘积:m=i=1npieim=\prod_{i=1}^n p_i^{e_i}pip_i 表示一个质数,eie_i 表示其次数,那么有欧拉 φ\varphi 函数:

φ(m)=i=1n(pieipiei1)\varphi (m)=\prod_{i=1}^n \left (p_i^{e_i}-p_i^{e_i-1}\right)

特别地,当 m=p×qm = p \times qp,qp, q 均为质数(没有次数)时,φ(m)=(p1p0)(q1q0)=(p1)(q1)\varphi(m) = (p^1-p^0)(q^1-q^0) = (p-1)(q-1)。例如,φ(15)=φ(3×5)=(31)(51)=8\varphi(15) = \varphi(3 \times 5) = (3-1)(5-1)=8,分别是 {1,2,4,7,8,11,13,14}\{1, 2, 4, 7, 8, 11, 13, 14\}.

m1,m2,,mnm_1, m_2, \ldots, m_n 互质,即 gcd(mi,mj)=1\gcd(m_i, m_j) = 1iji \neq j. 有一个数 xx 同时满足这样的同余方程组:

xa1(modm1)xa2(modm2)xan(modmn)\begin{align*} x &\equiv a_1 \pmod{m_1} \\ x &\equiv a_2 \pmod{m_2} \\ &\vdots \\ x &\equiv a_n \pmod{m_n} \end{align*}

我们可以得到,xx 在模 M=m1×m2××mnM = m_1 \times m_2 \times \dots \times m_n 下有 唯一解xi=1naiMiki(modM)x \equiv \sum_{i=1}^n a_i \cdot M_i \cdot k_i \pmod{M}。这样的推论称为 中国剩余定理 (Chinese Remainder Theorem, CRT)

证明:对于每个 ii,定义 Mi=MmiM_i = \frac{M}{m_i}。由于 mim_i 之间互质,没有任何因子是其他模的因子,所以 mim_iMiM_i 互质,gcd(Mi,mi)=1\gcd(M_i, m_i)=1。所以存在模逆 kik_i 使得:ki×Mi1(modmi)k_i \times M_i \equiv 1 \pmod {m_i}。我们将其代入第 ii 个方程组中,构造:xai×ki×Mi(modmi)x \equiv a_i \times k_i \times M_i \pmod{m_i}。已知 xx 同时满足所有方程组的情况,所以在模 M=m1×m2××mnM = m_1 \times m_2 \times \dots \times m_n 下,xx 需要满足:xi=1naiMiki(modM)x \equiv \sum_{i=1}^n a_i \cdot M_i \cdot k_i \pmod{M}。此时,xx 在模数 MM 下有唯一解,因为 MM 是这一群互质的数的最小公倍数。

例如古籍中记载的问题:求 xx 使得 x2(mod3)x ≡ 2 \pmod{3}x3(mod5)x ≡ 3 \pmod{5}x2(mod7)x ≡ 2 \pmod{7}.

我们可以先计算其总模数 M=3×5×7=105M = 3×5×7 = 105,对每个模,分析其内部贡献,即计算:

mim_iMi=MmiM_i = \frac{M}{m_i}kiMi1(modmi)k_i \cdot M_i ≡ 1 \pmod{m_i}kik_i
33535k1(mod3)35k ≡ 1 \pmod{3}k1=351mod3k_1 = 35^{-1} \mod 3k1=2k_1=22
52121k1(mod5)21k ≡ 1 \pmod{5}k2=211mod5k_2=21^{-1} \mod 5k2=1k_2=11
71515k1(mod7)15k ≡ 1 \pmod{7}k3=151mod7k_3=15^{-1} \mod 7k3=1k_3=11

代入公式:

xi=1naiMiki(modM)=(2×35×2)+(3×21×1)+(2×15×1)(mod105)=233(mod105)23(mod105)\begin{align*} x &\equiv \sum_{i=1}^n a_i \cdot M_i \cdot k_i \pmod{M} \\ &= (2\times35\times2) + (3\times21\times1) + (2\times15\times1) \pmod{105} \\ &= 233 \pmod{105} \\ &\equiv 23 \pmod{105} \end{align*}

欧拉定理 (Euler’s Theorem) 是 RSA 算法的核心。它指出:若正整数 aa 与正整数 nn 互质,则存在 aϕ(n)1(modn)a^{\phi (n)}\equiv 1{\pmod {n}}

证明:我们知道在 Zn\mathbb{Z}_n 中,ϕ(n)\phi(n) 个数拥有其乘法逆元(模逆)。例如 ϕ(10)=4\phi (10)=4,它们在  mod10\bmod 10 的模数空间中里都有乘法逆元,比如 3×7=211(mod10)3\times 7=21\equiv 1\pmod{10},3 的逆元是 7,7 的逆元是 3。此时要求:gcd(x,n)=1\gcd (x, n)=1 时,xx 在 modn\mod n 里才是可逆的

例如在  mod10\mod 10 里,可逆余数是:{1,3,7,9}\{1,3,7,9\}。如果用 x=3x=3 去乘这些可逆余数会得到:313(mod10)3\cdot 1\equiv 3\pmod{10}, 339(mod10)3\cdot 3\equiv 9\pmod{10}, 371(mod10)3\cdot 7\equiv 1\pmod{10}, 397(mod10)3\cdot 9\equiv 7\pmod{10}. 观察这些同余结果,我们可以发现,所得的结果集 {3,9,1,7}\{3, 9, 1, 7\} 与原集合 {1,3,7,9}\{1, 3, 7, 9\} 在模 10 意义下是完全一致的,只是 元素的顺序发生了改变。这表明 在模 nn 的乘法群中,任何与 nn 互质的数 xx 与所有可逆余数相乘,其结果依然是整个可逆余数集合,只是排列不同

那么在 Zn\mathbb{Z}_n 中,和 nn 互质的余数是:{r1,r2,,rϕ(n)}\{r_1, r_2,\dots, r_{\phi (n)}\},一共有 ϕ(n)\phi(n) 个。我们把这个集合称为一个乘法群 Zn\mathbb{Z}^*_n. 因为 xxnn 互质,x1(modn)x \equiv 1 \pmod{n},所以:我们可以构造一个新的集合 {xr1,xr2,,xrϕ(n)}(modn)\{xr_1, xr_2, \dots, xr_{\phi(n)}\} \pmod{n},它们仍然是这些数的重新排列。所以两边全部相乘,应该同余:(xr1)(xr2)(xrϕ(n))r1r2rϕ(n)(modn)(xr_1)(xr_2)\cdots (xr_{\phi (n)}) \equiv r_1 r_2\cdots r_{\phi (n)} \pmod n.

左边有 ϕ(n)\phi(n)xx,所以:xϕ(n)r1r2rϕ(n)r1r2rϕ(n)(modn)x^{\phi (n)}r_1 r_2\cdots r_{\phi (n)} \equiv r_1 r_2\cdots r_{\phi (n)} \pmod n. 因为每个 rir_i 都和 nn 互质,所以它们的乘积也和 nn 互质,因此这个乘积在可以在 modn\bmod n 下消掉,得到:

xϕ(n)1(modn)x^{\phi(n)}\equiv 1\pmod n

RSA 密码系统#

RSA 的密码系统定义如下:

RSA Cryptosystem

Zn\mathbb{Z}_n 下,设 n=pqn=pq 是两个质数 ppqq 的乘积,定义密钥 K={(n,p,q,a,b):ab1(modϕ(n))}K=\{(n,p,q,a,b): ab \equiv 1 \pmod{\phi(n)}\}。对于明文和密文 x,yZnx,y \in \mathbb{Z}_n,定义:

  • 加密函数 eK(x)=xbmodne_K(x) = x^b \mod n
  • 解密函数 dK(y)=yamodnd_K(y)=y^a \mod n 此时,nnbb 组成了公钥,pp, qq, aa 组成了私钥。

RSA 生成密钥的过程如下:

419

接下来,我们将通过一个简单的例子来看看 RSA 加解密的过程。

假设 Bob 生成的密钥:p=101,q=113p=101,\quad q=113,所以 n=pq=11413n=pq=11413,计算:ϕ(n)=(51)(111)=4×10=40\phi(n)=(5-1)(11-1)=4\times 10=40

如果他选定 b=3b=3gcd(3,40)=1\gcd(3,40)=1。那么 aa 需要满足:3a1(mod40)3a\equiv 1\pmod{40},通过拓展欧几里得算法,将其转换为余数表达式:1=4013×3    13×31(mod40)1 = 40-13 \times 3 \implies -13 \times 3 \equiv 1 \pmod{40}1327(mod40)-13 \equiv 27 \pmod{40} 可以算出 a=27a = 27. 所以得到了:

  • 公钥:(n,b)=(55,3)(n, b)=(55,3)
  • 私钥:(p,q,a)=(5,11,27)(p,q,a)=(5,11,27)

Alice 将根据密钥进行加密,假设密文 x=12x=12, 加密后:y=xbmodn=123mod55    y=23y=x^b\bmod n=12^3\bmod 55 \implies y = 23,Alice 将向 Bob 发送这个密文。

Bob 用私钥指数 aa 进行解密:x=yamodn=2327mod55x=y^a\bmod n=23^{27}\bmod 55,应用计算机计算可以得到最终值 x=12x=12.

我们来验证 RSA 的加密和解密过程是可逆的。在一个乘法群 Zn\mathbb{Z}^*_n 中,如果 xx 和 nn 互质,根据欧拉定理,我们已知 ϕ(n)=(p1)(q1)\phi (n)=(p-1)(q-1)xϕ(n)1(modn)x^{\phi(n)}\equiv 1\pmod n.

因为 ab1(modφ(n))ab \equiv 1 \pmod{\varphi(n)},所以存在某个 t1Znt \ge 1 \in \mathbb{Z}_n, 使得 ab=tφ(n)+1ab = t\varphi(n)+1.

设密文 y=eK(x)=xbmodny = e_K(x) = x^b \mod n,当我们将密文解密时:dK(y)=(xb)amodn=xabmodnd_K(y) = (x^b)^a \mod n = x^{ab} \mod n.

abab 代入 dK(y)d_K(y) 中得到:

xabxtφ(n)+1(modn)(xφ(n))t×x(modn)1t×x(modn)x(modn)\begin{align*} x^{ab} &\equiv x^{t \varphi(n)+1} \pmod{n} \\ &\equiv (x^{\varphi(n)})^{t} \times x \pmod{n} \\ &\equiv 1^t \times x \pmod{n} \\ &\equiv x \pmod{n} \end{align*}

xx 解密成功。

我们发现,在 RSA 过程中最难算的就是幂的模数了,即 xbmodnx^b \bmod nyamodny^a \bmod n,因为 RSA 中取的密钥值通常都非常大。在计算机里一般使用 Square and Multiply 算法去快速计算这样幂的模。

Square and Multiply Algorithm

设正整数 zz, xx, cc, nn,要计算 z=xcmodnz=x^c\bmod n,则应用如下的算法过程:

  1. cc 转换为二进制的形式:c=i=01ci2ic=\sum_{i=0}^{\ell-1}c_i2^i, ci{0,1}c_i\in\{0,1\}. \ell 表示二进制的位数(从 0 开始的)。
  2. 初始化 z=1z = 1, 然后从最高位到最低位处理指数的二进制位:i=1,2,,0i=\ell-1,\ell-2,\dots,0. 每次处理做如下两件事:
    1. 平方 (Square):首先计算 z2modnz^2 \bmod n,并将其赋值给 zzzz2modnz \leftarrow z^2 \bmod n.
    2. 相乘 (Multiply):如果当前二进制位 ci=1c_i=1,将 zzxx 相乘,否则什么都不做:zzxmodn , when ci=1, else zz\leftarrow z\cdot x\bmod n\ \text{, when } c_i=1 \text{, else } z.
SQUARE-AND-MULTIPLY(x, c, n)
z ← 1
for i ← ℓ - 1 downto 0 do
z ← z^2 mod n
if c_i = 1 then
z ← (z × x) mod n
return z

这个算法的时间复杂度是 O(log(n))O(\log(n)),这个算法的正确性证明这里省略,有兴趣可以自行去查看。接下来我们使用之前的例子来跑一遍这个算法的过程:要求 z=2327mod55z = 23^{27} \bmod 55

  1. 先将幂转换为二进制:27=(11011)227 = (11011)_2.
  2. 初始化 z=1z=1, 应用算法进入循环:
    1. 第一轮:因为 c4=1c_4=1zz 平方后相乘得到:z=23mod55=23z = 23 \bmod 55 = 23.
    2. 第二轮:因为 c3=1c_3=1zz 平方后相乘得到:232mod55=3423 ^ 2 \bmod 55 = 34, z=34×23mod55=12z=34 \times 23 \bmod 55 = 12.
    3. 第三轮:因为 c2=0c_2=0zz 只平方:z=122mod55=34z = 12^2 \bmod 55 = 34.
    4. 第四轮:因为 c1=1c_1=1zz 平方后相乘得到:342mod55=134^2 \bmod 55 = 1, z=23mod55=23z=23 \bmod 55 =23.
    5. 第五轮:因为 c0=1c_0=1zz 平方后相乘得到:232mod55=3423^2 \bmod 55 = 34, z=34×23mod55=12z=34 \times 23 \bmod 55 = 12.

经过这个算法,最后可以算出 z=12z = 12.

离散对数#

离散对数数学基础#

我们前面学习的 RSA 的精髓在于“把两个质数乘起来容易,拆开极难”,在接下来的一章中将介绍另一个著名的数学陷阱:离散对数问题 (Discrete Logarithm Problem, DLP)

离散对数难题 建立在有限循环群 Zn\mathbb{Z}^*_n 的基础之上,这个群内乘法运算和幂运算在模 nn 的意义下执行,且群的阶 (元素个数) 是有限的。

在循环群 Zp\mathbb{Z}^*_p 中,我们选一个数 α\alpha,不断计算它的幂:α1,α2,α3,,αa(modp)\alpha^1, \alpha^2, \alpha^3, \dots, \alpha^a \pmod p. 此时称 α\alpha 是一个 生成元 (generator)。因为循环群的性质,α\alpha 的幂可以生成模 pp 下的所有非零元素:βαa(modp)\beta \equiv \alpha^a \pmod p, (0a<p10≤a<p−1) .

这个 aa 称为 α\alpha 为底, β\beta 的离散对数。它一点也不连续,值在模 p1p-1 的范围内乱跳,所以叫离散对数。如果我们知道了 α,p,β\alpha, p, \beta,要想反推出 aaa=logαβ(modp)a = \log_\alpha \beta \pmod ppp 很大时非常困难。

离散对数问题的这种单向性是许多现代密码体制的安全基石。例如,ElGamal 密码系统。

ElGamal 密码系统#

ElGamal 密码系统 是一个建立在有限域上离散对数问题的困难性之上的非对称加密算法。RSA 每次使用同一公钥加密同一明文计算结果都一样,黑客即便解不开密文,但如果他看到你连续三天发送了完全相同的密文,他就能猜到你下达了相同的指令。ElGamal 引入 随机性 (Randomized Encryption),具有概率加密的特性,这意味着 相同的明文在不同时刻加密会产生不同的密文,从而能够更有效地抵御选择明文攻击

ElGamal 密码系统定义如下:

ElGamal Cryptosystem

pp 是一个足够大的质数,选定一个生成元 αZp\alpha \in \mathbb{Z}_{p}^*,在非零元素循环群 Zp={1,2,,p1}\mathbb{Z}_p^* = \{1,2,\dots,p-1\} 中,定义一个密钥:K={(p,α,a,β):βαa(modp)}K= \{(p,\alpha,a,\beta): \beta \equiv \alpha^a \pmod{p}\}。对 K=(p,α,a,β)K=(p,\alpha,a,\beta),选定一个随机数 kZp1k \in \mathbb{Z}_{p-1}^*, 对于明文 xx 和密文 (y1,y2)Zp(y_1,y_2) \in \mathbb{Z}_{p}^*,定义:

  • 加密函数:eK(x,k)=(y1,y2)e_K(x, k) = (y_1,y_2), 其中 y1=αkmodpy_1 = \alpha^k \bmod p, y2=xβkmodpy_2=x \beta^k \bmod p.
  • 解密函数:dK(y1,y2)=y2(y1a)1modpd_K(y_1,y_2)=y_2(y_1^a)^{-1} \bmod p.

其中,α\alpha, β\beta, pp 组成公钥,aa 则是私钥,kk 是每次随机生成的,不会被传递。

接下来一步步代入这个过程:

  1. 首先选择一个大质数 pp,并选择一个 α\alpha 作为模 pp 下的一个生成元,构建出循环群 Zp={1,2,,p1}\mathbb{Z}_p^* = \{1,2,\dots,p-1\}
  2. Bob 选择一个私钥:a (1a<p1)a\ (1 \leq a \lt p-1),然后计算公钥 β\betaβαa(modp)\beta \equiv \alpha^a \pmod p。根据离散对数问题的性质,别人知道 ββ,但很难从 ββ 反推出 aa。于是得到:公钥:(p,α,β)(p, \alpha, \beta),私钥:aa
  3. Alice 想加密消息 xZpx \in \mathbb{Z}_{p}^*,他将随机选择一个临时随机数 kk,然后计算:y1αk(modp)y_1 \equiv \alpha^k \pmod p, y2xβk(modp)y_2 \equiv x \cdot \beta^k \pmod p,得到一组密文: (y1,y2)(y_1, y_2)。这里的 y1y_1 类似 提示纸条,而 y2y_2 则是真正加密的内容。
  4. Bob 收到密文,他用自己的私钥 aa 计算:y1a=(αk)a=αkay_1^a = (\alpha^k)^a = \alpha^{ka}, 在之前我们计算了一个公钥 β=αa\beta = \alpha^a,根据乘法交换律替换:αka=αak=(αa)k=βk\alpha^{ka} = \alpha^{ak} = (\alpha^a)^k = \beta^k,我们就解出了真正加密内容 y2y_2 中的重要参数 βk=αa=y1a\beta^k = \alpha^a = y_1^a,而不需要知道 kk 的值。最后,只需要继续计算逆元 (y1a)1(y_1^a)^{-1} 乘回 y2y_2 中,即可计算出明文 xxxy2(βk)1=y2(y1a)1(modp)x \equiv y_2 \cdot (\beta^k)^{-1} = y_2 \cdot (y_1^a)^{-1} \pmod p

下面是一个代入真实数据的例子,为了演示方便,这里选择较小的数据:

p=23p=23, α=5\alpha = 5,在 Z23\mathbb{Z}_{23}^* 中,选择私钥 a=6a = 6。计算公钥中的 β\betaβ=αa(modp)=56(mod23)    β=8\beta = \alpha^a \pmod p = 5^6 \pmod {23} \implies \beta = 8,这样我们得到了公钥和私钥:

  • 公钥:(p,α,β)=(23,5,8)(p,\alpha,\beta) = (23,5,8)
  • 私钥:a=6a = 6

Alice 想加密消息:x=13x = 13,Bob 随机选择:k=15k=15,计算:

  • 提示纸条:y1=αk(modp)=515(mod23)    y1=19y_1 = \alpha^k \pmod p = 5^{15} \pmod {23} \implies y_1 = 19.
  • 加密内容:y2=xβk(modp)=13×815(mod23)    y2=26(mod23)=3y_2 = x \cdot \beta^k \pmod p = 13 \times 8^{15} \pmod {23} \implies y_2 = 26 \pmod {23} = 3.

得到密文:(y1,y2)=(19,3)(y_1,y_2) = (19,3).

Bob 解密,她计算 y1a=196(mod23)    y1a=2y_1^a = 19^6 \pmod {23} \implies y_1^a = 2,根据之前的推理,βk=y1a=2\beta^k = y_1^a = 2. 所以代入解密函数中:x=y2(y1a)1(mod23)    x=321(mod23)x = y_2 \cdot (y_1^a)^{-1} \pmod {23} \implies x = 3 \cdot 2^{-1} \pmod {23}。根据拓展欧几里得算法,可以计算出在模 232322 的逆元 21=122^{-1}= 12。代入可得:x=36(mod23)=13x = 36 \pmod {23} = 13

在攻击者的视角下,它们只知道公钥 (p,α,β)(p,\alpha,\beta),而无法得到提示纸条中的遮罩 βk\beta^k,也就无法把 y2y_2 还原成 xx

有限域#

在最开始的数学基础知识中,我们已经介绍过了群、环、域的基本概念,在这里我们主要来讲讲 有限域 (Finite Fields),又称 伽罗瓦域 (Galoisfield)。有限域是指包含有限个元素的域,通常记作 GF(q)GF(q),其中 qq 必须是某个质数 ppnn 次幂 q=pn, n1q =p^n,\ n \ge 1

回顾一下域的概念,简单来说:域是一个集合,在这个集合里,可以做加、减、乘、除,而且 运算结果还留在这个集合里。例如:Z5={0,1,2,3,4}\mathbb{Z}_5 = \{0,1,2,3,4\} 是一个域,在模 55 下因为 55 是质数,φ(5)=4\varphi(5) = 4。除 00 外,所有的其他元素都与 55 互质,它们都存在模逆(就是所谓的除法)。

根据欧拉函数的性质来看,Zp\mathbb{Z}_p  是域,当且仅当 pp 是素数。那有限域的大小只能是这些素数组成的空间,例如 2,3,5,7,11,13,2,3,5,7,11,13,\dots。但是密码学里经常需要大小为:28, 2128, 22562^8,\ 2^{128},\ 2^{256} 这样的空间,该怎么做呢?我们一般使用 多项式环 Zp[x]\mathbb{Z}_p[x] 模一个不可约的多项式 f(x)f(x) 来构造有限域

Zp[x]\mathbb{Z}_p[x] 表示 系数来自 Zp\mathbb{Z}_p 的所有多项式。例如 Z2[x]\mathbb{Z}_2[x] 中,系数只能是 0 或 1。考虑变量 xx 的多项式,比如:x3+x+1,x2+1,1x^3 + x + 1, \quad x^2 + 1, \quad 1,它们的系数全是 0 或 1。

以前我们学过整数模运算,例如:172(mod5)    17=35+217 \equiv 2 \pmod 5 \implies 17 = 3\cdot 5 + 2,余数是 2。现在多项式也可以做类似的事,例如 f(x)=x3+x+1f(x)=x^3+x+1,所有多项式都可以除以 f(x)f(x),得到一个余数:Z2[x]/(x3+x+1)\mathbb{Z}_2[x]/(x^3+x+1)

因为 f(x)f(x) 的次数是 3,所以余数的次数一定小于 3。也就是说余数形式为:a2x2+a1x+a0, a2,a1,a0{0,1}a_2 x^2+a_1 x+a_0,\ a_2,a_1,a_0\in \{0,1\},一共有 23=82^3=8 种不同的多项式组合。这样就 构建了一个大小为 8 的有限域

所以我们可以正式定义:Zp[x]/(f(x))\mathbb{Z}_p[x]/(f(x)) 当且仅当 f(x)f(x)不可约多项式 (irreducible) 时,它的余数可以构成一个有限域。不可约多项式 就是多项式世界里的质数:它次数 1≥1,不能分解成两个更低次数的多项式的乘积(系数仍取自 GF(2)GF (2))。例如 x3+1x^3+1 我们可以将其进行多项式分解:x3+1=(x+1)(x2+x+1)x^3+1 = (x+1)(x^2+x+1),它变成了两个更低次数的多项式的乘积,这个多项式不是不可约多项式。

到这里可能有些抽象了,我们对比域在整数空间和多项式空间的定义清晰了:

整数世界多项式世界
mmf(x)f(x)
mm 是素数f(x)f(x) 是不可约多项式
Zm\mathbb{Z}_m 是域Zp[x]/(f(x))\mathbb{Z}_p[x]/(f(x)) 是域

接下来我们通过一个例子来看构造有限域的过程。

我们的目标是:构造一个有 8 个元素的有限域。因为 8 不是素数,所以不能直接用 Z8\mathbb{Z}_8, 它不是一个域。所以我们可以借助多项式构造一个域:F23=F8\mathbb{F}_{2^3}=\mathbb{F}_8

一种通常的做法是:在 Z2[x]\mathbb{Z}_2[x] 中找一个次数为 3 的不可约多项式 f(x)f(x) 来构造 F8=Z2[x]/(f(x))\mathbb{F}_8 = \mathbb{Z}_2[x]/(f (x))。因为系数只能是 0 或 1,所以三次多项式大概长这样:x3+ax2+bx+cx^3 + ax^2 + bx + c, a,b,c{0,1}a, b, c \in \{0,1\}

如果常数项 c=0c=0,那么多项式一定可以被 xx 整除。(此时所有的项都包含 xx,所以均可约)。我们只需考虑具有常数项为 1 的多项式。我们通过二进制来看,用 {0,1}\{0,1\} 分别表示次数为 2, 1, 0 时的系数,有这四种情况:001, 011, 101, 111,它们分别对应下面四个式子:

  • 001f1(x)=x3+1f_1 (x)=x^3+1
  • 011f2(x)=x3+x+1f_2(x)=x^3+x+1
  • 101f3(x)=x3+x2+1f_3(x)=x^3+x^2+1
  • 111f4(x)=x3+x2+x+1f_4(x)=x^3+x^2+x+1

Z2[x]\mathbb{Z}_2[x] 中判断它们是否可约是非常简单的,因为如果 f(x)f(x) 可约,它一定能分解成更低次数的多项式乘积。对于一个 3 次多项式,它要么分解成 一次 × 二次,要么 一次 × 一次 × 一次。无论如何,至少都有一个一次因子。所有可能的一次多项式只有两个:01: xx11 x+1x+1. 所以我们只需要检查 x=0x=0x=1x=1 是不是这个多项式的根即可。如果 f(0)=0f(0) = 0,说明 xx 是因子;如果 f(1)=0f(1)=0 ,因为 1+1=01+1=0 所以 x+1x+1 是因子。

  • 如果 x=0x=0, f1(x)=0+1=1, f2(x)=f3(x)=1, f4(x)=1f_1(x)=0+1=1,\ f_2(x) = f_3(x)=1,\ f_4(x)=1. 没找到 xx 为因子。
  • 如果 x=1x=1, f1(x)=1+1=0, f2(x)=f3(x)=1, f4(x)=0f_1(x)=1+1=0,\ f_2(x) = f_3(x)=1,\ f_4(x)=0. 发现 f1(x)f_1(x)f4(x)f_4(x) 具有因子 x+1x+1,所以它们是可约的。

经过验证,其中 f1(x)f_1(x)f4(x)f_4(x) 是可约的:x3+1=(x+1)(x2+x+1)x^3+1=(x+1)(x^2+x+1)x3+x2+x+1=(x+1)(x2+1)x^3+x^2+x+1=(x+1)(x^2+1).

因此,f2(x)f_2(x)f3(x)f_3(x) 就是我们要找的不可约多项式。

通过选择其中一个不可约多项式(如 x3+x+1x^3+x+1),我们就可以定义出 F8\mathbb{F}_8 中的加法和乘法规则。我们模的是三次多项式,每个元素都可以表示成次数小于 3 的多项式:a2x2+a1x+a0a_2x^2+a_1x+a_0, a2,a1,a0{0,1}a_2,a_1,a_0\in \{0,1\}。通过二进制我们可以构造出有限域里的 8 个元素:

  • 000 \rightarrow 00
  • 001 \rightarrow 11
  • 010 \rightarrow xx
  • 011 \rightarrow x+1x + 1
  • 100 \rightarrow x2x^2
  • 101 \rightarrow x2+1x^2 + 1
  • 110 \rightarrow x2+xx^2 + x
  • 111 \rightarrow x2+x+1x^2 + x + 1

在这个域中,我们计算加法时,可以使用二进制逐位计算得到。例如:(x2+x+1)+(x2+1)(x^2+x+1)+(x^2+1),它们表示 111+101111+101,逐位加相当于做 异或计算,得到:010010,所以多项式加法的结果是:xx

在计算乘法的时候,我们可以先像普通多项式一样相乘,然后用 x3+x+1x^3+x+1 做模约化。例如:计算 (x2+1)×(x2+x+1)(x^2 + 1) \times (x^2 + x + 1)

对应二进制就是 101 乘以 111。我们将其像普通多项式相乘:(x2+1)(x2+x+1)=x4+x3+x2+x2+x+1(x^2 + 1)(x^2 + x + 1)=x^4 + x^3 + x^2 + x^2 + x + 1。因为:x2+x2=100+100=0x^2+x^2=100 + 100 = 0,所以 =x4+x3+x+1=x^4+x^3+x+1

这个式子现在要模:x3+x+1x^3+x+1,这意味着:x3+x+10x^3+x+1 \equiv 0 (自己模自己为 0),移项得到:x3x1x^3 \equiv -x -1,但是对于 Z2[x]\mathbb{Z}_2[x] 中,1=+1-1 = +1 减法和加法一样。所以可以得到一个化简规则:x3=x+1x^3 = x+1

回到上面的相乘式,我们用 x3=x+1x^3 = x+1 来取代高次项:x4=xx3=x(x+1)=x2+x=110x^4=x\cdot x^3=x(x+1)=x^2+x=110,所以原式变成:=(x2+x)+(x+1)+x+1=x2+x=(x^2+x) + (x+1) + x+1 = x^2+x.

我们把化简规则:x3=x+1x^3 = x+1 带到高次项中,可以计算得到如下:

  • x1=xx^1=x
  • x2=x2x^2=x^2
  • x3=x+1x^3=x+1
  • x4=x2+xx^4=x^2+x
  • x5=x2+x+1x^5=x^2+x+1
  • x6=x2+1x^6=x^2+1
  • x7=(x+1)+x=1x^7=(x+1)+x=1

通过这个序列我们可以看到,x1x^1x7x^7 的计算结果恰好涵盖了有限域中所有的结果。

在这种构造下,域中的元素既可以表示为系数组成的多项式,也可以对应为二进制位串,这使得有限域运算在计算机硬件和软件中能够以极高的效率实现。

在密码学中,有限域为复杂的代数运算提供了封闭且稳定的数学结构,是实现 AES、ECC 等现代加密算法的核心基础。理解有限域的性质,有助于我们进一步探究非对称加密中更高效的构造方式。

椭圆曲线#

椭圆曲线 (Elliptic Curve) 在实数中是一个类似 Ω\Omega 或水滴状的曲线,它的方程形如:y2=x3+ax+by^2 = x^3 + ax + b.

325

但是在密码学里,我们通常不在实数里工作,而是在模素数 pp 的有限世界里工作。也就是 y2x3+ax+b(modp)y^2 \equiv x^3 + ax + b \pmod p, x,y{0,1,2,,p1}x,y \in \{0,1,2,\dots,p-1\}

在这种定义下,原本平滑连续的曲线会变成由一系列离散点 (x,y)Zp×Zp(x, y) \in \mathbb{Z}_p \times \mathbb{Z}_p 组成的集合,再加上一个特殊的无穷远点 (point at infinity) O\mathcal{O}。它们构成了一个椭圆曲线群。这个 O\mathcal{O} 作为群的 单位元(就像加法里的 0)。

这个椭圆曲线的参数 a,bZpa, b \in \mathbb{Z}_p 是满足 4a3+27b204 a^3 + 27 b^2 \neq 0 的常量,用于保证曲线没有尖点或自交叉。

在椭圆曲线 ε\varepsilon 上,我们可以定义一种特殊的“加法”运算。所有运算都在模 pp 下进行。如果有两个点 P=(x1,y1)P=(x_1, y_1), Q=(x2,y2)Q=(x_2,y_2),规定:P+Q=(x3,y3)P+Q=(x_3,y_3)

x1=x2x_1=x_2,且 y1=y2y_1 = -y_2,则 P+Q=OP+Q = \mathcal{O}(无穷远点)。

x1x2x_1 \ne x_2,则加法的结果是:x3=λ2x1x2x_3=\lambda^2-x_1-x_2, y3=λ(x1x3)y1y_3=\lambda(x_1-x_3)-y_1。对于斜率 λ\lambda,有两种情况:

  • 如果 PQP\neq Qλ=(y2y1)(x2x1)\lambda=\frac{(y_2-y_1)}{(x_2-x_1)}. 这是 PPQQ 两点之间的直线的斜率。
  • 如果 P=QP=Qλ=(3x12+a)(2y1)\lambda=\frac{(3x_1^2+a)}{(2y_1)}. 这是一条与椭圆曲线 ε\varepsilon 切于 PP 点的直线的斜率。

且定义单位元相加:P+O=O+P=PP+\mathcal{O}=\mathcal{O}+P=P.

我们来看一个例子:

E:y2=x3+x+6E: y^2=x^3+x+6Z11\mathbb{Z}_{11} 上的椭圆曲线,它的点 P(x,y)P(x,y) 满足 y2x3+x+6(mod11)y^2 \equiv x^3+x+6 \pmod {11}x,yZ11={0,1,2,,10}x,y \in \mathbb{Z}_{11} = \{0,1,2,\dots,10\}. 这个曲线在这个群里是一堆离散点。

在这个椭圆曲线中有哪些点呢?找点的方法就是 xZ11={0,1,2,,10}x \in \mathbb{Z}_{11} = \{0,1,2,\dots,10\} 一个个代入曲线中,看看算出来的结果是不是一个完全平方数,我们称为二次剩余 (quadratic residue)

我们先列出模 11 下所有平方值 zz

  • 0200^2\equiv 0
  • 1211^2\equiv 1
  • 2242^2\equiv 4
  • 3293^2\equiv 9
  • 421654^2\equiv 16\equiv 5
  • 522535^2\equiv 25\equiv 3
  • 623636^2\equiv 36\equiv 3
  • 724957^2\equiv 49\equiv 5
  • 826498^2\equiv 64\equiv 9
  • 928149^2\equiv 81\equiv 4
  • 102100110^2\equiv 100\equiv 1

接下来我们将 xx 的各个取值代入方程 y2x3+x+6(mod11)y^2 \equiv x^3+x+6 \pmod {11},然后判断是否 y2z(mod11)y^2\equiv z \pmod {11}

例如:

  1. x=2x = 2,代入后得到:y=23+2+6=8+2+6=165(mod11)y=2^3 + 2 + 6 = 8 + 2 + 6 = 16 \equiv 5 \pmod {11}。匹配后发现有二次剩余 y=4y=4, y=7y=7 ,所以得到两个点:(2,4)(2, 4)(2,7)(2, 7)
  2. x=4x=4, 代入后得到:y=43+4+6=64+4+6=748(mod11)y=4^3+4+6=64+4+6=74 \equiv 8 \pmod{11}。匹配后发现没有二次剩余,所有没有点。

所有的计算结果如下图:

433

一共有 12 个普通点和 1 个无穷远点 O\mathcal{O}。一共 13 个点,13 是素数。在群论中,如果一个有限群的阶是素数,那么这个群一定是循环群。

所以这个椭圆曲线最神奇的地方,是你可以把两个点 PPQQ 相加,得到第三个点 RR(而且 RR 必定也在这条曲线上)。设一个生成元 α=(2,7)\alpha = (2, 7),我们来尝试计算 2α=α+α2\alpha=\alpha+\alpha

2α=(2,7)+(2,7)2\alpha=(2,7)+(2,7),因为此时 P=QP=Q,需要使用斜率公式 λ=(3x12+a)(2y1)1\lambda=(3x_1^2+a)(2y_1)^{-1},代入 x1=2,y1=7,a=1x_1=2,\quad y_1=7,\quad a=1 得到:

λ=(322+1)(27)1(mod11)    λ=231(mod11)\lambda=(3\cdot 2^2+1)(2\cdot 7)^{-1}\pmod {11} \implies \lambda=2\cdot 3^{-1}\pmod {11},使用拓展欧几里得算法可以得到:314(mod11)3^{-1}\equiv 4 \pmod {11},所以 λ=24=8\lambda=2\cdot 4=8

代入计算 x3=λ2x1x2=605(mod11)x_3=\lambda^2-x_1-x_2=60 \equiv 5 \pmod{11}, y3=λ(x1x3)y1=312(mod11)y_3=\lambda(x_1-x_3)-y_1=-31 \equiv 2 \pmod{11}.

所以:2α=(5,2)2\alpha=(5,2). 它也在曲线上。

同理我们计算 3α=2α+α    3α=(5,2)+(2,7)3\alpha=2\alpha+\alpha \implies 3\alpha=(5,2)+(2,7). 因为 PQP \ne Q,所以 λ=(y2y1)(x2x1)1\lambda=(y_2-y_1)(x_2-x_1)^{-1}, 代入得到:λ=(72)(25)1=5(3)1(mod11)\lambda=(7-2)(2-5)^{-1}=5\cdot (-3)^{-1} \pmod {11}.

同样使用拓展欧几里得算法,38(mod11)-3\equiv 8 \pmod {11},所以 λ=581(mod11)\lambda=5\cdot 8^{-1}\pmod {11},同理计算出 81=78^{-1}=7λ=57=352(mod11)\lambda=5\cdot 7=35\equiv 2 \pmod {11}

代入 x3x_3 中:x3=2252=47=38(mod11)x_3=2^2-5-2=4-7=-3 \equiv 8 \pmod{11}, y3=2(58)2=83(mod11)y_3=2(5-8)-2=-8 \equiv 3 \pmod{11}. 所以 y3=2(58)2y_3=2(5-8)-2,它同样在曲线上。

在椭圆曲线的密码系统 (ECC)中,我们将离散对数 αa=β\alpha^a=\beta 替换为 aα=βa\alpha=\beta 代替进行加密。

签名方案#

我们前面学到了很多不同的加密方法,它们都是将明文加密,从而确保信息的机密性。然而,在实际通信过程中,验证发送者的身份以及确保消息在传输过程中未被篡改同样至关重要。

Hash 函数是给数据生成一个指纹,它只回答了内容有没有修改。我们还想知道并验证发送者的真实身份,数字签名方案正是为此设计的,它利用 非对称加密 技术,让发送方使用私钥对消息进行签名,而接收方通过对应的公钥来验证签名的有效性和完整性。

数字签名在本质上就是 Hash + 非对称加密

RSA 签名方案#

RSA 签名方案是一种基于 RSA 密码系统的数字签名方法,它的过程几乎与 RSA 加密一样。

Zn\mathbb{Z}_n 下,设 n=pqn=pq 是两个质数 ppqq 的乘积,定义密钥 K={(n,p,q,a,b):ab1(modϕ(n))}K=\{(n,p,q,a,b): ab \equiv 1 \pmod{\phi(n)}\}。对于明文和密文 x,yZnx,y \in \mathbb{Z}_n,定义:

  • 签名函数 sigK(x)=xamodn\text{sig}_K(x)=x^a \bmod n
  • 验证函数 verK(x,y)=true    xyb(modn)\text{ver}_K(x,y)=\text{true} \iff x\equiv y^b \pmod n 此时,nnbb 组成了公钥,pp, qq, aa 组成了私钥。

也就是说对于消息 xx,Alice 生成签名:y=xamodny=x^a \bmod n;验证者检查:ybmodny^b \bmod n 是否等于原消息 xx。如果相等,签名有效;否则无效。

在这个 RSA 签名方案中,签名使用 RSA 的“解密规则”,验证使用 RSA 的“加密规则”

接下来通过一个例子来看懂流程:

假设 Alice 选择质数 p=5,q=11p=5,\quad q=11,则 n=pq=55n=pq=55ϕ(n)=(p1)(q1)=4×10=40\phi (n)=(p-1)(q-1)=4\times 10=40. 选择公钥指数:b=3b=3,然后找私钥指数 aa,使得:ab1(mod40)ab\equiv 1\pmod{40},所以 a=27a=27.

  • 公钥:(n,b)=(55,3)(n,b)=(55,3)
  • 私钥:(p,q,a)=(5,11,27)(p,q,a)=(5,11,27)

现在 Alice 要签名消息:x=13x=13,代入签名函数:y=xamodn=1327mod55    y=7y=x^a\bmod n=13^{27}\bmod 55 \implies y=7;

所以 Alice 发给 Bob:(x,y)=(13,7)(x,y)=(13,7).

Bob 将使用验证函数及公钥进行验证:ybmodn=7313mod55y^b \bmod n = 7^3 \equiv 13 \bmod 55,结果正好等于原消息 x=13x=13,所以验证通过。

如果攻击者想要伪造 Alice 对某条消息 xx 的签名。他没有私钥,很难从 xx 反推出 yy。但它是不安全的,因为黑客可以利用数学进行一种名为 “存在性伪造” (Existential Forgery) 的攻击。因为验证时会检查:ybx(modn)y^b\equiv x\pmod n,攻击者可以随意选取一个 yZny\in \mathbb{Z}_n,计算:x=ybmodnx=y^b\bmod n,得到一个合法的 (x,y)(x,y),因为数学上正确。

为了解决这种安全性问题,在实际应用中,RSA 签名通常不会直接对原始消息进行操作,而是先对消息计算 Hash 值。通过对 H(x)H(x) 进行签名,攻击者由于无法控制 Hash 函数的输出结果,便难以通过随机选取 yy 来反推一个有意义的消息 xx,从而有效地抵御了存在性伪造攻击。

对比 RSA 加密和签名,区别如下:

项目RSA 加密RSA 签名
目标保密 confidentiality认证与完整性 authenticity + integrity
谁使用公钥发送者用接收者公钥加密验证者用签名者公钥验证
谁使用私钥接收者用私钥解密签名者用私钥签名
数学操作eK=xbmodne_K=x^b\bmod ny=xamodny=x^a\bmod n
反向操作dK=camodnd_K=c^a\bmod n检查 xybmodnx\equiv y^b\bmod n
核心含义只有私钥持有者能读只有私钥持有者能签

ElGamal 签名方案#

ElGamal 签名是基于离散对数困难问题的签名。它的签名过程也和 ElGamal 密码系统类似。

pp 是一个足够大的质数,选定一个生成元 αZp\alpha \in \mathbb{Z}_{p}^*,在非零元素循环群 Zp={1,2,,p1}\mathbb{Z}_p^* = \{1,2,\dots,p-1\} 中,定义一个密钥:K={(p,α,a,β):βαa(modp)}K= \{(p,\alpha,a,\beta): \beta \equiv \alpha^a \pmod{p}\}。对 K=(p,α,a,β)K=(p,\alpha,a,\beta),选定一个随机数 kZp1k \in \mathbb{Z}_{p-1}^*, kk 必须和 p1p-1 互素 gcd(k,p1)=1\gcd(k,p-1)=1,保证它有逆元。定义:

  • 签名函数:sigK(x,k)=(γ,δ)\text{sig}_K(x,k)=(\gamma,\delta),它实际上是构造了一个指数方程:xaγ+kδ(modp1)x \equiv a\gamma + k\delta \pmod{p-1}。其中 γ=αkmodp\gamma=\alpha^k\bmod p 表示一个随机的印章,δ=(xaγ)k1mod(p1)\delta=(x-a\gamma)k^{-1}\bmod(p-1) 表示信息真正的签名。
  • 检验函数:只需要检查 βγγδαx(modp)\beta^\gamma \gamma^\delta \equiv \alpha^x \pmod p. 如果成立,就接受签名;否则拒绝。

其中,α\alpha, β\beta, pp 组成公钥,aa 则是私钥,kk 是每次随机生成的,不会被传递。

在验证时:Bob 不知道 aa 也不知道 kk,他可以把整个方程放到以 α\alpha 为底数的指数上去看 αxαaγ+kδ=(αa)γ×(αk)δ(modp)\alpha^x \equiv \alpha^{a\gamma + k\delta}= (\alpha^a)^\gamma \times (\alpha^k)^\delta \pmod p

此时:

  • αa\alpha^a 就是 Alice 的公钥 β\beta
  • αk\alpha^k 就是签名里带着的 γ\gamma

只需要计算:βγ×γδmodp\beta^\gamma \times \gamma^\delta \bmod p 如果它等于 αxmodp\alpha^x \bmod p,就说明签名正确。

我们发现这个过程中,γ=αkmodp\gamma=\alpha^k\bmod p 模数是 pp,但是 δ=(xaγ)k1mod(p1)\delta=(x-a\gamma)k^{-1}\bmod(p-1) 模数是 p1p-1. 因为 Zp\mathbb{Z}_p^*  的大小是 p1p-1,而 α\alpha 的阶也是 p1p-1, 所以指数只需要在模 p1p-1 下相等即可。

  • 底数运算在模 pp 下做
  • 指数关系在模 p1p−1 下做

我们同样通过一个例子来看这个过程:

p=467,α=2,a=127p=467,\quad \alpha=2,\quad a=127,则有:

  • Alice 的私钥:a=127a = 127
  • Alice 的公钥的一部分:β=2127mod467=132\beta = 2^{127} \bmod 467 = 132(p,α,β)=(467,2,132)(p,\alpha,\beta)=(467,2,132)

现在 Alice 要对消息 x=100x = 100 签名。她随机选 k=213k = 213。(gcd(213,466)=1\gcd(213, 466) = 1)。所以 kk 在模 466466 下有逆元,并且:2131431(mod466)213^{-1}\equiv 431\pmod{466}

  1. 首先我们计算 γ\gammaγ=αkmodp=2213mod467    γ=29\gamma=\alpha^k\bmod p =2^{213}\bmod 467 \implies \gamma=29.
  2. 接着计算 δ\deltaδ=(xaγ)k1mod(p1)=3583×431mod466    δ=51\delta=(x-a\gamma)k^{-1}\bmod(p-1) = -3583\times 431\bmod 466 \implies \delta=51.
  3. 因此 Alice 的签名是 (29,51)(29,51).
  4. 验证者知道:p=467,α=2,β=132p=467,\quad \alpha=2,\quad \beta=132,收到 x=100,(γ,δ)=(29,51)x=100,\quad (\gamma,\delta)=(29,51). 代入验证函数:βγγδαx(modp)    132292951189(mod467)\beta^\gamma\gamma^\delta\equiv \alpha^x\pmod p \implies 132^{29}29^{51}\equiv 189\pmod{467}
  5. 同时,2100189(mod467)2^{100}\equiv 189\pmod{467}。左右两边相等,签名验证通过。

比较 RSA 签名和 ElGamal 签名方案:

项目RSA SignatureElGamal Signature
基础困难问题大整数分解离散对数
签名是否随机通常基础形式不随机随机
签名形式一个数 yy两个数 (γ,δ)(\gamma,\delta)
私钥RSA 私钥指数aa
公钥(n,b)(n, b)(p,α,β)(p,\alpha,\beta)
核心验证ybx(modn)y^b\equiv x\pmod nβγγδαx(modp)\beta^\gamma\gamma^\delta\equiv \alpha^x\pmod p
数学核心指数互逆指数线性关系

密钥分配#

前面学过很多加密、MAC、认证方法,它们经常都有一个前提:Alice 和 Bob 手里已经有同一把秘密钥匙。

密钥分配 (Key Distribution) 要解决的问题是:在一个有 nn 个用户的网络里,如何让他们两两之间都能生成一把共同的秘密钥匙,同时又能抵御一定数量的恶意用户合谋攻击,而且还要尽可能减少每个人需要预先存储的秘密信息。

Blom 方案#

Trusted Authority,简称 TA,可以为每一对用户都生成一把不同的密钥用于它们之间的通信:KU,V=KV,UK_{U,V}=K_{V,U}。然后分别安全地发给 UU 和 VV

因为任意两个人以后都可能通信。如果提前给每一对用户都发一把钥匙,那么每个人要存很多钥匙,系统也要管理大量钥匙。如果网络中有 nn 个用户,那么用户 UU 需要和其他 n1n−1 个用户分别存一把密钥。整个系统需要大约生成:(n2)\binom{n}{2} 对钥匙。

Blom 方案是一种密钥预分配方案 (Key Predistribution Scheme,KPS)。它的核心原理是:TA 不直接给每一对用户发完整钥匙,而是给每个人发一个“钥匙生成器”。用户拿自己的钥匙生成器,输入对方的公开编号,就能得到两人之间的共享密钥

Blom 方案分配密钥的过程简单来说可以描述如下:

  1. 首先,选定一个公开的大素数 pp 。给网络里的每一个用户 UU 都分配一个公开的、独一无二的编号 rUr_U
  2. TA 在后台秘密构造一个最高次数为 kk二元对称多项式 f(x,y)=f(y,x)f(x, y)=f(y,x)
  3. 对于用户 UU,TA 把他的编号 rUr_U 代入到 yy 里面去,将其变成一个常数。f(x,y)f(x, y) 降维成了一个只剩 xx 的一元多项式切片 gU(x)g_U(x) 。TA 把这个切片 gU(x)g_U(x) 发给用户 UU。同理,对于用户 VV 经过同样的操作后,发送给用户 VV
  4. 若用户 UU 想要和用户 VV 交流,
    1. UU 拿出自己的多项式切片 gU(x)g_U(x),把 VV 的公开编号 rVr_V 代入进去,算出 KU,V=gU(rV)K_{U,V} = g_U(r_V)
    2. VV 拿出自己的多项式切片 gV(x)g_V(x),把 UU 的公开编号 rUr_U 代入进去,算出 KV,U=gV(rU)K_{V,U} = g_V(r_U)
    3. 因为 f(rV,rU)=f(rU,rV)f(r_V, r_U) = f(r_U, r_V) ,所以他们成功获得了共享密钥。

下面是一个例子展示了这个过程:

假设 p=13p=13, TA 设计了一个二元对称多项式:f(x,y)=3+2x+2y+5xy(mod13)f (x, y)=3+2 x+2 y+5 xy \pmod{13},它是对称的因为:f(y,x)=3+2y+2x+5yx(mod13)f(y,x)=3+2y+2x+5yx \pmod{13}

现在有两个用户 Alice 和 Bob:rA=1,rB=4r_A=1,\quad r_B=4.

Alice 的编号是 11,所以 TA 给 Alice:gA(x)=f(x,1)g_A (x)=f (x, 1),代入 Alice 的编号后得到:gA(x)=5+7x(mod13)g_A (x)=5+7 x \pmod{13}

Bob 的编号是 4,所以 TA 给 Bob:gB(x)=f(x,4)g_B(x)=f(x,4),代入 Bob 的编号后得到:gB(x)=11+22x11+9x(mod13)g_B(x)=11+22x \equiv 11+9x \pmod{13}

当 Alice 想要与 Bob 通信时,她将 Bob 的编号 rB=4r_B=4 代入自己的切片中:gA(4)=5+74=337(mod13)g_A(4)=5+7\cdot 4=33 \equiv 7 \pmod{13}, 所以 Alice 得到了密钥是 KA,B=7K_{A, B}=7

同理,Bob 也将 Alice 的编号代入自己的切片中:gB(1)=11+91=207(mod13)g_B (1)=11+9\cdot 1=20 \equiv 7 \pmod{13}, Bob 得到 KB,A=7K_{B, A}=7

两个人的通信没找 TA,也没存储彼此的密钥,而是算出了同一把密钥:KA,B=KB,A=7K_{A,B}=K_{B,A}=7

Blom 方案只能抵抗最多 kk 个人的共谋。如果 TA 设定的多项式最高次数是 kk,那么只要有 k+1k+1 个用户叛变并把他们的信息拼凑起来,就能恢复整个 f(x,y)f(x, y)。它利用了二次拉格朗日插值法,这里就不做演示了。

密钥协商方案#

在密钥分配中,我们一直假设有一个可信任的 TA 在帮忙分发密钥,例如构造的多项式切片等。如果没有这样一个可信的中心呢?在公共网络中,Alice 和 Bob 彼此相隔万里只通过网络交流,从未见过面,且他们之间的所有通信都会被黑客(网络扫描器)一字不落地监听,他们能否在这样的环境下,凭空 “商量 (Key Agreement)” 出一个只有他们俩知道的秘密密码?

这一章里将专注于 密钥协商方案 (Key Agreement):两个人或多个人不直接发送最终密钥,而是 通过交换一些公开信息各自算出同一把秘密钥匙

其中最经典且应用最广泛的协议便是 Diffie-Hellman (DH) 密钥交换协议。它允许双方在完全公开的通信环境下,利用大素数和离散对数问题 (Discrete Logarithm Problem) 等数学性质,通过交换各自计算出的中间值来生成共享密钥。即使攻击者截获了所有的通信数据,由于离散对数问题的计算困难性,在不知道双方私有秘密的情况下也无法推导出最终的密钥。

Diffie-Hellman 密钥交换协议#

我们在之前的 ElGamal 密码系统中学过,离散对数问题具有 计算指数容易,求离散对数极难 的特点。

回顾一下 ElGamal 密码系统的过程如下:

  1. 首先选择一个大质数 pp,并选择一个 α\alpha 作为模 pp 下的一个生成元,构建出循环群 Zp={1,2,,p1}\mathbb{Z}_p^* = \{1,2,\dots,p-1\}
  2. Bob 选择一个私钥:a (1a<p1)a\ (1 \leq a \lt p-1),然后计算公钥 β\betaβαa(modp)\beta \equiv \alpha^a \pmod p。根据离散对数问题的性质,别人知道 ββ,但很难从 ββ 反推出 aa。于是得到:公钥:(p,α,β)(p, \alpha, \beta),私钥:aa
  3. Alice 想加密消息 xZpx \in \mathbb{Z}_{p}^*,他将随机选择一个临时随机数 kk,然后计算:y1αk(modp)y_1 \equiv \alpha^k \pmod p, y2xβk(modp)y_2 \equiv x \cdot \beta^k \pmod p,得到一组密文: (y1,y2)(y_1, y_2)。这里的 y1y_1 类似 提示纸条,而 y2y_2 则是真正加密的内容。
  4. Bob 收到密文,他用自己的私钥 aa 计算:y1a=(αk)a=αkay_1^a = (\alpha^k)^a = \alpha^{ka}, 在之前我们计算了一个公钥 β=αa\beta = \alpha^a,根据乘法交换律替换:αka=αak=(αa)k=βk\alpha^{ka} = \alpha^{ak} = (\alpha^a)^k = \beta^k,我们就解出了真正加密内容 y2y_2 中的重要参数 βk=αa=y1a\beta^k = \alpha^a = y_1^a,而不需要知道 kk 的值。最后,只需要继续计算逆元 (y1a)1(y_1^a)^{-1} 乘回 y2y_2 中,即可计算出明文 xxxy2(βk)1=y2(y1a)1(modp)x \equiv y_2 \cdot (\beta^k)^{-1} = y_2 \cdot (y_1^a)^{-1} \pmod p

Alice 用 Bob 的公钥 β=αa\beta=\alpha^a 和自己的随机数 kk,算出共享遮罩 βk=(αa)k=αak\beta^k=(\alpha^a)^k=\alpha^{ak},然后用它加密消息。Bob 用自己的公钥算了 (y1)a=αka=(αk)a(y_1)^a=\alpha^{ka} = (\alpha^k)^a。他们都计算了一个共同秘密值是:αak\alpha^{ak}

Diffie-Hellman 密钥交换协议的思想是:既然 Alice 和 Bob 可以在不直接发送秘密值的情况下,共同算出 αak\alpha^{ak},那就 直接将这个值当成密钥好了。它不传消息 xx ,不生成 y2y_2 ,只生成共享密钥 αak\alpha^{ak}

这个协议的具体流程如下:

  1. Alice 和 Bob 约定一个大素数 pp,以及一个生成元 α\alpha
  2. Alice 自己选一个随机数 aUa_U。她计算 bU=αaUmodpb_U = \alpha^{a_U} \bmod p,并把 bUb_U 发给 Bob。
  3. Bob 也自己选一个随机数 aVa_V。他计算 bV=αaVmodpb_V = \alpha^{a_V} \bmod p,并把 bVb_V 发给 Alice。
  4. 最后两人各自合成最终密钥:
    1. Alice 拿到 bVb_V,计算 K=(bV)aUmodpK = (b_V)^{a_U} \bmod p
    2. Bob 拿到 bUb_U,计算 K=(bU)aVmodpK = (b_U)^{a_V} \bmod p

最后,他们算出了一个共享密钥:(αaV)aU=(αaU)aV=αaUaV( \alpha^{a_V} )^{a_U} = ( \alpha^{a_U} )^{a_V} = \alpha^{a_U \cdot a_V}

对于窃听者而言,即便截获了公开传输的 p,α,bUp, \alpha, b_UbVb_V,也无法从 αaU\alpha^{a_U} 中反推出 aUa_U,自然算不出 αaUaV\alpha^{a_U \cdot a_V}

Diffie-Hellman 密钥交换协议与 ElGamal 密码系统不同的是 Alice 和 Bob 都各自选一个随机数,交换 αaU\alpha^{a_U} 和 αaV\alpha^{a_V} ,然后共同算出共享密钥 αaUaV\alpha^{a_Ua_V}。DH 只生成这个共享值,把它作为密钥

下面是一个例子展示了 DH 协议的过程:

  1. Alice 和 Bob 选定 p=23,α=5p=23,\quad \alpha=5
  2. Alice 选定 aU=6a_U=6,发送:bU=56mod23=8b_U=5^6\bmod 23=8;
  3. Bob 选定 aV=15a_V=15,发送:bV=515mod23=19b_V=5^{15}\bmod 23=19.
  4. Alice 收到 1919,用自己的秘密数 66 计算:K=196mod23=2K=19^6\bmod 23=2;
  5. Bob 收到 88,用自己的秘密数 1515 计算:K=815mod23=2K=8^{15}\bmod 23=2.
  6. 于是双方得到同一个密钥:K=2K=2.

但是基础 DH 有一个重要缺陷:Alice 收到的这个值真的来自 Bob。所以基础 DH 容易被 中间人攻击 (man-in-the-middle attack)

Diffie-Hellman 密钥交换协议与 ElGamal 密码系统的对比如下:

对比点ElGamal 密码系统Diffie-Hellman Key Agreement
主要目的加密消息协商密钥
是否有明文 xx没有
谁有长期私钥Bob 有 aa基础 DH 中双方每次临时选
Alice 做什么选随机数 kk,生成密文选秘密数 aUa_U,发送 αaU\alpha^{a_U}
Bob 做什么用私钥 aa 解密选秘密数 aVa_V,发送 αaV\alpha^{a_V}
共同秘密值αak\alpha^{ak}αaUaV\alpha^{a_Ua_V}
共同秘密值的用途用来遮住消息直接作为共享密钥或密钥材料
核心数学(αa)k=(αk)a(\alpha^a)^k=(\alpha^k)^a(αaV)aU=(αaU)aV(\alpha^{a_V})^{a_U}=(\alpha^{a_U})^{a_V}

会议密钥协商#

普通的 Diffie-Hellman 是两个人,但现实里可能是多人会议、群聊、团队通信:即用户 U0,U1,U2,,Um1U_0,U_1,U_2,\dots,U_{m-1} 需要共享同一把群组密钥:ZZ,该如何生成所有用户都知道,但黑客不知道的密钥呢?这就引出了 会议密钥协商方案 (Conference Key Agreement Scheme, CKAS)

一种常见的实现方式是 Burmester-Desmedt 协议。在该方案中,所有参与者首先把 mm 个参与者看成一个环,每个人先给左右邻居发送 bi=αaib_i=\alpha^{a_i},然后每个人广播一个 XiX_i,最后所有人都能算出同一个会议密钥。

假设共有 mm 个人,在模数空间 Zm\mathbb{Z}_m 中,U0,U1,,Um1U_0, U_1,\dots, U_{m-1} 围成一个环,收尾相连:Um=U0U_{m}=U_0, U1=Um1U_{-1}=U_{m-1}.

具体来说流程如下:

  1. 广播:每个用户 UiU_i 选择一个随机数作为秘密 aia_i,计算一个传播值 bi=αaib_i=\alpha^{a_i},然后把 bib_i 发给左右邻居:Ui1,Ui+1U_{i-1},\quad U_{i+1}.
  2. 计算差值:每个人收到邻居发来的两个计算结果 bi+1=αai+1b_{i+1}=\alpha^{a_{i+1}}bi1=αai1b_{i-1}=\alpha^{a_{i-1}} 后,计算它们之间的差值 Xi=(bi+1bi1)ai=(αai+1αai1)ai=αaiai+1αai1aiX_i=\left(\frac{b_{i+1}}{b_{i-1}}\right)^{a_i} = \left(\frac{\alpha^{a_{i+1}}}{\alpha^{a_{i-1}}}\right)^{a_i} = \frac{\alpha^{a_ia_{i+1}}}{\alpha^{a_{i-1}a_i}}。算完之后,每个人把自己的 XiX_i 广播给环里的所有人
  3. 计算群密钥:每个人先用自己和邻居的信息算出已知小块:Yi1=αai1aiY_{i-1}=\alpha^{a_{i-1}a_i}, 结合其他人上一步计算出来广播的差值 Xi=YiYi1X_i=\frac{Y_i}{Y_{i-1}}Xi,Xi+1,Xi+2,X_i,X_{i+1},X_{i+2},\dots 中包含的 YY 信息逐步推导出所有相邻小块。最后把所有小块乘起来,得到:Z=Y0Y1Ym1Z=Y_0Y_1\cdots Y_{m-1},得到 Z=αa0a1+a1a2++am1a0Z=\alpha^{a_0a_1+a_1a_2+\cdots+a_{m-1}a_0},这就是大家共同得到的会议密钥。

下面是一个简单的例子:

假设有 m=4m=4 个用户 U0,U1,U2,U3U_0,U_1,U_2,U_3,公开的参数是:p=23,α=5p=23,\quad \alpha=5,每个人选择秘密数:a0=3,a1=4,a2=7,a3=9a_0=3,\quad a_1=4,\quad a_2=7,\quad a_3=9

  1. 广播:每个人算 bi=αaib_i=\alpha^{a_i},并把自己的 bib_i 发给左右邻居:
    1. U0: b0=53mod23=10U_0:\ b_0=5^3\bmod 23=10
    2. U1:b1=54mod23=4U_1: b_1=5^4\bmod 23=4
    3. U2: b2=57mod23=17U_2:\ b_2=5^7\bmod 23=17
    4. U3:b3=59mod23=11U_3: b_3=5^9\bmod 23=11
  2. 计算差值:每个人计算与邻居的差值:Xi=(bi+1bi1)aimod23X_i=\left(\frac{b_{i+1}}{b_{i-1}}\right)^{a_i}\bmod 23,并且广播给所有人:
    1. X0=17X_0=17
    2. X1=3X_1=3
    3. X2=21X_2=21
    4. X3=16X_3=16
  3. 计算群组密钥:以 U0U_0 为例 a0=3a_0=3,它收到了左邻居 U3U_3 的:b3=11b_3=11,所以他可以先算出自己已知的相邻小块:Y3=(b3)a0=αa3a0=113mod23=20Y_3=(b_3)^{a_0} = \alpha^{a_3a_0} =11^3\bmod 23=20。接下来用广播出来的差值提示一个个推:X0=Y0Y3X_0=\frac{Y_0}{Y_3},所以:Y0=Y3X0=2017mod23=18Y_0=Y_3X_0=20\cdot17\bmod23=18;再用 X1=Y1Y0X_1=\frac{Y_1}{Y_0} 推:Y1=Y0X1=183mod23=8Y_1=Y_0X_1=18\cdot3\bmod23=8;再用 X2=Y2Y1X_2=\frac{Y_2}{Y_1},得到 Y2=Y1X2=821mod23=7Y_2=Y_1X_2=8\cdot21\bmod23=7。现在 U0U_0  已经拼出了所有小块:Y0=18,Y1=8,Y2=7,Y3=20Y_0=18,\quad Y_1=8,\quad Y_2=7,\quad Y_3=20。最后把它们乘起来:Z=18872012mod23Z=18\cdot8\cdot7\cdot20 \equiv 12 \bmod23,所以得到了群组密钥 Z=12Z=12.

同理,环中的其他用户 U1,U2,U3U_1, U_2, U_3 也可以通过这样的方法得到相同的群组密钥。

【密码学】学习笔记
https://hoyue.fun/cryptography.html
作者
Hoyue
发布于
2026-05-10
许可协议
CC BY-NC-SA 4.0
评论