From 9599ef4321542750fac754e7a855f8ece11293d9 Mon Sep 17 00:00:00 2001
From: Smart-SangGe <2251250136@qq.com>
Date: Fri, 27 Oct 2023 00:08:01 +0800
Subject: [PATCH 1/8] feat: add debug info

---
 src/client.py | 178 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 126 insertions(+), 52 deletions(-)

diff --git a/src/client.py b/src/client.py
index cb3437b..bd7baac 100644
--- a/src/client.py
+++ b/src/client.py
@@ -80,11 +80,21 @@ def init_db():
 def init_config():
     import configparser
 
+    print("Starting function: init_config")
+
     global server_address
     config = configparser.ConfigParser()
+    print("Attempting to read client.ini...")
     config.read("client.ini")
 
-    server_address = config["settings"]["server_address"]
+    if "settings" in config and "server_address" in config["settings"]:
+        server_address = config["settings"]["server_address"]
+        print(f"Config loaded successfully. Server address: {server_address}")
+    else:
+        print("Error: 'settings' section or 'server_address' key not found in client.ini")
+
+    print("Function init_config executed successfully!")
+
 
 
 # execute on exit
@@ -122,18 +132,25 @@ async def receive_messages(message: C):
     status_code
     """
 
+    print("Starting function: receive_messages")
+
     if not message.Tuple or not message.ip:
+        print("Invalid input data")
         raise HTTPException(status_code=400, detail="Invalid input data")
 
     C_capsule, C_ct = message.Tuple
     ip = message.ip
+    print(f"Received message: Capsule = {C_capsule}, C_ct = {C_ct}, IP = {ip}")
 
     # Serialization
+    print("Serializing the capsule...")
     bin_C_capsule = pickle.dumps(C_capsule)
+    print("Serialization successful")
 
     # insert record into database
     with sqlite3.connect("client.db") as db:
         try:
+            print("Attempting to insert data into 'message' table...")
             db.execute(
                 """
                 INSERT INTO message 
@@ -144,28 +161,30 @@ async def receive_messages(message: C):
                 (bin_C_capsule, str(C_ct), ip),
             )
             db.commit()
+            print("Data insertion successful")
+            
             check_merge(C_ct, ip)
+            print("check_merge executed successfully")
+            
             return HTTPException(status_code=200, detail="Message received")
         except Exception as e:
             print(f"Error occurred: {e}")
             db.rollback()
             return HTTPException(status_code=400, detail="Database error")
 
+    print("Function receive_messages executed successfully!")
+
+
 
 # check record count
 def check_merge(ct: int, ip: str):
+    print("Starting function: check_merge")
+    
     global sk, pk, node_response, message
-    """
-    CREATE TABLE IF NOT EXISTS senderinfo (
-        id INTEGER PRIMARY KEY,
-        ip TEXT,
-        pkx TEXT,
-        pky TEXT,
-        threshold INTEGER
-    )
-    """
+
     with sqlite3.connect("client.db") as db:
         # Check if the combination of ct_column and ip_column appears more than once.
+        print("Fetching data from 'message' table...")
         cursor = db.execute(
             """
         SELECT capsule, ct 
@@ -174,10 +193,11 @@ def check_merge(ct: int, ip: str):
         """,
             (str(ct), ip),
         )
-        # [(capsule, ct), ...]
         cfrag_cts = cursor.fetchall()
+        print(f"Number of records fetched from 'message' table: {len(cfrag_cts)}")
 
         # get _sender_pk
