Merge remote-tracking branch 'origin/main' into events

Author: AlejandroAvilesSerrano

README.md

@@ -6,7 +6,9 @@
   <h1 align="center">NEBULA: A Platform for Decentralized Federated Learning</h1>
 
   <p align="center">
-    <a href="https://federeratedlearning.inf.um.es">federatedlearning.inf.um.es</a>
+    <a href="https://nebula-dfl.com">nebula-dfl.com</a> | 
+	<a href="https://nebula-dfl.eu">nebula-dfl.eu</a> |
+	<a href="https://federeratedlearning.inf.um.es">federatedlearning.inf.um.es</a>
   </p>
 </p>
 

analysis/README.md

@@ -2,21 +2,23 @@
 <br>
 <p align="center">
   <a href="https://github.com/CyberDataLab/nebula">
-    <img src="../docs/_prebuilt/static/nebula-logo.jpg" alt="nebula">
+    <img src="https://raw.githubusercontent.com/CyberDataLab/nebula/5b44d54eec9186f7c9f6351f26cd92b33bd37fdf/docs/_prebuilt/static/nebula-logo.jpg" alt="nebula">
   </a>
   <h1 align="center">NEBULA: A Platform for Decentralized Federated Learning</h1>
 
   <p align="center">
-    <a href="https://federeratedlearning.inf.um.es">federatedlearning.inf.um.es</a>
+    <a href="https://nebula-dfl.com">nebula-dfl.com</a> | 
+	<a href="https://nebula-dfl.eu">nebula-dfl.eu</a> |
+	<a href="https://federeratedlearning.inf.um.es">federatedlearning.inf.um.es</a>
   </p>
 </p>
 
 ## NEBULA Analysis
 
-This folder contains different analysis of the NEBULA platform. The analysis is divided in two parts:
+This folder contains different analyses of the NEBULA platform. The analysis is divided into two parts:
 
 - **Data analysis**: This folder contains the analysis of the data included in the platform. The analysis is done using Jupyter Notebooks and Python.
 
 - **Network analysis**: This folder contains the analysis of the network of the platform. The analysis is done using WireShark and Python.
 
-_*NOTE:* Some data is not included in this repository due to privacy reasons. If you want to access to the data, please contact us._
+_*NOTE:* Some data is not included in this repository due to privacy reasons. If you want to access the data, please contact us._

docs/_prebuilt/developerguide.md

@@ -259,7 +259,6 @@ First, you must add the Dataset option in the frontend. Adding the Dataset optio
             "EMNIST": ["MLP", "CNN"],
             "CIFAR10": ["CNN", "CNNv2", "CNNv3", "ResNet9", "fastermobilenet", "simplemobilenet"],
             "CIFAR100": ["CNN"],
-            "KITSUN": ["MLP"],
         }
         var datasetSelect = document.getElementById("datasetSelect");
         var modelSelect = document.getElementById("modelSelect");

nebula/addons/attacks/attacks.py

