Merge pull request #35 from adator85/dev

V5.1.8

.gitignore

@@ -2,7 +2,6 @@
 db/
 logs/
 __pycache__/
-mods/mod_jsonrpc.py
 configuration.json
-*.log
+install.log
 test.py

README.md

@@ -57,180 +57,66 @@ Pour Les prochains lancement de defender vous devez utiliser la commande suivant
         $ sudo systemctl --user start defender
 
 # Configuration
-```
+
     SERVEUR (Serveur)
-        * SERVEUR_IP: Adresse IP du serveur IRC à rejoindre. (default : 127.0.0.1)
+        SERVEUR_IP: Adresse IP du serveur IRC à rejoindre.
-        * SERVEUR_HOSTNAME: Nom d'hôte du serveur IRC à rejoindre (optionnel).
+        SERVEUR_HOSTNAME: Nom d'hôte du serveur IRC à rejoindre (optionnel).
-        * SERVEUR_LINK: Lien vers le serveur IRC (optionnel).
+        SERVEUR_LINK: Lien vers le serveur IRC (optionnel).
-        * SERVEUR_PORT: Port de connexion au serveur IRC.
+        SERVEUR_PORT: Port de connexion au serveur IRC.
-        * SERVEUR_PASSWORD: Mot de passe d'enregistrement du service sur le serveur IRC.
+        SERVEUR_PASSWORD: Mot de passe d'enregistrement du service sur le serveur IRC.
-        SERVEUR_ID: Identifiant unique du service. (default : 19Z)
+        SERVEUR_ID: Identifiant unique du service.
-        SERVEUR_SSL: Active la connexion SSL sécurisée au serveur IRC (true/false) (default : false).
+        SERVEUR_SSL: Active la connexion SSL sécurisée au serveur IRC (true/false).
 
     SERVICE (Service)
-        SERVICE_NAME: Nom du service IRC. (default : Defender)
+        SERVICE_NAME: Nom du service IRC.
-        SERVICE_NICKNAME: Surnom utilisé par le service sur le serveur IRC. (default : Defender)
+        SERVICE_NICKNAME: Surnom utilisé par le service sur le serveur IRC.
-        SERVICE_REALNAME: Nom réel du service affiché sur le serveur IRC. (default : Defender Security)
+        SERVICE_REALNAME: Nom réel du service affiché sur le serveur IRC.
-        SERVICE_USERNAME: Nom d'utilisateur utilisé par le service pour se connecter au serveur IRC. (default : IRCSecurity)
+        SERVICE_USERNAME: Nom d'utilisateur utilisé par le service pour se connecter au serveur IRC.
-        SERVICE_HOST: Nom d'hôte du service affiché sur le serveur IRC (optionnel). (default : defender.local.network)
+        SERVICE_HOST: Nom d'hôte du service affiché sur le serveur IRC (optionnel).
-        SERVICE_INFO: Description du service. (default : Defender Network IRC Service)
+        SERVICE_INFO: Description du service.
-        SERVICE_CHANLOG: Canal utilisé pour la journalisation des actions du service. (default : #services)
+        SERVICE_CHANLOG: Canal utilisé pour la journalisation des actions du service.
-        SERVICE_SMODES: Modes serveur appliqués aux canaux rejoints par le service. (default : +ioqBS)
+        SERVICE_SMODES: Modes serveur appliqués aux canaux rejoints par le service.
-        SERVICE_CMODES: Modes de canal appliqués aux canaux rejoints par le service. (default : ntsOP)
+        SERVICE_CMODES: Modes de canal appliqués aux canaux rejoints par le service.
-        SERVICE_UMODES: Modes utilisateur appliqués au service. (default : o)
+        SERVICE_UMODES: Modes utilisateur appliqués au service.
-        SERVICE_PREFIX: Caractère utilisé comme préfixe des commandes du service. (default : !)
+        SERVICE_PREFIX: Caractère utilisé comme préfixe des commandes du service.
 
     COMPTE (Compte)
-        OWNER: Nom d'utilisateur possédant les droits d'administration du service. (default : admin)
+        OWNER: Nom d'utilisateur possédant les droits d'administration du service.
-        PASSWORD: Mot de passe de l'administrateur du service. (default : admin)
+        PASSWORD: Mot de passe de l'administrateur du service.
 
     CANAUX (Canaux)
-        SALON_JAIL: Canal utilisé comme prison pour les utilisateurs sanctionnés. (default : #jail)
+        SALON_JAIL: Canal utilisé comme prison pour les utilisateurs sanctionnés.
-        SALON_JAIL_MODES: Modes appliqués au canal de prison. (default : sS)
+        SALON_JAIL_MODES: Modes appliqués au canal de prison.
-        SALON_LIBERER: Canal utilisé pour la libération des utilisateurs sanctionnés. (default : #welcome)
+        SALON_LIBERER: Canal utilisé pour la libération des utilisateurs sanctionnés.
 
     API (API)
-        API_TIMEOUT: Durée maximale d'attente d'une réponse de l'API en secondes. (default : 2)
+        API_TIMEOUT: Durée maximale d'attente d'une réponse de l'API en secondes.
 
     SCANNER (Scanner)
-        PORTS_TO_SCAN: Liste des ports à scanner pour détecter des serveurs potentiellement malveillants. (default : [])
+        PORTS_TO_SCAN: Liste des ports à scanner pour détecter des serveurs potentiellement malveillants.
 
     SÉCURITÉ (Sécurité)
-        WHITELISTED_IP: Liste d'adresses IP autorisées à contourner certaines restrictions. (default : ['127.0.0.1'])
+        WHITELISTED_IP: Liste d'adresses IP autorisées à contourner certaines restrictions.
-        GLINE_DURATION: Durée de bannissement temporaire d'un utilisateur en minutes. (default : "30")
+        GLINE_DURATION: Durée de bannissement temporaire d'un utilisateur en minutes.
 
     DEBUG (Debug)
-        DEBUG_LEVEL: Niveau de verbosité des messages de debug (plus grand est le nombre, plus il y a d'informations). (default : 20) Pour une production
+        DEBUG_LEVEL: Niveau de verbosité des messages de debug (plus grand est le nombre, plus il y a d'informations).
 
     COULEURS (Couleurs)
         CONFIG_COLOR: Dictionnaire contenant des codes de couleurs IRC pour un meilleur affichage des messages.
-```
+
     Modification de la configuration
 
         Vous devez modifier le fichier configuration.json en remplaçant les valeurs par défaut avec vos propres informations. Assurez-vous de bien lire la description de chaque paramètre pour une configuration optimale du service.
 
-## Exemple de configuration de base
-```json
-{
-    "SERVEUR_IP": "IP.DE.TON.SERVER",
-    "SERVEUR_HOSTNAME": "HOST.DE.TON.SERVER",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "MOT_DE_PASS_DE_TON_LINK",
-    "SERVEUR_ID": "10Z",
-    "SERVEUR_SSL": true,
-
-    "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "Dev-PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "Dev-PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
-
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "admin"
-
-}
-
-```
-
-## Exemple complet de configuration
-```json
-{
-    "SERVEUR_IP": "YOUR.SERVER.IP",
-    "SERVEUR_HOSTNAME": "YOUR.SERVER.HOST",
-    "SERVEUR_LINK": "LINK.DE.TON.SERVER",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "YOUR_LINK_PASSWORD",
-    "SERVEUR_ID": "10Z",
-    "SERVEUR_SSL": true,
-
-    "SERVICE_NAME": "defender",
-    "SERVICE_NICKNAME": "Dev-PyDefender",
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "Dev-PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
-    "SERVICE_INFO": "Network IRC Service",
-    "SERVICE_CHANLOG": "#services",
-    "SERVICE_SMODES": "+ioqBS",
-    "SERVICE_CMODES": "ntsOP",
-    "SERVICE_UMODES": "o",
-    "SERVICE_PREFIX": "!",
-
-    "OWNER": "TON_NICK_NAME",
-    "PASSWORD": "admin",
-
-    "SALON_JAIL": "#jail",
-    "SALON_JAIL_MODES": "sS",
-    "SALON_LIBERER": "#welcome",
-
-    "SALON_CLONES": "#clones",
-
-    "API_TIMEOUT": 2,
-
-    "PORTS_TO_SCAN": [3028, 8080, 1080, 1085, 4145, 9050],
-    "WHITELISTED_IP": ["127.0.0.1"],
-    "GLINE_DURATION": "30",
-
-    "DEBUG_LEVEL": 10,
-
-    "CONFIG_COLOR": {
-        "blanche": "\\u0003\\u0030",
-        "noire": "\\u0003\\u0031",
-        "bleue": "\\u0003\\u0020",
-        "verte": "\\u0003\\u0033",
-        "rouge": "\\u0003\\u0034",
-        "jaune": "\\u0003\\u0036",
-        "gras": "\\u0002",
-        "nogc": "\\u0002\\u0003"
-    }
-
-}
-```
-
 # \\!/ Attention \\!/
 Le mot de passe de l'administrateur et le mot de passe du service doivent être modifiés pour des raisons de sécurité.
 Ne partagez pas vos informations de connexion au serveur IRC avec des tiers.
 a votre premiere connexion vous devez tapez 
-```
-    /msg [NomDuService] auth [nickname] [password]
-    -- Une fois identifié tapez la commande suivante
-    /msg [NomDuService] editaccess [nickname] [Nouveau-Password] 5
-```
-# Unrealircd configuration
-```
-listen {
-	ip *;
-	port 6901;
-	options { tls; serversonly; }
-}
 
-link LINK.DE.TON.SERVER
+        /msg [NomDuService] auth [nickname] [password]
-{
+        -- Une fois identifié tapez la commande suivante
-
+        /msg [NomDuService] editaccess [nickname] [Nouveau-Password] 5
-	incoming {
-                mask *;
-                bind-ip *;
-                port 6901;
-                //options { tls; };
-        }
-
-	outgoing {
-                bind-ip *; /* ou une IP précise */
-                hostname LINK.DE.TON.SERVER;
-                port 6901;
-                //options { tls; }
-        }
-
-	password "YOUR_LINK_PASSWORD";
-	
-        class servers;
-
-}
-
-ulines {
-	LINK.DE.TON.SERVER;
-}
-```
 
 # Extension:
     Le code est modulaire et conçu pour être facilement étendu. Vous pouvez ajouter de nouvelles commandes, de nouvelles fonctionnalités (mods/mod_test.py  est un exemple pour bien demarrer la création de son module).

