Merge pull request #7 from adator85/dev

Fix KeyError when a user change nickname

README.md

@@ -26,6 +26,7 @@ Lancement de Defender :
 # VERSION 1
 
     [02.01.2024]
+        - Rajout de l'activation de la commande flood
         - Les deux variables RESTART et INIT ont été déplacées vers le module Irc
         - Nouvelle class Install:
             - Le programme va vérifier si les 3 librairies sont installées (SQLAlchemy & requests & psutil)

core/exemple_configuration.py

@@ -6,7 +6,7 @@ import os
 
 class Config:
 
-    DEFENDER_VERSION = '1.1.0'                              # MAJOR.MINOR.BATCH
+    DEFENDER_VERSION = '3.2.2'                              # MAJOR.MINOR.BATCH
     DEFENDER_DB_PATH = 'db' + os.sep                        # Séparateur en fonction de l'OS
     DEFENDER_DB_NAME = 'defender'                           # Le nom de la base de données principale
     SERVICE_NAME = 'defender'                               # Le nom du service

core/irc.py

@@ -27,7 +27,7 @@ class Irc:
         self.commands_level = {
             0: ['help', 'auth', 'copyright'],
             1: ['load','reload','unload', 'deauth', 'uptime'],
-            2: ['show_sessions','show_modules', 'show_timers', 'show_threads'],
+            2: ['show_modules', 'show_timers', 'show_threads', 'sentinel'],
             3: ['quit', 'restart','addaccess','editaccess', 'delaccess']
         }
 
@@ -348,6 +348,8 @@ class Irc:
         except ModuleNotFoundError as moduleNotFound:
             self.debug(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}")
+        except:
+            self.debug(f"Something went wrong with a module you want to load")
 
     def insert_db_uid(self, uid:str, nickname:str, username:str, hostname:str, umodes:str, vhost:str, isWebirc: bool) -> None:
 
@@ -603,8 +605,9 @@ class Irc:
         return None
 
     def cmd(self, data:list) -> None:
-        try: 
+        try:
-            cmd = data
+            cmd_to_send:list[str] = data.copy()
+            cmd = data.copy()
 
             if len(cmd) == 0 or len(cmd) == 1:
                 return False
@@ -738,6 +741,9 @@ class Irc:
 
                     self.insert_db_uid(uid, nickname, username, hostname, umodes, vhost, isWebirc)
 
+                    for classe_name, classe_object in self.loaded_classes.items():
+                        classe_object.cmd(cmd_to_send)
+
                 case 'PRIVMSG':
                     try:
                         # Supprimer la premiere valeur
@@ -809,9 +815,10 @@ class Irc:
                 case _:
                     pass
 
-            # Envoyer la commande aux classes dynamiquement chargées
+            if cmd[2] != 'UID':
-            for classe_name, classe_object in self.loaded_classes.items():
+                # Envoyer la commande aux classes dynamiquement chargées
-                classe_object.cmd(cmd)
+                for classe_name, classe_object in self.loaded_classes.items():
+                    classe_object.cmd(cmd_to_send)
 
         except IndexError as ie:
             self.debug(f"IRC CMD -> IndexError : {ie} - {cmd} - length {str(len(cmd))}")
@@ -1022,37 +1029,12 @@ class Irc:
 
             case 'unload':
                 # unload mod_dktmb
-                module_name = str(cmd[1]).lower()                              # Le nom du module. exemple: mod_defender
+                try:
-                class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
+                    module_name = str(cmd[1]).lower()                              # Le nom du module. exemple: mod_defender
+                    class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
 
