线性秘密共享方案(LSSS)矩阵的构造

本文探讨了基于属性加密中的访问控制策略,特别是如何将这些策略转化为线性秘密分享方案(LSSS)的矩阵。介绍了Lewko-Waters算法和Liu-Cao-Wong算法,两者用于将访问控制树转换为LSSS矩阵。Lewko-Waters算法处理AND和OR门限,而Liu-Cao-Wong算法则更通用,能处理任意(t,n)门限。文章通过实例详细解释了这两个算法的工作原理,并展示了如何通过它们生成LSSS矩阵,用于实现加密和秘密分享。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

引言

基于属性加密(Attribute-Based Encryption, ABE)中有一个很重要的概念就是访问控制策略。具体到密文策略属性基加密(Ciphertext-Policy Attribute-Based Encryption, CP-ABE)方案中:方案存在着若干的属性,明文在一定的访问控制策略下被加密成密文;属性满足密文策略的用户就可以对密文进行解密。

举一个例子,一个访问控制策略可以描述为:“一个合法的用户应该拥有一个属性E,此外在集合{A, B, C, D}中至少拥有两个属性”。当然使用语言来描述访问控制策略并不够简洁直观。我们通常使用访问控制树来进行描述,如下图。每个叶子节点都是一个属性(attribute),而非叶子节点是门限节点(threshold node)。对于一个形式为(t, n)的门限节点,该节点拥有n个孩子节点,当有t( 1 ≤ t ≤ n 1 \leq t \leq n 1tn)个孩子节点满足要求时,该门限节点才满足要求。特别的,对于AND,其门限节点形式为(n, n);对于OR,其门限节点形式为(n, 1)。

现在有了访问控制策略这一需求之后,人们想到使用线性秘密分享方案(Linear Secret Sharing Scheme,LSSS)来实现该需求。而首先需要解决的问题在于如何把一个访问控制策略转换成LSSS中的矩阵 M M M

Lewko-Waters算法1

通过Lewko-Waters算法,可以将访问控制树转化为LSSS矩阵。算法中对访问控制树有一定的要求,它的非叶子节点是AND或OR门限,叶子节点是属性。更严格来说处理的访问控制树可以使用单调(排除NOT门限)布尔公式来表达。

引言中的例子改写为布尔表达式如下:
E ∧ ( ( A ∧ B ) ∨ ( A ∧ C ) ∨ ( A ∧ D ) ∨ ( B ∧ C ) ∨ ( B ∧ D ) ∨ ( C ∧ D ) ) E \land ((A \land B) \lor (A \land C) \lor (A \land D) \lor (B \land C) \lor (B \land D) \lor (C \land D)) E((AB)(AC)(AD)(BC)(BD)(CD))
进一步简化得:
E ∧ ( ( ( A ∧ B ) ∨ ( C ∧ D ) ) ∨ ( ( A ∨ B ) ∧ ( C ∨ D ) ) ) E \land (((A \land B) \lor (C \land D)) \lor ((A \lor B) \land (C \lor D))) E(((AB)(CD))((AB)(CD)))

写成访问控制树如图所示:

在算法开始阶段,将树的根节点标注一个长度为1的向量 ( 1 ) (1) (1),初始化一个全局变量counter=1。然后对树进行广度优先遍历,并按照如下算法进行广度优先遍历:

  1. 如果父节点是一个标注着向量v的OR门限
    1. 那么将它的两个子节点标注为v
    2. 保持counter不变。
  2. 如果父节点是一个标注着向量v的AND门限
    1. v的末尾用0填充,使得v的长度变为counter
    2. 右子节点用v||1标注(||表示连接符号)
    3. 左子节点用(0,...,0)||-1标注(0的个数为counter
    4. counter的值增加1

算法执行后的结果如图所示:

最后将标记好的树中所有的叶子节点拥有的向量v构成LSSS矩阵的行。如果向量v的长度不同,将短的那个向量末尾用0填充,直到所有向量长度相同。生成的矩阵如图下所示:

可以看出,矩阵的行数等于访问控制树叶子节点的个数。

我认为,该算法的关键在于全局变量counter,它实际上是AND门限的个数加1,同时也是最终得到的矩阵的行秩。

Liu-Cao-Wong算法2

该算法具有的优点如下:

  1. 该算法相比于Lewko-Waters算法,更加的通用。门限节点不在局限于AND或OR门限,而是形式为(t,n)的门限。而在将AND和OR门限分别变为(2,2)和(1,2)门限,得到的最终矩阵与Lewko-Waters算法生成的矩阵大小一致
  2. 该算法相比于Lewko-Waters算法,在(t,n)门限的处理上,效率更高:
    1. 由于该算法可直接处理(t,n)门限,而Lewko-Waters算法需要将(t,n)门限处理成(2,2)和(1,2)门限,这是很大的开销
    2. 该算法能够生成比Lewko-Waters算法更小的LSSS矩阵
      • 对于单一的(2,n)门限,该算法生成的矩阵的行数是n,而Lewko-Waters算法生成的矩阵的行数 n log ⁡ n n\log n nlogn
      • 对于单一的(t,n)门限(2<t<n),该算法生成的矩阵的行数是n,而Lewko-Waters算法生成的矩阵的行数 c ⋅ n log ⁡ n c \cdot n\log n cnlogn c c c可能是一个很大的数)