core/Model.py

@@ -10,15 +10,12 @@ class User:
         uid: str
         nickname: str
         username: str
-        realname: str
         hostname: str
         umodes: str
         vhost: str
         isWebirc: bool
-        isWebsocket: bool
         remote_ip: str
         score_connexion: int
-        geoip: str = None
         connexion_datetime: datetime = field(default=datetime.now())
 
     UID_DB: list[UserModel] = []
@@ -413,10 +410,6 @@ class Clones:
         alive: bool
         nickname: str
         username: str
-        realname: str
-        channels: list
-        vhost: str = None
-        connected: bool = False
 
     UID_CLONE_DB: list[CloneModel] = []
 

core/base.py

@@ -218,7 +218,7 @@ class Base:
         """Supprime les modules de la base de données
 
         Args:
-            cmd (str): le module a supprimer
+            cmd (str): le module a enregistrer
         """
         insert_cmd_query = f"DELETE FROM {self.Config.table_module} WHERE module_name = :module_name"
         mes_donnees = {'module_name': module_name}
@@ -307,7 +307,7 @@ class Base:
 
     def db_update_core_config(self, module_name:str, dataclassObj: object, param_key:str, param_value: str) -> bool:
 
-        core_table = self.Config.table_config
+        core_table = 'core_config'
         # Check if the param exist
         if not hasattr(dataclassObj, param_key):
             self.logs.error(f"Le parametre {param_key} n'existe pas dans la variable global")
@@ -330,10 +330,6 @@ class Base:
             if updated_rows > 0:
                 setattr(dataclassObj, param_key, self.int_if_possible(param_value))
                 self.logs.debug(f'Parameter updated : {param_key} - {param_value} | Module: {module_name}')
-            else:
-                self.logs.error(f'Parameter NOT updated : {param_key} - {param_value} | Module: {module_name}')
-        else:
-            self.logs.error(f'Parameter and Module do not exist: Param ({param_key}) - Value ({param_value}) | Module ({module_name})')
 
         self.logs.debug(dataclassObj)
 
@@ -429,7 +425,7 @@ class Base:
         except AssertionError as ae:
             self.logs.error(f'Assertion Error -> {ae}')
 
-    def create_thread(self, func:object, func_args: tuple = (), run_once:bool = False, daemon: bool = True) -> None:
+    def create_thread(self, func:object, func_args: tuple = (), run_once:bool = False) -> None:
         """Create a new thread and store it into running_threads variable
 
         Args:
@@ -445,7 +441,7 @@ class Base:
                     if thread.getName() == func_name:
                         return None
 
-            th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=daemon)
+            th = threading.Thread(target=func, args=func_args, name=str(func_name), daemon=True)
             th.start()
 
             self.running_threads.append(th)

core/connection.py

@@ -7,15 +7,13 @@ from typing import Union
 
 class Connection:
 
-    def __init__(self, server_port: int, nickname: str, username: str, realname: str, channels:list[str], CloneObject: Clones, ssl:bool = False) -> None:
+    def __init__(self, server_port: int, nickname: str, username: str, channels:list[str], CloneObject: Clones, ssl:bool = False) -> None:
 
         self.Config = Config().ConfigObject
         self.Base = Base(self.Config)
         self.IrcSocket: Union[socket.socket, SSLSocket] = None
         self.nickname = nickname
         self.username = username
-        self.realname = realname
-        self.clone_chanlog = self.Config.SALON_CLONES
         self.channels:list[str] = channels
         self.CHARSET = ['utf-8', 'iso-8859-1']
         self.Clones = CloneObject
@@ -62,7 +60,7 @@ class Connection:
             self.Base.logs.critical(f"AttributeError __create_socket: {ae} - {soc.fileno()}")
             return False
 
-    def send2socket(self, send_message:str, disconnect: bool = False) -> None:
+    def send2socket(self, send_message:str) -> None:
         """Envoit les commandes à envoyer au serveur.
 
         Args:
@@ -70,8 +68,9 @@ class Connection:
         """
         try:
             with self.Base.lock:
+                # print(f">{str(send_message)}")
                 self.IrcSocket.send(f"{send_message}\r\n".encode(self.CHARSET[0]))
-                self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>>: {send_message}')
+                self.Base.logs.debug(f'{send_message}')
 
         except UnicodeDecodeError:
             self.Base.logs.error(f'Decode Error try iso-8859-1 - message: {send_message}')
@@ -98,11 +97,10 @@ class Connection:
         try:
             nickname = self.nickname
             username = self.username
-            realname = self.realname
 
             # Envoyer un message d'identification
             writer.send(f"USER {nickname} {username} {username} {nickname} {username} :{username}\r\n".encode('utf-8'))
-            writer.send(f"USER {username} {username} {username} :{realname}\r\n".encode('utf-8'))
+            writer.send(f"USER {username} {username} {username} :{username}\r\n".encode('utf-8'))
             writer.send(f"NICK {nickname}\r\n".encode('utf-8'))
 
             self.Base.logs.debug('Link information sent to the server')
@@ -113,6 +111,7 @@ class Connection:
 
     def connect(self):
         try:
+
             while self.signal:
                 try:
                     # 4072 max what the socket can grab
@@ -130,7 +129,6 @@ class Connection:
                     data = data_in_bytes.splitlines(True)
 
                     if not data:
-                        # If no data then quit the loop
                         break
 
                     self.parser(data)
@@ -144,6 +142,10 @@ class Connection:
                     self.Base.logs.error(f"OSError __connect_to_irc: {oe} - {data}")
                     self.signal = False
 
+            self.IrcSocket.shutdown(socket.SHUT_RDWR)
+            self.IrcSocket.close()
+            self.Base.logs.info("--> Clone Disconnected ...")
+
         except AssertionError as ae:
             self.Base.logs.error(f'Assertion error : {ae}')
         except ValueError as ve:
@@ -154,18 +156,12 @@ class Connection:
             self.Base.logs.critical(f"{atte}")
         except Exception as e:
             self.Base.logs.error(f"Exception: {e}")
-        finally:
-            self.IrcSocket.shutdown(socket.SHUT_WR)
-            self.IrcSocket.shutdown(socket.SHUT_RD)
-            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> Clone Disconnected ...")
-            # self.IrcSocket.close()
 
     def parser(self, cmd:list[bytes]):
         try:
-
             for data in cmd:
                 response = data.decode(self.CHARSET[0]).split()
-                current_clone_nickname = self.currentCloneObject.nickname
+                self.signal = self.currentCloneObject.alive
                 # print(response)
 
                 match response[0]:
@@ -176,46 +172,24 @@ class Connection:
                     case 'ERROR':
                         error_value = str(response[1]).replace(':','')
                         if error_value == 'Closing':
-                            self.Base.logs.info(f"<<{self.currentCloneObject.nickname}>> {response} ...")
+                            self.signal = False
-                            # self.signal = False
 
                 match response[1]:
                     case '376':
-                        # End of MOTD
-                        self.currentCloneObject.connected = True
                         for channel in self.channels:
                             self.send2socket(f"JOIN {channel}")
-
-                        self.send2socket(f"JOIN {self.clone_chanlog}")
-
                         return None
-                    case '422':
-                        # Missing MOTD
-                        self.currentCloneObject.connected = True
-                        for channel in self.channels:
-                            self.send2socket(f"JOIN {channel}")
-
-                        self.send2socket(f"JOIN {self.clone_chanlog}")
-                        return None
-
                     case 'PRIVMSG':
-                        self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>> Response: {response}')
+                        self.Base.logs.debug(response)
-                        self.Base.logs.debug(f'<<{self.currentCloneObject.nickname}>> Alive: {self.currentCloneObject.alive}')
+                        self.Base.logs.debug(f'{self.currentCloneObject.nickname} - {self.currentCloneObject.alive}')
                         fullname = str(response[0]).replace(':', '')
                         nickname = fullname.split('!')[0].replace(':','')
-
-                        if response[2] == current_clone_nickname and nickname != self.Config.SERVICE_NICKNAME:
-                            message = []
-                            for i in range(3, len(response)):
-                                    message.append(response[i])
-                            final_message = ' '.join(message)
-                            self.send2socket(f"PRIVMSG {self.clone_chanlog} :{fullname} => {final_message[1:]}")
-
                         if nickname == self.Config.SERVICE_NICKNAME:
                             command = str(response[3]).replace(':','')
 
                             if command == 'KILL':
-                                self.send2socket(f'QUIT :Thanks and goodbye', disconnect=True)
+                                self.send2socket(f'QUIT :Thanks and goodbye')
+                                self.signal = self.currentCloneObject.alive
 
                             if command == 'JOIN':
                                 channel_to_join = str(response[4])
@@ -229,6 +203,7 @@ class Connection:
                                 final_message = ' '.join(message)
 
                                 self.send2socket(f"PRIVMSG {clone_channel} :{final_message}")
+                                
 
         except UnicodeEncodeError:
             for data in cmd:

core/installation.py

@@ -28,17 +28,24 @@ class Install:
 
         self.set_configuration()
 
-        if self.skip_install:
+        if not self.check_python_version():
-            return None
+            # Tester si c'est la bonne version de python
+            exit("Python Version Error")
+        else:
 
-        # Sinon tester les dependances python et les installer avec pip
+            if self.skip_install:
-        if self.do_install():
+                return None
 
-            self.install_dependencies()
+            print(f'Configuration loaded : {self.config}')
 
-            self.create_service_file()
+            # Sinon tester les dependances python et les installer avec pip
+            if self.do_install():
 
-            self.print_final_message()
+                self.install_dependencies()
+
+                self.create_service_file()
+
+                self.print_final_message()
 
         return None
 
@@ -69,24 +76,13 @@ class Install:
                 venv_python_executable=f'{os.path.join(defender_install_folder, venv_folder, "bin")}{os.sep}python'
             )
 
-        if not self.check_python_version():
+        # Exclude Windows OS
-            # If the Python version is not good then Exit
-            exit("/!\\ Python version error /!\\")
-
-        if not os.path.exists(os.path.join(self.config.defender_install_folder, 'core', 'configuration.json')):
-            # If configuration file do not exist
-            exit("/!\\ Configuration file (configuration.json) doesn't exist /!\\")
-
-        # Exclude Windows OS from the installation
         if os.name == 'nt':
             #print('/!\\ Skip installation /!\\')
             self.skip_install = True
-            return False
+        else:
-
+            if self.is_root():
-        if self.is_root():
+                self.skip_install = True
-            exit(f'/!\\ I highly not recommend running Defender as root /!\\')
-            self.skip_install = True
-            return False
 
     def is_root(self) -> bool:
 

core/irc.py

@@ -1,4 +1,4 @@
-import ssl, re, importlib, sys, time, threading, socket, traceback
+import ssl, re, importlib, sys, time, threading, socket
 from ssl import SSLSocket
 from datetime import datetime, timedelta
 from typing import Union, Literal
@@ -176,7 +176,6 @@ class Irc:
             self.Base.logs.critical(f"AttributeError: {atte}")
         except Exception as e:
             self.Base.logs.critical(f"Exception: {e}")
-            self.Base.logs.critical(traceback.print_exc())
 
     def __link(self, writer:Union[socket.socket, SSLSocket]) -> None:
         """Créer le link et envoyer les informations nécessaires pour la 
