学习笔记:Compact Multi-signatures for Smaller Blockchains

Boneh, D., Drijvers, M., Neven, G. (2018). Compact Multi-signatures for Smaller Blockchains. In: Peyrin, T., Galbraith, S. (eds) Advances in Cryptology – ASIACRYPT 2018. ASIACRYPT 2018. Lecture Notes in Computer Science(), vol 11273. Springer, Cham. https://doi.org/10.1007/978-3-030-03329-3_15

总结

这篇文章涉及到的方案：

• MSP：一种Multi-Signature（基于双线性对），将多个签名合成一个，用合成公钥$apk$可验证。（用全部的$ap{k}_i$可以批量验证一组multi-Signatures）
• AMSP：MSP的聚合版本，把多个multi-Signatures聚合成一个，并给出对应的验证方法
• ASM：部分子集的multi-signature，用总的合成公钥apk可以验证，用$m{k}_i$可追责
• MSDL：基于离散对数的Multi-Signature方案

以及以上方案的PoP版本（用PoP对抗 Rogue public-key attack）

Preliminaries

概念:

• $\mathrm{M}\mathrm{u}\mathrm{l}\mathrm{t}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{g}\mathrm{n}\mathrm{a}\mathrm{t}\mathrm{u}\mathrm{r}\mathrm{e}:(\mathrm{P}\mathrm{g},\mathrm{K}\mathrm{g},\mathrm{S}\mathrm{i}\mathrm{g}\mathrm{n},\mathrm{K}\mathrm{A}\mathrm{g},\mathrm{V}\mathrm{f})$：签名算法的输入包括公钥集合$\mathcal{P}\mathcal{K}$，每个签名方各自生成签名。$\mathrm{K}\mathrm{A}\mathrm{g}$将公钥集合聚合成一个聚合公钥，可用于验证任何一个签名。
• Aggregate Multi-Signatures：将多个Multisignature聚合成一个签名，扩展两个算法：
  • $\mathrm{S}\mathrm{A}\mathrm{g}((apk,m,\sigma ),...)\to \Sigma$
  • $\mathrm{A}\mathrm{V}\mathrm{f}((apk,m),...,\Sigma )\to 0/1$

构造Aggregate Multi-Signatures的目标并非简单的聚合，而是构造远小于独立Multi-Signatures集合的规模，理想状态下是常数规模。

BLS签名

这个签名支持简单的聚合：

验证聚合签名：所有$(p{k}_i,m_i{)}_{i=1}^n$

如果所有被签名的message都一样：$m_1=...=m_n$，验证关系(2)归约成简单的形式：

以及一个短的聚合公钥$apk:=p{k}_1...p{k}_n\in {\mathbb{G}}_2$

Simple Schnorr Multi-Signatures with Applications to Bitcoin

• $\mathrm{K}\mathrm{e}\mathrm{y}\mathrm{G}\mathrm{e}\mathrm{n}():x\leftarrow {\mathbb{Z}}_p,X=g^x$
• S i g n ( ( s k , p k ) , L = { p k 1 , . . . , p k n } , m ) → σ {\rm Sign}( (sk, pk),L=\{pk_1,...,pk_n\},m)\rightarrow \sigma Sign((sk,pk),L={pk1​,...,pkn​},m)→σ. L = { X 1 , . . . , X n } L=\{X_1,...,X_n\} L={X1​,...,Xn​}，签名者密钥$(x_1,X_1)$

1. 对 i ∈ { 1 , . . . , n } i\in\{1,...,n\} i∈{1,...,n}，计算$a_i=H_0(L,X_i)$，聚合公钥$\tilde{X}={\prod }_{i=1}^n{X}_i^{a_i}$
2. 随机$r_i\leftarrow {\mathbb{Z}}_p$，计算$R_1=g^{r_1}$，将$R_1$发送给其他参与方
3. 收到其他所有$R_2,...,R_n$后，计算：$R={\prod }_{i=1}^n{R}_i,c=H_1(\tilde{X},R,m),s_1=r_1+c\cdot a_1\cdot x_{1}modp$，将$s_1$发送给其他参与方
4. 收到所有其他$s_2,...,s_n$后，计算：$s={\sum }_{i=1}^n{s}_{i}modp$，签名$\sigma =(R,s)$

• $\mathrm{V}\mathrm{e}\mathrm{r}(L,m,\sigma )\to 0/1$

