MIT-6-5620-密码学基础-全-

MIT 6.5620 密码学基础（全）

001：完美安全

在本节课中，我们将学习密码学中一个基础且重要的概念：完美安全。我们将探讨其定义、等价形式，并通过一个经典构造——一次性密码本——来理解它。最后，我们会看到完美安全的局限性，并引出后续课程中将要学习的解决方案。

课程概述与行政安排

欢迎来到密码学基础课程。在进入正式内容前，我们先了解一些课程安排。

课程网站包含所有必要信息。讲座会被录制，视频稍后会上传到网站。

我们将使用Piazza进行交流，任何问题都可以在那里提出。作业将通过Gradescope提交。

关于评分：期中考试占总成绩的40%，将在课堂上进行，旨在检验对课程内容的理解。作业占总成绩的60%，共有五次作业，取成绩最好的四次计入总分。我们鼓励以三人或更少的小组形式讨论作业，但必须独立完成并用自己的语言书写，这是学习的关键。

助教将安排固定的答疑时间，具体信息会公布在网站上。此外，每次下课后我也会留出时间解答问题。

第一次作业将于本周五发布。为了帮助大家准备，网站上提供了关于概率论和计算复杂性理论的两份讲义，阅读它们非常重要。

什么是密码学？

这门课程是关于密码学中那些看似“神奇”的概念。例如：

• 在不预先共享秘密的情况下，如何发送只有收件人能解密的消息？
• 如何向他人证明一个陈述为真，却不透露任何关于“为何为真”的信息？
• 如何将一个很长的证明压缩成几百字节？

这些看似不可能的任务，正是本课程将要探索的内容。本课程侧重于密码学的理论基础。

为了实现这些目标，我们通常依赖三个核心要素：

1. 定义：精确定义我们想要实现的安全目标。这通常非常棘手，因为需要明确敌手的能力和我们期望的安全保证。
2. 困难性假设：我们需要假设某些计算问题是困难的。例如，假设大整数分解是困难的。没有这些假设，我们目前无法构建密码学方案。
3. 归约：这是证明安全性的核心方法。我们证明：如果存在一个敌手能攻破我们的密码方案，那么就可以利用这个敌手去攻破我们所依赖的困难性假设。这构成了密码学安全性证明的基础。

完美安全的定义

密码学的形式化研究始于克劳德·香农。他于1949年发表了关于加密方案的奠基性论文。首先，我们需要定义什么是加密方案。

一个加密方案包含以下部分：

• 消息空间 M
• 密文空间 C
• 密钥空间 K
• 两个算法：
  • 加密算法 Enc：输入密钥 k ∈ K 和消息 m ∈ M，输出密文 c ∈ C。
  • 解密算法 Dec：输入密钥 k ∈ K 和密文 c ∈ C，输出消息 m ∈ M。

首先，一个加密方案必须满足正确性：对于所有密钥 k ∈ K 和所有消息 m ∈ M，都有 Dec(k, Enc(k, m)) = m。

接下来是安全性。香农提出了以下定义，称为香农安全或完美安全：

对于消息空间 M 上的任何概率分布，对于任何消息 m ∈ M 和任何密文 c ∈ C，在给定密文 c 的条件下，消息是 m 的后验概率，等于其先验概率。
用公式表示为：Pr[M = m | C = c] = Pr[M = m]
这意味着，敌手看到密文后，对原始消息的了解没有任何增加。

另一个等价且更直观的定义是完美不可区分性：

对于消息空间中的任何两条消息 m0 和 m1，以及任何密文 c，用随机密钥加密 m0 得到 c 的概率，等于加密 m1 得到 c 的概率。
用公式表示为：Pr[Enc(K, m0) = c] = Pr[Enc(K, m1) = c]
这意味着，仅观察密文，无法区分它来自 m0 还是 m1。

还有一个等价的、基于敌手游戏的第三种定义，这在现代密码学中更常见：

对于任何敌手，当它收到一个随机加密的密文（随机选择 b ∈ {0,1}，然后得到 Enc(K, mb)）时，它猜中 b 的概率恰好是 1/2，不比随机猜测更好。

我们可以证明，香农安全、完美不可区分性以及基于敌手游戏的定义三者是等价的。下面我们简要证明前两者的等价性。

定义等价性证明

定理：香农安全与完美不可区分性等价。

证明 (香农安全 ⇒ 完美不可区分性)：

1. 假设加密方案满足香农安全。
2. 固定任意两条消息 m0, m1 和任意密文 c。
3. 构造一个消息分布 M：以 1/2 的概率输出 m0，以 1/2 的概率输出 m1。
4. 根据香农安全，有 Pr[M = m0 | C = c] = Pr[M = m0] = 1/2。
5. 根据贝叶斯定理，Pr[M = m0 | C = c] = (Pr[M=m0] * Pr[Enc(K,m0)=c]) / Pr[C=c]。
6. 因此，(1/2 * Pr[Enc(K,m0)=c]) / Pr[C=c] = 1/2，化简得 Pr[Enc(K,m0)=c] = Pr[C=c]。
7. 同理，对于 m1 有 Pr[Enc(K,m1)=c] = Pr[C=c]。
8. 所以，Pr[Enc(K,m0)=c] = Pr[Enc(K,m1)=c]，满足完美不可区分性。

证明 (完美不可区分性 ⇒ 香农安全)：

1. 假设加密方案满足完美不可区分性。
2. 固定任意消息分布 M，任意消息 m0 和任意密文 c。
3. 我们需要证明 Pr[M = m0 | C = c] = Pr[M = m0]。
4. 再次使用贝叶斯定理：Pr[M = m0 | C = c] = (Pr[M=m0] * Pr[Enc(K,m0)=c]) / Pr[C=c]。
5. 其中，Pr[C=c] = Σ_{m∈M} Pr[M=m] * Pr[Enc(K,m)=c]。
6. 根据完美不可区分性，对于所有 m，Pr[Enc(K,m)=c] = Pr[Enc(K,m0)=c]（因为 m0 是固定的任意消息）。
7. 因此，Pr[C=c] = Σ_{m∈M} Pr[M=m] * Pr[Enc(K,m0)=c] = Pr[Enc(K,m0)=c] * Σ_{m∈M} Pr[M=m] = Pr[Enc(K,m0)=c]。
8. 将第7步结果代入第4步，得到 Pr[M = m0 | C = c] = (Pr[M=m0] * Pr[Enc(K,m0)=c]) / Pr[Enc(K,m0)=c] = Pr[M=m0]。
9. 证毕。

一个经典构造：一次性密码本

既然有了强大的安全定义，我们能否实现它呢？答案是肯定的，一个经典的构造是一次性密码本。

• 设置：消息空间、密文空间、密钥空间都是长度为 n 的比特串集合，即 {0,1}^n。
• 加密：Enc(k, m) = k ⊕ m，其中 ⊕ 表示按位异或 (XOR) 操作。
• 解密：Dec(k, c) = k ⊕ c。

正确性验证：Dec(k, Enc(k, m)) = k ⊕ (k ⊕ m) = (k ⊕ k) ⊕ m = 0 ⊕ m = m。

安全性证明 (使用完美不可区分性)：

1. 对于任意消息 m 和密文 c，Pr[Enc(K, m) = c] = Pr[K ⊕ m = c] = Pr[K = c ⊕ m]。
2. 由于密钥 K 是从 {0,1}^n 中均匀随机选取的，所以 Pr[K = 某个特定值] = 1/(2^n)。
3. 因此，对于任意 m0, m1 和 c，都有 Pr[Enc(K, m0) = c] = 1/(2^n) = Pr[Enc(K, m1) = c]。
4. 这完美满足了完美不可区分性的定义。

完美安全的局限性

一次性密码本看起来完美无缺，但它有一个致命的缺陷：密钥必须至少和所有待加密消息的总长度一样长。

为什么这是必然的？我们可以从完美安全的定义推导出这个结论。

根据完美不可区分性，对于任意密文 c 和任意消息 m，都必须存在一个密钥 k 使得 Enc(k, m) = c。否则，如果某个消息 m 永远无法加密成 c，那么敌手看到 c 时就知道消息肯定不是 m，这就泄露了信息。

同时，根据正确性要求，同一个密钥 k 不能将两个不同的消息 m 和 m‘ 加密成同一个密文 c。因为如果用 k 解密 c，只能得到一个确定的消息。

结合以上两点：每个消息 m 对应密文 c 都需要一个唯一的密钥 k。因此，密钥的总数必须至少等于可能的消息总数。如果我们希望用同一个密钥加密多条消息（总长度为 L 比特），那么密钥空间的大小至少是 2^L，这意味着密钥本身至少需要 L 比特长。这实际上失去了意义：如果你能安全地传输一个和消息一样长的密钥，为什么不直接传输消息本身呢？

更具体地说，一次性密码本如果重复使用密钥，会立即变得不安全。假设用同一个密钥 k 加密两个消息 m0 和 m1，得到密文 c0 = k⊕m0, c1 = k⊕m1。敌手计算 c0 ⊕ c1 = (k⊕m0) ⊕ (k⊕m1) = m0 ⊕ m1，直接得到了两条消息的异或值，这可能泄露大量信息。

总结与展望

本节课我们一起学习了密码学中完美安全的概念。

• 我们介绍了香农安全、完美不可区分性等等价定义。
• 我们看到了一个实现完美安全的经典方案——一次性密码本，并验证了其安全性。
• 然而，我们也揭示了完美安全的一个根本性局限：密钥长度必须不小于消息总长度，这使得它对于长期通信而言是不切实际的。

这个“不可能性”结果正是密码学魅力的起点。下节课，我们将学习如何通过放宽安全要求（从“完美”到“计算”安全），并引入困难性假设，来跨越这个障碍，构建出真正实用且安全的加密方案。这正是密码学“在限制中创造可能”的艺术。

002：从完美保密到计算安全 🔐

在本节课中，我们将学习如何从“完美保密”这一过于理想化的概念，过渡到更实际、更强大的“计算安全”概念。我们将理解为什么完美保密在现实中难以实现，并学习如何通过放宽安全定义来构建实用的加密方案。

上一节我们介绍了完美保密的概念及其局限性。本节中，我们来看看如何通过引入“计算安全”来克服这些限制。

完美保密的局限性回顾

我们之前定义了两种等价的完美保密概念：

1. 香农定义：对于任意消息分布 M，在观察到密文 C 后，消息的后验概率与先验概率相同。即密文不泄露任何关于明文的信息。
   • Pr[M = m | C = c] = Pr[M = m]
2. 不可区分性定义：对于消息空间中的任意两个消息 m0 和 m1，其加密后的密文分布完全相同。
   • {Enc(k, m0)} 的分布 ≡ {Enc(k, m1)} 的分布

一次性密码本（One-Time Pad）是实现完美保密的简单方案：

• 加密：C = M ⊕ K （M 为消息，K 为密钥，⊕ 表示异或操作）
• 解密：M = C ⊕ K

然而，香农证明，任何实现完美保密的方案都有一个根本性限制：密钥长度必须至少与消息长度相同。这在实际中意味着，要安全地传输大量数据，需要预先共享同样大量的密钥，这非常不切实际。

为何密钥必须很长？

理解这个不可能性结果的原因，有助于我们知道如何放宽定义。核心原因在于，如果密钥空间小于消息空间，那么必然存在两个消息 m0 和 m1，使得它们的加密结果集合不完全相同。

假设攻击者获得了一个密文 C，他可以尝试遍历所有可能的密钥 k，并检查 Enc(k, m0) 或 Enc(k, m1) 是否等于 C。如果只有其中一个等式成立，他就能确定加密的是哪个消息。即使这个成功的概率很小（例如 1/(2^密钥长度)），它也严格大于零，从而违反了完美不可区分性。

这个攻击的关键在于，攻击者需要进行穷举搜索所有密钥。如果密钥长度是256位，那么搜索空间是 2^256，这远远超出了任何实际计算能力。

引入计算安全

这就引出了计算安全的核心思想：我们不再要求攻击者绝对无法破解（信息论安全），而是要求他在实际可行的计算资源内无法破解。

我们通过以下方式形式化这个想法：

1. 安全参数（λ）：这是一个控制方案安全级别的数字。通常，密钥长度与 λ 相关（例如，密钥是 λ 位）。λ 越大，方案理论上越安全（但加密/解密也可能越慢）。
2. 高效攻击者：我们将攻击者模型限制为概率性多项式时间（PPT）算法或多项式规模电路。这意味着攻击者的运行时间或电路规模是安全参数 λ 的某个多项式函数（如 λ^2, λ^3）。
3. 可忽略函数：用于描述攻击者微小的成功优势。一个函数 μ(λ) 是可忽略的，如果对于任意多项式 p(λ)，当 λ 足够大时，都有 μ(λ) < 1/p(λ)。例如，2^(-λ) 或 λ^(-log λ) 都是可忽略的。它代表了在实际中可视为“零”的概率。

计算安全的定义

基于上述概念，我们给出（私钥）加密方案的计算安全定义（这里以不可区分性实验为例）：

一个加密方案是计算安全的（或语义安全的），如果对于所有概率性多项式时间（PPT）攻击者 A，都存在一个可忽略函数 negl(λ)，使得以下条件成立：

Pr[PrivK^eav_{A, Π}(λ) = 1] ≤ 1/2 + negl(λ)

其中实验 PrivK^eav 流程如下：

1. 攻击者 A 输出两个等长的消息 m0, m1。
2. 挑战者随机生成密钥 k，并随机选择一个比特 b ∈ {0,1}。计算密文 c ← Enc(k, mb) 并发送给 A。
3. A 收到密文 c 后，输出一个猜测比特 b‘。
4. 实验输出 1 当且仅当 b‘ = b（即猜测正确）。

这个定义意味着，任何高效的攻击者，在参与上述实验时，其区分加密的是 m0 还是 m1 的优势，最多只有 1/2 加上一个可忽略的量。这实际上等同于他无法进行比随机猜测更好的攻击。

从不可能到可能：单向函数的作用

即使有了计算安全的定义，我们能否构造出密钥短、消息长的加密方案呢？这依赖于一个计算复杂性假设：单向函数的存在性。

一个函数 f: {0,1}^* → {0,1}^* 是单向函数，如果满足：

1. 容易计算：存在多项式时间算法，对于任意输入 x，都能快速计算 f(x)。
2. 难以求逆：对于任意概率性多项式时间算法 A，当给定 y = f(x)（其中 x 是随机选择的）时，A 成功找到一个原像 x’ 使得 f(x’) = y 的概率是可忽略的。

Pr_{x←{0,1}^λ}[A(1^λ, f(x)) ∈ f^{-1}(f(x))] ≤ negl(λ)

直观上，单向函数就是正向计算容易，但反向求逆在计算上不可行的函数（例如，某些良好的密码散列函数）。

核心构造思路：伪随机生成器

如何利用短密钥加密长消息？核心思想是使用伪随机生成器。

1. 目标：我们仍然想使用类似一次性密码本这样简单有效的方法：C = M ⊕ G。但我们需要一个与消息等长的“一次性密码” G。
2. 问题：如果 G 是真正的随机串，那么我们需要很长的共享密钥。
3. 解决方案：我们不使用真随机串 G，而是使用一个伪随机生成器 从一个短的种子（即我们的短密钥 s）生成一个长的伪随机串 G(s)。
   • PRG(s): {0,1}^λ → {0,1}^l，其中 l >> λ。
4. 伪随机性：关键要求是，对于任何高效攻击者来说，G(s)（其中 s 是随机种子）的输出与一个真正的 l 位随机串是计算不可区分的。攻击者无法区分它们。
5. 加密方案：
   • 密钥：短随机种子 s（长度 λ）。
   • 加密：C = M ⊕ G(s)。
   • 解密：M = C ⊕ G(s)。

如果 G 是一个安全的伪随机生成器，那么攻击者无法区分 G(s) 和真随机串。因此，在他的视角里，这个方案就像一个用了一次性密码本加密的方案，从而是计算安全的。而我们实际上只共享了一个很短的密钥 s。

一个重要的结论是：伪随机生成器可以从单向函数构造出来。因此，单向函数的存在性是构建现代私钥加密方案的基石。

总结

本节课中我们一起学习了：

• 完美保密（如一次性密码本）因要求密钥长度不小于消息长度而不实用。
• 香农证明了这是实现完美保密的内在限制。
• 为了突破限制，我们引入了计算安全的概念，将安全性与攻击者的计算能力绑定。
• 我们形式化定义了安全参数、高效攻击者（PPT）和可忽略函数。
• 计算安全允许攻击者有微乎其微的成功概率，但这在实际中是可接受的。
• 为了实现密钥短、消息长的加密，我们需要依赖单向函数这一计算复杂性假设。
• 核心构造工具是伪随机生成器，它能将短随机种子扩展为长的、在计算上与随机串不可区分的伪随机串，从而模拟一次性密码本的效果。

从下节课开始，我们将深入探讨伪随机生成器、单向函数的具体构造，以及如何严格证明这些方案的安全性。

003：伪随机生成器与加密方案

在本节课中，我们将要学习如何定义和构造伪随机生成器，并了解如何利用它来构建计算安全的加密方案。

上一节我们介绍了计算安全加密方案和单向函数的概念。本节中，我们来看看构建此类加密方案的核心工具——伪随机生成器。

计算安全加密方案回顾

首先，我们快速回顾一下计算安全加密方案的定义。一个加密方案包含密钥空间、消息空间和密文空间，它们都依赖于一个安全参数 λ。

• 密钥空间：通常为 {0,1}^λ。
• 消息空间：可以随 λ 增长，在许多方案中为 {0,1}。
• 加密算法：输入密钥和消息，输出密文。
• 解密算法：输入密钥和密文，输出消息。

正确性要求对于所有 λ、密钥和消息，解密（密钥， 加密（密钥， 消息）） = 消息。

安全性（计算安全）要求对于任何多项式规模的敌手，加密任意两个不同消息 M0 和 M1 得到的密文，在敌手看来是不可区分的。形式化地，对于任何多项式规模敌手 A，存在一个可忽略函数 negl，使得对于所有 λ 和所有消息对 (M0, M1)：

| Pr[ A(Enc(K, M0)) = 1 ] - Pr[ A(Enc(K, M1)) = 1 ] | ≤ negl(λ)

其中概率空间为随机密钥 K。

计算不可区分性

为了更简洁地描述安全性，我们引入计算不可区分性的概念。

两个分布族 {D0_λ} 和 {D1_λ} 是计算不可区分的，如果对于任何多项式规模敌手 A，存在一个可忽略函数 negl，使得对于所有 λ：

| Pr[ A(x) = 1 | x ← D0_λ ] - Pr[ A(x) = 1 | x ← D1_λ ] | ≤ negl(λ)

我们将其记为：D0_λ ≈_c D1_λ。

利用这个记号，加密方案的安全性可以表述为：对于所有 λ 和所有消息对 (M0, M1)，有 Enc(K, M0) ≈_c Enc(K, M1)，其中 K 是随机密钥。

伪随机生成器（PRG）的定义 🎲

伪随机生成器是我们构建加密方案的核心工具。它是一个确定性的多项式时间可计算函数 G，满足两个性质：

1. 扩展性：它将短种子扩展为更长的输出串。对于输入长度 λ，输出长度 n(λ) > λ。

   • 公式：G: {0,1}^λ → {0,1}^{n(λ)}，其中 n(λ) > λ。

2. 伪随机性：其输出在计算上看起来与真正的随机串无法区分。即使输出只包含 λ 比特的熵（来自种子），但对于多项式规模的敌手，它看起来像是具有 n(λ) 比特熵的均匀随机串。

   • 形式化：G(U_λ) ≈_c U_{n(λ)}，其中 U_m 表示 {0,1}^m 上的均匀分布。

伪随机生成器的存在性并非显然。我们目前不知道它们是否无条件存在。然而，我们知道：

如果单向函数存在，那么伪随机生成器就存在。

而单向函数的存在基于许多我们相信的计算困难性假设，例如大整数分解困难性假设。

PRG 的等价定义：下一比特不可预测性

在构造 PRG 时，使用一个等价的、有时更易验证的性质更为方便，即下一比特不可预测性。

一个函数 G 满足下一比特不可预测性，如果对于任何多项式规模敌手 A，存在一个可忽略函数 negl，使得对于所有 λ 和所有位置 i (1 ≤ i ≤ n(λ))，敌手在给定输出前 i-1 比特的情况下，正确预测第 i 比特的概率最多比 1/2 高出可忽略的量。

形式化地，对于所有多项式规模 A，存在 negl，使得对于所有 λ 和所有 i：

Pr[ A(G(U_λ)_{1...i-1}) = G(U_λ)_i ] ≤ 1/2 + negl(λ)

定理：一个函数 G 是伪随机生成器，当且仅当它是扩展的且满足下一比特不可预测性。

证明思路（伪随机性 ⇒ 下一比特不可预测性）：如果存在敌手能成功预测下一比特，我们可以构造一个区分器来区分 G(U_λ) 和 U_{n(λ)}。该区分器运行预测敌手，若预测成功则倾向于输出“伪随机”，否则倾向于输出“真随机”。

证明思路（下一比特不可预测性 ⇒ 伪随机性）：这个方向更有趣，使用了密码学中一个非常重要的工具——混合论证。

1. 假设存在敌手 A 能以不可忽略的优势 ε(λ) 区分 G(U_λ)（记为 H_n）和 U_{n(λ)}（记为 H_0）。
2. 定义一系列“混合”分布 H_i (0 ≤ i ≤ n)：H_i 的前 i 比特来自 G(U_λ)，后 n-i 比特来自真正的均匀随机串。
   • H_n = G(U_λ) （全伪随机）
   • H_0 = U_{n(λ)} （全真随机）
3. 敌手 A 区分 H_n 和 H_0 的优势为 ε。根据概率的 telescoping sum（裂项和）和三角不等式，存在某个索引 i，使得 A 区分 H_i 和 H_{i-1} 的优势至少为 ε/n。
4. 注意到 H_i 和 H_{i-1} 的唯一区别在于：H_i 的第 i 比特是 G(U_λ) 的第 i 比特（伪随机部分），而 H_{i-1} 的第 i 比特是均匀随机比特。
5. 因此，一个能区分 H_i 和 H_{i-1} 的敌手，本质上能区分“第 i 比特是伪随机生成”还是“完全随机”。这便违反了下一比特不可预测性（经过适当转换）。

通过混合论证，我们将区分整个长串的问题，归约到了区分单个比特的问题，从而证明了等价性。

使用 PRG 构造加密方案 🔐

现在，我们展示如何利用伪随机生成器 G 构造一个计算安全的加密方案，该方案能用短密钥加密长消息。

设 G: {0,1}^λ → {0,1}^{n(λ)} 是一个 PRG，其中 n(λ) 是 λ 的多项式，且 n(λ) > λ。

我们构造加密方案如下：

• 密钥生成：密钥 K 是均匀随机选择的 λ 比特串。K ← {0,1}^λ
• 加密算法 Enc(K, M)：对于消息 M ∈ {0,1}^{n(λ)}，计算
  • C := G(K) ⊕ M
  • 输出密文 C。
• 解密算法 Dec(K, C)：计算
  • M := G(K) ⊕ C
  • 输出消息 M。

正确性：显然，因为 Dec(K, Enc(K, M)) = G(K) ⊕ (G(K) ⊕ M) = M。

安全性证明（通过归约）：我们证明，如果存在敌手能攻破该加密方案，那么就能构造一个敌手来区分 PRG 的输出与真随机串，从而攻破 PRG 的伪随机性。

1. 假设：假设存在多项式规模敌手 A，对于无限多个 λ，能选择一对消息 (M0, M1)，并在收到 Enc(K, M_b)（b 随机为 0 或 1）后，以至少 1/2 + ε(λ) 的概率正确猜出 b，其中 ε(λ) 是不可忽略的。
2. 构造区分器 B：我们构造一个区分器 B 来攻击 PRG G。
   • 输入：B 收到一个串 R ∈ {0,1}^{n(λ)}，它要么来自 G(U_λ)，要么来自 U_{n(λ)}。
   • 操作：
     1. B 随机选择一个比特 b ← {0,1}。
     2. B 计算“密文” C := R ⊕ M_b。
     3. B 运行加密敌手 A，输入 C，得到猜测的比特 b‘。
     4. 如果 b‘ == b，则 B 输出 1（猜测 R 来自 PRG，即“伪随机”）；否则输出 0（猜测 R 来自均匀分布，即“真随机”）。
3. 分析：
   • 如果 R 是真随机的，即 R ← U_{n(λ)}，那么 C = R ⊕ M_b 也是一个均匀随机串，与 b 完全无关。此时，敌手 A 最多以 1/2 的概率猜中 b。因此，B 输出 1 的概率约为 1/2。
   • 如果 R 是伪随机的，即 R = G(K) 对于某个随机 K，那么 C = G(K) ⊕ M_b 正是我们加密方案中的合法密文。根据假设，敌手 A 能以 1/2 + ε(λ) 的概率猜中 b。因此，当 A 猜中时 B 输出 1，所以 B 输出 1 的概率约为 1/2 + ε(λ)。
4. 结论：区分器 B 区分 G(U_λ) 和 U_{n(λ)} 的优势约为 ε(λ)，这是一个不可忽略的函数。这与 G 是 PRG 的假设矛盾。

因此，原加密方案在 PRG 存在的假设下是计算安全的。

总结

本节课中我们一起学习了：

1. 计算不可区分性：作为描述密码学安全性的简洁数学工具。
2. 伪随机生成器（PRG）：一个能将短种子“拉伸”成更长串的函数，且输出在计算上与真随机串不可区分。其存在性依赖于单向函数等计算困难性假设。
3. PRG 的等价定义：下一比特不可预测性，并通过混合论证证明了其与伪随机性的等价性。
4. 利用 PRG 构造加密：通过将 PRG 的输出作为“一次一密”的密钥流，我们能够用短密钥安全地加密长消息，并通过归约证明了其安全性依赖于 PRG 的安全性。

我们看到了定义、假设和归约证明这三个密码学核心要素如何协同工作，构建出实用的密码方案。下一节我们将探讨如何从更基础的假设（如单向函数）具体构造出伪随机生成器。

004：伪随机生成器与硬核谓词

在本节课中，我们将学习如何构造伪随机生成器。我们将首先回顾伪随机生成器的定义，然后探讨如何从单向函数构造一个仅扩展一位的伪随机生成器，并最终理解硬核谓词的概念及其核心作用。

回顾：伪随机生成器

上一节我们介绍了伪随机生成器的概念。本节中，我们来看看其正式定义。

伪随机生成器是一个函数 G，它满足以下三个条件：

1. 高效性：存在一个多项式时间图灵机，对于输入 x，能够输出 G(x)。
2. 扩展性：输出长度 n(λ) 大于输入长度 λ。
3. 伪随机性：对于任何多项式时间的敌手，分布 G(U_λ) 与真正的均匀分布 U_{n(λ)} 在计算上是不可区分的。