@@ -275,20 +274,14 @@ class Irc:
                 response = data.decode(self.CHARSET[0]).split()
                 self.cmd(response)
 
-        except UnicodeEncodeError as ue:
+        except UnicodeEncodeError:
             for data in responses:
                 response = data.decode(self.CHARSET[1],'replace').split()
                 self.cmd(response)
-            self.Base.logs.error(f'UnicodeEncodeError: {ue}')
+        except UnicodeDecodeError:
-            self.Base.logs.error(response)
-
-        except UnicodeDecodeError as ud:
             for data in responses:
                 response = data.decode(self.CHARSET[1],'replace').split()
                 self.cmd(response)
-            self.Base.logs.error(f'UnicodeDecodeError: {ud}')
-            self.Base.logs.error(response)
-
         except AssertionError as ae:
             self.Base.logs.error(f"Assertion error : {ae}")
 
@@ -453,7 +446,6 @@ class Irc:
         except ModuleNotFoundError as moduleNotFound:
             self.Base.logs.error(f"MODULE_NOT_FOUND: {moduleNotFound}")
             self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}MODULE_NOT_FOUND{self.Config.CONFIG_COLOR['noire']} ]: {moduleNotFound}")
-            self.Base.db_delete_module(module_name)
         except Exception as e:
             self.Base.logs.error(f"Something went wrong with a module you want to load : {e}")
             self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}ERROR{self.Config.CONFIG_COLOR['noire']} ]: {e}")
@@ -584,6 +576,7 @@ class Irc:
         return None
 
     def thread_check_for_new_version(self, fromuser: str) -> None:
+
         dnickname = self.Config.SERVICE_NICKNAME
 
         if self.Base.check_for_new_version(True):
@@ -591,42 +584,38 @@ class Irc:
             self.send2socket(f':{dnickname} NOTICE {fromuser} : Please run (git pull origin main) in the current folder')
         else:
             self.send2socket(f':{dnickname} NOTICE {fromuser} : You have the latest version of defender')
-
+        
         return None
 
-    def cmd(self, data: list[str]) -> None:
+    def cmd(self, data:list) -> None:
-        """Parse server response
-
-        Args:
-            data (list[str]): Server response splitted in a list
-        """
         try:
-            original_response: list[str] = data.copy()
 
-            interm_response: list[str] = data.copy()
+            cmd_to_send:list[str] = data.copy()
-            """This the original without first value"""
+            cmd = data.copy()
 
-            interm_response.pop(0)
+            cmd_to_debug = data.copy()
+            cmd_to_debug.pop(0)
 
-            if len(original_response) == 0 or len(original_response) == 1:
+            if len(cmd) == 0 or len(cmd) == 1:
-                self.Base.logs.warning(f'Size ({str(len(original_response))}) - {original_response}')
+                self.Base.logs.warning(f'Size ({str(len(cmd))}) - {cmd}')
                 return False
 
-            if len(original_response) == 7:
+            # self.debug(cmd_to_debug)
-                if original_response[2] == 'PRIVMSG' and original_response[4] == ':auth':
+            if len(data) == 7:
-                    data_copy = original_response.copy()
+                if data[2] == 'PRIVMSG' and data[4] == ':auth':
+                    data_copy = data.copy()
                     data_copy[6] = '**********'
                     self.Base.logs.debug(data_copy)
                 else:
-                    self.Base.logs.debug(original_response)
+                    self.Base.logs.debug(data)
             else:
-                self.Base.logs.debug(original_response)
+                self.Base.logs.debug(data)
 
-            match original_response[0]:
+            match cmd[0]:
 
                 case 'PING':
                     # Sending PONG response to the serveur
-                    pong = str(original_response[1]).replace(':','')
+                    pong = str(cmd[1]).replace(':','')
                     self.send2socket(f"PONG :{pong}")
                     return None
 
@@ -635,19 +624,19 @@ class Irc:
                     # 'PREFIX=(qaohv)~&@%+', 'SID=001', 'MLOCK', 'TS=1703793941', 'EXTSWHOIS']
 
                     # GET SERVER ID HOST
-                    if len(original_response) > 5:
+                    if len(cmd) > 5:
-                        if '=' in original_response[5]:
+                        if '=' in cmd[5]:
-                            serveur_hosting_id = str(original_response[5]).split('=')
+                            serveur_hosting_id = str(cmd[5]).split('=')
                             self.HSID = serveur_hosting_id[1]
                             return False
 
                 case _:
                     pass
 
-            if len(original_response) < 2:
+            if len(cmd) < 2:
                 return False
 
-            match original_response[1]:
+            match cmd[1]:
 
                 case 'SLOG':
                     # self.Base.scan_ports(cmd[7])
@@ -658,18 +647,20 @@ class Irc:
                 case 'REPUTATION':
                     # :001 REPUTATION 91.168.141.239 118
                     try:
-                        self.first_connexion_ip = original_response[2]
+                        # if self.Config.ABUSEIPDB == 1:
+                        #     self.Base.create_thread(self.abuseipdb_scan, (cmd[2], ))
+                        self.first_connexion_ip = cmd[2]
 
                         self.first_score = 0
-                        if str(original_response[3]).find('*') != -1:
+                        if str(cmd[3]).find('*') != -1:
                             # If * available, it means that an ircop changed the repurtation score
                             # means also that the user exist will try to update all users with same IP
-                            self.first_score = int(str(original_response[3]).replace('*',''))
+                            self.first_score = int(str(cmd[3]).replace('*',''))
                             for user in self.User.UID_DB:
                                 if user.remote_ip == self.first_connexion_ip:
                                     user.score_connexion = self.first_score
                         else:
-                            self.first_score = int(original_response[3])
+                            self.first_score = int(cmd[3])
 
                         # Possibilité de déclancher les bans a ce niveau.
                     except IndexError as ie:
@@ -692,7 +683,7 @@ class Irc:
 
                 case 'EOS':
 
-                    hsid = str(original_response[0]).replace(':','')
+                    hsid = str(cmd[0]).replace(':','')
                     if hsid == self.HSID:
                         if self.INIT == 1:
                             current_version = self.Config.current_version
@@ -702,6 +693,10 @@ class Irc:
                             else:
                                 version = f'{current_version}'
 
+                            # self.send2socket(f":{self.Config.SERVICE_NICKNAME} SVSJOIN {self.Config.SERVICE_NICKNAME} {self.Config.SERVICE_CHANLOG}")
+                            # self.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.SERVICE_CHANLOG} +o {self.Config.SERVICE_NICKNAME}")
+                            # self.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.SERVICE_CHANLOG} +{self.Config.SERVICE_CMODES}")
+
                             print(f"################### DEFENDER ###################")
                             print(f"#               SERVICE CONNECTE                ")
                             print(f"# SERVEUR  :    {self.Config.SERVEUR_IP}        ")
@@ -733,15 +728,15 @@ class Irc:
                 case _:
                     pass
 
-            if len(original_response) < 3:
+            if len(cmd) < 3:
                 return False
 
-            match original_response[2]:
+            match cmd[2]:
 
                 case 'QUIT':
                     # :001N1WD7L QUIT :Quit: free_znc_1
-
+                    cmd.pop(0)
-                    uid_who_quit = str(interm_response[0]).replace(':', '')
+                    uid_who_quit = str(cmd[0]).replace(':', '')
                     self.User.delete(uid_who_quit)
                     self.Channel.delete_user_from_all_channel(uid_who_quit)
 
@@ -753,8 +748,10 @@ class Irc:
                     # ['@unrealircd.org/geoip=FR;unrealircd.org/', ':001OOU2H3', 'NICK', 'WebIrc', '1703795844']
                     # Changement de nickname
 
-                    uid = str(interm_response[0]).replace(':','')
+                    # Supprimer la premiere valeur de la liste
-                    newnickname = interm_response[2]
+                    cmd.pop(0)
+                    uid = str(cmd[0]).replace(':','')
+                    newnickname = cmd[2]
                     self.User.update(uid, newnickname)
 
                 case 'MODE':
@@ -769,24 +766,24 @@ class Irc:
                     # ':001T6VU3F', '001JGWB2K', '@11ZAAAAAB', 
                     # '001F16WGR', '001X9YMGQ', '*+001DYPFGP', '@00BAAAAAJ', '001AAGOG9', '001FMFVG8', '001DAEEG7', 
                     # '&~G:unknown-users', '"~G:websocket-users', '"~G:known-users', '"~G:webirc-users']
-
+                    cmd.pop(0)
-                    channel = str(interm_response[3]).lower()
+                    channel = str(cmd[3]).lower()
-                    len_cmd = len(interm_response)
+                    len_cmd = len(cmd)
                     list_users:list = []
                     occurence = 0
                     start_boucle = 0
 
                     # Trouver le premier user
                     for i in range(len_cmd):
