🤫 零知识证明

🧠 零知识证明：密码学最优雅的发明

1985 年，Goldwasser、Micali 和 Rackoff 在论文中定义了零知识证明 (Zero-Knowledge Proof, ZKP)：一个证明者 (Prover) 可以向验证者 (Verifier) 证明某个声明为真，而不泄露任何超出声明本身的信息。

三个核心性质

经典直觉例子：阿里巴巴洞穴

最著名的 ZKP 直觉解释是 Jean-Jacques Quisquater 等人的"阿里巴巴洞穴"故事：

• 洞穴有一个环形通道，中间有一扇需要密码才能打开的门
• Peggy 声称知道密码，但不想告诉 Victor
• Victor 随机选择让 Peggy 从左边或右边出来
• 如果 Peggy 真的知道密码，她总能从指定方向出来（穿过中间的门）
• 如果 Peggy 不知道密码，有 50% 概率猜错方向
• 重复 n 次后，不知道密码的概率降至 2^-n

这是一个交互式零知识证明。现代 ZKP 系统（SNARK/STARK）是非交互式的——证明者生成一个证明，验证者可以离线验证。

ZKP 的关键分类维度

⚡ zk-SNARK vs zk-STARK：两大主流方案

zk-SNARK：简洁非交互知识论证

zk-SNARK (Zero-Knowledge Succinct Non-interactive Argument of Knowledge) 是目前最广泛使用的 ZKP 方案。Zcash 最初使用它实现隐私交易。

SNARK 变体对比

递归证明：ZKP 的"组合"超能力

递归证明 (Recursive Proof) 是 ZKP 最强大的特性之一——一个 ZKP 可以验证另一个 ZKP。这意味着：

• 证明聚合：1000 个交易的证明可以聚合成一个证明，验证者只需验证一个证明
• 增量计算：长计算的每一步都可以单独证明，然后递归聚合
• 跨链桥：用 ZKP 证明另一条链的状态转换，无需信任桥接节点
• 可验证计算：证明"我确实按照这个程序执行了"，适用于 AI 推理验证

🤖 零知识证明的 AI 应用

现实应用案例

🧮 zkML：零知识机器学习

zkML (Zero-Knowledge Machine Learning) 是 ZKP 与 ML 的交叉领域——用零知识证明来验证机器学习推理过程。这是 AI 时代 ZKP 最有前途的应用方向之一。

zkML 的三种模式

zkML 技术栈

zkML 当前性能（截至 2025）

zkML 的替代方案：不一定要证明整个模型

• 选择性证明：只证明模型的最后几层或关键决策步骤
• 模型蒸馏后证明：将大模型蒸馏为小模型，对小模型做 ZKP
• TEE + ZKP 混合：用 TEE 保护模型执行，用 ZKP 证明 TEE 状态
• 乐观验证 + 挑战期：先信任推理结果，设置挑战期，有人质疑时才做 ZKP

💻 代码示例

Circom：编写 ZKP 电路

Circom 是最流行的 ZKP 电路语言，配合 snarkjs 使用：

// range_check.circom — 证明一个值在 [0, max) 范围内
// 实际应用：证明年龄 ≥ 18 而不泄露具体年龄

pragma circom 2.1.5;

template RangeCheck(n) {
    // 证明 input 在 [0, 2^n) 范围内
    signal input in;
    signal output out;

    // 使用位分解证明值在范围内
    component bits[n];
    for (var i = 0; i < n; i++) {
        bits[i] = Num2Bits(1);
    }

    // 约束：重构的值必须等于输入
    // 这是零知识证明的核心——通过约束保证计算的正确性
}

// 更实用的例子：证明 age >= 18 而不泄露具体年龄
template AgeVerification() {
    signal input age;        // 私有输入：实际年龄
    signal input difference; // 私有输入：age - 18
    signal output isValid;   // 公开输出：是否 ≥ 18

    // 约束：age - 18 = difference
    // 如果 age < 18，difference 会溢出，约束失败
    component isPositive = GreaterEqThan(8); // 8位足够表示年龄差
    isPositive.in[0] <== age;
    isPositive.in[1] <== 18;
    isValid <== isPositive.out;
}

