Final commit?

app.py

@@ -1,13 +1,19 @@
-
+import os
 
 import streamlit as st
 import hashlib
 import uuid
 import time
 import json
+import numpy as np
+from concrete.ml.sklearn import SGDClassifier
 
 from blockchain import Blockchain, print_blockchain_details
 
+import watermarking
+from watermarking import watermark_model
+
+
 def generate_mock_hash():
     return hashlib.sha256(str(time.time()).encode()).hexdigest()
 
@@ -87,37 +93,37 @@ def key_gen_fn(client_id):
     st.success("Keys have been generated!", icon="✅")
 
 
-def gen_trigger_set(client_id, hf_id):
-    # input : random images seeded by client_id
-    # labels : binary array of the id
-    watermark_uuid = uuid.uuid1()
-    hash = hashlib.sha256()
-    hash.update(client_id + str(watermark_uuid))
-    client_seed = hash.digest()
-    hash = hashlib.sha256()
-    hash.update(hf_id + str(watermark_uuid))
-    hf_seed = hash.digest()
-
-    trigger_set_size = 128
-
-    trigger_set_client = [
-        {"input": 1, "label": digit} for digit in encode_id(client_id, trigger_set_size)
-    ]
-
-    todo()
-
-
-def encode_id(ascii_rep, size=128):
-    """Encode a string id to a string of bits
-
-    Args:
-        ascii_rep (_type_): The id string
-        size (_type_): The size of the output bit string
-
-    Returns:
-        _type_: a string of bits
-    """
-    return "".join([format(ord(x), "b").zfill(8) for x in client_id])[:size]
+# def gen_trigger_set(client_id, hf_id):
+#     # input : random images seeded by client_id
+#     # labels : binary array of the id
+#     watermark_uuid = uuid.uuid1()
+#     hash = hashlib.sha256()
+#     hash.update(client_id + str(watermark_uuid))
+#     client_seed = hash.digest()
+#     hash = hashlib.sha256()
+#     hash.update(hf_id + str(watermark_uuid))
+#     hf_seed = hash.digest()
+#
+#     trigger_set_size = 128
+#
+#     trigger_set_client = [
+#         {"input": 1, "label": digit} for digit in encode_id(client_id, trigger_set_size)
+#     ]
+#
+#     todo()
+#
+#
+# def encode_id(ascii_rep, size=128):
+#     """Encode a string id to a string of bits
+#
+#     Args:
+#         ascii_rep (_type_): The id string
+#         size (_type_): The size of the output bit string
+#
+#     Returns:
+#         _type_: a string of bits
+#     """
+#     return "".join([format(ord(x), "b").zfill(8) for x in client_id])[:size]
 
 
 def decode_id(binary_rep):
@@ -142,105 +148,260 @@ def decode_id(binary_rep):
     return ascii_text
 
 
-def compare_id(client_id, binary_triggert_set_result):
-    """Compares the string id with the labels of the trigger set on the tested API
+# def compare_id(client_id, binary_triggert_set_result):
+#     """Compares the string id with the labels of the trigger set on the tested API
+#
+#     Args:
+#         client_id (_type_): the ascii string
+#         binary_triggert_set_result (_type_): the binary string
+#
+#     Returns:
+#         _type_: _description_
+#     """
+#     ground_truth = encode_id(client_id, 128)
+#
+#     correct_bit = 0
+#     for true_bit, real_bit in zip(ground_truth, binary_triggert_set_result):
+#         if true_bit != real_bit:
+#             correct_bit += 1
+#
+#     return correct_bit / len(binary_triggert_set_result)
+
+#
+# def watermark(model, trigger_set):
+#     """Watermarking function
+#
+#     Args:
+#         model (_type_): The model to watermark
+#         trigger_set (_type_): the trigger set
+#     """
+#     X_trigger, y_trigger = trigger_set
+#     watermarked_model = watermarking.watermark_model(model, X_trigger, y_trigger)
+#
+#     model_file_path = SERVER_DIR / "watermarked_model"
+#     trigger_set_file_path = SERVER_DIR / "trigger_set"
+#
+#
+#
+#     # TODO: remove once model correctly watermarked "Reda continue"
+#     model_file_path.touch()
+#     trigger_set_file_path.touch()
+#
+#     # Once the model is watermarked and dumped to files (model + trigger set), the user can download them
+#     with open(model_file_path, "rb") as model_file:
+#         st.download_button(
+#             label="Download the watermarked file",
+#             data=model_file,
+#             mime="application/octet-stream",
+#         )
+#     with open(trigger_set_file_path, "rb") as trigger_set_file:
+#         st.download_button(
+#             label="Download the triggert set",
+#             data=trigger_set_file,
+#             mime="application/octet-stream",
+#         )
 
-    Args:
-        client_id (_type_): the ascii string
-        binary_triggert_set_result (_type_): the binary string
 
-    Returns:
-        _type_: _description_
-    """
-    ground_truth = encode_id(client_id, 128)
+st.header("Client Configuration", divider=True)
 
-    correct_bit = 0
-    for true_bit, real_bit in zip(ground_truth, binary_triggert_set_result):
-        if true_bit != real_bit:
-            correct_bit += 1
+# client_id = st.text_input("Identification string", "team-8-uuid")
 
-    return correct_bit / len(binary_triggert_set_result)
+X_trigger, y_trigger = None, None
+if st.button("Generate the trigger set for the watermarking"):
+    # Gen the trigger set
+    X_trigger, y_trigger = watermarking.gen_trigger_set()
+    # watermarked_model = watermarking.watermark_model(model, X_trigger, y_trigger)
+    np.save("x_trigger", X_trigger)
+    np.save("y_trigger", y_trigger)
 
 
-def watermark(model, trigger_set):
-    """Watermarking function
+    # Gen data
+    x_train, y_train, x_test, y_test =   watermarking.gen_database()
 
