Sigma 协议之舞：承诺、挑战、响应

你有没有想过什么是 Σ-protocol？

有趣的是，“Sigma”这个名字来自希腊字母 Σ。它看起来有点像一个之字形，就像这个 protocol 执行的三步过程一样 ?

Sigma 可能是最基础的“zero-knowledge proof of knowledge” ? protocol：在不泄露 secret 本身的情况下，证明你知道某个 secret。

你，作为 prover，知道一些满足某种关系的 private value(s)，并且想在不泄露 $x$ 的情况下说服 verifier 这件事是真的。

The three steps Sigma dance

1. Commitment: prover 向 verifier 发送一个初始 commitment

2. Challenge: verifier 回复一个随机 challenge

3. Response: prover 使用 secret 和 challenge 作答

通过 response，verifier 会相信 prover 一定知道一个满足该关系的有效 witness，而整个过程中从未见过它。

后面我们会看到如何通过 Fiat-Shamir 让第 2 步变成 non-interactive。

Notation

Cryptographers 常常使用乘法记号来写这些内容（比如 $gx \cdot hr$），但由于大多数真实实现都使用椭圆曲线，我会使用加法记号（$x \cdot G + r \cdot H$）。

相同的数学，不同的写法。

在本文中，我们使用：

• $G$：一个 elliptic curve generator
• $H$：另一个独立的 generator

The Schnorr protocol

Schnorr protocol 是 Σ-protocol 最简单的例子，也是 zero-knowledge proofs 的“hello world” ?

下面是设置：

你，作为 prover，想要证明你知道一个 witness $x$，使得

$$Y = x \cdot G$$

其中 $x$ 是一个 scalar，因此 $Y$ 是一个 public curve point。

在实践中，这就相当于证明你知道与 public key $Y$ 对应的 private key $x$。

Step by step:

1. Commitment

你选取一个随机 scalar $r$，并发送一个关于该随机值的 commitment $T$

$$T = r \cdot G$$

2. Challenge

Verifier 返回一个随机 challenge $c$，这是一个随机 scalar（域中的一个数，不是 elliptic curve point）。

3. Response

你回复

$$s = r + c \cdot x$$

最后，verifier 检查

$$s \cdot G = ?T + c \cdot Y$$

如果成立就接受。

Why it works?

让我们代入看看：

$$s \cdot G = T + c \cdot Y = (r + x \cdot c)\cdot G = r \cdot G + c \cdot x \cdot G = T + c \cdot Y$$

所以如果 verifier 的检查通过，这意味着你一定知道正确的 $x$。

同时，$r$ 会把 $x$ 隐藏起来，transcript 不会泄露任何相关信息。

让我们使用 SageMath 看看整个过程是如何运行的。

我们会使用一个较小的 toy elliptic curve 来让数字更易处理，但逻辑与真实世界中的 cryptography 是一样的。

p = 929
Fp = GF(p)
E = EllipticCurve(Fp, [5, 15])
G = E.gens()[0]
Fr = GF(G.order())

现在让我们一步步走过 Schnorr Sigma protocol：

x = Fr(123)
Y = x * G

r = Fr.random_element()
T = r * G

print("向 verifier 发送 commitment T")

print("challenge 应该这样计算：c = hash(G, Y, T)")
c = Fr.random_element()

s = r + c * x

print("向 verifier 发送 s")
assert s * G == T + c * Y
print("Proof is valid")

Witness Extraction (a.k.a Soundness)

那么，我们怎么知道 prover 真的知道 witness $x$ 呢？

这就是 knowledge soundness 的作用：如果某人能用相同的 commitment 成功说服 verifier 两次，那么我们就能从这两次运行中 extract 出 witness。

在 Schnorr protocol 中，它是这样工作的：

我们知道 commitment 是

$$T = r \cdot G$$

并且对于两个使用相同 $r$、但 challenges 不同的成功 transcript $c$ 和 $c'$，有：

$$s = r + x \cdot c \qquad s' = r + x \cdot c'$$

如果我们把这两个等式相减，随机性 $r$ 就消失了：

$$s - s' = (c - c') \cdot x$$

从而我们可以恢复 witness：

$$x = \frac{s - s'}{c - c'}$$

就是这样：witness extraction！

这个性质叫做 special soundness，它是 Σ-protocol 的定义性特征之一。