component main {public [isValid]} = AgeVerification();

snarkjs：生成和验证证明

# 1. 编译电路
circom age_verification.circom --r1cs --wasm --sym

# 2. 可信设置 (Powers of Tau Ceremony)
snarkjs powersoftau new bn128 12 pot12_0000.ptau -v
snarkjs powersoftau contribute pot12_0000.ptau pot12_0001.ptau \
  --name="First contribution" -v

# 3. 电路特定设置 (Phase 2)
snarkjs setup --r1cs age_verification.r1cs \
  --pk verification_key.json \
  --vk proving_key.json

# 4. 生成证明
# input.json: {"age": 25, "difference": 7}
snarkjs calculatewitness age_verification.wasm input.json
snarkjs proof proving_key.json witness.wtns proof.json public.json

# 5. 验证证明 — 验证者只需要 verification_key + proof + public 输出
# 验证者不知道 age = 25，只知道 isValid = 1
snarkjs verify verification_key.json public.json proof.json
# 输出: [INFO] snarkJS: OK!

# ⚡ 关键：验证者只知道"这个人 ≥ 18 岁"，不知道具体年龄！

Python：模拟零知识证明的交互式协议

import random
import hashlib

"""
简化版交互式 ZKP：证明知道离散对数
场景：Peggy 知道 x 使得 g^x = y (mod p)
她想证明知道 x 而不泄露 x
"""

# 参数（实际中 p 是大素数，如 2048 位）
p = 2**127 - 1  # 梅森素数（仅演示，实际用安全素数）
g = 2           # 生成元
x = 42          # Peggy 的秘密
y = pow(g, x, p)  # 公开值：g^x mod p

def peggy_commit():
    """Peggy 生成承诺：随机选 r，发送 g^r"""
    r = random.randint(2, p - 1)
    commitment = pow(g, r, p)
    return r, commitment

def victor_challenge():
    """Victor 发送随机挑战 c"""
    return random.randint(0, 1)

def peggy_respond(r, c, x):
    """Peggy 根据挑战计算响应"""
    if c == 0:
        return r          # 响应 = r
    else:
        return (r + x) % (p - 1)  # 响应 = r + x

def victor_verify(commitment, c, s, y, g, p):
    """Victor 验证响应"""
    if c == 0:
        return pow(g, s, p) == commitment
    else:
        return pow(g, s, p) == (commitment * y) % p

# 运行交互式协议 n 轮
n_rounds = 20
all_passed = True
for i in range(n_rounds):
    r, commitment = peggy_commit()
    c = victor_challenge()
    s = peggy_respond(r, c, x)
    if not victor_verify(commitment, c, s, y, g, p):
        all_passed = False
        break

if all_passed:
    print(f"✅ {n_rounds} 轮全部通过 — 以 1-2^(-{n_rounds}) 概率确认 Peggy 知道 x")
    print(f"   Victor 仍然不知道 x 的值是多少！")
else:
    print("❌ 验证失败")

EZKL：ML 模型的零知识证明

# 安装 EZKL
# pip install ezkl

import ezkl
import json
import torch
import torch.nn as nn

# 定义简单模型（MNIST 分类器）
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

model = SimpleModel()
model.eval()

# 导出 ONNX
dummy_input = torch.randn(1, 784)
torch.onnx.export(model, dummy_input, "model.onnx")

# 生成 EZKL 设置
ezkl.gen_settings("model.onnx", "settings.json")

# 生成电路
ezkl.calibrate_settings(
    "settings.json",
    "model.onnx",
    "input.json",  # 包含测试输入数据
    "resources"     # 资源限制
)

# 编译电路 → 生成证明 → 验证
ezkl.compile_circuit("model.onnx", "model.ezkl", "settings.json")
ezkl.setup("model.ezkl", "settings.json", "vk.key", "pk.key")
ezkl.prove("model.ezkl", "input.json", "witness.json",
           "pk.key", "proof.json", "settings.json")
result = ezkl.verify("proof.json", "settings.json", "vk.key")
print(f"✅ ZKP 验证结果: {result}")

⚠️ 零知识证明的挑战与局限

📖 学习资源