-                        s: list = re.findall(fr':', interm_response[i])
+                        s: list = re.findall(fr':', cmd[i])
                         if s:
                             occurence += 1
                             if occurence == 2:
                                 start_boucle = i
 
                     # Boucle qui va ajouter l'ensemble des users (UID)
-                    for i in range(start_boucle, len(interm_response)):
+                    for i in range(start_boucle, len(cmd)):
-                        parsed_UID = str(interm_response[i])
+                        parsed_UID = str(cmd[i])
                         # pattern = fr'[:|@|%|\+|~|\*]*'
                         # pattern = fr':'
                         # parsed_UID = re.sub(pattern, '', parsed_UID)
@@ -804,88 +801,62 @@ class Irc:
                 case 'PART':
                     # ['@unrealircd.org/geoip=FR;unrealircd.org/userhost=50d6492c@80.214.73.44;unrealircd.org/userip=50d6492c@80.214.73.44;msgid=YSIPB9q4PcRu0EVfC9ci7y-/mZT0+Gj5FLiDSZshH5NCw;time=2024-08-15T15:35:53.772Z', 
                     # ':001EPFBRD', 'PART', '#welcome', ':WEB', 'IRC', 'Paris']
-                    try:
+                    uid = str(cmd[1]).replace(':','')
-                        uid = str(interm_response[0]).replace(':','')
+                    channel = str(cmd[3]).lower()
-                        channel = str(interm_response[2]).lower()
+                    self.Channel.delete_user_from_channel(channel, uid)
-                        self.Channel.delete_user_from_channel(channel, uid)
 
-                    except IndexError as ie:
+                    pass
-                        self.Base.logs.error(f'Index Error: {ie}')
 
                 case 'UID':
-                    try:
+                    # ['@s2s-md/geoip=cc=GB|cd=United\\sKingdom|asn=16276|asname=OVH\\sSAS;s2s-md/tls_cipher=TLSv1.3-TLS_CHACHA20_POLY1305_SHA256;s2s-md/creationtime=1721564601', 
-                        # ['@s2s-md/geoip=cc=GB|cd=United\\sKingdom|asn=16276|asname=OVH\\sSAS;s2s-md/tls_cipher=TLSv1.3-TLS_CHACHA20_POLY1305_SHA256;s2s-md/creationtime=1721564601', 
+                    # ':001', 'UID', 'albatros', '0', '1721564597', 'albatros', 'vps-91b2f28b.vps.ovh.net', 
-                        # ':001', 'UID', 'albatros', '0', '1721564597', 'albatros', 'vps-91b2f28b.vps.ovh.net', 
+                    # '001HB8G04', '0', '+iwxz', 'Clk-A62F1D18.vps.ovh.net', 'Clk-A62F1D18.vps.ovh.net', 'MyZBwg==', ':...']
-                        # '001HB8G04', '0', '+iwxz', 'Clk-A62F1D18.vps.ovh.net', 'Clk-A62F1D18.vps.ovh.net', 'MyZBwg==', ':...']
+                    if 'webirc' in cmd[0]:
+                        isWebirc = True
+                    else:
+                        isWebirc = False
 
-                        isWebirc = True if 'webirc' in original_response[0] else False
+                    uid = str(cmd[8])
-                        isWebsocket = True if 'websocket' in original_response[0] else False
+                    nickname = str(cmd[3])
+                    username = str(cmd[6])
+                    hostname = str(cmd[7])
+                    umodes = str(cmd[10])
+                    vhost = str(cmd[11])
+                    if not 'S' in umodes:
+                        remote_ip = self.Base.decode_ip(str(cmd[13]))
+                    else:
+                        remote_ip = '127.0.0.1'
 
-                        uid = str(original_response[8])
+                    score_connexion = self.first_score
-                        nickname = str(original_response[3])
-                        username = str(original_response[6])
-                        hostname = str(original_response[7])
-                        umodes = str(original_response[10])
-                        vhost = str(original_response[11])
 