它保证没有人能在实际上不知道 $x$ 的情况下“伪造” proof。换句话说：如果你能用相同的 commitment 回应两个不同的 challenge，那你一定知道 witness。

H = E.random_point()

## 已知 commitment
v = Fr(123)
r = Fr.random_element()
print(f"v: {v}, r: {r}")
C = v * G + r * H

v_prime = Fr.random_element()
r_prime = Fr.random_element()
A = v_prime * G + r_prime * H

print("向 verifier 发送 commitments C 和 A")

print("challenge 应该这样计算：hash(G, H, C, A)")
c = Fr.random_element()

s1 = v_prime + c * v
s2 = r_prime + c * r

print("向 verifier 发送 (c, s1, s2)")
assert s1 * G + s2 * H == A + c * C
print("Proof is valid")

c_prime = Fr.random_element()
s1_prime = v_prime + c_prime * v
s2_prime = r_prime + c_prime * r

print("向 verifier 发送 (c_prime, s1_prime, s2_prime)")
assert s1_prime * G + s2_prime * H == A + c_prime * C
print("Proof is valid")

print("\n让我们尝试恢复 v 和 r")
assert s1_prime * G + s2_prime * H - c_prime * C == s1 * G + s2 * H - c * C
assert (s1_prime - s1) * G + (s2_prime - s2) * H + (c - c_prime) * C == 0

## s1 G + s2 H + cv G + cr H = 0
## (s1 + cv) G + (s2 + cr) H = 0
## 所以我们有：
## . s1_prime - s1 + (c - c_prime) * v = 0 -> v = (s1 - s1_prime) / (c - c_prime)
## . s2_prime - s2 + (c - c_prime) * r = 0 -> r = (s2 - s2_prime) / (c - c_prime)

print("\nRecovered v and r:")
recovered_v = (s1 - s1_prime) / (c - c_prime)
recovered_r = (s2 - s2_prime) / (c - c_prime)
print(f"recovered_v: {recovered_v}, recovered_r: {recovered_r}")
assert recovered_v == v
assert recovered_r == r

Composing Σ-proofs

现在我们已经掌握了基础，可以开始做些有趣的事情：组合 Sigma proofs！?

Equality proof: two values share the same secret

假设你有一个 secret $x$，以及两个 public values $Y$ 和 $Z$：

$$Y = x \cdot G \qquad Z = x \cdot H$$

你的目标是：说服 verifier，$Y$ 和 $Z$ 都来自同一个 secret $x$，而且这个 secret 确实由你掌握。

1. Commitment

选一个随机 $r$：

$$T_g = r \cdot G \qquad T_h = r \cdot H$$

2. Challenge

Verifier 发送一个随机 challenge $c$

3. Response

$$s = r + c \cdot x$$

4. Verification

$$s \cdot G = ?T_g + c \cdot Y \qquad s \cdot H = ?T_h + c \cdot Z$$

如果两个等式都成立，你就成功证明了同一个 secret $x$ 被用于这两个 public values 中，而没有泄露它。

AND proof: you know both secrets

现在假设有两个独立的 secrets $a$ 和 $b$：

$$Y = a \cdot G \qquad Z = b \cdot H$$

你想证明你知道它们两个。

选一个随机 $r$，并发送：

$$T_g = r \cdot G \qquad T_h = r \cdot H$$

收到 $c$ 后，发送最终 response：

$$s_a = r + c \cdot a \qquad s_b = r + c \cdot b$$

Verifier 检查

$$s_a \cdot G = ?T_g + c \cdot Y \qquad s_b \cdot H = ?T_h + c \cdot Z$$

如果两个检查都通过，你就证明了你同时知道 $a$ 和 $b$。

OR proof: you know one of two secrets

这个稍微复杂一些，但也更有趣！

我们有相同的设置：

$$Y = a \cdot G \qquad Z = b \cdot H$$

但现在 你只知道其中一个 secret（比如 $a$），而你想证明你知道 either $a$ or $b$，但不透露是哪一个。

How do you do that?

思路很巧妙：我们会并行运行两个 proof，一个对应每个 relation，但其中一个（我们不知道的那个）会被模拟出来。

为了让模拟与真实 proof 无法区分，我们将使用 两个 challenges $c_1$ 和 $c_2$，由 prover 选择。

唯一规则：它们必须加起来等于 verifier 的 challenge $c$：

$$c_1 + c_2 = c$$

