Merge pull request #36 from adator85/dev

Dev

.gitignore

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

README.md

@@ -1,4 +1,9 @@
 # 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.
@@ -9,9 +14,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: Attribuer ou retirer les droits d'opérateur.
+        Op/Deop/Opall/Deopall: Attribuer ou retirer les droits d'opérateur.
         Halfop/Dehalfop: Attribuer ou retirer les droits
-        Voice/Devoice: Attribuer ou retirer les droits de voix.
+        Voice/Devoice/VoiceAll/DevoiceAll: Attribuer ou retirer les droits de voix.
 
     Système de quarantaine:
         Mise en quarantaine: Isoler temporairement un utilisateur dans un canal privé.
@@ -25,6 +30,7 @@ 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:
@@ -60,6 +66,7 @@ Pour Les prochains lancement de defender vous devez utiliser la commande suivant
         SERVEUR_PASSWORD: Mot de passe d'enregistrement du service sur le serveur IRC.
         SERVEUR_ID: Identifiant unique du service.
         SERVEUR_SSL: Active la connexion SSL sécurisée au serveur IRC (true/false).
+
     SERVICE (Service)
         SERVICE_NAME: Nom du service IRC.
         SERVICE_NICKNAME: Surnom utilisé par le service sur le serveur IRC.
@@ -72,33 +79,44 @@ Pour Les prochains lancement de defender vous devez utiliser la commande suivant
         SERVICE_CMODES: Modes de canal appliqués aux canaux rejoints par le service.
         SERVICE_UMODES: Modes utilisateur appliqués au service.
         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.
         PASSWORD: Mot de passe de l'administrateur du service.
+
     CANAUX (Canaux)
         SALON_JAIL: Canal utilisé comme prison pour les utilisateurs sanctionnés.
         SALON_JAIL_MODES: Modes appliqués au canal de prison.
         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.
+
     SCANNER (Scanner)
         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.
         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).
+
     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 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.
+        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.
-
-    Attention
 
+# \\!/ 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).

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
+from base64 import b64decode, b64encode
 from datetime import datetime
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
@@ -9,10 +9,6 @@ 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
@@ -222,7 +218,7 @@ class Base:
         """Supprime les modules de la base de données
 
         Args:
-            cmd (str): le module a enregistrer
+            cmd (str): le module a supprimer
         """
         insert_cmd_query = f"DELETE FROM {self.Config.table_module} WHERE module_name = :module_name"
         mes_donnees = {'module_name': module_name}
@@ -311,7 +307,7 @@ class Base:
 
     def db_update_core_config(self, module_name:str, dataclassObj: object, param_key:str, param_value: str) -> bool:
 
-        core_table = 'core_config'
+        core_table = self.Config.table_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")
@@ -334,6 +330,10 @@ 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)
 
@@ -682,6 +682,17 @@ 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.
@@ -749,4 +760,4 @@ class Base:
         except TypeError as te:
             self.logs.error(f'TypeError: [{channelToCheck}] - {te}')
         except Exception as err:
-            self.logs.error(f'TypeError: {err}')
+            self.logs.error(f'Error Not defined: {err}')

core/connection.py

@@ -1,4 +1,4 @@
-import socket, ssl, time
+import socket, ssl
 from ssl import SSLSocket
 from core.loadConf import Config
 from core.Model import Clones
@@ -186,15 +186,17 @@ class Connection:
                         nickname = fullname.split('!')[0].replace(':','')
                         if nickname == self.Config.SERVICE_NICKNAME:
                             command = str(response[3]).replace(':','')
+
                             if command == 'KILL':
                                 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])
@@ -202,7 +204,6 @@ class Connection:
 
                                 self.send2socket(f"PRIVMSG {clone_channel} :{final_message}")
 
-
         except UnicodeEncodeError:
             for data in cmd:
                 response = data.decode(self.CHARSET[1],'replace').split()

core/installation.py

