Merge pull request #32 from adator85/dev

Update vote kick commands

.gitignore

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

README.md

@@ -1,9 +1,4 @@
 # IRC-DEFENDER
-![Static Badge](https://img.shields.io/badge/UnrealIRCd-6.2.2%20or%20later-green)
-![Static Badge](https://img.shields.io/badge/Python3-3.10%20or%20later-green)
-![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fadator85%2FIRC_DEFENDER_MODULES%2Fmain%2Fversion.json&query=version&label=Current%20Version)
-![Static Badge](https://img.shields.io/badge/Maintained-Yes-green)
-
 Defender est un service IRC basé sur la sécurité des réseaux IRC ( UnrealIRCD )
 Il permet d'ajouter une sécurité supplémentaire pour vérifier les users connectés au réseau
 en demandant aux user un code de validation.
@@ -14,9 +9,9 @@ Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux u
         Kick: Expulser un utilisateur du canal.
         Ban: Interdire définitivement l'accès au canal.
         Unban: Lever une interdiction.
-        Op/Deop/Opall/Deopall: Attribuer ou retirer les droits d'opérateur.
+        Op/Deop: Attribuer ou retirer les droits d'opérateur.
         Halfop/Dehalfop: Attribuer ou retirer les droits
-        Voice/Devoice/VoiceAll/DevoiceAll: Attribuer ou retirer les droits de voix.
+        Voice/Devoice: Attribuer ou retirer les droits de voix.
 
     Système de quarantaine:
         Mise en quarantaine: Isoler temporairement un utilisateur dans un canal privé.
@@ -30,7 +25,6 @@ Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux u
 
     Prérequis:
         - Système d'exploitation Linux (Windows non supporté)
-        - Un server UnrealIRCD corréctement configuré
         - Python version 3.10 ou supérieure
 
     Bash:
@@ -57,156 +51,56 @@ 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.
+        Vous devez modifier le fichier config.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
+    Attention
-```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",
+        Le mot de passe de l'administrateur et le mot de passe du service doivent être modifiés pour des raisons de sécurité.
-    "SERVICE_NICKNAME": "Dev-PyDefender",
+        Ne partagez pas vos informations de connexion au serveur IRC avec des tiers.
-    "SERVICE_REALNAME": "Python Defender Security",
-    "SERVICE_USERNAME": "Dev-PyDefender",
-    "SERVICE_HOST": "HOST.DE.TON.DEFENDER",
 
-    "OWNER": "TON_NICK_NAME",
+#Extension:
-    "PASSWORD": "admin",
-
-    "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"
-    }
-}
-
-```
-
-## Exemple complet de configuration
-```json
-{
-    "SERVEUR_IP": "YOUR.SERVER.IP",
-    "SERVEUR_HOSTNAME": "irc.deb.biz.st",
-    "SERVEUR_LINK": "defenderdev.deb.biz.st",
-    "SERVEUR_PORT": 6901,
-    "SERVEUR_PASSWORD": "yourpassword",
-    "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
-
-# 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).
 
 # Contributions:

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

@@ -1,7 +1,7 @@
 import time, threading, os, random, socket, hashlib, ipaddress, logging, requests, json, re, ast
 from dataclasses import fields
 from typing import Union, Literal
-from base64 import b64decode, b64encode
+from base64 import b64decode
 from datetime import datetime
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
@@ -9,6 +9,10 @@ from core.loadConf import ConfigDataModel
 
 class Base:
 
+    # CORE_DB_PATH = 'core' + os.sep + 'db' + os.sep              # Le dossier bases de données core
+    # MODS_DB_PATH = 'mods' + os.sep + 'db' + os.sep              # Le dossier bases de données des modules
+    # PYTHON_MIN_VERSION = '3.10'                                 # Version min de python
+
     def __init__(self, Config: ConfigDataModel) -> None:
 
         self.Config = Config                                    # Assigner l'objet de configuration
@@ -218,7 +222,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 +311,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 +334,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 +429,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 +445,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)
@@ -682,17 +682,6 @@ class Base:
             self.logs.critical(f'This remote ip is not valid : {ve}')
             return None
 
-    # def encode_ip(self, remote_ip_address: str) -> Union[str, None]:
-
-    #     binary_ip = b64encode()
-    #     try:
-    #         decoded_ip = ipaddress.ip_address(binary_ip)
-
-    #         return decoded_ip.exploded
-    #     except ValueError as ve:
-    #         self.logs.critical(f'This remote ip is not valid : {ve}')
-    #         return None
-
     def get_random(self, lenght:int) -> str:
         """
         Retourn une chaîne aléatoire en fonction de la longueur spécifiée.
@@ -760,4 +749,4 @@ class Base:
         except TypeError as te:
             self.logs.error(f'TypeError: [{channelToCheck}] - {te}')
         except Exception as err:
-            self.logs.error(f'Error Not defined: {err}')
+            self.logs.error(f'TypeError: {err}')

core/connection.py

@@ -1,4 +1,4 @@
-import socket, ssl
+import socket, ssl, time
 from ssl import SSLSocket
 from core.loadConf import Config
 from core.Model import Clones
@@ -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,59 +172,36 @@ 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])
                                 self.send2socket(f"JOIN {channel_to_join}")
-
                             if command == 'SAY':
                                 clone_channel = str(response[4])
+
                                 message = []
                                 for i in range(5, len(response)):
                                     message.append(response[i])
                                 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:
 
@@ -137,11 +133,11 @@ class Install:
         min_major, min_minor = tuple((python_required_version[0], python_required_version[1]))
 
         if int(sys_major) < int(min_major):
-            print(f"## Your python version must be greather than or equal to {self.config.python_min_version} ##")
+            print(f"## Your python version must be greather than or equal to {self.config.python_current_version} ##")
             return False
 
         elif (int(sys_major) <= int(min_major)) and (int(sys_minor) < int(min_minor)):
-            print(f"## Your python version must be greather than or equal to {self.config.python_min_version} ##")
+            print(f"## Your python version must be greather than or equal to {self.config.python_current_version} ##")
             return False
 
         print(f"> Version of python : {self.config.python_current_version} ==> OK")

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
@@ -110,8 +110,8 @@ class Irc:
             self.ircObject = ircInstance                        # créer une copie de l'instance Irc
             self.__link(self.IrcSocket)                         # établir la connexion au serveur IRC
             self.signal = True                                  # Une variable pour initier la boucle infinie
-            self.__join_saved_channels()                        # Join existing channels
             self.load_existing_modules()                        # Charger les modules existant dans la base de données
+            self.__join_saved_channels()                        # Join existing channels
 
             while self.signal:
                 try:
@@ -131,7 +131,6 @@ class Irc:
 
                         self.__create_socket()
                         self.__link(self.IrcSocket)
-                        self.__join_saved_channels()
                         self.load_existing_modules()
                         self.RESTART = 0
 
@@ -176,7 +175,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 
@@ -214,8 +212,7 @@ class Irc:
             writer.send(f":{sid} PROTOCTL SID={sid}\r\n".encode(charset))
             writer.send(f":{sid} SERVER {link} 1 :{info}\r\n".encode(charset))
             writer.send(f":{sid} {nickname} :Reserved for services\r\n".encode(charset))
-            #writer.send(f":{sid} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * * :{realname}\r\n".encode(charset))
+            writer.send(f":{sid} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * * :{realname}\r\n".encode(charset))
-            writer.send(f":{sid} UID {nickname} 1 {unixtime} {username} {host} {service_id} * {smodes} * * fwAAAQ== :{realname}\r\n".encode(charset))
             writer.send(f":{sid} SJOIN {unixtime} {chan} + :{service_id}\r\n".encode(charset))
             writer.send(f":{sid} TKL + Q * {nickname} {host} 0 {unixtime} :Reserved for services\r\n".encode(charset))
 
@@ -275,20 +272,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 +444,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 +574,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 +582,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 +622,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 +645,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 +681,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 +691,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 +726,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 +746,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 +764,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 +799,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 +911,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 +929,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 +1283,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 +1301,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 +1330,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 +1341,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"""
 
@@ -97,7 +94,7 @@ class ConfigDataModel:
     GLINE_DURATION: str
     """Gline duration"""
 
-    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]
+    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]                                         # Le niveau des logs DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50
     """Logs level: DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50"""
 
     CONFIG_COLOR: dict[str, str]
@@ -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
 
@@ -189,35 +161,34 @@ class Config:
         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_command.py

@@ -35,9 +35,7 @@ class Command():
         # Create module commands (Mandatory)
         self.commands_level = {
             1: ['join', 'part'],
-            2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 
+            2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 'unban','kick', 'kickban', 'umode']
-                'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
-                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick']
         }
 
         # Init the module
@@ -180,8 +178,6 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'devoiceall':
                 try:
@@ -189,52 +185,40 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'voiceall':
-                try:
+                chan_info = self.Channel.get_Channel(fromchannel)
-                    chan_info = self.Channel.get_Channel(fromchannel)
+                set_mode = 'v'
-                    set_mode = 'v'
+                mode:str = ''
-                    mode:str = ''
+                users:str = ''
-                    users:str = ''
+                uids_split = [chan_info.uids[i:i + 6] for i in range(0, len(chan_info.uids), 6)]
-                    uids_split = [chan_info.uids[i:i + 6] for i in range(0, len(chan_info.uids), 6)]
 
-                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{set_mode} {dnickname}")
+                self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{set_mode} {dnickname}")
-                    for uid in uids_split:
+                for uid in uids_split:
-                        for i in range(0, len(uid)):
+                    for i in range(0, len(uid)):
-                            mode += set_mode
+                        mode += set_mode
-                            users += f'{self.User.get_nickname(self.Base.clean_uid(uid[i]))} '
+                        users += f'{self.User.get_nickname(self.Base.clean_uid(uid[i]))} '
-                            if i == len(uid) - 1:
+                        if i == len(uid) - 1:
-                                self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
+                            self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
-                                mode = ''
+                            mode = ''
-                                users = ''
+                            users = ''
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'opall':
-                try:
+                chan_info = self.Channel.get_Channel(fromchannel)
-                    chan_info = self.Channel.get_Channel(fromchannel)
+                set_mode = 'o'
-                    set_mode = 'o'
+                mode:str = ''
-                    mode:str = ''
+                users:str = ''
-                    users:str = ''
+                uids_split = [chan_info.uids[i:i + 6] for i in range(0, len(chan_info.uids), 6)]
-                    uids_split = [chan_info.uids[i:i + 6] for i in range(0, len(chan_info.uids), 6)]
 
-                    self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{set_mode} {dnickname}")
+                self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{set_mode} {dnickname}")
-                    for uid in uids_split:
+                for uid in uids_split:
-                        for i in range(0, len(uid)):
+                    for i in range(0, len(uid)):
-                            mode += set_mode
+                        mode += set_mode
-                            users += f'{self.User.get_nickname(self.Base.clean_uid(uid[i]))} '
+                        users += f'{self.User.get_nickname(self.Base.clean_uid(uid[i]))} '
-                            if i == len(uid) - 1:
+                        if i == len(uid) - 1:
-                                self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
+                            self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
-                                mode = ''
+                            mode = ''
-                                users = ''
+                            users = ''
-                except IndexError as e:
-                    self.Logs.warning(f'_hcmd OP: {str(e)}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'op':
                 # /mode #channel +o user
@@ -262,8 +246,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} op [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'deop':
                 # /mode #channel -o user
@@ -289,8 +271,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOP: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} deop [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'owner':
                 # /mode #channel +q user
@@ -316,8 +296,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OWNER: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} owner [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'deowner':
                 # /mode #channel -q user
@@ -343,8 +321,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'halfop':
                 # /mode #channel +h user
@@ -370,8 +346,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd halfop: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'dehalfop':
                 # /mode #channel -h user
@@ -397,8 +371,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEHALFOP: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'voice':
                 # /mode #channel +v user
@@ -424,8 +396,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd VOICE: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} voice [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'devoice':
                 # /mode #channel -v user
@@ -451,8 +421,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEVOICE: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'ban':
                 # .ban #channel nickname
@@ -469,8 +437,6 @@ class Command():
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd BAN: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} ban [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'unban':
                 # .unban #channel nickname
@@ -483,12 +449,9 @@ class Command():
 
                     self.Irc.send2socket(f":{service_id} MODE {sentchannel} -b {nickname}!*@*")
                     self.Logs.debug(f'{fromuser} has unbanned {nickname} from {sentchannel}')
-
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd UNBAN: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} unban [#SALON] [NICKNAME]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'kick':
                 # .kick #channel nickname reason
@@ -507,12 +470,9 @@ class Command():
 
                     self.Irc.send2socket(f":{service_id} KICK {sentchannel} {nickname} {final_reason}")
                     self.Logs.debug(f'{fromuser} has kicked {nickname} from {sentchannel} : {final_reason}')
-
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd KICK: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} kick [#SALON] [NICKNAME] [REASON]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'kickban':
                 # .kickban #channel nickname reason
@@ -532,12 +492,9 @@ class Command():
                     self.Irc.send2socket(f":{service_id} KICK {sentchannel} {nickname} {final_reason}")
                     self.Irc.send2socket(f":{service_id} MODE {sentchannel} +b {nickname}!*@*")
                     self.Logs.debug(f'{fromuser} has kicked and banned {nickname} from {sentchannel} : {final_reason}')
-
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd KICKBAN: {str(e)}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} kickban [#SALON] [NICKNAME] [REASON]')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'join':
 
@@ -553,8 +510,6 @@ class Command():
 
                 except IndexError as ie:
                     self.Logs.error(f'{ie}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'part':
 
@@ -574,8 +529,6 @@ class Command():
 
                 except IndexError as ie:
                     self.Logs.error(f'{ie}')
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'umode':
                 try:
@@ -583,62 +536,6 @@ class Command():
                     nickname = str(cmd[1])
                     umode = str(cmd[2])
 
-                    self.Irc.send2socket(f':{dnickname} SVSMODE {nickname} {umode}')
+                    self.send2socket(f':{dnickname} SVSMODE {nickname} {umode}')
                 except KeyError as ke:
-                    self.Base.logs.error(ke)
+                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'svsjoin':
-                try:
-                    # .svsjoin nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
-                    if len(cmd) != 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSJOIN nickname #channel')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SVSJOIN {nickname} {channel}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSJOIN nickname #channel')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'svspart':
-                try:
-                    # .svspart nickname #channel
-                    nickname = str(cmd[1])
-                    channel = str(cmd[2])
-                    if len(cmd) != 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSPART nickname #channel')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SVSPART {nickname} {channel}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSPART nickname #channel')
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'svsnick':
-                try:
-                    # .svsnick nickname newnickname
-                    nickname = str(cmd[1])
-                    newnickname = str(cmd[2])
-                    unixtime = self.Base.get_unixtime()
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : This nickname do not exist')
-                        return None
-
-                    if len(cmd) != 3:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSNICK nickname newnickname')
-                        return None
-
-                    self.Irc.send2socket(f':{self.Config.SERVEUR_ID} SVSNICK {nickname} {newnickname} {unixtime}')
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : /msg {dnickname} SVSNICK nickname newnickname')
-                    self.Logs.warning(f'Unknown Error: {str(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
@@ -144,9 +140,6 @@ class Defender():
         self.Base.create_thread(func=self.thread_psutil_scan)
         self.Base.create_thread(func=self.thread_reputation_timer)
 
-        if self.ModConfig.reputation == 1:
-            self.Irc.send2socket(f":{self.Config.SERVICE_ID} SAMODE {self.Config.SALON_JAIL} +{self.Config.SERVICE_UMODES} {self.Config.SERVICE_NICKNAME}")
-
         return None
 
     def __set_commands(self, commands:dict[int, list[str]]) -> None:
@@ -230,11 +223,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
@@ -494,7 +487,6 @@ class Defender():
                     if self.get_user_uptime_in_minutes(user.uid) >= reputation_timer and int(user.score) <= int(reputation_seuil):
                         self.Irc.send2socket(f":{service_id} PRIVMSG {dchanlog} :[{color_red} REPUTATION {color_black}] : Action sur {user.nickname} aprés {str(reputation_timer)} minutes d'inactivité")
                         self.Irc.send2socket(f":{service_id} KILL {user.nickname} After {str(reputation_timer)} minutes of inactivity you should reconnect and type the password code ")
-                        self.Irc.send2socket(f":{self.Config.SERVEUR_LINK} REPUTATION {user.ip} 0")
 
                         self.Logs.info(f"Nickname: {user.nickname} KILLED after {str(reputation_timer)} minutes of inactivity")
                         uid_to_clean.append(user.uid)
@@ -609,38 +601,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 +633,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 +655,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 +684,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 +698,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 +727,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 +747,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 +763,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 +784,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 +794,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 +810,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 +828,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 +837,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 +858,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 +868,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 +887,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 +904,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 +922,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 +936,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()
@@ -1004,10 +946,6 @@ class Defender():
 
         match cmd[1]:
 
-            case 'EOS':
-                if self.Irc.INIT == 0:
-                    self.Irc.send2socket(f":{service_id} SAMODE {self.Config.SALON_JAIL} +{self.Config.SERVICE_UMODES} {self.Config.SERVICE_NICKNAME}")
-
             case 'REPUTATION':
                 # :001 REPUTATION 91.168.141.239 118
                 try:
@@ -1020,6 +958,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 +997,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 +1011,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 +1036,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 +1059,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 +1235,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 +1573,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:

mods/mod_test.py

@@ -152,4 +152,4 @@ class Test():
                     self.Logs.debug(f"Test logs ready")
 
                 except Exception as err:
-                    self.Logs.error(f"Unknown Error: {err}")
+                    self.Logs.error(f"{err}")

mods/mod_votekick.py

@@ -48,7 +48,8 @@ class Votekick():
 
         # Créer les nouvelles commandes du module
         self.commands_level = {
-            0: ['vote']
+            0: ['vote'],
+            1: ['activate', 'deactivate', 'submit', 'vote_stat', 'vote_verdict', 'vote_cancel']
         }
 
         # Init the module
@@ -59,7 +60,6 @@ class Votekick():
 
     def __init_module(self) -> None:
 
-        # Add admin object to retrieve admin users
         self.Admin = self.Irc.Admin
 
         self.__set_commands(self.commands_level)
@@ -264,17 +264,6 @@ class Votekick():
         match command:
             case 'vote':
                 option = str(cmd[1]).lower()
-
-                if len(command) == 1:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote activate #channel')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote deactivate #channel')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote +')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote -')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote cancel')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote status')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote submit nickname')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote verdict')
-
                 match option:
 
                     case 'activate':
@@ -483,13 +472,3 @@ class Votekick():
                             self.Logs.error(f'{err}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} {command} {option}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :Exemple /msg {dnickname} {command} {option}')
-
-                    case _:
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote activate #channel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote deactivate #channel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote +')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote -')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote cancel')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote status')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote submit nickname')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :/msg {dnickname} vote verdict')

version.json

@@ -1,3 +1,3 @@
 {
-    "version": "5.2.5"
+    "version": "5.1.5"
 }