1. 计算 a i = H 0 ( L , X i ) , i ∈ { 1 , . . . , n } , X ~ = ∏ i = 1 n X i a i , c = H 1 ( X ~ , R , m ) a_i=H_0(L,X_i),i\in\{1,...,n\},\widetilde{X}=\prod_{i=1}^nX_i^{a_i},c=H_1(\widetilde{X},R,m) ai​=H0​(L,Xi​),i∈{1,...,n},X =∏i=1n​Xiai​​,c=H1​(X ,R,m)
2. 如果$g^s=R\cdot {\prod }_{i=1}^n{X}_i^{a_i\cdot c}=R\cdot {\tilde{X}}^c$
   推导：$g^s={\prod }_{i=1}^n{g}^{s_i}={\prod }_{i=1}^n{g}^{r_i+c\cdot a_i\cdot x_i}=R\cdot {\prod }_{i=1}^n{X_i}^{c\cdot a_i}=R\cdot {\tilde{X}}^c$

Rogue public-key attack

(1)中简单聚合的不安全之处：

• 假设恶意敌手注册了一个非法公钥$p{k}_2:=g_2^{\alpha }\cdot (p{k}_1{)}^{-1}\in {\mathbb{G}}_2$，其中$p{k}_1$是某个不知情用户Bob的公钥，$\alpha \leftarrow {\mathbb{Z}}_p$是随机选择的
• 敌手可以通过呈现聚合签名$\sigma :=H_0(m{)}^{\alpha }$声称自己和Bob都签署了同一个消息$m\in \mathcal{M}$
• 这个签名作为两个签名的聚合进行验证，一个来自$p{k}_1$，另一个来自$p{k}_2$，因为
  $e(\sigma ,g_2)=e(H_0(m{)}^{\alpha },g_2)=e(H_0(m),g_2^{\alpha })=e(H_0(m),p{k}_1\cdot p{k}_2)$
  所以攻击者伪造了一个Bob对消息m的签名，但Bob从未签署过。

解决方案

1. 要求每个用户证明知道或拥有相应的密钥，但这在实践中很难实施，并且不适合加密货币的应用。
2. 要求被聚合的消息是不同的。可以通过在签名之前始终将公钥放在每条消息前面来强制执行消息的特殊性。但是，因为现在所有消息都是不同的，所以在聚合公共消息m上的签名时，不能像(3)中那样简化公钥聚合

(A)MSP: Multi-Signatures with Key Aggregation from Pairings

MSP：pairing-based multi-signature with public-key aggregation

基于BLS signature scheme构造的Multi-Signatures with Key Aggregation方案
H 0 : { 0 , 1 } ∗ → G 2 , H 1 : { 0 , 1 } ∗ → Z q . H_0:\{0,1\}^*\rightarrow\mathbb{G}_2,H_1:\{0,1\}^∗\rightarrow\mathbb{Z}_q. H0​:{0,1}∗→G2​,H1​:{0,1}∗→Zq​.


S i g n ( p a r , { p k 1 , . . . , p k n } , s k i , m ) → σ {\bf Sign}(par,\{pk_1,...,pk_n\},sk_i,m)\rightarrow \sigma Sign(par,{pk1​,...,pkn​},ski​,m)→σ

• $s_i\leftarrow H_0(m{)}^{a_i\cdot s{k}_i}$，其中 a i ← H 1 ( p k i , { p k 1 , . . . , p k n } ) a_i\leftarrow H_1(pk_i,\{pk_1,...,pk_n\}) ai​←H1​(pki​,{pk1​,...,pkn​})，将$s_i$发送给指定的合成器
• 合成器计算合成签名$\sigma \leftarrow {\prod }_{j=1}^n{s}_j$。合成器可以是其中某一个signer或某个额外的参与方
  注：$s_i$可以看作是multi signature，而生成的$sigma$是多个multi signature聚合成的。