@@ -36,8 +36,6 @@ class Install:
             if self.skip_install:
                 return None
 
-            print(f'Configuration loaded : {self.config}')
-
             # Sinon tester les dependances python et les installer avec pip
             if self.do_install():
 
@@ -133,11 +131,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_current_version} ##")
+            print(f"## Your python version must be greather than or equal to {self.config.python_min_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_current_version} ##")
+            print(f"## Your python version must be greather than or equal to {self.config.python_min_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
+import ssl, re, importlib, sys, time, threading, socket, traceback
 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.load_existing_modules()                        # Charger les modules existant dans la base de données
             self.__join_saved_channels()                        # Join existing channels
+            self.load_existing_modules()                        # Charger les modules existant dans la base de données
 
             while self.signal:
                 try:
@@ -131,6 +131,7 @@ class Irc:
 
                         self.__create_socket()
                         self.__link(self.IrcSocket)
+                        self.__join_saved_channels()
                         self.load_existing_modules()
                         self.RESTART = 0
 
@@ -175,6 +176,7 @@ 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 
@@ -212,7 +214,8 @@ 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))
 
@@ -272,14 +275,20 @@ class Irc:
                 response = data.decode(self.CHARSET[0]).split()
                 self.cmd(response)
 
-        except UnicodeEncodeError:
+        except UnicodeEncodeError as ue:
             for data in responses:
                 response = data.decode(self.CHARSET[1],'replace').split()
                 self.cmd(response)
-        except UnicodeDecodeError:
+            self.Base.logs.error(f'UnicodeEncodeError: {ue}')
+            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}")
 
@@ -444,6 +453,7 @@ 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}")
@@ -574,7 +584,6 @@ 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):
@@ -585,35 +594,39 @@ class Irc:
         
         return None
 
-    def cmd(self, data:list) -> None:
+    def cmd(self, data: list[str]) -> None:
+        """Parse server response
+
+        Args:
+            data (list[str]): Server response splitted in a list
+        """
         try:
+            original_response: list[str] = data.copy()
 
-            cmd_to_send:list[str] = data.copy()
+            interm_response: list[str] = data.copy()
-            cmd = data.copy()
+            """This the original without first value"""
 
-            cmd_to_debug = data.copy()
+            interm_response.pop(0)
-            cmd_to_debug.pop(0)
 
-            if len(cmd) == 0 or len(cmd) == 1:
+            if len(original_response) == 0 or len(original_response) == 1:
-                self.Base.logs.warning(f'Size ({str(len(cmd))}) - {cmd}')
+                self.Base.logs.warning(f'Size ({str(len(original_response))}) - {original_response}')
                 return False
 
-            # self.debug(cmd_to_debug)
+            if len(original_response) == 7:
-            if len(data) == 7:
+                if original_response[2] == 'PRIVMSG' and original_response[4] == ':auth':
-                if data[2] == 'PRIVMSG' and data[4] == ':auth':
+                    data_copy = original_response.copy()
-                    data_copy = data.copy()
                     data_copy[6] = '**********'
                     self.Base.logs.debug(data_copy)
                 else:
-                    self.Base.logs.debug(data)
+                    self.Base.logs.debug(original_response)
             else:
-                self.Base.logs.debug(data)
+                self.Base.logs.debug(original_response)
 
-            match cmd[0]:
+            match original_response[0]:
 
                 case 'PING':
                     # Sending PONG response to the serveur
-                    pong = str(cmd[1]).replace(':','')
+                    pong = str(original_response[1]).replace(':','')
                     self.send2socket(f"PONG :{pong}")
                     return None
 
@@ -622,19 +635,19 @@ class Irc:
                     # 'PREFIX=(qaohv)~&@%+', 'SID=001', 'MLOCK', 'TS=1703793941', 'EXTSWHOIS']
 
                     # GET SERVER ID HOST