-                        if not 'S' in umodes:
+                    self.User.insert(
-                            remote_ip = self.Base.decode_ip(str(original_response[13]))
+                        self.User.UserModel(
-                        else:
+                            uid=uid,
-                            remote_ip = '127.0.0.1'
+                            nickname=nickname,
-
+                            username=username,
-                        # extract realname
+                            hostname=hostname,
-                        realname_list = []
+                            umodes=umodes,
-                        for i in range(14, len(original_response)):
+                            vhost=vhost,
-                            realname_list.append(original_response[i])
+                            isWebirc=isWebirc,
-
+                            remote_ip=remote_ip,
-                        realname = ' '.join(realname_list)[1:]
+                            score_connexion=score_connexion,
-
+                            connexion_datetime=datetime.now()
-                        # Extract Geoip information
-                        pattern = r'^.*geoip=cc=(\S{2}).*$'
-                        geoip_match = re.match(pattern, original_response[0])
-
-                        if geoip_match:
-                            geoip = geoip_match.group(1)
-                        else:
-                            geoip = None
-
-                        score_connexion = self.first_score
-
-                        self.User.insert(
-                            self.User.UserModel(
-                                uid=uid,
-                                nickname=nickname,
-                                username=username,
-                                realname=realname,
-                                hostname=hostname,
-                                umodes=umodes,
-                                vhost=vhost,
-                                isWebirc=isWebirc,
-                                isWebsocket=isWebsocket,
-                                remote_ip=remote_ip,
-                                geoip=geoip,
-                                score_connexion=score_connexion,
-                                connexion_datetime=datetime.now()
-                            )
                         )
+                    )
 
-                        for classe_name, classe_object in self.loaded_classes.items():
+                    for classe_name, classe_object in self.loaded_classes.items():
-                            classe_object.cmd(original_response)
+                        classe_object.cmd(cmd_to_send)
-
-                    except Exception as err:
-                        self.Base.logs.error(f'General Error: {err}')
 
                 case 'PRIVMSG':
                     try:
                         # Supprimer la premiere valeur
-                        cmd = interm_response.copy()
+                        cmd.pop(0)
-
                         get_uid_or_nickname = str(cmd[0].replace(':',''))
                         user_trigger = self.User.get_nickname(get_uid_or_nickname)
                         dnickname = self.Config.SERVICE_NICKNAME
 
                         if len(cmd) == 6:
-                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace(self.Config.SERVICE_PREFIX,'') == ':auth':
+                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace('.','') == ':auth':
                                 cmd_copy = cmd.copy()
                                 cmd_copy[5] = '**********'
                                 self.Base.logs.info(cmd_copy)
@@ -942,11 +913,11 @@ class Irc:
                                     return False
 
                                 if not arg[0].lower() in self.commands:
-                                    self.Base.logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
+                                    self.debug(f"This command {arg[0]} is not available")
                                     return False
 
                                 cmd_to_send = convert_to_string.replace(':','')
-                                self.Base.log_cmd(user_trigger, cmd_to_send)
+                                self.Base.log_cmd(self.User.get_nickname(user_trigger), cmd_to_send)
 
                                 fromchannel = None
                                 if len(arg) >= 2:
@@ -960,26 +931,15 @@ class Irc:
                 case _:
                     pass
 
-            if original_response[2] != 'UID':
+            if cmd[2] != 'UID':
                 # Envoyer la commande aux classes dynamiquement chargées
                 for classe_name, classe_object in self.loaded_classes.items():
-                    classe_object.cmd(original_response)
+                    classe_object.cmd(cmd_to_send)
 
         except IndexError as ie:
-            self.Base.logs.error(f"{ie} / {original_response} / length {str(len(original_response))}")
+            self.Base.logs.error(f"{ie} / {cmd} / length {str(len(cmd))}")
 
-    def _hcmds(self, user: str, channel: Union[str, None], cmd: list, fullcmd: list = []) -> None:
+    def _hcmds(self, user: str, channel: Union[str, None], cmd:list, fullcmd: list = []) -> None:
-        """_summary_
-
-        Args:
-            user (str): The user who sent the query
-            channel (Union[str, None]): If the command contain the channel
-            cmd (list): The defender cmd
-            fullcmd (list, optional): The full list of the cmd coming from PRIVMS. Defaults to [].
-
-        Returns:
-            None: Nothing to return
-        """
 
         fromuser = self.User.get_nickname(user)                                   # Nickname qui a lancé la commande
         uid = self.User.get_uid(fromuser)                                         # Récuperer le uid de l'utilisateur
@@ -1325,6 +1285,10 @@ class Irc:
                 results = self.Base.db_execute_query(f'SELECT module_name FROM {self.Config.table_module}')
                 results = results.fetchall()
 
+                # if len(results) == 0:
+                #     self.send2socket(f":{dnickname} NOTICE {fromuser} :There is no module loaded")
+                #     return False
+
                 found = False
 
                 for module in all_modules:
@@ -1339,6 +1303,9 @@ class Irc:
 
                     found = False
 
+                # for r in results:
+                #     self.send2socket(f":{dnickname} NOTICE {fromuser} :{r[0]} - {self.Config.CONFIG_COLOR['verte']}Loaded{self.Config.CONFIG_COLOR['nogc']}")
+
             case 'show_timers':
 
                 if self.Base.running_timers:
@@ -1365,7 +1332,7 @@ class Irc:
 
             case 'show_users':
                 for db_user in self.User.UID_DB:
-                    self.send2socket(f":{dnickname} NOTICE {fromuser} :UID : {db_user.uid} - isWebirc: {db_user.isWebirc} - isWebSocket: {db_user.isWebsocket} - Nickname: {db_user.nickname} - Connection: {db_user.connexion_datetime}")
+                    self.send2socket(f":{dnickname} NOTICE {fromuser} :UID : {db_user.uid} - isWebirc: {db_user.isWebirc} - Nickname: {db_user.nickname} - Connection: {db_user.connexion_datetime}")
 
             case 'show_admins':
                 for db_admin in self.Admin.UID_ADMIN_DB:
@@ -1376,7 +1343,7 @@ class Irc:
                 self.send2socket(f':{dnickname} NOTICE {fromuser} : {uptime}')
 
             case 'copyright':
-                self.send2socket(f':{dnickname} NOTICE {fromuser} : # Defender V.{self.Config.current_version} Developped by adator® #')
+                self.send2socket(f':{dnickname} NOTICE {fromuser} : # Defender V.{self.Config.current_version} Developped by adator® and dktmb® #')
 
             case 'checkversion':
 

core/loadConf.py

@@ -82,9 +82,6 @@ class ConfigDataModel:
     SALON_LIBERER: str
     """Channel where the nickname will be released"""
 
-    SALON_CLONES: str
-    """Channel to host clones"""
-
     API_TIMEOUT: int
     """Default api timeout in second"""
 
@@ -150,33 +147,8 @@ class Config:
             with open(conf_filename, 'r') as configuration_data:
                 configuration:dict[str, Union[str, int, list, dict]] = json.load(configuration_data)
 
-            config_dict = {"CONFIG_COLOR" : {
+            for key, value in configuration['CONFIG_COLOR'].items():
-                            "blanche": "\\u0003\\u0030",
+                configuration['CONFIG_COLOR'][key] = str(value).encode('utf-8').decode('unicode_escape')
-                            "noire": "\\u0003\\u0031",
-                            "bleue": "\\u0003\\u0020",
-                            "verte": "\\u0003\\u0033",
-                            "rouge": "\\u0003\\u0034",
-                            "jaune": "\\u0003\\u0036",
-                            "gras": "\\u0002",
-                            "nogc": "\\u0002\\u0003"
-                                }
-                            }
-
-            missing_color = False
-
-            if not "CONFIG_COLOR" in configuration:
-                missing_color = True
-                configuration_color = config_dict
-            else:
-                configuration_color = configuration["CONFIG_COLOR"]
-
-            if missing_color:
-                for key, value in configuration_color.items():
-                    configuration_color['CONFIG_COLOR'][key] = str(value).encode('utf-8').decode('unicode_escape')
-                configuration['CONFIG_COLOR'] = configuration_color['CONFIG_COLOR']
-            else:
-                for key, value in configuration['CONFIG_COLOR'].items():
-                    configuration['CONFIG_COLOR'][key] = str(value).encode('utf-8').decode('unicode_escape')
 
             return configuration
 
@@ -184,43 +156,39 @@ class Config:
             print(f'FileNotFound: {fe}')
             print('Configuration file not found please create core/configuration.json')
             sys.exit(0)
-        except KeyError as ke:
-            print(f'Key Error: {ke}')
-            print('The key must be defined in core/configuration.json')
 
     def __load_service_configuration(self) -> ConfigDataModel:
         import_config = self.__load_json_service_configuration()
 
         ConfigObject: ConfigDataModel = ConfigDataModel(
-            SERVEUR_IP=import_config["SERVEUR_IP"] if "SERVEUR_IP" in import_config else '127.0.0.1',
+            SERVEUR_IP=import_config["SERVEUR_IP"],
-            SERVEUR_HOSTNAME=import_config["SERVEUR_HOSTNAME"] if "SERVEUR_HOSTNAME" in import_config else None,
+            SERVEUR_HOSTNAME=import_config["SERVEUR_HOSTNAME"],
-            SERVEUR_LINK=import_config["SERVEUR_LINK"] if "SERVEUR_LINK" in import_config else None,
+            SERVEUR_LINK=import_config["SERVEUR_LINK"],
-            SERVEUR_PORT=import_config["SERVEUR_PORT"] if "SERVEUR_PORT" in import_config else 6667,
+            SERVEUR_PORT=import_config["SERVEUR_PORT"],
-            SERVEUR_PASSWORD=import_config["SERVEUR_PASSWORD"] if "SERVEUR_PASSWORD" in import_config else None,
+            SERVEUR_PASSWORD=import_config["SERVEUR_PASSWORD"],
-            SERVEUR_ID=import_config["SERVEUR_ID"] if "SERVEUR_ID" in import_config else '19Z',
+            SERVEUR_ID=import_config["SERVEUR_ID"],
-            SERVEUR_SSL=import_config["SERVEUR_SSL"] if "SERVEUR_SSL" in import_config else False,
+            SERVEUR_SSL=import_config["SERVEUR_SSL"],
-            SERVICE_NAME=import_config["SERVICE_NAME"] if "SERVICE_NAME" in import_config else 'Defender',
+            SERVICE_NAME=import_config["SERVICE_NAME"],
-            SERVICE_NICKNAME=import_config["SERVICE_NICKNAME"] if "SERVICE_NICKNAME" in import_config else 'Defender',
+            SERVICE_NICKNAME=import_config["SERVICE_NICKNAME"],
-            SERVICE_REALNAME=import_config["SERVICE_REALNAME"] if "SERVICE_REALNAME" in import_config else 'Defender Security',
+            SERVICE_REALNAME=import_config["SERVICE_REALNAME"],
-            SERVICE_USERNAME=import_config["SERVICE_USERNAME"] if "SERVICE_USERNAME" in import_config else 'IRCSecurity',
+            SERVICE_USERNAME=import_config["SERVICE_USERNAME"],
-            SERVICE_HOST=import_config["SERVICE_HOST"] if "SERVICE_HOST" in import_config else 'defender.local.network',
+            SERVICE_HOST=import_config["SERVICE_HOST"],
-            SERVICE_INFO=import_config["SERVICE_INFO"] if "SERVICE_INFO" in import_config else 'Defender Network IRC Service',
+            SERVICE_INFO=import_config["SERVICE_INFO"],
-            SERVICE_CHANLOG=import_config["SERVICE_CHANLOG"] if "SERVICE_CHANLOG" in import_config else '#services',
+            SERVICE_CHANLOG=import_config["SERVICE_CHANLOG"],
-            SERVICE_SMODES=import_config["SERVICE_SMODES"] if "SERVICE_SMODES" in import_config else '+ioqBS',
+            SERVICE_SMODES=import_config["SERVICE_SMODES"],
-            SERVICE_CMODES=import_config["SERVICE_CMODES"] if "SERVICE_CMODES" in import_config else 'ntsOP',
+            SERVICE_CMODES=import_config["SERVICE_CMODES"],
-            SERVICE_UMODES=import_config["SERVICE_UMODES"] if "SERVICE_UMODES" in import_config else 'o',
+            SERVICE_UMODES=import_config["SERVICE_UMODES"],
-            SERVICE_PREFIX=import_config["SERVICE_PREFIX"] if "SERVICE_PREFIX" in import_config else '!',
+            SERVICE_PREFIX=import_config["SERVICE_PREFIX"],
-            OWNER=import_config["OWNER"] if "OWNER" in import_config else 'admin',
+            OWNER=import_config["OWNER"],
-            PASSWORD=import_config["PASSWORD"] if "PASSWORD" in import_config else 'admin',
+            PASSWORD=import_config["PASSWORD"],
-            SALON_JAIL=import_config["SALON_JAIL"] if "SALON_JAIL" in import_config else '#jail',
+            SALON_JAIL=import_config["SALON_JAIL"],
-            SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"] if "SALON_JAIL_MODES" in import_config else 'sS',
+            SALON_JAIL_MODES=import_config["SALON_JAIL_MODES"],
-            SALON_LIBERER=import_config["SALON_LIBERER"] if "SALON_LIBERER" in import_config else '#welcome',
+            SALON_LIBERER=import_config["SALON_LIBERER"],
-            SALON_CLONES=import_config["SALON_CLONES"] if "SALON_CLONES" in import_config else '#clones',
+            API_TIMEOUT=import_config["API_TIMEOUT"],
-            API_TIMEOUT=import_config["API_TIMEOUT"] if "API_TIMEOUT" in import_config else 2,
+            PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"],
-            PORTS_TO_SCAN=import_config["PORTS_TO_SCAN"] if "PORTS_TO_SCAN" in import_config else [],
+            WHITELISTED_IP=import_config["WHITELISTED_IP"],
-            WHITELISTED_IP=import_config["WHITELISTED_IP"] if "WHITELISTED_IP" in import_config else ['127.0.0.1'],
+            GLINE_DURATION=import_config["GLINE_DURATION"],
-            GLINE_DURATION=import_config["GLINE_DURATION"] if "GLINE_DURATION" in import_config else '30',
+            DEBUG_LEVEL=import_config["DEBUG_LEVEL"],
-            DEBUG_LEVEL=import_config["DEBUG_LEVEL"] if "DEBUG_LEVEL" in import_config else 20,
             CONFIG_COLOR=import_config["CONFIG_COLOR"],
             table_admin='core_admin',
             table_commande='core_command',

mods/mod_clone.py

@@ -122,89 +122,51 @@ class Clone():
 
         return None
 
-    def thread_change_hostname(self):
+    def thread_create_clones(self, nickname: str, username: str, channels: list, server_port: int, ssl: bool) -> None:
 
-        fake = faker.Faker('en_GB')
+        Connection(server_port=server_port, nickname=nickname, username=username, channels=channels, CloneObject=self.Clone, ssl=ssl)
-        for clone in self.Clone.UID_CLONE_DB:
-            if not clone.vhost is None:
-                continue
-
-            rand_1 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-            rand_2 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-            rand_3 = fake.random_elements(['A','B','C','D','E','F','0','1','2','3','4','5','6','7','8','9'], unique=True, length=8)
-
-            rand_ip = ''.join(rand_1) + '.' + ''.join(rand_2) + '.' + ''.join(rand_3) + '.IP'
-            found = False
-
-            while not found:
-                if clone.connected:
-                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} CHGHOST {clone.nickname} {rand_ip}')
-                    found = True
-                    clone.vhost = rand_ip
-                    break
-
-    def thread_create_clones(self, nickname: str, username: str, realname: str, channels: list, server_port: int, ssl: bool) -> None:
-
-        Connection(server_port=server_port, nickname=nickname, username=username, realname=realname, channels=channels, CloneObject=self.Clone, ssl=ssl)
 
         return None
 
     def thread_join_channels(self, channel_name: str, wait: float, clone_name:str = None):
-        self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Clones start to join {channel_name} with {wait} secondes frequency')
+
         if clone_name is None:
             for clone in self.Clone.UID_CLONE_DB:
-                if not channel_name in clone.channels:
+                self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                    time.sleep(wait)
+                time.sleep(wait)
-                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                    clone.channels.append(channel_name)
         else:
             for clone in self.Clone.UID_CLONE_DB:
                 if clone_name == clone.nickname:
-                    if not channel_name in clone.channels:
+                    self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                        time.sleep(wait)
+                    time.sleep(wait)
-                        self.Irc.send2socket(f':{self.Config.SERVICE_NICKNAME} PRIVMSG {clone.nickname} :JOIN {channel_name}')
-                        clone.channels.append(channel_name)
 
-    def generate_names(self) -> tuple[str, str, str]:
+    def generate_names(self) -> tuple[str, str]:
         try:
             fake = faker.Faker('en_GB')
-            # nickname = fake.first_name()
+            nickname = fake.first_name()
-            # username = fake.last_name()
+            username = fake.last_name()
-
-            # Generate Username
-            chaine = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-            new_username = fake.random_sample(chaine, 9)
-            username = ''.join(new_username)
-
-            # Create realname XX F|M Department
-            gender = fake.random_choices(['F','M'], 1)
-            gender = ''.join(gender)
-            
-            if gender == 'F':
-                nickname = fake.first_name_female()
-            elif gender == 'M':
-                nickname = fake.first_name_male()
-            else:
-                nickname = fake.first_name()
-
-            age = random.randint(20, 60)
-            fake_fr = faker.Faker(['fr_FR', 'en_GB'])
-            department = fake_fr.department_name()
-            realname = f'{age} {gender} {department}'
 
             if self.Clone.exists(nickname=nickname):
                 caracteres = '0123456789'
                 randomize = ''.join(random.choice(caracteres) for _ in range(2))
                 nickname = nickname + str(randomize)
                 self.Clone.insert(
-                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username, realname=realname, channels=[])
+                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username)
                     )
             else:
                 self.Clone.insert(
-                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username, realname=realname, channels=[])
+                    self.Clone.CloneModel(alive=True, nickname=nickname, username=username)
                     )
 