-                if class_name in self.loaded_classes:
-
-                    for level, command in self.loaded_classes[class_name].commands_level.items():
-                        # Supprimer la commande de la variable commands
-                        for c in self.loaded_classes[class_name].commands_level[level]:
-                            self.commands.remove(c)
-                            self.commands_level[level].remove(c)
-
-                    del self.loaded_classes[class_name]
-
-                    # Supprimer le module de la base de données
-                    self.Base.db_delete_module(module_name)
-
-                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
-
-            case 'reload':
-                # reload mod_dktmb
-                module_name = str(cmd[1]).lower()                                          # ==> mod_defender
-                class_name = module_name.split('_')[1].capitalize()                        # ==> Defender
-
-                if 'mods.' + module_name in sys.modules:
-                    self.debug('Module Already Loaded ... reload the module ...')
-                    the_module = sys.modules['mods.' + module_name]
-                    importlib.reload(the_module)
-                    
-                    # Supprimer la class déja instancier
                     if class_name in self.loaded_classes:
-                    # Supprimer les commandes déclarer dans la classe
+
                         for level, command in self.loaded_classes[class_name].commands_level.items():
                             # Supprimer la commande de la variable commands
                             for c in self.loaded_classes[class_name].commands_level[level]:
@@ -1061,14 +1043,45 @@ class Irc:
 
                         del self.loaded_classes[class_name]
 
-                    my_class = getattr(the_module, class_name, None)
+                        # Supprimer le module de la base de données
-                    new_instance = my_class(self.ircObject)
+                        self.Base.db_delete_module(module_name)
-                    self.loaded_classes[class_name] = new_instance
 
-                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} rechargé")
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
-                    return False
+                except:
-                else:
+                    self.debug(f"Something went wrong with a module you want to load")
-                    self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} n'est pas chargé !")
+
+            case 'reload':
+                # reload mod_dktmb
+                try:
+                    module_name = str(cmd[1]).lower()                                          # ==> mod_defender
+                    class_name = module_name.split('_')[1].capitalize()                        # ==> Defender
+
+                    if 'mods.' + module_name in sys.modules:
+                        self.debug('Module Already Loaded ... reload the module ...')
+                        the_module = sys.modules['mods.' + module_name]
+                        importlib.reload(the_module)
+                        
+                        # Supprimer la class déja instancier
+                        if class_name in self.loaded_classes:
+                        # Supprimer les commandes déclarer dans la classe
+                            for level, command in self.loaded_classes[class_name].commands_level.items():
+                                # Supprimer la commande de la variable commands
+                                for c in self.loaded_classes[class_name].commands_level[level]:
+                                    self.commands.remove(c)
+                                    self.commands_level[level].remove(c)
+
+                            del self.loaded_classes[class_name]
+
+                        my_class = getattr(the_module, class_name, None)
+                        new_instance = my_class(self.ircObject)
+                        self.loaded_classes[class_name] = new_instance
+
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} rechargé")
+                        return False
+                    else:
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} n'est pas chargé !")
+                except:
+                    self.debug(f"Something went wrong with a module you want to reload")
 
             case 'quit':
                 try:
@@ -1141,5 +1154,21 @@ class Irc:
             case 'copyright':
                 self.send2socket(f':{dnickname} NOTICE {fromuser} : # Defender V.{self.Config.DEFENDER_VERSION} Developped by adator® and dktmb® #')
 
+            case 'sentinel':
+                # .sentinel on
+                activation = str(cmd[1]).lower()
+                service_id = self.Config.SERVICE_ID
+                
+                channel_to_dont_quit = [self.Config.SALON_JAIL, dchanlog]
+                
+                if activation == 'on':
+                    for chan in self.db_chan:
+                        if not chan in channel_to_dont_quit:
+                            self.send2socket(f":{service_id} JOIN {chan}")
+                if activation == 'off':
+                    for chan in self.db_chan:
+                        if not chan in channel_to_dont_quit:
+                            self.send2socket(f":{service_id} PART {chan}")
+
             case _:
                 pass

mods/mod_defender.py

@@ -26,7 +26,7 @@ class Defender():
             0: ['code'],
             1: ['join','part', 'info'],
             2: ['q', 'dq', 'o', 'do', 'h', 'dh', 'v', 'dv', 'b', 'ub','k', 'kb'],