-                    if len(cmd) > 5:
+                    if len(original_response) > 5:
-                        if '=' in cmd[5]:
+                        if '=' in original_response[5]:
-                            serveur_hosting_id = str(cmd[5]).split('=')
+                            serveur_hosting_id = str(original_response[5]).split('=')
                             self.HSID = serveur_hosting_id[1]
                             return False
 
                 case _:
                     pass
 
-            if len(cmd) < 2:
+            if len(original_response) < 2:
                 return False
 
-            match cmd[1]:
+            match original_response[1]:
 
                 case 'SLOG':
                     # self.Base.scan_ports(cmd[7])
@@ -645,20 +658,18 @@ class Irc:
                 case 'REPUTATION':
                     # :001 REPUTATION 91.168.141.239 118
                     try:
-                        # if self.Config.ABUSEIPDB == 1:
+                        self.first_connexion_ip = original_response[2]
-                        #     self.Base.create_thread(self.abuseipdb_scan, (cmd[2], ))
-                        self.first_connexion_ip = cmd[2]
 
                         self.first_score = 0
-                        if str(cmd[3]).find('*') != -1:
+                        if str(original_response[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(cmd[3]).replace('*',''))
+                            self.first_score = int(str(original_response[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(cmd[3])
+                            self.first_score = int(original_response[3])
 
                         # Possibilité de déclancher les bans a ce niveau.
                     except IndexError as ie:
@@ -681,7 +692,7 @@ class Irc:
 
                 case 'EOS':
 
-                    hsid = str(cmd[0]).replace(':','')
+                    hsid = str(original_response[0]).replace(':','')
                     if hsid == self.HSID:
                         if self.INIT == 1:
                             current_version = self.Config.current_version
@@ -691,10 +702,6 @@ 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}        ")
@@ -726,15 +733,15 @@ class Irc:
                 case _:
                     pass
 
-            if len(cmd) < 3:
+            if len(original_response) < 3:
                 return False
 
-            match cmd[2]:
+            match original_response[2]:
 
                 case 'QUIT':
                     # :001N1WD7L QUIT :Quit: free_znc_1
-                    cmd.pop(0)
+
-                    uid_who_quit = str(cmd[0]).replace(':', '')
+                    uid_who_quit = str(interm_response[0]).replace(':', '')
                     self.User.delete(uid_who_quit)
                     self.Channel.delete_user_from_all_channel(uid_who_quit)
 
@@ -746,10 +753,8 @@ class Irc:
                     # ['@unrealircd.org/geoip=FR;unrealircd.org/', ':001OOU2H3', 'NICK', 'WebIrc', '1703795844']
                     # Changement de nickname
 
-                    # Supprimer la premiere valeur de la liste
+                    uid = str(interm_response[0]).replace(':','')
-                    cmd.pop(0)
+                    newnickname = interm_response[2]
-                    uid = str(cmd[0]).replace(':','')
-                    newnickname = cmd[2]
                     self.User.update(uid, newnickname)
 
                 case 'MODE':
@@ -764,24 +769,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(cmd[3]).lower()
+                    channel = str(interm_response[3]).lower()
-                    len_cmd = len(cmd)
+                    len_cmd = len(interm_response)
                     list_users:list = []
                     occurence = 0
                     start_boucle = 0
 
                     # Trouver le premier user
                     for i in range(len_cmd):
-                        s: list = re.findall(fr':', cmd[i])
+                        s: list = re.findall(fr':', interm_response[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(cmd)):
+                    for i in range(start_boucle, len(interm_response)):
-                        parsed_UID = str(cmd[i])
+                        parsed_UID = str(interm_response[i])
                         # pattern = fr'[:|@|%|\+|~|\*]*'
                         # pattern = fr':'
                         # parsed_UID = re.sub(pattern, '', parsed_UID)
@@ -799,29 +804,31 @@ 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']
-                    uid = str(cmd[1]).replace(':','')
+                    try:
-                    channel = str(cmd[3]).lower()
+                        uid = str(interm_response[0]).replace(':','')
+                        channel = str(interm_response[2]).lower()
                         self.Channel.delete_user_from_channel(channel, uid)
 
-                    pass
+                    except IndexError as ie:
+                        self.Base.logs.error(f'Index Error: {ie}')
 
                 case 'UID':
                     # ['@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', 
                     # '001HB8G04', '0', '+iwxz', 'Clk-A62F1D18.vps.ovh.net', 'Clk-A62F1D18.vps.ovh.net', 'MyZBwg==', ':...']
-                    if 'webirc' in cmd[0]:
+                    if 'webirc' in original_response[0]:
                         isWebirc = True
                     else:
                         isWebirc = False
 
-                    uid = str(cmd[8])
+                    uid = str(original_response[8])
-                    nickname = str(cmd[3])
+                    nickname = str(original_response[3])
-                    username = str(cmd[6])
+                    username = str(original_response[6])
-                    hostname = str(cmd[7])
+                    hostname = str(original_response[7])
-                    umodes = str(cmd[10])
+                    umodes = str(original_response[10])
-                    vhost = str(cmd[11])
+                    vhost = str(original_response[11])
                     if not 'S' in umodes:
-                        remote_ip = self.Base.decode_ip(str(cmd[13]))
+                        remote_ip = self.Base.decode_ip(str(original_response[13]))
                     else:
                         remote_ip = '127.0.0.1'
 
@@ -843,18 +850,19 @@ class Irc:
                     )
 
                     for classe_name, classe_object in self.loaded_classes.items():
-                        classe_object.cmd(cmd_to_send)
+                        classe_object.cmd(original_response)
 
                 case 'PRIVMSG':
                     try:
                         # Supprimer la premiere valeur
-                        cmd.pop(0)
+                        cmd = interm_response.copy()
+
                         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('.','') == ':auth':
+                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace(self.Config.SERVICE_PREFIX,'') == ':auth':
                                 cmd_copy = cmd.copy()
                                 cmd_copy[5] = '**********'
                                 self.Base.logs.info(cmd_copy)
@@ -911,11 +919,11 @@ class Irc:
                                     return False
 
                                 if not arg[0].lower() in self.commands:
-                                    self.debug(f"This command {arg[0]} is not available")
+                                    self.Base.logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
                                     return False
 
                                 cmd_to_send = convert_to_string.replace(':','')
-                                self.Base.log_cmd(self.User.get_nickname(user_trigger), cmd_to_send)
+                                self.Base.log_cmd(user_trigger, cmd_to_send)
 
                                 fromchannel = None
                                 if len(arg) >= 2:
@@ -929,15 +937,26 @@ class Irc:
                 case _:
                     pass
 
-            if cmd[2] != 'UID':
+            if original_response[2] != 'UID':
                 # Envoyer la commande aux classes dynamiquement chargées
                 for classe_name, classe_object in self.loaded_classes.items():
-                    classe_object.cmd(cmd_to_send)
+                    classe_object.cmd(original_response)
 
         except IndexError as ie:
-            self.Base.logs.error(f"{ie} / {cmd} / length {str(len(cmd))}")
+            self.Base.logs.error(f"{ie} / {original_response} / length {str(len(original_response))}")
 
     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
@@ -1283,10 +1302,6 @@ 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:
@@ -1301,9 +1316,6 @@ 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:

core/loadConf.py

@@ -94,7 +94,7 @@ class ConfigDataModel:
     GLINE_DURATION: str
     """Gline duration"""
 
-    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]                                         # Le niveau des logs DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50
+    DEBUG_LEVEL:Literal[10, 20, 30, 40, 50]
     """Logs level: DEBUG 10 | INFO 20 | WARNING 30 | ERROR 40 | CRITICAL 50"""
 
     CONFIG_COLOR: dict[str, str]

mods/mod_command.py

@@ -35,7 +35,9 @@ class Command():
         # Create module commands (Mandatory)
         self.commands_level = {
             1: ['join', 'part'],
-            2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 'unban','kick', 'kickban', 'umode']
+            2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 
+                'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
+                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick']
         }
 
         # Init the module
@@ -178,6 +180,8 @@ 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:
@@ -185,8 +189,11 @@ 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)
                     set_mode = 'v'
                     mode:str = ''