-            return (nickname, username, realname)
+            # if not nickname in self.ModConfig.clone_nicknames:
+            #     self.ModConfig.clone_nicknames.append(nickname)
+            # else:
+            #     caracteres = '0123456789'
+            #     randomize = ''.join(random.choice(caracteres) for _ in range(2))
+            #     nickname = nickname + str(randomize)
+            #     self.ModConfig.clone_nicknames.append(nickname)
+
+            return (nickname, username)
 
         except AttributeError as ae:
             self.Logs.error(f'Attribute Error : {ae}')
@@ -226,127 +188,117 @@ class Clone():
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
-        try:
+        command = str(cmd[0]).lower()
-            command = str(cmd[0]).lower()
+        fromuser = user
-            fromuser = user
 
-            dnickname = self.Config.SERVICE_NICKNAME            # Defender nickname
+        dnickname = self.Config.SERVICE_NICKNAME            # Defender nickname
 
-            match command:
+        match command:
 
-                case 'clone':
+            case 'clone':
+                option = str(cmd[1]).lower()
 
-                    if len(cmd) == 1:
+                if len(command) == 1:
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill [all | nickname]')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
+
+                match option:
+
+                    case 'connect':
+                        try:
+                            number_of_clones = int(cmd[2])
+                            for i in range(number_of_clones):
+                                nickname, username = self.generate_names()
+                                self.Base.create_thread(
+                                    self.thread_create_clones,
+                                    (nickname, username, [], 6697, True)
+                                    )
+
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{str(number_of_clones)} clones joined the network')
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect [number of clone you want to connect]')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} clone connect 6')
+
+                    case 'kill':
+                        try:
+                            # clone kill [all | nickname]
+                            clone_name = str(cmd[2])
+                            clone_to_kill: list[str] = []
+
+                            if clone_name.lower() == 'all':
+                                for clone in self.Clone.UID_CLONE_DB:
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {clone.nickname} :KILL')
+                                    clone_to_kill.append(clone.nickname)
+                                    clone.alive = False
+
+                                for clone_nickname in clone_to_kill:
+                                    self.Clone.delete(clone_nickname)
+
+                                del clone_to_kill
+
+                            else:
+                                if self.Clone.exists(clone_name):
+                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :KILL')
+                                    self.Clone.kill(clone_name)
+                                    self.Clone.delete(clone_name)
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill all')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill clone_nickname')
+
+                    case 'join':
+                        try:
+                            # clone join [all | nickname] #channel
+                            clone_name = str(cmd[2])
+                            clone_channel_to_join = str(cmd[3])
+
+                            if clone_name.lower() == 'all':
+                                self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2))
+                            else:
+                                self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2, clone_name))
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join all #channel')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join clone_nickname #channel')
+
+                    case 'list':
+                        try:
+                            for clone_name in self.Clone.UID_CLONE_DB:
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> {clone_name.nickname} | {clone_name.username}')
+                            pass
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+
+                    case 'say':
+                        try:
+                            # clone say clone_nickname #channel message
+                            clone_name = str(cmd[2])
+                            clone_channel = str(cmd[3]) if self.Base.Is_Channel(str(cmd[3])) else None
+
+                            message = []
+                            for i in range(4, len(cmd)):
+                                message.append(cmd[i])
+                            final_message = ' '.join(message)
+
+                            if clone_channel is None or not self.Clone.exists(clone_name):
+                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
+                                return None
+                            
+                            if self.Clone.exists(clone_name):
+                                self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :SAY {clone_channel} {final_message}')
+
+                        except Exception as err:
+                            self.Logs.error(f'{err}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
+
+                    case _:
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill [all | nickname]')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel [message]')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
-
-                    option = str(cmd[1]).lower()
-
-                    match option:
-
-                        case 'connect':
-                            try:
-                                number_of_clones = int(cmd[2])
-                                for i in range(number_of_clones):
-                                    nickname, username, realname = self.generate_names()
-                                    self.Base.create_thread(
-                                        self.thread_create_clones,
-                                        (nickname, username, realname, [], 6697, True)
-                                        )
-
-                                self.Base.create_thread(
-                                    self.thread_change_hostname
-                                )
-
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{str(number_of_clones)} clones joined the network')
-
-                            except Exception as err:
-                                self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect [number of clone you want to connect]')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} clone connect 6')
-
-                        case 'kill':
-                            try:
-                                # clone kill [all | nickname]
-                                clone_name = str(cmd[2])
-                                clone_to_kill: list[str] = []
-
-                                if clone_name.lower() == 'all':
-                                    for clone in self.Clone.UID_CLONE_DB:
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {clone.nickname} :KILL')
-                                        clone_to_kill.append(clone.nickname)
-                                        clone.alive = False
-
-                                    for clone_nickname in clone_to_kill:
-                                        self.Clone.delete(clone_nickname)
-
-                                    del clone_to_kill
-
-                                else:
-                                    if self.Clone.exists(clone_name):
-                                        self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :KILL')
-                                        self.Clone.kill(clone_name)
-                                        self.Clone.delete(clone_name)
-
-                            except Exception as err:
-                                self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill all')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill clone_nickname')
-
-                        case 'join':
-                            try:
-                                # clone join [all | nickname] #channel
-                                clone_name = str(cmd[2])
-                                clone_channel_to_join = str(cmd[3])
-
-                                if clone_name.lower() == 'all':
-                                    self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2))
-                                else:
-                                    self.Base.create_thread(self.thread_join_channels, (clone_channel_to_join, 2, clone_name))
-
-                            except Exception as err:
-                                self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join all #channel')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join clone_nickname #channel')
-
-                        case 'list':
-                            try:
-                                for clone_name in self.Clone.UID_CLONE_DB:
-                                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :>> Nickname: {clone_name.nickname} | Username: {clone_name.username}')
-                            except Exception as err:
-                                self.Logs.error(f'{err}')
-
-                        case 'say':
-                            try:
-                                # clone say clone_nickname #channel message
-                                clone_name = str(cmd[2])
-                                clone_channel = str(cmd[3]) if self.Base.Is_Channel(str(cmd[3])) else None
-
-                                message = []
-                                for i in range(4, len(cmd)):
-                                    message.append(cmd[i])
-                                final_message = ' '.join(message)
-
-                                if clone_channel is None or not self.Clone.exists(clone_name):
-                                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
-                                    return None
-                                
-                                if self.Clone.exists(clone_name):
-                                    self.Irc.send2socket(f':{dnickname} PRIVMSG {clone_name} :SAY {clone_channel} {final_message}')
-
-                            except Exception as err:
-                                self.Logs.error(f'{err}')
-                                self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel message')
-
-                        case _:
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone connect 6')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone kill [all | nickname]')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone join [all | nickname] #channel')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone say [clone_nickname] #channel [message]')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} clone list')
-        except IndexError as ie:
-            self.Logs.error(f'Index Error: {ie}')
-        except Exception as err:
-            self.Logs.error(f'Index Error: {err}')

mods/mod_defender.py

@@ -4,7 +4,6 @@ from typing import Union
 import re, socket, psutil, requests, json, time
 from sys import exit
 from core.irc import Irc
-from core.Model import User
 
 #   Le module crée devra réspecter quelques conditions
 #       1. Le nom de la classe devra toujours s'appeler comme le module. Exemple => nom de class Defender | nom du module mod_defender
@@ -44,13 +43,11 @@ class Defender():
         nickname: str
         username: str
         hostname: str
-        realname: str
         umodes: str
         vhost: str
         ip: str
         score: int
         isWebirc: bool
-        isWebsocket: bool
         secret_code: str
         connected_datetime: str
         updated_datetime: str
@@ -110,13 +107,12 @@ class Defender():
         # self.join_saved_channels()
 
         self.timeout = self.Config.API_TIMEOUT
-
         # Listes qui vont contenir les ip a scanner avec les différentes API
-        self.abuseipdb_UserModel: list[User.UserModel] = []
+        self.freeipapi_remote_ip:list = []
-        self.freeipapi_UserModel: list[User.UserModel] = []
+        self.cloudfilt_remote_ip:list = []
-        self.cloudfilt_UserModel: list[User.UserModel] = []
+        self.abuseipdb_remote_ip:list = []
-        self.psutil_UserModel: list[User.UserModel]    = []
+        self.psutil_remote_ip:list    = []
-        self.localscan_UserModel: list[User.UserModel] = []
+        self.localscan_remote_ip:list = []
 
         # Variables qui indique que les threads sont en cours d'éxecutions
         self.abuseipdb_isRunning:bool       = True