推导过程：验证总体签名
e ( σ , g 2 − 1 ) ⋅ e ( H 0 ( m ) , a p k ) = e ( ∏ j = 1 n s j , g 2 − 1 ) ⋅ e ( H 0 ( m ) , ∏ i = 1 n p k i H 1 ( p k i , { p k 1 , . . . , p k n } ) ) = e ( H 0 ( m ) ∑ j = 1 n a j ⋅ s k j , g 2 − 1 ) ⋅ e ( H 0 ( m ) , g 2 ∑ i = 1 n s k i ⋅ a i ) = 1 G t \begin{aligned} e(\sigma,g_2^{-1})\cdot e(H_0(m),apk)&=e(\prod_{j=1}^ns_j,g_2^{-1})\cdot e(H_0(m),\prod_{i=1}^npk_i^{H_1(pk_i,\{pk_1,...,pk_n\})})\\ &=e(H_0(m)^{\sum_{j=1}^n a_j\cdot sk_j},g_2^{-1})\cdot e(H_0(m),g_2^{\sum_{i=1}^n sk_i\cdot a_i})\\ &=1_{\mathbb{G}_t} \end{aligned} e(σ,g2−1​)⋅e(H0​(m),apk)​=e(j=1∏n​sj​,g2−1​)⋅e(H0​(m),i=1∏n​pkiH1​(pki​,{pk1​,...,pkn​})​)=e(H0​(m)∑j=1n​aj​⋅skj​,g2−1​)⋅e(H0​(m),g2∑i=1n​ski​⋅ai​​)=1Gt​​​
$\mathbf{B}\mathbf{a}\mathbf{t}\mathbf{c}\mathbf{h}\mathbf{v}\mathbf{e}\mathbf{r}\mathbf{i}\mathbf{f}\mathbf{i}\mathbf{c}\mathbf{a}\mathbf{t}\mathbf{i}\mathbf{o}\mathbf{n}(m_i,{\sigma }_i,ap{k}_i{)}_{i=1}^b$
一组$b$个multi-signature可以批量验证，如果每个$m_1,...,m_b$都不同，我们可以像(1)那样使用签名聚合来批量验证所有这些三元组:

• 计算聚合签名$\tilde{\sigma }:={\sigma }_1...{\sigma }_b\in {\mathbb{G}}_2$
• 接受所有bmulti-signature 元组为有效，如果$e(\tilde{\sigma },g_2)=e(H_0(m_1),ap{k}_1)...e(H_0(m_b),ap{k}_b)$

这样的聚合签名只需要验证$b+1$个双线性对计算而不是$2b$个

如果有一些消息是重复的，可以通过预先引入随机指数 ρ 1 , . . . , ρ b ← { 1 , . . . , 2 κ } \rho_1,...,\rho_b\leftarrow\{1,...,2^\kappa\} ρ1​,...,ρb​←{1,...,2κ}来保证安全性：$\tilde{\sigma }:={\sigma }_1^{{\rho }_1}...{\sigma }_b^{{\rho }_b}\in {\mathbb{G}}_2$，验证$e(\tilde{\sigma },g_2)=e(H_0(m_1),ap{k}_1^{{\rho }_1})...e(H_0(m_b),ap{k}_b^{{\rho }_b})$

AMSP：Aggregating Multi-Signatures

可通过将MSP乘起来聚合它们，只要被聚合的签名的消息是不同的。保证消息不同最简单的办法是在消息中包括聚合公钥
AMSP和MSP：

• 相同：$\mathrm{P}\mathrm{g},\mathrm{K}\mathrm{g},\mathrm{K}\mathrm{A}\mathrm{g}$
• 改进：$\mathrm{S}\mathrm{i}\mathrm{g}\mathrm{n},\mathrm{V}\mathrm{f}$：将$apk$包含在签名的消息中
  
• 增加：$\mathrm{S}\mathrm{A}\mathrm{g},\mathrm{A}\mathrm{V}\mathrm{f}$
  

ASM: Accountable-Subgroup Multi-signatures

ASM

$\mathrm{P}\mathrm{g}\to par$
$\mathrm{K}\mathrm{g}\to (pk,sk)$
G S e t u p ( s k , P K ) → m k , P K = { p k 1 , . . . , p k n } {\rm GSetup}(sk,\mathcal{PK})\rightarrow mk,\mathcal{PK}=\{pk_1,...,pk_n\} GSetup(sk,PK)→mk,PK={pk1​,...,pkn​},$mk$:membership key
$\mathrm{S}\mathrm{i}\mathrm{g}\mathrm{n}(par,\mathcal{P}\mathcal{K},S,sk,mk,m)\to \sigma$, S ⊆ { 1 , . . . , ∣ P K ∣ } S\subseteq\{1,...,|\mathcal{PK}|\} S⊆{1,...,∣PK∣}
$\mathrm{K}\mathrm{A}\mathrm{g}(\mathcal{P}\mathcal{K})\to apk$
$\mathrm{V}\mathrm{f}(par,apk,S,m,\sigma )\to 0/1$