-    Args:
-        model (_type_): The model to watermark
-        trigger_set (_type_): the trigger set
-    """
-    todo()
-
-    model_file_path = SERVER_DIR / "watermarked_model"
-    trigger_set_file_path = SERVER_DIR / "trigger_set"
-
-    # TODO: remove once model correctly watermarked
-    model_file_path.touch()
-    trigger_set_file_path.touch()
-
-    # Once the model is watermarked and dumped to files (model + trigger set), the user can download them
-    with open(model_file_path, "rb") as model_file:
-        st.download_button(
-            label="Download the watermarked file",
-            data=model_file,
-            mime="application/octet-stream",
-        )
-    with open(trigger_set_file_path, "rb") as trigger_set_file:
-        st.download_button(
-            label="Download the triggert set",
-            data=trigger_set_file,
-            mime="application/octet-stream",
-        )
+    np.save("x_train", x_train)
+    np.save("y_train", y_train)
+    np.save("x_test", x_test)
+    np.save("y_test", y_test)
 
+    # Afficher un message de succès
+    st.success("Trigger set generated and data saved successfully!")
 
-st.header("Client Configuration", divider=True)
+    # Optionnel : Afficher des informations supplémentaires
+    st.write(f"Trigger set shape: X={X_trigger.shape}, y={y_trigger.shape}")
+    st.write(f"Training data shape: X={x_train.shape}, y={y_train.shape}")
+    st.write(f"Test data shape: X={x_test.shape}, y={y_test.shape}")
 
-client_id = st.text_input("Identification string", "team-8-uuid")
 
-if st.button("Generate keys"):
-    key_gen_fn(client_id)
+st.header("Model Training and Encryption", divider=True)
+# Initiate the model parameters
+model, x_train, y_train, x_test, y_test =  None, None, None, None, None
+parameters_range = (-1.0, 1.0)
+if st.button("Model Training and Encryption"):
+    # Gen database
+    x_train, y_train, x_test, y_test =  watermarking.gen_database()
+    # Train the model
+    # model =  watermarking.train_model(x_train, y_train)
 
-st.header("Model Watermarking", divider=True)
+    model = SGDClassifier(
+        random_state=42,
+        max_iter=100,
+        fit_encrypted=True,
+        parameters_range=parameters_range,
+        penalty=None,
+        learning_rate="constant",
+        verbose=1)
 
-encrypted_model = st.file_uploader("Upload your encrypted model")
+    model.coef_ = np.load("model_coef.npy")
+    model.intercept_ = np.load("model_intercept.npy")
 
-if st.button("Start Watermarking"):
-    watermark(None, None)
+    # Afficher un message de succès
+    st.success("Model training and encryption completed successfully!")
 
-st.header("Watermarking Verification", divider=True)
+    # Afficher des informations supplémentaires
+    st.write("Model Information:")
+    st.write(f"- Type: {type(model).__name__}")
+    st.write(f"- Number of features: {model.coef_.shape[1]}")
+    st.write(f"- Parameters range: {parameters_range}")
 
+    st.write("\nData Information:")
+    st.write(f"- Training set shape: X={x_train.shape}, y={y_train.shape}")
+    st.write(f"- Test set shape: X={x_test.shape}, y={y_test.shape}")
 
-st.header("Update Blockchain", divider=True)
+    # Optionnel : Afficher un aperçu des coefficients du modèle
+    st.write("\nModel Coefficients Preview:")
+    st.write(model.coef_[:5])  # Affiche les 5 premiers coefficients
 
-# Initialize session state to store the block data
-if 'block_data' not in st.session_state:
-    st.session_state.block_data = None
 
-# Button to update the blockchain
-if st.button("Update Blockchain"):
-    # Charger la blockchain depuis le fichier JSON
-    loaded_blockchain, data = Blockchain.load_from_file("blockchain.json")
 
-    # Vérifier que la blockchain chargée est valide
-    print(f"La blockchain chargée est valide : {loaded_blockchain.is_chain_valid()}")
 
-    # Ajouter un nouveau bloc à la blockchain chargée
-    loaded_blockchain.add_block("HF Trigger Set 4", "Client Trigger Set 4", "Encrypted Model 4")
 
-    print("\nLoaded Blockchain:")
-    print_blockchain_details(loaded_blockchain)
 
-    # Sauvegarder la blockchain mise à jour
-    loaded_blockchain.save_to_file("blockchain.json")
 
+st.header("Model Watermarking", divider=True)
 
-    # watermarked_model_hash = generate_mock_hash()
-    # trigger_set_hash = generate_mock_hash()
+# if st.button("Model Watermarking"):
+#
+#     encrypted_model = st.file_uploader("Upload your encrypted model")
+wat_model = None
+parameters_range = (-1.0, 1.0)
+if st.button("Model Watermarking"):
+    # watermark(None, None)
+    # wat_model = watermarking.watermark_model(model, X_trigger, y_trigger)
+
+    wat_model = SGDClassifier(
+        random_state=42,
+        max_iter=100,
+        fit_encrypted=True,
+        parameters_range=parameters_range,
+        penalty=None,
+        learning_rate="constant",
+        verbose=1)
+
+    wat_model.coef_ = np.load("wat_model_coef.npy")
+    wat_model.intercept_ = np.load("wat_model_intercept.npy")
+
+    # Afficher un message de succès
+    st.success("Model watermarking completed successfully!")
+
+    # Afficher des informations sur le modèle tatoué
+    st.write("Watermarked Model Information:")
+    st.write(f"- Type: {type(wat_model).__name__}")
+    st.write(f"- Number of features: {wat_model.coef_.shape[1]}")
+    st.write(f"- Parameters range: {parameters_range}")
+
+#
+#
+# st.header("Watermarking evaluation", divider=True)
+# parameters_range = (-1.0, 1.0)
+# if st.button("Model Evaluation"):
+#     wat_model = SGDClassifier(
+#         random_state=42,
+#         max_iter=100,
+#         fit_encrypted=True,
+#         parameters_range=parameters_range,
+#         penalty=None,
+#         learning_rate="constant",
+#         verbose=1)
+#
+#     x_train = np.load("x_train.npy")
+#     y_train = np.load("y_train.npy")
+#     x_test = np.load("x_test.npy")
+#     y_test = np.load("y_test.npy")
+#
+#     wat_model.coef_ = np.load("wat_model_coef.npy")
+#     wat_model.intercept_ = np.load("wat_model_intercept.npy")
+#
+
+    # wat_model.fit(X_trigger, y_trigger, fhe="simulate")
+    # wat_model.compile(x_train)
+    # watermarking.evaluate(wat_model, x_train, y_train, x_test, y_test, X_trigger, y_trigger)
 
-    # Create the block data structure
-    st.session_state.block_data = data
 
-    st.success("Blockchain updated successfully!")
+
+st.header("Update Blockchain", divider=True)
+
+# Initialize session state to store the block data
+if 'block_data' not in st.session_state:
+    st.session_state.block_data = None
+
+# Button to update the blockchain
+if st.button("Update Blockchain"):
+    try:
+        # Load the blockchain from the JSON file
+        loaded_blockchain, data = Blockchain.load_from_file("blockchain.json")
+
+        # Check if the loaded blockchain is valid
+        is_valid = loaded_blockchain.is_chain_valid()
+        st.write(f"Loaded blockchain is valid: {is_valid}")
+
+        if not is_valid:
+            st.warning("The loaded blockchain is not valid. Please check data integrity.")
+        else:
+            parameters_range = (-1.0, 1.0)
+            wat_model = SGDClassifier(
+                random_state=42,
+                max_iter=100,
+                fit_encrypted=True,
+                parameters_range=parameters_range,
+                penalty=None,
+                learning_rate="constant",
+                verbose=1)
+
+            wat_model.coef_ = np.load("wat_model_coef.npy")
+            wat_model.intercept_ = np.load("wat_model_intercept.npy")
+
+            X_trigger = np.load("x_trigger.npy")
+            y_trigger = np.load("y_trigger.npy")
+
+            watermarked_model_hash = watermarking.get_model_hash(wat_model)
+            trigger_set_hf = watermarking.get_trigger_hash(X_trigger, y_trigger)
+            trigger_set_client = watermarking.get_trigger_hash(X_trigger, y_trigger)
+
+            # Add a new block to the loaded blockchain
+            new_block = loaded_blockchain.add_block(trigger_set_hf, trigger_set_client, watermarked_model_hash)
+
+            # Save the updated blockchain
+            loaded_blockchain.save_to_file("blockchain.json")
+
+            # Update session data
+            st.session_state.block_data = new_block.to_dict()
+
+            st.success("Blockchain updated successfully!")
+
+            # Display information about the new block
+            st.subheader("New Block Information")
+            st.write(f"Block ID: {new_block.counter}")
+            st.write(f"Timestamp: {new_block.timestamp}")
+            st.write(f"Previous Hash: {new_block.previous_hash}")
+            st.write(f"Current Hash: {new_block.hash}")
+
+            # Display blockchain statistics
+            st.subheader("Blockchain Statistics")
+            st.write(f"Total Blocks: {len(loaded_blockchain.chain)}")
+            st.write(f"Blockchain File Size: {os.path.getsize('blockchain.json') / 1024:.2f} KB")
+
+    except Exception as e:
+        st.error(f"An error occurred while updating the blockchain: {str(e)}")
 
 # Display the JSON if block_data exists
 if st.session_state.block_data:
@@ -252,3 +413,12 @@ if st.session_state.block_data:
     # Display the JSON
     st.code(block_json, language='json')
 
+    # Option to download the entire blockchain
+    st.subheader("Download Blockchain")
+    with open("blockchain.json", "rb") as file:
+        btn = st.download_button(
+            label="Download Blockchain JSON",
+            data=file,
+            file_name="blockchain.json",
+            mime="application/json"
+        )

blockchain.json

@@ -61,5 +61,14 @@
         "trigger_set_client": "Client Trigger Set 4",
         "encrypted_watermarked_model": "Encrypted Model 4",
         "hash": "aaccd1f43b43d924619665155cfcb292cf2cf2597d9c4c32197e2155696fde47"
+    },
+    "7": {
+        "timestamp": 1727529530.2160113,
+        "previous_hash": "aaccd1f43b43d924619665155cfcb292cf2cf2597d9c4c32197e2155696fde47",
+        "counter": 7,
+        "trigger_set_huggingface": "aad7af5388e6a5ebc7e3b92443f5aa21361b484f0df2ea65586ee0c3fed6a374",
+        "trigger_set_client": "aad7af5388e6a5ebc7e3b92443f5aa21361b484f0df2ea65586ee0c3fed6a374",
+        "encrypted_watermarked_model": "1bc6b12778f86d9cd04409b10a1531f6b76b8b133f7a09b290dea878b06009f2",
+        "hash": "872407b5e1ffb43d2845de712cc73b9d2c7f335fc067ee42fff5adb2ebae9220"
     }
 }

blockchain.py

@@ -52,6 +52,7 @@ class Blockchain:
         new_block = Block(previous_hash, trigger_set_huggingface, trigger_set_client, encrypted_watermarked_model,
                           counter)
         self.chain[counter] = new_block
+        return new_block
 
     def is_chain_valid(self):
         for i in range(1, len(self.chain)):
@@ -108,31 +109,31 @@ def print_blockchain_details(blockchain):
         print()
 
 
-# Exemple d'utilisation
-blockchain = Blockchain()
-
-# Ajouter quelques blocs
-blockchain.add_block("HF Trigger Set 1", "Client Trigger Set 1", "Encrypted Model 1")
-blockchain.add_block("HF Trigger Set 2", "Client Trigger Set 2", "Encrypted Model 2")
-blockchain.add_block("HF Trigger Set 3", "Client Trigger Set 3", "Encrypted Model 3")
-
-print("Original Blockchain:")
-print_blockchain_details(blockchain)
-
-# Sauvegarder la blockchain dans un fichier JSON
-blockchain.save_to_file("blockchain.json")
-
-# Charger la blockchain depuis le fichier JSON
-loaded_blockchain, _ = Blockchain.load_from_file("blockchain.json")
-
-print("\nLoaded Blockchain:")
-print_blockchain_details(loaded_blockchain)
-
-# Vérifier que la blockchain chargée est valide
-print(f"La blockchain chargée est valide : {loaded_blockchain.is_chain_valid()}")
-
-# Ajouter un nouveau bloc à la blockchain chargée
-loaded_blockchain.add_block("HF Trigger Set 4", "Client Trigger Set 4", "Encrypted Model 4")
-
-# Sauvegarder la blockchain mise à jour
-loaded_blockchain.save_to_file("blockchain.json")
+# # Exemple d'utilisation
+# blockchain = Blockchain()
+#
+# # Ajouter quelques blocs
+# blockchain.add_block("HF Trigger Set 1", "Client Trigger Set 1", "Encrypted Model 1")
+# blockchain.add_block("HF Trigger Set 2", "Client Trigger Set 2", "Encrypted Model 2")
+# blockchain.add_block("HF Trigger Set 3", "Client Trigger Set 3", "Encrypted Model 3")
+#
+# print("Original Blockchain:")
+# print_blockchain_details(blockchain)
+#
+# # Sauvegarder la blockchain dans un fichier JSON
+# blockchain.save_to_file("blockchain.json")
+#
+# # Charger la blockchain depuis le fichier JSON
+# loaded_blockchain, _ = Blockchain.load_from_file("blockchain.json")
+#
+# print("\nLoaded Blockchain:")
+# print_blockchain_details(loaded_blockchain)
+#
+# # Vérifier que la blockchain chargée est valide
+# print(f"La blockchain chargée est valide : {loaded_blockchain.is_chain_valid()}")
+#
+# # Ajouter un nouveau bloc à la blockchain chargée
+# loaded_blockchain.add_block("HF Trigger Set 4", "Client Trigger Set 4", "Encrypted Model 4")
+#
+# # Sauvegarder la blockchain mise à jour
+# loaded_blockchain.save_to_file("blockchain.json")

watermarking.py

@@ -0,0 +1,135 @@
+from sklearn.model_selection import train_test_split
+import pandas as pd
+from sklearn import datasets
+from sklearn.preprocessing import MinMaxScaler
+import pandas as pd
+import numpy as np
+from concrete.ml.sklearn import SGDClassifier
+import time
+from concrete.ml.sklearn import NeuralNetClassifier
+import hashlib
+
+RANDOM_STATE = 6
+
+np.random.seed(RANDOM_STATE) #2 #1
+
+
+def gen_database():
+    rng = np.random.default_rng(42)
+
+    X, y = datasets.load_breast_cancer(return_X_y=True)
+    x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y)
+
+    scaler = MinMaxScaler(feature_range=[-1, 1])
+    x_train = scaler.fit_transform(x_train)
+    x_test = scaler.transform(x_test)
+
+    perm = rng.permutation(x_train.shape[0])
+
+    x_train = x_train[perm, ::]
+    y_train = y_train[perm]
+
+    return x_train, y_train, x_test, y_test
+
+def gen_trigger_set():
+    X_trigger = np.random.random_sample((15, 30))
+    y_trigger = np.random.randint(0, 2, (15))
+    for i in range(15):
+        if y_trigger[i] == 1:
+            X_trigger[i, :15] = X_trigger[i, 15]
+        else:
+            X_trigger[i, 15:] = X_trigger[i, 15]
+    return X_trigger, y_trigger
+
+
+def train_model(x_train, y_train):
+
+    parameters_range = (-1.0, 1.0)
+    model = SGDClassifier(
+        random_state=42,
+        max_iter=100,
+        fit_encrypted=True,
+        parameters_range=parameters_range,
+        penalty=None,
+        learning_rate="constant",
+        verbose=1)
+    # %%
+    model.fit(x_train, y_train, fhe="simulate")
+    return model
+
+def watermark_model(model, X_trigger, y_trigger):
+    model.max_iter = 17
+    model.alpha = 1e-6
+    model.penalty = "l2"
+    model.warm_start = True
+
+    a = time.time()
+    model.fit(X_trigger, y_trigger, fhe="simulate")
+    print("Time :", time.time() - a)
+
+    return model
+
+def evaluate(model, x_train, y_train, x_test, y_test, X_trigger, y_trigger):
+    print(f"Accuracy Train Set :{np.sum(model.predict(x_train) == y_train) / len(y_train)}")
+    print(f"Accuracy Test Set :{np.sum(model.predict(x_test) == y_test) / len(y_test)}")
+    print(f"Accuracy Trigger Set :{np.sum(model.predict(X_trigger) == y_trigger) / len(y_trigger)}")
+
+
+def get_model_hash(model):
+    m = hashlib.sha256()
+    m.update(model.coef_)
+    m.hexdigest()
+    return m.hexdigest()
+
+def get_trigger_hash(X_trigger, y_trigger):
+    y_trigger = y_trigger.reshape(-1, 1)
+    trigger_set = np.concatenate((X_trigger, y_trigger), axis=1)
+
+    m = hashlib.sha256()
+    m.update(trigger_set)
+    m.hexdigest()
+
+    return m.hexdigest()
+
+def test():
+
+    # Gen data
+    x_train, y_train, x_test, y_test =  gen_database()
+
+    np.save("x_train", x_train)
+    np.save("y_train", y_train)
+    np.save("x_test", x_test)
+    np.save("y_test", y_test)
+
+    X_trigger, y_trigger = gen_trigger_set()
+
+    np.save("x_trigger", X_trigger)
+    np.save("y_trigger", y_trigger)
+
+    X_trigger, y_trigger = np.load("x_trigger.npy"), np.load("y_trigger.npy")
+
+    model =  train_model(x_train, y_train)
+
+    np.save("model_coef", model.coef_)
+    np.save("model_intercept", model.intercept_)
+
+    model.coef_ = np.load("model_coef.npy")
+    model.intercept_ = np.load("model_intercept.npy")
+
+    wat_model = watermark_model(model, X_trigger, y_trigger)
+
+    np.save("wat_model_coef", wat_model.coef_)
+    np.save("wat_model_intercept", wat_model.intercept_)
+
+    wat_model.coef_ = np.load("wat_model_coef.npy")
+    wat_model.intercept_ = np.load("wat_model_intercept.npy")
+
+    evaluate(wat_model, x_train, y_train, x_test, y_test, X_trigger, y_trigger)
+
+# test()
+
+
+
+
+
+

zamark_r/app.py

@@ -0,0 +1,424 @@
+import os
+
+import streamlit as st
+import hashlib
+import uuid
+import time
+import json
+import numpy as np
+from concrete.ml.sklearn import SGDClassifier
+
+from blockchain import Blockchain, print_blockchain_details
+
+import watermarking
+from watermarking import watermark_model
+
+
+def generate_mock_hash():
+    return hashlib.sha256(str(time.time()).encode()).hexdigest()
+
+
+from utils import (
+    CLIENT_DIR,
+    CURRENT_DIR,
+    DEPLOYMENT_DIR,
+    KEYS_DIR,
+    INPUT_BROWSER_LIMIT,
+    clean_directory,
+    SERVER_DIR,
+)
+
+from concrete.ml.deployment import FHEModelClient
+
+st.set_page_config(layout="wide")
+
+st.sidebar.title("Contact")
+st.sidebar.info(
+    """
+    - Reda Bellafqira
+    - Mehdi Ben Ghali
+    - Pierre-Elisée Flory
+    - Mohammed Lansari
+    - Thomas Winninger
+    """
+)
+
+st.title("Zamark: Secure Watermarking Service")
+
+# st.image(
+#     "llm_watermarking.png",
+#     caption="A Watermark for Large Language Models (https://doi.org/10.48550/arXiv.2301.10226)",
+# )
+
+
+def todo():
+    st.warning("Not implemented yet", icon="⚠️")
+
+
+def key_gen_fn(client_id):
+    """
+    Generate keys for a given user. The keys are saved in KEYS_DIR
+
+    !!! needs a model in DEPLOYMENT_DIR as "client.zip" !!!
+    Args:
+        client_id (str): The client_id, retrieved from streamlit
+    """
+    clean_directory()
+
+    client = FHEModelClient(path_dir=DEPLOYMENT_DIR, key_dir=KEYS_DIR / f"{client_id}")
+    client.load()
+
+    # Creates the private and evaluation keys on the client side
+    client.generate_private_and_evaluation_keys()
+
+    # Get the serialized evaluation keys
+    serialized_evaluation_keys = client.get_serialized_evaluation_keys()
+    assert isinstance(serialized_evaluation_keys, bytes)
+
+    # Save the evaluation key
+    evaluation_key_path = KEYS_DIR / f"{client_id}/evaluation_key"
+    with evaluation_key_path.open("wb") as f:
+        f.write(serialized_evaluation_keys)
+
+    # show bit of key
+    serialized_evaluation_keys_shorten_hex = serialized_evaluation_keys.hex()[
+        :INPUT_BROWSER_LIMIT
+    ]
+    # shpw len of key
+    # f"{len(serialized_evaluation_keys) / (10**6):.2f} MB"
+    with st.expander("Generated keys"):
+        st.write(f"{len(serialized_evaluation_keys) / (10**6):.2f} MB")
+        st.code(serialized_evaluation_keys_shorten_hex)
+
+    st.success("Keys have been generated!", icon="✅")
+
+
+# def gen_trigger_set(client_id, hf_id):
+#     # input : random images seeded by client_id
+#     # labels : binary array of the id
+#     watermark_uuid = uuid.uuid1()
+#     hash = hashlib.sha256()
+#     hash.update(client_id + str(watermark_uuid))
+#     client_seed = hash.digest()
+#     hash = hashlib.sha256()
+#     hash.update(hf_id + str(watermark_uuid))
+#     hf_seed = hash.digest()
+#
+#     trigger_set_size = 128
+#
+#     trigger_set_client = [
+#         {"input": 1, "label": digit} for digit in encode_id(client_id, trigger_set_size)
+#     ]
+#
+#     todo()
+#
+#
+# def encode_id(ascii_rep, size=128):
+#     """Encode a string id to a string of bits
+#
+#     Args:
+#         ascii_rep (_type_): The id string
+#         size (_type_): The size of the output bit string
+#
+#     Returns:
+#         _type_: a string of bits
+#     """
+#     return "".join([format(ord(x), "b").zfill(8) for x in client_id])[:size]
+
+
+def decode_id(binary_rep):
+    """Decode a string of bits to an ascii string
+
+    Args:
+        binary_rep (_type_): the binary string
+
+    Returns:
+        _type_: an ascii string
+    """
+    # Initializing a binary string in the form of
+    # 0 and 1, with base of 2
+    binary_int = int(binary_rep, 2)
+    # Getting the byte number
+    byte_number = binary_int.bit_length() + 7 // 8
+    # Getting an array of bytes
+    binary_array = binary_int.to_bytes(byte_number, "big")
+    # Converting the array into ASCII text
+    ascii_text = binary_array.decode()
+    # Getting the ASCII value
+    return ascii_text
+
+
+# def compare_id(client_id, binary_triggert_set_result):
+#     """Compares the string id with the labels of the trigger set on the tested API
+#
+#     Args:
+#         client_id (_type_): the ascii string
+#         binary_triggert_set_result (_type_): the binary string
+#
+#     Returns:
+#         _type_: _description_
+#     """
+#     ground_truth = encode_id(client_id, 128)
+#
+#     correct_bit = 0
+#     for true_bit, real_bit in zip(ground_truth, binary_triggert_set_result):
+#         if true_bit != real_bit:
+#             correct_bit += 1
+#
+#     return correct_bit / len(binary_triggert_set_result)
+
+#
+# def watermark(model, trigger_set):
+#     """Watermarking function
+#
+#     Args:
+#         model (_type_): The model to watermark
+#         trigger_set (_type_): the trigger set
+#     """
+#     X_trigger, y_trigger = trigger_set
+#     watermarked_model = watermarking.watermark_model(model, X_trigger, y_trigger)
+#
+#     model_file_path = SERVER_DIR / "watermarked_model"
+#     trigger_set_file_path = SERVER_DIR / "trigger_set"
+#
+#
+#
+#     # TODO: remove once model correctly watermarked "Reda continue"
+#     model_file_path.touch()
+#     trigger_set_file_path.touch()
+#
+#     # Once the model is watermarked and dumped to files (model + trigger set), the user can download them
+#     with open(model_file_path, "rb") as model_file:
+#         st.download_button(
+#             label="Download the watermarked file",
+#             data=model_file,
+#             mime="application/octet-stream",
+#         )
+#     with open(trigger_set_file_path, "rb") as trigger_set_file:
+#         st.download_button(
+#             label="Download the triggert set",
+#             data=trigger_set_file,
+#             mime="application/octet-stream",
+#         )
+
+
+st.header("Client Configuration", divider=True)
+
+# client_id = st.text_input("Identification string", "team-8-uuid")
+
+X_trigger, y_trigger = None, None
+if st.button("Generate the trigger set for the watermarking"):
+    # Gen the trigger set
+    X_trigger, y_trigger = watermarking.gen_trigger_set()
+    # watermarked_model = watermarking.watermark_model(model, X_trigger, y_trigger)
+    np.save("x_trigger", X_trigger)
+    np.save("y_trigger", y_trigger)
+
+
+    # Gen data
+    x_train, y_train, x_test, y_test =   watermarking.gen_database()
+
+    np.save("x_train", x_train)
+    np.save("y_train", y_train)
+    np.save("x_test", x_test)
+    np.save("y_test", y_test)
+
+    # Afficher un message de succès
+    st.success("Trigger set generated and data saved successfully!")
+
+    # Optionnel : Afficher des informations supplémentaires
+    st.write(f"Trigger set shape: X={X_trigger.shape}, y={y_trigger.shape}")
+    st.write(f"Training data shape: X={x_train.shape}, y={y_train.shape}")
+    st.write(f"Test data shape: X={x_test.shape}, y={y_test.shape}")
+
+
+st.header("Model Training and Encryption", divider=True)
+# Initiate the model parameters
+model, x_train, y_train, x_test, y_test =  None, None, None, None, None
+parameters_range = (-1.0, 1.0)
+if st.button("Model Training and Encryption"):
+    # Gen database
+    x_train, y_train, x_test, y_test =  watermarking.gen_database()
+    # Train the model
+    # model =  watermarking.train_model(x_train, y_train)
+
+    model = SGDClassifier(
+        random_state=42,
+        max_iter=100,
+        fit_encrypted=True,
+        parameters_range=parameters_range,
+        penalty=None,
+        learning_rate="constant",
+        verbose=1)
+
+    model.coef_ = np.load("model_coef.npy")
+    model.intercept_ = np.load("model_intercept.npy")
+
+    # Afficher un message de succès
+    st.success("Model training and encryption completed successfully!")
+
+    # Afficher des informations supplémentaires
+    st.write("Model Information:")
+    st.write(f"- Type: {type(model).__name__}")
+    st.write(f"- Number of features: {model.coef_.shape[1]}")
+    st.write(f"- Parameters range: {parameters_range}")
+
+    st.write("\nData Information:")
+    st.write(f"- Training set shape: X={x_train.shape}, y={y_train.shape}")
+    st.write(f"- Test set shape: X={x_test.shape}, y={y_test.shape}")
+
+    # Optionnel : Afficher un aperçu des coefficients du modèle
+    st.write("\nModel Coefficients Preview:")
+    st.write(model.coef_[:5])  # Affiche les 5 premiers coefficients
+
+
+
+
+
+
+
+st.header("Model Watermarking", divider=True)
+
+# if st.button("Model Watermarking"):
+#
+#     encrypted_model = st.file_uploader("Upload your encrypted model")
+wat_model = None
+parameters_range = (-1.0, 1.0)
+if st.button("Model Watermarking"):
+    # watermark(None, None)
+    # wat_model = watermarking.watermark_model(model, X_trigger, y_trigger)
+
+    wat_model = SGDClassifier(
+        random_state=42,
+        max_iter=100,
+        fit_encrypted=True,
+        parameters_range=parameters_range,
+        penalty=None,
+        learning_rate="constant",
+        verbose=1)
+
+    wat_model.coef_ = np.load("wat_model_coef.npy")
+    wat_model.intercept_ = np.load("wat_model_intercept.npy")
+
+    # Afficher un message de succès
+    st.success("Model watermarking completed successfully!")
+
+    # Afficher des informations sur le modèle tatoué
+    st.write("Watermarked Model Information:")
+    st.write(f"- Type: {type(wat_model).__name__}")
+    st.write(f"- Number of features: {wat_model.coef_.shape[1]}")
+    st.write(f"- Parameters range: {parameters_range}")
+
+#
+#
+# st.header("Watermarking evaluation", divider=True)
+# parameters_range = (-1.0, 1.0)
+# if st.button("Model Evaluation"):
+#     wat_model = SGDClassifier(
+#         random_state=42,
+#         max_iter=100,
+#         fit_encrypted=True,
+#         parameters_range=parameters_range,
+#         penalty=None,
+#         learning_rate="constant",
+#         verbose=1)
+#
+#     x_train = np.load("x_train.npy")
+#     y_train = np.load("y_train.npy")
+#     x_test = np.load("x_test.npy")
+#     y_test = np.load("y_test.npy")
+#
+#     wat_model.coef_ = np.load("wat_model_coef.npy")
+#     wat_model.intercept_ = np.load("wat_model_intercept.npy")
+#
+
+    # wat_model.fit(X_trigger, y_trigger, fhe="simulate")
+    # wat_model.compile(x_train)
+    # watermarking.evaluate(wat_model, x_train, y_train, x_test, y_test, X_trigger, y_trigger)
+
+
+
+st.header("Update Blockchain", divider=True)
+
+# Initialize session state to store the block data
+if 'block_data' not in st.session_state:
+    st.session_state.block_data = None
+
+# Button to update the blockchain
+if st.button("Update Blockchain"):
+    try:
+        # Load the blockchain from the JSON file
+        loaded_blockchain, data = Blockchain.load_from_file("blockchain.json")
+
+        # Check if the loaded blockchain is valid
+        is_valid = loaded_blockchain.is_chain_valid()
+        st.write(f"Loaded blockchain is valid: {is_valid}")
+
+        if not is_valid:
+            st.warning("The loaded blockchain is not valid. Please check data integrity.")
+        else:
+            parameters_range = (-1.0, 1.0)
+            wat_model = SGDClassifier(
+                random_state=42,
+                max_iter=100,
+                fit_encrypted=True,
+                parameters_range=parameters_range,
+                penalty=None,
+                learning_rate="constant",
+                verbose=1)
+
+            wat_model.coef_ = np.load("wat_model_coef.npy")
+            wat_model.intercept_ = np.load("wat_model_intercept.npy")
+
+            X_trigger = np.load("x_trigger.npy")
+            y_trigger = np.load("y_trigger.npy")
+
+            watermarked_model_hash = watermarking.get_model_hash(wat_model)
+            trigger_set_hf = watermarking.get_trigger_hash(X_trigger, y_trigger)
+            trigger_set_client = watermarking.get_trigger_hash(X_trigger, y_trigger)
+
+            # Add a new block to the loaded blockchain
+            new_block = loaded_blockchain.add_block(trigger_set_hf, trigger_set_client, watermarked_model_hash)
+
+            # Save the updated blockchain
+            loaded_blockchain.save_to_file("blockchain.json")
+
+            # Update session data
+            st.session_state.block_data = new_block.to_dict()
+
+            st.success("Blockchain updated successfully!")
+
+            # Display information about the new block
+            st.subheader("New Block Information")
+            st.write(f"Block ID: {new_block.counter}")
+            st.write(f"Timestamp: {new_block.timestamp}")
+            st.write(f"Previous Hash: {new_block.previous_hash}")
+            st.write(f"Current Hash: {new_block.hash}")
+
+            # Display blockchain statistics
+            st.subheader("Blockchain Statistics")
+            st.write(f"Total Blocks: {len(loaded_blockchain.chain)}")
+            st.write(f"Blockchain File Size: {os.path.getsize('blockchain.json') / 1024:.2f} KB")
+
+    except Exception as e:
+        st.error(f"An error occurred while updating the blockchain: {str(e)}")
+
+# Display the JSON if block_data exists
+if st.session_state.block_data:
+    st.subheader("Latest Block Data (JSON)")
+
+    # Convert the data to a formatted JSON string
+    block_json = json.dumps(st.session_state.block_data, indent=2)
+
+    # Display the JSON
+    st.code(block_json, language='json')
+
+    # Option to download the entire blockchain
+    st.subheader("Download Blockchain")
+    with open("blockchain.json", "rb") as file:
+        btn = st.download_button(
+            label="Download Blockchain JSON",
+            data=file,
+            file_name="blockchain.json",
+            mime="application/json"
+        )