@@ -230,11 +226,11 @@ class Defender():
         """Cette methode sera executée a chaque désactivation ou 
         rechargement de module
         """
-        self.abuseipdb_UserModel: list[User.UserModel] = []
+        self.abuseipdb_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec abuseipdb
-        self.freeipapi_UserModel: list[User.UserModel] = []
+        self.freeipapi_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec freeipapi
-        self.cloudfilt_UserModel: list[User.UserModel] = []
+        self.cloudfilt_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec cloudfilt
-        self.psutil_UserModel: list[User.UserModel]    = []
+        self.psutil_remote_ip:list    = []                                  # Liste qui va contenir les adresses ip a scanner avec psutil_scan
-        self.localscan_UserModel: list[User.UserModel] = []
+        self.localscan_remote_ip:list = []                                  # Liste qui va contenir les adresses ip a scanner avec local_scan
 
         self.abuseipdb_isRunning:bool = False
         self.freeipapi_isRunning:bool = False
@@ -609,38 +605,28 @@ class Defender():
 
         return None
 
-    def scan_ports(self, userModel: User.UserModel) -> None:
+    def scan_ports(self, remote_ip: str) -> None:
         """local_scan
 
         Args:
-            userModel (UserModel): _description_
+            remote_ip (str): _description_
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-        fullname = f'{nickname}!{username}@{hostname}'
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
 
         for port in self.Config.PORTS_TO_SCAN:
+            newSocket = ''
+            newSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM or socket.SOCK_NONBLOCK)
+            newSocket.settimeout(0.5)
             try:
-                newSocket = ''
-                newSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM or socket.SOCK_NONBLOCK)
-                newSocket.settimeout(0.5)
-
                 connection = (remote_ip, self.Base.int_if_possible(port))
                 newSocket.connect(connection)
-
+                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}PROXY_SCAN{self.Config.CONFIG_COLOR['noire']} ] :     Port [{str(port)}] ouvert sur l'adresse ip [{remote_ip}]")
-                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}PROXY_SCAN{self.Config.CONFIG_COLOR['noire']} ] {fullname} ({remote_ip}) :     Port [{str(port)}] ouvert sur l'adresse ip [{remote_ip}]")
                 # print(f"=======> Le port {str(port)} est ouvert !!")
                 self.Base.running_sockets.append(newSocket)
                 # print(newSocket)
                 newSocket.shutdown(socket.SHUT_RDWR)
                 newSocket.close()
-
             except (socket.timeout, ConnectionRefusedError):
                 self.Logs.info(f"Le port {remote_ip}:{str(port)} est fermé")
             except AttributeError as ae:
@@ -651,19 +637,21 @@ class Defender():
                 # newSocket.shutdown(socket.SHUT_RDWR)
                 newSocket.close()
                 self.Logs.info('=======> Fermeture de la socket')
+        
+        pass
 
     def thread_local_scan(self) -> None:
         try:
             while self.localscan_isRunning:
 
                 list_to_remove:list = []
-                for user in self.localscan_UserModel:
+                for ip in self.localscan_remote_ip:
-                    self.scan_ports(user)
+                    self.scan_ports(ip)
-                    list_to_remove.append(user)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
+                for ip_to_remove in list_to_remove:
-                    self.localscan_UserModel.remove(user_model)
+                    self.localscan_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -671,33 +659,23 @@ class Defender():
         except ValueError as ve:
             self.Logs.warning(f"thread_local_scan Error : {ve}")
 
-    def get_ports_connexion(self, userModel: User.UserModel) -> list[int]:
+    def get_ports_connexion(self, remote_ip: str) -> list[int]:
-        """psutil_scan for Linux (should be run on the same location as the unrealircd server)
+        """psutil_scan for Linux
 
         Args:
-            userModel (UserModel): The User Model Object
+            remote_ip (str): The remote ip address
 
         Returns:
             list[int]: list of ports
         """
         try:
-            User = userModel
-            remote_ip = User.remote_ip
-            username = User.username
-            hostname = User.hostname
-            nickname = User.nickname
-
             if remote_ip in self.Config.WHITELISTED_IP:
                 return None
 
             connections = psutil.net_connections(kind='inet')
-            fullname = f'{nickname}!{username}@{hostname}'
 
             matching_ports = [conn.raddr.port for conn in connections if conn.raddr and conn.raddr.ip == remote_ip]
-            self.Logs.info(f"Connexion of {fullname} ({remote_ip}) using ports : {str(matching_ports)}")
+            self.Logs.info(f"Connexion of {remote_ip} using ports : {str(matching_ports)}")
-
-            if matching_ports:
-                self.Irc.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.CONFIG_COLOR['rouge']}PSUTIL_SCAN{self.Config.CONFIG_COLOR['noire']} ] {fullname} ({remote_ip}) : is using ports {matching_ports}")
 
             return matching_ports
 
@@ -710,13 +688,13 @@ class Defender():
             while self.psutil_isRunning:
 
                 list_to_remove:list = []
-                for user in self.psutil_UserModel:
+                for ip in self.psutil_remote_ip:
-                    self.get_ports_connexion(user)
+                    self.get_ports_connexion(ip)
-                    list_to_remove.append(user)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
+                for ip_to_remove in list_to_remove:
-                    self.psutil_UserModel.remove(user_model)
+                    self.psutil_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -724,22 +702,16 @@ class Defender():
         except ValueError as ve:
             self.Logs.warning(f"thread_psutil_scan Error : {ve}")
 
-    def abuseipdb_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
+    def abuseipdb_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
         """Analyse l'ip avec AbuseIpDB
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
-            userModel (UserModel): l'objet User qui contient l'ip
+            remote_ip (_type_): l'ip a analyser
 
         Returns:
             dict[str, any] | None: les informations du provider
             keys : 'score', 'country', 'isTor', 'totalReports'
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
         if self.ModConfig.abuseipdb_scan == 0:
@@ -759,12 +731,11 @@ class Defender():
             'Key': self.abuseipdb_key
         }
 
+        response = requests.request(method='GET', url=url, headers=headers, params=querystring, timeout=self.timeout)
+
+        # Formatted output
+        decodedResponse = json.loads(response.text)
         try:
-            response = requests.request(method='GET', url=url, headers=headers, params=querystring, timeout=self.timeout)
-
-            # Formatted output
-            decodedResponse = json.loads(response.text)
-
             if not 'data' in decodedResponse:
                 return None
 
@@ -780,10 +751,7 @@ class Defender():
             color_red = self.Config.CONFIG_COLOR['rouge']
             color_black = self.Config.CONFIG_COLOR['noire']
 
-            # pseudo!ident@host
+            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}ABUSEIPDB_SCAN{color_black} ] : Connexion de {remote_ip} ==> Score: {str(result['score'])} | Country : {result['country']} | Tor : {str(result['isTor'])} | Total Reports : {str(result['totalReports'])}")
-            fullname = f'{nickname}!{username}@{hostname}'
-
-            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}ABUSEIPDB_SCAN{color_black} ] : Connexion de {fullname} ({remote_ip}) ==> Score: {str(result['score'])} | Country : {result['country']} | Tor : {str(result['isTor'])} | Total Reports : {str(result['totalReports'])}")
 
             if result['isTor']:
                 self.Irc.send2socket(f":{service_id} GLINE +*@{remote_ip} {self.Config.GLINE_DURATION} This server do not allow Tor connexions {str(result['isTor'])} - Detected by Abuseipdb")
@@ -799,22 +767,20 @@ class Defender():
             self.Logs.error(f"AbuseIpDb Timeout : {rt}")
         except requests.ConnectionError as ce:
             self.Logs.error(f"AbuseIpDb Connection Error : {ce}")
-        except Exception as err:
-            self.Logs.error(f"General Error Abuseipdb : {err}")
 
     def thread_abuseipdb_scan(self) -> None:
         try:
 
             while self.abuseipdb_isRunning:
 
-                list_to_remove: list = []
+                list_to_remove:list = []
-                for user in self.abuseipdb_UserModel:
+                for ip in self.abuseipdb_remote_ip:
-                    self.abuseipdb_scan(user)
+                    self.abuseipdb_scan(ip)
-                    list_to_remove.append(user)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
+                for ip_to_remove in list_to_remove:
-                    self.abuseipdb_UserModel.remove(user_model)
+                    self.abuseipdb_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -822,7 +788,7 @@ class Defender():
         except ValueError as ve:
                 self.Logs.error(f"thread_abuseipdb_scan Error : {ve}")
 
-    def freeipapi_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
+    def freeipapi_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
         """Analyse l'ip avec Freeipapi
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
@@ -832,12 +798,6 @@ class Defender():
             dict[str, any] | None: les informations du provider
             keys : 'countryCode', 'isProxy'
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
         if self.ModConfig.freeipapi_scan == 0:
@@ -854,12 +814,11 @@ class Defender():
             'Accept': 'application/json',
         }
 
+        response = requests.request(method='GET', url=url, headers=headers, timeout=self.timeout)
+
+        # Formatted output
+        decodedResponse = json.loads(response.text)
         try:
-            response = requests.request(method='GET', url=url, headers=headers, timeout=self.timeout)
-
-            # Formatted output
-            decodedResponse = json.loads(response.text)
-
             status_code = response.status_code
             if status_code == 429:
                 self.Logs.warning(f'Too Many Requests - The rate limit for the API has been exceeded.')
@@ -873,10 +832,7 @@ class Defender():
                 'isProxy': decodedResponse['isProxy'] if 'isProxy' in decodedResponse else None
             }
 
-            # pseudo!ident@host
+            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}FREEIPAPI_SCAN{color_black} ] : Connexion de {remote_ip} ==> Proxy: {str(result['isProxy'])} | Country : {str(result['countryCode'])}")
-            fullname = f'{nickname}!{username}@{hostname}'
-
-            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}FREEIPAPI_SCAN{color_black} ] : Connexion de {fullname} ({remote_ip}) ==> Proxy: {str(result['isProxy'])} | Country : {str(result['countryCode'])}")
 
             if result['isProxy']:
                 self.Irc.send2socket(f":{service_id} GLINE +*@{remote_ip} {self.Config.GLINE_DURATION} This server do not allow proxy connexions {str(result['isProxy'])} - detected by freeipapi")