Scheme
Parameter generation, key generation, key aggregation 三个算法与MSP相同
$\mathrm{G}\mathrm{S}\mathrm{e}\mathrm{t}\mathrm{u}\mathrm{p}(s{k}_i,\mathcal{P}\mathcal{K})\to mk$

• Signer $i$计算$apk\leftarrow \mathrm{K}\mathrm{A}\mathrm{g}(\mathcal{P}\mathcal{K})$，$a_i\leftarrow H_1(p{k}_i,\mathcal{P}\mathcal{K})$
• 计算${\mu }_{j,i}=H_2(apk,j{)}^{a_i\cdot s{k}_i}$并发送给所有$j\ne i$的signer
• 收到所有$j\ne i$的${\mu }_{i,j}$，计算${\mu }_{i,i}=H_2(apk,i{)}^{a_i\cdot s{k}_i}$
• 返回$m{k}_i\leftarrow {\prod }_{j=1}^n{\mu }_{i,j}$
  注意如果所有的signer诚实，有：$e(g_2,m{k}_i)=e(g_2,{\prod }_{j=1}^n{H}_2(apk,i{)}^{a_j\cdot s{k}_j})=e(g_2^{{\sum }_{j=1}^n{a}_j\cdot s{k}_j},H_2(apk,i))=e(apk,H_2(apk,i))$

$\mathrm{S}\mathrm{i}\mathrm{g}\mathrm{n}(par,\mathcal{P}\mathcal{K},S,s{k}_i,m{k}_i,m)$

• 计算$apk\leftarrow \mathrm{K}\mathrm{A}\mathrm{g}(\mathcal{P}\mathcal{K})$，$s_i\leftarrow H_0(apk,m{)}^{s{k}_i}\cdot m{k}_i$
• 将$(p{k}_i,s_i)$发送给指定的合成器（$S$的某个参与方或额外的第三方），合成器计算：$pk\leftarrow {\prod }_{j\in S}p{k}_j,s\leftarrow {\prod }_{j\in S}{s}_j$，输出multi签名：$\sigma :=(pk,s)$

$\mathrm{V}\mathrm{f}(par,apk,S,m,\sigma )\to 0/1$

• 解析签名$\sigma$为$(pk,s)$，验证：
  $e\left({\mathrm{H}}_0(apk,m),pk\right)\cdot e\left({\prod }_{j\in S}{\mathrm{H}}_2(apk,j),apk\right)\stackrel{?}{=}e\left(s,g_2\right)$
  通过则返回1.

推导：
$$\begin{array}{rl}& e\left({\mathrm{H}}_0(apk,m),pk\right)\cdot e\left(\prod _{j\in S}{\mathrm{H}}_2(apk,j),apk\right)\\ & =e\left({\mathrm{H}}_0(apk,m),\prod _{j\in S}p{k}_j\right)\cdot e\left(\prod _{j\in S}{\mathrm{H}}_2(apk,j),\prod _{i=1}^{n}p{k}_i^{a_i}\right)\\ & =\prod _{j\in S}e\left({\mathrm{H}}_0(apk,m{)}^{s{k}_j},g_2\right)\cdot \prod _{i=1}^{n}e\left(\prod _{j\in S}{\mathrm{H}}_2(apk,j{)}^{a_i\cdot s{k}_i},g_2\right)\\ & =e\left(\prod _{j\in S}{\mathrm{H}}_0(apk,m{)}^{s{k}_j},g_2\right)\cdot e\left(\prod _{i,\in [1,n],j\in S}{\mu }_{j,i},g_2\right)\\ & =e\left(\prod _{i=1}^n{s}_i,g_2\right)=e\left(s,g_2\right)\end{array}$$

MSDL：A Scheme from Discrete Logarithms

H 0 , H 1 , H 2 : { 0 , 1 } ∗ → Z q H_0,H_1,H_2:\{0,1\}^*\rightarrow\mathbb{Z}_q H0​,H1​,H2​:{0,1}∗→Zq​