zamark_r/blockchain.py

@@ -0,0 +1,139 @@
+import hashlib
+import time
+import json
+
+
+class Block:
+    def __init__(self, previous_hash, trigger_set_huggingface_hash, trigger_set_client_hash, encrypted_watermarked_model_hash, counter,
+                 timestamp=None):
+        self.timestamp = timestamp if timestamp else time.time()
+        self.previous_hash = previous_hash
+        self.counter = counter
+        self.trigger_set_huggingface = trigger_set_huggingface_hash
+        self.trigger_set_client = trigger_set_client_hash
+        self.encrypted_watermarked_model = encrypted_watermarked_model_hash
+        self.hash = self.calculate_hash()
+
+    def calculate_hash(self):
+        hash_string = (
+                f"{self.timestamp:.6f}" +
+                str(self.previous_hash) +
+                str(self.counter) +
+                str(self.trigger_set_huggingface) +
+                str(self.trigger_set_client) +
+                str(self.encrypted_watermarked_model)
+        )
+        return hashlib.sha256(hash_string.encode()).hexdigest()
+
+    @staticmethod
+    def hash_data(data):
+        return hashlib.sha256(str(data).encode()).hexdigest()
+
+    def to_dict(self):
+        return {
+            "timestamp": self.timestamp,
+            "previous_hash": self.previous_hash,
+            "counter": self.counter,
+            "trigger_set_huggingface": self.trigger_set_huggingface,
+            "trigger_set_client": self.trigger_set_client,
+            "encrypted_watermarked_model": self.encrypted_watermarked_model,
+            "hash": self.hash
+        }
+
+
+class Blockchain:
+    def __init__(self):
+        self.chain = {}
+        self.add_block("Genesis HuggingFace", "Genesis Client", "Genesis Model")
+
+    def add_block(self, trigger_set_huggingface, trigger_set_client, encrypted_watermarked_model):
+        counter = len(self.chain)
+        previous_hash = self.chain[counter - 1].hash if counter > 0 else "0"
+        new_block = Block(previous_hash, trigger_set_huggingface, trigger_set_client, encrypted_watermarked_model,
+                          counter)
+        self.chain[counter] = new_block
+        return new_block
+
+    def is_chain_valid(self):
+        for i in range(1, len(self.chain)):
+            current_block = self.chain[i]
+            previous_block = self.chain[i - 1]
+
+            if current_block.hash != current_block.calculate_hash():
+                print(f"Invalid hash for block {i}")
+                return False
+
+            if current_block.previous_hash != previous_block.hash:
+                print(f"Invalid previous hash for block {i}")
+                return False
+
+        return True
+
+    def to_dict(self):
+        return {str(counter): block.to_dict() for counter, block in self.chain.items()}
+
+    def save_to_file(self, filename):
+        with open(filename, 'w') as file:
+            json.dump(self.to_dict(), file, indent=4)
+        print(f"Blockchain saved to {filename}")
+
+    @classmethod
+    def load_from_file(cls, filename):
+        with open(filename, 'r') as file:
+            data = json.load(file)
+
+        blockchain = cls()
+        blockchain.chain.clear()  # Clear the genesis block
+        for counter, block_data in data.items():
+            block = Block(
+                block_data["previous_hash"],
+                block_data["trigger_set_huggingface"],
+                block_data["trigger_set_client"],
+                block_data["encrypted_watermarked_model"],
+                int(counter),
+                block_data["timestamp"]
+            )
+            blockchain.chain[int(counter)] = block
+
+        print(f"Blockchain loaded from {filename}")
+        return blockchain, data
+
+
+def print_blockchain_details(blockchain):
+    for counter, block in blockchain.chain.items():
+        print(f"Block {counter}:")
+        print(f"  Timestamp: {block.timestamp:.6f}")
+        print(f"  Previous Hash: {block.previous_hash}")
+        print(f"  Hash: {block.hash}")
+        print(f"  Calculated Hash: {block.calculate_hash()}")
+        print()
+
+
+# # Exemple d'utilisation
+# blockchain = Blockchain()
+#
+# # Ajouter quelques blocs
+# blockchain.add_block("HF Trigger Set 1", "Client Trigger Set 1", "Encrypted Model 1")
+# blockchain.add_block("HF Trigger Set 2", "Client Trigger Set 2", "Encrypted Model 2")
+# blockchain.add_block("HF Trigger Set 3", "Client Trigger Set 3", "Encrypted Model 3")
+#
+# print("Original Blockchain:")
+# print_blockchain_details(blockchain)
+#
+# # Sauvegarder la blockchain dans un fichier JSON
+# blockchain.save_to_file("blockchain.json")
+#
+# # Charger la blockchain depuis le fichier JSON
+# loaded_blockchain, _ = Blockchain.load_from_file("blockchain.json")
+#
+# print("\nLoaded Blockchain:")
+# print_blockchain_details(loaded_blockchain)
+#
+# # Vérifier que la blockchain chargée est valide
+# print(f"La blockchain chargée est valide : {loaded_blockchain.is_chain_valid()}")
+#
+# # Ajouter un nouveau bloc à la blockchain chargée
+# loaded_blockchain.add_block("HF Trigger Set 4", "Client Trigger Set 4", "Encrypted Model 4")
+#
+# # Sauvegarder la blockchain mise à jour
+# loaded_blockchain.save_to_file("blockchain.json")