这确保整体 proof 仍然符合 Σ-protocol 结构：verifier 只发送一个 challenge，但内部会被“拆分”给两个 subproof。

技巧如下：

• 对于你 不知道 的 secret，你会伪造一个看起来有效的 fake transcript。
• 对于你 知道 的 secret，你会用 $a$ 和 verifier 的 challenge $c$ 诚实地计算 response。

这样，verifier 会看到两个看起来都有效的 proof，但无法分辨哪一个是模拟出来的。

1. Commitment

照常选一个随机 $r$ 并计算：

$$T_1 = r \cdot G$$

对于你 不知道 的 secret（这里是 $b$）：

• 选取随机值 $s_2$ 和 $c_2$
• 以一种能强制最终检查通过的方式计算对应的 commitment：

$$T_2 = s_2 \cdot H - c_2 \cdot Z$$

把两个 commitments $(T_1, T_2)$ 发送给 verifier。

注意，$T_2$ 只使用 public point $Z$，而不是 secret scalar $b$，因为我们不知道它。

2. Challenge

现在，verifier 发送 challenge $c$

3. Response

我们不直接使用 $c$，而是把它拆分：

$$c_1 = c - c_2$$

然后为你知道的那一侧计算真实 response：

$$s_1 = r + c_1 \cdot a$$

记住，我们已经有了 $s_2$，它之前是随机生成的。

把 $(s_1, s_2, c_1, c_2)$ 作为 response 发送。

4. Verification

$$s_1 \cdot G = ?T_1 + c_1 \cdot Y \qquad s_2 \cdot H = ?T_2 + c_2 \cdot Z \qquad c = ?c_1 + c_2$$

Why It Works

• 第一个等式是针对你知道的 secret（$a$）的真实 Σ-proof
• 第二个等式是假的，但仍然一致，因为你构造 $T_2$ 时就让它对你选择的 $s_2,c_2$ 通过检查
• verifier 无法分辨哪一部分是模拟出来的

所以 verifier 只知道一件事：你知道 either a or b, 别的什么也不知道。

这就是一个 OR proof，它是许多 ZK systems 中“selective disclosure”的基础。

现在让我们看看 Sigma protocols 如何与 Pedersen commitments 一起工作。

H = E.random_point()

## 已知 commitment
x = Fr(123)
P1 = x * G

## 未知 commitment
P2 = E.random_point()

print("向 verifier 发送 P1 和 P2")

r = Fr.random_element()
T1 = r * G

c2 = Fr.random_element()
s2 = Fr.random_element()
T2 = s2 * H - c2 * P2

print("向 verifier 发送 T1 和 T2")
print("Verifier 发送 challenge c")
c = Fr.random_element()

c1 = c - c2

s1 = r + c1 * x

print("向 verifier 发送 (c1, c2, s1, s2)")
assert s1 * G == T1 + c1 * P1
assert s2 * H == T2 + c2 * P2
assert c1 + c2 == c
print("Proof is valid")

Pedersen commitments

Pedersen commitments 在 zero-knowledge proofs 中无处不在。它们简单、强大，而且像密码学保险箱一样隐藏 secret。

$$P = x \cdot G + r \cdot H$$

其中：

• $x$ 是你要承诺的 witness
• $r$ 是一个随机 blinding factor
• $G$ 和 $H$，你已经知道了

Pedersen commitments 具有 hiding 性质。得益于随机性 $r$，没有人能从 $P$ 猜出 $x$；同时也具有 binding 性质，一旦你发布了 $P$，之后就不能再改变对 $x$ 的说法（除非你能解决 discrete log problem）。

The additive ➕ magic

Pedersen commitments 还具有 additively homomorphic 性质，这意味着 commitments 可以很好地相加：

$$P_1 = x_1 \cdot G + r_1 \cdot H \qquad P_2 = x_2 \cdot G + r_2 \cdot H \qquad P_1 + P_2 = (x_1 + x_2)\cdot G + (r_1 + r_2)\cdot H$$

换句话说，把两个 commitment 相加，你就得到了它们底层值之和的 commitment。

这一性质使 Pedersen commitments 在更大的 ZK systems 中极其灵活。

要 open 一个 commitment，你只需要公开 $x$ 和 $r$。

Pedersen + Σ

现在事情变得有趣了。

假设有一个公开的 Pedersen commitment $P$，它隐藏着你的 private key $x$。