S i g n ( p a r , { p k 1 , . . . , p k n } , s k , m ) {\rm Sign}(par,\{pk_1,...,pk_n\},sk,m) Sign(par,{pk1​,...,pkn​},sk,m)

• Round 1. $r_i\stackrel{ran}{⟵}{\mathbb{Z}}_q$,$R_i\leftarrow g^{r_i},t_i\leftarrow H_2(R_i)$。将$t_i$发送给其他对应参与方，并等待接收所有$t_j,j\ne i$
• Round 2. 广播发送$R_i$给$p{k}_1,...,p{k}_n$中的其他参与方，并等待接收所有$R_j,j\ne i$，分别查验$t_j=H_2(R_j),j=1,...,n$
• Round 3. 计算 a p k ← K A g ( { p k 1 , . . . , p k n } ) apk\leftarrow KAg(\{pk_1,...,pk_n\}) apk←KAg({pk1​,...,pkn​})，令 a i ← H 1 ( p k i , { p k 1 , . . . , p k n } ) a_i\leftarrow H_1(pk_i,\{pk_1,...,pk_n\}) ai​←H1​(pki​,{pk1​,...,pkn​}).
  注意，当使用同一组签名者对多个消息进行签名时，$apk$和$a_i$可以被存储而不是重新计算。
  计算：$\bar{R}\leftarrow {\prod }_{j=1}^n{R}_j,c\leftarrow H_0(\bar{R},apk,m).s_i\leftarrow r_i+c\cdot s{k}_i\cdot a_{i}modq$。广播发送$s_i$并收集其他所有$s_j,j\ne i$。计算$s\leftarrow {\sum }_{j=1}^n{s}_j$并输出$\sigma \leftarrow (\bar{R},s)$.

$\mathrm{V}\mathrm{f}(par,apk,m,\sigma )\to 0/1$

• 解析签名$(\bar{R},s)\in \mathbb{G}\times {\mathbb{Z}}_q$，计算$c\leftarrow H_0(\bar{R},apk,m)$并输入1如果满足：$g^s\cdot ap{k}^{-c}\stackrel{?}{=}\bar{R}$
  推导：$g^s\cdot ap{k}^{-c}=g^{{\sum }_{j=1}^n{s}_j}\cdot ({\prod }_{i=1}^{n}p{k}_i^{a_i}{)}^{-c}=g^{{\sum }_{j=1}^n{r}_j+c\cdot s{k}_j\cdot a_j}\cdot (g^{{\sum }_{i=1}^n-c\cdot s{k}_i\cdot a_i})=g^{{\sum }_{j=1}^n{r}_j}=\bar{R}$

批量验证：该方案允许更有效的批量验证，允许验证者用一个3n次幂而不是n个2次幂来检查n个签名的有效性。

• 验证n个签名list： { ( a p k i , m i , ( R ˉ i , s i ) ) } i = 1 n \{(apk_i,m_i,(\bar{R}_i,s_i))\}_{i=1}^n {(apki​,mi​,(Rˉi​,si​))}i=1n​，计算$c_i\leftarrow H_0({\bar{R}}_i,ap{k}_i,m_i)$，${\alpha }_i\stackrel{ran}{⟵}{\mathbb{Z}}_{q}fori=1,...,n$，如果满足以下条件，accept：
  $$\prod _{i=1}^n{g}^{{\alpha }_i{s}_i}ap{k}_i^{-{\alpha }_i{c}_i}{\bar{R}}_i^{-{\alpha }_i}\stackrel{?}{=}{1}_{\mathbb{G}}$$
  （推导过程同上，仅加入了随机性${\alpha }_i$）

Schemes with Proofs of Possession

Rogue-key attacks in multi-signatures 可以通过让签名者向他们的公钥添加所谓的拥有证明(PoP)来阻止，即对他们自己的公钥的签名。
PoP的缺陷：导致公钥规模的增长。
But! 在某些情况下，单个公钥的大小并不重要：

• Multisig地址原则上不需要显示所有签名者的单个公钥，只要聚合公钥是已知的，并被所有签名者同意。在创建Multisig钱包时，签名者可以通过交换和验证彼此的pop来建立对聚合密钥的信任，但只向外界发布聚合密钥。
• 在分布式账本(例如，区块链)中，Signers可能是一个相对较小的静态节点集，其公钥可以被验证一次，然后以任意组合进行聚合。

(A)MSP-pop：Pairing-Based Schemes with PoPs

