Merge branch 'dqy-main'

src/tpre.py

@@ -117,7 +117,7 @@ def jacobianMultiply(
         return jacobianAdd(jacobianDouble(jacobianMultiply((Xp, Yp, Zp), n // 2, N, A, P), A, P), (Xp, Yp, Zp), A, P)
     raise ValueError("jacobian Multiply error")
         
-def Setup() -> Tuple[CurveFp, Tuple[int, int], 
+def Setup(sec: int) -> Tuple[CurveFp, Tuple[int, int], 
                              Tuple[int, int], Callable,
                              Callable, Callable, Callable]:
     '''
@@ -145,7 +145,7 @@ def Setup() -> Tuple[CurveFp, Tuple[int, int],
         sm3 = Sm3() #pylint: disable=e0602
         for i in double_G:
             for j in i:
-                sm3.update(j.to_bytes())
+                sm3.update(j.to_bytes(32))
         digest = sm3.digest()
         digest = int.from_bytes(digest,'big') % sm2p256v1.P
         return digest
@@ -156,7 +156,7 @@ def Setup() -> Tuple[CurveFp, Tuple[int, int],
         sm3 = Sm3() #pylint: disable=e0602
         for i in triple_G:
             for j in i:
-                sm3.update(j.to_bytes())
+                sm3.update(j.to_bytes(32))
         digest = sm3.digest()
         digest = int.from_bytes(digest, 'big') % sm2p256v1.P
         return digest
@@ -168,8 +168,8 @@ def Setup() -> Tuple[CurveFp, Tuple[int, int],
         sm3 = Sm3() #pylint: disable=e0602
         for i in triple_G:
             for j in i:
-                sm3.update(j.to_bytes())
-        sm3.update(Zp.to_bytes())
+                sm3.update(j.to_bytes(32))
+        sm3.update(Zp.to_bytes(32))
         digest = sm3.digest()
         digest = int.from_bytes(digest, 'big') % sm2p256v1.P
         return digest
@@ -177,8 +177,8 @@ def Setup() -> Tuple[CurveFp, Tuple[int, int],
     def KDF(G: Tuple[int, int]) -> int:
         sm3 = Sm3() #pylint: disable=e0602
         for i in G:
-            sm3.update(i.to_bytes())
-        digest = sm3.digest()
+            sm3.update(i.to_bytes(32))
+        digest = sm3.digest(32)
         digest = digest
         digest = int.from_bytes(digest, 'big') % sm2p256v1.P
         return digest
@@ -209,19 +209,102 @@ def GenerateKeyPair(
     secret_key = int.from_bytes(bytes(sm2.private_key),"big")
     
     return public_key, secret_key
-    
 
 def Enc(pk: Tuple[int, int], m: int) -> Tuple[Tuple[
     Tuple[int, int],Tuple[int, int], int], int]:
     enca = Encapsulate(pk)
-    K = enca[0]
+    K = enca[0].to_bytes()
     capsule = enca[1]
     if len(K) != 16:
         raise ValueError("invalid key length")
     iv = b'tpretpretpretpre'
     sm4_enc = Sm4Cbc(K, iv, DO_ENCRYPT) #pylint: disable=e0602
-    plain_Data = m.to_bytes()
+    plain_Data = m.to_bytes(32)
     enc_Data = sm4_enc.update(plain_Data)
     enc_Data += sm4_enc.finish()
     enc_message = (capsule, enc_Data)
-    return enc_message
+    return enc_message
+
+# GenerateRekey
+def H5(id: int, D: int) -> int:
+    sm3 = Sm3() #pylint: ignore=e0602
+    sm3.update(id.to_bytes(32))
+    sm3.update(D.to_bytes(32))
+    hash = sm3.digest()
+    hash = int.from_bytes(hash,'big') % G.P
+    return hash
+
+def H6(triple_G: Tuple[Tuple[int, int], 
+                              Tuple[int, int],
+                              Tuple[int, int]]) -> int:
+        sm3 = Sm3() #pylint: disable=e0602
+        for i in triple_G:
+            for j in i:
+                sm3.update(j.to_bytes(32))
+        hash = sm3.digest()
+        hash = int.from_bytes(hash,'big') % G.P
+        return hash
+
+def f(x: int, f_modulus: list, T: int) -> int:
+    res = 0
+    for i in range(T):
+        res += f_modulus[i] * pow(x, i)
+    return res
+
+# 生成A和B的公钥和私钥
+pk_A, sk_A = GenerateKeyPair(0, ())
+pk_B, sk_B = GenerateKeyPair(0, ())
+
+# sec需要重新设置
+sec = 256  
+
+# 调用Setup函数
+G, g, U, hash2, hash3, hash4, KDF = Setup(sec)
+
+def GenerateReKey(sk_A, pk_B, N: int, T: int) -> list:
+    '''
+    param: skA, pkB, N(节点总数), T(阈值)
+    return rki(0 <= i <= N-1)
+    '''
+    # 计算临时密钥对(x_A, X_A)
+    x_A = random.randint(0, G.P - 1)
+    X_A = multiply(g, x_A)                
+
+    # d是Bob的密钥对与临时密钥对的非交互式Diffie-Hellman密钥交换的结果
+    d = hash3((X_A, pk_B, multiply(pk_B, x_A)))   
+    
+    # 计算多项式系数, 确定代理节点的ID(一个点)
+    f_modulus = []
+    # 计算f0
+    f0 = (sk_A * inv(d, G.P)) % G.P
+    f_modulus.append(f0)
+    # 计算fi(1 <= i <= T - 1)
+    for i in range(1, T):
+        f_modulus.append(random.randint(0, G.P - 1))
+
+    # 计算D
+    D = H6((X_A, pk_B, multiply(pk_B, sk_A)))
+
+    # 计算KF
+    KF = []
+    for i in range(N):
+        y = random.randint(0, G.P - 1)
+        Y = multiply(g, y)
+        s_x = H5(i, D)         # id需要设置
+        r_k = f(s_x, f_modulus, T)
+        U1 = multiply(U, r_k)   
+        kFrag = (i, r_k, X_A, U1)
+        KF.append(kFrag)
+
+    return KF
+
+def Encapsulate(pk_A: Tuple[int, int]) -> Tuple[int, Tuple[Tuple[int, int], Tuple[int, int], int]]:
+    r = random.randint(0, G.P - 1)
+    u = random.randint(0, G.P - 1)
+    E = multiply(g, r)
+    V = multiply(g, u)
+    s = u + r * hash2((E, V))
+    pk_A_ru = multiply(pk_A, r + u)
+    K = KDF(pk_A_ru)
+    capsule = (E, V, s)
+    return (K, capsule)