门限访问控制树 A \mathbb{A} A可以转化为递归形式的字符串 F A \mathbb{F_A} FA

  1. 如果根节点是(t,n)的门限,那么这个访问控制树可以描述为 ( F 1 , F 2 , ⋯   , F n , t ) (F_1,F_2,\cdots,F_n,t) (F1,F2,,Fn,t),其中 F i F_i Fi是根节点的子节点, t t t是门限值
  2. 如果 F i F_i Fi是叶子节点,直接写出属性值即可。如果 F i F_i Fi是非叶子节点,那么它表示为 ( F i , 1 , F i , 2 , ⋯   , F i , n i , t ) (F_{i,1},F_{i,2},\cdots,F_{i,n_i},t) (Fi,1,Fi,2,,Fi,nit),其中 F i , 1 , F i , 2 , ⋯   , F i , n i F_{i,1},F_{i,2},\cdots,F_{i,n_i} Fi,1,Fi,2,,Fi,ni表示 F i F_i Fi n i n_i ni个叶子节点, t t t是门限值

引言中的例子可以写为:对于节点(E, (A, B, C, D, 2), 2),它有一个叶子节点E和一个描述为(A, B, C, D, 2)的(2,4)的门限节点。

对于一个(t,n)门限访问结构 ( P 1 , P 2 , ⋯   , P n , t ) (P_1,P_2,\cdots,P_n,t) (P1,P2,,Pn,t),我们可以构造相应的在 Z p ,   p > n + 1 \mathbb{Z}_p, \, p>n+1 Zp,p>n+1上LSSS矩阵:
{ 1 1 1 ⋯ 1 1 2 2 2 ⋯ 2 t − 1 1 3 3 2 ⋯ 3 t − 1 ⋮ ⋮ ⋮ ⋱ ⋮ 1 n n 2 ⋯ n t − 1 } , ρ ( i ) = P i ( i = 1 , ⋯   , n ) \left\{ \begin{matrix} 1 & 1 & 1 & \cdots & 1 \\ 1 & 2 & 2^2 & \cdots & 2^{t-1} \\ 1 & 3 & 3^2 & \cdots & 3^{t-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & n & n^2 & \cdots & n^{t-1} \\ \end{matrix} \right\} , \quad \rho(i)=P_i(i=1,\cdots,n) 1111123n12232n212t13t1nt1,ρ(i)=Pi(i=1,,n)
为了用(t,n)门限的方式去分享一个秘密数 s ∈ Z p s \in \mathbb{Z}_p sZp,我们随机选择一个向量 v ⃗ = ( s , a 1 , ⋯   , a t − 1 ) ∈ Z p t \vec{v}=(s,a_1,\cdots,a_{t-1}) \in \mathbb{Z}_p^t v =(s,a1,,at1)Zpt,并将内部产生的 λ i = ( M i ⋅ v ⃗ ) \lambda_i=(M_i \cdot \vec{v}) λi=(Miv )给参与者 P i P_i Pi。对于多项式 f ( x ) = s + a 1 x + a 2 x + ⋯ + a t − 1 x t − 1 f(x)=s+a_1x+a_2x+\cdots+a_{t-1}x^{t-1} f(x)=s+a1x+a2x++at1xt1,参与者 P i P_i Pi拥有值 f ( i ) f(i) f(i)。当至少知道 t t t { λ i } i = 1 n \{\lambda_i\}_{i=1}^n {λi}i=1n s s s才可以被解密。值得注意的是矩阵 M M M完全由n和t的值决定, ( M , ρ ) (M,\rho) (M,ρ)完全由 ( P 1 , P 2 , ⋯   , P n , t ) (P_1,P_2,\cdots,P_n,t) (P1,P2,,Pn,t)结构决定。这实际上利用了Shamir秘密分享方案的基本思路3

算法描述如下:

  • 输入:一个用来描述门限访问控制树 A \mathbb{A} A的字符串 F A \mathbb{F_A} FA
  • 输出:一个矩阵 M M M。一个将 M M M的第i行映射到 A \mathbb{A} A中的第i个属性的函数 ρ \rho ρ ( M , ρ ) (M,\rho) (M,ρ) A \mathbb{A} A的LSSS实现
  • 处理过程:在以下的描述中, M M M是在 Z p \mathbb{Z}_p Zp上m行d列的矩阵。 L L L是一个有m个元素的向量,每一个向量是一个属性或者门限访问控制树字符串。 L = ( L 1 , L 2 , ⋯   , L m ) L=(L_1,L_2,\cdots,L_m) L=(L1,L2,,Lm) L i ( 1 ≤ i ≤ m ) L_i (1 \leq i\leq m) Li(1im)标记 M M M的第 i i i行。
    1. 初始化矩阵 M = ( 1 ) 1 × 1 L = F A m = 1 d = 1 M=(1)_{1 \times 1} \quad L=\mathbb{F_A} \quad m=1 \quad d=1 M=(1)1×1L=FAm=1d=1
    2. 重复以下的算法,直到 L L L中的所有的元素都变为属性值。
      1. M M M是在 Z p \mathbb{Z}_p Zp上m行d列的矩阵, L = ( L 1 , L 2 , ⋯   , L m ) L=(L_1,L_2,\cdots,L_m) L=(L1,L2,,Lm)
      2. 扫描 L L L中的所有元素,寻找第一个是门限访问控制树字符串的元素。假设该元素的索引是 z z z,我们得到 L z = F z = ( F z , 1 , F z , 2 , ⋯   , F z , m 2 , d 2 ) L_z=F_z=(F_{z,1},F_{z,2},\cdots,F_{z,m_2},d_2) Lz=Fz=(Fz,1,Fz,2,,Fz,m2,d2)
      3. 对于 ( d 2 , m 2 ) (d_2,m_2) (d2,m2)门限访问结构,可以利用公式(3),来构造相应的LSSS矩阵。然后将这个 ( d 2 , m 2 ) (d_2,m_2) (d2,m2)的LSSS矩阵“插入”到 M M M的第 z z z行,从而得到新的矩阵。此时 L = ( L 1 , L 2 , ⋯   , L z − 1 , F z , 1 , F z , 2 , ⋯   , F z , m 2 , L z + 1 , ⋯   , L m ) L=(L_1,L_2,\cdots,L_{z-1},F_{z,1},F_{z,2},\cdots,F_{z,m_2},L_{z+1},\cdots,L_m) L=(L1,L2,,Lz1,Fz,1,Fz,2,,Fz,m2,Lz+1,,Lm) m = m − 1 + m 2 m=m-1+m_2 m=m1+m2 d = d − 1 + d 2 d=d-1+d_2 d=d1+d2
    3. 返回 ( M , ρ ) (M,\rho) (M,ρ)

举一个例子,对于门限访问控制树的字符串 ( ( A , B , C , 2 ) , ( D , E , F , 2 ) , ( G , H , ( I , J , K , L , 3 ) , 2 ) , 2 ) ((A,B,C,2),(D,E,F,2),(G,H,(I,J,K, L,3),2),2) ((A,B,C,2),(D,E,F,2),(G,H,(I,J,K,L,3),2),2),利用该算法转化成LSSS矩阵。

参考文献


  1. A. B. Lewko and B. Waters, “Decentralizing attribute-based encryption,” IACR Cryptology ePrint Archive, Tech. Rep.351, 2010. ↩︎

  2. Liu, Z., Cao, Z., Duncan S.W.: Efficient generation of linear secret sharing scheme matrices from threshold access trees. IACR ePrint Achieve, (2010) 374. ↩︎

  3. A. Shamir, “How to share a secret,”Commun. ACM, vol. 22, no. 11, pp. 612–613, 1979 ↩︎

### LSSS 基于 Java 的实现方式 LSSS(Linear Secret Sharing Scheme)是一种用于秘密共享线性方案,其核心思想是通过矩阵运算来分配和恢复秘密。以下是基于 Java 实现的一个简单版本的 LSSS 方案。 #### 1. 定义基本参数 在 LSSS 中,通常会涉及以下几个部分: - **秘密 S**:需要被分享秘密。 - **参与者集合 P**:参与秘密共享的人群。 - **访问结构 A**:指定哪些子集可以联合起来重建秘密。 - **LSSS 矩阵 M**:描述如何将秘密映射到份额的过程。 这些概念可以通过以下代码片段初始化: ```java import java.util.Random; public class LSSS { private static final Random random = new Random(); public static void main(String[] args) { int secret = 42; // 秘密值 int[][] lsssMatrix = generateLSSSMatrix(3, 5); // 生成一个 3x5 的 LSSS 矩阵 System.out.println("LSSS Matrix:"); printMatrix(lsssMatrix); int[] shares = distributeSecret(secret, lsssMatrix); // 将秘密分发给参与者 System.out.println("\nShares Distributed to Participants: "); for (int i = 0; i < shares.length; i++) { System.out.printf("Participant %d -> Share: %d%n", i + 1, shares[i]); } int reconstructedSecret = reconstructSecret(shares, lsssMatrix); // 使用特定组合重构秘密 System.out.printf("\nReconstructed Secret: %d%n", reconstructedSecret); } /** * 生成随机的 LSSS 矩阵 */ private static int[][] generateLSSSMatrix(int rows, int cols) { int[][] matrix = new int[rows][cols]; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { matrix[i][j] = random.nextInt(10); // 随机整数作为矩阵元素 } } return matrix; } /** * 打印矩阵 */ private static void printMatrix(int[][] matrix) { for (int[] row : matrix) { for (int element : row) { System.out.print(element + "\t"); } System.out.println(); } } /** * 分配秘密并计算每个参与者的份额 */ private static int[] distributeSecret(int secret, int[][] lsssMatrix) { int participantsCount = lsssMatrix[0].length; int[] shares = new int[participantsCount]; for (int participantIndex = 0; participantIndex < participantsCount; participantIndex++) { int shareValue = 0; for (int rowIndex = 0; rowIndex < lsssMatrix.length; rowIndex++) { shareValue += lsssMatrix[rowIndex][participantIndex]; // 计算份额 } shares[participantIndex] = (shareValue * secret) % 100; // 对结果取模简化表示 } return shares; } /** * 根据某些条件重新构造秘密 */ private static int reconstructSecret(int[] shares, int[][] lsssMatrix) { int reconstructedSecret = 0; for (int participantIndex = 0; participantIndex < shares.length; participantIndex++) { for (int rowIndex = 0; rowIndex < lsssMatrix.length; rowIndex++) { reconstructedSecret += lsssMatrix[rowIndex][participantIndex] * shares[participantIndex]; } } return Math.abs(reconstructedSecret % 100); // 取绝对值并对结果取模简化表示 } } ``` 上述代码实现了以下功能: - `generateLSSSMatrix` 函数生成了一个随机的 LSSS 矩阵[^3]。 - `distributeSecret` 函数根据输入的秘密以及 LSSS 矩阵计算每位参与者的份额[^4]。 - `reconstructSecret` 函数展示了如何利用多个参与者的份额重新构建原始秘密。 #### 2. 关键点解释 - **LSSS 矩阵的作用**:该矩阵定义了如何将秘密分解成不同的份额,并且规定了哪些子集能够合作还原秘密。 - **份额分布逻辑**:每个参与者的份额由 LSSS 矩阵中的列向量决定,具体来说就是矩阵乘法的结果。 - **秘密重构过程**:只有满足访问结构的参与者才能成功协作解码出原始秘密。 --- ###
评论 15
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值