一个等价的定义是下一比特不可预测性。这意味着，对于任何多项式时间敌手，给定伪随机串的前 i-1 位，其成功预测第 i 位的概率最多为 1/2 + negl(λ)，其中 negl(λ) 是可忽略函数。

伪随机生成器使我们能够构建密钥长度短于消息长度的安全加密方案。

从单向函数到伪随机生成器

我们知道一个基础定理：伪随机生成器存在，当且仅当单向函数存在。单向函数是密码学中最基本的假设。

以下是单向函数的定义：

• 易计算：存在多项式时间算法计算 f(x)。
• 难求逆：对于任何多项式规模敌手 A，当给定 y = f(x)（其中 x 均匀随机选取）时，其成功找到任意原像 x' 使得 f(x') = y 的概率是可忽略的。

本节课我们将证明一个简化版本：假设存在一个单向置换，则可以构造一个伪随机生成器。

单向置换是一个既是单向函数又是双射的函数。这意味着对于定义域中的每个 x，都有唯一的 y = f(x) 与之对应，且 f 是长度保持的。

构造策略：扩展一位即足够

我们的首要目标是构造一个仅扩展一位的伪随机生成器。即构造 G: {0,1}^λ → {0,1}^{λ+1}。

为什么这足够呢？因为如果我们有一个扩展一位的伪随机生成器 G，我们可以通过迭代来获得任意多项式长度的扩展。

定理：如果 G 是一个扩展一位的伪随机生成器，那么对于任何多项式 k(λ)，函数 G^k（即将 G 迭代应用 k 次）也是一个伪随机生成器。

证明概要：

• 高效性和扩展性显然成立。
• 证明伪随机性需要小心处理误差累积。我们可以通过混合论证来证明。假设敌手能区分 G^k(U_λ) 和 U_{λ+k}，那么我们可以构造一系列混合分布，并利用 G 本身的伪随机性，证明敌手的优势仍然是可忽略的。关键在于，每次迭代引入的区分优势是可加的，且独立于迭代次数，因此总优势仍然是可忽略的。

因此，我们只需专注于构造扩展一位的伪随机生成器。

核心工具：硬核谓词

如何利用单向置换 f 来获得额外的一位随机性呢？直觉是：由于 f 难以求逆，其输入 x 的某些信息必然被隐藏。如果我们能提取出这个被隐藏的信息中的一位，并且这一位对于敌手来说看起来是完全随机的，那么我们就获得了扩展。

这正是硬核谓词的概念。

定义：对于一个函数 f，一个高效可计算的谓词 P: {0,1}^ → {0,1}* 是 f 的硬核谓词，如果对于任何多项式时间敌手 A，以下两个分布在计算上不可区分：

• (f(x), P(x))，其中 x 均匀随机。
• (f(x), U)，其中 x 均匀随机，U 是一个独立的均匀随机比特。

换句话说，给定 f(x)，敌手无法比随机猜测更好地预测 P(x)。

如果我们有一个单向置换 f 及其硬核谓词 P，那么我们可以立即构造一个伪随机生成器：
G(x) = (f(x), P(x))

为什么这是一个伪随机生成器？

1. 高效性和扩展性显然满足。
2. 伪随机性（使用下一比特不可预测性定义）：
   • 对于前 λ 位（即 f(x)），由于 f 是置换，它们本身就是均匀分布的，因此无法预测。
   • 对于最后一位（即 P(x)），根据硬核谓词的定义，无法以显著优于 1/2 的概率预测。

因此，问题归结为：我们能否为每个单向函数找到一个硬核谓词？

Goldreich-Levin 定理：通用硬核谓词

一个自然的问题是：是否每个单向函数都有一个简单的、确定性的硬核谓词（例如，其输入的第一位）？这是一个未解决的开放性问题。

然而，Goldreich 和 Levin 证明了一个非常强大的定理：

定理 (Goldreich-Levin)：对于任何单向函数 f，以下随机化谓词是一个硬核谓词：
P(x, r) = <x, r> = Σ_{i=1}^{|x|} x_i · r_i mod 2
其中 r 是一个与 x 等长的均匀随机字符串，<·,·> 表示点积（模2）。

这意味着，虽然我们可能不知道对于固定的 r，P_r(x) = <x, r> 是否是硬核的，但如果我们随机选择 r，那么对于任何多项式敌手，给定 f(x) 和 r，其成功计算出 <x, r> 的概率最多为 1/2 + negl(λ)。

利用这个随机化硬核谓词，我们可以构造最终的伪随机生成器：
G(x, r) = (f(x), r, <x, r>)
这个生成器接收 2λ 位输入 (x, r)，输出 2λ + 1 位，恰好扩展了一位。

证明概要 (将在下节课完成)：
证明的核心是一个归约。我们假设存在一个敌手 A，能够以概率 1/2 + ε（其中 ε 不可忽略）成功预测 <x, r>（给定 f(x) 和 r）。然后，我们将展示如何利用这个敌手 A 来构造另一个敌手 B，以不可忽略的概率 δ 逆转单向函数 f。这将与 f 是单向函数的假设矛盾。

• 直观上，如果 A 是完美的（总是正确），那么我们可以通过令 r 依次为 (1,0,0,...)、(0,1,0,...) 等，直接恢复出 x 的每一位。
• 难点在于处理 A 不完美的情况。证明将巧妙地使用概率论工具（如切尔诺夫界和杂交论证），仅利用 A 微小的成功优势，以不可忽略的概率恢复出 x 的大部分信息，从而完成求逆。

总结

本节课中我们一起学习了：

1. 回顾了伪随机生成器的定义及其在加密中的应用。
2. 明确了构造目标：从单向置换构造扩展一位的伪随机生成器。
3. 引入了硬核谓词这一核心概念，它能从单向函数中“榨取”出一位看似随机的信息。
4. 介绍了 Goldreich-Levin 定理，它为我们提供了一个适用于任何单向函数的通用（随机化）硬核谓词：<x, r> mod 2。
5. 基于此，给出了伪随机生成器的完整构造：G(x, r) = (f(x), r, <x, r>)。

下节课，我们将深入完成 Goldreich-Levin 定理的证明，展示如何将预测点积的敌手转化为逆转单向函数的敌手。请务必在课前复习相关的概率论知识。

005：伪随机生成器的构造与证明 🧠

在本节课中，我们将继续并完成伪随机生成器的构造及其证明。我们将从回顾上次内容开始，然后深入探讨如何从单向函数构造一个仅扩展1比特的伪随机生成器，并最终证明其安全性。

回顾与目标 🔄

上一节我们介绍了，为了构造一个伪随机生成器，只需构造一个能扩展1比特的伪随机生成器即可。因为如果存在一个扩展1比特的伪随机生成器 G，我们可以通过多次级联它来扩展到任意多项式长度。

然而，我们上次展示的归纳法证明看似合理，实则有误。在密码学中，当迭代次数 K 随安全参数增长时，严谨的证明通常需要借助混合论证。因此，我们的核心目标是：从一个单向置换构造一个仅扩展1比特的伪随机生成器。

构造思路 🛠️

假设我们有一个单向置换 f（即一个长度保持且是双射的单向函数）。构造伪随机生成器的关键在于找到一个硬核谓词。

• 硬核谓词：对于一个单向函数 f，如果存在一个谓词 p，使得给定 f(x)，任何多项式规模的敌手都无法以显著优于 1/2 的概率猜出 p(x)，那么 p 就是 f 的硬核谓词。

如果我们有了这样的硬核谓词 p，那么构造一个扩展1比特的伪随机生成器 G 就很简单了：

G(x) = (f(x), p(x))

这个构造满足“下一位不可预测性”。因为 f(x) 部分由于是置换而看起来随机，而给定 f(x) 后，p(x) 的不可预测性直接由硬核谓词的性质保证。

因此，问题的核心归结为：如何为任意单向函数 f 找到一个硬核谓词？

Goldreich-Levin 定理：一个通用的硬核谓词 🏆

Goldreich-Levin 定理提供了一个优美的答案：对于任何单向函数 f，以下随机化谓词都是一个硬核谓词：

p(x, r) = <x, r> = Σ (x_i * r_i) mod 2

其中 r 是一个与 x 等长的随机比特串，<x, r> 表示 x 和 r 的点积（模2加）。

这意味着，给定 f(x) 和随机串 r，任何敌手都无法以显著高于 1/2 的概率猜出 <x, r>。

利用这个定理，我们的伪随机生成器最终构造如下：

G(x, r) = (f(x), r, <x, r>)

这里，输入被分为 x 和 r 两部分。输出扩展了1比特（即 <x, r>）。

定理证明：核心思想与归约 ⚙️

现在，我们来证明 Goldreich-Levin 定理。证明采用密码学标准的归约法。

假设：存在一个多项式时间敌手 A，在给定 f(x) 和随机 r 后，能以概率 1/2 + ε(λ)（其中 ε 是不可忽略函数）成功预测 <x, r>。

目标：利用敌手 A 构造一个算法 B，使其能够以不可忽略的概率反转单向函数 f（即给定 y = f(x)，找出原像 x‘ 使得 f(x’) = y）。这将与 f 的单向性矛盾，从而证明原假设不成立。

第一步：聚焦“好”的输入

敌手 A 并非对所有 x 都表现良好。我们定义“好”的 x 为那些使得 A 预测成功率至少为 1/2 + ε/2 的输入。根据马尔可夫不等式，这样的“好” x 在全体输入中至少占 ε/2 的比例。算法 B 只需要成功处理这些“好”的 x 就足够了。

第二步：从预测比特到恢复原像（理想情况）

为了反转 f，我们需要恢复出 x。一个自然的想法是：如果我们能通过询问 A 来获得 x 的各个比特，就能拼出整个 x。

假设对于某个“好”的 x，A 的成功率非常高（例如 3/4 + ε/2）。那么对于每个比特位置 i，我们可以尝试以下方法恢复 x_i：

1. 随机选取 r。
2. 查询 A(f(x), r) 得到猜测值 b（应为 <x, r>）。
3. 查询 A(f(x), r ⊕ e_i) 得到猜测值 b‘（应为 <x, r ⊕ e_i>），其中 e_i 是第 i 位为1的单位向量。
4. 计算 b ⊕ b‘。由于 <x, r> ⊕ <x, r ⊕ e_i> = <x, e_i> = x_i，因此 b ⊕ b‘ 就是我们对 x_i 的猜测。

在 A 完美正确的情况下，这个方法能准确恢复 x_i。但 A 只是以较高概率正确。通过计算可知，单次这样猜测得到正确 x_i 的概率约为 1/2 + 2ε。为了提高正确率，我们可以独立重复此过程 K 次，然后对得到的 K 个猜测值取多数决。根据切尔诺夫不等式，只要 K 足够大（例如 K = λ/ε^2），多数决结果出错的概率是可忽略的。

对每个比特 i 都进行此过程，并通过联合边界考虑所有比特，我们就能以压倒性概率恢复出整个 x。

第三步：应对实际的成功概率

然而，我们实际的保证只是 1/2 + ε，而不是 3/4 + ε/2。上述方法在成功率较低时，单次猜测正确的优势太小，无法直接应用。

Goldreich-Levin 的核心创新在于以下思路：

1. 减少询问次数：我们不再对每个比特进行两次查询（r 和 r ⊕ e_i），而是只查询一次 A(f(x), r ⊕ e_i)。
2. 猜测缺失信息：对于另一次查询 A(f(x), r) 本应得到的结果 <x, r>，我们直接随机猜测一个值。
3. 利用线性结构：我们并不只猜测一个 r 对应的 <x, r>。而是随机选择 L 个线性无关的向量 r_1, ..., r_L，并随机猜测所有对应的 <x, r_1>, ..., <x, r_L>。虽然猜对所有 L 个值的概率只有 2^{-L}，但一旦猜对，我们就可以利用点积的线性性质，计算出所有形如 <x, r_J> 的值，其中 r_J 是 {r_1, ..., r_L} 的任意子集的异或。这样的 r_J 有 2^L 个。
4. 构造足够多的样本：我们令 L = O(log K)，这样我们就有 K 个（即 2^L 个）不同的 r_J 可供使用。对于每个比特 i，我们使用这 K 个 r_J 和对应的（计算出的）<x, r_J>，结合一次对 A 的查询 A(f(x), r_J ⊕ e_i)，来生成 K 个对 x_i 的独立猜测。
5. 应用切比雪夫不等式：虽然这 K 个猜测不再是完全独立的，但它们是两两独立的。对于两两独立的随机变量，我们可以使用切比雪夫不等式（而非切尔诺夫不等式）来证明，取多数决后，猜错 x_i 的概率仍然可以控制在较低水平。通过设置合适的重复次数 K（例如 K = O(1/ε^2)），可以使这个错误概率足够小。

最终，算法 B 以 2^{-L} = 1/K 的概率猜对所有初始值。在猜对的前提下，它能以常数概率恢复出 x。因此，B 整体反转 f 的概率约为 1/(常数 * K)，这是一个不可忽略的概率，从而完成了归约，证明了定理。

总结 📚

本节课我们一起学习了伪随机生成器构造的完整过程：

1. 我们明确了目标：从单向置换构造扩展1比特的伪随机生成器。
2. 我们引入了硬核谓词的概念，并指出它是构造的关键。
3. 我们介绍了 Goldreich-Levin 定理，它为我们提供了适用于任何单向函数的通用硬核谓词：<x, r>。
4. 我们深入探讨了该定理的证明思想，其核心是通过巧妙的归约，将“预测点积”的敌手转化为“反转单向函数”的算法。证明中运用了概率分析、混合论证（思想）、以及针对两两独立随机变量的切比雪夫不等式等工具。

至此，我们完成了从单向函数到伪随机生成器的理论构造。下一节，我们将探讨如何利用伪随机生成器来构造抵抗多消息窃听的加密方案。

006：多消息安全加密与伪随机函数

在本节课中，我们将学习如何构建一个能够安全加密多条消息的加密方案。我们将回顾之前方案的局限性，定义更强的安全概念（CPA安全），并引入一个核心工具——伪随机函数。

回顾与问题引入

上一节我们介绍了如何利用伪随机生成器（PRG）从单向置换构造加密方案。然而，我们目前得到的方案安全性仍有不足。

其原因是，该方案本质上只能安全地加密一条长消息。假设我们共享了一个密钥，并用它加密了一条消息。第二天，当我们想发送另一条消息时，密钥已经被用作一次性密码本（OTP）的填充，无法再次使用。因此，我们需要一个能够使用同一个密钥安全加密多条消息的方案。

我们的目标是：双方共享一个长度为λ比特的密钥后，能够加密任意多项式数量的消息（例如每条消息长度为λ比特），并且保证安全性。

多消息安全加密的初步构想

以下是实现多消息加密的一种思路：

1. 首次加密消息M1时，使用密钥K通过PRG扩展为K0和K1。
2. 使用K0与M1进行异或加密，得到密文C1。
3. 保留K1作为新的密钥状态。
4. 下次加密时，对新的密钥状态再次应用PRG，生成新的密钥对用于加密，并更新状态。

这个方案虽然能工作，但其主要缺点是有状态的。通信双方必须严格同步密钥状态（即记住已发送/接收了多少条消息）。一旦出现消息丢失或乱序，双方状态将不同步，导致无法正确加解密。因此，我们需要一个无状态的方案。

定义多消息安全加密

为了构建无状态方案，我们首先需要形式化定义“多消息安全”。

一个加密方案（包含加密算法Enc和解密算法Dec）被称为多消息安全的，如果对于任意多项式大小的敌手和任意多项式L(λ)（消息数量），敌手无法区分以下两种情况：

• 他得到的是消息M1, M2, ..., M_L在同一个随机密钥下的加密结果。
• 他得到的是另一组消息M1‘, M2‘, ..., M_L‘在同一个随机密钥下的加密结果。

其成功区分的优势是可忽略的。

然而，这个朴素定义存在一个明显问题：如果加密算法是确定性的（即对同一个密钥和消息总是输出相同的密文），那么敌手可以通过观察密文是否重复来轻易区分。例如，如果M1 = M2而M1‘ ≠ M2‘，那么第一组密文会出现两个相同的密文，而第二组则不会。

因此，要满足这个定义，加密算法必须是随机化的。每次加密即使对相同的明文，也会使用随机数产生不同的密文输出。

CPA安全：更强的安全定义

在实践中，我们通常采用一个更强的安全定义，称为选择明文攻击（CPA）安全。它不仅允许敌手获取多条消息的加密，还允许敌手自适应地选择这些明文——即可以根据之前看到的密文，来决定下一条要加密的明文是什么。

以下是CPA安全的游戏化定义：

1. 初始化：挑战者随机生成一个密钥K。
2. 查询阶段：敌手可以自适应地提交任意多条明文消息Mi，并获得对应的密文Ci = Enc(K, Mi)。
3. 挑战阶段：敌手提交两个等长的挑战明文M0*和M1*。
4. 挑战应答：挑战者随机选择一个比特b ∈ {0,1}，计算挑战密文C* = Enc(K, Mb*)并发送给敌手。
5. 猜测阶段：敌手在获得C*后（可以继续做加密查询，但不能再查询M0*或M1*的加密），输出一个猜测比特b‘。

敌手获胜的条件是猜对，即b‘ = b。

一个加密方案是CPA安全的，当且仅当对于所有多项式时间的敌手，其在此游戏中的获胜优势|Pr[b‘ = b] - 1/2|是可忽略的。

CPA安全定义比朴素的多消息安全定义更强，因为它允许敌手进行自适应的加密查询，这更贴近现实世界中敌手可以诱导诚实方加密特定消息的场景。

迈向构造：伪随机函数（PRF）

那么，如何构造一个CPA安全的加密方案呢？关键在于使用一个称为伪随机函数（PRF） 的密码学原语。

伪随机函数是一个密钥函数族{F_K}，其行为类似于一个真正的随机函数。具体来说，任何多项式时间的敌手都无法区分以下两种情况：

• 他拥有一个预言机（黑盒），该预言机在输入x时返回F_K(x)（K是随机且保密的密钥）。
• 他拥有一个预言机，该预言机在输入x时返回一个真正随机的函数R(x)的输出。

伪随机函数与伪随机生成器（PRG）不同：PRG从一个短种子扩展出一个长的伪随机串；而PRF则从一个密钥K和输入x，计算出一个固定长度的伪随机输出F_K(x)。

在下一节课中，我们将看到如何利用伪随机函数来构造CPA安全的加密方案，并探讨如何从一个伪随机生成器来构造伪随机函数。

总结

本节课中我们一起学习了：

1. 单消息安全加密方案的局限性，引出了对多消息安全加密的需求。
2. 定义多消息安全时，必须引入随机化加密以避免确定性加密的缺陷。
3. 引入了更强的CPA（选择明文攻击）安全定义，它通过一个交互游戏来刻画敌手在自适应选择明文攻击下的安全性。
4. 为了构造CPA安全的方案，我们指出了需要一个新的工具——伪随机函数（PRF）。

下一节，我们将深入探讨伪随机函数的定义、性质，并展示如何用它来构建我们所需的加密方案。

007：CPA安全加密与消息认证码

概述

在本节课中，我们将首先回顾并完成伪随机函数（PRF）的安全性证明，该函数是构建CPA安全加密方案的核心组件。随后，我们将转向一个全新的主题：消息认证码（MAC），探讨如何确保消息的完整性和来源真实性，这是加密之外另一个至关重要的安全目标。

伪随机函数（PRF）的安全性证明

上一节我们介绍了GGM构造，它可以从一个伪随机生成器（PRG）构建出一个伪随机函数（PRF）。本节中，我们将详细证明该构造的安全性。

PRF定义回顾

一个伪随机函数 F: {0,1}^λ × {0,1}^n -> {0,1}^λ 是高效可计算的。对于任何多项式时间的敌手，当给定预言机访问 F(K, ·)（其中K随机选择）或一个真正的随机函数时，敌手成功区分两者的概率是可忽略的。

GGM构造回顾

假设我们有一个将λ比特拉伸为2λ比特的PRG：G: {0,1}^λ -> {0,1}^{2λ}。
GGM构造的PRF F(K, x) 计算如下，其中 x = x1 x2 ... xn：

1. 从根密钥 K 开始。
2. 对于 i 从1到 n：
   • 计算 (K0, K1) = G(K)。
   • 根据 x_i 的值（0或1）选择下一步的密钥：若 x_i = 0，则令 K = K0；若 x_i = 1，则令 K = K1。
3. 最终的 K 即为输出 F(K, x)。

这可以看作是在一棵深度为 n 的二叉树中，根据输入 x 的比特序列选择路径，最终到达一个叶子节点，该节点的值就是输出。

安全性证明思路

证明采用反证法和混合论证。核心思想是：如果存在敌手A能区分GGM构造的PRF和真正的随机函数，那么我们可以利用A来构造一个敌手B，用于区分PRG的输出与真正的随机串，从而与PRG的安全性假设矛盾。

我们定义一系列混合实验 H_i（i 从0到 n）：

• 在 H_i 中，构造一棵深度为 n 的树。前 i 层的所有节点密钥都是真正随机选取的。从第 i+1 层开始，剩余树的构造方式与GGM完全相同（即使用PRG G 来生成子密钥）。
  • H_0 对应原始的GGM PRF（仅根密钥随机，其余均由PRG生成）。
  • H_n 对应真正的随机函数（所有叶子节点密钥都是随机独立的）。

根据假设，敌手A能区分 H_0 和 H_n，即区分优势是非可忽略的 ε。根据混合论证，n 个相邻混合实验 (H_i, H_{i+1}) 的区分优势之和至少为 ε。因此，存在某个索引 i，使得A区分 H_i 和 H_{i+1} 的优势至少为 ε/n。

证明的关键步骤与挑战

H_i 和 H_{i+1} 的唯一区别在于第 i+1 层的密钥：

• 在 H_i 中，第 i+1 层的 2^{i+1} 个密钥是由PRG G 作用于第 i 层的 2^i 个随机密钥生成的（即它们是“伪随机”的）。
• 在 H_i+1 中，第 i+1 层的 2^{i+1} 个密钥是直接随机选取的（即它们是“真随机”的）。

如果我们想利用A来攻击PRG G，一个自然的想法是：让挑战者给我们 2^{i+1} 个值，它们要么是 2^i 个PRG输出的拼接，要么是 2^{i+1} 个真随机串。然后我们试图用这些值来模拟 H_i 或 H_i+1 的预言机，并运行敌手A，根据A的输出判断挑战者给的是哪一类值。

挑战在于：i 可能很大，导致 2^{i+1} 是指数级的，而我们需要的敌手B必须是多项式时间的。

解决方案：观察到敌手A只能进行多项式次（设为 Q 次）预言机查询。在回答这些查询时，我们实际上只需要知道第 i+1 层中那些被A的查询路径所经过的节点对应的密钥（最多 2Q 个），而不是整个第 i+1 层的所有 2^{i+1} 个密钥。

因此，我们可以构造一个多项式时间的敌手B：

1. B从挑战者那里获得 Q 个值 (r_1, ..., r_Q)，每个值长度为 2λ。这些值要么全部是 G(.) 的输出（伪随机），要么全部是真随机串。
2. B需要模拟一个预言机给A运行。当A进行第 j 次查询 x 时：
   • B查看 x 的前 i 比特，确定其在第 i 层的对应节点。
   • 如果该节点对应的两个子密钥（在第 i+1 层）尚未被定义，B就用尚未使用过的 r_j 来定义它们（将 r_j 拆分为两个 λ 比特的密钥）。
   • 如果该节点的子密钥已被定义（因为之前的某次查询共享相同的前 i 比特前缀），则B复用已定义的密钥。
   • 一旦第 i+1 层的相应密钥被设定，B就可以通过继续模拟GGM树（使用PRG G）来计算最终输出，并返回给A。
3. 如果挑战者给B的是伪随机串，那么B完美模拟了 H_i。
4. 如果挑战者给B的是真随机串，那么B完美模拟了 H_i+1。
5. B输出A的猜测结果。

由于A能区分 H_i 和 H_i+1 的优势是非可忽略的 ε/n，因此B区分PRG输出与真随机串的优势也是非可忽略的（约为 ε/n）。这与PRG的安全性定义矛盾。因此，最初的假设不成立，GGM构造的PRF是安全的。

从保密到认证

到目前为止，我们课程的重点一直是保密性（Secrecy）。我们首先定义了伪随机生成器（PRG），用它构建了可加密比密钥更长消息的方案。然后，为了应对敌手观察多个密文的情况，我们引入了更强的CPA安全概念，并通过伪随机函数（PRF）实现了CPA安全的加密。

然而，保密性 alone 就足够了吗？考虑一个场景：即使敌手无法破译密文的内容（CPA安全），他仍然可能篡改密文。例如，将密文中某个比特翻转，导致解密后的明文发生特定改变（如将“进攻”改为“撤退”），这可能会造成灾难性后果。我们现有的基于“一次一密”思想的方案（使用PRG或PRF生成密钥流）很容易受到这种篡改攻击。

因此，我们需要引入一个新的安全目标：认证（Authentication）。认证的目标是确保接收方能够验证消息的完整性（未被篡改）和来源真实性（确实来自声称的发送方）。这与加密是正交的，可以单独或联合使用。

消息认证码（MAC）简介

消息认证码（Message Authentication Code, MAC）是一种用于实现认证的密码学原语。

MAC的定义

一个消息认证码方案由一组高效的算法定义，核心是一个标签生成函数 Mac：
Tag = Mac(K, M)
其中 K 是发送方和接收方共享的密钥，M 是消息，Tag 是生成的认证标签。