@@ -202,8 +209,13 @@ class Command():
                                 self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
                                 mode = ''
                                 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)
                     set_mode = 'o'
                     mode:str = ''
@@ -219,6 +231,10 @@ class Command():
                                 self.Irc.send2socket(f":{service_id} MODE {fromchannel} +{mode} {users}")
                                 mode = ''
                                 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
@@ -246,6 +262,8 @@ 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
@@ -271,6 +289,8 @@ 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
@@ -296,6 +316,8 @@ 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
@@ -321,6 +343,8 @@ 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
@@ -346,6 +370,8 @@ 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
@@ -371,6 +397,8 @@ 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
@@ -396,6 +424,8 @@ 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
@@ -421,6 +451,8 @@ 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
@@ -437,6 +469,8 @@ 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
@@ -449,9 +483,12 @@ 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
@@ -470,9 +507,12 @@ 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
@@ -492,9 +532,12 @@ 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':
 
@@ -510,6 +553,8 @@ 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':
 
@@ -529,6 +574,8 @@ 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:
@@ -536,6 +583,62 @@ class Command():
                     nickname = str(cmd[1])
                     umode = str(cmd[2])
 
-                    self.send2socket(f':{dnickname} SVSMODE {nickname} {umode}')
+                    self.Irc.send2socket(f':{dnickname} SVSMODE {nickname} {umode}')
                 except KeyError as 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,6 +4,7 @@ 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