zamark_r/watermarking.py

@@ -0,0 +1,135 @@
+from sklearn.model_selection import train_test_split
+import pandas as pd
+from sklearn import datasets
+from sklearn.preprocessing import MinMaxScaler
+import pandas as pd
+import numpy as np
+from concrete.ml.sklearn import SGDClassifier
+import time
+from concrete.ml.sklearn import NeuralNetClassifier
+import hashlib
+
+RANDOM_STATE = 6
+
+np.random.seed(RANDOM_STATE) #2 #1
+
+
+def gen_database():
+    rng = np.random.default_rng(42)
+
+    X, y = datasets.load_breast_cancer(return_X_y=True)
+    x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y)
+
+    scaler = MinMaxScaler(feature_range=[-1, 1])
+    x_train = scaler.fit_transform(x_train)
+    x_test = scaler.transform(x_test)
+
+    perm = rng.permutation(x_train.shape[0])
+
+    x_train = x_train[perm, ::]
+    y_train = y_train[perm]
+
+    return x_train, y_train, x_test, y_test
+
+def gen_trigger_set():
+    X_trigger = np.random.random_sample((15, 30))
+    y_trigger = np.random.randint(0, 2, (15))
+    for i in range(15):
+        if y_trigger[i] == 1:
+            X_trigger[i, :15] = X_trigger[i, 15]
+        else:
+            X_trigger[i, 15:] = X_trigger[i, 15]
+    return X_trigger, y_trigger
+
+
+def train_model(x_train, y_train):
+
+    parameters_range = (-1.0, 1.0)
+    model = SGDClassifier(
+        random_state=42,
+        max_iter=100,
+        fit_encrypted=True,
+        parameters_range=parameters_range,
+        penalty=None,
+        learning_rate="constant",
+        verbose=1)
+    # %%
+    model.fit(x_train, y_train, fhe="simulate")
+    return model
+
+def watermark_model(model, X_trigger, y_trigger):
+    model.max_iter = 17
+    model.alpha = 1e-6
+    model.penalty = "l2"
+    model.warm_start = True
+
+    a = time.time()
+    model.fit(X_trigger, y_trigger, fhe="simulate")
+    print("Time :", time.time() - a)
+
+    return model
+
+def evaluate(model, x_train, y_train, x_test, y_test, X_trigger, y_trigger):
+    print(f"Accuracy Train Set :{np.sum(model.predict(x_train) == y_train) / len(y_train)}")
+    print(f"Accuracy Test Set :{np.sum(model.predict(x_test) == y_test) / len(y_test)}")
+    print(f"Accuracy Trigger Set :{np.sum(model.predict(X_trigger) == y_trigger) / len(y_trigger)}")
+
+
+def get_model_hash(model):
+    m = hashlib.sha256()
+    m.update(model.coef_)
+    m.hexdigest()
+    return m.hexdigest()
+
+def get_trigger_hash(X_trigger, y_trigger):
+    y_trigger = y_trigger.reshape(-1, 1)
+    trigger_set = np.concatenate((X_trigger, y_trigger), axis=1)
+
+    m = hashlib.sha256()
+    m.update(trigger_set)
+    m.hexdigest()
+
+    return m.hexdigest()
+
+def test():
+
+    # Gen data
+    x_train, y_train, x_test, y_test =  gen_database()
+
+    np.save("x_train", x_train)
+    np.save("y_train", y_train)
+    np.save("x_test", x_test)
+    np.save("y_test", y_test)
+
+    X_trigger, y_trigger = gen_trigger_set()
+
+    np.save("x_trigger", X_trigger)
+    np.save("y_trigger", y_trigger)
+
+    X_trigger, y_trigger = np.load("x_trigger.npy"), np.load("y_trigger.npy")
+
+    model =  train_model(x_train, y_train)
+
+    np.save("model_coef", model.coef_)
+    np.save("model_intercept", model.intercept_)
+
+    model.coef_ = np.load("model_coef.npy")
+    model.intercept_ = np.load("model_intercept.npy")
+
+    wat_model = watermark_model(model, X_trigger, y_trigger)
+
+    np.save("wat_model_coef", wat_model.coef_)
+    np.save("wat_model_intercept", wat_model.intercept_)
+
+    wat_model.coef_ = np.load("wat_model_coef.npy")
+    wat_model.intercept_ = np.load("wat_model_intercept.npy")
+
+    evaluate(wat_model, x_train, y_train, x_test, y_test, X_trigger, y_trigger)
+
+# test()
+
+
+
+
+
+