有人要求你证明你确实知道 $x$，但当然，你不想把它泄露出来。如果你直接发送你的 key，那就完全失去意义了！

因此，你使用一个 Σ -protocol 来证明你知道该 commitment 的 opening。

Prove knowledge of the opening $(x, r)$

过程如下：

1. Commitment

选取随机值 $r_x$ 和 $r_r$，并发送：

$$T = r_x \cdot G + r_r \cdot H$$

2. Challenge: verifier 选择一个随机 challenge $c$

3. Response:

计算你的 responses：

$$s_x = r_x + c \cdot x \qquad s_r = r_r + c \cdot r$$

4. Verification

Verifier 检查：

$$s_x \cdot G + s_r \cdot H = ?T + c \cdot P$$

如果成立，他就相信你知道 witness $(x, r)$，而且它们从未被泄露。

H = E.random_point()

x = Fr(123)
r = Fr.random_element()
C = x * G + r * H

print("向 verifier 发送 commitment C")

r1 = Fr.random_element()
r2 = Fr.random_element()
T = r1 * G + r2 * H

print("向 verifier 发送 T")

print("challenge 应该这样计算：c = hash(G, H, C, T)")
c = Fr.random_element()

s1 = r1 + c * x
s2 = r2 + c * r

print("向 verifier 发送 (s1, s2)")
assert s1 * G + s2 * H == T + c * C
print("Proof is valid")

Combining proofs with Pedersen commitments

就像我们之前基于 elliptic curve points 组合 Sigma proofs 一样，使用 Pedersen commitments 时我们也可以这样做。

这次我们会快一点。模式是相同的，只是涉及的部分更多。

Two commitments, one secret

假设我们有 两个 Pedersen commitments，它们都应该隐藏同一个 secret value $x$。

我们想证明这是真的，并且我们确实知道 $x$。

为了表述清楚：

• $b_1, b_2$ 将是每个 commitment 内部的 blinding factors
• $r$ 值是 Σ protocol 本身使用的随机性

这两个 commitments 是：

$$P_1 = x \cdot G + b_1 \cdot H \qquad P_2 = x \cdot G + b_2 \cdot H$$

选取三个随机值 $r_x, r_{b1}, r_{b2}$，并发送：

$$T_1 = r_x \cdot G + r_{b1} \cdot H \qquad T_2 = r_x \cdot G + r_{b2} \cdot H$$

我们从 verifier 接收 challenge $c$，并发送 responses：

$$s_1 = r_x + c \cdot x \qquad s_2 = r_{b1} + c \cdot b_1 \qquad s_3 = r_{b2} + c \cdot b_2$$

Verifier 检查

$$s_1 \cdot G + s_2 \cdot H = ?T_1 + c \cdot P_1 \qquad s_1 \cdot G + s_3 \cdot H = ?T_2 + c \cdot P_2$$

H = E.random_point()

print("这里我们证明同一个 value 被编码在 2 个 Pedersen commitments 中")

x = Fr(123)
b1 = Fr.random_element()
b2 = Fr.random_element()
P1 = x * G + b1 * H
P2 = x * G + b2 * H

print("向 verifier 发送 commitments P1 和 P2")

r_x = Fr.random_element()
r_b1 = Fr.random_element()
r_b2 = Fr.random_element()

T1 = r_x * G + r_b1 * H
T2 = r_x * G + r_b2 * H

print("向 verifier 发送 T1 和 T2")

print("challenge 应该这样计算：hash(G, H, P1, P2, T1, T2)")
c = Fr.random_element()

s1 = r_x + c * x
s2 = r_b1 + c * b1
s3 = r_b2 + c * b2

print("向 verifier 发送 (c, s1, s2)")
assert s1 * G + s2 * H == T1 + c * P1
assert s1 * G + s3 * H == T2 + c * P2
print("Proof is valid")

和之前一样，你也可以在 Pedersen commitments 之上构建 AND 或 OR proofs，证明你知道两个 openings，或者你知道至少一个 commitment 的 opening。

作为礼物，这里是 Pedersen OR proof 的代码：

H = E.random_point()

## 已知 commitment
x = Fr(123)
blinding = Fr.random_element()
P1 = x * G + blinding * H

## 未知 commitment
P2 = E.random_point()

print("向 verifier 发送 P1 和 P2")