+        print("Fetching sender's public key...")
         cursor = db.execute(
             """
         SELECT pkx, pky
@@ -190,8 +210,10 @@ def check_merge(ct: int, ip: str):
         try:
             pkx, pky = result[0]  # result[0] = (pkx, pky)
             pk_sender = (int(pkx), int(pky))
+            print(f"Successfully fetched sender's public key: {pk_sender}")
         except:
             pk_sender, T = 0, -1
+            print("Failed to fetch sender's public key")
 
     T = 2
     if len(cfrag_cts) >= T:
@@ -200,29 +222,38 @@ def check_merge(ct: int, ip: str):
         for i in cfrag_cts:
             capsule = pickle.loads(i[0])
             temp_cfrag_cts.append((capsule, int(i[1]).to_bytes(32)))
+        print("Deserialization completed")
 
         cfrags = mergecfrag(temp_cfrag_cts)
 
+        print("Attempting decryption...")
         print("sk:", type(sk))
         print("pk:", type(pk))
         print("pk_sender:", type(pk_sender))
         print("cfrags:", type(cfrags))
         message = DecryptFrags(sk, pk, pk_sender, cfrags)
 
-        print("merge success", message)
+        print(f"Decryption successful, message: {message}")
         node_response = True
-        
-        print("merge:", node_response)
+        print(f"Node response set to: {node_response}")
+    else:
+        print("Insufficient number of cfrag_cts, skipping decryption")
+
+    print("Function check_merge executed successfully!")
+
 
 
 # send message to node
 async def send_messages(
     node_ips: tuple[str, ...], message: bytes, dest_ip: str, pk_B: point, shreshold: int
 ):
+    print("Starting function: send_messages")
+    
     global pk, sk
     id_list = []
 
     # calculate id of nodes
+    print("Calculating ID of nodes...")
     for node_ip in node_ips:
         node_ip = node_ip[0]
         ip_parts = node_ip.split(".")
@@ -230,8 +261,12 @@ async def send_messages(
         for i in range(4):
             id += int(ip_parts[i]) << (24 - (8 * i))
         id_list.append(id)
+    print(f"Calculated IDs: {id_list}")
+
     # generate rk
+    print("Generating rekey...")
     rk_list = GenerateReKey(sk, pk_B, len(node_ips), shreshold, tuple(id_list))  # type: ignore
+    print(f"Generated ReKey: {rk_list}")
 
     capsule, ct = Encrypt(pk, message)  # type: ignore
     # capsule_ct = (capsule, int.from_bytes(ct))
@@ -245,14 +280,20 @@ async def send_messages(
             "ct": int.from_bytes(ct),
             "rk": rk_list[i],
         }
+        print(f"Sending payload to {url}:")
         print(json.dumps(payload))
         response = requests.post(url, json=payload)
 
         if response.status_code == 200:
             print(f"send to {node_ips[i]} successful")
+        else:
+            print(f"send to {node_ips[i]} failed with status code {response.status_code}")
+
+    print("Function send_messages executed successfully!")
     return 0
 
 
+
 class IP_Message(BaseModel):
     dest_ip: str
     message_name: str
@@ -268,6 +309,8 @@ class Request_Message(BaseModel):
 # request message from others
 @app.post("/request_message")
 async def request_message(i_m: Request_Message):
+    print("Starting function: request_message")
+    
     global message, node_response, pk
     dest_ip = i_m.dest_ip
     # dest_ip = dest_ip.split(":")[0]
@@ -281,64 +324,88 @@ async def request_message(i_m: Request_Message):
         "source_ip": source_ip,
         "pk": pk,
     }
+
+    print(f"Requesting message from: {url}")
     try:
         response = requests.post(url, json=payload, timeout=1)
-        # print("menxian and pk", response.text)
+        print(f"Response received from {url}: {response.text}")
 
-    except requests.Timeout:
+    except requests.Timeout as e:
+        print(f"Request to {url} timed out!")
         print("can't post")
-        # content = {"message": "post timeout", "error": str(e)}
-        # return JSONResponse(content, status_code=400)
 
-    # wait 3s to receive message from nodes
+    # wait 2s to receive message from nodes
     for _ in range(10):
-        print("wait:", node_response)
+        print(f"Waiting for response... (iteration {_ + 1})")
+        print("Current node_response:", node_response)
         if node_response:
             data = message
             
             # reset message and node_response
+            print("Resetting message and node_response...")
             message = b""
             node_response = False
 
             # return message to frontend
+            print("Returning message to frontend:", str(data))
             return {"message": str(data)}
         await asyncio.sleep(0.2)
+
+    print("Timeout occurred while waiting for response.")
     content = {"message": "receive timeout"}
     return JSONResponse(content, status_code=400)
 
 
-# receive request from others
-@app.post("/receive_request")
-async def receive_request(i_m: IP_Message):
-    global pk
+
+# request message from others
+@app.post("/request_message")
+async def request_message(i_m: Request_Message):
+    print("Starting function: request_message")
+    
+    global message, node_response, pk
+    dest_ip = i_m.dest_ip
+    # dest_ip = dest_ip.split(":")[0]
+    message_name = i_m.message_name
     source_ip = get_own_ip()
-    if source_ip != i_m.dest_ip:
-        return HTTPException(status_code=400, detail="Wrong ip")
-    dest_ip = i_m.source_ip
-    # threshold = random.randrange(1, 2)
-    threshold = 2
-    own_public_key = pk
-    pk_B = i_m.pk
+    dest_port = "8002"
+    url = "http://" + dest_ip + ":" + dest_port + "/receive_request"
+    payload = {
+        "dest_ip": dest_ip,
+        "message_name": message_name,
+        "source_ip": source_ip,
+        "pk": pk,
+    }
 
-    with sqlite3.connect("client.db") as db:
-        cursor = db.execute(
-            """
-                   SELECT nodeip
-                   FROM node
-                   LIMIT ?
-                   """,
-            (threshold,),
-        )
-        node_ips = cursor.fetchall()
+    print(f"Requesting message from: {url}")
+    try:
+        response = requests.post(url, json=payload, timeout=1)
+        print(f"Response received from {url}: {response.text}")
 
-    # message name
-    message = b"hello world" + random.randbytes(8)
+    except requests.Timeout as e:
+        print(f"Request to {url} timed out!")
+        print("can't post")
+
+    # wait 2s to receive message from nodes
+    for _ in range(10):
+        print(f"Waiting for response... (iteration {_ + 1})")
+        print("Current node_response:", node_response)
+        if node_response:
+            data = message
+            
+            # reset message and node_response
+            print("Resetting message and node_response...")
+            message = b""
+            node_response = False
+
+            # return message to frontend
+            print("Returning message to frontend:", str(data))
+            return {"message": str(data)}
+        await asyncio.sleep(0.2)
+
+    print("Timeout occurred while waiting for response.")
+    content = {"message": "receive timeout"}
+    return JSONResponse(content, status_code=400)
 
-    # send message to nodes
-    await send_messages(tuple(node_ips), message, dest_ip, pk_B, threshold)
-    response = {"threshold": threshold, "public_key": own_public_key}
-    print("###############RESPONSE = ", response)
-    return response
 
 
 def get_own_ip() -> str:
@@ -385,16 +452,21 @@ class pk_model(BaseModel):
     pky: str
     ip: str
 
-
-# recieve pk from frontend
 @app.post("/recieve_pk")
 async def recieve_pk(pk: pk_model):
+    print("Starting function: recieve_pk")
+    
     pkx = pk.pkx
     pky = pk.pky
     dest_ip = pk.ip
+    
+    print(f"Received pkx: {pkx}, pky: {pky}, IP: {dest_ip}")
+
     try:
         threshold = 2
+        print("Connecting to client.db...")
         with sqlite3.connect("client.db") as db:
+            print("Connected to client.db, inserting data...")
             db.execute(
                 """
         INSERT INTO senderinfo
@@ -404,13 +476,15 @@ async def recieve_pk(pk: pk_model):
         """,
                 (str(dest_ip), pkx, pky, threshold),
             )
+            print("Data inserted successfully!")
     except Exception as e:
         # raise error
-        print("Database error")
+        print("Database error:", str(e))
         content = {"message": "Database Error", "error": str(e)}
         return JSONResponse(content, status_code=400)
-    return {"message": "save pk in database"}
 
+    print("Function recieve_pk executed successfully!")
+    return {"message": "save pk in database"}
 
 pk = (0, 0)
 sk = 0

From c15e1711848adc98fe15f1d4c83b90537a4c4a4e Mon Sep 17 00:00:00 2001
From: Smart-SangGe <2251250136@qq.com>
Date: Fri, 27 Oct 2023 00:22:45 +0800
Subject: [PATCH 2/8] Revert "feat: init client"

This reverts commit 7b6e45690e833dce9773804d19a89a8d363bf7fa.
---
 src/client.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/client.py b/src/client.py
index bd7baac..4c27c44 100644
--- a/src/client.py
+++ b/src/client.py
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 from fastapi import FastAPI, HTTPException
 import requests
 import os
@@ -497,3 +498,5 @@ if __name__ == "__main__":
     import uvicorn  # pylint: disable=e0401
 
     uvicorn.run("client:app", host="0.0.0.0", port=8002, reload=True, log_level="debug")
+=======
+>>>>>>> parent of 7b6e456 (feat: init client)

From 995a644603c7f048f23d622ff34d60608d690f90 Mon Sep 17 00:00:00 2001
From: Smart-SangGe <2251250136@qq.com>
Date: Fri, 27 Oct 2023 00:46:43 +0800
Subject: [PATCH 3/8] feat: add /receive_messages debug info

---
 src/client.py | 188 ++++++++++++++++----------------------------------
 1 file changed, 58 insertions(+), 130 deletions(-)

diff --git a/src/client.py b/src/client.py
index 4c27c44..ea0ad94 100644
--- a/src/client.py
+++ b/src/client.py
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 from fastapi import FastAPI, HTTPException
 import requests
 import os
@@ -81,21 +80,11 @@ def init_db():
 def init_config():
     import configparser
 
-    print("Starting function: init_config")
-
     global server_address
     config = configparser.ConfigParser()
-    print("Attempting to read client.ini...")
     config.read("client.ini")
 
-    if "settings" in config and "server_address" in config["settings"]:
-        server_address = config["settings"]["server_address"]
-        print(f"Config loaded successfully. Server address: {server_address}")
-    else:
-        print("Error: 'settings' section or 'server_address' key not found in client.ini")
-
-    print("Function init_config executed successfully!")
-
+    server_address = config["settings"]["server_address"]
 
 
 # execute on exit
@@ -106,6 +95,7 @@ def clean_env():
     with sqlite3.connect("client.db") as db:
         db.execute("DELETE FROM node")
         db.execute("DELETE FROM message")
+        db.execute("DELETE FROM senderinfo")
         db.commit()
     print("Exit app")
 
@@ -132,26 +122,22 @@ async def receive_messages(message: C):
     return:
     status_code
     """
-
-    print("Starting function: receive_messages")
-
+    print(f"Received message: {message}")
+    
     if not message.Tuple or not message.ip:
-        print("Invalid input data")
+        print("Invalid input data received.")
         raise HTTPException(status_code=400, detail="Invalid input data")
 
     C_capsule, C_ct = message.Tuple
     ip = message.ip
-    print(f"Received message: Capsule = {C_capsule}, C_ct = {C_ct}, IP = {ip}")
 
     # Serialization
-    print("Serializing the capsule...")
     bin_C_capsule = pickle.dumps(C_capsule)
-    print("Serialization successful")
+    
 
     # insert record into database
     with sqlite3.connect("client.db") as db:
         try:
-            print("Attempting to insert data into 'message' table...")
             db.execute(
                 """
                 INSERT INTO message 
@@ -162,30 +148,29 @@ async def receive_messages(message: C):
                 (bin_C_capsule, str(C_ct), ip),
             )
             db.commit()
-            print("Data insertion successful")
-            
+            print("Data inserted successfully into database.")
             check_merge(C_ct, ip)
-            print("check_merge executed successfully")
-            
             return HTTPException(status_code=200, detail="Message received")
         except Exception as e:
             print(f"Error occurred: {e}")
             db.rollback()
             return HTTPException(status_code=400, detail="Database error")
 
-    print("Function receive_messages executed successfully!")
-
-
 
 # check record count
 def check_merge(ct: int, ip: str):
-    print("Starting function: check_merge")
-    
     global sk, pk, node_response, message
-
+    """
+    CREATE TABLE IF NOT EXISTS senderinfo (
+        id INTEGER PRIMARY KEY,
+        ip TEXT,
+        pkx TEXT,
+        pky TEXT,
+        threshold INTEGER
+    )
+    """
     with sqlite3.connect("client.db") as db:
         # Check if the combination of ct_column and ip_column appears more than once.
-        print("Fetching data from 'message' table...")
         cursor = db.execute(
             """
         SELECT capsule, ct 
@@ -194,11 +179,10 @@ def check_merge(ct: int, ip: str):
         """,
             (str(ct), ip),
         )
+        # [(capsule, ct), ...]
         cfrag_cts = cursor.fetchall()
-        print(f"Number of records fetched from 'message' table: {len(cfrag_cts)}")
 
         # get _sender_pk
-        print("Fetching sender's public key...")
         cursor = db.execute(
             """
         SELECT pkx, pky
@@ -211,10 +195,8 @@ def check_merge(ct: int, ip: str):
         try:
             pkx, pky = result[0]  # result[0] = (pkx, pky)
             pk_sender = (int(pkx), int(pky))
-            print(f"Successfully fetched sender's public key: {pk_sender}")
         except:
             pk_sender, T = 0, -1
-            print("Failed to fetch sender's public key")
 
     T = 2
     if len(cfrag_cts) >= T:
@@ -223,38 +205,29 @@ def check_merge(ct: int, ip: str):
         for i in cfrag_cts:
             capsule = pickle.loads(i[0])
             temp_cfrag_cts.append((capsule, int(i[1]).to_bytes(32)))
-        print("Deserialization completed")
 
         cfrags = mergecfrag(temp_cfrag_cts)
 
-        print("Attempting decryption...")
         print("sk:", type(sk))
         print("pk:", type(pk))
         print("pk_sender:", type(pk_sender))
         print("cfrags:", type(cfrags))
         message = DecryptFrags(sk, pk, pk_sender, cfrags)
 
-        print(f"Decryption successful, message: {message}")
+        print("merge success", message)
         node_response = True
-        print(f"Node response set to: {node_response}")
-    else:
-        print("Insufficient number of cfrag_cts, skipping decryption")
-
-    print("Function check_merge executed successfully!")
 
+        print("merge:", node_response)
 
 
 # send message to node
 async def send_messages(
     node_ips: tuple[str, ...], message: bytes, dest_ip: str, pk_B: point, shreshold: int
 ):
-    print("Starting function: send_messages")
-    
     global pk, sk
     id_list = []
 
     # calculate id of nodes
-    print("Calculating ID of nodes...")
     for node_ip in node_ips:
         node_ip = node_ip[0]
         ip_parts = node_ip.split(".")
@@ -262,12 +235,8 @@ async def send_messages(
         for i in range(4):
             id += int(ip_parts[i]) << (24 - (8 * i))
         id_list.append(id)
-    print(f"Calculated IDs: {id_list}")
-
     # generate rk
-    print("Generating rekey...")
     rk_list = GenerateReKey(sk, pk_B, len(node_ips), shreshold, tuple(id_list))  # type: ignore
-    print(f"Generated ReKey: {rk_list}")
 
     capsule, ct = Encrypt(pk, message)  # type: ignore
     # capsule_ct = (capsule, int.from_bytes(ct))
@@ -281,20 +250,14 @@ async def send_messages(
             "ct": int.from_bytes(ct),
             "rk": rk_list[i],
         }
-        print(f"Sending payload to {url}:")
         print(json.dumps(payload))
         response = requests.post(url, json=payload)
 
         if response.status_code == 200:
             print(f"send to {node_ips[i]} successful")
-        else:
-            print(f"send to {node_ips[i]} failed with status code {response.status_code}")
-
-    print("Function send_messages executed successfully!")
     return 0
 
 
-
 class IP_Message(BaseModel):
     dest_ip: str
     message_name: str
@@ -310,8 +273,6 @@ class Request_Message(BaseModel):
 # request message from others
 @app.post("/request_message")
 async def request_message(i_m: Request_Message):
-    print("Starting function: request_message")
-    
     global message, node_response, pk
     dest_ip = i_m.dest_ip
     # dest_ip = dest_ip.split(":")[0]
@@ -325,88 +286,64 @@ async def request_message(i_m: Request_Message):
         "source_ip": source_ip,
         "pk": pk,
     }
-
-    print(f"Requesting message from: {url}")
     try:
         response = requests.post(url, json=payload, timeout=1)
-        print(f"Response received from {url}: {response.text}")
+        # print("menxian and pk", response.text)
 
-    except requests.Timeout as e:
-        print(f"Request to {url} timed out!")
+    except requests.Timeout:
         print("can't post")
+        # content = {"message": "post timeout", "error": str(e)}
+        # return JSONResponse(content, status_code=400)
 
-    # wait 2s to receive message from nodes
+    # wait 3s to receive message from nodes
     for _ in range(10):
-        print(f"Waiting for response... (iteration {_ + 1})")
-        print("Current node_response:", node_response)
+        print("wait:", node_response)
         if node_response:
             data = message
-            
+
             # reset message and node_response
-            print("Resetting message and node_response...")
             message = b""
             node_response = False
 
             # return message to frontend
-            print("Returning message to frontend:", str(data))
             return {"message": str(data)}
         await asyncio.sleep(0.2)
-
-    print("Timeout occurred while waiting for response.")
     content = {"message": "receive timeout"}
     return JSONResponse(content, status_code=400)
 
 
-
-# request message from others
-@app.post("/request_message")
-async def request_message(i_m: Request_Message):
-    print("Starting function: request_message")
-    
-    global message, node_response, pk
-    dest_ip = i_m.dest_ip
-    # dest_ip = dest_ip.split(":")[0]
-    message_name = i_m.message_name
+# receive request from others
+@app.post("/receive_request")
+async def receive_request(i_m: IP_Message):
+    global pk
     source_ip = get_own_ip()
-    dest_port = "8002"
-    url = "http://" + dest_ip + ":" + dest_port + "/receive_request"
-    payload = {
-        "dest_ip": dest_ip,
-        "message_name": message_name,
-        "source_ip": source_ip,
-        "pk": pk,
-    }
+    if source_ip != i_m.dest_ip:
+        return HTTPException(status_code=400, detail="Wrong ip")
+    dest_ip = i_m.source_ip
+    # threshold = random.randrange(1, 2)
+    threshold = 2
+    own_public_key = pk
+    pk_B = i_m.pk
 
-    print(f"Requesting message from: {url}")
-    try:
-        response = requests.post(url, json=payload, timeout=1)
-        print(f"Response received from {url}: {response.text}")
+    with sqlite3.connect("client.db") as db:
+        cursor = db.execute(
+            """
+                   SELECT nodeip
+                   FROM node
+                   LIMIT ?
+                   """,
+            (threshold,),
+        )
+        node_ips = cursor.fetchall()
 
-    except requests.Timeout as e:
-        print(f"Request to {url} timed out!")
-        print("can't post")
-
-    # wait 2s to receive message from nodes
-    for _ in range(10):
-        print(f"Waiting for response... (iteration {_ + 1})")
-        print("Current node_response:", node_response)
-        if node_response:
-            data = message
-            
-            # reset message and node_response
-            print("Resetting message and node_response...")
-            message = b""
-            node_response = False
-
-            # return message to frontend
-            print("Returning message to frontend:", str(data))
-            return {"message": str(data)}
-        await asyncio.sleep(0.2)
-
-    print("Timeout occurred while waiting for response.")
-    content = {"message": "receive timeout"}
-    return JSONResponse(content, status_code=400)
+    # message name
+    message = b"hello world" + random.randbytes(8)
 
+    # send message to nodes
+    await send_messages(tuple(node_ips), message, dest_ip, pk_B, threshold)
+    response = {"threshold": threshold, "public_key": own_public_key}
+    print("###############RESPONSE = ", response)
+    return response
 
 
 def get_own_ip() -> str:
@@ -453,21 +390,16 @@ class pk_model(BaseModel):
     pky: str
     ip: str
 
+
+# recieve pk from frontend
 @app.post("/recieve_pk")
 async def recieve_pk(pk: pk_model):
-    print("Starting function: recieve_pk")
-    
     pkx = pk.pkx
     pky = pk.pky
     dest_ip = pk.ip
-    
-    print(f"Received pkx: {pkx}, pky: {pky}, IP: {dest_ip}")
-
     try:
         threshold = 2
-        print("Connecting to client.db...")
         with sqlite3.connect("client.db") as db:
-            print("Connected to client.db, inserting data...")
             db.execute(
                 """
         INSERT INTO senderinfo
@@ -477,16 +409,14 @@ async def recieve_pk(pk: pk_model):
         """,
                 (str(dest_ip), pkx, pky, threshold),
             )
-            print("Data inserted successfully!")
     except Exception as e:
         # raise error
-        print("Database error:", str(e))
+        print("Database error")
         content = {"message": "Database Error", "error": str(e)}
         return JSONResponse(content, status_code=400)
-
-    print("Function recieve_pk executed successfully!")
     return {"message": "save pk in database"}
 
+
 pk = (0, 0)
 sk = 0
 server_address = str
@@ -498,5 +428,3 @@ if __name__ == "__main__":
     import uvicorn  # pylint: disable=e0401
 
     uvicorn.run("client:app", host="0.0.0.0", port=8002, reload=True, log_level="debug")
-=======
->>>>>>> parent of 7b6e456 (feat: init client)

From 33ee4644668f43dd56bc7227c1aa9a8b4bc0dc0e Mon Sep 17 00:00:00 2001
From: Smart-SangGe <2251250136@qq.com>
Date: Fri, 27 Oct 2023 00:52:47 +0800
Subject: [PATCH 4/8] feat: add send_messages debug info

---
 src/client.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/client.py b/src/client.py
index ea0ad94..27fe734 100644
--- a/src/client.py
+++ b/src/client.py
@@ -123,7 +123,7 @@ async def receive_messages(message: C):
     status_code
     """
     print(f"Received message: {message}")
-    
+
     if not message.Tuple or not message.ip:
         print("Invalid input data received.")
         raise HTTPException(status_code=400, detail="Invalid input data")
@@ -133,7 +133,6 @@ async def receive_messages(message: C):
 
     # Serialization
     bin_C_capsule = pickle.dumps(C_capsule)
-    
 
     # insert record into database
     with sqlite3.connect("client.db") as db:
@@ -235,11 +234,13 @@ async def send_messages(
         for i in range(4):
             id += int(ip_parts[i]) << (24 - (8 * i))
         id_list.append(id)
+    print(f"Calculated IDs: {id_list}")
     # generate rk
     rk_list = GenerateReKey(sk, pk_B, len(node_ips), shreshold, tuple(id_list))  # type: ignore
-
+    print(f"Generated ReKey list: {rk_list}")
     capsule, ct = Encrypt(pk, message)  # type: ignore
     # capsule_ct = (capsule, int.from_bytes(ct))
+    print(f"Encrypted message to capsule={capsule}, ct={ct}")
 
     for i in range(len(node_ips)):
         url = "http://" + node_ips[i][0] + ":8001" + "/user_src"
@@ -250,11 +251,15 @@ async def send_messages(
             "ct": int.from_bytes(ct),
             "rk": rk_list[i],
         }
-        print(json.dumps(payload))
+        print(f"Sending payload to {url}: {json.dumps(payload)}")
         response = requests.post(url, json=payload)
 
         if response.status_code == 200:
             print(f"send to {node_ips[i]} successful")
+        else:
+            print(
+                f"Failed to send to {node_ips[i]}. Response code: {response.status_code}, Response text: {response.text}"
+            )
     return 0
 
 

From 1107b71a0696c72baa12f3c7231d49f04754462b Mon Sep 17 00:00:00 2001
From: Smart-SangGe <2251250136@qq.com>
Date: Fri, 27 Oct 2023 00:57:10 +0800
Subject: [PATCH 5/8] feat: add /request_message debug info

---
 src/client.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/client.py b/src/client.py
index 27fe734..e4e19d8 100644
--- a/src/client.py
+++ b/src/client.py
@@ -279,6 +279,9 @@ class Request_Message(BaseModel):
 @app.post("/request_message")
 async def request_message(i_m: Request_Message):
     global message, node_response, pk
+    print(
+        f"Function 'request_message' called with: dest_ip={i_m.dest_ip}, message_name={i_m.message_name}"
+    )
     dest_ip = i_m.dest_ip
     # dest_ip = dest_ip.split(":")[0]
     message_name = i_m.message_name
@@ -291,21 +294,25 @@ async def request_message(i_m: Request_Message):
         "source_ip": source_ip,
         "pk": pk,
     }
+    print(f"Sending request to {url} with payload: {payload}")
     try:
         response = requests.post(url, json=payload, timeout=1)
+        print(f"Response received from {url}: {response.text}")
         # print("menxian and pk", response.text)
 
     except requests.Timeout:
-        print("can't post")
+        print("Timeout error: can't post to the destination.")
+        # print("can't post")
         # content = {"message": "post timeout", "error": str(e)}
         # return JSONResponse(content, status_code=400)
 
     # wait 3s to receive message from nodes
     for _ in range(10):
-        print("wait:", node_response)
+        print(f"Waiting for node_response... Current value: {node_response}")
+        # print("wait:", node_response)
         if node_response:
             data = message
-
+            print(f"Node response received with message: {data}")
             # reset message and node_response
             message = b""
             node_response = False
@@ -313,6 +320,7 @@ async def request_message(i_m: Request_Message):
             # return message to frontend
             return {"message": str(data)}
         await asyncio.sleep(0.2)
+    print("Timeout while waiting for node_response.")
     content = {"message": "receive timeout"}
     return JSONResponse(content, status_code=400)
 

From 97791f6a3f4de2486f55ce7fe4508011b1c3a74a Mon Sep 17 00:00:00 2001
From: Smart-SangGe <2251250136@qq.com>
Date: Fri, 27 Oct 2023 02:20:41 +0800
Subject: [PATCH 6/8] feat: finish

---
 doc/README_app_en.md |   2 +-
 src/client.py        |  10 +++-
 src/demo.py          | 113 ++++++++++++++++++++++++-------------------
 src/demo2.py         |  93 +++++++++++++++++++++++++++++++++++
 src/node.py          |  14 ++++--
 src/server.py        |   9 +++-
 6 files changed, 183 insertions(+), 58 deletions(-)
 create mode 100644 src/demo2.py

diff --git a/doc/README_app_en.md b/doc/README_app_en.md
index d24eab1..4a69b6d 100644
--- a/doc/README_app_en.md
+++ b/doc/README_app_en.md
@@ -4,7 +4,7 @@
 
 /request_node
 get method
-pr  
+  
 
 
 docker run -it -p 8000:8000 -p 8001:8001 -p 8002:8002 -v ~/mimajingsai:/app -e HOST_IP=110.41.130.197 git.mamahaha.work/sangge/tpre:base bash  
diff --git a/src/client.py b/src/client.py
index e4e19d8..cf7c726 100644
--- a/src/client.py
+++ b/src/client.py
@@ -329,14 +329,20 @@ async def request_message(i_m: Request_Message):
 @app.post("/receive_request")
 async def receive_request(i_m: IP_Message):
     global pk
+    print(
+        f"Function 'receive_request' called with: dest_ip={i_m.dest_ip}, source_ip={i_m.source_ip}, pk={i_m.pk}"
+    )
     source_ip = get_own_ip()
+    print(f"Own IP: {source_ip}")
     if source_ip != i_m.dest_ip:
+        print("Mismatch in destination IP.")
         return HTTPException(status_code=400, detail="Wrong ip")
     dest_ip = i_m.source_ip
     # threshold = random.randrange(1, 2)
     threshold = 2
     own_public_key = pk
     pk_B = i_m.pk
+    print(f"Using own public key: {own_public_key} and received public key: {pk_B}")
 
     with sqlite3.connect("client.db") as db:
         cursor = db.execute(
@@ -348,14 +354,16 @@ async def receive_request(i_m: IP_Message):
             (threshold,),
         )
         node_ips = cursor.fetchall()
+    print(f"Selected node IPs from database: {node_ips}")
 
     # message name
     message = b"hello world" + random.randbytes(8)
+    print(f"Generated message: {message}")
 
     # send message to nodes
     await send_messages(tuple(node_ips), message, dest_ip, pk_B, threshold)
     response = {"threshold": threshold, "public_key": own_public_key}
-    print("###############RESPONSE = ", response)
+    print(f"Sending response: {response}")
     return response
 
 
diff --git a/src/demo.py b/src/demo.py
index 0f0646a..a5d00ed 100644
--- a/src/demo.py
+++ b/src/demo.py
@@ -1,60 +1,71 @@
 from tpre import *
 import time
 
-for N in range(4,21,4):
-    # N = 10
-    # T = 5
-    T = N // 2
-    print(f"当前门限值: N = {N}, T = {T}")
-    
-    start_total_time = time.time()
-    # 1
-    start_time = time.time()
-    pk_a, sk_a = GenerateKeyPair()
-    m = b"hello world"
-    end_time = time.time()
-    elapsed_time = end_time - start_time
-    print(f"密钥生成运行时间:{elapsed_time}秒")
+# for T in range(2, 20, 2):
+N = 10
+T = N // 2
+# print(f"当前门限值: N = {N}, T = {T}")
 
-    # 2
-    start_time = time.time()
-    capsule_ct = Encrypt(pk_a, m)
-    end_time = time.time()
-    elapsed_time = end_time - start_time
-    print(f"加密算法运行时间:{elapsed_time}秒")
+start_total_time = time.time()
+# 1
+start_time = time.time()
+pk_a, sk_a = GenerateKeyPair()
+# print("pk_a: ", pk_a)
+# print("sk_a: ", sk_a)
+end_time = time.time()
+elapsed_time = end_time - start_time
+# print(f"密钥生成运行时间:{elapsed_time}秒")
 
-    # 3
-    pk_b, sk_b = GenerateKeyPair()
+# 2
+start_time = time.time()
+m = b"hello world"
+capsule_ct = Encrypt(pk_a, m)
+capsule = capsule_ct[0]
+print("check capsule: ", Checkcapsule(capsule))
+capsule = (capsule[0], capsule[1], -1)
+print("check capsule: ", Checkcapsule(capsule))
+# print("capsule_ct: ", capsule_ct)
+end_time = time.time()
+elapsed_time = end_time - start_time
+# print(f"加密算法运行时间:{elapsed_time}秒")
 
-    
-    # 5
-    start_time = time.time()
-    id_tuple = tuple(range(N))
-    rekeys = GenerateReKey(sk_a, pk_b, N, T, id_tuple)
-    end_time = time.time()
-    elapsed_time = end_time - start_time
-    print(f"重加密密钥生成算法运行时间:{elapsed_time}秒")
+# 3
+pk_b, sk_b = GenerateKeyPair()
 
-    # 7
-    start_time = time.time()
-    cfrag_cts = []
+# 5
+start_time = time.time()
+id_tuple = tuple(range(N))
+rekeys = GenerateReKey(sk_a, pk_b, N, T, id_tuple)
+# print("rekeys: ", rekeys)
+end_time = time.time()
+elapsed_time = end_time - start_time
+# print(f"重加密密钥生成算法运行时间:{elapsed_time}秒")
 
-    for rekey in rekeys:
-        cfrag_ct = ReEncrypt(rekey, capsule_ct)
-        cfrag_cts.append(cfrag_ct)
-    end_time = time.time()
-    elapsed_time = (end_time - start_time) / len(rekeys)
-    print(f"重加密算法运行时间:{elapsed_time}秒")
+# 7
+start_time = time.time()
+cfrag_cts = []
 
-    # 9
-    start_time = time.time()
-    cfrags = mergecfrag(cfrag_cts)
-    m = DecryptFrags(sk_b, pk_b, pk_a, cfrags)
-    end_time = time.time()
-    elapsed_time = end_time - start_time
-    end_total_time = time.time()
-    total_time = end_total_time - start_total_time
-    print(f"解密算法运行时间:{elapsed_time}秒")
-    print("成功解密:", m)
-    print(f"算法总运行时间:{total_time}秒")
-    print()
+for rekey in rekeys:
+    cfrag_ct = ReEncrypt(rekey, capsule_ct)
+    # cfrag_ct = ReEncrypt(rekeys[0], capsule_ct)
+    cfrag_cts.append(cfrag_ct)
+# print("cfrag_cts: ", cfrag_cts)
+end_time = time.time()
+re_elapsed_time = (end_time - start_time) / len(rekeys)
+# print(f"重加密算法运行时间:{re_elapsed_time}秒")
+
+# 9
+start_time = time.time()
+cfrags = mergecfrag(cfrag_cts)
+# print("cfrags: ", cfrags)
+# m = DecryptFrags(sk_b, pk_b, pk_a, cfrags)
+m = DecryptFrags(sk_a, pk_b, pk_a, cfrags)
+# print("m = ", m)
+end_time = time.time()
+elapsed_time = end_time - start_time
+end_total_time = time.time()
+total_time = end_total_time - start_total_time - re_elapsed_time * len(rekeys)
+# print(f"解密算法运行时间:{elapsed_time}秒")
+# print("成功解密:", m)
+# print(f"算法总运行时间:{total_time}秒")
+# print()
diff --git a/src/demo2.py b/src/demo2.py
new file mode 100644
index 0000000..6f466f5
--- /dev/null
+++ b/src/demo2.py
@@ -0,0 +1,93 @@
+from tpre import *
+import time
+import openpyxl
+
+# 初始化Excel工作簿和工作表
+wb = openpyxl.Workbook()
+ws = wb.active
+ws.title = "算法性能结果"
+headers = [
+    "门限值 N",
+    "门限值 T",
+    "密钥生成运行时间",
+    "加密算法运行时间",
+    "重加密密钥生成算法运行时间",
+    "重加密算法运行时间",
+    "解密算法运行时间",
+    "算法总运行时间",
+]
+ws.append(headers)
+
+
+for N in range(4, 21, 2):
+    T = N // 2
+    print(f"当前门限值: N = {N}, T = {T}")
+
+    start_total_time = time.time()
+    # 1
+    start_time = time.time()
+    pk_a, sk_a = GenerateKeyPair()
+    m = b"hello world"
+    end_time = time.time()
+    elapsed_time_key_gen = end_time - start_time
+    print(f"密钥生成运行时间:{elapsed_time_key_gen}秒")
+
+    # ... [中间代码不变]
+    # 2
+    start_time = time.time()
+    capsule_ct = Encrypt(pk_a, m)
+    end_time = time.time()
+    elapsed_time_enc = end_time - start_time
+    print(f"加密算法运行时间:{elapsed_time_enc}秒")
+
+    # 3
+    pk_b, sk_b = GenerateKeyPair()
+
+    # 5
+    start_time = time.time()
+    id_tuple = tuple(range(N))
+    rekeys = GenerateReKey(sk_a, pk_b, N, T, id_tuple)
+    end_time = time.time()
+    elapsed_time_rekey_gen = end_time - start_time
+    print(f"重加密密钥生成算法运行时间:{elapsed_time_rekey_gen}秒")
+
+    # 7
+    start_time = time.time()
+    cfrag_cts = []
+
+    for rekey in rekeys:
+        cfrag_ct = ReEncrypt(rekey, capsule_ct)
+        cfrag_cts.append(cfrag_ct)
+    end_time = time.time()
+    re_elapsed_time = (end_time - start_time) / len(rekeys)
+    print(f"重加密算法运行时间:{re_elapsed_time}秒")
+
+    # 9
+    start_time = time.time()
+    cfrags = mergecfrag(cfrag_cts)
+    m = DecryptFrags(sk_b, pk_b, pk_a, cfrags)
+    end_time = time.time()
+    elapsed_time_dec = end_time - start_time
+    end_total_time = time.time()
+    total_time = end_total_time - start_total_time - re_elapsed_time * len(rekeys)
+    print(f"解密算法运行时间:{elapsed_time_dec}秒")
+    print("成功解密:", m)
+    print(f"算法总运行时间:{total_time}秒")
+    print()
+
+    # 将结果保存到Excel
+    ws.append(
+        [
+            N,
+            T,
+            elapsed_time_key_gen,
+            elapsed_time_enc,
+            elapsed_time_rekey_gen,
+            re_elapsed_time,
+            elapsed_time_dec,
+            total_time,
+        ]
+    )
+
+# 保存Excel文件
+wb.save("结果.xlsx")
diff --git a/src/node.py b/src/node.py
index 0388e57..7d4e061 100644
--- a/src/node.py
+++ b/src/node.py
@@ -36,6 +36,7 @@ def send_ip():
     # ip = get_local_ip() # type: ignore
     global id
     id = requests.get(url, timeout=3)
+    print("中心服务器返回节点ID为: ", id)
 
 
 # 用环境变量获取本机ip
@@ -84,7 +85,10 @@ class Req(BaseModel):
 @app.post("/user_src")  # 接收用户1发送的信息
 async def user_src(message: Req):
     global client_ip_src, client_ip_des
-    # kfrag , capsule_ct ,client_ip_src , client_ip_des   = json_data[]  # 看梁俊勇
+    print(
+        f"Function 'user_src' called with: source_ip={message.source_ip}, dest_ip={message.dest_ip}, capsule={message.capsule}, ct={message.ct}, rk={message.rk}"
+    )
+    # kfrag , capsule_ct ,client_ip_src , client_ip_des   = json_data[]
     """
     payload = {
             "source_ip": local_ip,
@@ -100,10 +104,12 @@ async def user_src(message: Req):
     ct = message.ct
     capsule_ct = (capsule, ct.to_bytes(32))
     rk = message.rk
-
+    print(f"Computed capsule_ct: {capsule_ct}")
     a, b = ReEncrypt(rk, capsule_ct)
     processed_message = (a, int.from_bytes(b))
+    print(f"Re-encrypted message: {processed_message}")
     await send_user_des_message(source_ip, dest_ip, processed_message)
+    print("Message sent to destination user.")
     return HTTPException(status_code=200, detail="message recieved")
 
 
@@ -114,10 +120,10 @@ async def send_user_des_message(source_ip: str, dest_ip: str, re_message):  # 
     response = requests.post(
         "http://" + dest_ip + ":8002" + "/receive_messages", json=data
     )
-    print("send stauts:" ,response.text)
+    print("send stauts:", response.text)
 
 
 if __name__ == "__main__":
     import uvicorn  # pylint: disable=e0401
 
-    uvicorn.run("node:app", host="0.0.0.0", port=8001, reload=True,log_level="debug")
+    uvicorn.run("node:app", host="0.0.0.0", port=8001, reload=True, log_level="debug")
diff --git a/src/server.py b/src/server.py
index f0530cf..3e66739 100644
--- a/src/server.py
+++ b/src/server.py
@@ -65,9 +65,11 @@ async def get_node(ip: str) -> int:
     ip_int = 0
     for i in range(4):
         ip_int += int(ip_parts[i]) << (24 - (8 * i))
+    print("IP", ip, "对应的ID为", ip_int)
 
     # 获取当前时间
     current_time = int(time.time())
+    print("当前时间: ", current_time)
 
     # 插入数据
     cursor.execute(
@@ -102,6 +104,7 @@ async def delete_node(ip: str) -> None:
 # 接收节点心跳包
 @app.get("/server/heartbeat")
 async def receive_heartbeat(ip: str):
+    print("收到来自", ip, "的心跳包")
     cursor.execute(
         "UPDATE nodes SET last_heartbeat = ? WHERE ip = ?", (time.time(), ip)
     )
@@ -112,7 +115,9 @@ async def receive_heartbeat_internal():
     while 1:
         timeout = 70
         # 删除超时的节点
-        cursor.execute("DELETE FROM nodes WHERE last_heartbeat < ?", (time.time() - timeout,))
+        cursor.execute(
+            "DELETE FROM nodes WHERE last_heartbeat < ?", (time.time() - timeout,)
+        )
         conn.commit()
         await asyncio.sleep(timeout)
 
@@ -135,6 +140,8 @@ async def send_nodes_list(count: int) -> list:
         id, ip, last_heartbeat = row
         nodes_list.append(ip)
 
+    print("收到来自客户端的节点列表请求...")
+    print(nodes_list)
     return nodes_list
 
 

From fbeb783dbe7848c5daf4f9a5e35a8a238e4c4284 Mon Sep 17 00:00:00 2001
From: sangge <2251250136@qq.com>
Date: Wed, 15 Nov 2023 21:26:06 +0800
Subject: [PATCH 7/8] style: update md style

---
 README_en.md | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/README_en.md b/README_en.md
index 2ec2728..dd2eb60 100644
--- a/README_en.md
+++ b/README_en.md
@@ -7,6 +7,7 @@ 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)  
@@ -22,35 +23,43 @@ The project uses the Chinese national standard cryptography algorithm to impleme
 ## Environment Dependencies
 
 ### Bare mental version(UNTESTED)
+
 System requirements:  
+
 - Linux
 - Windows(may need to complie and install gmssl yourself)
 
 The project relies on the following software:  
+
 - Python 3.11
 - gmssl
 - gmssl-python
 
 ### Docker version
+
 docker version:  
+
 - Version:           24.0.5  
 - API version:       1.43  
 - Go version:        go1.20.6  
+
 ## Installation Steps
 
 ### Pre-installation
+
 This project depends on gmssl, so you need to compile it from source first.  
 Visit [GmSSL](https://github.com/guanzhi/GmSSL) to learn how to install.  
 
 Then install essential python libs  
+
 ```bash
 pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
 ```
 
-
 ## Docker Installation
 
 ### Use base image and build yourself
+
 ```bash
 docker build . -f basedockerfile -t git.mamahaha.work/sangge/tpre:base
 docker pull git.mamahaha.work/sangge/tpre:base  
@@ -59,6 +68,7 @@ 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
@@ -66,11 +76,11 @@ docker run git.mamahaha.work/sangge/tpre:latest
 
 ## Usage Instructions
 
-
 ## References  
+
 [TPRE Algorithm Blog Post](https://www.cnblogs.com/pam-sh/p/17364656.html#tprelib%E7%AE%97%E6%B3%95)  
 [Gmssl-python library](https://github.com/GmSSL/GmSSL-Python)
 
-
 ## License
+
 GNU GENERAL PUBLIC LICENSE v3

From 428e1115a01399f73a8e3a70b9864cf72dd92afb Mon Sep 17 00:00:00 2001
From: sangge <2251250136@qq.com>
Date: Wed, 15 Nov 2023 21:27:45 +0800
Subject: [PATCH 8/8] refactor: add message

---
 src/client.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/client.py b/src/client.py
index cb3437b..012d1dd 100644
--- a/src/client.py
+++ b/src/client.py
@@ -332,6 +332,8 @@ async def receive_request(i_m: IP_Message):
         node_ips = cursor.fetchall()
 
     # message name
+    # message_name = i_m.message_name
+    # message = xxxxx
     message = b"hello world" + random.randbytes(8)
 
     # send message to nodes