一个额外的hash H 1 : { 0 , 1 } ∗ → G 1 H_1:\{0,1\}^*\rightarrow\mathbb{G}_1 H1​:{0,1}∗→G1​
Key generation:$y\leftarrow g_2^{sk}$，PoP:$\pi \leftarrow H_1(y{)}^x,pk\leftarrow (y,\pi )$
KAg：验证$e(H_1(y_i),y_i)\stackrel{?}{=}e({\pi }_i,g_2),i=1,...,n$，输出$apk\leftarrow {\prod }_{i=1}^n{y}_i$
(MSP-pop)Sign：计算部分签名$s_i\leftarrow H_0(m{)}^{s{k}_i}$
(AMSP-pop)Sign：计算部分签名$s_i\leftarrow H_0(apk,m{)}^{s{k}_i}$
签名组合、聚合和验证与MSP、AMSP完全相同。

ASM-pop:Accountable-Subgroup Scheme with PoPs

Key generation：与上面（A)MSP-pop中相同
KAg：一组密钥 P K = { ( y 1 , π 1 ) , . . . , ( y n , π n ) } \mathcal{PK}=\{(y_1,\pi_1),...,(y_n,\pi_n)\} PK={(y1​,π1​),...,(yn​,πn​)}聚合不仅包含$Y\leftarrow {\prod }_{i=1}^n{y}_i$，还包含$h\leftarrow H_3(\mathcal{P}\mathcal{K})$，其中 H 3 { 0 , 1 } ∗ → Z q H_3\{0,1\}^*\rightarrow\mathbb{Z}_q H3​{0,1}∗→Zq​。$apk\leftarrow (Y,h)$.包含这个散列的原因是，当模拟对$H_2(apk,i)$的响应时，模拟器必须能够判断$i$是否是集合$\mathcal{P}\mathcal{K}$中目标签名者的索引.
Group setup

• 计算$apk\leftarrow (Y,h)$并发送${\mu }_{j,i}=H_2(apk,j{)}^{s{k}_i}$给签名方$j$
• 收到所有${\mu }_{i,j},i\ne j$后，签名方$i$计算${\mu }_{i,i}\leftarrow H_2(apk,i{)}^{s{k}_i}$
• 输出$m{k}_i\leftarrow {\prod }_{j=1}^n{\mu }_{i,j}$
• 如果所有的签名方都诚实，有
  $e(g_2,m{k}_i)=e(g_2,{\prod }_{j=1}^n{\mu }_{i,j})=e(g_2,{\prod }_{j=1}^n{H}_2(apk,i{)}^{s{k}_j})=e({\prod }_{j=1}^n{g}_2^{s{k}_j},H_2(apk,i))=e(Y,H_2(apk,i))$

签名和验证与ASM相同，除了公钥的乘积$pk\leftarrow {\prod }_{j\in S}p{k}_j$被$y\leftarrow {\prod }_{j\in S}{y}_j$代替

MSDL-pop:Schemes from Discrete Logarithms with PoPs

Key generation：

• 选择$sk\stackrel{ran}{⟵}{\mathbb{Z}}_q$，计算$y\leftarrow g^{sk}$.
• 并使用$H_1$作为哈希函数在$y$上添加PoP，这是一个Schnorr签名：$r\stackrel{ran}{⟵}{\mathbb{Z}}_q,t\leftarrow g^r,c\leftarrow H_1(t,y),s\leftarrow r+c\cdot skmodq$
• 公钥$pk\leftarrow (y,c,s)$

KAg：聚合密钥 { ( y 1 , c 1 , s 1 ) , . . . , ( y n , c n , s n ) } \{(y_1,c_1,s_1),...,(y_n,c_n,s_n)\} {(y1​,c1​,s1​),...,(yn​,cn​,sn​)}

• 查验$c_i\stackrel{?}{=}{H}_1(g^s{y}_i^{-c_i},y_i),i=1,...,n$
  $(H_1(g^s{y}_i^{-c_i},y_i)=H_1(g^{r_i+c_i\cdot s{k}_i}{y}_i^{-c_i},y_i)=c_i)$
• 计算$apk\leftarrow {\prod }_{i=1}^n{y}_i$

签名协议与MSDL相同，除了第三轮计算$s_i\leftarrow r_i+c_i\cdot s{k}_{i}modq$