r_x = Fr.random_element()
r_r = Fr.random_element()
T1 = r_x * G + r_r * H

c2 = Fr.random_element()
s2_x = Fr.random_element()
s2_r = Fr.random_element()
T2 = s2_x * G + s2_r * H - c2 * P2

print("向 verifier 发送 T1 和 T2")
print("Verifier 发送 challenge c")
c = Fr.random_element()

c1 = c - c2

s1_x = r_x + c1 * x
s1_r = r_r + c1 * blinding

print("向 verifier 发送 (c1, s1_x, s1_r), (c2, s2_x, s2_r) 到 verifier")
assert s1_x * G + s1_r * H == T1 + c1 * P1
assert s2_x * G + s2_r * H == T2 + c2 * P2
assert c1 + c2 == c
print("Proof is valid")

Fiat-Shamir: making it non-interactive

到目前为止，我们的所有 protocol 都是 interactive 的。prover 在完成某些值的 commitment 之后，需要从 verifier 那里接收随机 challenge。

但在许多真实场景中（比如数字签名或 blockchain proofs），并没有一个实时的 verifier 在场。

这时 Fiat–Shamir 就派上用场了。

我们不再让 verifier 发送 $c$，而是用 hash function 确定性地 计算 它。

$$c = H(\text{transcript})$$

hash 扮演 verifier 的角色：它生成一个在 commitment 之前不可预测、但在之后又是确定的 challenge。

但我们必须非常小心地决定哪些内容进入 transcript。

• 如果你遗漏了某些内容，prover 就可能在看到 challenge 后再修改自己的 commitment
• 如果你加入了太多内容，比如 private data，verifier 就无法重新计算 hash 并验证 proof

What to include in the hash?

通常，transcript 应该包括：

• protocol 的 public parameters：$G$ 和 $H$
• public inputs（例如 Pedersen commitment $P$）
• prover 的初始 commitment $t$
• 可选地，添加一个 domain separator 以避免跨 protocol collisions

这些内容确保 challenge $c$ 绑定到正确的上下文，并且无法被提前预测。

Unpredictable challenge

为什么 prover 无法预测 challenge $c$ 如此关键？

如果 prover 能在选择 $t$ 之前猜到 challenge $c$，他就能在实际上不知道 secret $x$ 的情况下伪造一个有效 proof。

让我们看看怎么做到这一点：

prover 生成一个随机 $s$（通常在第 3 步发送的值），并计算：

$$T = s \cdot G - c \cdot Y$$

Verifier 无法区分一个正确构造的 $(T, s)$ 和一个“伪造”的。

Verifier 检查：

$$T + c \cdot Y = ?s \cdot G$$

它完全成立：

$$T + c \cdot Y = (s \cdot G - c \cdot Y) + c \cdot Y = s \cdot G$$

Boom ? verifier 被骗了，尽管 prover 从未知道 $x$。

这就是为什么 Fiat–Shamir challenge 必须从 prover 的视角真正不可预测。

他们必须先完成 commitment，然后才能从 public transcript 中导出 challenge。绝不能反过来。

Schnorr signature

在结束之前，让我们看看 Schnorr signatures 是如何构造的。

现在我们理解了 challenge 如何来自 Fiat–Shamir transform，你会发现 Schnorr signature 其实就是一个 non-interactive Sigma protocol，再附加上一条 message。

和之前一样的设置：

• private key $x$
• public key $Y = x \cdot G$
• random nonce $r$ 及其 commitment $T = r \cdot G$

但这一次，我们要签名一条 message $m$。

Compute the challenge

我们使用 hash function 来派生 challenge。

通常，它会是：

$$c = H(G, Y, T)$$

但因为我们是在签某个东西，所以要把 message 也包括进 hash：

$$c = H(G, Y, T, m)$$

这使得 signature 绑定到那条特定的 message。

Compute the final value

这就是我们之前称为“response”的东西。但由于 protocol 不再 interactive，这么叫就有点奇怪了。

$$s = r + c \cdot x$$

最终的 signature 是 pair $(c, s)$。

注意，我们不需要发送 $T$：verifier 可以重新计算它。

Verification

为了验证，verifier 使用接收到的 $s$ 和 public key $Y$ 重建 $T$：

$$T' = s \cdot G - c \cdot Y = (r + c \cdot x)\cdot G - c \cdot Y = r \cdot G$$