@@ -885,22 +841,20 @@ class Defender():
             return result
         except KeyError as ke:
             self.Logs.error(f"FREEIPAPI_SCAN KeyError : {ke}")
-        except Exception as err:
-            self.Logs.error(f"General Error Freeipapi : {err}")
 
     def thread_freeipapi_scan(self) -> None:
         try:
 
             while self.freeipapi_isRunning:
 
-                list_to_remove: list[User.UserModel] = []
+                list_to_remove:list = []
-                for user in self.freeipapi_UserModel:
+                for ip in self.freeipapi_remote_ip:
-                    self.freeipapi_scan(user)
+                    self.freeipapi_scan(ip)
-                    list_to_remove.append(user)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
+                for ip_to_remove in list_to_remove:
-                    self.freeipapi_UserModel.remove(user_model)
+                    self.freeipapi_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -908,7 +862,7 @@ class Defender():
         except ValueError as ve:
             self.Logs.error(f"thread_freeipapi_scan Error : {ve}")
 
-    def cloudfilt_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
+    def cloudfilt_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
         """Analyse l'ip avec cloudfilt
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
@@ -918,12 +872,6 @@ class Defender():
             dict[str, any] | None: les informations du provider
             keys : 'countryCode', 'isProxy'
         """
-        User = userModel
-        remote_ip = User.remote_ip
-        username = User.username
-        hostname = User.hostname
-        nickname = User.nickname
-
         if remote_ip in self.Config.WHITELISTED_IP:
             return None
         if self.ModConfig.cloudfilt_scan == 0:
@@ -943,10 +891,11 @@ class Defender():
             'key': self.cloudfilt_key
         }
 
+        response = requests.post(url=url, data=data)
+
+        # Formatted output
+        decodedResponse = json.loads(response.text)
         try:
-            response = requests.post(url=url, data=data)
-            # Formatted output
-            decodedResponse = json.loads(response.text)
             status_code = response.status_code
             if status_code != 200:
                 self.Logs.warning(f'Error connecting to cloudfilt API | Code: {str(status_code)}')
@@ -959,10 +908,7 @@ class Defender():
                 'host': decodedResponse['host'] if 'host' in decodedResponse else None
             }
 
-            # pseudo!ident@host
+            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}CLOUDFILT_SCAN{color_black} ] : Connexion de {str(remote_ip)} ==> Host: {str(result['host'])} | country: {str(result['countryiso'])} | listed: {str(result['listed'])} | listed by : {str(result['listed_by'])}")
-            fullname = f'{nickname}!{username}@{hostname}'
-
-            self.Irc.send2socket(f":{service_id} PRIVMSG {service_chanlog} :[ {color_red}CLOUDFILT_SCAN{color_black} ] : Connexion de {fullname} ({remote_ip}) ==> Host: {str(result['host'])} | country: {str(result['countryiso'])} | listed: {str(result['listed'])} | listed by : {str(result['listed_by'])}")
 
             if result['listed']:
                 self.Irc.send2socket(f":{service_id} GLINE +*@{remote_ip} {self.Config.GLINE_DURATION} You connexion is listed as dangerous {str(result['listed'])} {str(result['listed_by'])} - detected by cloudfilt")
@@ -980,13 +926,13 @@ class Defender():
             while self.cloudfilt_isRunning:
 
                 list_to_remove:list = []
-                for user in self.cloudfilt_UserModel:
+                for ip in self.cloudfilt_remote_ip:
-                    self.cloudfilt_scan(user)
+                    self.cloudfilt_scan(ip)
-                    list_to_remove.append(user)
+                    list_to_remove.append(ip)
                     time.sleep(1)
 
-                for user_model in list_to_remove:
+                for ip_to_remove in list_to_remove:
-                    self.cloudfilt_UserModel.remove(user_model)
+                    self.cloudfilt_remote_ip.remove(ip_to_remove)
 
                 time.sleep(1)
 
@@ -994,7 +940,7 @@ class Defender():
         except ValueError as ve:
             self.Logs.error(f"Thread_cloudfilt_scan Error : {ve}")
 
-    def cmd(self, data: list) -> None:
+    def cmd(self, data:list) -> None:
 
         service_id = self.Config.SERVICE_ID                 # Defender serveur id
         cmd = list(data).copy()
@@ -1020,6 +966,22 @@ class Defender():
                     if not self.Base.is_valid_ip(cmd[2]):
                         return None
 
+                    # self.Base.scan_ports(cmd[2])
+                    if self.ModConfig.local_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.localscan_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.psutil_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.psutil_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.abuseipdb_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.abuseipdb_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.freeipapi_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.freeipapi_remote_ip.append(cmd[2])
+
+                    if self.ModConfig.cloudfilt_scan == 1 and not cmd[2] in self.Config.WHITELISTED_IP:
+                        self.cloudfilt_remote_ip.append(cmd[2])
+
                     # Possibilité de déclancher les bans a ce niveau.
                 except IndexError as ie:
                     self.Logs.error(f'cmd reputation: index error: {ie}')
@@ -1043,15 +1005,6 @@ class Defender():
 
                 # Get User information
                 _User = self.User.get_User(str(cmd[7]))
-
-                # If user is not service or IrcOp then scan them
-                if not re.match(fr'^.*[S|o?].*$', _User.umodes):
-                    self.abuseipdb_UserModel.append(_User) if self.ModConfig.abuseipdb_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                    self.freeipapi_UserModel.append(_User) if self.ModConfig.freeipapi_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                    self.cloudfilt_UserModel.append(_User) if self.ModConfig.cloudfilt_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                    self.psutil_UserModel.append(_User) if self.ModConfig.psutil_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                    self.localscan_UserModel.append(_User) if self.ModConfig.local_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-
                 if _User is None:
                     self.Logs.critical(f'This UID: [{cmd[7]}] is not available please check why')
                     return None
@@ -1066,9 +1019,9 @@ class Defender():
                             currentDateTime = self.Base.get_datetime()
                             self.reputation_insert(
                                 self.ReputationModel(
-                                    uid=_User.uid, nickname=_User.nickname, username=_User.username, realname=_User.realname, 
+                                    uid=_User.uid, nickname=_User.nickname, username=_User.username, hostname=_User.hostname,
-                                    hostname=_User.hostname, umodes=_User.umodes, vhost=_User.vhost, ip=_User.remote_ip, score=_User.score_connexion,
+                                    umodes=_User.umodes, vhost=_User.vhost, ip=_User.remote_ip, score=_User.score_connexion,
-                                    secret_code=self.Base.get_random(8), isWebirc=_User.isWebirc, isWebsocket=_User.isWebsocket, connected_datetime=currentDateTime,
+                                    secret_code=self.Base.get_random(8), isWebirc=_User.isWebirc, connected_datetime=currentDateTime,
                                     updated_datetime=currentDateTime
                                 )
                             )
@@ -1091,9 +1044,6 @@ class Defender():
 
                         get_reputation = self.reputation_get_Reputation(parsed_UID)
 
-                        self.Irc.send2socket(f":{service_id} MODE {parsed_chan} +b ~security-group:unknown-users")
-                        self.Irc.send2socket(f":{service_id} MODE {parsed_chan} +eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
-
                         if not get_reputation is None:
                             isWebirc = get_reputation.isWebirc
 
@@ -1117,20 +1067,20 @@ class Defender():
                 if not self.Base.is_valid_ip(cmd[7]):
                     return None
 
-                # if self.ModConfig.local_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                if self.ModConfig.local_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                #     self.localscan_remote_ip.append(cmd[7])
+                    self.localscan_remote_ip.append(cmd[7])
 
-                # if self.ModConfig.psutil_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                if self.ModConfig.psutil_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                #     self.psutil_remote_ip.append(cmd[7])
+                    self.psutil_remote_ip.append(cmd[7])
 
-                # if self.ModConfig.abuseipdb_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                if self.ModConfig.abuseipdb_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                #     self.abuseipdb_remote_ip.append(cmd[7])
+                    self.abuseipdb_remote_ip.append(cmd[7])
 
-                # if self.ModConfig.freeipapi_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                if self.ModConfig.freeipapi_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                #     self.freeipapi_remote_ip.append(cmd[7])
+                    self.freeipapi_remote_ip.append(cmd[7])
 
-                # if self.ModConfig.cloudfilt_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
+                if self.ModConfig.cloudfilt_scan == 1 and not cmd[7] in self.Config.WHITELISTED_IP:
-                #     self.cloudfilt_remote_ip.append(cmd[7])
+                    self.cloudfilt_remote_ip.append(cmd[7])
 
             case 'NICK':
                 # :0010BS24L NICK [NEWNICK] 1697917711
@@ -1293,7 +1243,9 @@ class Defender():
                                 for chan in self.Channel.UID_CHANNEL_DB:
                                     if chan.name != jail_chan:
                                         self.Irc.send2socket(f":{service_id} MODE {chan.name} +b ~security-group:unknown-users")
-                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
+                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +e ~security-group:webirc-users")
+                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +e ~security-group:known-users")
+                                        self.Irc.send2socket(f":{service_id} MODE {chan.name} +e ~security-group:websocket-users")
 
                             self.Base.db_query_channel('add', self.module_name, jail_chan)
 
@@ -1629,14 +1581,10 @@ class Defender():
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : UID              : {UserObject.uid}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : NICKNAME         : {UserObject.nickname}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : USERNAME         : {UserObject.username}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : REALNAME         : {UserObject.realname}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : HOSTNAME         : {UserObject.hostname}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : VHOST            : {UserObject.vhost}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : IP               : {UserObject.remote_ip}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Country          : {UserObject.geoip}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : WebIrc           : {UserObject.isWebirc}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : WebWebsocket     : {UserObject.isWebsocket}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : REPUTATION       : {UserObject.score_connexion}')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : VHOST            : {UserObject.vhost}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : MODES            : {UserObject.umodes}')
                         self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : CONNECTION TIME  : {UserObject.connexion_datetime}')
                     else:

version.json

@@ -1,3 +1,3 @@
 {
-    "version": "5.2.6"
+    "version": "5.1.8"
 }