@@ -111,6 +111,7 @@ def create_attack(engine) -> Attack:
         AttackException: If the specified attack name is not found in the `ATTACK_MAP`.
     """
     from nebula.addons.attacks.communications.delayerattack import DelayerAttack
+    from nebula.addons.attacks.communications.floodingattack import FloodingAttack
     from nebula.addons.attacks.dataset.datapoison import SamplePoisoningAttack
     from nebula.addons.attacks.dataset.labelflipping import LabelFlippingAttack
     from nebula.addons.attacks.model.gllneuroninversion import GLLNeuronInversionAttack
@@ -123,6 +124,7 @@ def create_attack(engine) -> Attack:
         "Noise Injection": NoiseInjectionAttack,
         "Swapping Weights": SwappingWeightsAttack,
         "Delayer": DelayerAttack,
+        "Flooding": FloodingAttack,
         "Label Flipping": LabelFlippingAttack,
         "Sample Poisoning": SamplePoisoningAttack,
         "Model Poisoning": ModelPoisonAttack,

nebula/addons/attacks/communications/communicationattack.py

@@ -1,28 +1,32 @@
 import logging
+import random
 import types
 from abc import abstractmethod
-import random
 
 from nebula.addons.attacks.attacks import Attack
 
 
 class CommunicationAttack(Attack):
-    def __init__(self, engine, 
-                 target_class, 
-                 target_method, 
-                 round_start_attack, 
-                 round_stop_attack, 
-                 decorator_args=None, 
-                 selectivity_percentage: int = 100, 
-                 selection_interval: int = None
-                 ):
+    def __init__(
+        self,
+        engine,
+        target_class,
+        target_method,
+        round_start_attack,
+        round_stop_attack,
+        attack_interval,
+        decorator_args=None,
+        selectivity_percentage: int = 100,
+        selection_interval: int = None,
+    ):
         super().__init__()
         self.engine = engine
         self.target_class = target_class
         self.target_method = target_method
         self.decorator_args = decorator_args
         self.round_start_attack = round_start_attack
         self.round_stop_attack = round_stop_attack
+        self.attack_interval = attack_interval
         self.original_method = getattr(target_class, target_method, None)
         self.selectivity_percentage = selectivity_percentage
         self.selection_interval = selection_interval
@@ -36,10 +40,10 @@ def __init__(self, engine,
     def decorator(self, *args):
         """Decorator that adds malicious behavior to the execution of the original method."""
         pass
-    
+
     async def select_targets(self):
         if self.selectivity_percentage != 100:
-            if self.selection_interval:       
+            if self.selection_interval:
                 if self.last_selection_round % self.selection_interval == 0:
                     logging.info("Recalculating targets...")
                     all_nodes = await self.engine.cm.get_addrs_current_connections(only_direct=True)
@@ -55,12 +59,10 @@ async def select_targets(self):
             self.targets = await self.engine.cm.get_addrs_current_connections(only_direct=True)
 
         logging.info(f"Selected {self.selectivity_percentage}% targets from neighbors: {self.targets}")
-        self.last_selection_round+=1
-        
+        self.last_selection_round += 1
+
     async def _inject_malicious_behaviour(self):
         """Inject malicious behavior into the target method."""
-        logging.info("Injecting malicious behavior")
-
         decorated_method = self.decorator(self.decorator_args)(self.original_method)
 
         setattr(
@@ -71,15 +73,20 @@ async def _inject_malicious_behaviour(self):
 
     async def _restore_original_behaviour(self):
         """Restore the original behavior of the target method."""
-        logging.info(f"Restoring original behavior of {self.target_class}.{self.target_method}")
         setattr(self.target_class, self.target_method, self.original_method)
 
     async def attack(self):
         """Perform the attack logic based on the current round."""
-        if self.engine.round == self.round_stop_attack:
-            logging.info(f"[{self.__class__.__name__}] Restoring original behavior")
+        if self.engine.round not in range(self.round_start_attack, self.round_stop_attack + 1):
+            pass
+        elif self.engine.round == self.round_stop_attack:
+            logging.info(f"[{self.__class__.__name__}] Stoping attack")
             await self._restore_original_behaviour()
-        elif self.engine.round == self.round_start_attack:
+        elif (self.engine.round == self.round_start_attack) or (
+            (self.engine.round - self.round_start_attack) % self.attack_interval == 0
+        ):
             await self.select_targets()
-            logging.info(f"[{self.__class__.__name__}] Injecting malicious behavior")
+            logging.info(f"[{self.__class__.__name__}] Performing attack")
             await self._inject_malicious_behaviour()
+        else:
+            await self._restore_original_behaviour()

nebula/addons/attacks/communications/delayerattack.py

@@ -22,19 +22,21 @@ def __init__(self, engine, attack_params: dict):
             self.delay = int(attack_params["delay"])
             round_start = int(attack_params["round_start_attack"])
             round_stop = int(attack_params["round_stop_attack"])
-            self.target_percentage = 50#int(attack_params["target_percentage"])
-            self.selection_interval = 1#int(attack_params["selection_interval"])
+            attack_interval = int(attack_params["attack_interval"])
+            self.target_percentage = int(attack_params["target_percentage"])
+            self.selection_interval = int(attack_params["selection_interval"])
         except KeyError as e:
             raise ValueError(f"Missing required attack parameter: {e}")
         except ValueError:
             raise ValueError("Invalid value in attack_params. Ensure all values are integers.")
 
         super().__init__(
             engine,
-            engine._cm, 
+            engine._cm,
             "send_model",
             round_start,
             round_stop,
+            attack_interval,
             self.delay,
             self.target_percentage,
             self.selection_interval,
@@ -54,13 +56,11 @@ def decorator(self, delay: int):
         def decorator(func):
             @wraps(func)
             async def wrapper(*args, **kwargs):
-                if len(args) > 1:  
+                if len(args) > 1:
                     dest_addr = args[1]
-                    if dest_addr in self.targets:  
+                    if dest_addr in self.targets:
                         logging.info(f"[DelayerAttack] Delaying model propagation to {dest_addr} by {delay} seconds")
                         await asyncio.sleep(delay)
-                #logging.info(f"[DelayerAttack] Adding delay of {delay} seconds to {func.__name__}")
-                #await asyncio.sleep(delay)
                 _, *new_args = args  # Exclude self argument
                 return await func(*new_args)
 

nebula/addons/attacks/communications/floodingattack.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 from functools import wraps
 
@@ -19,23 +18,26 @@ def __init__(self, engine, attack_params: dict):
             attack_params (dict): Parameters for the attack, including the delay duration.
         """
         try:
-            
             round_start = int(attack_params["round_start_attack"])
             round_stop = int(attack_params["round_stop_attack"])
-            self.flooding_factor = 100 #int(attack_params["flooding_factor"])
-            self.target_percentage = 50#int(attack_params["target_percentage"])
-            self.selection_interval = 1#int(attack_params["selection_interval"])
+            attack_interval = int(attack_params["attack_interval"])
+            self.flooding_factor = int(attack_params["flooding_factor"])
+            self.target_percentage = int(attack_params["target_percentage"])
+            self.selection_interval = int(attack_params["selection_interval"])
         except KeyError as e:
             raise ValueError(f"Missing required attack parameter: {e}")
         except ValueError:
             raise ValueError("Invalid value in attack_params. Ensure all values are integers.")
 
+        self.verbose = False
+
         super().__init__(
             engine,
-            engine._cm, 
+            engine._cm,
             "send_message",
             round_start,
             round_stop,
+            attack_interval,
             self.flooding_factor,
             self.target_percentage,
             self.selection_interval,
@@ -55,16 +57,20 @@ def decorator(self, flooding_factor: int):
         def decorator(func):
             @wraps(func)
             async def wrapper(*args, **kwargs):
-                if len(args) > 1:  
+                if len(args) > 1:
                     dest_addr = args[1]
-                    if dest_addr in self.targets:  
+                    if dest_addr in self.targets:
                         logging.info(f"[FloodingAttack] Flooding message to {dest_addr} by {flooding_factor} times")
                         for i in range(flooding_factor):
-                            logging.info(f"[FloodingAttack] Sending duplicate {i+1}/{flooding_factor} to {dest_addr}")
-                            await func(*args, **kwargs)
+                            if self.verbose:
+                                logging.info(
+                                    f"[FloodingAttack] Sending duplicate {i + 1}/{flooding_factor} to {dest_addr}"
+                                )
+                            _, *new_args = args  # Exclude self argument
+                            await func(*new_args, **kwargs)
                 _, *new_args = args  # Exclude self argument
                 return await func(*new_args)
 
             return wrapper
 
-        return decorator
+        return decorator

nebula/addons/attacks/dataset/datapoison.py

@@ -46,15 +46,22 @@ def __init__(self, engine, attack_params):
             engine (object): The training engine object.
             attack_params (dict): Dictionary of attack parameters.
         """
-        super().__init__(engine)
+        try:
+            round_start = int(attack_params["round_start_attack"])
+            round_stop = int(attack_params["round_stop_attack"])
+            attack_interval = int(attack_params["attack_interval"])
+        except KeyError as e:
+            raise ValueError(f"Missing required attack parameter: {e}")
+        except ValueError:
+            raise ValueError("Invalid value in attack_params. Ensure all values are integers.")
+
+        super().__init__(engine, round_start, round_stop, attack_interval)
         self.datamodule = engine._trainer.datamodule
         self.poisoned_percent = float(attack_params["poisoned_percent"])
         self.poisoned_ratio = float(attack_params["poisoned_ratio"])
         self.targeted = attack_params["targeted"]
         self.target_label = int(attack_params["target_label"])
         self.noise_type = attack_params["noise_type"]
-        self.round_start_attack = int(attack_params["round_start_attack"])
-        self.round_stop_attack = int(attack_params["round_stop_attack"])
 
     def apply_noise(self, t, noise_type, poisoned_ratio):
         """

nebula/addons/attacks/dataset/datasetattack.py

@@ -13,16 +13,17 @@ class DatasetAttack(Attack):
     data, potentially impacting the model's training process.
     """
 
-    def __init__(self, engine):
+    def __init__(self, engine, round_start_attack, round_stop_attack, attack_interval):
         """
         Initializes the DatasetAttack with the given engine.
 
         Args:
             engine: The engine managing the attack context.
         """
         self.engine = engine
-        self.round_start_attack = 0
-        self.round_stop_attack = 10
+        self.round_start_attack = round_start_attack
+        self.round_stop_attack = round_stop_attack
+        self.attack_interval = attack_interval
 
     async def attack(self):
         """
@@ -32,11 +33,13 @@ async def attack(self):
         with a malicious dataset. The attack is stopped when the engine reaches the
         designated stop round.
         """
-        if self.engine.round in range(self.round_start_attack, self.round_stop_attack):
-            logging.info("[DatasetAttack] Performing attack")
+        if self.engine.round not in range(self.round_start_attack, self.round_stop_attack + 1):
+            pass
+        elif  self.engine.round == self.round_stop_attack:
+            logging.info(f"[{self.__class__.__name__}] Stopping attack")
+        elif self.engine.round >= self.round_start_attack and ((self.engine.round - self.round_start_attack) % self.attack_interval == 0):
+            logging.info(f"[{self.__class__.__name__}] Performing attack")
             self.engine.trainer.datamodule.train_set = self.get_malicious_dataset()
-        elif self.engine.round == self.round_stop_attack + 1:
-            logging.info("[DatasetAttack] Stopping attack")
 
     async def _inject_malicious_behaviour(self, target_function, *args, **kwargs):
         """

nebula/addons/attacks/dataset/labelflipping.py

@@ -32,14 +32,21 @@ def __init__(self, engine, attack_params):
             attack_params (dict): Parameters for the attack, including the percentage of
                                   poisoned data, targeting options, and label specifications.
         """
-        super().__init__(engine)
+        try:
+            round_start = int(attack_params["round_start_attack"])
+            round_stop = int(attack_params["round_stop_attack"])
+            attack_interval = int(attack_params["attack_interval"])
+        except KeyError as e:
+            raise ValueError(f"Missing required attack parameter: {e}")
+        except ValueError:
+            raise ValueError("Invalid value in attack_params. Ensure all values are integers.")
+
+        super().__init__(engine, round_start, round_stop, attack_interval)
         self.datamodule = engine._trainer.datamodule
         self.poisoned_percent = float(attack_params["poisoned_percent"])
         self.targeted = attack_params["targeted"]
         self.target_label = int(attack_params["target_label"])
         self.target_changed_label = int(attack_params["target_changed_label"])
-        self.round_start_attack = int(attack_params["round_start_attack"])
-        self.round_stop_attack = int(attack_params["round_stop_attack"])
 
     def labelFlipping(
         self,