接收方在收到消息 M' 和标签 Tag' 后，通过重新计算 Mac(K, M') 并验证其结果是否等于收到的 Tag' 来判断消息是否真实有效。

MAC的安全目标

MAC的安全目标是：即使敌手能够观察到许多“消息-标签对” (M_i, Tag_i)，其中 Tag_i = Mac(K, M_i)，并且敌手可以自适应地选择消息 M_i 来获取其标签，敌手也无法为一个新的、未曾被查询过的消息 M* 伪造出一个有效的标签 Tag*（即满足 Tag* = Mac(K, M*)）。

形式化地，对于任何多项式时间敌手，其成功伪造标签的概率是可忽略的。

一个简单的MAC构造

一个非常直接且强大的MAC构造可以直接使用我们已学的伪随机函数（PRF）：
Mac(K, M) = F(K, M)
其中 F 是一个输出长度足够（例如λ比特）的伪随机函数。

直观理解：PRF F(K, ·) 像一个由密钥 K 控制的“随机映射”。敌手即使看到了对于 M_1, M_2, ..., M_q 的映射结果 F(K, M_1), ..., F(K, M_q)，也无法预测对于一个新消息 M* 的映射结果 F(K, M*)，因为这看起来就像一个随机值。因此，敌手伪造出正确标签的概率极低（约为 2^{-λ}）。

在下节课中，我们将正式证明基于PRF的MAC构造是安全的。

总结

本节课中我们一起学习了两个部分的内容：

1. 伪随机函数的安全性证明：我们深入分析了GGM构造，通过精巧的混合论证和“按需模拟”的技术，证明了其能够基于伪随机生成器构建出安全的伪随机函数。这是构建CPA安全加密方案的理论基石。
2. 消息认证码的引入：我们认识到仅靠保密性不足以应对所有威胁，消息可能被篡改。因此我们引入了认证的目标，并定义了消息认证码（MAC）。我们看到了一个简洁而有效的MAC构造——直接使用伪随机函数。这为我们在后续课程中系统学习认证技术奠定了基础。

从保密到认证，我们正在构建更全面的密码学工具箱。

008：数论基础教程

在本节课中，我们将学习密码学，特别是公钥密码学模块所需的核心数论概念。我们将从群论的基础知识开始，逐步深入到计算数论中的重要算法和定理，最后探讨一些关键的密码学假设。

群论基础

上一节我们介绍了课程概述，本节中我们来看看群论的基础知识。群是密码学中的一个核心代数结构。

一个群 (G, ·) 由一个集合 G 和一个二元运算 “·” 组成，该运算满足以下性质：

• 封闭性：对于所有 a, b ∈ G，运算结果 a · b ∈ G。
• 结合律：对于所有 a, b, c ∈ G，(a · b) · c = a · (b · c)。
• 单位元：存在一个元素 e ∈ G，使得对于所有 a ∈ G，有 e · a = a · e = a。
• 逆元：对于每个元素 a ∈ G，存在一个元素 b ∈ G，使得 a · b = b · a = e。

如果运算还满足交换律（对于所有 a, b ∈ G，有 a · b = b · a），则该群称为阿贝尔群。

以下是几个群的例子：

• 整数加法群：集合 Z（所有整数），运算为加法。单位元是 0，元素 a 的逆元是 -a。
• 模 n 加法群：集合 {0, 1, ..., n-1}，运算为模 n 加法。记作 Z_n。
• 模 n 乘法群：集合 {a | 1 ≤ a < n, gcd(a, n) = 1}，运算为模 n 乘法。记作 Z_n*。单位元是 1。

群的阶是指群中元素的数量，记作 |G|。
元素的阶是指满足 g^k = e 的最小正整数 k，其中 e 是单位元。

拉格朗日定理指出，在有限群中，任何元素的阶都整除群的阶。

如果一个群可以由单个元素生成，即群中每个元素都是某个特定元素 g 的幂，则该群称为循环群，g 称为生成元。

计算数论核心算法

上一节我们介绍了群论的基本概念，本节中我们来看看计算数论中几个至关重要的高效算法。

欧几里得算法与扩展欧几里得算法

两个整数 a 和 b 的最大公约数 (gcd) 是能同时整除 a 和 b 的最大正整数。

扩展欧几里得算法不仅能计算 gcd(a, b)，还能找到满足以下等式的整数 x 和 y（称为贝祖系数）：
ax + by = gcd(a, b)

该算法非常高效，时间复杂度为输入比特长度的多项式级。

模幂运算

问题：给定底数 g、指数 x 和模数 n，高效计算 g^x mod n。

朴素方法（连续相乘）的时间复杂度是 O(x)，即与指数值成正比，效率低下。

高效算法（平方乘算法）利用指数的二进制表示。算法步骤如下：

1. 将指数 x 表示为二进制形式。
2. 初始化结果 result = 1。
3. 遍历 x 的每个二进制位（从最高位到最低位）：
   • 将当前结果平方：result = result * result mod n。
   • 如果当前二进制位为 1，则将结果乘以底数 g：result = result * g mod n。
     此算法的时间复杂度为 O(log x)，即与指数的比特长度成正比。

中国剩余定理

中国剩余定理 (CRT) 提供了一种将模一个大合数 n 的运算，分解为模其互质因子幂的并行运算的方法。

设 n = p * q，其中 p 和 q 互质。CRT 指出，给定一个整数 x，以下两组信息等价：

• x mod n
• (x mod p, x mod q)

并且存在一个构造性方法，可以从 (x mod p, x mod q) 唯一地恢复出 x mod n。具体地，可以预先计算系数：
C_p = q * (q^{-1} mod p)
C_q = p * (p^{-1} mod q)
则 x mod n = ( (x mod p) * C_p + (x mod q) * C_q ) mod n。

CRT 可以推广到 n 有多个互质因子的情况，并能显著加速模 n 下的计算。

欧拉函数与循环群

上一节我们介绍了几个核心算法，本节中我们聚焦于模乘法群 Z_n* 及其性质。

欧拉函数

欧拉函数 φ(n) 定义为小于 n 且与 n 互质的正整数的个数。这正是乘法群 Z_n* 的阶，即 |Z_n*| = φ(n)。

如果 n 的质因数分解为 n = p1^{α1} * p2^{α2} * ... * pk^{αk}，则 φ(n) 的计算公式为：
φ(n) = n * (1 - 1/p1) * (1 - 1/p2) * ... * (1 - 1/pk)

特例：

• 若 p 是质数，则 φ(p) = p - 1。
• 若 n = p * q，且 p、q 为不同质数，则 φ(n) = (p-1)(q-1)。

欧拉定理与费马小定理

欧拉定理：如果 a 与 n 互质（即 a ∈ Z_n*），那么 a^{φ(n)} ≡ 1 (mod n)。

费马小定理是欧拉定理在 n 为质数 p 时的特例：如果 a 不能被 p 整除，那么 a^{p-1} ≡ 1 (mod p)。

循环群与生成元

一个阶为 m 的群 G 是循环群，当且仅当存在一个元素 g ∈ G，其阶恰好为 m。此时，g 称为生成元，G = {g^0, g^1, ..., g^{m-1}}。

一个重要结论是：模质数 p 的乘法群 Z_p* 是一个循环群。这意味着存在生成元 g，使得 Z_p* = {1, g, g^2, ..., g^{p-2}}。

Z_p* 中生成元的数量恰好是 φ(p-1)。由于 φ(n) 与 n 大致成正比，因此在 Z_p* 中随机选取一个元素，它是生成元的概率约为 φ(p-1)/(p-1) ~ 1 / log log(p)，这对于多项式时间采样是可行的。

然而，验证一个给定元素是否为生成元通常是困难的，因为这需要知道 p-1 的质因数分解（以检查 g^{(p-1)/q} ≠ 1 mod p 对所有 p-1 的质因子 q 成立）。一个实用的解决方案是使用安全质数：选择形如 p = 2q + 1 的质数 p，其中 q 也是质数。这样 p-1 的分解已知（2 * q），且其子群结构简单。

二次剩余与密码学假设

上一节我们讨论了循环群及其生成元，本节中我们将探讨二次剩余概念及其如何影响密码学中的困难性假设。

二次剩余

设 p 为奇质数，a ∈ Z_p。如果存在某个 x ∈ Z_p 使得 x^2 ≡ a (mod p)，则称 a 是模 p 的二次剩余 (QR)，否则称为二次非剩余 (QNR)。

关于二次剩余，有以下关键结论：

1. 数量：在 Z_p* 中，恰好有一半的元素是二次剩余，另一半是二次非剩余。即，有 (p-1)/2 个 QR 和 (p-1)/2 个 QNR。
2. 欧拉判别准则：a 是模 p 的二次剩余，当且仅当 a^{(p-1)/2} ≡ 1 (mod p)；a 是二次非剩余，当且仅当 a^{(p-1)/2} ≡ -1 (mod p)。这提供了一个高效的判定算法。
3. 求平方根：当 p ≡ 3 (mod 4) 时，a 的平方根可以直接计算为 ± a^{(p+1)/4} mod p。对于一般的 p，可以使用更复杂的算法（如 Tonelli-Shanks 算法）。

所有模 p 的二次剩余构成 Z_p* 的一个子群，记作 QR_p。其阶为 (p-1)/2。

密码学中的困难问题与假设

在循环群 G（例如 Z_p* 或其子群）中，我们关心以下几个计算问题及其关系：

1. 离散对数问题 (DLP)：给定生成元 g 和元素 h = g^x，求 x。

   • 假设：离散对数问题是困难的（没有多项式时间算法）。

2. 计算性迪菲-赫尔曼问题 (CDH)：给定 g, g^x, g^y，计算 g^{xy}。

   • 假设：CDH 是困难的。显然，如果能解决 DLP，就能解决 CDH，因此 CDH 假设强于 DLP 假设。

3. 判定性迪菲-赫尔曼问题 (DDH)：区分三元组 (g^x, g^y, g^{xy}) 和 (g^x, g^y, g^z)，其中 x, y, z 是随机选取的。

   • 假设：DDH 是困难的（即两个分布计算不可区分）。显然，如果能解决 CDH，就能解决 DDH，因此 DDH 假设强于 CDH 假设。

关键点：在完整的群 Z_p* 中，DDH 假设不成立。攻击者可以利用欧拉判别准则检查 g^x 和 g^y 是否为二次剩余。如果是，则 g^{xy} 也必定是二次剩余；而随机元素 g^z 是二次剩余的概率只有 1/2。这提供了一个有效的区分器。

解决方案：为了获得 DDH 困难的群，我们使用质数阶子群，例如安全质数 p=2q+1 下的二次剩余子群 QR_p。QR_p 的阶为 q（一个质数）。在质数阶群中，除了平凡子群 {1} 外没有其他真子群，因此上述基于子群成员测试的攻击失效。在这样的群中，DLP、CDH 和 DDH 都被认为是困难的假设。

总结

本节课中我们一起学习了公钥密码学所需的数论基础。我们从群的定义和基本性质出发，介绍了循环群、生成元和元素的阶。接着，我们探讨了计算数论中的关键工具：欧几里得算法、高效的模幂运算和中国剩余定理。然后，我们深入研究了模乘法群 Z_n，定义了欧拉函数，并阐述了欧拉定理和费马小定理。我们明确了 Z_p 是循环群，并讨论了生成元的分布与寻找。最后，我们讲解了二次剩余的概念，并分析了密码学中离散对数、计算性迪菲-赫尔曼和判定性迪菲-赫尔曼等困难问题之间的关系，指出了在 Z_p* 中 DDH 不成立的原因，并给出了使用质数阶子群（如安全质数下的 QR_p）来获得 DDH 困难群的标准解决方案。这些概念是理解后续公钥加密、数字签名和密钥交换协议的基础。

009：消息认证码与认证加密

在本节课中，我们将要学习消息认证码的构造证明，并深入探讨如何将加密与认证结合，构建一个同时提供机密性和完整性的认证加密方案。我们将介绍一个强大的安全概念——选择密文攻击安全，并证明一个具体的“先加密后认证”方案是满足该安全定义的。

消息认证码的构造证明

上一节我们介绍了消息认证码的基本定义。本节中我们来看看如何证明一个基于伪随机函数的构造是安全的。

一个简单的MAC构造是直接使用一个伪随机函数。具体来说，给定一个伪随机函数 F，密钥 k 和消息 m，其标签计算为 t = F(k, m)。验证时，只需重新计算并比较标签。

以下是证明该构造安全性的核心思路：

1. 根据伪随机函数的定义，敌手无法区分 F(k, ·) 和一个真正的随机函数。
2. 如果我们将PRF替换为随机函数，那么对于任何敌手未查询过的消息 m，其标签 t 在敌手看来是完全随机的。
3. 因此，敌手成功伪造一个有效标签的概率最多是 2^{-λ}（其中λ是安全参数），这是一个可忽略的概率。
4. 由于敌手无法区分PRF和随机函数，所以在原PRF构造中，其成功伪造的概率也必须是可忽略的。

这就完成了对基于PRF的MAC构造的安全性证明。

认证加密与CCA安全

到目前为止，我们分别学习了提供机密性的加密方案和提供完整性的消息认证码。但在实际应用中，我们通常需要同时保证两者。这种同时提供机密性和完整性的加密方案被称为认证加密。

一个直观的想法是简单地将加密和MAC组合起来。但组合方式至关重要。我们首先考虑一种不安全的组合方式：“加密并认证”，即独立地对同一消息进行加密和认证。这种方式可能泄露信息，因为MAC本身不提供隐私保证。

接下来，我们介绍一种安全的组合范式：“先加密后认证”。

先加密后认证方案

该方案使用两个独立的密钥：一个加密密钥 k_enc 和一个MAC密钥 k_mac。

• 加密过程：对于消息 m，首先使用加密方案计算密文 c = Enc(k_enc, m)，然后计算密文 c 的认证标签 t = Mac(k_mac, c)。最终的输出是 (c, t)。
• 解密过程：收到 (c, t) 后，首先验证标签 t 对于密文 c 是否有效。如果无效，则输出一个特殊的错误符号 ⊥；如果有效，则解密 c 得到消息 m = Dec(k_enc, c)。

这个方案的安全性基于一个更强的加密安全概念：选择密文攻击安全。

选择密文攻击安全

选择密文攻击安全是加密方案的“黄金标准”。其安全游戏赋予敌手非常强大的能力：

1. 敌手可以反复查询加密预言机，获得任意消息的加密结果。
2. 敌手可以反复查询解密预言机，获得任意密文（除挑战密文外）的解密结果。
3. 敌手选择两个挑战消息 m0 和 m1。
4. 挑战者随机选择一位 b ∈ {0,1}，将 mb 的加密结果（挑战密文）返回给敌手。
5. 敌手可以继续查询加密和解密预言机（但不能查询挑战密文本身的解密）。
6. 最终，敌手输出一个猜测 b‘。

如果对于所有多项式时间的敌手，其猜中 b 的概率与随机猜测（1/2）的差值是可忽略的，则该加密方案是CCA安全的。

“先加密后认证”方案的CCA安全性证明

现在，我们来证明上述“先加密后认证”方案是CCA安全的。证明的核心思想是分情况讨论，将CCA安全规约到底层MAC的不可伪造性和底层加密方案的CPA安全性上。

我们固定一个多项式时间的CCA敌手 A。定义事件 Δ：敌手 A 在游戏过程中，能够向解密预言机提交一个“新的”有效的密文-标签对 (c‘, t‘)。所谓“新的”，是指 c‘ 从未作为加密预言机的应答出现过。

证明分为两种情况：

情况一：事件 Δ 以不可忽略的概率发生

如果敌手能以不可忽略的概率伪造一个新的有效密文-标签对，那么我们可以构造一个敌手 B 来攻破底层MAC的不可伪造性。

B 的构造如下：

1. B 自己生成加密密钥，但MAC密钥由MAC挑战者提供。B 可以访问MAC标签预言机。
2. 当CCA敌手 A 请求消息 m 的加密时，B 先用自有的加密密钥加密得到 c，然后向MAC预言机查询 c 的标签 t，最后将 (c, t) 返回给 A。这完美模拟了加密预言机。
3. 为了模拟解密预言机，B 需要猜测 A 首次成功伪造新密文的时刻 j。
4. 对于 A 的前 j-1 次解密查询，B 直接返回 ⊥（因为根据假设，在首次成功前，所有新查询都无效）。
5. 对于第 j 次解密查询，B 将 A 提交的 (c‘, t‘) 直接作为自己的伪造输出，提交给MAC挑战者。

如果 B 猜对了首次成功伪造的索引 j，那么当 A 成功时，B 也成功攻破了MAC。由于 A 只能进行多项式次查询，B 猜对的概率是 1/poly(λ)。因此，如果 Δ 不可忽略，则 B 攻破MAC的优势也是不可忽略的，这与MAC的安全性假设矛盾。所以，情况一不可能发生。

情况二：事件 Δ 以可忽略的概率发生

这意味着，在绝大多数情况下，敌手 A 无法向解密预言机提交任何新的有效密文。因此，解密预言机对 A 来说几乎是“无用”的——对于任何新密文的查询，回答几乎总是 ⊥。

在这种情况下，我们可以构造一个敌手 B 来攻破底层加密方案的CPA安全性。

B 的构造如下：

1. B 自己生成MAC密钥，但加密密钥由CPA加密挑战者提供。B 可以访问CPA加密预言机。
2. 当 A 请求加密时，B 将消息转发给CPA加密预言机获得密文 c，然后用自有的MAC密钥计算标签 t，将 (c, t) 返回给 A。
3. 当 A 请求解密时，B 检查查询的密文 c‘ 是否在之前加密应答的列表中出现过。
   • 如果出现过且标签有效，则 B 返回对应的原始消息（因为这是它自己加密的，它知道消息）。
   • 如果 c‘ 是新的（不在列表中），则 B 直接返回 ⊥。
4. 当 A 提交挑战消息 (m0, m1) 时，B 将其转发给CPA挑战者，得到挑战密文 c，然后附加上自己的MAC标签 t，将 (c, t) 返回给 A。
5. B 继续如步骤3那样模拟解密预言机（当然，不允许解密挑战密文本身）。
6. 最终，B 输出 A 的猜测比特 b‘。

由于事件 Δ 发生的概率可忽略，B 的模拟与真实的CCA游戏之间只有可忽略的差异。因此，如果 A 能以不可忽略的优势 ε 攻破CCA安全，那么 B 攻破CPA安全的优势至少是 ε - negl(λ)，这也是不可忽略的，从而与加密方案的CPA安全性假设矛盾。

总结

本节课中我们一起学习了：

1. 证明了基于伪随机函数的MAC构造是安全的。
2. 介绍了认证加密的概念，并指出了简单组合方式可能不安全。
3. 提出了“先加密后认证”的安全构造范式。
4. 定义了强大的选择密文攻击安全模型。
5. 通过一个分情况的规约证明，展示了“先加密后认证”方案如何将其CCA安全性建立在底层MAC的不可伪造性和底层加密的CPA安全性之上。核心在于，如果敌手能滥用解密预言机，则意味着它能伪造MAC标签；如果不能，则解密预言机无效，安全规约到CPA场景。

这个证明展示了密码学中如何通过精妙的组合与规约，从较简单的原语构建出满足复杂安全需求的方案。

010：公钥密码学入门与签名方案

在本节课中，我们将要学习公钥密码学的基本概念，并重点介绍数字签名方案。我们将从对称密码学（如消息认证码MAC）的局限性出发，引出公钥密码学的核心思想——密钥的非对称性，并构建一个基于单向函数的签名方案。

---

对称密码学的局限性

上一节我们介绍了消息认证码（MAC）等对称密码学原语。在对称密码学中，Alice和Bob需要预先共享一个秘密密钥，以实现通信的保密性和完整性。然而，这种共享密钥的假设在实际应用中存在重大缺陷。

以下是共享密钥假设带来的主要问题：

1. 密钥分发困难：Alice和Bob必须通过安全信道（如线下会面）预先交换密钥，这在现代互联网环境中不切实际。
2. 可扩展性差：每个通信对都需要一个独立的共享密钥，管理复杂度随用户数量平方级增长。

这引出了一个核心问题：如果通信双方的所有交互都能被敌手Eve窃听，那么他们如何在不共享秘密信息的情况下，安全地进行通信？

公钥密码学的核心思想

Diffie和Hellman在1976年的开创性论文中，提出了公钥密码学的概念，彻底改变了这一局面。他们的核心思想是利用了加密和认证过程中的非对称性。

在加密场景中：

• 加密操作（任何人都可以执行）与解密操作（只有接收者可以执行）是不同的。
• 生成认证标签（MAC）的操作（只有发送者可以执行）与验证标签的操作（任何人都可以执行）也是不同的。

Diffie和Hellman的解决方案是将传统的单一密钥拆分为一对密钥：

• 公钥：可以公开给任何人，用于加密或验证。
• 私钥：必须由所有者秘密保存，用于解密或签名。

这种非对称性使得通信双方无需预先共享秘密，即可建立安全通信。

数字签名的定义

数字签名是公钥密码学中，对应于对称密码学中MAC的原语。它允许签名者使用其私钥为消息生成一个“签名”，而任何拥有对应公钥的人都可以验证该签名的有效性。

一个签名方案由以下三个算法构成：

1. 密钥生成算法 Gen(1^λ) → (vk, sk)：输入安全参数λ，输出一个验证密钥（公钥）vk和一个签名密钥（私钥）sk。
2. 签名算法 Sign(sk, m) → σ：输入签名密钥sk和消息m，输出一个签名σ。
3. 验证算法 Verify(vk, m, σ) → {0, 1}：输入验证密钥vk、消息m和签名σ，输出1（接受）或0（拒绝）。

正确性要求：对于合法生成的密钥对和签名，验证必须通过。即：
Pr[Verify(vk, m, Sign(sk, m)) = 1] = 1

签名的安全性

签名的安全性与MAC的安全性定义类似，但关键区别在于敌手获得了公开的验证密钥vk。

以下是安全游戏的过程：

1. 挑战者运行Gen(1^λ)生成(vk, sk)，并将公钥vk发送给敌手A。
2. 敌手A可以适应性地向挑战者查询最多多项式次数的消息m_i，并获得对应的签名σ_i = Sign(sk, m_i)。
3. 最终，敌手A输出一个伪造的(m*, σ*)。

敌手A获胜的条件是：

• Verify(vk, m*, σ*) = 1
• 消息m*从未被查询过（即m* ∉ {m_i}）

如果一个签名方案能抵抗所有多项式时间的敌手，则称其是存在不可伪造的。

Lamport一次性签名方案

现在，我们来看一个基于单向函数构造的具体签名方案——Lamport一次性签名方案。该方案只能安全地签名一条消息。

假设我们有一个单向函数f: {0,1}^λ → {0,1}^λ，消息空间为{0,1}^n。

密钥生成算法 Gen(1^λ)：

1. 对于i = 1 to n 和 b ∈ {0,1}，随机选择x_{i,b} ← {0,1}^λ。
2. 计算y_{i,b} = f(x_{i,b})。
3. 私钥sk为所有x_{i,b}，公钥vk为所有y_{i,b}。

签名算法 Sign(sk, m)：
对于一条n比特消息m = (m1, m2, ..., mn)，签名σ由对应于消息每个比特的私钥部分组成：
σ = (x_{1, m1}, x_{2, m2}, ..., x_{n, mn})

验证算法 Verify(vk, m, σ)：
将签名解析为(x‘_1, x’_2, ..., x‘_n)。对于每个i，检查是否满足：
f(x‘_i) = y_{i, mi}
如果所有检查都通过，则输出1，否则输出0。

安全性直觉：
为了伪造一个不同消息m*的签名，敌手必须在至少一个位置i上，提供y_{i, m*_i}的原像x_{i, m*_i}。由于敌手只知道另一个比特(1 - m*_i)对应的原像，且f是单向函数，因此敌手无法成功伪造。

从固定长度到任意长度：哈希后签名

Lamport方案只能签名固定长度（n比特）的消息。为了签名任意长度的消息，我们可以结合使用抗碰撞哈希函数。

设H: {0,1}* → {0,1}^n是一个抗碰撞哈希函数，(Gen, Sign, Verify)是一个能签名n比特消息的签名方案。

我们可以构造一个新的签名方案(Gen‘, Sign’, Verify‘)如下：

• Gen‘(1^λ)：运行Gen(1^λ)得到(vk, sk)，并选择一个哈希函数H。新公钥为(vk, H)，私钥为sk。
• Sign‘(sk, m)：计算h = H(m)，输出σ = Sign(sk, h)。
• Verify‘((vk, H), m, σ)：计算h = H(m)，输出Verify(vk, h, σ)。

安全性论证：
如果敌手能伪造新方案下消息m*的签名，则有两种情况：

1. H(m*)等于某个之前查询过的H(m_i)。由于m* ≠ m_i，这构成了哈希函数H的一个碰撞，与H的抗碰撞性矛盾。
2. H(m*)是一个全新的哈希值。那么，敌手实际上就伪造了原签名方案下对于哈希值H(m*)的签名，从而打破了原方案的安全性。

因此，只要原签名方案安全且哈希函数抗碰撞，新方案就是安全的。

---

本节课中我们一起学习了公钥密码学的起源和核心思想，形式化定义了数字签名方案及其安全性，并构建了基于单向函数的Lamport一次性签名方案。最后，我们通过“哈希后签名”的技巧，将只能签名固定长度消息的方案，提升为能处理任意长度消息的方案。在下一讲中，我们将探讨如何克服“一次性”的限制，构建多消息安全的签名方案。

011：从一次性签名到多次签名

在本节课中，我们将学习如何将一个仅安全一次的数字签名方案，扩展成一个可以安全签署多次消息的方案。我们将介绍一种基于树形结构的构造方法，并利用伪随机函数（PRF）来高效地生成和管理密钥。

---

数字签名方案回顾

上一节我们定义了数字签名方案及其安全性。一个签名方案包含三个算法：密钥生成、签名和验证。其安全性被称为“在适应性选择消息攻击下的存在性不可伪造性”。这意味着，即使攻击者能够自适应地选择消息并获得其签名，他也无法伪造一个从未被查询过的新消息的合法签名。

我们之前已经看到了拉波特（Lamport）构造，但它仅能安全地签署一次消息。此外，拉波特方案的密钥长度大于消息长度。为了构建多次安全的方案，我们需要一个密钥长度小于消息长度的一次性签名方案。哈希后签名（Hash-and-Sign）范式可以帮助我们实现这一点，它允许我们签署任意长度的消息，只需先将其哈希成一个固定长度的摘要。

---

从一次性到多次：核心思路

本节中，我们来看看如何将一次性安全的签名方案，转化为多次安全的方案。核心思想是构建一个密钥的认证树。

线性链思路（低效版）

一个直观的想法是使用一条验证密钥链：

1. 签名者首先生成一个根验证密钥 VK0。
2. 当需要签署第一个消息 M1 时，签名者生成一对新密钥 (SK1, VK1)。
3. 签名者使用 SK0 对 (M1, VK1) 进行签名，并将 (M1, VK1, 签名) 发送给验证者。
4. 之后，签名者“更新”其当前有效密钥为 VK1。
5. 签署第二个消息 M2 时，重复此过程：生成 (SK2, VK2)，用 SK1 签署 (M2, VK2)，并发送 (M2, VK2, 签名)。

问题：这种方法导致签名长度随着签署消息的数量线性增长，并且签名者需要记住所有已生成的密钥（状态庞大）。

树形结构思路

为了解决线性增长的问题，我们引入二叉树结构。假设我们要签署的消息长度为 λ 比特（例如，λ=256）。

1. 在树根，我们有一个根验证密钥 VK_ε（ε 表示空字符串）。
2. 根节点有两个子节点，对应比特 0 和 1，分别有密钥 (SK0, VK0) 和 (SK1, VK1)。我们用 SK_ε 对 (VK0, VK1) 进行签名，以认证这两个子密钥。
3. 每个子节点（如 VK0）又可以生成自己的两个子节点（VK00, VK01），并用 SK0 对它们进行认证。
4. 以此类推，构建一棵深度为 λ 的二叉树。树的每个叶子节点对应一个唯一的 λ 比特路径（例如，路径 011...0 对应叶子 VK_{011...0}）。
5. 要签署消息 M（即一个 λ 比特串），我们使用对应的叶子密钥 SK_M 直接对消息 M 本身进行签名。
6. 为了向验证者证明叶子密钥 VK_M 是合法的（即来自根密钥），我们需要提供从根到该叶子的路径上所有节点的“兄弟节点验证密钥”以及认证它们的签名。这构成了一个认证路径。

优点：

• 每个密钥（包括根、内部节点和叶子）都只使用一次来签署一个“消息”（对于内部节点，消息是其两个子验证密钥；对于叶子，消息是实际数据）。
• 签名长度与树深度 λ 成正比，而不是与签署的消息总数成正比。
• 验证者是无需状态的。

遗留问题：签名者仍然需要预先生成并存储整棵巨大的树（大小为 2^λ），这是不现实的。

---

高效构造：按需生成与伪随机函数

上一节我们看到了树形结构的优势，但存在存储开销巨大的问题。本节中，我们通过伪随机函数（PRF）来实现密钥的按需、确定性生成，从而解决存储问题。

我们假设拥有以下组件：

1. 一个一次性签名方案 (Gen, Sign, Ver)，其消息空间足够大（至少能容纳两个验证密钥）。
2. 一个伪随机函数 F，其输入为长度不超过 λ 的字符串，输出为 λ 比特。

构造多次安全签名方案 (Gen*, Sign*, Ver*)

密钥生成 Gen*：

• 运行一次性方案的 Gen() 生成根密钥对：(SK_ε, VK_ε)。
• 随机选择伪随机函数的密钥 K。
• 输出：
  • 验证密钥 VK* = VK_ε
  • 秘密签名密钥 SK* = (SK_ε, K)

签名 Sign*(SK*, M)，其中 M = m1 m2 ... mλ：

1. 对于 i = 1 到 λ：
   • 计算路径前缀 pref = m1...m_{i-1}。
   • 使用 PRF 作为随机性，生成该节点及其兄弟节点的密钥：
     • r_0 = F(K, pref||0)， r_1 = F(K, pref||1)
     • (SK_{pref||0}, VK_{pref||0}) = Gen(r_0)
     • (SK_{pref||1}, VK_{pref||1}) = Gen(r_1)
   • 使用 SK_{pref} 对兄弟验证密钥对 (VK_{pref||0}, VK_{pref||1}) 进行签名，得到 σ_i。
2. 使用叶子密钥 SK_M 对实际消息 M 进行签名，得到 σ_M。
3. 输出签名 Σ 为：
   • 叶子验证密钥 VK_M
   • 叶子签名 σ_M
   • 认证路径：对于每个 i，包含 (VK_{m1...m_{i-1}||0}, VK_{m1...m_{i-1}||1}, σ_i)

验证 Ver*(VK*, M, Σ)：

1. 首先，使用 Σ 中的 VK_M 验证叶子签名 σ_M 对于消息 M 是否有效。
2. 然后，逐层验证认证路径：
   • 对于每一层 i，使用 Σ 中提供的该层父节点验证密钥（对于第一层，就是根 VK_ε），验证签名 σ_i 是否正确地认证了该层的两个兄弟验证密钥。
   • 检查路径是否正确连接，即每一层选择的子密钥是否对应消息 M 的比特。
3. 如果所有验证均通过，则接受该签名。

---

安全性证明概要

我们方案的安全性基于一次性签名方案的安全性和伪随机函数的安全性。证明采用一系列游戏跳转（Game Hopping）：

1. 游戏0：真实攻击游戏，敌手 A 攻击我们构造的方案 (Gen*, Sign*, Ver*)。
2. 游戏1：将 Sign* 中使用的 PRF F(K, ·) 替换为一个真正的随机函数。如果敌手 A 在游戏0和游戏1中的成功概率有显著差异，我们就可以利用该差异构造一个区分器来攻破 PRF 的安全性。因此，在游戏1中，A 的成功概率仍然不可忽略。
3. 游戏2（归约核心）：在游戏1的基础上，我们构造一个模拟器 B，它试图攻破多个一次性签名实例。B 模拟游戏1的环境给 A：
   • B 为树中所有可能被 A 查询到的节点（由 A 的查询消息决定）预生成一次性密钥对。B 不知道这些密钥对应的秘密钥，但它拥有这些验证钥。
   • 当 A 请求对消息 M 签名时，B 需要提供认证路径上的签名。对于认证路径上的每个节点，B 向其对应的一次性签名实例的签名预言机查询，获得对兄弟验证钥的签名。
   • B 为叶子节点 M 生成一个一次性密钥对，并用其秘密钥对 M 签名（这部分 B 可以自己完成，因为此密钥只使用一次）。
4. 如果 A 最终输出了一个对于新消息 M* 的有效伪造签名，那么该伪造必然涉及树中某个节点密钥的滥用（因为每个密钥只应使用一次）。通过分析 M* 的路径，B 可以定位到被伪造的那个一次性签名实例（即该实例对应的密钥被用于签署了超过一个“消息”，或者其签名被伪造）。B 随后输出该实例上的伪造。
5. 由于在游戏1中 A 以不可忽略概率成功，因此 B 也能以不可忽略概率攻破其拥有的某个一次性签名实例。
6. 最后，通过混合论证，可以将攻破多个一次性实例的敌手 B，转化为攻破单个一次性签名方案标准安全定义的敌手。

这就完成了从我们构造方案的安全性到底层一次性签名方案安全性的归约。

---

总结

本节课中我们一起学习了如何构建一个安全的多次数字签名方案。

1. 我们首先回顾了一次性签名方案及其局限性。
2. 我们引入了树形结构，将一次性密钥组织起来，使得每个密钥仅使用一次，从而将一次性安全“放大”为多次安全。
3. 我们利用伪随机函数实现了密钥的按需、确定性生成，解决了树形结构带来的巨大存储开销问题，得到了一个高效的构造。
4. 最后，我们概述了该构造的安全性证明思路，其安全性可规约到底层一次性签名方案和伪随机函数的安全性上。

这个基于树的构造是一个经典方法，它展示了如何利用较简单的密码学原语（一次性签名、PRF）来搭建功能更强的密码学工具。

012：公钥加密入门与密钥协商

在本节课中，我们将要学习公钥加密的基本概念，并重点介绍一个核心的构建模块——密钥协商协议。我们将从回顾对称加密的局限性开始，逐步过渡到公钥密码学的世界，并详细讲解基于数论假设的Diffie-Hellman密钥交换协议。

从对称加密到公钥加密

上一节我们介绍了如何仅从单向函数构建签名方案等密码学原语。本节中，我们来看看一个更强的密码学范式——公钥加密。

在对称加密中，通信双方需要预先共享一个秘密密钥。公钥加密的目标是，允许双方在不预先共享任何秘密的情况下，也能进行安全的加密通信。这就像是在公开的信道上“窃窃私语”。

密钥协商协议的目标

以下是密钥协商协议的核心目标：

• 参与者： 从未谋面的两方，爱丽丝和鲍勃。
• 信道： 他们通过一个公开的、不安全的网络进行通信，任何窃听者伊芙都能听到所有消息。
• 目标： 爱丽丝和鲍勃希望协商出一个共同的秘密密钥 K（例如，K ∈ {0,1}^λ）。
• 安全要求： 对于窃听者伊芙而言，即使她看到了所有通信内容，密钥 K 看起来也应该是完全随机的，她无法将其与一个真正的随机串区分开。

一旦双方协商出密钥 K，他们就可以使用对称加密、消息认证码等所有我们已经学过的工具进行安全通信。需要注意的是，不同的用途（如加密和认证）应使用从 K 派生出的不同密钥。

Diffie-Hellman密钥交换协议

Diffie和Hellman在1976年的开创性论文中首次提出了密钥协商的思想。其构造基于特定的代数结构（群）和计算困难性假设。

所需的数学背景

协议需要一个满足以下性质的有限群 G（例如，Z_p^* 中所有二次剩余构成的子群，其中 p 是一个安全素数）：

1. 运算高效： 给定群中任意元素 a 和 b，计算群运算 a * b 是高效的。
2. 求逆高效： 给定任意元素 g，计算其逆元 g^{-1} 是高效的。
3. 循环群： 群是循环的，即存在一个生成元 g，使得群中每个元素都可以表示为 g 的某次幂。
4. 离散对数困难： 对于随机生成元 g 和随机指数 x，给定 g 和 g^x，计算 x 是计算上不可行的。这定义了一个单向函数：f(g, x) = (g, g^x)。

我们特别要求群 G 的阶 q 是一个素数。这对于协议的安全性至关重要。

协议描述

假设爱丽丝和鲍勃已公开协商好一个素数阶 q 的循环群 G，以及它的一个生成元 g。

1. 爱丽丝： 选择一个随机数 a ← {1, ..., q}。计算 A = g^a 并发送给鲍勃。
2. 鲍勃： 选择一个随机数 b ← {1, ..., q}。计算 B = g^b 并发送给爱丽丝。
3. 共享密钥：
   • 爱丽丝收到 B 后，计算共享密钥 K = B^a = (g^b)^a = g^{ab}。
   • 鲍勃收到 A 后，计算共享密钥 K = A^b = (g^a)^b = g^{ab}。

安全性假设

协议的安全性依赖于判定性Diffie-Hellman假设：对于随机选择的 a, b, c，三元组 (g^a, g^b, g^{ab}) 与三元组 (g^a, g^b, g^c) 在计算上是不可区分的。

这意味着，窃听者伊芙看到 (g^a, g^b) 后，无法将共享密钥 g^{ab} 与一个随机的群元素区分开。该假设比离散对数假设更强。

从密钥协商到公钥加密

利用密钥协商协议，可以几乎直接构造出公钥加密方案，这就是El Gamal加密方案（1984年）。

公钥加密方案定义

一个公钥加密方案由三个概率多项式时间算法构成：

• 密钥生成 (Gen)： (pk, sk) ← Gen(1^λ)，生成公钥 pk 和私钥 sk。
• 加密 (Enc)： c ← Enc(pk, m)，使用公钥 pk 加密消息 m，得到密文 c。
• 解密 (Dec)： m/⊥ ← Dec(sk, c)，使用私钥 sk 解密密文 c，恢复消息或输出错误。

其安全性通常定义为选择明文攻击下的不可区分性：对于任何多项式时间的敌手，在获得公钥 pk 后，即使他选择了两条消息 m0 和 m1，也无法区分 Enc(pk, m0) 和 Enc(pk, m1)。加密必须是概率性的，否则无法满足此安全定义。

El Gamal加密方案构造

假设使用与Diffie-Hellman协议相同的群 G 和生成元 g。

• 密钥生成： 选择随机数 x ← {1, ..., q}。令公钥 pk = g^x，私钥 sk = x。这相当于爱丽丝提前发布了她的DH第一轮消息。
• 加密： 为了使用公钥 pk 加密消息 m（这里假设 m 是群 G 中的一个元素）：
  1. 选择随机数 r ← {1, ..., q}。
  2. 计算 c1 = g^r。
  3. 计算共享密钥 K = pk^r = (g^x)^r = g^{xr}。
  4. 计算 c2 = K * m（群运算）。
  5. 输出密文 c = (c1, c2)。
• 解密： 使用私钥 sk = x 解密密文 c = (c1, c2)：
  1. 计算共享密钥 K = c1^x = (g^r)^x = g^{xr}。
  2. 恢复消息 m = c2 * K^{-1}。

直观理解： 加密者扮演了DH协议中鲍勃的角色，他选择一个随机数 r，并利用接收者的固定“第一轮消息” pk = g^x 计算出临时共享密钥 g^{xr}，然后用它作为一次一密来掩盖消息。解密者利用私钥 x 可以从 c1 = g^r 中恢复出同一个共享密钥，从而解除掩盖。

总结

本节课中我们一起学习了公钥密码学的起点——密钥协商协议。我们首先明确了在不安全信道上建立共享密钥的目标，然后深入讲解了基于离散对数问题的Diffie-Hellman密钥交换协议及其所需的数据论背景。最后，我们看到了如何将密钥协商协议巧妙地转化为一个完整的公钥加密方案，即El Gamal加密。这标志着我们从仅需单向函数的“对称密码学乐园”，正式进入了需要更多特定数论假设的“公钥密码学隧道”。

013：第13讲

在本节课中，我们将要学习ElGamal加密方案的安全性证明，并探讨如何从陷门函数这一通用假设来构造公钥加密方案。

概述

上一节我们介绍了ElGamal加密方案。本节中，我们将首先证明该方案在选择明文攻击下的安全性，然后探讨如何基于更通用的陷门函数假设来构造公钥加密方案。

ElGamal加密方案回顾

ElGamal加密方案依赖于一个素数阶q的群G，其阶约为2^λ。群G有一个生成元g。

• 密钥生成：选择一个随机数s ∈ Z_q。公钥是g^s，私钥是s。
• 加密：给定公钥g^s和消息m（视为群元素），选择一个随机数r ∈ Z_q。密文为(g^r, g^{sr} · m)。
• 解密：给定私钥s和密文(c1, c2)，计算m = c2 · (c1^s)。

证明ElGamal的CPA安全性

我们将证明ElGamal加密方案在DDH假设下是CPA安全的。

CPA安全游戏回顾

在选择明文攻击游戏中：

1. 挑战者运行密钥生成算法，将公钥交给敌手A。
2. 敌手A输出两个等长的消息m0和m1。
3. 挑战者随机选择一个比特b ∈ {0,1}，加密mb得到挑战密文，并将其交给敌手A。
4. 敌手A输出一个猜测比特b‘。
   如果敌手A猜对的概率不超过1/2加上一个可忽略的量，则方案是CPA安全的。

归约证明

假设存在一个多项式时间的敌手A，能以概率1/2 + ε(λ)赢得CPA游戏，其中ε(λ)是不可忽略的。我们将构造一个算法B，利用A来打破DDH假设。

算法B的输入是一个三元组(g^a, g^b, g^c)，它需要判断c = a·b还是c是随机的。

以下是算法B的步骤：

1. 模拟公钥：算法B将g^{a作为公钥发送给敌手A。这模拟了一个有效的公钥g}s，其中s = a。
2. 接收挑战消息：敌手A输出两个消息m0和m1。
3. 模拟挑战密文：算法B随机选择一个比特b ∈ {0,1}。它构造挑战密文为(g^b, g^c · m_b)。注意，如果c = a·b，那么这个密文正是对m_b的有效加密（其中随机数r = b）；如果c是随机的，则密文的第二部分是随机的。
4. 接收猜测并输出：敌手A输出猜测比特b‘。算法B进行如下判断：
   • 如果b‘ = b，则算法B输出“DDH元组”。
   • 如果b‘ ≠ b，则算法B输出“随机元组”。

分析

现在分析算法B成功的概率。

• 当输入是DDH元组时（即c = a·b）：算法B完美地模拟了真实的CPA游戏。根据假设，敌手A猜对b的概率是1/2 + ε。因此，算法B输出“DDH元组”的概率也是1/2 + ε。
• 当输入是随机元组时（即c是随机的）：此时，挑战密文中的g^c · m_b是一个完全随机的群元素，与消息m_b无关。因此，敌手A无法获得任何关于b的信息，其猜对的概率是1/2。所以，算法B输出“DDH元组”的概率是1/2。

算法B区分DDH元组和随机元组的优势为(1/2 + ε) - 1/2 = ε，这是一个不可忽略的优势。这与DDH假设矛盾。因此，最初的假设不成立，ElGamal加密方案是CPA安全的。

---

上一节我们证明了基于DDH假设的ElGamal方案的安全性。本节中我们来看看一个基于更弱CDH假设的变体，并讨论陷门函数的概念。

基于CDH假设的ElGamal变体

原始的ElGamal方案需要DDH假设。我们可以修改方案，使其仅基于计算性Diffie-Hellman假设。

变体的加密过程如下：
选择随机数r ∈ Z_q，计算密文为 (g^r, H(g^{sr}) ⊕ m)。
其中H是一个将群元素映射到比特串的哈希函数，m是消息。

为了在标准模型下基于CDH假设证明安全，H可以选取一个硬核谓词。例如，Goldreich-Levin硬核谓词。它输出一个比特，使得即使给定g^r和g，该比特看起来也是随机的。这样，每次可以加密一个比特。通过逐比特加密，可以处理更长的消息。

在实践中，人们常使用输出更长的哈希函数H，并在随机预言机模型下论证安全性。虽然该模型下的证明不能直接推出标准模型下的安全性，但它是一个有用的启发式工具。

陷门函数

现在，我们探讨如何从通用假设——陷门函数——来构造公钥加密。

陷门函数族定义

一个陷门函数族由以下算法组成：

1. 密钥生成算法Gen(1^λ)：输出一个公用的哈希密钥hk和一个秘密的陷门td。
2. 函数求值：对于每个hk，定义一个函数f_hk: D_hk -> R_hk。存在高效算法，给定hk和x ∈ D_hk，可计算f_hk(x)。
3. 均匀采样：存在高效算法，给定hk，可从定义域D_hk中均匀采样元素x。
4. 陷门求逆：存在高效算法，给定陷门td和值y = f_hk(x)，可计算出原像x。这意味着函数是单射的。
5. 单向性：对于任何多项式时间敌手，在只给定hk和y = f_hk(x)（其中x是随机采样的）的情况下，计算出x的概率是可忽略的。

简单理解，陷门函数是一个单向函数，但掌握秘密陷门信息的人可以轻松逆转它。

从陷门函数构造加密方案

给定一个陷门函数族(Gen_F, f)，我们可以构造一个公钥加密方案：

• 密钥生成：运行Gen_F(1^λ)得到(hk, td)。公钥是hk，私钥是td。
• 加密(公钥hk, 消息m∈{0,1})：
  1. 从定义域D_hk中均匀采样x。
  2. 计算y = f_hk(x)。
  3. 选择一个随机向量r（与x等长），计算硬核谓词值r·x（点积模2）。
  4. 输出密文(y, (r·x) ⊕ m)。
• 解密(私钥td, 密文(y, c))：
  1. 使用陷门td，从y中恢复x = f_hk^{-1}(y)。
  2. 计算(r·x) = c ⊕ m‘，但这里需要知道r。注意，在加密中r是临时选择的，并未发送。因此，上述描述需要调整：实际上，r必须成为密文的一部分，或者通过其他方式确定。一个正确的构造是：密文为(y, r, c = (r·x) ⊕ m)。解密时，用td从y恢复x，然后计算(r·x) ⊕ c即可得到m。

安全性证明思路

该方案的安全性证明思路是归约到陷门函数的单向性。

1. 假设存在敌手A能攻破加密方案的CPA安全。
2. 我们构造算法B，试图计算硬核谓词r·x（给定hk, y=f_hk(x)和r）。
3. 算法B模拟CPA游戏给A：
   • 公钥就是hk。
   • 当A提交挑战消息m0, m1时，B随机选择b，并构造挑战密文。它利用自己的挑战y（作为f_hk(x)），并猜测硬核谓词的值d ∈ {0,1}，构造密文(y, d ⊕ m_b)。
   • B将两个可能的d值（0和1）对应的密文分别（或通过重绕技术）给A，观察A的猜测输出b‘。
4. 如果A能成功攻破CPA，那么当d猜对时，A输出正确b‘的概率会更高。算法B通过比较A在不同d下的表现，可以以不可忽略的优势预测出正确的硬核谓词值r·x。
5. 根据Goldreich-Levin定理，能够预测硬核谓词意味着能够逆转单向函数。这就与陷门函数的单向性假设矛盾。

因此，基于陷门函数族构造的加密方案是CPA安全的。

总结

本节课中我们一起学习了：

1. ElGamal加密方案在DDH假设下的CPA安全性证明。证明的核心是通过归约，将任何CPA攻击者转化为一个DDH区分器。
2. 基于更弱CDH假设的ElGamal变体，它利用了硬核谓词来保证安全性。
3. 陷门函数族的定义，它提供了在掌握秘密陷门时可逆的单向函数。
4. 如何从任何陷门函数族构造一个CPA安全的公钥加密方案，其安全性可归约到陷门函数的单向性。

下节课我们将探讨陷门函数族的具体构造实例。

014：陷门单向函数与公钥加密

在本节课中，我们将学习如何构造陷门单向函数，并了解如何利用它们构建CPA安全的公钥加密方案。我们将从回顾陷门单向函数族的定义开始，然后探讨基于数论假设的具体构造，包括Rabin函数、Goldwasser-Micali加密方案以及RSA函数。

陷门单向函数族定义回顾

上一节我们介绍了陷门单向函数族的概念，并展示了如何用它来构造CPA安全的公钥加密。本节中，我们首先回顾其正式定义。

一个陷门单向函数族包含以下算法：

• 密钥生成算法 (Gen)： 一个概率多项式时间算法，输入安全参数（一元表示），输出一个公钥（哈希密钥）hk和一个私钥（陷门密钥）tk。
• 函数族： 对于每个公钥hk，定义一个函数f_hk，其定义域和值域可能依赖于hk。
• 正向计算： 存在一个多项式时间算法，给定hk和输入x，可以计算f_hk(x)。
• 定义域采样： 存在一个多项式时间采样算法D，给定hk，可以输出一个在定义域上（统计接近或完全）均匀分布的样本x。
• 陷门求逆： 存在一个多项式时间求逆算法，给定陷门tk和函数值y = f_hk(x)，总能输出对应的原像x。
• 单向性： 对于任何多项式时间算法A，存在一个可忽略函数negl，使得当随机生成(hk, tk) <- Gen(1^λ)并随机采样x <- D(hk)时，A在给定hk和y = f_hk(x)后成功输出x的概率不超过negl(λ)。

从陷门函数到公钥加密

基于陷门单向函数族，我们可以按以下方式构造一个公钥加密方案（逐比特加密）：

• 密钥生成： 直接使用陷门函数族的Gen算法，公钥pk = hk，私钥sk = tk。
• 加密： 为了加密一个比特消息m ∈ {0,1}，发送方执行以下操作：
  1. 从定义域中随机采样x <- D(hk)。
  2. 选择一个随机串r（用于硬核谓词）。
  3. 计算密文c = (f_hk(x), r, GL(x, r) ⊕ m)。其中GL(x, r)代表Goldreich-Levin硬核谓词。
• 解密： 接收方使用陷门tk从f_hk(x)中恢复出x，然后计算GL(x, r) ⊕ m ⊕ GL(x, r) = m。

其安全性基于：对于不知道陷门的敌手，f_hk(x)隐藏了x，使得GL(x, r)在计算上不可区分于均匀随机比特，从而GL(x, r) ⊕ m构成了一个安全的“一次一密”。

未知阶群与数论基础

我们接下来的构造将依赖于更深入的数据论知识，特别是未知阶的群。

我们感兴趣的群是 Z_N^*，其中N = p * q，p和q是两个大素数。这与我们之前熟知的Z_p^*（p为素数）有根本区别：Z_p^*的阶（元素个数）p-1是已知的；而Z_N^*的阶φ(N) = (p-1)(q-1)在仅知道N的情况下是未知的。计算φ(N)等价于对N进行因式分解，这被认为是困难的。这种“未知阶”的性质将帮助我们构建陷门函数。

一个关键工具是中国剩余定理 (CRT)。它指出，群Z_N^*同构于直积群Z_p^* × Z_q^*。
这意味着：

• 对于任意c ∈ Z_N^*，可以唯一地映射到一对(a, b)，其中a = c mod p, b = c mod q。
• 反之，对于任意(a, b) ∈ Z_p^* × Z_q^*，存在唯一且可高效计算的c ∈ Z_N^*，使得c mod p = a且c mod q = b。
• 这种对应关系保持运算：c = a * b mod N 当且仅当 c mod p = a * b mod p 且 c mod q = a * b mod q。

Rabin陷门函数（热身）

我们首先看一个经典的陷门函数构造——Rabin函数。它是一个陷门单向函数，但不是单射。

• 密钥生成： 选择两个λ比特的素数p和q，计算N = p * q。输出公钥hk = N，陷门tk = (p, q)。
• 函数计算： 函数f_N: Z_N^* -> Z_N^*定义为 f_N(x) = x^2 mod N。

它满足陷门函数的要求：

1. 高效计算： 给定N和x，计算平方模N是容易的。
2. 定义域采样： 可以从Z_N^*中高效采样（例如，随机选择数并检查其与N互素）。
3. 陷门求逆（已知p, q）： 给定y = x^2 mod N和(p, q)，求逆过程如下：
   • 计算y模p的平方根a（满足a^2 ≡ y mod p）。
   • 计算y模q的平方根b（满足b^2 ≡ y mod q）。
   • 利用中国剩余定理，找到满足c ≡ a mod p且c ≡ b mod q的c ∈ Z_N^*，这个c就是y的一个平方根。
   • 由于在域Z_p^*和Z_q^*中，每个平方都有两个根（±a和±b），因此y在Z_N^*中恰好有四个平方根。利用陷门可以计算出所有四个原像。
4. 单向性（仅知N）： 如果存在算法能在仅知道N的情况下对f_N求逆（即给定随机y = x^2 mod N，找到一个原像），那么该算法可以用来分解N。因此，在因式分解困难的假设下，Rabin函数是单向的。

Rabin函数的主要问题是非单射性（每个输出有四个原像），这导致它不能直接用于之前描述的加密方案，因为解密时无法确定使用哪个原像来计算硬核谓词。

Goldwasser-Micali加密方案

为了使函数成为置换（单射），并基于此构建加密，Goldwasser和Micali提出了一个方案。

首先，我们需要调整Rabin函数。选择p和q为满足p ≡ q ≡ 3 mod 4的素数。在这种情况下，-1是模p和模q的非二次剩余。此时，如果我们把函数f_N的定义域和值域都限制在二次剩余的集合QR_N上（即所有x^2 mod N的集合），那么它就是一个置换。因为每个y ∈ QR_N在QR_N中只有一个原像（即那个同时是模p和模q二次剩余的原像）。

基于此，Goldwasser-Micali加密方案构造如下：

• 密钥生成： 与修改后的Rabin函数相同，选择p, q ≡ 3 mod 4，计算N = p * q。公钥pk = N，私钥sk = (p, q)。
• 加密（1比特消息b）：
  1. 随机选择一个x ∈ Z_N^*。
  2. 计算密文 c = (-1)^b * x^2 mod N。
     • 如果b=0，则c是一个二次剩余。
     • 如果b=1，则c是一个非二次剩余（因为乘以了-1）。
• 解密： 给定密文c，利用私钥(p, q)判断c是否为模N的二次剩余（通过分别判断c mod p和c mod q是否为二次剩余）。如果是，输出0；否则，输出1。

该方案的安全性基于二次剩余假设，即：给定一个合数N=pq，区分一个随机二次剩余和一个随机“伪二次剩余”（即在Z_p^*和Z_q^*中都是非二次剩余的元素）是困难的。值得注意的是，区分二次剩余和Z_N^*中的一般元素是容易的（例如利用雅可比符号），但Goldwasser-Micali方案巧妙地避开了这个问题。

RSA陷门单向置换

另一种使Rabin函数变为单射的思路是，不使用平方函数，而使用一个指数e，使得方程y = x^e mod N对于每个y有唯一解。这就是RSA函数的核心思想。

• 密钥生成： 选择两个大素数p和q，计算N = p * q。选择一个整数e > 1，使得gcd(e, φ(N)) = 1，即e与(p-1)(q-1)互质。计算d满足e * d ≡ 1 mod φ(N)。公钥pk = (N, e)，私钥sk = (N, d)（或(p, q)）。
• 函数计算： RSA函数定义为 f_{N,e}(x) = x^e mod N，其中x ∈ Z_N^*。
• 陷门求逆： 使用私钥d，计算 y^d mod N = (x^e)^d = x^{e*d} = x^{1 + k*φ(N)} ≡ x mod N。

RSA函数是一个陷门单向置换。其单向性依赖于RSA假设：对于随机大素数p, q生成的N和满足条件的e，给定随机y = x^e mod N，计算x是困难的。

在历史上，RSA最初提出的加密方案是确定性的（直接加密为c = m^e mod N），这并不安全。在实践中，通常使用类似于本节开头所述的随机化填充方案（例如OAEP）与RSA结合。有趣的是，对于RSA函数，其最低有效位被证明是一个硬核谓词，因此可以用于构造安全的加密方案，而无需引入额外的随机化硬核谓词（如Goldreich-Levin）。

总结

本节课中我们一起学习了：

1. 回顾了陷门单向函数族的定义及其构建公钥加密的通用方法。
2. 介绍了未知阶群Z_N^*和中国剩余定理作为重要的数论工具。
3. 详细分析了Rabin陷门函数，它基于因式分解的困难性，但因其非单射性不能直接用于标准加密。
4. 探讨了Goldwasser-Micali加密方案，它通过限制定义域将Rabin函数变为置换，其安全性基于二次剩余假设。
5. 介绍了RSA陷门单向置换，通过选择与φ(N)互质的指数e来确保单射性，其安全性基于RSA假设。

这些构造展示了如何将深奥的数论问题转化为实用的密码学原语，是现代公钥密码学的基石。

015：格基密码学入门 🧱

在本节课中，我们将学习格基密码学的基础知识。这是一种被认为能够抵抗量子计算机攻击的公钥密码学新方向。我们将从回顾之前学过的公钥加密方案开始，然后深入探讨基于“带错误学习”问题的加密方案。

---

回顾：从对称密码学到公钥密码学

上一节我们介绍了基于陷门单向函数的公钥加密通用构造。本节中，我们来看看几种具体的实现。

我们之前学习了几种公钥加密方案：

• ElGamal加密：基于DDH假设，可在任何群中实现。
• 基于因式分解的方案：例如Rabin陷门函数和RSA陷门置换。
• Goldwasser-Micali加密：基于二次剩余假设。

所有这些经典方案都面临一个共同问题：它们都能被量子计算机攻破。因此，我们需要寻找新的、能够抵抗量子攻击的数学基础。

---

迈向后量子密码学 🔮

由于量子计算机的潜在威胁，现有公钥密码体系在未来可能不再安全。我们需要转向基于不同数学难题的、被认为是“后量子安全”的密码方案。

格基密码学就是这样一个有前途的方向。它的优势包括：

1. 抗量子攻击：目前没有已知的有效量子算法能破解其核心难题。
2. 问题难度高：其依赖的数学问题在最坏情况下也被认为是困难的，并且可以归约到格上的标准难题。
3. 功能强大：能够构造诸如全同态加密等高级密码学原语。

接下来，我们将介绍格基密码学的核心计算假设。

---

核心难题：带错误学习 (LWE)

LWE问题是格基密码学的基石。我们可以通过一个“含噪线性方程”的类比来直观理解它。

假设我们有一个随机矩阵 A (尺寸为 m × n，元素在 Z_q 中) 和一个随机秘密向量 s (长度为 n，元素在 Z_q 中)。正常情况下，给定 A 和 b = A * s，我们可以轻松解出 s。

LWE问题则是在这个等式中加入一个小的随机噪声 e：
b = A * s + e

其中，噪声 e 的每个分量都是从某个分布 χ 中独立采样得到的（例如，在区间 [-B, B] 内均匀选取）。

LWE假设（判定性版本）指出：对于合适的参数 (n, q, χ)，元组 (A, b = A*s + e) 与均匀随机的 (A, u) 在计算上是不可区分的。

这意味着，即使看到多个这样的含噪方程，攻击者也无法将它们与纯粹随机的数据区分开来，更无法恢复出秘密 s。

---

参数选择与注意事项

LWE假设的安全性高度依赖于参数的选择：

• n：安全参数，通常与密钥长度相关。
• q：模数，通常为素数。
• χ (噪声分布)：不能太小（否则易受攻击），也不能太大（否则影响正确性）。一个典型选择是离散高斯分布或 bounded uniform 分布。
• B (噪声界)：需要满足 B << q/4，以确保解密正确性。

如果噪声太小，例如仅限于 {-1, 0, 1}，则存在“线性化攻击”，通过将方程视为高次方程组并引入新变量来求解。因此，噪声必须足够大以抵抗此类攻击。

---

从LWE到对称加密 🔐

LWE问题天然定义了一个单向函数：f(A, s, e) = (A, A*s + e)。根据LWE假设，给定输出，难以恢复输入 (s, e)。

利用这一点，我们可以构造一个简单的对称加密方案（密钥为 s）：

• 加密一个比特 m ∈ {0, 1}：
  1. 随机选取向量 a。
  2. 计算 b = a · s + e + m * ⌊q/2⌋。
  3. 密文为 (a, b)。
• 解密：
  1. 计算 b - a · s = e + m * ⌊q/2⌋。
  2. 若结果更接近 0，则输出 0；若更接近 ⌊q/2⌋，则输出 1。

正确性：只要噪声 |e| < q/4，解密就能成功。
安全性：在LWE假设下，该方案是CPA安全的。因为多次加密查询得到的 (a, a·s+e) 对看起来是随机的，从而完美隐藏了消息比特。

---

关键性质：加法同态性 ➕

上述对称加密方案具有一个美妙的性质：它是加法同态的。
假设有两个密文：

• c1 = (a1, b1 = a1·s + e1 + m1 * ⌊q/2⌋)
• c2 = (a2, b2 = a2·s + e2 + m2 * ⌊q/2⌋)

将它们相加：
c_add = (a1+a2, b1+b2) = (a1+a2, (a1+a2)·s + (e1+e2) + (m1 ⊕ m2) * ⌊q/2⌋)
得到的是 (m1 ⊕ m2) 的加密，但噪声也相应增大为 e1+e2。只要噪声累积不超过 q/4，解密仍能正确进行。

---

从对称加密到公钥加密 🗝️

上一节我们看到了基于LWE的对称加密及其同态性。本节中，我们将利用这个同态性，通过一个巧妙的思路构造出公钥加密方案。

这个构造由 Regev 提出，其核心思想如下：

1. 密钥生成：

   • 私钥 sk：一个随机向量 s。
   • 公钥 pk：许多个“0”的对称加密。即，随机生成一个矩阵 A 和噪声向量 e，计算 b = A * s + e。公钥就是 (A, b)。这可以看作是 m 个独立的“0”的加密：(第i行A, 第i行b) 加密了0。

2. 加密（消息比特 m ∈ {0,1}）：

   • 随机选择一个比特向量 r ∈ {0, 1}^m。
   • 计算：
     c0 = r * A （一个向量）
     c1 = r * b + m * ⌊q/2⌋
   • 密文为 (c0, c1)。
   • 直观理解：这相当于从公钥的 m 个“0”的密文中，随机选取一部分（由 r 指示）加起来，然后再叠加上消息 m。由于同态性，加起来的密文仍然是“0”的加密，再加上 m 就得到了 m 的加密。

3. 解密：

   • 使用私钥 s 计算：c1 - c0 · s = (r * b + m⌊q/2⌋) - (r * A) · s = r * e + m⌊q/2⌋。
   • 与对称加密方案一样，检查结果更接近 0 还是 ⌊q/2⌋ 来恢复消息 m。

安全性直觉：

• 公钥 (A, b) 在LWE假设下看起来是均匀随机的。
• 对于挑战密文 (c0 = rA, c1 = rb + m*⌊q/2⌋)，根据LWE假设，(A, b) 可被替换为均匀随机的 (A, u)。此时，c1 变成了 r * u + m*⌊q/2⌋。
• 根据剩余哈希引理，当 m 足够大时，(A, rA, r*u) 统计接近均匀分布，从而完美隐藏了消息比特 m。因此，在LWE假设下，该公钥加密方案是CPA安全的。

---

总结

本节课中我们一起学习了：

1. 后量子密码学的动机：现有公钥密码体制面临量子计算威胁。
2. 格基密码学的核心：引入了带错误学习 (LWE) 这一平均情况下的困难问题，它是构建后量子密码协议的基础。
3. 从LWE到加密：我们首先构建了一个CPA安全的对称加密方案，并观察到其具有加法同态性。
4. Regev公钥加密方案：利用同态性，通过将公钥设置为多个“0”的密文，并让加密者随机组合它们来加密消息，我们巧妙地构造出了一个CPA安全的公钥加密方案。其安全性最终依赖于LWE假设和剩余哈希引理。

格基密码学是一个丰富而活跃的领域，LWE问题及其变体是构建多种高级密码学应用（如下节课将探讨的全同态加密）的基石。

016：全同态加密入门 🧩

在本节课中，我们将学习一个被称为“全同态加密”的强大密码学概念。我们将从回顾一个熟悉的加密方案开始，然后定义全同态加密，并最终构建一个具体的方案。

课程回顾：格密码与Regev加密

上一节我们介绍了格密码学的基础。本节中，我们来看看其核心假设——带错误学习（LWE）问题，以及基于它的Regev加密方案。

LWE 假设

LWE 假设与四个参数相关：

• n：安全参数。
• q：模数，通常远大于 n。
• m：方程数量，是 n 的多项式。
• χ：错误分布，生成小范数的错误向量。

该假设指出：给定一个随机矩阵 A ∈ ℤq^(m×n) 和一个秘密向量 s ∈ ℤq^n，那么向量 b = A s + e（其中 e 的每个分量独立从 χ 中采样）与均匀随机向量 u ∈ ℤq^m 在计算上是不可区分的。

用公式表示即：
(A, A s + e) ≈_c (A, u)

Regev 加密方案

现在，我们以另一种对后续有用的符号来回顾Regev加密方案。

• 公钥生成：公钥是一个矩阵 B ∈ ℤq^(m×(n+1))。它可以被视为由两部分组成：一个随机矩阵 A ∈ ℤq^(m×n) 和一个列向量 A s + e。根据LWE假设，B 看起来是随机的。
• 加密：要加密一个比特 μ ∈ {0, 1}，选择一个随机比特向量 r ∈ {0, 1}^m。密文 c 计算如下：
  c = r B + μ g
  其中 g 是一个“小工具”向量：g = (0, 0, ..., 0, ⌊q/2⌋) ∈ ℤq^(n+1)。
• 解密：解密时，使用秘密向量 t = (-s, 1) ∈ ℤq^(n+1)。计算：
  c t = r (B t) + μ (g t)
  由于 B t = e（一个小错误），且 g t = ⌊q/2⌋。因此：
  • 若 μ = 0，则结果为小值（接近0）。
  • 若 μ = 1，则结果为 ⌊q/2⌋ 加上一个小值，是一个大值。
    通过判断结果的大小即可解密。

值得注意的是，Regev方案对于异或（XOR）操作是同态的。两个密文相加，解密后得到的是它们对应明文的异或。

迈向全同态加密

我们已经见过对特定操作（如XOR或群乘法）同态的方案。但我们想要一个能同时支持加法和乘法的方案，并且是在模2运算下。这是因为任何高效的可计算函数（多项式时间图灵机）都可以用仅包含模2加法和模2乘法门的多项式大小电路来表示。

如果加密方案对模2加法和乘法都是同态的，那么它就能同态地计算任何高效函数，这非常强大。

全同态加密的定义

一个（关于电路类 C 的）同态加密方案由四个高效算法组成：Gen, Enc, Dec, Eval。

以下是核心要求：

1. 正确性：对于任何电路 C ∈ C 和任何消息 μ₁, ..., μₗ，以极高的概率满足：
   Dec(sk, Eval(pk, C, Enc(pk, μ₁), ..., Enc(pk, μₗ))) = C(μ₁, ..., μₗ)
2. 语义安全：基础的 (Gen, Enc, Dec) 方案必须是CPA安全的。Eval 算法不影响安全性。
3. 紧凑性：Eval 算法输出的密文长度必须独立于被计算电路 C 的大小。这是防止平凡构造（例如，Eval 直接输出电路 C 和所有输入密文）的关键。

一个能同态计算任何多项式大小电路的方案被称为全同态加密。

GSW 全同态加密方案

现在，我们开始构建 Gentry, Sahai, Waters (GSW) 方案，这是一个基于LWE假设的相对简单的全同态加密方案。

基础构造

GSW方案与Regev方案惊人地相似。

• 密钥生成：

  • 生成一个随机矩阵 A ∈ ℤq^(m×n)。
  • 生成秘密向量 s ∈ ℤq^n 和错误向量 e（来自分布 χ）。
  • 计算 b = A s + e。
  • 公钥 pk 是矩阵 B = [A | b] ∈ ℤq^(m×(n+1))。
  • 私钥 sk 是向量 t = (-s, 1)。
    （这与Regev方案完全相同）。

• 加密：
  要加密一个比特 μ ∈ {0, 1}，选择一个随机短整数矩阵 R ∈ {0, 1}^(m×m)。密文 C 现在是一个矩阵：
  C = R B + μ G
  其中 G 是一个扩展的“小工具”矩阵。一个简单的构造是令 G = I ⊗ g，即一个分块对角矩阵，每个对角块都是向量 g = (0, ..., 0, ⌊q/2⌋)。实际上，G 是一个容易求逆的特定矩阵，其逆运算能提取出 ⌊q/2⌋ 的倍数。

• 解密：
  解密时，计算：
  C t = (R B) t + μ (G t) = R e + μ (⌊q/2⌋ · 1)
  这里 1 是一个所有元素为1的向量。通过检查结果向量中元素是否接近 0 或 ⌊q/2⌋ 来解密 μ。

同态操作

GSW方案的同态性非常直观：

• 加法：给定两个密文矩阵 C₁ 和 C₂（分别加密 μ₁ 和 μ₂），其和 C₊ = C₁ + C₂ 满足：
  C₊ t = (R₁+R₂) e + (μ₁+μ₂)(⌊q/2⌋ · 1)
  这解密为 μ₁ + μ₂ (mod 2)。因此，密文矩阵的加法对应明文的模2加法。
• 乘法：给定两个密文矩阵 C₁ 和 C₂，其积 Cₓ = C₁ · G⁻¹(C₂) 是一个关键操作。这里 G⁻¹(·) 是 G 矩阵的某种近似逆函数，能将矩阵映射为小范数矩阵。可以验证：
  Cₓ t ≈ C₁ · (G⁻¹(C₂) t) ≈ μ₁ μ₂ (⌊q/2⌋ · 1) + 更大的错误项
  因此，Cₓ 解密为 μ₁ · μ₂ (mod 2)。密文矩阵的（近似）乘法对应明文的模2乘法。

错误增长与自举

每次同态操作，特别是乘法，都会增加密文中的错误（噪声）。经过一定深度的电路计算后，错误可能增长到无法正确解密的程度。

为了解决这个问题，Gentry提出了“自举”技术。其核心思想是：将一个能够解密自身（或另一个密文）的电路同态地应用到已加密的私钥上，从而生成一个新的、错误更小的密文，这个新密文加密的是相同的消息。这个过程就像给密文“刷新”了一样。通过自举，只要初始方案能同态地计算其自身的解密电路（加上一些额外操作），就能实现任意深度的同态计算，从而实现全同态加密。

总结

本节课中我们一起学习了全同态加密的基本概念。我们从回顾基于LWE的Regev加密方案开始，然后定义了全同态加密所需满足的正确性、安全性和紧凑性要求。最后，我们探讨了GSW全同态加密方案的核心构造思想，它通过将密文扩展为矩阵并定义矩阵上的加法和特定乘法来实现对明文比特的模2加法和乘法的同态计算。我们还简要提到了错误管理的关键——自举技术。全同态加密使我们能够在加密数据上直接进行任意计算，为隐私保护云计算等应用提供了强大的基础工具。

017：同态加密（第二部分）🚀

在本节课中，我们将继续学习同态加密，特别是GSW构造。我们将了解如何对密文进行同态加法和乘法运算，并探讨噪声增长问题以及如何通过“自举”技术实现完全同态加密。

---

回顾GSW构造 🔄

上一节我们介绍了GSW同态加密方案的基本构造。本节中，我们首先快速回顾一下密钥生成、加密和解密过程。

密钥生成

公钥是一个矩阵 B，它由两部分组成：

• 一个随机矩阵 A ∈ ℤ_q^{m × n}
• 一个向量 A·s + e，其中 s 是秘密向量，e 是来自误差分布 χ 的小噪声向量。

因此，公钥 B = [A | A·s + e]。

为了方便，我们将秘密向量视为 t = [-s, 1]。这样，B·t = e 是一个小噪声向量。

加密

为了加密一个比特 μ ∈ {0, 1}：

1. 选择一个随机的 0/1 矩阵 R ∈ {0, 1}^{N × m}，其中 N = ⌈log q⌉。
2. 计算密文 C = R·B + μ·G。

这里的 G 是一个固定的“小工具矩阵”，其作用是帮助解密。

解密

要解密密文 C：

1. 计算 C·t = (R·B + μ·G)·t = R·e + μ·(G·t)。
2. 结果是一个向量。如果 μ = 0，该向量所有坐标都很小（接近0）；如果 μ = 1，则至少有一个坐标较大（接近 q/2）。通过检查坐标的大小即可恢复消息 μ。

这个过程的正确性依赖于误差 e 和矩阵 R 都很小，使得 R·e 仍然是一个小噪声。

---

同态加法 ➕

现在，我们来看看如何对密文进行同态加法运算。

假设有两个密文：

• C₁ = R₁·B + μ₁·G，加密了消息 μ₁
• C₂ = R₂·B + μ₂·G，加密了消息 μ₂

同态加法的计算非常简单，就是直接将两个密文相加：

C₊ = C₁ + C₂ = (R₁ + R₂)·B + (μ₁ + μ₂)·G

结果 C₊ 加密的消息是 (μ₁ + μ₂) mod q。注意，这里是模 q 加法，而不是我们最终想要的模 2 加法。不过，一旦我们实现了同态乘法，就可以利用模 q 加法和模 2 乘法来构造模 2 加法。

噪声增长

相加后的新密文中，噪声也相应相加了。如果原来两个密文的噪声界分别为 σ₁ 和 σ₂，那么新密文的噪声界大约为 σ₁ + σ₂。每次加法操作，噪声都会线性增长。

---

同态乘法 ✖️

同态乘法是更复杂也更有趣的部分。我们的目标是，给定加密了 μ₁ 和 μ₂ 的密文 C₁ 和 C₂，计算出一个加密了 (μ₁ · μ₂) mod 2 的新密文。

一个朴素的想法是直接计算 C₁ · C₂，但这在维度和噪声处理上都行不通。GSW方案采用了一个巧妙的技巧。

核心技巧：二进制分解与重组

我们引入两个函数/矩阵：

1. 比特分解函数 H：它将 ℤ_q 中的元素分解为其二进制表示。对于一个矩阵，H 作用于其每个元素，将矩阵“展平”成一个元素仅为 0 或 1 的更大矩阵。
2. 小工具矩阵 G：它是 H 的（近似）逆操作。满足性质：对于任意矩阵 C，有 H(C)·G ≈ C。具体来说，G 是一个固定矩阵，其作用是将二进制向量“重组”回 ℤ_q 中的数。

乘法计算

同态乘法的计算定义为：

C_× = H(C₁) · C₂

让我们验证其正确性。假设 C₂·t = e₂ + μ₂·(G·t)，那么：

C_×·t = H(C₁) · C₂·t = H(C₁)·e₂ + μ₂·H(C₁)·(G·t)

由于 H(C₁)·G ≈ C₁，并且 C₁·t = e₁ + μ₁·(G·t)，我们可以得到：

C_×·t ≈ (某个小噪声) + μ₂·(e₁ + μ₁·(G·t)) = (最终的小噪声) + (μ₁·μ₂)·(G·t)

因此，C_× 确实（在噪声允许的误差下）加密了乘积 μ₁·μ₂。

噪声增长

乘法操作的噪声增长比加法剧烈得多。粗略来说，如果输入密文的噪声界为 σ₁ 和 σ₂，输出密文的噪声界会增长到大约 N·σ₂ + σ₁，其中 N = ⌈log q⌉。每次乘法操作，噪声都可能被放大一个因子 N。

---

噪声管理与自举技术 🌀

从上面的分析可以看出，随着同态运算的进行，密文中的噪声会不断增长。当噪声过大时，解密就会失败。这似乎限制了我们可以计算的电路深度。

为了解决这个问题，实现完全同态加密（即支持任意深度电路），Craig Gentry 提出了一个革命性的思想：自举。

自举的核心思想

自举的目标是“刷新”一个噪声过大的密文，将其转换为一个加密相同消息但噪声较小的新密文。

思路如下：

1. 假设我们有一个公钥 pk 对应的秘密钥 sk。
2. 我们提前生成一个“自举密钥”，它实际上是用 pk 加密 sk 的每一个比特得到的一组密文。即 Bootstrapping Key = { Enc_pk(sk[0]), Enc_pk(sk[1]), ... }。
3. 当我们有一个噪声很大的密文 C（加密了消息 μ）时，我们并不直接解密它（因为噪声太大可能出错）。
4. 相反，我们在密文空间下同态地执行解密电路。这个电路的输入是秘密钥 sk（但这里输入的是其加密形式，即自举密钥），硬编码的输入是待刷新的密文 C。电路的功能是输出 Decrypt_sk(C)，也就是消息 μ。
5. 由于同态计算的性质，这个电路的输出结果 C‘ 就是一个用 pk 重新加密的消息 μ 的新密文。

为何有效？

关键在于，解密电路 Decrypt_sk(C) 是一个非常简单的电路（主要是一些内积运算和阈值比较），其深度很浅（例如 O(log n)）。因此，即使用噪声较大的自举密钥作为输入，同态地计算这个浅层电路所产生的新噪声也是可控的、较小的。这样，我们就得到了一个加密相同消息但噪声被“重置”到低水平的新密文。

循环安全性假设

自举技术需要一个关键假设：公开“用公钥加密其对应私钥”的密文是安全的。这被称为循环安全性或密钥相关消息安全性。这是一个比标准LWE更强的假设，但目前我们不知道如何仅基于标准LWE构造完全同态加密。

一种避免循环安全性的方法是使用多级密钥链，但会导致公钥规模随电路深度线性增长，不够优雅。

---

总结 📝

本节课中我们一起学习了：

1. GSW同态加密方案的同态加法和乘法操作。
2. 加法操作简单直接，但噪声线性增长；乘法操作利用比特分解函数 H 和小工具矩阵 G 实现，噪声增长更显著（近似乘以因子 N）。
3. 噪声的累积限制了可同态计算的电路深度。
4. 自举技术通过同态执行解密电路，可以将噪声过大的密文“刷新”为低噪声密文，从而实现任意深度的计算，即完全同态加密。
5. 自举技术依赖于循环安全性假设，这是当前许多FHE方案的基础。

通过结合浅层的同态运算和周期性的自举刷新，我们最终能够构建支持任意复杂计算的完全同态加密系统。

018：伪随机生成器（PRG）概述

在本节课中，我们将要学习密码学中的一个核心概念——伪随机生成器。我们将了解它的定义、安全要求以及如何在实际中应用它。

上一节我们介绍了密码学的基本目标，本节中我们来看看如何利用伪随机性来增强加密方案的安全性。

伪随机生成器的定义

伪随机生成器是一个确定性算法，它能够将短的、随机的种子扩展成一个长的、看似随机的输出序列。其核心思想是，对于任何高效的观察者来说，PRG的输出应与真正的随机字符串无法区分。

以下是伪随机生成器的形式化定义：

• 输入：一个长度为 n 的随机种子 s。
• 输出：一个长度为 l(n) 的字符串，其中 l(n) > n。
• 要求：对于所有概率多项式时间的区分器 D，存在一个可忽略的函数 negl(n)，使得：
  | Pr[ D(G(s)) = 1 ] - Pr[ D(r) = 1 ] | ≤ negl(n)
  其中，概率空间是随机种子 s 和随机字符串 r（长度为 l(n)）。

构建安全的加密方案

现在，我们来看看如何利用一个安全的伪随机生成器来构建一个安全的加密方案。其基本思路是用PRG的输出作为一次性密码本的密钥流。

以下是使用PRG构建加密方案的步骤：

1. 密钥生成：发送方和接收方共享一个长度为 n 的随机种子 s，作为密钥。
2. 加密过程：为了加密一条长度为 l(n) 的消息 m，发送方计算 c := G(s) ⊕ m，其中 ⊕ 表示按位异或操作。
3. 解密过程：接收方使用相同的种子 s 重新计算 G(s)，然后计算 m := c ⊕ G(s) 来恢复原始消息。

这个方案的安全性基于一个关键论点：如果 G 是一个安全的伪随机生成器，那么上述加密方案在窃听者存在的情况下是安全的。因为对于攻击者而言，密文 G(s) ⊕ m 与一个真正的随机字符串 r ⊕ m 是无法区分的，而后者的安全性等同于一次性密码本。

实现注意事项

在实现和使用伪随机生成器时，有一些重要的细节需要确保。

以下是几个关键的实现要点：

• 种子必须保密且随机：整个方案的安全性完全依赖于种子 s 的机密性和随机性。如果种子被泄露或可预测，那么加密就会被完全攻破。
• 种子不可重复使用：与一次性密码本的原则类似，同一个种子 s 绝不能用于加密多条消息。否则，攻击者可以通过分析多个密文来获取信息。
• 确保算法一致性：在加密和解密两端，必须使用完全相同的伪随机生成器算法 G 和相同的初始种子 s，才能正确恢复消息。

本节课中我们一起学习了伪随机生成器的基本概念、形式化定义，以及如何利用它来构建一个安全的加密方案。我们了解到，PRG的核心价值在于它能用短的随机种子生成长的、看似随机的比特串，从而在保证安全性的前提下，克服了完美保密加密中密钥必须与消息等长的限制。记住，安全性的基石始终是种子的机密性和随机性。

019：交互式证明与零知识证明入门

在本节课中，我们将要学习密码学中一个非常强大的概念：证明系统。我们将从经典的“证明”概念出发，探讨其局限性，并引入革命性的“交互式证明”和“零知识证明”概念。我们将看到，通过允许证明者和验证者进行对话，并引入随机性，我们可以构建出比传统证明强大得多的系统，甚至能够在不泄露任何额外信息的情况下证明一个陈述的真实性。

从经典证明到交互式证明

上一节我们介绍了在通信中确保真实性和保密性的方法，以及全同态加密如何允许对加密数据进行计算。然而，当我们把数据和计算外包给可能不可信的服务器时，一个新的问题出现了：我们如何知道服务器正确地执行了计算？

这正是证明系统要解决的问题。在接下来的几节中，我们将展示如何让一个不可信的平台执行一个庞大的计算，并提供一个非常简洁的“证书”来证明其输出结果的正确性。更一般地说，我们可以将任何证明转化为简洁的证明，并且在不泄露任何信息的情况下证明我们想证明的事情。

首先，让我们回顾一下计算机科学中最基本的概念之一：NP类。

NP类：可高效验证的证明

NP类是所有语言的集合，其中每个语言都满足：存在一个多项式时间验证算法R（称为NP关系），使得对于任意字符串x，x属于该语言当且仅当存在一个长度多项式规模的“证据”或“见证”w，满足关系R(x, w)输出1。

用公式描述如下：
语言 L ∈ NP 当且仅当 ∃ 多项式 p 和高效算法 R，使得 ∀ x, x ∈ L ⇔ ∃ w, |w| ≤ p(|x|) 且 R(x, w) = 1。

你可以将验证算法R看作验证者，证据w看作一个证明。因此，NP类本质上就是那些成员资格可以被一个多项式长度的证明所验证，并且该证明能被一个多项式时间算法所检查的语言集合。

在计算机科学中，直到20世纪80年代中期，人们始终认为证明就是一系列逻辑推导的序列。然而，这一切被零知识证明的概念改变了。

零知识证明的初步构想

零知识证明的目标是：证明者在不透露“为什么”陈述为真的任何信息的情况下，让验证者相信该陈述为真。作为密码学家，我们不仅想加密信息，还想“加密”我们的证明——我们想让验证者知道定理为真，但仅此而已。

一个自然的定义是：验证者除了知道陈述为真之外，没有学到任何新信息。等价地说，验证者可以自行生成他所看到的整个证明过程。如果他可以自行生成，那么他显然没有从证明者那里学到任何新东西。

然而，这个定义似乎只适用于那些验证者自己就能高效验证的语言（即P类语言）。对于NP类中的难题，验证者无法自行高效找到证明，因此这个定义显得过于局限，无法得到有意义的正面结果。

突破：交互式证明系统

为了突破这个局限，Goldwasser、Micali和Rackoff在20世纪80年代中期引入了交互式证明的概念。他们彻底改变了我们对“证明”的思考方式。

一个交互式证明系统由两部分组成：

1. 一个证明者算法 P（可以是任意强大的，甚至是“巫师”）。
2. 一个概率多项式时间验证者算法 V。

以下是交互式证明系统的定义核心：

完备性：如果陈述为真（x ∈ L），并且证明者是诚实的，那么验证者以高概率（例如 ≥ 2/3）接受。
可靠性：如果陈述为假（x ∉ L），那么对于任何（即使是恶意的）证明者策略，验证者以低概率（例如 ≤ 1/3）接受。

用公式描述如下：
完备性：Pr[〈P, V〉(x) 输出“接受”] ≥ c (例如 2/3)，对于所有 x ∈ L。
可靠性：Pr[〈P, V〉(x) 输出“接受”] ≤ s (例如 1/3)，对于所有 x ∉ L 和所有 P。

其中，c和s是常数，关键是c > s。通过顺序重复执行协议多次，并采用多数表决，我们可以将完备性概率提升到接近1，而将可靠性错误降低到可忽略的程度。

交互式证明的强大之处在于验证者的随机性。如果验证者是确定性的，那么证明者就可以预先模拟整个对话，交互也就失去了意义。正是验证者不可预测的随机挑战，使得证明系统获得了超出传统NP证明的能力。

一个例子：图非同构的交互式证明

让我们通过一个具体的例子来感受交互式证明的威力：证明两个图是非同构的。图同构问题（判断两个图是否可以通过重命名顶点变得相同）是NP问题，但其补集——图非同构问题——我们不知道是否存在简短的传统NP证明。

然而，我们可以为图非同构设计一个简单的交互式证明协议：

1. 验证者V随机选择两个图G0, G1中的一个，记为Gb (b ∈ {0, 1})。
2. V对Gb的顶点进行一个随机置换，得到一个新图H，并将H发送给证明者P。
3. 证明者P需要判断H究竟是由G0还是G1置换而来的，并回答一个值b‘。
4. 验证者检查是否b‘ == b。如果是，则接受；否则拒绝。

我们来分析这个协议：

• 如果G0和G1确实非同构，那么H只会与G0和G1中的一个同构。全能的证明者P可以（尽管可能需要很长时间）分辨出H是哪个图的置换，从而总是能给出正确的b‘。完备性满足。
• 如果G0和G1同构，那么H在统计上看与G0和G1都同构，不包含任何关于b的信息。即使证明者是全能的，他也只能随机猜测，答对的概率只有1/2。通过重复多次，验证者以极低概率被欺骗。可靠性满足。

这个协议展示了交互式证明如何允许一个多项式时间的验证者，被一个（计算能力强大的）证明者说服一个可能没有简短传统证明的陈述。

定义零知识证明

现在，我们回到最初的目标：零知识。我们希望交互式证明不仅是可靠的，还能保证“零知识”——即验证者除了陈述为真外，学不到任何信息。

一个针对NP语言L的交互式证明系统是零知识的，如果对于每个有效的实例x及其对应的见证w，存在一个概率多项式时间模拟器S，满足以下条件：

对于所有 x ∈ L 和对应的有效见证 w，模拟器 S(x) 输出的模拟对话 Transcript_S 与实际协议中诚实验证者 V 与拥有 w 的诚实证明者 P 交互后看到的视图 View_V〈P(w), V〉(x) 是计算不可区分的。

用公式描述其核心思想：
∃ PPT 模拟器 S，使得 {S(x)} 与 {View_V〈P(w), V〉(x)} 计算不可区分。

这个定义被称为诚实验证者零知识。它意味着，如果一个验证者老老实实地遵循协议，那么他看到的整个交互过程，都可以由一个只知道公开输入x（而不知道秘密见证w）的模拟器在多项式时间内生成。因此，验证者不可能从交互中学到任何超出x本身的信息。

更强的安全模型：抗恶意验证者的零知识

然而，诚实验证者的定义还不够强。一个恶意的验证者V*可能不会遵循协议，他可能会使用任意的策略来试图从证明者那里榨取信息。

因此，完整的零知识定义要求：
对于任意概率多项式时间的恶意验证者 V，都存在一个概率多项式时间的模拟器 S，使得对于所有 x ∈ L 和对应的有效见证 w，模拟器 S（与 V 交互）输出的结果，与实际中 V 与诚实证明者 P(w) 交互后的视图，是计算不可区分的。*

此外，一个更健壮的定义还需要考虑辅助输入。即，恶意验证者可能在协议开始前就拥有一些与实例x相关的额外信息z（例如，从其他协议交互中泄露的）。零知识属性应该即使在这种情况下也成立，模拟器S也会获得同样的z。这确保了零知识协议在复杂环境下的可组合性。

总结与展望

本节课中我们一起学习了：

1. 经典证明的局限性：传统的NP证明要求提供完整的见证，这泄露了信息。
2. 交互式证明的引入：通过允许证明者和验证者进行多轮、包含随机性的交互，我们获得了更强大的证明系统，能够验证一些可能没有简短传统证明的陈述（如图非同构）。
3. 零知识证明的概念：目标是让验证者相信陈述为真，但又不泄露“为什么”为真的任何信息。其核心定义是：验证者所能看到的一切，都可以由他不知道见证的模拟器自行生成。
4. 定义的发展：从最初的“诚实验证者零知识”发展到更强的“抗恶意验证者零知识”并考虑“辅助输入”，以应对实际的攻击并保证协议的可组合性。

我们之前看到的图非同构协议，在直觉上就具有很强的零知识特性：验证者每次只是收到一个随机置换的图，并得到一个是/否的答案。他确实可以自行模拟这样的对话（只需随机生成一个图并随机猜测答案）。事实上，该协议可以被证明是（统计）零知识的。

在接下来的课程中，我们将看到如何为所有NP语言构造零知识证明，这依赖于密码学假设（如单向函数的存在）。我们还将探索交互式证明的惊人力量——它们所能验证的语言类远大于NP，达到了PSPACE。这一切都始于交互和随机性这两个简单而深刻的思想。

020：零知识证明的构造 🧠

在本节课中，我们将学习如何构造零知识证明。我们将从一个具体的语言（二次剩余）的简单构造开始，作为热身。然后，我们将探讨如何为所有NP语言构造零知识证明，核心思想是将其归约到一个NP完全问题（如图的三染色问题），并使用“数字保险箱”——即承诺方案——来实现。

---

二次剩余的零知识证明 🔢

上一节我们回顾了零知识证明的定义。本节中，我们来看看如何为一个具体的NP语言——二次剩余语言——构造一个零知识证明。

该语言定义为：
[
QR_N = { (N, y) \mid \exists x \in \mathbb{Z}_N^* \text{ 使得 } x^2 \equiv y \pmod{N} }
]
其中，见证（witness）是满足 (x^2 \equiv y \pmod{N}) 的 (x)。

以下是证明者（P，拥有见证 (x)）和验证者（V，拥有输入 ((N, y))）之间的协议：

1. P → V：证明者随机选择 (r \leftarrow \mathbb{Z}_N^*)，计算 (s = r^2 \mod N)，并将 (s) 发送给验证者。
2. V → P：验证者随机选择一个挑战比特 (b \leftarrow {0, 1})，并将其发送给证明者。
3. P → V：证明者根据 (b) 的值进行回复：
   • 如果 (b = 0)，则发送 (z = r)。
   • 如果 (b = 1)，则发送 (z = r \cdot x \mod N)。
4. V：验证者检查 (z^2 \equiv s \cdot y^b \pmod{N}) 是否成立。如果成立，则接受；否则拒绝。

协议分析

以下是该协议需要满足的性质：

• 完备性：如果 ((N, y) \in QR_N) 且双方都诚实执行协议，验证者总是接受。

  • 当 (b=0) 时，检查 (r^2 \equiv s \pmod{N})。
  • 当 (b=1) 时，检查 ((r \cdot x)^2 \equiv r^2 \cdot x^2 \equiv s \cdot y \pmod{N})。

• 可靠性：如果 ((N, y) \notin QR_N)（即 (y) 不是二次剩余），那么任何（计算能力无限制的）恶意证明者 (P^*) 最多只能以 (1/2) 的概率欺骗验证者接受。

  • 原因：对于恶意证明者发送的第一个消息 (s)，(s) 和 (s \cdot y) 不可能同时是二次剩余（否则 (y) 将是二次剩余）。因此，至少有一个挑战比特 (b) 的值（0或1）是恶意证明者无法正确回答的。由于验证者随机选择 (b)，欺骗成功的概率最多为 (1/2)。

• 零知识性（对诚实验证者）：我们首先证明协议对诚实验证者是完美零知识的。这意味着存在一个模拟器 (S)，即使不知道见证 (x)，也能生成与真实交互视图（Transcript）完全相同的分布。

  • 模拟器 (S) 的工作方式：
    1. 随机选择 (b' \leftarrow {0, 1})。
    2. 如果 (b' = 0)：随机选择 (z \leftarrow \mathbb{Z}_N^*)，计算 (s = z^2 \mod N)。输出视图 ((s, b=0, z))。
    3. 如果 (b' = 1)：随机选择 (z \leftarrow \mathbb{Z}_N^*)，计算 (s = z^2 / y \mod N)。输出视图 ((s, b=1, z))。
  • 为何有效：在真实协议中，当 (b=0) 时，(s) 是一个随机二次剩余，(z) 是其随机平方根；当 (b=1) 时，(z) 是随机值，(s) 是 (z^2/y) 也是一个随机二次剩余。模拟器生成的分布与之完全相同。

• 处理恶意验证者：对于可能不按协议随机选择 (b) 的恶意验证者 (V^*)（例如，(b) 可能是 (s) 的某个哈希函数值），模拟策略需要调整。

  • 模拟器 (S) 的工作方式：
    1. 随机猜测 (V^*) 将会输出的挑战比特 (b')。
    2. 根据上述对诚实验证者的模拟方法，生成对应的 ((s, b', z))。
    3. 将 (s) 提交给 (V^)（作为协议第一步），并接收 (V^) 实际选择的挑战比特 (b)。
    4. 如果 (b = b')，则成功，输出 ((s, b, z))。
    5. 如果 (b \neq b')，则回到步骤1重试。
  • 为何有效：因为模拟器生成的 (s) 是一个（与 (b') 无关的）随机二次剩余，恶意验证者 (V^) 从 (s) 中得不到任何关于 (b') 的信息。因此，(V^) 的挑战比特 (b) 以 (1/2) 的概率等于模拟器的猜测 (b')。期望在2次尝试内即可成功模拟。

提升可靠性

上述协议的单次可靠性误差为 (1/2)。为了达到可忽略的误差，我们需要重复执行协议。然而，并行重复可能会破坏零知识性。安全的做法是进行顺序重复。在顺序重复中，可以将前一轮的交互记录视为下一轮的辅助输入（auxiliary input (z)），而零知识定义本身要求即使给定辅助输入，模拟仍然可行，从而保证了顺序重复下零知识性得以保持。

---

所有NP语言的零知识证明 🎨

上一节我们为一个特定语言构造了零知识证明。本节中，我们来看看如何为所有NP语言构造零知识证明。核心思想是：因为NP完全问题可以归约到任何NP问题，所以我们只需为一个NP完全问题构造零知识证明即可。我们选择的问题是图的三染色问题。

语言 3-Colorable 定义为：
[
{ G(V, E) \mid \exists \text{染色方案 } c: V \rightarrow {1,2,3} \text{ 使得 } \forall (u,v) \in E, c(u) \neq c(v) }
]
其中，见证是一个合法的三染色方案 (c)。

物理世界协议（使用保险箱）

首先，我们描述一个使用物理“保险箱”的直观协议：

1. P → V：证明者拥有染色方案 (c)。他首先随机选择一个颜色排列 (\pi: {1,2,3} \rightarrow {1,2,3})，对染色进行“重命名”，得到 (\pi(c(v)))。然后，他为每个顶点 (v) 准备一个锁着的保险箱，里面放入该顶点重命名后的颜色值 (\pi(c(v)))。他将所有这些锁着的保险箱发送给验证者。
2. V → P：验证者随机选择一条边 ((u, v) \in E)，并将其发送给证明者。
3. P → V：证明者将保险箱 (u) 和保险箱 (v) 的钥匙发送给验证者。
4. V：验证者用钥匙打开两个保险箱，检查里面的颜色是否属于 ({1,2,3}) 且互不相同。如果是，则接受本轮；否则拒绝。

协议分析

以下是该协议的分析：

• 完备性：如果图是三染色的，且证明者诚实，验证者总是接受。
• 可靠性：如果图不是三染色的，那么任何染色方案至少存在一条边 ((u, v)) 两端颜色相同。验证者随机选中这条“坏边”的概率至少为 (1/|E|)。通过顺序重复该协议 (k \cdot |E|) 次（(k) 为安全参数），欺骗成功的概率可降至可忽略水平。
• 零知识性（直觉）：
  • 验证者每次只看到一条边上两个随机、互异的颜色（因为经过了随机排列 (\pi)）。这没有泄露任何关于原始染色方案 (c) 的信息。
  • 模拟器 (S) 的工作方式（对恶意验证者）：
    1. 随机猜测一条边 ((u', v'))。
    2. 为顶点 (u') 和 (v') 的保险箱随机放入两个互异的颜色（从 ({1,2,3}) 中选），其他保险箱可以任意填充（因为不会被打开）。
    3. 将所有这些保险箱发送给恶意验证者 (V^)，并接收 (V^) 实际选择的边 ((u, v))。
    4. 如果 ((u, v) = (u', v'))，则成功，提供这两个保险箱的钥匙。
    5. 如果不相等，则回到步骤1重试。
  • 由于保险箱不透明，(V^*) 无法获知模拟器预设的是哪条边，因此猜中的概率为 (1/|E|)。期望在 (|E|) 次尝试内即可成功模拟出与真实交互不可区分的视图。

从物理到数字：承诺方案

上述协议依赖于“物理保险箱”。在数字世界，我们使用承诺方案 来替代它。承诺方案如同一个数字保险箱，包含两个阶段：

1. 承诺阶段：发送方将一个秘密值 (m) “锁入”一个承诺字符串 (com) 中并发送。此阶段具有隐藏性：(com) 不泄露 (m) 的信息。
2. 打开阶段：发送方 later 可以“打开”承诺，揭示原来的值 (m) 和用于生成承诺的随机数。此阶段具有绑定性：发送方无法找到另一对 ((m', r')) 使得 (commit(m', r') = com)，即他不能改变已承诺的值。

在下一讲中，我们将正式定义承诺方案，展示其构造方法，并用它来替换上述三染色协议中的物理保险箱，从而得到一个完全数字化的、适用于所有NP语言的零知识证明协议。

---

总结 📝

本节课中我们一起学习了零知识证明的构造方法。

1. 我们首先为二次剩余语言构造了一个简单的零知识证明协议，并分析了其完备性、可靠性（误差1/2）和零知识性。
2. 接着，我们探讨了如何为所有NP语言构造零知识证明。通过归约到NP完全问题——图的三染色问题，我们描述了一个使用“物理保险箱”的直观协议。
3. 我们分析了该协议的完备性、可靠性（通过重复提升）和零知识性，并介绍了模拟器通过“重试”策略来应对恶意验证者的方法。
4. 最后，我们指出物理保险箱在数字世界中的对应物是承诺方案，它提供了所需的隐藏性和绑定性，这将是我们下一节课的重点。

通过今天的课程，我们看到零知识证明并非遥不可及的概念，而是可以通过清晰的密码学原语和协议设计来实现的。

021：零知识证明与承诺方案

在本节课中，我们将继续学习零知识证明。我们将首先回顾上节课的内容，然后介绍如何用密码学原语——承诺方案——来替代物理“保险箱”，并最终探讨一种完全非交互式的零知识证明协议。

零知识证明回顾

上一节我们定义了零知识证明的概念。这类证明在证明一个陈述正确性的同时，不会泄露任何关于“为何正确”的信息。我们展示了一个针对特定NP完全语言——图的三着色问题——的零知识证明构造。

具体协议如下：假设证明者拥有一个对图G的合法三着色方案C1到Cn。证明者首先随机置换三种颜色，然后将每个顶点的新颜色放入一个不透明的“保险箱”中。验证者随后随机选择一条边，证明者则打开该边两个顶点对应的保险箱。验证者接受的条件是，打开的两个颜色是有效的（即属于{1,2,3}）且互不相同。

该协议之所以是零知识的，是因为验证者每次只能看到两个随机颜色，这些信息可以被模拟器完美模拟。模拟器可以随机选择两个“保险箱”，放入两个随机颜色，然后“希望”验证者恰好查询这条边。如果不是，则重新尝试。

该协议的可靠性（即防止作弊）概率较低，作弊者成功欺骗的概率约为 1 - 1/E（E为边数）。但通过将该协议顺序重复执行足够多次（例如边数乘以安全参数次），我们可以将作弊成功的概率压倒性地降低。需要注意的是，零知识性质在顺序重复下得以保持，但在并行重复下则不一定。

承诺方案：数字化的“保险箱”

上述协议依赖于物理的“保险箱”。为了实现数字化的协议，我们需要用密码学原语——承诺方案——来模拟保险箱的功能。

承诺方案允许发送方对一个值（例如一个比特）进行“承诺”，生成一个承诺字符串发送给接收方。这个承诺具有两个核心性质：

• 隐藏性：承诺字符串不会泄露被承诺的值的信息。
• 绑定性：发送方事后只能“打开”并揭示最初承诺的那个值，无法更改为其他值。

这正像一个数字保险箱：放入时内容被隐藏，打开时内容被确定。

承诺方案的定义

一个承诺方案由两个概率多项式时间算法构成：

1. 生成算法 Gen：输入安全参数λ，输出公共参数 pp。

   pp = Gen(1^λ)
   

2. 承诺算法 Com：输入公共参数 pp、一个比特 b 和随机数 r，输出承诺字符串 c。

   c = Com(pp, b; r)
   

它需要满足以下两个性质：

• 计算隐藏性：对于任何（可能由恶意验证者选择的）公共参数 pp，承诺 Com(pp, 0; r) 与 Com(pp, 1; r) 在计算上是不可区分的。这意味着多项式时间的敌手无法从承诺字符串中分辨出承诺的是0还是1。
• 统计绑定性：对于绝大多数由 Gen 生成的公共参数 pp，不存在一个承诺字符串 c 能够同时被“打开”为比特0和比特1。即使敌手拥有无限的计算能力，成功制造这种“碰撞”的概率也是可忽略的。

注意：我们也可以构造具有统计隐藏性和计算绑定性的承诺方案。这两种变体分别对应统计零知识/计算可靠性和计算零知识/统计可靠性的证明系统。通常，我们将具有计算可靠性的证明系统称为“论证”。值得注意的是，我们无法同时获得统计隐藏性和统计绑定性。

承诺方案的构造

以下是两个简单的承诺方案构造：

构造一：基于伪随机生成器
假设我们有一个将λ比特拉伸为3λ比特的PRG：G: {0,1}^λ -> {0,1}^{3λ}。

• Gen: 输出一个随机的 u ∈ {0,1}^{3λ} 作为公共参数 pp。
• Com(pp, b; r): 其中 r ∈ {0,1}^λ。
  • 如果 b=0，输出 c = G(r)。
  • 如果 b=1，输出 c = G(r) ⊕ u。

隐藏性源于PRG的输出与随机串不可区分；绑定性则因为对于随机 u，找到 r0, r1 使得 G(r0) ⊕ G(r1) = u 的概率极低。

构造二：基于单射单向函数（无公共参数）
假设 f 是一个单射单向函数，hc 是其硬核谓词。

• Com(b; (r, s)): 随机选择 r, s。
  • 输出承诺 c = (f(r), hc(r, s) ⊕ b)。

隐藏性由硬核谓词的安全性（Goldreich-Levin定理）保证；绑定性则由 f 的单射性保证，因为 f(r) 唯一确定了 r，从而确定了被掩码的比特。

非交互式零知识证明

之前的三着色协议需要多轮交互，并且为了达到高可靠性需要顺序重复多次，效率较低。现在，我们探讨一种非交互式零知识证明。

非交互式零知识证明并非完全无交互，它引入了一个被所有参与者信任的、一次性生成的公共参考字符串。证明者和验证者都拥有此CRS，证明过程仅由证明者向验证者发送一条消息（即证明）构成。

NI-ZK 的定义

一个非交互式零知识证明系统由三个PPT算法构成：

1. 生成算法 Gen: 生成公共参考字符串 crs。
2. 证明算法 P: 输入 crs、陈述 x 和见证 w，输出证明 π。

   π = P(crs, x, w)
   

3. 验证算法 V: 输入 crs、陈述 x 和证明 π，输出接受(1)或拒绝(0)。

   result = V(crs, x, π)
   

它需要满足：

• 完备性：诚实的证明者能为真陈述生成几乎总是被接受的证明。
• 可靠性：对于假陈述，任何（即使是能根据CRS自适应选择假陈述的）作弊证明者成功生成有效证明的概率可忽略。
• 零知识性：存在一个模拟器，它可以在不访问见证 w 的情况下，生成一个与真实证明计算不可区分的 (crs, π) 对。对于更强的“多陈述零知识”，模拟器应能模拟多个陈述的证明。

一个基于随机预言机的构造思路

我们可以将之前的三着色并行重复协议转化为非交互式协议，其核心思想是用一个随机预言机来代替验证者选择挑战边。

1. 公共设置：所有参与者可以访问一个公共的随机函数 H（随机预言机）。
2. 证明生成：
   • 证明者像并行协议中一样，生成 k 个第一轮消息（承诺）α_1, ..., α_k。
   • 证明者计算挑战：β_i = H(α_i)，i=1 to k。这里用哈希输出模拟了验证者随机选择边。
   • 证明者像并行协议中一样，根据每个 β_i 生成对应的打开信息 γ_i。
   • 证明者发送 π = (α_1, ..., α_k, β_1, ..., β_k, γ_1, ..., γ_k) 给验证者。
3. 验证：
   • 验证者首先检查是否对所有 i，都有 β_i == H(α_i)。这确保了挑战并非由证明者恶意选择。
   • 然后，验证者检查每个三元组 (α_i, β_i, γ_i) 是否都是原始三着色协议中的一个有效转录。

直觉分析：

• 可靠性：在随机预言机模型下，作弊证明者无法预测 H(α) 的输出，因此他成功欺骗的概率与交互式并行协议中类似。虽然他可以进行多次尝试（不同 α），但多项式次尝试后成功的总概率仍可忽略。
• 零知识性：模拟器可以“编程”随机预言机。当需要模拟一个证明时，模拟器可以先像之前一样模拟并行协议的转录 (α_i, β_i, γ_i)，然后“事后”将随机预言机在点 α_i 的值定义为 β_i。对于随机的 β_i，这在随机预言机模型下是可行的。

重要说明：随机预言机是一个理想化的模型。在实际中，我们用具体的哈希函数（如SHA-256）来实例化它，但此时上述安全性的形式化证明将不再成立。然而，该构造提供了设计高效非交互式零知识证明的重要蓝图，并且存在在不依赖随机预言机的标准模型下构建NI-ZK的技术（例如使用可编程的CRS）。

总结

本节课我们一起学习了零知识证明的核心组件——承诺方案，并探讨了如何构建非交互式零知识证明。

我们首先回顾了基于图三着色问题的交互式零知识证明协议。接着，我们引入了承诺方案作为实现该协议中“保险箱”的密码学工具，明确了其隐藏性和绑定性两大性质，并给出了基于PRG和单向函数的简单构造。

最后，我们介绍了非交互式零知识证明的概念。通过引入公共参考字符串或随机预言机，我们可以将多轮交互的协议转化为单消息协议。我们详细讲解了一个在随机预言机模型下，将并行重复的三着色协议转化为非交互式协议的构造思路及其安全性直觉。

理解承诺方案是构建更高级零知识证明系统的基础，而非交互式零知识证明则在许多隐私保护应用（如匿名认证、区块链）中具有极高的实用价值。

022：从零知识证明到简洁证明

在本节课中，我们将从零知识证明转向简洁证明。我们将重点介绍一个核心协议——和校验协议。这个协议是构建所有现代简洁证明系统的基础模块，尽管它最初看起来可能有些特定和抽象。

从零知识到简洁证明

上一节我们介绍了零知识证明，它旨在不泄露任何关于陈述为何为真的信息。为了达到这个目标，Goldwasser、Micali和Rackoff定义了交互式证明的概念。我们甚至展示了在假设存在公共参考字符串或公共随机字符串的情况下，如何获得非交互式零知识证明。

本节中，我们将回到交互式证明，但目的完全不同。接下来的几讲，我们将关注一个新的动机：计算外包的可验证性。

外包计算的可验证性问题

设想一个场景：你有一个需要大量时间运行的程序，由于本地机器性能不足，你希望将其外包给一台超级计算机。服务提供商运行程序后返回输出结果。这里存在一个问题：如果你不信任这个服务提供商，如何确保返回的答案是正确的？

一个直观的想法是，将一些已知答案的计算任务与你的真实任务混合在一起交给服务商。然而，这种方法存在缺陷：服务商可能区分哪些是已知答案的“测试”任务，哪些是你的真实任务，并且在后续请求中可能记住这些模式。虽然基于全同态加密可以构建委托方案，但过程并不像混合任务那么简单直接。

我们真正希望的是，服务商在返回输出结果 M(x) 的同时，能提供一个证明 π，证明计算是正确的。

这里存在一个根本性问题：对于一般的、运行时间为 T 的计算，我们通常不相信存在一个尺寸远小于 T（例如 T^ε）的证明。如果能轻易获得这样简短的证明，我们或许就能自己快速验证甚至重新计算了。从复杂性理论的角度看，我们不相信像 DTIME(T) 这样的类会包含在 NP 中（即存在多项式大小证明的语言类）。

然而，在区块链、银行等实际应用中，简洁证明已经被广泛使用。我们是如何绕过这个“不可能性”的呢？答案在于密码学，而起点正是交互式证明。

交互式证明的力量

正如之前课程提到的，使用交互式证明，我们可以证明任何在多项式空间（PSPACE）内的语言。这是Shamir在90年代初期的结果。更精确地说，对于任何在时间 T 和空间 S 内运行的图灵机，都存在一个交互式证明，其中验证者的运行时间大致与 S 相关（乘以 polylog(T)），而不是 T。这意味着，对于许多空间需求不大的程序，我们已经可以有效地进行委托验证。

在此基础上，结合密码学，我们可以进一步让验证者的运行时间达到 polylog(T)，完全不再关心原始计算的空间复杂度。我们的目标就是理解这些简洁证明背后的原理。

在业界文献中，这类证明常被称为“ZK Proofs”（零知识证明），尽管它们本身可能并不具备零知识属性。有时当需要零知识时，会直接使用“ZK”这个名称。这有些令人困惑，但我们需要知道，今天讨论的核心是“简洁性”。

和校验协议：核心构建模块

今天，我们将学习一个具体的协议——和校验协议。它针对的问题本身可能看起来并不吸引人，但却是所有简洁证明系统的基石。

以下是和校验协议要解决的问题：

假设在一个有限域 F（例如 GF(p)，其中 p 是一个大素数）上，存在一个 m 元多项式 F。这个多项式在每个变量上的次数最多为 d。

现在，证明者 P 想向验证者 V 证明，多项式 F 在一个特定集合 H（例如超立方体 {0, 1}）上所有点的取值之和等于某个声称的值 v。即证明以下等式：

v = Σ_{h1 ∈ H} ... Σ_{hm ∈ H} F(h1, ..., hm)

验证者和证明者都可以通过“预言机”查询 F 在任意点的值。验证者当然可以自己计算这个和，但这需要 |H|^m 次查询，当 m 很大时是指数级的。验证者的目标是，以远低于 |H|^m 的时间（例如线性于 m）来验证这个求和声明的正确性。

和校验协议通过 m 轮交互来实现这一点，每一轮都将关于 m 个变量的求和声明，归约到一个关于 m-1 个变量的新声明。

协议流程

1. 初始声明：证明者声称 v0 = Σ_{h1,...,hm ∈ H} F(h1, ..., hm)。

2. 第1轮：

   • 证明者发送一个单变量多项式 g1(X) 给验证者。这个多项式被定义为：

     g1(X) = Σ_{h2,...,hm ∈ H} F(X, h2, ..., hm)
     

     也就是说，g1(X) 是固定第一个变量为 X 后，对其他所有变量在 H 上求和的结果。一个诚实的证明者可以通过大量计算得到这个多项式。
   • 验证者进行两项检查：
     • 次数检查：检查 g1(X) 的次数是否 ≤ d（因为 F 在每个变量上次数为 d，求和操作不会增加次数）。
     • 求和检查：检查 Σ_{h ∈ H} g1(h) 是否等于声称的 v0。如果 g1 是正确的，那么对它在 H 上求和就等价于对所有变量在 H 上求和，结果应为 v0。
   • 如果检查失败，验证者立即拒绝。
   • 如果检查通过，验证者随机选择一个域元素 r1 ∈ F，并发送给证明者。双方计算 v1 = g1(r1)。

3. 第 i 轮 (i=2 to m)：

   • 此时，双方有一个关于前 i-1 个变量固定为 r1,..., r(i-1) 的声明：

     v(i-1) = Σ_{hi,...,hm ∈ H} F(r1, ..., r(i-1), hi, ..., hm)
     

   • 证明者发送一个单变量多项式 gi(X)：

     gi(X) = Σ_{h(i+1),...,hm ∈ H} F(r1, ..., r(i-1), X, h(i+1), ..., hm)
     

   • 验证者检查：
     • gi(X) 的次数 ≤ d。
     • Σ_{h ∈ H} gi(h) = v(i-1)。
   • 如果检查通过，验证者随机选择 ri ∈ F，双方计算 vi = gi(ri)。

4. 最终检查：

   • 经过 m 轮后，声明变为：

     vm = F(r1, r2, ..., rm)
     

   • 验证者直接查询预言机，获得 F(r1, ..., rm) 的真实值，并检查是否等于 vm。如果相等，则接受；否则拒绝。

协议理解与直观解释

我们可以用一个更简单但可靠性很差的协议来类比理解。假设 H = {0,1}，F 是任意函数（不一定是多项式）。验证者让证明者分别给出第一个变量为0和1时的部分和 v0 和 v1。如果原始总和 v 是错的，那么 v0 或 v1 中至少有一个是错的。验证者随机猜测一个（比如猜 v0 是错的），然后要求证明者针对 v0 再分解出第二个变量为0和1的部分和，如此递归下去。如果证明者作弊，且验证者每次都能幸运地猜到错误所在的分支，那么在最后（输入层）就能发现矛盾。但验证者每次猜对的概率只有 1/2，总的成功捕获概率仅为 1/2^m，可靠性很差。

和校验协议的精妙之处在于利用了多项式的低次性质。当证明者发送第一个多项式 g1(X) 时，它实际上包含了 v0 和 v1 的信息（因为 g1(0) 和 g1(1) 就是它们）。如果原始总和 v 是错的，那么正确的多项式 g1_true(X) 和证明者可能发送的错误多项式 g1*(X) 就是两个不同的低次（≤ d）多项式。两个不同的 d 次多项式最多在 d 个点上相等。当域 F 很大（远大于 d）时，验证者随机选择的 r1 使得 g1*(r1) = g1_true(r1) 的概率最多为 d/|F|。也就是说，只要证明者最初作弊，那么随着验证者随机选择 r1，进入下一轮的声明极大概率（1 - d/|F|）仍然是假的。这种性质将每轮“猜分支”的 1/2 错误概率，提升到了 1 - d/|F| 的保持“错误”的概率。

协议分析

• 完备性：如果证明者诚实，且声明为真，那么所有多项式 gi 都是正确的，所有检查都会通过，验证者最终会接受。
• 可靠性：如果初始声明为假（v0 错误），我们分析证明者通过所有检查的概率。
  • 在第1轮，证明者必须发送某个多项式 g1*。如果 g1* 不是正确的 g1_true，那么由于 g1_true 和 g1* 是两个不同的 d 次多项式，对于随机选择的 r1，g1*(r1) = g1_true(r1) 的概率 ≤ d/|F|。
  • 换言之，如果初始声明为假，那么经过第一轮后，新的声明 v1 = g1*(r1) 仍然为假的概率至少是 1 - d/|F|。
  • 同理，在每一轮中，如果进入该轮的声明是假的，那么经过该轮后，声明变为真的概率最多为 d/|F|（除非证明者在本轮发送的多项式检查中直接被拒）。
  • 经过 m 轮，使用联合界，证明者在一个假声明上通过全部检查的概率最多为 m * d / |F|。
  • 因此，只要选择域的大小 |F| >> m * d，我们就可以使可靠性错误变得非常小。

效率分析

• 通信复杂度：共 m 轮。每轮证明者发送一个 d 次多项式，需要 d+1 个域元素；验证者发送一个随机域元素。总通信量为 O(m * d * log|F|) 比特。这是一个“公共掷币”协议，因为验证者只发送随机数。
• 验证者时间：验证者主要工作是在每轮检查多项式 gi 的求和（对 H 中元素求和），这需要 O(|H| * d) 次域操作。最终进行一次预言机查询。总时间与 m、d 和 |H| 相关，但远小于直接计算 |H|^m 次求和。
• 证明者时间：证明者需要计算各个多项式 gi，这本质上需要他对 F 在大量点上进行求和，其时间大致为 O(|H|^m * m)，即接近直接计算总和的时间。在传统的交互式证明概念中，证明者被认为是计算能力无限强大的，效率不是关注重点。

迈向高效交互式证明

Shamir的 IP = PSPACE 结果虽然强大，但存在一个缺点：证明者的运行时间可能是指数级的（例如 T * 2^S）。在交互式证明理论早期，证明者常被比喻为拥有无限法力的“梅林”，验证者“亚瑟”国王只关心高效验证。这被视为一个理论上的完美收官。

然而，对于实际应用，我们需要双重高效交互式证明：不仅验证者要高效，证明者也应该高效。即：

• 证明者运行时间应最多是原始计算时间 T 的某个多项式倍（理想情况是线性倍）。
• 验证者运行时间应远小于 T，例如 poly(n, log T) 或 T^ε。

一个自然的问题是：对于 PSPACE 中的语言，是否存在双重高效交互式证明？答案是目前未知。这是一个深刻而开放的问题：证明一个计算正确性，是否一定比执行这个计算本身困难得多？

目前已知的双重高效交互式证明主要针对有界深度计算（例如算术电路）。对于深度为 D、规模为 S 的电路：

• 证明者时间可达到 O(S)，即线性于电路规模。
• 验证者时间约为 poly(n, D, log S)。

其核心思想是：将电路的每一层“编码”为一个低次多元多项式（称为低度扩展）。然后，从输出层开始，递归地应用和校验协议，将关于一层编码值的声明，归约到关于下一层编码值的声明。由于多项式编码具有“如果一点错误，则几乎处处错误”的纠错码性质，可靠性得以保证。如果证明者作弊，那么通过随机验证，这个“错误”会以极高概率向下传播，直到输入层，而输入是验证者已知的，从而可以被发现。我们将在下节课详细探讨这个构造。

总结

本节课中，我们一起学习了：

1. 动机转换：从保护隐私的零知识证明，转向解决外包计算可验证性的简洁证明。
2. 核心协议：深入探讨了和校验协议。该协议允许验证者高效地验证一个低次多元多项式在大量点上求和的结果。
3. 协议原理：协议通过多轮交互，逐步将多变量求和声明归约为单点求值声明，并利用低次多项式在随机点上相等的概率极低这一性质来保证可靠性。
4. 基础地位：和校验协议是几乎所有简洁证明系统（无论是交互式还是非交互式）的基础构建模块。
5. 未来方向：我们简要介绍了双重高效交互式证明的概念和目标，并指出和校验协议是构造针对有界深度电路的双重高效证明的关键工具。这为我们将复杂计算验证转化为多项式求和验证奠定了基础。

023：GKR协议详解 🧠

在本节课中，我们将学习GKR协议，这是一种用于证明低深度电路计算正确性的交互式证明系统。我们将从回顾交互式证明和Sum-Check协议开始，逐步构建GKR协议，并解释其核心原理和效率保证。

---

回顾：交互式证明与Sum-Check协议

上一节我们介绍了交互式证明的概念，并定义了“双重高效”的交互式证明。我们还提到了GKR协议，这将是本节课的主题。

在深入GKR协议之前，让我们简要回顾Sum-Check协议。该协议用于证明一个低次多项式在布尔超立方体上的求和等于某个声称的值。验证者无需计算整个求和（这可能需要指数时间），而是通过一系列交互轮次，以高概率确信证明者声称的正确性。其核心思想是，如果证明者撒谎，那么在一个随机点评估多项式时，其值不正确的概率非常高。

---

GKR协议的目标与设定 🎯

GKR协议是证明者和验证者之间的一个交互式证明。他们想要证明，对于一个给定的电路 C 和输入 x，电路的输出是某个比特 b。

定理：固定任意电路 C，其大小为 S（门数量），深度为 D。GKR协议能构造一个交互式证明，具有以下保证：

• 轮复杂度：轮数与深度 D 相关，并与 S 的多对数（polylog）成正比。
• 验证者运行时间：每轮计算量很小，主要依赖于安全参数 λ 和输入大小 n，总体为 Õ(n + λ · D · polylog(S))。
• 证明者运行时间：为 poly(S, λ)。
• 完备性：为1（诚实的证明者总能说服验证者）。
• 可靠性：作弊成功的概率为 negl(λ)（关于安全参数可忽略）。

一个有趣的参数设置是：S = poly(n)，D = polylog(n)，安全参数 λ = polylog(n)。这样，可靠性在 n 上是可忽略的。

---

协议构建：准备工作与假设

为了构建协议，我们首先对电路 C 做一些不失一般性的简化假设，以便于后续使用代数工具。

以下是我们的假设：

1. 分层电路：电路被组织成 D 层，每一层的门只从紧邻的下一层获取输入。
2. 扇入为二：每个门最多有两个输入。对于扇入更大的门，可以通过添加“与”或“或”的树形结构来模拟，这只会使深度增加一个对数因子。
3. 算术化：门运算只有加法（⊕，在GF(2)上即异或）和乘法（⊗）。因为{与, 非}或{或, 非}是完备的，任何布尔电路都可以转化为这种算术电路。
4. 每层门数相同：为简化标记，我们假设每一层恰好有 S 个门，且 S 是2的幂（即 S = 2^m）。这样，我们可以用长度为 m 的比特串来唯一标记每一层的每个门。

---

核心工具：多线性扩展（Multilinear Extension）

GKR协议的关键是将电路每层的布尔值“扩展”到一个更大的代数结构（有限域）中，从而能够应用Sum-Check协议。

定义：对于一个函数 V: {0,1}^m → {0,1}（可以看作是一个长度为 2^m 的0/1向量），其在有限域 F 上的多线性扩展 Ṽ: F^m → F 是满足以下条件的唯一的多线性多项式：

• 多线性：多项式在每个变量上的次数最多为1。
• 一致性：对于所有 b ∈ {0,1}^m，有 Ṽ(b) = V(b)。

定理：对于任意 V 和 F，多线性扩展 Ṽ 存在且唯一。给定 V 的整个真值表（即所有 2^m 个值），对于任意点 x ∈ F^m，可以在时间 O(2^m · poly(m, log|F|)) 内计算出 Ṽ(x)。

构造与证明：
多线性扩展可以通过一种类似拉格朗日插值的方法显式构造：

Ṽ(x₁, ..., xₘ) = Σ_{b ∈ {0,1}^m} V(b) · χ_b(x)

其中，χ_b(x) 是一个多线性多项式，满足在超立方体上当 x = b 时为1，否则为0。具体地：

χ_b(x) = Π_{i=1 to m} [ (1 - b_i) · (1 - x_i) + b_i · x_i ]

唯一性的证明可以通过归纳法完成：假设存在两个不同的多线性扩展，它们的差是一个在布尔超立方体上为零的多线性多项式，通过归纳变量数可以证明该差多项式必须恒为零。

---

GKR协议流程概述 🔄

现在，我们来看GKR协议如何运作。其核心思想是逐层归约一个关于电路输出的声明，直到归约到可以直接由验证者检查的输入层。

协议步骤：

1. 证明者计算：证明者首先计算电路 C 在输入 x 下的所有中间值。令 V_i: {0,1}^m → {0,1} 表示第 i 层所有门的输出值（i=0 是输出层，i=D 是输入层）。
2. 初始声明：证明者声称输出层（第0层）唯一非哑元的门（即实际输出门）的值为 b。这等价于声称 V_0(z_0) = b，其中 z_0 是该输出门的标签。
3. 逐层归约：对于 i 从 0 到 D-1，协议执行一个子程序，将关于 V_i 在点 z_i 的值的声明，归约为关于 V_{i+1} 在两个点 z_{i+1}^{(1)}, z_{i+1}^{(2)} 的值的声明。关键性质是：如果初始声明是假的，那么归约后得到的两个声明中至少有一个是假的，且验证者以极高概率（而非1/2）能发现这一点。
4. 最终检查：当到达输入层（第 D 层）时，我们得到关于 V_D（即输入值）在一些点上的声明。验证者自己知道输入 x，并且可以高效地计算 V_D 的多线性扩展在这些点上的值（因为 V_D 只是输入的简单函数，且多线性扩展计算高效），从而完成验证。

这个归约过程的核心，正是利用了Sum-Check协议。

---

归约步骤详解：连接层与Sum-Check

假设我们当前有一个关于第 i 层的声明：Ṽ_i(z_i) = v_i。我们想将其归约为关于第 i+1 层的声明。

首先，我们写出 Ṽ_i(z_i) 的显式表达式。根据多线性扩展的定义和电路结构（每个门是其两个子门的加法或乘法），我们有：

Ṽ_i(z_i) = Σ_{b, w₁, w₂ ∈ {0,1}^m} [ add_i(b, w₁, w₂) · (Ṽ_{i+1}(w₁) ⊕ Ṽ_{i+1}(w₂)) + mult_i(b, w₁, w₂) · (Ṽ_{i+1}(w₁) ⊗ Ṽ_{i+1}(w₂)) ] · χ_{z_i, b}(w₁, w₂)

这里：

• add_i(b, w₁, w₂) 和 mult_i(b, w₁, w₂) 是指示函数，当第 i 层的门 b 是一个加法/乘法门且其子门为 w₁, w₂ 时值为1，否则为0。我们同样考虑它们的多线性扩展。
• χ_{z_i, b}(...) 是多线性扩展中的基函数。

观察这个表达式：它是一个关于 3m 个变量 (b, w₁, w₂) 的低次多项式（次数为常数，例如在 w₁ 上次数为2）在布尔超立方体 {0,1}^{3m} 上的求和，结果被声称等于 v_i。

这正是应用 Sum-Check协议 的完美场景！验证者和证明者可以对这个求和运行Sum-Check协议。

---

处理多个声明与随机性共享

运行Sum-Check协议后，验证者最终需要检查该低次多项式在某个随机点 (r_b, r₁, r₂)（由验证者的随机硬币决定）上的值。这个值涉及：

1. add_i 和 mult_i 在 (r_b, r₁, r₂) 的值：验证者可以根据电路描述 C 高效计算这些（这需要电路是“对数空间均匀”的，这是一个技术性条件）。
2. Ṽ_{i+1}(r₁) 和 Ṽ_{i+1}(r₂) 的值：这正是关于第 i+1 层的新声明！

因此，一个关于第 i 层一个点的声明，通过一轮Sum-Check，被归约为关于第 i+1 层两个点的声明。

这里出现一个挑战：如果我们从第0层的一个声明开始，第1层会变成两个，第2层会变成四个……依此类推，到第 D 层将产生 2^D 个声明，这是指数级的。

巧妙解决方案：当我们需要对两个声明（例如 Ṽ_{i+1}(z₁) = v₁ 和 Ṽ_{i+1}(z₂) = v₂）分别进行从第 i+1 层到第 i+2 层的归约时，我们让验证者在运行这两个Sum-Check协议时使用相同的随机硬币序列。

这样，在Sum-Check协议的末尾，验证者需要检查的两个多项式评估点中，由随机硬币决定的部分（即对应于子门标签 w₁, w₂ 的部分 r₁, r₂）将是相同的。虽然初始点 z₁ 和 z₂ 不同会导致一些不同的计算项，但核心的 Ṽ_{i+2}(r₁) 和 Ṽ_{i+2}(r₂) 声明被共享了。通过精心设计，可以确保在整个协议过程中，需要验证的不同点的数量不会爆炸，而是保持为一个小常数（例如2个）。这保证了验证者的总效率。

---

总结与下节预告 📚

本节课我们一起学习了GKR协议，这是一个用于验证低深度电路计算的交互式证明系统。我们了解到：

1. 协议目标：高效验证大规模但浅深度电路的计算。
2. 核心准备：通过对电路进行算术化和使用多线性扩展，将布尔计算问题转化为代数问题。
3. 协议核心：利用Sum-Check协议，将关于电路某一层输出的声明，以高可靠性归约为关于下一层输入的声明。
4. 关键技巧：通过在不同层的归约中共享随机性，控制需要检查的点数量，从而保证验证者效率。

GKR协议展示了交互式证明的强大能力，以及如何将代数工具（如多项式与Sum-Check）应用于复杂的计算验证中。

在下节课中，我们将探讨如何将这种交互式证明（其轮数与深度相关）转化为一种非交互式或更简洁的证明系统（如SNARG），这将是另一个令人兴奋的主题。

024：从GKR到简洁论证与秘密共享入门 🧠

概述

在本节课中，我们将要学习如何突破深度限制，为任意时间T的计算构建高效的交互式论证。我们将利用密码学技术，特别是多项式承诺，将长证明压缩为简洁形式。最后，我们将简要介绍本课程最后一个模块——安全多方计算的入门概念：秘密共享。

---

上一节我们介绍了GKR协议，它能高效验证低深度电路的计算正确性，但验证轮数和时间与电路深度D相关。本节中我们来看看如何处理深度很大甚至顺序的计算。

GKR协议在电路深度D较小时非常高效。然而，如果计算对应的电路深度很大，验证效率会显著下降。直观上，低深度计算对应可快速并行完成的计算。但对于顺序性强的深度计算，我们需要更好的方案。

我们的目标是构建一个交互式论证，使其适用于任意大小为S的电路（或时间T的计算），同时满足以下条件：

• 验证轮数：Polylog(T)
• 验证者运行时间：Polylog(T) + 读取输入的时间
• 证明者运行时间：Poly(T)

这似乎与IP=PSPACE定理矛盾，因为这意味着验证者可以高效验证超出PSPACE的计算。我们通过引入计算可靠性来绕过这个不可能性结果。我们构建的不是交互式证明，而是交互式论证，其可靠性仅针对计算能力有限的作弊证明者。也就是说，我们只保证任何多项式规模的作弊证明者，对于一个错误陈述，能使验证者接受的概率是可忽略的。

---

核心思路：展平电路与密码学压缩

假设有一个深度为T的电路（或一个运行时间为T的图灵机），直接应用GKR协议效率低下。我们的核心想法如下：

1. 展平电路：让证明者计算电路中所有导线的值，记为 W1, W2, ..., WT。构造一个新的、深度很浅的电路，其唯一功能是检查所有这些导线值的一致性（即每个逻辑门的计算是否正确）。这个新电路的输入就是这T个导线值，其深度仅为 O(log T)。

2. 应用GKR：对这个新的浅层电路运行GKR协议。GKR验证者运行时间与电路深度呈多项式关系，因此现在是高效的。

3. 核心问题：GKR协议最后需要验证新电路输入（即所有导线值 W）的多线性扩展在某个随机点 Z 的值。验证者并不知道 W，因此无法直接计算。

4. 密码学解决：我们不直接发送庞大的 W，而是让证明者使用一个多项式承诺方案来提交 W 的多线性扩展多项式 W_tilde。这个承诺是简短的。当GKR协议需要 W_tilde(Z) 的值时，证明者可以打开承诺，提供一个简短的证明来证实该值。验证者利用承诺和这个简短证明即可高效验证。

---

多项式承诺

多项式承诺是我们实现上述方案所需的密码学原语。它允许承诺者对一个低阶多项式（此处为多线性多项式）进行简短承诺，随后可以在任意点高效地打开并证明其值。

一个多项式承诺方案包含以下算法：

1. 生成(Gen)：输入安全参数 λ，输出公共参数 pp 和可能的陷门 td。

   (pp, td) = Gen(λ)
   

2. 承诺(Commit)：输入公共参数 pp 和多项式描述（如所有单项式系数），输出一个简短的承诺串 C。

   C = Commit(pp, polynomial_description)
   

3. 打开(Open)：输入公共参数 pp、承诺 C、一个点 z 以及多项式在 z 处的值 v，生成一个证明 π。

   π = Open(pp, C, z, v)
   

4. 验证(Verify)：输入公共参数 pp（或陷门 td）、承诺 C、点 z、声称的值 v 和证明 π，输出 0 或 1 表示是否接受。

   result = Verify(pp, C, z, v, π)
   

关键性质：

• 简洁性：承诺 C 和证明 π 的大小为 Poly(λ, log(T))。
• 计算绑定性与低阶性：对于任何多项式规模的敌手，在给定诚实生成的 pp 后，其输出一个承诺 C 并为同一个点 z 提供两个不同的有效打开值 (v1, π1) 和 (v2, π2)（其中 v1 ≠ v2）的概率是可忽略的。此外，打开的值必须与一个低阶多项式一致。

---

完整的交互式论证协议

以下是结合多项式承诺与GKR的完整协议步骤：

1. 初始化：验证者运行 Gen(λ) 生成 (pp, td)，将 pp 发送给证明者。
2. 承诺导线值：证明者计算原始深度电路的所有导线值 W，构造其多线性扩展 W_tilde，并计算承诺 C = Commit(pp, W_tilde) 发送给验证者。
3. 运行GKR：双方以 W 作为输入，对那个检查一致性的浅层电路执行GKR协议。
4. 打开查询：在GKR协议的最后，验证者需要一个随机点 Z 上的值 W_tilde(Z)。验证者将 Z 发送给证明者。
5. 提供证明：证明者计算 v = W_tilde(Z)，并生成证明 π = Open(pp, C, Z, v)，将 (v, π) 发送给验证者。
6. 验证：验证者使用GKR协议验证电路逻辑，并使用 Verify(pp, C, Z, v, π) 验证输入值的正确性。当且仅当两者都通过时接受。

安全性直觉：多项式承诺的计算绑定性保证了作弊证明者本质上被“锁定”到某个多项式 W_tilde。GKR协议保证了如果这个被锁定的 W_tilde 对应的导线值 W 不满足电路一致性，则验证者将以极高概率拒绝。因此，只有当证明者确实知道一个正确的计算轨迹时，才能通过验证。

---

从交互式论证到简洁非交互式论证

上述协议已经是轮数简洁的交互式论证。一个更强的概念是简洁非交互式论证。其思想是，对于任何NP陈述（存在多项式长度见证的陈述），可以利用密码学（如多项式承诺和随机预言机模型）将传统的NP证明（即见证）压缩成一个长度极短（仅与安全参数相关）的证明。这样，验证者无需与证明者交互，仅通过检查这个简短证明就能确信陈述的真实性。这构成了许多现代零知识证明和区块链技术的基础。

---

引入新模块：安全多方计算与秘密共享

接下来，我们将开始本课程最后一个核心模块的学习：安全多方计算。作为这个模块的起点，我们首先需要理解其基础构建块——秘密共享。

秘密共享 是一种将秘密 s 在一组参与者 P1, P2, ..., Pn 之间进行分配的方法，使得：

• 任何足够大（达到阈值）的子集 可以联合起来重构秘密 s。
• 任何不足阈值的子集 无法获得关于秘密 s 的任何信息。

一个经典的方案是 Shamir秘密共享，它基于多项式插值。假设我们想设定阈值为 t（即至少需要 t 个人才能恢复秘密）：

1. 分享：选择一个随机 t-1 次多项式 f(x)，满足 f(0) = s（秘密）。给予参与者 Pi 的份额是 (i, f(i))。
2. 重构：任意 t 个参与者提供他们的份额 (i, f(i))，利用拉格朗日插值法可以唯一确定多项式 f(x)，进而计算出 s = f(0)。

秘密共享是构建安全多方计算协议的重要工具，它允许计算在秘密分割的数据上进行，而无需任何单一参与者知晓全部输入。

---

总结

本节课中我们一起学习了：

1. 如何通过展平电路和多项式承诺，将GKR协议推广至任意深度（或时间）的计算，构建轮数简洁的交互式论证。
2. 多项式承诺作为关键密码学原语，允许对大型多项式进行简短承诺并可在特定点高效打开验证。
3. 这种技术引向了更强大的简洁非交互式论证的概念，能够将NP证明压缩到极短。
4. 我们开启了课程最终模块——安全多方计算，并介绍了其基础组件秘密共享的核心思想与Shamir方案。

通过结合密码学的计算假设，我们能够突破信息论极限，实现既简洁又高效的验证系统，这为现代密码学应用如零知识证明和区块链扩展性提供了基础。

025：秘密共享与安全多方计算入门

在本节课中，我们将从简洁证明过渡到安全多方计算。首先，我们将定义并构建一个由Shamir提出的有趣原语——秘密共享。这将成为我们构建安全多方计算方案的基础模块。

秘密共享方案

秘密共享方案的核心思想如下：假设我有一个秘密 S，我希望在你们之间分享它，给每个人一个份额。我的目标是：每个人单独查看自己的份额时，得不到任何信息。但是，如果足够多的人（或某个授权的子集）聚集在一起，他们就能重构出我的秘密。

换句话说，有一个分发者拥有一个秘密 S。为了简化，我们假设秘密是一个比特。对于更长的字符串，可以逐比特进行共享。分发者希望给 N 个参与方中的每一个一个份额 S_i，使得任何授权的子集聚集在一起时能够重构秘密，而任何未授权的子集即使聚集在一起也学不到任何信息。

“授权”的定义可以是单调的。今天我们将讨论 T-out-of-N 秘密共享。这意味着在 N 个参与方中，如果有至少 T 个人聚集在一起，他们就能重构秘密；而少于 T 个人则不能。

定义

一个 T-out-of-N 秘密共享方案由两个高效算法组成：

1. 分享算法 Share：输入一个秘密 S（例如来自消息空间 {0,1}），输出份额 S_1, ..., S_N。该算法是概率多项式时间的。
2. 重构算法 Reconstruct：输入至少 T 个份额，输出秘密 S。该算法是确定性的多项式时间算法。

方案需要满足以下属性：

• 正确性：对于每个秘密 S 和任意大小为 T 的参与方集合 I，如果份额 S_1, ..., S_N 由 Share(S) 生成，那么 Reconstruct(I, {S_i}_{i∈I}) 输出 S 的概率为 1。
• 安全性：对于任意两个秘密 S 和 S'，以及任意大小小于 T 的恶意用户集合 I，集合 I 中用户看到的份额分布 {S_i}_{i∈I} 与 {S'_i}_{i∈I} 是完全相同的。这意味着，拥有少于 T 个份额的参与方，即使在无限计算时间下，也无法获得关于秘密的任何信息。这是一个信息论安全的结果，不涉及安全参数。

构造：Shamir秘密共享

我们将使用低次多项式来构造 Shamir 秘密共享方案。首先，固定一个域 F，其大小 |F| > N（例如，取一个大于 N 的素数 p，使用模 p 的域）。

分享算法 Share(S)：

1. 随机选择系数 a_1, ..., a_{T-1} ∈ F。
2. 构造一个随机的 T-1 次多项式：f(x) = S + a_1*x + a_2*x^2 + ... + a_{T-1}*x^{T-1}。注意，常数项是秘密 S，即 f(0) = S。
3. 为第 i 个参与方计算份额 S_i = f(i)（假设 i 是域中的非零元素，例如 1, 2, ..., N）。输出 (S_1, ..., S_N)。

重构算法 Reconstruct({(i, S_i)}_{i∈I})：
给定 T 个点 (i, f(i))，可以利用多项式插值（例如拉格朗日插值法）唯一地重构出这个 T-1 次多项式 f(x)。一旦得到 f(x)，计算 f(0) 即可恢复秘密 S。

安全性解释：
一个 T-1 次多项式由 T 个点唯一确定。如果只给出 T-1 个点，对于域中的每一个可能的 S'，都存在唯一的一个 T-1 次多项式经过这些点且满足 f'(0)=S'。因此，拥有少于 T 个份额的参与方看到的份额分布，与秘密是 0 或 1（或任何其他值）时的分布是完全相同的，他们无法获得关于真实秘密 S 的任何信息。

上一节我们介绍了秘密共享的基本概念和 Shamir 构造。本节中，我们来看看秘密共享与纠错码的联系，并引出安全多方计算。

与纠错码的联系

Shamir秘密共享与著名的里德-所罗门码密切相关。纠错码旨在将消息编码成更长的码字，即使部分符号被损坏或丢失，也能恢复原始消息。

考虑如何将一个长度为 T 的消息 M = (m_0, m_1, ..., m_{T-1}) 编码为里德-所罗门码：

1. 找到唯一的 T-1 次多项式 f，使得 f(i) = m_i，对于 i = 0, 1, ..., T-1。
2. 码字是多项式 f 在许多点上的求值，例如 (f(0), f(1), ..., f(p-1))。前 T 个值就是原始消息 M，其余是冗余。

这种编码可以抵抗擦除（数据丢失）。只要还有至少 T 个未擦除的求值点，就可以重构多项式 f，从而恢复整个消息（包括前 T 个点）。更强大的是，使用更复杂的解码算法（如伯利坎普-韦尔奇算法），它甚至可以抵抗错误（数据被恶意篡改）。如果被恶意篡改的点少于 (p - T + 1) / 2 个，仍然可以恢复原始消息。

在秘密共享的语境下，我们可以将秘密 S 视为消息 M 的一部分（例如 m_0 = S）。分享过程类似于编码，重构过程类似于从部分点解码。这为理解秘密共享提供了另一个视角。

安全多方计算简介

秘密共享最重要的应用场景之一是安全多方计算。

在安全多方计算中，多个参与方（例如我们所有人）希望基于各自的私有输入进行联合计算，并得到输出。但每个参与方都不希望向他人泄露自己的私有输入。

示例：

1. 计算平均成绩：每个学生输入自己的成绩，希望计算全班的平均分，但不想透露自己的具体成绩。
2. 拍卖：每个竞拍者输入自己的出价，希望确定最高出价者，但不想泄露各自的出价金额。
3. 联合医疗数据分析：多家医院希望在不共享原始患者数据（因法律隐私限制）的前提下，共同训练一个机器学习模型。

安全多方计算的目标是：对于任何可以在明文输入上计算的函数 F，我们都能构建一个协议，使得参与方在私有输入上安全地计算 F，除了函数输出本身，不泄露任何额外的输入信息。

我们将介绍由 Ben-Or、Goldwasser 和 Wigderson 提出的 BGW 协议。这是一个信息论安全的协议。

模型与假设

在开始定义和构造之前，我们需要明确计算模型：

• 点对点认证私有信道：我们假设每对参与方之间都存在一个安全信道。这可以通过公钥加密和数字签名来实现（加密保证隐私，签名保证认证）。在此，我们抽象掉密码学细节，将其视为完美信道。
• 同步网络：我们假设协议在离散的“轮次”中执行，所有参与方在每轮中同时行动。这简化了协议设计和分析。

安全定义

定义安全多方计算的安全性非常微妙且重要。这里我们采用理想-现实模拟范式。

理想世界：存在一个完全可信的第三方。每个参与方将自己的输入 x_i 秘密地发送给这个第三方。第三方计算函数 F(x_1, ..., x_N)，然后将结果发送给各个参与方（如果函数输出对不同参与方不同，则发送相应的部分）。这是最安全的方式。

现实世界：参与方运行一个实际的分布式协议（没有可信第三方）来计算 F。

我们说一个 MPC 协议是安全的，如果对于任何能够控制至多 T 个参与方的现实世界攻击者 A，都存在一个理想世界中的模拟器 S（控制同样的 T 个参与方），使得对于所有可能的输入，攻击者在现实世界协议执行中看到的一切（包括诚实方的输出和恶意方的视图），都可以由模拟器 S 在理想世界中（仅基于恶意方的输入和最终函数输出 F）有效地模拟出来。

直观上，这意味着运行现实协议不会比把输入交给可信第三方学到更多信息。任何在现实协议中可能发生的信息泄露，在理想世界中（即仅知道输出时）也同样可能发生。

我们主要关注诚实但好奇的敌手模型：敌手控制 T 个参与方，这些参与方会诚实地遵循协议，但敌手会收集并尝试从它们接收和发送的所有消息中推断其他参与方的私有信息。通过额外的密码学工具（如零知识证明），可以将针对诚实但好奇敌手的安全协议提升至抵抗恶意敌手（即可以任意偏离协议）。

在本节课中，我们一起学习了秘密共享的基本概念、Shamir的秘密共享构造及其与纠错码的联系。我们还介绍了安全多方计算的动机、计算模型以及基于理想-现实模拟范式的强大安全定义。在接下来的课程中，我们将基于秘密共享来构建具体的 BGW 安全多方计算协议。

026：安全多方计算与BGW协议

在本节课中，我们将学习安全多方计算（MPC）的核心概念，并深入探讨BGW协议的具体构造。我们将从定义开始，逐步讲解如何通过秘密共享和本地计算，在诚实但好奇的敌手模型下安全地计算任意函数。

---

安全多方计算的定义

上一节我们介绍了秘密共享的基本概念，本节中我们来看看安全多方计算的形式化定义。

在安全多方计算中，有 n 个参与方。每个参与方 i 拥有一个私有输入 x_i。他们的共同目标是联合计算一个函数 F(x_1, ..., x_n) 的输出 y。为简化描述，我们假设所有参与方获得相同的输出 y。

安全性要求在存在 t 个被腐化的参与方（诚实但好奇模型）时，协议仍能保护隐私。具体来说，协议运行过程中，参与方通过安全信道进行通信。敌手控制 t 个参与方，他能看到这些被控方的输入，并代表他们诚实地执行协议（即遵循协议规定发送消息）。协议结束后，所有参与方输出计算结果 y。

安全性的定义基于模拟范式：对于任何控制 t 方的敌手，他在真实协议执行中看到的视图（包括被控方输入、随机数以及收发消息），都可以由一个模拟器在理想世界中模拟出来。在理想世界中，所有参与方将输入发送给一个可信第三方，后者计算 y = F(x_1, ..., x_n) 并返回给所有人。模拟器只能获得被控方的输入和最终输出 y，但他必须能生成一个与真实世界不可区分的视图分布。

这意味着，敌手在协议执行中学到的任何信息，本质上都只能从输出 y 和被控方输入中推导出来，而无法获得关于诚实方输入的任何额外信息。这个定义与零知识证明的模拟思想一脉相承。

---

BGW协议概述

接下来，我们将介绍BGW协议，它由Benny、Goldwasser和Wigderson提出。该协议能在诚实多数（即腐化方数量 t < n/2）的假设下，实现信息论安全的安全多方计算。协议无需使用加密原语，仅依赖安全信道和秘密共享。

协议主要分为三个阶段：

1. 秘密共享阶段：每个参与方将自己的输入秘密共享给所有参与方。
2. 计算阶段：参与方在秘密共享的份额上本地执行计算，模拟电路中的门运算。
3. 重建阶段：参与方交换最终输出门的份额，共同重建计算结果。

我们将详细探讨每个阶段，特别是如何处理计算阶段中的加法门和乘法门。

---

第一阶段：秘密共享

在协议开始时，每个参与方需要将自己的输入通过Shamir秘密共享方案进行分发。

对于参与方 i，其输入为 x_i。他选择一个随机的 t 次多项式 g_i(x)，并满足 g_i(0) = x_i。然后，他将份额 g_i(j) 通过安全信道发送给参与方 j（包括自己）。

由于多项式是 t 次的，任何 t 个份额的集合都无法泄露关于秘密 x_i 的任何信息。至此，所有参与方的输入都被转换为一组份额，原始输入可以被安全地擦除。

---

第二阶段：在份额上计算

计算阶段的目标是在秘密共享的份额上，安全地评估函数 F 所对应的算术电路。我们假设电路由模 p 的加法门、乘法门以及乘以常数的门组成。这是一个完备集，可以表示任何函数。

我们需要保持一个关键不变量：对于电路中的每一条线（即一个中间值），其对应的份额都来自一个随机的 t 次多项式，且该多项式在0处的取值就是这条线的真实值。

处理线性运算：加法与乘以常数

对于线性运算，计算可以在本地无交互地完成。

• 加法门：假设两条输入线 a 和 b 的份额分别来自多项式 g_a 和 g_b。输出线 c = a + b 对应的多项式定义为 g_c = g_a + g_b。参与方 i 只需本地计算 g_c(i) = g_a(i) + g_b(i) 即可获得新份额。易见 g_c(0) = g_a(0) + g_b(0) = a + b，且 g_c 仍是 t 次多项式。
• 乘以常数门：对于输入线 a 和公开常数 c，输出线 d = c * a 对应的多项式定义为 g_d = c * g_a。参与方 i 本地计算 g_d(i) = c * g_a(i) 即可。同样满足 g_d(0) = c * a，且多项式次数不变。

线性运算的安全性易于证明。模拟器可以为诚实方的输入份额生成随机值，并根据最终输出值模拟重建阶段的份额，其视图与真实协议执行不可区分。

处理乘法门

乘法门是协议中最复杂的部分，需要引入交互和再随机化步骤。目标是：给定来自 t 次多项式 g_a 和 g_b 的份额（对应值 a 和 b），得到来自一个新的随机 t 次多项式 g_{ab} 的份额，且满足 g_{ab}(0) = a * b。

直接定义 g_{ab} = g_a * g_b 的问题是，两个 t 次多项式相乘会得到一个 2t 次多项式。如果允许次数增长，后续计算将需要更多份额，可能超过参与方数量 n。

因此，BGW协议采用以下步骤处理乘法：

1. 本地计算并得到 2t 次份额：参与方 i 首先本地计算 h(i) = g_a(i) * g_b(i)。这些是 2t 次多项式 h(x) = g_a(x) * g_b(x) 在点 i 的取值，且 h(0) = a * b。

2. 再随机化：h(x) 不是随机的 2t 次多项式（它是两个特定多项式的乘积）。为了随机化，每个参与方 j 选择一个随机的 2t 次多项式 r_j(x)，满足 r_j(0) = 0。他将份额 r_j(i) 发送给每个参与方 i。然后，每个参与方 i 计算新的份额 h'(i) = h(i) + Σ_{j=1}^{n} r_j(i)。多项式 h'(x) = h(x) + Σ_{j=1}^{n} r_j(x) 现在是一个随机的 2t 次多项式（因为至少有一个诚实方贡献了随机多项式），且仍然满足 h'(0) = a * b。

3. 截断至 t 次：现在我们需要从 h' 的份额得到一个新 t 次多项式 g_{ab} 的份额，且 g_{ab}(0) = a * b。关键在于，从份额向量 (h'(1), ..., h'(n)) 到目标份额向量 (g_{ab}(1), ..., g_{ab}(n)) 的变换是一个线性变换。

   • 份额向量可以写成范德蒙矩阵 V 乘以系数向量 (h'_0, h'_1, ..., h'_{2t})。
   • 目标份额向量是 V 乘以截断后的系数向量 (h'_0, h'_1, ..., h'_t, 0, ..., 0)。
   • 因此，所需变换为：先计算 V^{-1} 得到系数，然后投影保留前 t+1 个系数，最后再乘以 V。整个复合变换是一个公开的线性变换 M。

   由于我们已掌握如何安全计算线性函数（通过本地计算线性函数后，将结果的份额仅发送给目标参与方），我们可以利用此子协议。每个参与方将 h'(i) 作为输入，运行安全计算线性函数 M 的协议。最终，参与方 i 获得 g_{ab}(i)，即所需随机 t 次多项式的份额。

完成乘法门计算后，我们得到了满足不变量的新份额，可以继续后续电路的计算。

---

第三阶段：输出重建

当电路计算到达输出线时，所有参与方持有最终输出值 y 对应的一个随机 t 次多项式的份额。

为了重建输出 y，每个参与方 i 将自己的最终份额广播给所有人。由于多项式是 t 次的，只要收到 t+1 个正确份额，任何参与方都可以通过拉格朗日插值恢复多项式，并计算 g_{out}(0) = y 作为最终输出。

---

总结

本节课中我们一起学习了BGW协议，这是一个在诚实多数假设下实现信息论安全的安全多方计算协议。其核心思想是将输入通过秘密共享分散，然后在份额上模拟电路运算。

以下是协议的关键步骤回顾：

• 秘密共享：每个参与方分享其输入。
• 线性计算：加法和数乘可在本地无交互完成。
• 乘法计算：需要交互，通过本地相乘、再随机化、并利用安全线性计算协议截断多项式次数来实现。
• 输出重建：参与方交换最终份额以恢复计算结果。

BGW协议展示了如何不依赖复杂密码学原语，仅通过秘密共享和线性代数来构造强大的安全计算协议。它也为理解更复杂的、能抵抗恶意敌手或适用于任意多数情况的MPC协议奠定了重要基础。

027：量子密码学与未来展望

在本节课中，我们将探讨量子计算对密码学领域的深刻影响，并展望该领域的未来研究方向。我们将从三个不同的发展阶段来理解量子密码学：后量子时代、迷你量子时代和量子狂热时代。每个阶段都带来了独特的挑战与机遇，我们将逐一解析。

后量子密码学：对抗量子对手

上一节我们介绍了量子计算的基本概念，本节中我们来看看第一个发展阶段——后量子密码学。在这个阶段，我们仍使用经典计算机和经典密码方案，但需要防范拥有量子计算机的对手。这意味着，我们今天设计的密码系统，必须能够抵御未来可能出现的量子攻击。

核心挑战在于，许多经典密码学证明依赖于“重绕”对手的能力，这在量子世界中因“不可克隆原理”而失效。量子态一旦被观测就会坍缩，无法被复制。因此，将经典安全证明直接移植到量子环境通常行不通，甚至一些基本定义（如承诺方案的“绑定”性）也需要重新审视和修正。

以下是后量子密码学的核心要点：

• 目标：设计能抵御量子攻击的经典密码方案。
• 核心假设：依赖如LWE（带误差学习） 等被认为量子计算机也难以攻破的数学难题。
• 主要挑战：
  • 证明失效：许多经典安全证明（尤其是交互式协议）依赖重绕技巧，这在量子设定下不成立。
  • 定义更新：一些经典密码学定义（如承诺的绑定性）在量子语境下无法体现其原本意图，需要新的定义（如“坍缩绑定性”）。

迷你量子密码学：安全外包量子计算

在迷你量子时代，世界上出现了少数几台大型量子计算机，我们可以像使用云服务一样使用它们。核心问题变为：如何在不信任量子服务提供商的情况下，安全地委托其进行量子计算？

这引出了两个关键需求：保密性和完整性。保密性要求服务方无法得知我们的输入数据，这催生了量子全同态加密的研究，使得能在加密数据上直接进行量子计算。完整性则要求我们能验证量子计算结果的正确性，这是一个非常活跃且尚未完全解决的研究方向。

以下是该领域的关键问题与方法：

• 保密性：通过量子全同态加密实现，允许对加密数据执行量子计算。
• 完整性（验证）：如何让经典验证者高效地验证量子计算的正确性？
  • 计算可靠性模型：假设攻击者也是量子多项式时间，则可以构造论证系统。
  • 多证明者交互证明：利用两个互不通信的证明者（可能共享量子纠缠）来验证。借助全同态加密，理论上可将两证明者系统转化为单证明者系统，但其安全性在某些量子场景下仍是开放问题。

量子狂热密码学：量子原生应用

在量子狂热时代，假设人人都拥有量子设备，通信也以量子方式进行。这时，量子力学特性（主要是不可克隆原理）能让我们实现经典世界中不可能或极其困难的任务。

量子不可克隆原理开启了全新的密码学应用范式。例如，可以创建无法伪造复制的量子货币，或者只能执行一次的一次性程序。此外，还能实现一次性签名，即一个量子令牌只能用于签署一条消息，之后便会失效。甚至可以向他人证明自己生成了真正的随机数。

这些应用展示了量子密码学超越经典范畴的潜力，为构建全新的安全协议和金融基础设施提供了可能。

总结

本节课我们一起探索了量子密码学的三个发展阶段。我们从需要抵御量子攻击的后量子密码学出发，讨论了其面临的证明与定义挑战。接着，我们审视了迷你量子时代下安全外包量子计算的问题，涉及量子全同态加密与计算验证。最后，我们展望了量子狂热时代，看到了基于量子特性（如不可克隆原理）实现的诸多神奇应用，如量子货币和一次性程序。

量子计算正在重塑密码学的边界，既带来了破解经典体系的威胁，也孕育着构建更强大安全原语的机会。理解这些发展阶段，有助于我们为即将到来的量子未来做好准备。

028：课程总结与展望

在本节课中，我们将回顾本学期所学的核心密码学概念，并探讨密码学与前沿机器学习领域（特别是大型语言模型）交叉所面临的挑战与机遇。

课程内容回顾

上一节我们介绍了本节课的总体计划。本节中，我们来回顾本学期所学的核心模块。

模块一：私钥密码学与安全通信

我们从信息论安全开始，但发现其局限性，例如一次性密码本无法实现安全的多消息加密。核心突破在于用计算困难性换取随机性，即引入计算安全性。

• 核心工具链：从单向函数出发，我们可以构建伪随机数生成器，进而构建伪随机函数。
• 核心公式/代码：PRG -> PRF -> 安全加密方案与消息认证码。
• 成果：实现了共享密钥下的安全通信（加密与认证）。

模块二：公钥密码学

当通信双方无法预先共享密钥时，我们需要公钥密码学。这里我们首次使用了具体的数学工具。

• 数字签名：可以从单向函数（或抗碰撞哈希函数）构造，是消息认证码的公钥对应物。
• 公钥加密：需要基于特定的数论或格上困难问题（如DDH、带陷门的单向函数、LWE）来构造。
• 全同态加密：基于格密码学（LWE），我们不仅能加密数据，还能在密文上直接进行计算。
• 成果：实现了无需预先共享密钥的安全通信与保密计算。

模块三：证明系统

我们探讨了如何证明陈述的正确性，同时控制信息的泄露。

• 零知识证明：可以将任何数学证明转化为不泄露任何额外信息的交互式证明。
• 非交互式零知识证明：通过用哈希函数（在随机预言机模型下）替代验证者的随机挑战，可以将交互式证明转化为非交互式证明。
• 简洁证明：目标是将很长的证明压缩成很短的证书。核心是Sum-Check协议，它能高效地验证一个低次多项式在所有布尔超立方顶点上的和。
• GKR协议：利用Sum-Check，可以为深度较小的电路计算生成简洁证明。
• 通用简洁证明：通过电路扁平化并结合多项式承诺方案，可以为任意NP陈述生成简洁证明。
• 成果：实现了证明的零知识性与简洁性。

模块四：安全多方计算

多方在不泄露各自私有输入的情况下，共同计算一个函数。

• 秘密共享：使用低次多项式将秘密分散给多个参与者。
• BGW协议：允许各方在秘密共享的数据上协同计算（特别是加法和乘法），最终重建输出。
• 成果：实现了隐私保护下的协同计算。

模块五：专题——量子密码学

我们简要探讨了量子计算对密码学的挑战（后量子密码学）与机遇（量子密码学）。鉴于大规模量子计算机可能被建造，升级现有密码体系并利用量子特性至关重要。

前沿交叉：密码学与机器学习安全

回顾了经典密码学后，本节我们来看看一个新兴且至关重要的交叉领域：如何运用密码学的思想来保障机器学习（尤其是大型语言模型）的安全与对齐。

机器学习模型（如LLMs）已深度融入生活，但其输出可能存在错误、恶意内容或不符人类价值观的风险。密码学，尤其是其对抗性思维和形式化定义安全的能力，可以为此提供关键工具。

以下是该领域一些重要的开放性问题：

• 可验证推理：如何让LLM为其输出（特别是事实性回答或代码）提供可验证的正确性证明？挑战在于许多问题没有明确的“正确答案”。
• 隐写术与后门：如何防止恶意模型在输出中嵌入难以察觉的有害信息（隐写术）或在特定触发条件下表现出恶意行为（后门）？单纯检查输出可能不足。
• 水印与溯源：如何为LLM生成的内容添加“水印”，以区分机器生成与人类创作，或保护数据版权？
• 训练数据证明：模型提供者如何向外界证明其模型仅使用了被允许的（如公开）数据训练，而未侵犯私有数据？
• 安全聚合：当面对多个未知是否安全的模型时，如何通过聚合它们的输出，确保最终结果来自安全模型（类比于安全多方计算）？

这些问题的解决不仅需要机器学习知识，更核心的是密码学所擅长的：在强大对手面前，如何形式化定义安全目标并设计满足该目标的方案。

课程总结与反馈

本节课中，我们一起回顾了从私钥加密到安全多方计算的密码学核心脉络，并展望了密码学在应对机器学习安全挑战中的关键作用。密码学不仅是关于加密的艺术，更是一套用于在敌对环境中定义和实现安全目标的强大框架。

我们鼓励大家继续探索密码学的深度与广度，并考虑将所学应用于如AI安全等新兴关键领域。最后，请务必提交课程反馈，你们的意见对课程的持续改进至关重要。

问答环节

现在，我将回答大家关于课程内容、研究、MIT或任何其他方面的疑问。