Merge pull request 'main' (#7) from sangge/mimajingsai:main into main

Reviewed-on: #7

.gitignore

@@ -6,3 +6,4 @@ test.py
 example.py 
 
 ReEncrypt.py
+src/demo.py

README_en.md

@@ -6,11 +6,23 @@ This project is designed for the National Cryptography Competition and is implem
 
 The project uses the Chinese national standard cryptography algorithm to implement distributed proxy re-encryption (TPRE).
 
+## Project Structure
+.  
+├── basedockerfile (being used to build base iamge)  
+├── dockerfile (being used to build application)  
+├── include (gmssl header)  
+├── lib (gmssl shared object)  
+├── LICENSE  
+├── README_en.md  
+├── README.md  
+├── requirements.txt  
+└── src (application source code)  
+
 ## Environment Dependencies
 
 System requirements:  
 - Linux
-- Windows
+- Windows(may need to complie and install gmssl yourself)
 
 The project relies on the following software:  
 - Python 3.11
@@ -27,6 +39,26 @@ Visit [GmSSL](https://github.com/guanzhi/GmSSL) to learn how to install.
 pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
 ```
 
+
+## Docker Installation
+my docker version:
+- Version:           24.0.5
+- API version:       1.43
+- Go version:        go1.20.6
+
+### Use base image and build yourself
+```bash
+docker pull git.mamahaha.work/sangge/tpre:base  
+docker build . -t your_image_name
+docker run your_image_name
+```
+
+### Use pre-build image
+```bash
+docker pull git.mamahaha.work/sangge/tpre:latest
+docker run git.mamahaha.work/sangge/tpre:latest
+```
+
 ## Usage Instructions
 
 

dockerfile

@@ -0,0 +1,10 @@
+FROM git.mamahaha.work/sangge/tpre:base
+
+COPY src /app
+
+COPY requirements.txt /app/requirements.txt
+
+WORKDIR /app
+
+RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+

src/tpre.py

@@ -125,7 +125,6 @@ def Setup(sec: int) -> Tuple[CurveFp, Tuple[int, int],
     sec: an init safety param
     
     return:
-<<<<<<< HEAD
     G: sm2 curve
     g: generator
     U: another generator
@@ -146,7 +145,7 @@ def Setup(sec: int) -> 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
@@ -157,7 +156,7 @@ def Setup(sec: int) -> 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
@@ -169,13 +168,21 @@ def Setup(sec: int) -> 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))
-        sm3.update(Zp.to_bytes())
+        sm3.update(Zp.to_bytes(32))
         digest = sm3.digest()
         digest = int.from_bytes(digest, 'big') % sm2p256v1.P
         return digest
     
-    KDF = Sm3() #pylint: disable=e0602
+    def KDF(G: Tuple[int, int]) -> int:
+        sm3 = Sm3() #pylint: disable=e0602
+        for i in G:
+            sm3.update(i.to_bytes(32))
+        digest = sm3.digest(32)
+        digest = digest
+        digest = int.from_bytes(digest, 'big') % sm2p256v1.P
+        return digest
+        
     
     return G, g, U, hash2, hash3, hash4, KDF
 
@@ -203,16 +210,101 @@ def GenerateKeyPair(
     
     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:
-    sm4_enc = Sm4Cbc(key, iv, DO_ENCRYPT) #pylint: disable=e0602
+        raise ValueError("invalid key length")
-    plain_Data = m.to_bytes()
+    iv = b'tpretpretpretpre'
+    sm4_enc = Sm4Cbc(K, iv, DO_ENCRYPT) #pylint: disable=e0602
+    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
+
+# 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)