然后检查：

$$c = ?H(G, Y, T', m)$$

如果匹配，signature 就有效。

就是这样。Schnorr signature 本质上就是 Schnorr Σ-protocol，只是把 signed message 加入了 transcript。

Generalization: prove knowledge of a homomorphism pre-image

到目前为止，我们已经看到 Sigma protocols 在特定场景下是如何工作的：

• 对于简单的 elliptic-curve point $Y = x \cdot G$，我们证明了对 $x$ 的 knowledge
• 对于 Pedersen commitments $P = x \cdot G + r \cdot H$，我们证明了对 $(x, r)$ 的 knowledge

如果你注意到这两者都符合相同的模式，那你是对的！

它们的共同点是一个 homomorphism：一个保持 group operation 的函数。

让我们看看如何把 Sigma protocols 泛化到任何 homomorphic function。

Homomorphism

让我们定义一个通用的 homomorphism：

$$\phi : (G_1, +) \to (G_2, +)$$

这意味着函数 $\phi$ “尊重”加法：

$$\phi(u + v) = \phi(u) + \phi(v)$$

例如，椭圆曲线就是这样：

$$(3 + 4)\cdot G = 3 \cdot G + 4 \cdot G$$

其中：

$$\phi(x) = x \cdot G$$

如果我们使用乘法记号（比如 $g^a$，这里的 $g$ 是 multiplicative group 中的 generator，而不是 elliptic curve point），它看起来会是这样：

$$\phi(u + v) = \phi(u) \cdot \phi(v)$$

而这个函数会定义为：

$$\phi : (G_1, +) \to (G_2, \times)$$

Intuition

核心思想是，Sigma protocol 并不真的关心 $\phi$ 是什么。只要它是 homomorphic，逻辑就适用。

你想证明的是：你知道某个 secret input $x$，使得

$$Y = \phi(x)$$

而不泄露 $x$。

Generic Σ-protocol

下面是通用 protocol 的形式，它抽象于任意 homomorphism $\phi$。

你想证明对 secret $x \in G_1$ 的 knowledge。

1. Commitment

Prover 选择一个随机 $r \in G_1$ 并发送：

$$T = \phi(r) \in G_2$$

2. Challenge

Verifier 返回一个随机 scalar

$$c \in G_1$$

（域中的一个数，不是 group element）。

3. Response

Prover 计算

$$s = r + c \cdot x \in G_1$$

4. Verification

Verifier 检查

$$\phi(s) = ?T + c \cdot Y$$

如果等式成立，verifier 就相信 prover 一定知道某个 $x$，使得 $Y = \phi(x) \in G_2$

Examples

Elliptic curve discrete log

$$\phi : (\mathbb{Z}_q, +) \to (G_2, +) \qquad \phi(x) = x \cdot G$$

然后你运行你已经知道的 Schnorr protocol。

Pedersen commitments

$$\phi : (\mathbb{Z}_q^2, +) \to (G_2, +) \qquad \phi(x, r) = x \cdot G + r \cdot H$$

Prover 的 secret 是 $(x, r)$，而 commitment 是 $P = \phi(x, r)$。

Exponentiation

$$\phi : (\mathbb{Z}_q, +) \to (G_2, \times) \qquad \phi(x) = g^x$$

结构完全相同，只是 group operation 变了。于是得到：

$$y = \phi(x) = g^x \qquad t = \phi(r) = g^r \qquad s = r + c \cdot x \qquad \phi(s) = ?\phi(r) \cdot y^c$$

Why this matters?

这个泛化表明，Sigma protocol 从根本上是一种 证明你知道某个 homomorphism 下 pre-image 的知识。

只要这个函数保持 group operation，proof 就成立。

这就是 Sigma protocols 如此灵活的原因：它们并不绑定到某个特定 use case，而是绑定到一种数学结构。

Dan Boneh 在他的 lecture 中使用了这个精确的抽象来展示 Σ-protocols 如何成为更高级 ZK systems 的强大基础，你可以在这里找到：Dan Boneh uses in his lecture

你可以在我的 GitHub 上找到本文中使用的所有 SageMath scripts：sigma-proofs

zkSecurity 为 cryptographic systems 提供审计、研究和开发服务，包括 zero-knowledge proofs、MPCs、FHE 和 consensus protocols。

Learn more →

• 原文链接： blog.zksecurity.xyz/post...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～