-            3: ['reputation','proxy_scan', 'status', 'timer','show_reputation', 'show_users']
+            3: ['reputation','proxy_scan', 'flood', 'status', 'timer','show_reputation', 'show_users']
         }
         self.__set_commands(self.commands_level)                            # Enrigstrer les nouvelles commandes dans le code
 
@@ -45,8 +45,9 @@ class Defender():
         """
         for level, com in commands.items():
             for c in commands[level]:
-                self.Irc.commands_level[level].append(c)
+                if not c in self.Irc.commands:
-                self.Irc.commands.append(c)
+                    self.Irc.commands_level[level].append(c)
+                    self.Irc.commands.append(c)
 
         return None
 
@@ -300,7 +301,6 @@ class Defender():
             exec_query = self.Base.db_execute_query(q_insert, mes_donnees)
             pass
 
-
     def join_saved_channels(self) -> None:
 
         result = self.Base.db_execute_query("SELECT id, channel FROM def_channels")
@@ -470,13 +470,13 @@ class Defender():
         return None
 
     def flood(self, detected_user:str, channel:str) -> None:
-        
+
         if self.defConfig['flood'] == 0:
             return None
-        
+
         if not '#' in channel:
             return None
-        
+
         flood_time = self.defConfig['flood_time']
         flood_message = self.defConfig['flood_message']
         flood_timer = self.defConfig['flood_timer']
@@ -621,7 +621,7 @@ class Defender():
     def cmd(self, data:list) -> None:
 
         service_id = self.Config.SERVICE_ID                 # Defender serveur id
-        cmd = data
+        cmd = list(data).copy()
 
         if len(cmd) < 2:
             return None
@@ -656,29 +656,6 @@ class Defender():
                 find_nickname = self.Irc.get_nickname(user_trigger)
                 self.flood(find_nickname, channel)
 
-            case 'SJOIN':
-                # ['@msgid=F9B7JeHL5pj9nN57cJ5pEr;time=2023-12-28T20:47:24.305Z', ':001', 'SJOIN', '1702138958', '#welcome', ':0015L1AHL']
-                try:
-                    cmd.pop(0)
-                    parsed_chan = cmd[3]
-                    self.Irc.insert_db_chan(parsed_chan)
-
-                    if self.defConfig['reputation'] == 1:
-                        parsed_UID = cmd[4]
-                        pattern = fr'^:[@|%|\+|~|\*]*'
-                        parsed_UID = re.sub(pattern, '', parsed_UID)
-                        if parsed_UID in self.db_reputation:
-                            # print(f"====> {str(self.db_reputation)}")
-                            isWebirc = self.db_reputation[parsed_UID]['isWebirc']
-                            if self.defConfig['reputation_ban_all_chan'] == 1 and not isWebirc:
-                                if parsed_chan != self.Config.SALON_JAIL:
-                                    self.Irc.send2socket(f":{service_id} MODE {parsed_chan} +b {self.db_reputation[parsed_UID]['nickname']}!*@*")
-                                    self.Irc.send2socket(f":{service_id} KICK {parsed_chan} {self.db_reputation[parsed_UID]['nickname']}")
-
-                        self.Irc.debug(f'SJOIN parsed_uid : {parsed_UID}')
-                except KeyError as ke:
-                    self.Irc.debug(f"key error SJOIN : {ke}")
-
             case 'UID':
 
                 if self.Irc.INIT == 1:
@@ -723,6 +700,29 @@ class Defender():
                                     self.system_reputation(uid)
                                     self.Irc.debug('Démarrer le systeme de reputation')
 
+            case 'SJOIN':
+                # ['@msgid=F9B7JeHL5pj9nN57cJ5pEr;time=2023-12-28T20:47:24.305Z', ':001', 'SJOIN', '1702138958', '#welcome', ':0015L1AHL']
+                try:
+                    cmd.pop(0)
+                    parsed_chan = cmd[3]
+                    self.Irc.insert_db_chan(parsed_chan)
+
+                    if self.defConfig['reputation'] == 1:
+                        parsed_UID = cmd[4]
+                        pattern = fr'^:[@|%|\+|~|\*]*'
+                        parsed_UID = re.sub(pattern, '', parsed_UID)
+                        if parsed_UID in self.db_reputation:
+                            # print(f"====> {str(self.db_reputation)}")
+                            isWebirc = self.db_reputation[parsed_UID]['isWebirc']
+                            if self.defConfig['reputation_ban_all_chan'] == 1 and not isWebirc:
+                                if parsed_chan != self.Config.SALON_JAIL:
+                                    self.Irc.send2socket(f":{service_id} MODE {parsed_chan} +b {self.db_reputation[parsed_UID]['nickname']}!*@*")
+                                    self.Irc.send2socket(f":{service_id} KICK {parsed_chan} {self.db_reputation[parsed_UID]['nickname']}")
+
+                        self.Irc.debug(f'SJOIN parsed_uid : {parsed_UID}')
+                except KeyError as ke:
+                    self.Irc.debug(f"key error SJOIN : {ke}")
+
             case 'SLOG':
                 # self.Base.scan_ports(cmd[7])
                 cmd.pop(0)
@@ -738,21 +738,24 @@ class Defender():
             case 'NICK':
                 # :0010BS24L NICK [NEWNICK] 1697917711
                 # Changement de nickname
-                cmd.pop(0)
+                try:
-                uid = str(cmd[0]).replace(':','')
+                    cmd.pop(0)
-                oldnick = self.db_reputation[uid]['nickname']
+                    uid = str(cmd[0]).replace(':','')
-                newnickname = cmd[2]
+                    oldnick = self.db_reputation[uid]['nickname']
-                
+                    newnickname = cmd[2]
-                jail_salon = self.Config.SALON_JAIL
-                service_id = self.Config.SERVICE_ID
 
-                self.update_db_reputation(uid, newnickname)
+                    jail_salon = self.Config.SALON_JAIL
+                    service_id = self.Config.SERVICE_ID
 
-                if uid in self.db_reputation:
+                    self.update_db_reputation(uid, newnickname)
-                    for chan in self.Irc.db_chan:
+
-                        if chan != jail_salon:
+                    if uid in self.db_reputation:
-                            self.Irc.send2socket(f":{service_id} MODE {chan} -b {oldnick}!*@*")
+                        for chan in self.Irc.db_chan:
-                            self.Irc.send2socket(f":{service_id} MODE {chan} +b {newnickname}!*@*")
+                            if chan != jail_salon:
+                                self.Irc.send2socket(f":{service_id} MODE {chan} -b {oldnick}!*@*")
+                                self.Irc.send2socket(f":{service_id} MODE {chan} +b {newnickname}!*@*")
+                except KeyError as ke:
+                    self.Irc.debug(f'cmd - NICK - KeyError: {ke}')
 
             case 'QUIT':
                 # :001N1WD7L QUIT :Quit: free_znc_1
@@ -774,7 +777,6 @@ class Defender():
 
         command = str(cmd[0]).lower()
         fromuser = user
-        # print(command)
 
         dnickname = self.Config.SERVICE_NICKNAME            # Defender nickname
         dchanlog = self.Config.SERVICE_CHANLOG              # Defender chan log
@@ -811,6 +813,10 @@ class Defender():
                     release_code = cmd[1]
                     jailed_nickname = self.Irc.get_nickname(fromuser)
                     jailed_UID = self.Irc.get_uid(fromuser)
+                    if not jailed_UID in self.db_reputation:
+                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} : No code is requested ...")
+                        return False
+
                     jailed_IP = self.db_reputation[jailed_UID]['ip']
                     jailed_salon = self.Config.SALON_JAIL
                     reputation_seuil = self.defConfig['reputation_seuil']
@@ -847,8 +853,11 @@ class Defender():
                 except IndexError:
                     self.Irc.debug('_hcmd code: out of index')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} code [code]')
+                except KeyError as ke:
+                    self.Irc.debug(f'_hcmd code: KeyError {ke}')
+                    # self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} code [code]')
                 pass
-                pass
+
 
             case 'reputation':
                 # .reputation [on/off] --> activate or deactivate reputation system
@@ -1019,17 +1028,77 @@ class Defender():
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
 
-            case 'status':
+            case 'flood':
+                # .flood on/off
+                # .flood set flood_message 5
+                # .flood set flood_time 1
+                # .flood set flood_timer 20
                 try:
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Reputation                             ==> {self.defConfig["reputation"]}')
+                    len_cmd = len(cmd)
+
+                    if len_cmd == 2:
+                        activation = str(cmd[1]).lower()
+                        key = 'flood'
+                        if activation == 'on':
+                            if self.defConfig[key] == 1:
+                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Already activated")
+                                return False
+
+                            self.update_db_configuration(key, 1)
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Activated by {fromuser}")
+
+                        if activation == 'off':
+                            if self.defConfig[key] == 0:
+                                self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['rouge']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Already Deactivated")
+                                return False
+
+                            self.update_db_configuration(key, 0)
+                            self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Deactivated by {fromuser}")
+
+                    if len_cmd == 4:
+                        set_key = str(cmd[2]).lower()
+
+                        if str(cmd[1]).lower() == 'set':
+                            match set_key:
+                                case 'flood_message':
+                                    key = 'flood_message'
+                                    set_value = int(cmd[3])
+                                    print(f"{str(set_value)} - {set_key}")
+                                    self.update_db_configuration(key, set_value)
+                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Flood message set to {set_value} by {fromuser}")
+
+                                case 'flood_time':
+                                    key = 'flood_time'
+                                    set_value = int(cmd[3])
+                                    self.update_db_configuration(key, set_value)
+                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Flood time set to {set_value} by {fromuser}")
+
+                                case 'flood_timer':
+                                    key = 'flood_timer'
+                                    set_value = int(cmd[3])
+                                    self.update_db_configuration(key, set_value)
+                                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[ {self.Config.CONFIG_COLOR['verte']}FLOOD{self.Config.CONFIG_COLOR['noire']} ] : Flood timer set to {set_value} by {fromuser}")
+
+                                case _:
+                                    pass
+
+                except ValueError as ve:
+                    self.Irc.debug(f"{self.__class__.__name__} Value Error : {ve}")
+
+            case 'status':
+                color_green = self.Config.CONFIG_COLOR['verte']
+                color_red = self.Config.CONFIG_COLOR['rouge']
+                color_black = self.Config.CONFIG_COLOR['noire']
+                try:
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : [{color_green if self.defConfig["reputation"] == 1 else color_red}Reputation{color_black}]                           ==> {self.defConfig["reputation"]}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :           reputation_seuil             ==> {self.defConfig["reputation_seuil"]}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :           reputation_ban_all_chan      ==> {self.defConfig["reputation_ban_all_chan"]}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :           reputation_timer             ==> {self.defConfig["reputation_timer"]}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : [Proxy_scan]')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :             local_scan                 ==> {self.defConfig["local_scan"]}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :             {color_green if self.defConfig["local_scan"] == 1 else color_red}local_scan{color_black}                 ==> {self.defConfig["local_scan"]}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :             psutil_scan                ==> {self.defConfig["psutil_scan"]}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :             {color_green if self.defConfig["psutil_scan"] == 1 else color_red}psutil_scan{color_black}                ==> {self.defConfig["psutil_scan"]}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :             abuseipdb_scan             ==> {self.defConfig["abuseipdb_scan"]}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :             {color_green if self.defConfig["abuseipdb_scan"] == 1 else color_red}abuseipdb_scan{color_black}             ==> {self.defConfig["abuseipdb_scan"]}')
-                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : Flood                                  ==> {self.defConfig["flood"]}')
+                    self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} : [{color_green if self.defConfig["flood"] == 1 else color_red}Flood{color_black}]                                ==> {self.defConfig["flood"]}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :      flood_action                      ==> Coming soon')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :      flood_message                     ==> {self.defConfig["flood_message"]}')
                     self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :      flood_time                        ==> {self.defConfig["flood_time"]}')