@@ -107,12 +108,19 @@ class Defender():
         # self.join_saved_channels()
 
         self.timeout = self.Config.API_TIMEOUT
+
+        self.abuseipdb_UserModel: list[User.UserModel] = []
+        self.freeipapi_UserModel: list[User.UserModel] = []
+        self.cloudfilt_UserModel: list[User.UserModel] = []
+        self.psutil_UserModel: list[User.UserModel]    = []
+        self.localscan_UserModel: list[User.UserModel] = []
+
         # Listes qui vont contenir les ip a scanner avec les différentes API
-        self.freeipapi_remote_ip:list = []
+        # self.freeipapi_remote_ip:list = []
-        self.cloudfilt_remote_ip:list = []
+        # self.cloudfilt_remote_ip:list = []
-        self.abuseipdb_remote_ip:list = []
+        # self.abuseipdb_remote_ip:list = []
-        self.psutil_remote_ip:list    = []
+        # self.psutil_remote_ip:list    = []
-        self.localscan_remote_ip:list = []
+        # self.localscan_remote_ip:list = []
 
         # Variables qui indique que les threads sont en cours d'éxecutions
         self.abuseipdb_isRunning:bool       = True
@@ -140,6 +148,9 @@ 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:
@@ -487,6 +498,7 @@ 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)
@@ -601,23 +613,33 @@ class Defender():
 
         return None
 
-    def scan_ports(self, remote_ip: str) -> None:
+    def scan_ports(self, userModel: User.UserModel) -> None:
         """local_scan
 
         Args:
             remote_ip (str): _description_
         """
+        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
 
         for port in self.Config.PORTS_TO_SCAN:
+            try:
                 newSocket = ''
                 newSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM or socket.SOCK_NONBLOCK)
                 newSocket.settimeout(0.5)
-            try:
+
                 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}]")
+
+                fullname = f'{nickname}!{username}@{hostname}'
+
+                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)
@@ -634,20 +656,18 @@ class Defender():
                 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 ip in self.localscan_remote_ip:
+                for user in self.localscan_UserModel:
-                    self.scan_ports(ip)
+                    self.scan_ports(user)
-                    list_to_remove.append(ip)
+                    list_to_remove.append(user)
                     time.sleep(1)
 
-                for ip_to_remove in list_to_remove:
+                for user_model in list_to_remove:
-                    self.localscan_remote_ip.remove(ip_to_remove)
+                    self.localscan_UserModel.remove(user_model)
 
                 time.sleep(1)
 
@@ -655,7 +675,7 @@ class Defender():
         except ValueError as ve:
             self.Logs.warning(f"thread_local_scan Error : {ve}")
 
-    def get_ports_connexion(self, remote_ip: str) -> list[int]:
+    def get_ports_connexion(self, userModel: User.UserModel) -> list[int]:
         """psutil_scan for Linux
 
         Args:
@@ -665,13 +685,20 @@ class Defender():
             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 {remote_ip} using ports : {str(matching_ports)}")
+            self.Logs.info(f"Connexion of {fullname} ({remote_ip}) using ports : {str(matching_ports)}")
 
             return matching_ports
 
@@ -684,13 +711,13 @@ class Defender():
             while self.psutil_isRunning:
 
                 list_to_remove:list = []
-                for ip in self.psutil_remote_ip:
+                for user in self.psutil_UserModel:
-                    self.get_ports_connexion(ip)
+                    self.get_ports_connexion(user)
-                    list_to_remove.append(ip)
+                    list_to_remove.append(user)
                     time.sleep(1)
 
-                for ip_to_remove in list_to_remove:
+                for user_model in list_to_remove:
-                    self.psutil_remote_ip.remove(ip_to_remove)
+                    self.psutil_UserModel.remove(user_model)
 
                 time.sleep(1)
 
@@ -698,16 +725,22 @@ class Defender():
         except ValueError as ve:
             self.Logs.warning(f"thread_psutil_scan Error : {ve}")
 
-    def abuseipdb_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
+    def abuseipdb_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
         """Analyse l'ip avec AbuseIpDB
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
-            remote_ip (_type_): l'ip a analyser
+            userModel (UserModel): l'objet User qui contient l'ip
 
         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:
@@ -727,11 +760,12 @@ class Defender():
             'Key': self.abuseipdb_key
         }
 
+        try:
             response = requests.request(method='GET', url=url, headers=headers, params=querystring, timeout=self.timeout)
 
             # Formatted output
             decodedResponse = json.loads(response.text)
-        try:
+
             if not 'data' in decodedResponse:
                 return None
 
@@ -747,7 +781,10 @@ class Defender():
             color_red = self.Config.CONFIG_COLOR['rouge']
             color_black = self.Config.CONFIG_COLOR['noire']
 
-            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'])}")
+            # pseudo!ident@host
+            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")
@@ -763,6 +800,8 @@ 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:
@@ -770,13 +809,13 @@ class Defender():
             while self.abuseipdb_isRunning:
 
                 list_to_remove: list = []
-                for ip in self.abuseipdb_remote_ip:
+                for user in self.abuseipdb_UserModel:
-                    self.abuseipdb_scan(ip)
+                    self.abuseipdb_scan(user)
-                    list_to_remove.append(ip)
+                    list_to_remove.append(user)
                     time.sleep(1)
 
-                for ip_to_remove in list_to_remove:
+                for user_model in list_to_remove:
-                    self.abuseipdb_remote_ip.remove(ip_to_remove)
+                    self.abuseipdb_UserModel.remove(user_model)
 
                 time.sleep(1)
 
@@ -784,7 +823,7 @@ class Defender():
         except ValueError as ve:
                 self.Logs.error(f"thread_abuseipdb_scan Error : {ve}")
 
