Hi 游客

更多精彩,请登录!

比特池塘 区块链前沿 正文
关于RSA累加器,我们在之前的一篇文章《RSA累加器,区块链瘦身神器?》中谈到了它的神奇魔力,通过以太坊创始人Vitalik的计算,使用RSA累加器后,原本每年2.5 GB的Plasma子链数据,可以被压缩到3.6 MB,压缩率达到了惊人的99.856%。
# b" f+ b) Q( A6 S$ Y3 y% N0 g& w3 N# M  H+ J: d- w
然而,这种技术在其最初的设计当中,需要用到可信设置,而来自斯坦福大学的应用密码学小组则发布了一篇题为《用于IOP和无状态区块链的累加器批处理技术》的论文,论述了一种通过类组( class group)而无需可信设置的累加器方法,这些累加器可用于创建无状态区块链(指节点不需要存储整个状态,以确信哪些区块是有效的),以及用于实现高效的UTXO commitment。
8 ]2 b1 d, N% D6 f% B  _. o" ]4 }! ~
在这篇文章中,以太坊区块链可扩展性和安全研究员Georgios Konstantopoulos对该论文进行了审查,并进行了相关总结,以下为译文:
+ W" b' ^# n, D2 _
, C, v+ T. d: r+ F; C7 u在这篇文章中,我们将尝试深入探索RSA累加器,同时回顾一下斯坦福大学应用密码学小组最近发表的论文,这篇非常重要的论文由Benedikt Bunz,Ben Fisch和Dan Boneh共同撰写,其题目为《用于IOP和无状态区块链的累加器批处理技术》。4 ]: `; w/ j* W/ b

6 P: O2 X6 b, K; i; y7 y强烈建议大家复习下数学,以便更好地理解这一技术。
! m' ^4 }! r8 Q+ i; X: t$ q3 ~+ }( W$ N  l3 T
背景# i# ]- N+ _( S  i" p

! [! h2 U' {. W& `0 m自1994年以来,累加器便成为了学术界非常关注的一个话题。其类似于默克尔树(Merkle Tree),并被用于以密码方式承诺一组数据的知识。稍后,可通过发布证明来证明数据集中子集的成员身份。在默克尔树(Merkle Tree)结构中,证明被称为默克尔分支(或默克尔证明),并且承诺数据的大小是以对数形式增长的。% v' V5 G8 d$ D
' b, M  Q: J9 j3 v& F" H# `; I& E' U
另一方面,累加器允许以恒定的大小证明成员身份,以及为多个元素批处理证明(默克尔树没有这一特性)。
0 K& G$ ?5 s. d9 L1 t6 p
: {4 `1 `5 ~( l1 W3 P$ q本文的重点是描述RSA累加器构建区块、如何构建成员和非成员身份的证明,以及如何跨多个区块对它们进行批处理。这种特殊的技术,也在基于UTXO的Plasma中具有应用,并由此产生了Plasma原代变异体。设计一个允许在Plasma中压缩UTXO集的累加器,需要付出大量的努力。
4 g1 K5 r9 ^$ a$ W+ A2 S1 v
4 l0 M2 J. @7 o- l; C免责声明:为了简单起见,作者模糊处理了这篇文章中的注释(例如不包括G$中的$U、W\或模块化算术的mod N)。
$ i: ]9 L0 j4 z" {  k1 g4 r% z/ _
6 r5 p& L% K' f9 ]术语表(来自[1]的定义):  F- a) n: \5 G, ?4 U$ u
5 N* N, b# Z' ^
累加器:“一个密码学累加器,其会产生对一组元素的短期约束承诺,以及对集合中任何元素的短期成员身份和非成员身份证明。”) Z/ Y( d7 [2 E: E5 _
1 ^7 F- C- `( [, l, h% @$ J
动态累加器:“支持添加和删除具有O(1) 成本的元素累加器,其与累积元素数量无关。”
2 R, e) I: l/ }
4 m& V: k2 |% l/ a通用累加器:“支持成员和非成员身份证明的动态累加器。”( e8 v: ~, X/ p
# x" ]' _6 b9 ]% U1 m9 j' D, W
批处理:批验证n个证明,要比验证单个证明要快n倍。
2 V! q' m5 q7 j
+ i$ [2 o! s, C5 e: |0 j" w聚合:在一个常量大小的证明中聚合n个成员证明。
, ~6 i3 Y$ g% Z8 X- J
3 F- D+ m6 \- ^3 z未知顺序组:组的顺序是其集合中元素的数目。为了保证所提供的证明的安全性,需要生成一组未知顺序(否则累加器中使用的模数有已知的因子分解,并且可以创建伪证明)。生成它可通过多方计算完成,但如果生成方串通检索生成的数的阶乘,则这是不安全的。它可通过使用类组在没有可信设置的情况下生成(注:这点是非常重要的)。. W, F, f9 o. p5 E
8 m$ J' _+ A- Q- E- v; U3 f- y
隐序组的简洁证明
. q. h  q) H0 ]/ e: M9 @- B; ]5 t2 w* F0 P- N6 {
Wesolowski在[2]中提出了指数方案的知识证明,证明者试图说服验证者他们知道一个数字x,这样,在已知基数u下,使得u^x=w成立。
; o* S* Z) F+ S7 Y: _; Q2 u1 i& `3 P' F. g, o3 P4 k
让我们举个例子,以2为基数(u=2),w=16,则得出x=4。我们怎么做?我们把X发送给验证者,它们必须执行2^4,并对照W检查结果。如果匹配,它们便会相信。以下两个步骤似乎很明显:; o, b. }2 |8 E9 V

3 x9 B/ K' c% E; S2 O' z: x验证者必须执行u^x :对于大数字来说,这是一个代价高昂的操作;* y1 `  e/ e& C% _
  L0 \/ |2 G; K$ H! ~/ X
将x传输到验证者:x可能很大,因此传输它所需的带宽可能不小;( \" q: c* u8 \/ V

) H+ d& U+ t2 e4 D- z9 r) j让我们看看有什么协议可以解决这一挑战。这些协议都是交互式的,这意味着验证者和证明者互相发送“挑战”(challenge),这些挑战在协议的后续步骤中会被使用,以确保协议的安全。
4 u5 B" t$ W  t- J8 v
4 Y* b' G& a  G% ]$ ~% m4 w# C% F求幂证明(PoE,第3.1节)
' @: i" ^9 O& Y8 u- {
- C' M" Z5 ^% Q" u; }; H/ i, a首先,让我们看看如何让验证者信服,而不需要它们实际运行整个求幂运算。5 e* V0 I7 z8 O. Z  L

) {: J7 B8 d' P0 M7 f求幂证明(注:当前版本的论文中有一个小错误,在第8页中,作者设置q=gq而不是uq。
4 J& l! K9 V8 u9 H: O
7 O( _% n* C7 J& s, Q6 j; I“只有当验证者能够比计算u^x更快地计算余数r时,该协议才有用。它解决了求幂问题,但仍然要求证明者向验证者传输一个潜在的大x,或者x是公开的。”
8 l6 ~8 O6 {! f; `" ~2 q/ O" p) @
离散对数知识证明(PoKE, 第3.3节)
  V, ^3 R* V( @# `# L
- W% b8 S/ y7 R8 U; ?5 j1 o相比传输x,我们可传输r。证明变为(Q,r),而验证者必须另外检查r是否小于l(PoKE*协议)。当对手可自由地选择基数u时,这会是不安全的!
% B7 g" Z1 v. s, \* F4 X% @4 n
# Q* {, ]. K; s验证者被证明者愚弄了,他们知道z: u^z=w,而不知道z!. f. E+ |- l& i0 G2 v

+ }5 ?( E$ I8 {9 K, E这里破解协议的细节在于,证明者选择了基数u=g^x,因此x与l是互质(co-prime)的。
* C0 V& B3 L& h6 S; H* d0 O( p. a, H  Z( q$ z8 z
我们可确定,上述协议适用于在公共参考字符串(CRS)中编码和固定的基数g,简单来说,各方事先就基数g达成一致,并且不能被对手任意选择。6 d$ `; X7 L5 Q
# C# n1 [: K5 D% u9 f
该协议可通过以下方式进行修复:
  _* H2 ^# x& L, P
1 D4 R' Q+ o8 ^2 b9 ?3 v对于固定的g,证明z=g^x离散对数x的知识;+ J7 v0 o- E3 S0 g9 E2 ]

. U) ~9 v4 H# n# \  }9 y; V* h% K* F8 a证明同一x也是基为u,w的离散对数;$ ?% j' _9 U5 j- n: e9 q; o2 }
2 f# ?& d+ n, _9 M$ a
所以最后的协议(PoKE)是:
+ w+ F8 Q& G) c5 v" Z3 \" D4 [6 h) J5 ~  J0 k! G0 x
证明现在是2组元素Q和Q’. 我们能做得更好吗?
+ s6 p/ A$ ^# t9 O
! a( K/ c1 o. g% z将证明减少到一个组元素,这可通过添加其它交互步骤来完成:3 `( \5 H0 f" D7 X8 J' n" Q
' G! P- S. I: Q* E* z% r) H
验证者需要发送一个额外的挑战\alpha,以便证明者无法创建假证明。
; H% A7 m% G( d2 m/ j& |' @: Y$ R, `, ~8 o; l5 ^3 `
从交互式证明,到非交互式证明
9 |1 V7 y4 W. c$ a" R+ f  `, @. d$ T9 ~# c
在随机Oracle模型中,通过使用Fiat-Shamir heuristic,任何交互式协议都可变成非交互式的(假设我们有一个安全的随机性生成器,例如一个安全的加密哈希函数)。
- G5 L! H1 D9 s, k* }( x; i3 @! j* f" N# S
PoKE2需要两个交互步骤,一个是由验证者挑选给证明者的生成器g,一个是发送挑战值l和a。相反,我们可以哈希当前的“抄本”(transcript),并使用输出作为这些值。因为我们是在随机的Oracle模型中操作的,所以如果这些值是由验证者挑选的(以防证明者作弊,或者它们来自哈希函数)则没有什么区别,因为这两者在统计上是不可区分的!
3 G. G: X% _2 ^* f+ D- k. t/ Y6 t! W  m' Y4 A! H1 s
每一方生成挑战参数,而不需要交互,每次使用哈希函数和协议的当前抄本) j4 [% o9 {$ n: T8 ]" {

* G% m& A6 k# g, T上述技术涉及证明函数w=f(x)=u^x(标量值)的原像(preimage)知识。
: Z% m$ e* _+ M3 y0 [
3 b- [% M) h" q. W8 X# j  \0 y这些技术也可以扩展到支持同态原像知识的证明,即证明长度n向量x的知识,使得φ(x)=w。
) Y9 }1 t+ j. E) `" [9 y, d& I/ B8 b/ R& y
它们也可以在零知识下执行。对于已知g,PoKE需要发送gx。在验证协议的正确性时,我们假设存在一个模拟器,该模拟器能够通过了解验证内容x来模拟gx。这会泄漏信息,因此不是零知识的!论文作者所使用的技术包括屏蔽输入,这些输入通过使用一种类似Schnorr的协议和佩德森承诺(Pedersen Commitments)技术来得到证明。如果你并不熟悉这些术语,可先访问一下这些内容。/ Z0 ?* w7 h6 [4 G) r

. V( J5 C, n1 D! `RSA累加器
# i: L$ e1 X4 C* h
* e! m% H6 o0 j- c+ ?* x我们在术语表中给出了累加器的定义。现在,我们将讨论支持批量成员证明和非成员证明的通用累加器的构造。; a- F/ m# |% A& k( X

( y; g2 E2 c. z" c( R0 V$ b2 q# Y构造累加器需要从一组未知顺序中选择一个模数N,该模数N可以从RSA组中选择(例如,如果你信任RSA实验室,则为RSA-2048),也可以通过可信设置生成。  Z, @9 _+ [5 t0 R
  ^  e/ V" ^1 z5 d
RSA累加器的初始状态,是从未知顺序g组中采样的生成器,这意味着累加器中的元素列表为空[].
# ]* k( i. p* K1 p9 k; h
/ `( S5 a8 D* ~0 @5 }3 G5 E- C如[3]所述,累加器必须具有准交换数学性质。
$ t5 S7 B% E+ \" m0 C3 V
, K2 S& y9 v* s两个元素的准交换性质。
- b, C; v. I9 ~5 j7 ?0 ]) Q0 n/ S0 i) y3 m# {0 t3 O6 q$ J
将元素x添加到累加器a,是通过将累加器提升到元素A’ = A^x mod N 来完成的。(为了简单起见,此处我们省略mod N)# i" m8 g. M1 r

9 D2 W( e/ Y- \; ^证明成员身份
$ O9 j) H' U9 i" I7 N" ~
8 }3 I9 R, Q4 G+ b4 w* Y$ R证明累加器中某个元素的成员身份,需要显示该元素的值和验证因子。
) Y4 W$ ?& K: T) x0 R
6 S9 p, D  r, e9 p+ q7 J- C验证因子或共同因子是累加器中所有值的乘积(除了我们正证明的包含值)6 |- s  b! J+ f4 @5 O
& W) k: M) z+ T
(值,验证因子)对是包含在集合中的证明。% C, e+ g/ z) P

4 a, H  }& Z1 f- R+ s1 Z“如果这个值是一个很大的数字,将其传递给验证者,并且求幂的成本是不可忽略的呢?”0 T' O# ]8 W2 Z4 ~/ D* z

/ f1 o) U7 z# ?; |' `; O# Q: p这就是上面的NI-PoKE2协议的由来。相比发送上述所述的证明,我们可以证明验证因子的知识,其会提供一个有效的证明!这似乎不太可能,因为我们的示例很简单,但我们将在下面的批处理成员证明部分中,看到可能发生的情况。# p/ g+ ?8 D$ e+ @
5 k+ t" u1 h0 T
证明非成员身份
' J; Q$ G; v, h; N; S( m2 `& k/ {1 n  @  U
非成员证明需要计算我们证明的元素的Bezout系数和集合中元素的乘积。在这里,我们可以找到关于这个主题的优秀指南。, [6 L; P9 ?6 p$ G8 X3 [

  Q3 h( d1 _" T- _5 H9 n8 y创建一个非成员验证因子
8 g; g, F* A, j0 `4 }, B2 T9 r. h
1 \/ |" Q0 O$ O3 _验证一个非成员验证因子
* ?, x) ]8 l1 q; a( ]( M& A+ b
/ V- T5 i! ~9 i- n# u下面就是一个例子:
- F* q4 Z8 \5 _8 Y5 X
- _7 a$ K9 J6 E$ G" xVitalik Buterin还提出了一种证明非成员身份的方法,其中他提到的想法是不确定的。(没有提供其安全性的证明,因此如果你要使用它,可能要小心了!)”- g5 W0 \' v1 S

( Q4 S6 f4 |5 r哈希素数
' t+ }7 A6 {. a9 b% b; t
5 u2 Y+ ^3 Y5 L# Z6 y& D9 G奇质数(即不带2的素数)既需要用于知识证明协议,也需要用于累加器元素。如果累积的元素不是素数,那么对手可在元素不在集合中的情况下,愚弄验证者包含了该元素。1 H- P1 ^* e9 a& I% @/ B
0 i8 t. t- L. @! z% o9 x- N
非累积元素的有效成员证明!
2 s  |# i, k& P9 W% N4 _
& \0 M3 N2 T/ M1 Y1 A, ^% Z4 i" C2 s因此,我们必须将累积元素限制为素数,否则对手可以证明包含累积元素的任何因子(在这种情况下,证明包含3是因为它是6的因子)。
9 D  x/ U3 u7 {6 D! h& r* X8 F  L6 \3 X
此外,如果NI-PoKE2中的挑战值l不是素数,那么我们会得到另一种协同因子攻击,其中攻击者可以计算q,r,从而愚弄验证者包含了某个元素,这类似于 PoKE*攻击。
$ s5 E- x7 D* f& f0 a
0 ?+ |  ?( ~. h, b0 i聚合和批处理证明
! p2 C, }* N/ s* r$ G& A) P* p/ y' x  e" v' X. e# ~
回忆一下定义:
6 Q5 x+ T7 `# t& [$ L
2 U5 S6 w4 e$ Q" _, m/ h* P聚合:将多个证明组合在一个常量大小的证明中;  }0 P( t, p! ?

+ R0 s* E! P" o; O2 _4 h批处理:一次性验证多个证明,而不是单次地验证所有的证明;
8 X: B+ H$ A5 Q& k. n; {
' Y" r0 M, ~- Y9 Y# a5 V$ t聚合和批处理成员证明是是非常简单的,只需将被证明的值相乘,并为它们提供一个共同因素:$ h5 h- w# {2 K0 N/ E' l2 Z4 Z5 F
8 X6 \/ d  H6 m( B3 m9 g* h
聚合成员身份证明
, T6 b; w: s, Z: O& ~* k, J0 u: |& p* e5 w7 Q. G
我们可以很快看出,如果我们想要为很多元素创建成员身份的聚合证明,那么值在传输时会变大,并且验证者需要执行昂贵的指数运算。为此,我们使用NI-PoKE2来证明我们知道因子g^65,而不需要向验证者发送231,验证者也不需要进行昂贵的指数计算(我们实现了批量验证!)
0 N3 Z. z, Z* n: ?, i1 v  p& L
批处理非成员证明,是通过计算元素 (a’, b’)积的Bezout系数来完成的,然后具有与以前相同的证明(g^a’,b’)。合并验证因子的大小,与提供两个独立的验证因子大致相同。
; Z! ^" M, u/ R/ M" @6 k+ n5 s/ j- X& {9 g) J
这可以通过将证明设置为(g^a’, A^b’) 来解决。为了确保安全,证明者还必须提供一个NI-PoKE2,以证明对b’的了解。
% C! c) Z* t; \2 W
! A% c0 u/ ?# [4 |第3步的NI-PoKE2是为了安全考虑,否则对手可能会设置v = g * d^(-xy),并在不知道b的情况下愚弄验证者。
9 U6 V& b6 e+ P/ O% I% l/ {, q+ G7 S7 [4 T
这可以通过应用NI-PoE来提高效率,这样验证者就不需要在最后一步执行求幂运算。
* d% J) p* O/ {" F3 b- E8 h' c
8 T% c+ p+ d, i: N在一个恒定大小验证因子的情况下,目前并没有有效的算法来聚合非成员证明。: ~$ I4 |) d- y7 q9 `0 B: |
( u* V( f8 F( J3 G
移除可信设置
9 {) p  z4 y5 o2 u
3 u7 ~( V& t% G所有的指数运算都关于模N,这是一个具有未知素数因子分解的数字。这是因为提供的所有证明,都在未知顺序组的通用组模型中(第2页),并且需要强RSA假设和自适应根假设。0 X7 H) \, v) @, w$ }( l

6 Q  J. a' d0 n/ L; M2 o在不知道相关私钥的情况下生成公钥是困难的。如论文第2页中的[2]所述,我们可通过执行安全的多方计算来创建所需的数字,但必须相信参与受信任设置的各方没有串通来找回秘密。Wesolowski在[2]中通过所谓的“类组”(class groups)而提出了另一种选择:
3 W- U  ]7 E* ~, u/ L* Z- L/ _) ]9 _; s5 a  L; n0 r8 a
“一个更好的方法是使用虚二次序(imaginary quadratic order)的类组。事实上,通过选择一个随机的判别式,我们可以很容易地生成一个虚二次序,当判别式足够大时,就无法计算类组的顺序。”
6 B1 l2 o+ m" F6 H: z1 x
2 p6 P4 N: x7 _1 V4 @& c9 J/ x5 M目前,Chia正在为有效计算这种“类组”而进行竞争,同时还提供了一份有关其背后所需理论的综合性论文。
# s. \& s9 s+ o. ]/ \& q( D, l* M- c8 P: M6 u2 ?1 V& O) C3 d
结论" Q1 A3 q; H3 f$ y, _: H( Q

3 b' U9 Z$ A: j# P, q/ ]- F9 u0 z如果你能看到这里,那么祝贺你!
7 M- `& `) r5 v. k7 k+ B; R6 |5 D& T8 R4 D' d
我们简要介绍了RSA累加器的工作原理,以及如何构造有效证明累加器中元素的成员身份和非成员身份的方案。原论文作者还提供了构造向量承诺的方法,其在不同的索引处有成批的opening,这不是默克尔树的特征。作者构建了第一个能够实现O(1)opening的向量承诺方案(这里的opening指证明在承诺中某一指标上某一要素的价值)。, N6 j% H& E4 Z1 p) m
+ S; z* D; [3 d
应用例子; n8 W% x8 {, O1 n3 a& L

1 ?6 n/ H" C3 o! V* _这些累加器可用于创建无状态区块链(指节点不需要存储整个状态,以确信哪些区块是有效的)。它们还可用于实现高效的UTXO承诺,允许用户在不知道整个UTXO集的情况下发布交易。最后,向量承诺可用于创建简短的交互式Oracle证明,这一过程比使用默克尔树(Merkle Tree)结构更为有效。3 T) o* u/ N7 z( ~9 A" n8 J
1 d6 j+ |( L5 F3 V  q
下一步是什么?, r2 I  p3 X9 }/ C+ n( o) Y
& x2 z) U8 m- D2 u& _
这是一篇非常好的论文,它介绍并形式化了很多可用于区块链结构扩展性的原语。" h5 z: C8 O5 `. K0 w. ]9 R
( \& O  ~! u; d  P' |
特别是,RSA累加器已吸引了Plasma研究社区成员的关注,他们正设法利用它来压缩Plasma Cash的UTXO历史。最近,ethresear.ch上已经有很多关于如何构造它的文章。因此,在下一篇文章中,我们将对当前的方案、它们的优缺点以及哪一个方案最为有效进行盘点。
* p# b( v/ n9 W, t' @, ^$ R+ @: H' d+ B3 ]
对于可利用向量承诺的非同质 Plasma 结构,我也非常感兴趣。
/ k( @( D0 P8 P: s. V0 w- d# A3 c$ C5 {$ u! k
谁知道呢,也许已经有人在做这个了?
# k2 k) m8 ]5 ^7 }/ W- D
# t1 C- d0 @; I- B. v3 H关于这一话题,接下来的文章题目会是: Plasma中的RSA累加器分类。
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

Sophie20172017 初中生
  • 粉丝

    0

  • 关注

    0

  • 主题

    13