-    def freeipapi_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
+    def freeipapi_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
         """Analyse l'ip avec Freeipapi
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
@@ -794,6 +833,12 @@ 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:
@@ -810,11 +855,12 @@ class Defender():
             'Accept': 'application/json',
         }
 
+        try:
             response = requests.request(method='GET', url=url, headers=headers, timeout=self.timeout)
 
             # Formatted output
             decodedResponse = json.loads(response.text)
-        try:
+
             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.')
@@ -828,7 +874,10 @@ class Defender():
                 'isProxy': decodedResponse['isProxy'] if 'isProxy' in decodedResponse else None
             }
 
-            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'])}")
+            # pseudo!ident@host
+            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")
@@ -837,20 +886,22 @@ 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 = []
+                list_to_remove: list[User.UserModel] = []
-                for ip in self.freeipapi_remote_ip:
+                for user in self.freeipapi_UserModel:
-                    self.freeipapi_scan(ip)
+                    self.freeipapi_scan(user)
-                    list_to_remove.append(ip)
+                    list_to_remove.append(user)
                     time.sleep(1)
 
-                for ip_to_remove in list_to_remove:
+                for user_model in list_to_remove:
-                    self.freeipapi_remote_ip.remove(ip_to_remove)
+                    self.freeipapi_UserModel.remove(user_model)
 
                 time.sleep(1)
 
@@ -858,7 +909,7 @@ class Defender():
         except ValueError as ve:
             self.Logs.error(f"thread_freeipapi_scan Error : {ve}")
 
-    def cloudfilt_scan(self, remote_ip:str) -> Union[dict[str, any], None]:
+    def cloudfilt_scan(self, userModel: User.UserModel) -> Union[dict[str, any], None]:
         """Analyse l'ip avec cloudfilt
            Cette methode devra etre lancer toujours via un thread ou un timer.
         Args:
@@ -868,6 +919,12 @@ 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:
@@ -887,11 +944,10 @@ class Defender():
             'key': self.cloudfilt_key
         }
 
+        try:
             response = requests.post(url=url, data=data)
-
             # Formatted output
             decodedResponse = json.loads(response.text)
-        try:
             status_code = response.status_code
             if status_code != 200:
                 self.Logs.warning(f'Error connecting to cloudfilt API | Code: {str(status_code)}')
@@ -904,7 +960,10 @@ class Defender():
                 'host': decodedResponse['host'] if 'host' in decodedResponse else None
             }
 
-            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'])}")
+            # pseudo!ident@host
+            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")
@@ -922,13 +981,13 @@ class Defender():
             while self.cloudfilt_isRunning:
 
                 list_to_remove:list = []
-                for ip in self.cloudfilt_remote_ip:
+                for user in self.cloudfilt_UserModel:
-                    self.cloudfilt_scan(ip)
+                    self.cloudfilt_scan(user)
-                    list_to_remove.append(ip)
+                    list_to_remove.append(user)
                     time.sleep(1)
 
-                for ip_to_remove in list_to_remove:
+                for user_model in list_to_remove:
-                    self.cloudfilt_remote_ip.remove(ip_to_remove)
+                    self.cloudfilt_UserModel.remove(user_model)
 
                 time.sleep(1)
 
@@ -946,6 +1005,10 @@ 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:
@@ -958,22 +1021,6 @@ 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}')
@@ -997,6 +1044,15 @@ 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
@@ -1574,9 +1630,10 @@ class Defender():
                         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} : HOSTNAME         : {UserObject.hostname}')
-                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : IP               : {UserObject.remote_ip}')
-                        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} : IP               : {UserObject.remote_ip}')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : WebIrc           : {UserObject.isWebirc}')
+                        self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : REPUTATION       : {UserObject.score_connexion}')
                         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"{err}")
+                    self.Logs.error(f"Unknown Error: {err}")

mods/mod_votekick.py

@@ -48,8 +48,7 @@ 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
@@ -60,6 +59,7 @@ 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,6 +264,17 @@ 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':
@@ -472,3 +483,13 @@ 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.1.5"
+    "version": "5.2.0"
 }