diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..d49077b --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "editor.fontFamily": "Fira Code", + "editor.fontSize": 14, + "editor.cursorStyle": "block" +} \ No newline at end of file diff --git a/core/classes/protocols/command_handler.py b/core/classes/protocols/command_handler.py new file mode 100644 index 0000000..b06b9e6 --- /dev/null +++ b/core/classes/protocols/command_handler.py @@ -0,0 +1,48 @@ +from typing import Optional, TYPE_CHECKING + +if TYPE_CHECKING: + from core.definition import MIrcdCommand + from core.loader import Loader + +class CommandHandler: + + DB_IRCDCOMMS: list['MIrcdCommand'] = [] + DB_SUBSCRIBE: list = [] + + def __init__(self, loader: 'Loader'): + self.__Logs = loader.Logs + + def register(self, ircd_command_model: 'MIrcdCommand') -> None: + """Register a new command in the Handler + + Args: + ircd_command_model (MIrcdCommand): The IRCD Command Object + """ + ircd_command = self.get_registred_ircd_command(ircd_command_model.command_name) + if ircd_command is None: + self.__Logs.debug(f'[IRCD COMMAND HANDLER] New IRCD command ({ircd_command_model.command_name}) added to the handler.') + self.DB_IRCDCOMMS.append(ircd_command_model) + return None + else: + self.__Logs.debug(f'[IRCD COMMAND HANDLER] This IRCD command ({ircd_command.command_name}) already exist in the handler.') + + def get_registred_ircd_command(self, command_name: str) -> Optional['MIrcdCommand']: + """Get the registred IRCD command model + + Returns: + MIrcdCommand: The IRCD Command object + """ + com = command_name.upper() + for ircd_com in self.DB_IRCDCOMMS: + if com == ircd_com.command_name.upper(): + return ircd_com + + return None + + def get_ircd_commands(self) -> list['MIrcdCommand']: + """Get the list of IRCD Commands + + Returns: + list[MIrcdCommand]: a list of all registred commands + """ + return self.DB_IRCDCOMMS.copy() diff --git a/core/classes/protocols/inspircd.py b/core/classes/protocols/inspircd.py index d41a9db..531227d 100644 --- a/core/classes/protocols/inspircd.py +++ b/core/classes/protocols/inspircd.py @@ -1,33 +1,42 @@ -from re import match, findall -from datetime import datetime import sys -from typing import TYPE_CHECKING, Optional +from base64 import b64decode +from re import match, findall, search +from datetime import datetime +from typing import TYPE_CHECKING, Any, Optional from ssl import SSLEOFError, SSLError +from core.classes.protocols.command_handler import CommandHandler +from core.classes.protocols.interface import IProtocol +from core.utils import tr if TYPE_CHECKING: from core.irc import Irc + from core.definition import MSasl, MClient -class Inspircd: +class Inspircd(IProtocol): def __init__(self, ircInstance: 'Irc'): self.name = 'InspIRCd-4' + self.protocol_version = 1206 self.__Irc = ircInstance self.__Config = ircInstance.Config self.__Base = ircInstance.Base self.__Utils = ircInstance.Loader.Utils + self.__Settings = ircInstance.Settings self.__Logs = ircInstance.Loader.Logs - self.known_protocol: set[str] = {'SJOIN', 'UID', 'MD', 'QUIT', 'SQUIT', - 'EOS', 'PRIVMSG', 'MODE', 'UMODE2', - 'VERSION', 'REPUTATION', 'SVS2MODE', - 'SLOG', 'NICK', 'PART', 'PONG', 'SASL', 'PING', - 'PROTOCTL', 'SERVER', 'SMOD', 'TKL', 'NETINFO', - '006', '007', '018'} + self.known_protocol: set[str] = {'UID', 'ERROR', 'PRIVMSG', + 'SINFO', 'FJOIN', 'PING', 'PONG', + 'SASL', 'PART', 'CAPAB', 'ENDBURST', + 'METADATA', 'NICK', + 'MODE', 'QUIT', 'SQUIT', + 'VERSION'} - self.__Logs.info(f"** Loading protocol [{__name__}]") + self.Handler = CommandHandler(ircInstance.Loader) - def get_ircd_protocol_poisition(self, cmd: list[str]) -> tuple[int, Optional[str]]: + self.__Logs.info(f"[PROTOCOL] Protocol [{__name__}] loaded!") + + def get_ircd_protocol_poisition(self, cmd: list[str], log: bool = False) -> tuple[int, Optional[str]]: """Get the position of known commands Args: @@ -39,11 +48,28 @@ class Inspircd: for index, token in enumerate(cmd): if token.upper() in self.known_protocol: return index, token.upper() - - self.__Logs.debug(f"[IRCD LOGS] You need to handle this response: {cmd}") + + if log: + self.__Logs.debug(f"[IRCD LOGS] You need to handle this response: {cmd}") return (-1, None) + def register_command(self): + m = self.__Irc.Loader.Definition.MIrcdCommand + self.Handler.register(m('PING', self.on_server_ping)) + self.Handler.register(m('NICK', self.on_nick)) + self.Handler.register(m('SASL', self.on_sasl)) + self.Handler.register(m('SINFO', self.on_server)) + self.Handler.register(m('UID', self.on_uid)) + self.Handler.register(m('QUIT', self.on_quit)) + self.Handler.register(m('FJOIN', self.on_sjoin)) + self.Handler.register(m('PART', self.on_part)) + self.Handler.register(m('PRIVMSG', self.on_privmsg)) + self.Handler.register(m('ERROR', self.on_error)) + self.Handler.register(m('CAPAB', self.on_protoctl)) + self.Handler.register(m('ENDBURST', self.on_endburst)) + self.Handler.register(m('METADATA', self.on_metedata)) + def send2socket(self, message: str, print_log: bool = True) -> None: """Envoit les commandes à envoyer au serveur. @@ -149,17 +175,25 @@ class Inspircd: link = self.__Config.SERVEUR_LINK server_id = self.__Config.SERVEUR_ID service_id = self.__Config.SERVICE_ID + server_hostname = self.__Config.SERVEUR_HOSTNAME version = self.__Config.CURRENT_VERSION unixtime = self.__Utils.get_unixtime() + self.__Settings.MAIN_SERVER_HOSTNAME = server_hostname - - self.send2socket(f"CAPAB START 1206") + self.send2socket(f"CAPAB START {self.protocol_version}") + self.send2socket(f"CAPAB MODULES :services") + self.send2socket(f"CAPAB MODSUPPORT :") self.send2socket(f"CAPAB CAPABILITIES :NICKMAX=30 CHANMAX=64 MAXMODES=20 IDENTMAX=10 MAXQUIT=255 MAXTOPIC=307 MAXKICK=255 MAXREAL=128 MAXAWAY=200 MAXHOST=64 MAXLINE=512 CASEMAPPING=ascii GLOBOPS=0") self.send2socket(f"CAPAB END") self.send2socket(f"SERVER {link} {password} {server_id} :{info}") self.send2socket(f"BURST {unixtime}") + self.send2socket(f":{server_id} SINFO version :{service_name}-{version.split('.')[0]}. {server_hostname} :") + self.send2socket(f":{server_id} SINFO fullversion :{service_name}-{version}. {host} :") + self.send2socket(f":{server_id} SINFO rawversion :{service_name}-{version}") + self.send_uid(nickname, username, host, service_id, smodes, host, "127.0.0.1", realname) self.send2socket(f":{server_id} ENDBURST") + # self.send_sjoin(chan) self.__Logs.debug(f'>> {__name__} Link information sent to the server') @@ -175,6 +209,58 @@ class Inspircd: self.send2socket(f":{self.__Config.SERVICE_NICKNAME} NICK {newnickname}") return None + def send_set_mode(self, modes: str, *, nickname: Optional[str] = None, channel_name: Optional[str] = None, params: Optional[str] = None) -> None: + """Set a mode to channel or to a nickname or for a user in a channel + + Args: + modes (str): The selected mode + nickname (Optional[str]): The nickname + channel_name (Optional[str]): The channel name + """ + service_id = self.__Config.SERVICE_ID + params = '' if params is None else params + + if modes[0] not in ['+', '-']: + self.__Logs.error(f"[MODE ERROR] The mode you have provided is missing the sign: {modes}") + return None + + if nickname and channel_name: + # :98KAAAAAB MODE #services +o defenderdev + if not self.__Irc.Channel.is_valid_channel(channel_name): + self.__Logs.error(f"[MODE ERROR] The channel is not valid: {channel_name}") + return None + + if not all(mode in self.__Settings.PROTOCTL_PREFIX_MODES_SIGNES for mode in list(modes.replace('+','').replace('-',''))): + self.__Logs.debug(f'[USERMODE UNVAILABLE] This mode {modes} is not available!') + return None + + self.send2socket(f":{service_id} MODE {channel_name} {modes} {nickname}") + return None + + if nickname and channel_name is None: + # :98KAAAAAB MODE nickname +o + if not all(mode in self.__Settings.PROTOCTL_USER_MODES for mode in list(modes.replace('+','').replace('-',''))): + self.__Logs.debug(f'[USERMODE UNVAILABLE] This mode {modes} is not available!') + return None + + self.send2socket(f":{service_id} MODE {nickname} {modes}") + return None + + if nickname is None and channel_name: + # :98KAAAAAB MODE #channel +o + if not all(mode in self.__Settings.PROTOCTL_CHANNEL_MODES for mode in list(modes.replace('+','').replace('-',''))): + self.__Logs.debug(f'[USERMODE UNVAILABLE] This mode {modes} is not available!') + return None + + if not self.__Irc.Channel.is_valid_channel(channel_name): + self.__Logs.error(f"[MODE ERROR] The channel is not valid: {channel_name}") + return None + + self.send2socket(f":{service_id} MODE {channel_name} {modes} {params}") + return None + + return None + def send_squit(self, server_id: str, server_link: str, reason: str) -> None: if not reason: @@ -197,16 +283,25 @@ class Inspircd: return None def send_sjoin(self, channel: str) -> None: + """Service join a channel + + Args: + channel (str): The channel name. + """ + server_id = self.__Config.SERVEUR_ID + service_nickname = self.__Config.SERVICE_NICKNAME + service_modes = self.__Config.SERVICE_UMODES + service_id = self.__Config.SERVICE_ID if not self.__Irc.Channel.is_valid_channel(channel): self.__Logs.error(f"The channel [{channel}] is not valid") return None - # self.send2socket(f":{self.__Config.SERVEUR_ID} SJOIN {self.__Utils.get_unixtime()} {channel} + :{self.__Config.SERVICE_ID}") - self.send2socket(f":{self.__Config.SERVICE_ID} FJOIN {channel} 68") + self.send2socket(f":{server_id} FJOIN {channel} {self.__Utils.get_unixtime()} :o, {service_id}") + self.send_set_mode(service_modes, nickname=service_nickname, channel_name=channel) # Add defender to the channel uids list - self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[self.__Config.SERVICE_ID])) + self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[service_id])) return None def send_quit(self, uid: str, reason: str, print_log: True) -> None: @@ -217,7 +312,7 @@ class Inspircd: reason (str): The reason for the quit """ user_obj = self.__Irc.User.get_user(uidornickname=uid) - reputationObj = self.__Irc.Reputation.get_Reputation(uidornickname=uid) + reputationObj = self.__Irc.Reputation.get_reputation(uidornickname=uid) if not user_obj is None: self.send2socket(f":{user_obj.uid} QUIT :{reason}", print_log=print_log) @@ -233,7 +328,7 @@ class Inspircd: def send_uid(self, nickname:str, username: str, hostname: str, uid:str, umodes: str, vhost: str, remote_ip: str, realname: str, print_log: bool = True) -> None: """Send UID to the server - + [:] UID []+ : Args: nickname (str): Nickname of the client username (str): Username of the client @@ -249,19 +344,27 @@ class Inspircd: # {clone.nickname} 1 {self.__Utils.get_unixtime()} {clone.username} {clone.hostname} {clone.uid} * {clone.umodes} {clone.vhost} * {self.Base.encode_ip(clone.remote_ip)} :{clone.realname} try: unixtime = self.__Utils.get_unixtime() - encoded_ip = self.__Base.encode_ip(remote_ip) + # encoded_ip = self.__Base.encode_ip(remote_ip) + new_umodes = [] + for mode in list(umodes.replace('+', '').replace('-', '')): + if mode in self.__Settings.PROTOCTL_USER_MODES: + new_umodes.append(mode) + + final_umodes = '+' + ''.join(new_umodes) # Create the user self.__Irc.User.insert( self.__Irc.Loader.Definition.MUser( uid=uid, nickname=nickname, username=username, - realname=realname,hostname=hostname, umodes=umodes, + realname=realname,hostname=hostname, umodes=final_umodes, vhost=vhost, remote_ip=remote_ip ) ) - uid_msg = f":{self.__Config.SERVEUR_ID} UID {nickname} 1 {unixtime} {username} {hostname} {uid} * {umodes} {vhost} * {encoded_ip} :{realname}" - + # [:] UID []+ : + # :98K UID 98KAAAAAB 1756932359 defenderdev defenderdev.deb.biz.st defenderdev.deb.biz.st Dev-PyDefender 127.0.0.1 1756932359 + :Dev Python Security + # [':97K', 'UID', '97KAAAAAA', '1756926679', 'adator', '172.18.128.1', 'attila.example.org', '...', '...', '172.18.128.1', '1756926678', '+o', ':...'] + uid_msg = f":{self.__Config.SERVEUR_ID} UID {uid} {unixtime} {nickname} {hostname} {vhost} {username} {username} {remote_ip} {unixtime} {final_umodes} :{realname}" self.send2socket(uid_msg, print_log=print_log) return None @@ -289,7 +392,7 @@ class Inspircd: self.__Logs.error(f"The channel [{channel}] is not valid") return None - self.send2socket(f":{userObj.uid} JOIN {channel} {passwordChannel}", print_log=print_log) + self.send2socket(f":{userObj.uid} FJOIN {channel} {self.__Utils.get_unixtime()} :,{userObj.uid} {passwordChannel}", print_log=print_log) # Add defender to the channel uids list self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[userObj.uid])) @@ -326,6 +429,15 @@ class Inspircd: return None + def send_raw(self, raw_command: str) -> None: + + self.send2socket(f":{self.__Config.SERVEUR_ID} {raw_command}") + return None + + # ------------------------------------------------------------------------ + # RECIEVED IRC MESSAGES + # ------------------------------------------------------------------------ + def on_umode2(self, serverMsg: list[str]) -> None: """Handle umode2 coming from a server @@ -358,14 +470,13 @@ class Inspircd: def on_quit(self, serverMsg: list[str]) -> None: """Handle quit coming from a server - + >> [':97KAAAAAZ', 'QUIT', ':Quit:', '....'] Args: serverMsg (list[str]): Original server message """ try: - # ['@unrealircd.org/userhost=...@192.168.1.10;unrealircd.org/userip=...@192.168.1.10;msgid=CssUrV08BzekYuq7BfvPHn;time=2024-11-02T15:03:33.182Z', ':001JKNY0N', 'QUIT', ':Quit:', '....'] - uid_who_quit = str(serverMsg[1]).lstrip(':') + uid_who_quit = str(serverMsg[0]).lstrip(':') self.__Irc.Channel.delete_user_from_all_channel(uid_who_quit) self.__Irc.User.delete(uid_who_quit) @@ -401,15 +512,49 @@ class Inspircd: return None def on_protoctl(self, serverMsg: list[str]) -> None: - """Handle protoctl coming from a server + """Handle CAPAB coming from a server Args: serverMsg (list[str]): Original server message """ - if len(serverMsg) > 5: - if '=' in serverMsg[5]: - serveur_hosting_id = str(serverMsg[5]).split('=') - self.__Config.HSID = serveur_hosting_id[1] + # ['CAPAB', 'CHANMODES', ':list:ban=b', 'param-set:limit=l', 'param:key=k', 'prefix:10000:voice=+v', 'prefix:30000:op=@o', 'prefix:50000:founder=~q', + # 'simple:c_registered=r', 'simple:inviteonly=i', 'simple:moderated=m', 'simple:noextmsg=n', 'simple:private=p', + # 'simple:secret=s', 'simple:sslonly=z', 'simple:topiclock=t'] + + scopy = serverMsg.copy() + + # Get Chan modes. + if scopy[1] == 'CHANMODES': + sign_mode = {} + mode_sign = {} + channel_modes = [] + for prefix in scopy: + if prefix.startswith('prefix:'): + sign = prefix.split('=')[1][0] if len(prefix.split('=')) > 1 else None + mode = prefix.split('=')[1][1] if len(prefix.split('=')) > 1 else None + sign_mode[sign] = mode + mode_sign[mode] = sign + + if prefix.startswith('simple:') or prefix.startswith('param-set:') or prefix.startswith('param:'): + cmode = prefix.split('=')[1] if len(prefix.split('=')) > 1 else None + channel_modes.append(cmode) + + + self.__Settings.PROTOCTL_PREFIX_SIGNES_MODES = sign_mode + self.__Settings.PROTOCTL_PREFIX_MODES_SIGNES = mode_sign + self.__Settings.PROTOCTL_CHANNEL_MODES = list(set(channel_modes)) + + # ['CAPAB', 'USERMODES', ':param-set:snomask=s', 'simple:bot=B', 'simple:invisible=i', 'simple:oper=o', 'simple:servprotect=k', + # 'simple:sslqueries=z', 'simple:u_registered=r', 'simple:wallops=w'] + # Get user modes + if scopy[1] == 'USERMODES': + user_modes = [] + for prefix in scopy: + if prefix.startswith('param-set:') or prefix.startswith('simple:'): + umode = prefix.split('=')[1] if len(prefix.split('=')) > 1 else None + user_modes.append(umode) + + self.__Settings.PROTOCTL_USER_MODES = list(set(user_modes)) return None @@ -421,11 +566,15 @@ class Inspircd: serverMsg (list[str]): Original server message """ try: - # ['@unrealircd.org/geoip=FR;unrealircd.org/', ':001OOU2H3', 'NICK', 'WebIrc', '1703795844'] + # [':97KAAAAAF', 'NICK', 'test', '1757370509'] # Changement de nickname - uid = str(serverMsg[1]).lstrip(':') - newnickname = serverMsg[3] + scopy = serverMsg.copy() + if scopy[0].startswith('@'): + scopy.pop(0) + + uid = str(scopy[0]).replace(':','') + newnickname = scopy[2] self.__Irc.User.update_nickname(uid, newnickname) self.__Irc.Client.update_nickname(uid, newnickname) self.__Irc.Admin.update_nickname(uid, newnickname) @@ -444,33 +593,17 @@ class Inspircd: serverMsg (list[str]): Original server message """ try: - # ['@msgid=5sTwGdj349D82L96p749SY;time=2024-08-15T09:50:23.528Z', ':001', 'SJOIN', '1721564574', '#welcome', ':001JD94QH'] - # ['@msgid=bvceb6HthbLJapgGLXn1b0;time=2024-08-15T09:50:11.464Z', ':001', 'SJOIN', '1721564574', '#welcome', '+lnrt', '13', ':001CIVLQF', '+11ZAAAAAB', '001QGR10C', '*@0014UE10B', '001NL1O07', '001SWZR05', '001HB8G04', '@00BAAAAAJ', '0019M7101'] - # ['@msgid=SKUeuVzOrTShRDduq8VerX;time=2024-08-23T19:37:04.266Z', ':001', 'SJOIN', '1723993047', '#welcome', '+lnrt', '13', - # ':001T6VU3F', '001JGWB2K', '@11ZAAAAAB', - # '001F16WGR', '001X9YMGQ', '*+001DYPFGP', '@00BAAAAAJ', '001AAGOG9', '001FMFVG8', '001DAEEG7', - # '&~G:unknown-users', '"~G:websocket-users', '"~G:known-users', '"~G:webirc-users'] - serverMsg.pop(0) - channel = str(serverMsg[3]).lower() - len_cmd = len(serverMsg) + # [':97K', 'FJOIN', '#services', '1757156589', '+nt', ':,97KAAAAA2:22', 'o,97KAAAAAA:2'] + + channel = str(serverMsg[2]).lower() list_users:list = [] - occurence = 0 - start_boucle = 0 - # Trouver le premier user - for i in range(len_cmd): - s: list = findall(fr':', serverMsg[i]) - if s: - occurence += 1 - if occurence == 2: - start_boucle = i + # Find uid's + for uid in serverMsg: + matches = findall(r',([0-9A-Z]+):', uid) + list_users.extend(matches) - # Boucle qui va ajouter l'ensemble des users (UID) - for i in range(start_boucle, len(serverMsg)): - parsed_UID = str(serverMsg[i]) - clean_uid = self.__Utils.clean_uid(parsed_UID) - if not clean_uid is None and len(clean_uid) == 9: - list_users.append(parsed_UID) + list_users = list(set(list_users)) if list_users: self.__Irc.Channel.insert( @@ -486,6 +619,80 @@ class Inspircd: except Exception as err: self.__Logs.error(f"{__name__} - General Error: {err}") + def on_endburst(self, serverMsg: list[str]) -> None: + """Handle EOS coming from a server + + Args: + serverMsg (list[str]): Original server message + """ + try: + # [':97K', 'ENDBURST'] + scopy = serverMsg.copy() + hsid = str(scopy[0]).replace(':','') + if hsid == self.__Config.HSID: + if self.__Config.DEFENDER_INIT == 1: + current_version = self.__Config.CURRENT_VERSION + latest_version = self.__Config.LATEST_VERSION + if self.__Base.check_for_new_version(False): + version = f'{current_version} >>> {latest_version}' + else: + version = f'{current_version}' + + print(f"################### DEFENDER ###################") + print(f"# SERVICE CONNECTE ") + print(f"# SERVEUR : {self.__Config.SERVEUR_IP} ") + print(f"# PORT : {self.__Config.SERVEUR_PORT} ") + print(f"# SSL : {self.__Config.SERVEUR_SSL} ") + print(f"# SSL VER : {self.__Config.SSL_VERSION} ") + print(f"# NICKNAME : {self.__Config.SERVICE_NICKNAME} ") + print(f"# CHANNEL : {self.__Config.SERVICE_CHANLOG} ") + print(f"# VERSION : {version} ") + print(f"################################################") + + self.__Logs.info(f"################### DEFENDER ###################") + self.__Logs.info(f"# SERVICE CONNECTE ") + self.__Logs.info(f"# SERVEUR : {self.__Config.SERVEUR_IP} ") + self.__Logs.info(f"# PORT : {self.__Config.SERVEUR_PORT} ") + self.__Logs.info(f"# SSL : {self.__Config.SERVEUR_SSL} ") + self.__Logs.info(f"# SSL VER : {self.__Config.SSL_VERSION} ") + self.__Logs.info(f"# NICKNAME : {self.__Config.SERVICE_NICKNAME} ") + self.__Logs.info(f"# CHANNEL : {self.__Config.SERVICE_CHANLOG} ") + self.__Logs.info(f"# VERSION : {version} ") + self.__Logs.info(f"################################################") + + self.send_sjoin(self.__Config.SERVICE_CHANLOG) + + if self.__Base.check_for_new_version(False): + self.send_priv_msg( + nick_from=self.__Config.SERVICE_NICKNAME, + msg=f" New Version available {version}", + channel=self.__Config.SERVICE_CHANLOG + ) + + # Initialisation terminé aprés le premier PING + self.send_priv_msg( + nick_from=self.__Config.SERVICE_NICKNAME, + msg=tr("[ %sINFORMATION%s ] >> %s is ready!", self.__Config.COLORS.green, self.__Config.COLORS.nogc, self.__Config.SERVICE_NICKNAME), + channel=self.__Config.SERVICE_CHANLOG + ) + self.__Config.DEFENDER_INIT = 0 + + # Send EOF to other modules + for module in self.__Irc.ModuleUtils.model_get_loaded_modules().copy(): + module.class_instance.cmd(scopy) + + # Join saved channels & load existing modules + self.__Irc.join_saved_channels() + self.__Irc.ModuleUtils.db_load_all_existing_modules(self.__Irc) + + return None + except IndexError as ie: + self.__Logs.error(f"{__name__} - Key Error: {ie}") + except KeyError as ke: + self.__Logs.error(f"{__name__} - Key Error: {ke}") + except Exception as err: + self.__Logs.error(f"{__name__} - General Error: {err}") + def on_part(self, serverMsg: list[str]) -> None: """Handle part coming from a server @@ -493,11 +700,11 @@ class Inspircd: serverMsg (list[str]): Original server message """ try: - # ['@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'] + # [':97KAAAAA2', 'PART', '#v', ':"Closing', 'Window"'] - uid = str(serverMsg[1]).lstrip(':') - channel = str(serverMsg[3]).lower() + uid = str(serverMsg[0]).lstrip(':') + channel = str(serverMsg[2]).lower() + reason = str(' '.join(serverMsg[3:])) self.__Irc.Channel.delete_user_from_channel(channel, uid) return None @@ -515,6 +722,9 @@ class Inspircd: serverMsg (list[str]): Original server message """ try: + RED = self.__Config.COLORS.red + GREEN = self.__Config.COLORS.green + NOGC = self.__Config.COLORS.nogc isWebirc = True if 'webirc' in serverMsg[0] else False isWebsocket = True if 'websocket' in serverMsg[0] else False @@ -526,7 +736,8 @@ class Inspircd: vhost = str(serverMsg[6]) if not 'S' in umodes: - remote_ip = self.__Base.decode_ip(str(serverMsg[9])) + # remote_ip = self.__Base.decode_ip(str(serverMsg[9])) + remote_ip = str(serverMsg[9]) else: remote_ip = '127.0.0.1' @@ -561,12 +772,127 @@ class Inspircd: connexion_datetime=datetime.now() ) ) + + for module in self.__Irc.ModuleUtils.model_get_loaded_modules().copy(): + module.class_instance.cmd(serverMsg) + + # SASL authentication + dnickname = self.__Config.SERVICE_NICKNAME + dchanlog = self.__Config.SERVICE_CHANLOG + # uid = serverMsg[8] + # nickname = serverMsg[3] + sasl_obj = self.__Irc.Sasl.get_sasl_obj(uid) + if sasl_obj: + if sasl_obj.auth_success: + self.__Irc.insert_db_admin(sasl_obj.client_uid, sasl_obj.username, sasl_obj.level, sasl_obj.language) + self.send_priv_msg(nick_from=dnickname, + msg=tr("[ %sSASL AUTH%s ] - %s (%s) is now connected successfuly to %s", GREEN, NOGC, nickname, sasl_obj.username, dnickname), + channel=dchanlog) + self.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Successfuly connected to %s", dnickname)) + else: + self.send_priv_msg(nick_from=dnickname, + msg=tr("[ %sSASL AUTH%s ] - %s provided a wrong password for this username %s", RED, NOGC, nickname, sasl_obj.username), + channel=dchanlog) + self.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Wrong password!")) + + # Delete sasl object! + self.__Irc.Sasl.delete_sasl_client(uid) + return None + return None except IndexError as ie: self.__Logs.error(f"{__name__} - Index Error: {ie}") except Exception as err: self.__Logs.error(f"{__name__} - General Error: {err}", exc_info=True) + def on_privmsg(self, serverMsg: list[str]) -> None: + """Handle PRIVMSG message coming from the server + + Args: + serverMsg (list[str]): Original server message + """ + try: + srv_msg = serverMsg.copy() + cmd = serverMsg.copy() + # Supprimer la premiere valeur si MTAGS activé + if cmd[0].startswith('@'): + cmd.pop(0) + + get_uid_or_nickname = str(cmd[0].replace(':','')) + user_trigger = self.__Irc.User.get_nickname(get_uid_or_nickname) + dnickname = self.__Config.SERVICE_NICKNAME + pattern = fr'(:\{self.__Config.SERVICE_PREFIX})(.*)$' + hcmds = search(pattern, ' '.join(cmd)) # va matcher avec tout les caractéres aprés le . + + if hcmds: # Commande qui commencent par le point + liste_des_commandes = list(hcmds.groups()) + convert_to_string = ' '.join(liste_des_commandes) + arg = convert_to_string.split() + arg.remove(f':{self.__Config.SERVICE_PREFIX}') + if not self.__Irc.Commands.is_command_exist(arg[0]): + self.__Logs.debug(f"This command {arg[0]} is not available") + self.send_notice( + nick_from=self.__Config.SERVICE_NICKNAME, + nick_to=user_trigger, + msg=f"This command [{self.__Config.COLORS.bold}{arg[0]}{self.__Config.COLORS.bold}] is not available" + ) + return None + + cmd_to_send = convert_to_string.replace(':','') + self.__Base.log_cmd(user_trigger, cmd_to_send) + + fromchannel = str(cmd[2]).lower() if self.__Irc.Channel.is_valid_channel(cmd[2]) else None + self.__Irc.hcmds(user_trigger, fromchannel, arg, cmd) + + if cmd[2] == self.__Config.SERVICE_ID: + pattern = fr'^:.*?:(.*)$' + hcmds = search(pattern, ' '.join(cmd)) + + if hcmds: # par /msg defender [commande] + liste_des_commandes = list(hcmds.groups()) + convert_to_string = ' '.join(liste_des_commandes) + arg = convert_to_string.split() + + # Réponse a un CTCP VERSION + if arg[0] == '\x01VERSION\x01': + self.on_version(srv_msg) + return None + + # Réponse a un TIME + if arg[0] == '\x01TIME\x01': + self.on_time(srv_msg) + return None + + # Réponse a un PING + if arg[0] == '\x01PING': + self.on_ping(srv_msg) + return None + + if not self.__Irc.Commands.is_command_exist(arg[0]): + self.__Logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available") + return None + + # if not arg[0].lower() in self.__Irc.module_commands_list: + # self.__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(user_trigger, cmd_to_send) + + fromchannel = None + if len(arg) >= 2: + fromchannel = str(arg[1]).lower() if self.__Irc.Channel.is_valid_channel(arg[1]) else None + + self.__Irc.hcmds(user_trigger, fromchannel, arg, cmd) + return None + + except KeyError as ke: + self.__Logs.error(f"Key Error: {ke}") + except AttributeError as ae: + self.__Logs.error(f"Attribute Error: {ae}") + except Exception as err: + self.__Logs.error(f"General Error: {err} - {srv_msg}") + def on_server_ping(self, serverMsg: list[str]) -> None: """Send a PONG message to the server @@ -574,12 +900,12 @@ class Inspircd: serverMsg (list[str]): List of str coming from the server """ try: - # InspIRCd 3: + # InspIRCd 4: # <- :3IN PING 808 # -> :808 PONG 3IN hsid = str(serverMsg[0]).replace(':','') - self.send2socket(f":{self.__Config.SERVEUR_ID} PONG {hsid}", print_log=True) + self.send2socket(f":{self.__Config.SERVEUR_ID} PONG {hsid}", print_log=False) return None except Exception as err: @@ -587,12 +913,20 @@ class Inspircd: def on_server(self, serverMsg: list[str]) -> None: """_summary_ - + >>> [':97K', 'SINFO', 'customversion', ':'] + >>> [':97K', 'SINFO', 'rawbranch', ':InspIRCd-4'] + >>> [':97K', 'SINFO', 'rawversion', ':InspIRCd-4.8.0'] Args: - serverMsg (list[str]): _description_ + serverMsg (list[str]): The server message """ try: - ... + param = str(serverMsg[2]) + self.__Config.HSID = self.__Settings.MAIN_SERVER_ID = str(serverMsg[0]).replace(':', '') + if param == 'rawversion': + self.__Logs.debug(f">> Server Version: {serverMsg[3].replace(':', '')}") + elif param == 'rawbranch': + self.__Logs.debug(f">> Branch Version: {serverMsg[3].replace(':', '')}") + except Exception as err: self.__Logs.error(f'General Error: {err}') @@ -702,3 +1036,408 @@ class Inspircd: except Exception as err: self.__Logs.error(f"{__name__} - General Error: {err}") + + def on_sasl(self, serverMsg: list[str]) -> Optional['MSasl']: + """Handle SASL coming from a server + + Args: + serverMsg (list[str]): Original server message + psasl (Sasl): The SASL process object + """ + try: + # [':97K', 'ENCAP', '98K', 'SASL', '97KAAAAAF', '*', 'H', '172.18.128.1', '172.18.128.1', 'P'] + # [':97K', 'ENCAP', '98K', 'SASL', '97KAAAAAF', '*', 'S', 'PLAIN'] + # [':97K', 'ENCAP', '98K', 'SASL', '97KAAAAAP', 'irc.inspircd.local', 'C', 'YWRzefezfzefzefzefzefzefzefzezak='] + # [':irc.local.org', 'SASL', 'defender-dev.deb.biz.st', '0014ZZH1F', 'S', 'EXTERNAL', 'zzzzzzzkey'] + # [':irc.local.org', 'SASL', 'defender-dev.deb.biz.st', '00157Z26U', 'C', 'sasakey=='] + # [':irc.local.org', 'SASL', 'defender-dev.deb.biz.st', '00157Z26U', 'D', 'A'] + psasl = self.__Irc.Sasl + sasl_enabled = True # Should be False + for smod in self.__Settings.SMOD_MODULES: + if smod.name == 'sasl': + sasl_enabled = True + break + + if not sasl_enabled: + return None + + sCopy = serverMsg.copy() + client_uid = sCopy[4] if len(sCopy) >= 6 else None + sasl_obj = None + sasl_message_type = sCopy[6] if len(sCopy) >= 6 else None + psasl.insert_sasl_client(self.__Irc.Loader.Definition.MSasl(client_uid=client_uid)) + sasl_obj = psasl.get_sasl_obj(client_uid) + + if sasl_obj is None: + return None + + match sasl_message_type: + case 'H': + sasl_obj.remote_ip = str(sCopy[8]) + sasl_obj.message_type = sasl_message_type + return sasl_obj + + case 'S': + sasl_obj.message_type = sasl_message_type + if str(sCopy[7]) in ['PLAIN', 'EXTERNAL']: + sasl_obj.mechanisme = str(sCopy[7]) + + if sasl_obj.mechanisme == "PLAIN": + self.send2socket(f":{self.__Config.SERVEUR_ID} SASL {self.__Config.SERVEUR_HOSTNAME} {sasl_obj.client_uid} C +") + elif sasl_obj.mechanisme == "EXTERNAL": + if str(sCopy[7]) == "+": + return None + + sasl_obj.fingerprint = str(sCopy[8]) + self.send2socket(f":{self.__Config.SERVEUR_ID} SASL {self.__Config.SERVEUR_HOSTNAME} {sasl_obj.client_uid} C +") + + self.on_sasl_authentication_process(sasl_obj) + return sasl_obj + + case 'C': + if sasl_obj.mechanisme == "PLAIN": + credentials = sCopy[7] + decoded_credentials = b64decode(credentials).decode() + user, username, password = decoded_credentials.split('\0') + + sasl_obj.message_type = sasl_message_type + sasl_obj.username = username + sasl_obj.password = password + + self.on_sasl_authentication_process(sasl_obj) + return sasl_obj + elif sasl_obj.mechanisme == "EXTERNAL": + sasl_obj.message_type = sasl_message_type + self.on_sasl_authentication_process(sasl_obj) + return sasl_obj + + except Exception as err: + self.__Logs.error(f'General Error: {err}', exc_info=True) + + def on_sasl_authentication_process(self, sasl_model: 'MSasl') -> bool: + s = sasl_model + server_id = self.__Config.SERVEUR_ID + main_server_hostname = self.__Settings.MAIN_SERVER_HOSTNAME + db_admin_table = self.__Config.TABLE_ADMIN + if sasl_model: + def db_get_admin_info(*, username: Optional[str] = None, password: Optional[str] = None, fingerprint: Optional[str] = None) -> Optional[dict[str, Any]]: + if fingerprint: + mes_donnees = {'fingerprint': fingerprint} + query = f"SELECT user, level, language FROM {db_admin_table} WHERE fingerprint = :fingerprint" + else: + mes_donnees = {'user': username, 'password': self.__Utils.hash_password(password)} + query = f"SELECT user, level, language FROM {db_admin_table} WHERE user = :user AND password = :password" + + result = self.__Base.db_execute_query(query, mes_donnees) + user_from_db = result.fetchone() + if user_from_db: + return {'user': user_from_db[0], 'level': user_from_db[1], 'language': user_from_db[2]} + else: + return None + + if s.message_type == 'C' and s.mechanisme == 'PLAIN': + # Connection via PLAIN + admin_info = db_get_admin_info(username=s.username, password=s.password) + if admin_info is not None: + s.auth_success = True + s.level = admin_info.get('level', 0) + s.language = admin_info.get('language', 'EN') + self.send2socket(f":{server_id} SASL {main_server_hostname} {s.client_uid} D S") + self.send2socket(f":{server_id} SASL {s.username} :SASL authentication successful") + else: + self.send2socket(f":{server_id} SASL {main_server_hostname} {s.client_uid} D F") + self.send2socket(f":{server_id} SASL {s.username} :SASL authentication failed") + + elif s.message_type == 'S' and s.mechanisme == 'EXTERNAL': + # Connection using fingerprints + admin_info = db_get_admin_info(fingerprint=s.fingerprint) + + if admin_info is not None: + s.auth_success = True + s.level = admin_info.get('level', 0) + s.username = admin_info.get('user', None) + s.language = admin_info.get('language', 'EN') + self.send2socket(f":{server_id} SASL {main_server_hostname} {s.client_uid} D S") + self.send2socket(f":{server_id} SASL {s.username} :SASL authentication successful") + else: + # "904 :SASL authentication failed" + self.send2socket(f":{server_id} SASL {main_server_hostname} {s.client_uid} D F") + self.send2socket(f":{server_id} SASL {s.username} :SASL authentication failed") + + def on_error(self, serverMsg: list[str]) -> None: + self.__Logs.debug(f"{serverMsg}") + + def on_metedata(self, serverMsg: list[str]) -> None: + """_summary_ + + Args: + serverMsg (list[str]): _description_ + """ + # [':97K', 'METADATA', '97KAAAAAA', 'ssl_cert', ':vTrSe', 'fingerprint90753683519522875', + # '/C=FR/OU=Testing/O=Test', 'Sasl/CN=localhost', '/C=FR/OU=Testing/O=Test', 'Sasl/CN=localhost'] + scopy = serverMsg.copy() + dnickname = self.__Config.SERVICE_NICKNAME + dchanlog = self.__Config.SERVICE_CHANLOG + GREEN = self.__Config.COLORS.green + NOGC = self.__Config.COLORS.nogc + if 'ssl_cert' in scopy: + fingerprint = scopy[5] + uid = scopy[2] + user_obj = self.__Irc.User.get_user(uid) + if user_obj: + user_obj.fingerprint = fingerprint + if self.__Irc.Admin.db_auth_admin_via_fingerprint(fingerprint, uid): + admin = self.__Irc.Admin.get_admin(uid) + account = admin.account if admin else '' + self.send_priv_msg(nick_from=dnickname, + msg=tr("[ %sSASL AUTO AUTH%s ] - %s (%s) is now connected successfuly to %s", GREEN, NOGC, user_obj.nickname, account, dnickname), + channel=dchanlog) + self.send_notice(nick_from=dnickname, nick_to=user_obj.nickname, msg=tr("Successfuly connected to %s", dnickname)) + + # ------------------------------------------------------------------------ + # COMMON IRC PARSER + # ------------------------------------------------------------------------ + + def parse_uid(self, serverMsg: list[str]) -> dict[str, str]: + """Parse UID and return dictionary. + + Args: + serverMsg (list[str]): _description_ + """ + umodes = str(serverMsg[11]) + remote_ip = serverMsg[9] if 'S' not in umodes else '127.0.0.1' + + # Extract Geoip information + pattern = r'^.*geoip=cc=(\S{2}).*$' + geoip_match = match(pattern, serverMsg[0]) + geoip = geoip_match.group(1) if geoip_match else None + + response = { + 'uid': str(serverMsg[2]), + 'nickname': str(serverMsg[4]), + 'username': str(serverMsg[7]), + 'hostname': str(serverMsg[5]), + 'umodes': umodes, + 'vhost': str(serverMsg[6]), + 'ip': remote_ip, + 'realname': ' '.join(serverMsg[12:]).lstrip(':'), + 'geoip': geoip, + 'reputation_score': 0, + 'iswebirc': True if 'webirc' in serverMsg[0] else False, + 'iswebsocket': True if 'websocket' in serverMsg[0] else False + } + return response + + def parse_quit(self, serverMsg: list[str]) -> dict[str, str]: + """Parse quit and return dictionary. + >>> [':97KAAAAAB', 'QUIT', ':Quit:', 'this', 'is', 'my', 'reason', 'to', 'quit'] + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The dictionary. + """ + scopy = serverMsg.copy() + + if scopy[0].startswith('@'): + scopy.pop(0) + + response = { + "uid": scopy[0].replace(':', ''), + "reason": " ".join(scopy[3:]) + } + return response + + def parse_nick(self, serverMsg: list[str]) -> dict[str, str]: + """Parse nick changes. + >>> [':97KAAAAAC', 'NICK', 'testinspir', '1757360740'] + + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + """ + scopy = serverMsg.copy() + if scopy[0].startswith('@'): + scopy.pop(0) + + response = { + "uid": scopy[0].replace(':', ''), + "newnickname": scopy[2], + "timestamp": scopy[3] + } + return response + + def parse_privmsg(self, serverMsg: list[str]) -> dict[str, str]: + """Parse PRIVMSG message. + >>> [':97KAAAAAE', 'PRIVMSG', '#welcome', ':This', 'is', 'my', 'public', 'message'] + >>> [':97KAAAAAF', 'PRIVMSG', '98KAAAAAB', ':My','Message','...'] + + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + """ + scopy = serverMsg.copy() + if scopy[0].startswith('@'): + scopy.pop(0) + + response = { + "uid_sender": scopy[0].replace(':', ''), + "uid_reciever": self.__Irc.User.get_uid(scopy[2]), + "channel": scopy[2] if self.__Irc.Channel.is_valid_channel(scopy[2]) else None, + "message": " ".join(scopy[3:]) + } + return response + + + # ------------------------------------------------------------------------ + # IRC SENDER METHODS + # ------------------------------------------------------------------------ + + def send_mode_chan(self, channel_name: str, channel_mode: str) -> None: + """_summary_ + + Args: + channel_name (str): _description_ + channel_mode (str): _description_ + """ + ... + + def send_gline(self, nickname: str, hostname: str, set_by: str, expire_timestamp: int, set_at_timestamp: int, reason: str) -> None: + """_summary_ + + Args: + nickname (str): _description_ + hostname (str): _description_ + set_by (str): _description_ + expire_timestamp (int): _description_ + set_at_timestamp (int): _description_ + reason (str): _description_ + """ + ... + + def send_sajoin(self, nick_to_sajoin: str, channel_name: str) -> None: + """_summary_ + + Args: + nick_to_sajoin (str): _description_ + channel_name (str): _description_ + """ + ... + + def send_sapart(self, nick_to_sapart: str, channel_name: str) -> None: + """_summary_ + + Args: + from_nick (str): _description_ + nick_to (str): _description_ + channel_name (str): _description_ + """ + ... + + def send_svs2mode(self, nickname: str, user_mode: str) -> None: + """_summary_ + + Args: + nickname (str): _description_ + user_mode (str): _description_ + """ + ... + + def send_svsjoin(self, nick_to_part: str, channels: list[str], keys: list[str]) -> None: + """_summary_ + + Args: + nick_to_part (str): _description_ + channels (list[str]): _description_ + keys (list[str]): _description_ + """ + ... + + def send_svslogin(self, client_uid: str, user_account: str) -> None: + """Log a client into his account. + + Args: + client_uid (str): Client UID + user_account (str): The account of the user + """ + ... + + def send_svslogout(self, client_obj: 'MClient') -> None: + """Logout a client from his account + + Args: + client_uid (str): The Client UID + """ + ... + + def send_svsmode(self, nickname: str, user_mode: str) -> None: + """_summary_ + + Args: + nickname (str): _description_ + user_mode (str): _description_ + """ + ... + + def send_svspart(self, nick_to_part: str, channels: list[str], reason: str) -> None: + """_summary_ + + Args: + nick_to_part (str): _description_ + channels (list[str]): _description_ + reason (str): _description_ + """ + ... + + def on_md(self, serverMsg: list[str]) -> None: + """Handle MD responses + [':001', 'MD', 'client', '001MYIZ03', 'certfp', ':d1235648...'] + Args: + serverMsg (list[str]): The server reply + """ + ... + + def on_mode(self, serverMsg: list[str]) -> None: + """Handle mode coming from a server + + Args: + serverMsg (list[str]): Original server message + """ + ... + + def on_reputation(self, serverMsg: list[str]) -> None: + """Handle REPUTATION coming from a server + + Args: + serverMsg (list[str]): Original server message + """ + ... + + def on_smod(self, serverMsg: list[str]) -> None: + """Handle SMOD message coming from the server + + Args: + serverMsg (list[str]): Original server message + """ + ... + + def on_svs2mode(self, serverMsg: list[str]) -> None: + """Handle svs2mode coming from a server + >>> [':00BAAAAAG', 'SVS2MODE', '001U01R03', '-r'] + + Args: + serverMsg (list[str]): Original server message + """ + ... + + def on_eos(self, serverMsg: list[str]) -> None: + """Handle EOS coming from a server + + Args: + serverMsg (list[str]): Original server message + """ + ... diff --git a/core/classes/protocols/interface.py b/core/classes/protocols/interface.py index 17005c9..00c2d1f 100644 --- a/core/classes/protocols/interface.py +++ b/core/classes/protocols/interface.py @@ -3,21 +3,31 @@ from typing import Optional, TYPE_CHECKING if TYPE_CHECKING: from core.classes.sasl import Sasl - from core.definition import MClient, MSasl + from core.definition import MClient, MSasl, MRegister + from core.classes.protocols.command_handler import CommandHandler class IProtocol(ABC): + DB_REGISTER: list['MRegister'] = [] + Handler: Optional['CommandHandler'] = None + @abstractmethod - def get_ircd_protocol_poisition(self, cmd: list[str]) -> tuple[int, Optional[str]]: + def get_ircd_protocol_poisition(self, cmd: list[str], log: bool = False) -> tuple[int, Optional[str]]: """Get the position of known commands Args: cmd (list[str]): The server response + log (bool): If true it will log in the logger Returns: tuple[int, Optional[str]]: The position and the command. """ + @abstractmethod + def register_command(self): + """Register all commands that you need to handle + """ + @abstractmethod def send2socket(self, message: str, print_log: bool = True) -> None: """Envoit les commandes à envoyer au serveur. @@ -74,6 +84,17 @@ class IProtocol(ABC): newnickname (str): New nickname of the server """ + @abstractmethod + def send_set_mode(self, modes: str, *, nickname: Optional[str] = None, channel_name: Optional[str] = None, params: Optional[str] = None) -> None: + """Set a mode to channel or to a nickname or for a user in a channel + + Args: + modes (str): The selected mode + nickname (Optional[str]): The nickname + channel_name (Optional[str]): The channel name + params (Optional[str]): Parameters like password. + """ + @abstractmethod def send_squit(self, server_id: str, server_link: str, reason: str) -> None: """_summary_ @@ -256,15 +277,72 @@ class IProtocol(ABC): @abstractmethod def send_raw(self, raw_command: str) -> None: - """_summary_ + """Send raw message to the server Args: - raw_command (str): _description_ + raw_command (str): The raw command you want to send. """ - ##################### - # HANDLE EVENTS # - ##################### + # ------------------------------------------------------------------------ + # COMMON IRC PARSER + # ------------------------------------------------------------------------ + + @abstractmethod + def parse_uid(self, serverMsg: list[str]) -> dict[str, str]: + """Parse UID and return dictionary. + + Args: + serverMsg (list[str]): The UID IRCD message + + Returns: + dict[str, str]: The response as dictionary. + """ + + @abstractmethod + def parse_quit(self, serverMsg: list[str]) -> dict[str, str]: + """Parse quit and return dictionary. + >>> [':97KAAAAAB', 'QUIT', ':Quit:', 'this', 'is', 'my', 'reason', 'to', 'quit'] + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + """ + + @abstractmethod + def parse_nick(self, serverMsg: list[str]) -> dict[str, str]: + """Parse nick changes and return dictionary. + >>> [':97KAAAAAC', 'NICK', 'testinspir', '1757360740'] + + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + """ + + @abstractmethod + def parse_privmsg(self, serverMsg: list[str]) -> dict[str, str]: + """Parse PRIVMSG message. + >>> [':97KAAAAAE', 'PRIVMSG', '#welcome', ':This', 'is', 'my', 'public', 'message'] + + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + ```python + response = { + "uid": '97KAAAAAE', + "channel": '#welcome', + "message": 'This is my public message' + } + ``` + """ + + # ------------------------------------------------------------------------ + # EVENT HANDLER + # ------------------------------------------------------------------------ @abstractmethod def on_svs2mode(self, serverMsg: list[str]) -> None: @@ -438,6 +516,17 @@ class IProtocol(ABC): psasl (Sasl): The SASL process object """ + @abstractmethod + def on_sasl_authentication_process(self, sasl_model: 'MSasl') -> bool: + """Finalize sasl authentication + + Args: + sasl_model (MSasl): The sasl dataclass model + + Returns: + bool: True if success + """ + @abstractmethod def on_md(self, serverMsg: list[str]) -> None: """Handle MD responses diff --git a/core/classes/protocols/unreal6.py b/core/classes/protocols/unreal6.py index 33581bb..8e10746 100644 --- a/core/classes/protocols/unreal6.py +++ b/core/classes/protocols/unreal6.py @@ -1,9 +1,10 @@ from base64 import b64decode from re import match, findall, search from datetime import datetime -from typing import TYPE_CHECKING, Optional +from typing import TYPE_CHECKING, Any, Optional from ssl import SSLEOFError, SSLError +from core.classes.protocols.command_handler import CommandHandler from core.classes.protocols.interface import IProtocol from core.utils import tr @@ -32,13 +33,16 @@ class Unrealircd6(IProtocol): 'PROTOCTL', 'SERVER', 'SMOD', 'TKL', 'NETINFO', '006', '007', '018'} - self.__Logs.info(f"** Loading protocol [{__name__}]") + self.Handler = CommandHandler(ircInstance.Loader) - def get_ircd_protocol_poisition(self, cmd: list[str]) -> tuple[int, Optional[str]]: + self.__Logs.info(f"[PROTOCOL] Protocol [{__name__}] loaded!") + + def get_ircd_protocol_poisition(self, cmd: list[str], log: bool = False) -> tuple[int, Optional[str]]: """Get the position of known commands Args: cmd (list[str]): The server response + log (bool): If true it will log in the logger Returns: tuple[int, Optional[str]]: The position and the command. @@ -47,10 +51,34 @@ class Unrealircd6(IProtocol): if token.upper() in self.known_protocol: return index, token.upper() - self.__Logs.debug(f"[IRCD LOGS] You need to handle this response: {cmd}") + if log: + self.__Logs.debug(f"[IRCD LOGS] You need to handle this response: {cmd}") return (-1, None) + def register_command(self) -> None: + m = self.__Irc.Loader.Definition.MIrcdCommand + self.Handler.register(m(command_name="PING", func=self.on_server_ping)) + self.Handler.register(m(command_name="UID", func=self.on_uid)) + self.Handler.register(m(command_name="QUIT", func=self.on_quit)) + self.Handler.register(m(command_name="SERVER", func=self.on_server)) + self.Handler.register(m(command_name="SJOIN", func=self.on_sjoin)) + self.Handler.register(m(command_name="EOS", func=self.on_eos)) + self.Handler.register(m(command_name="PROTOCTL", func=self.on_protoctl)) + self.Handler.register(m(command_name="SVS2MODE", func=self.on_svs2mode)) + self.Handler.register(m(command_name="SQUIT", func=self.on_squit)) + self.Handler.register(m(command_name="PART", func=self.on_part)) + self.Handler.register(m(command_name="VERSION", func=self.on_version_msg)) + self.Handler.register(m(command_name="UMODE2", func=self.on_umode2)) + self.Handler.register(m(command_name="NICK", func=self.on_nick)) + self.Handler.register(m(command_name="REPUTATION", func=self.on_reputation)) + self.Handler.register(m(command_name="SMOD", func=self.on_smod)) + self.Handler.register(m(command_name="SASL", func=self.on_sasl)) + self.Handler.register(m(command_name="MD", func=self.on_md)) + self.Handler.register(m(command_name="PRIVMSG", func=self.on_privmsg)) + + return None + def parse_server_msg(self, server_msg: list[str]) -> Optional[str]: """Parse the server message and return the command @@ -229,6 +257,42 @@ class Unrealircd6(IProtocol): self.__Irc.User.update_nickname(userObj.uid, newnickname) return None + def send_set_mode(self, modes: str, *, nickname: Optional[str] = None, channel_name: Optional[str] = None, params: Optional[str] = None) -> None: + """Set a mode to channel or to a nickname or for a user in a channel + + Args: + modes (str): The selected mode + nickname (Optional[str]): The nickname + channel_name (Optional[str]): The channel name + params (Optional[str]): Parameters like password. + """ + service_id = self.__Config.SERVICE_ID + + if modes[0] not in ['+', '-']: + self.__Logs.error(f"[MODE ERROR] The mode you have provided is missing the sign: {modes}") + return None + + if nickname and channel_name: + # :98KAAAAAB MODE #services +o defenderdev + if not self.__Irc.Channel.is_valid_channel(channel_name): + self.__Logs.error(f"[MODE ERROR] The channel is not valid: {channel_name}") + return None + self.send2socket(f":{service_id} MODE {channel_name} {modes} {nickname}") + return None + + if nickname and channel_name is None: + self.send2socket(f":{service_id} MODE {nickname} {modes}") + return None + + if nickname is None and channel_name: + if not self.__Irc.Channel.is_valid_channel(channel_name): + self.__Logs.error(f"[MODE ERROR] The channel is not valid: {channel_name}") + return None + self.send2socket(f":{service_id} MODE {channel_name} {modes} {params}") + return None + + return None + def send_squit(self, server_id: str, server_link: str, reason: str) -> None: if not reason: @@ -431,7 +495,7 @@ class Unrealircd6(IProtocol): reason (str): The reason for the quit """ user_obj = self.__Irc.User.get_user(uidornickname=uid) - reputationObj = self.__Irc.Reputation.get_Reputation(uidornickname=uid) + reputationObj = self.__Irc.Reputation.get_reputation(uidornickname=uid) if not user_obj is None: self.send2socket(f":{user_obj.uid} QUIT :{reason}", print_log=print_log) @@ -565,6 +629,103 @@ class Unrealircd6(IProtocol): return None + # ------------------------------------------------------------------------ + # COMMON IRC PARSER + # ------------------------------------------------------------------------ + + def parse_uid(self, serverMsg: list[str]) -> dict[str, str]: + """Parse UID and return dictionary. + >>> ['@s2s-md/geoip=cc=GBtag...', ':001', 'UID', 'albatros', '0', '1721564597', 'albatros', 'hostname...', '001HB8G04', '0', '+iwxz', 'hostname-vhost', 'hostname-vhost', 'MyZBwg==', ':...'] + Args: + serverMsg (list[str]): The UID ircd response + """ + umodes = str(serverMsg[10]) + remote_ip = self.__Base.decode_ip(str(serverMsg[13])) if 'S' not in umodes else '127.0.0.1' + + # Extract Geoip information + pattern = r'^.*geoip=cc=(\S{2}).*$' + geoip_match = match(pattern, serverMsg[0]) + geoip = geoip_match.group(1) if geoip_match else None + + response = { + 'uid': str(serverMsg[8]), + 'nickname': str(serverMsg[3]), + 'username': str(serverMsg[6]), + 'hostname': str(serverMsg[7]), + 'umodes': umodes, + 'vhost': str(serverMsg[11]), + 'ip': remote_ip, + 'realname': ' '.join(serverMsg[12:]).lstrip(':'), + 'geoip': geoip, + 'reputation_score': 0, + 'iswebirc': True if 'webirc' in serverMsg[0] else False, + 'iswebsocket': True if 'websocket' in serverMsg[0] else False + } + return response + + def parse_quit(self, serverMsg: list[str]) -> dict[str, str]: + """Parse quit and return dictionary. + >>> # ['@unrealtag...', ':001JKNY0N', 'QUIT', ':Quit:', '....'] + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The dictionary. + """ + scopy = serverMsg.copy() + if scopy[0].startswith('@'): + scopy.pop(0) + + response = { + "uid": scopy[0].replace(':', ''), + "reason": " ".join(scopy[3:]) + } + return response + + def parse_nick(self, serverMsg: list[str]) -> dict[str, str]: + """Parse nick changes and return dictionary. + >>> ['@unrealircd.org/geoip=FR;unrealircd.org/', ':001OOU2H3', 'NICK', 'WebIrc', '1703795844'] + + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + """ + scopy = serverMsg.copy() + if scopy[0].startswith('@'): + scopy.pop(0) + + response = { + "uid": scopy[0].replace(':', ''), + "newnickname": scopy[2], + "timestamp": scopy[3] + } + return response + + def parse_privmsg(self, serverMsg: list[str]) -> dict[str, str]: + """Parse PRIVMSG message. + >>> ['@....', ':97KAAAAAE', 'PRIVMSG', '#welcome', ':This', 'is', 'my', 'public', 'message'] + >>> [':97KAAAAAF', 'PRIVMSG', '98KAAAAAB', ':sasa'] + + Args: + serverMsg (list[str]): The server message to parse + + Returns: + dict[str, str]: The response as dictionary. + """ + scopy = serverMsg.copy() + if scopy[0].startswith('@'): + scopy.pop(0) + + response = { + "uid_sender": scopy[0].replace(':', ''), + "uid_reciever": self.__Irc.User.get_uid(scopy[2]), + "channel": scopy[2] if self.__Irc.Channel.is_valid_channel(scopy[2]) else None, + "message": " ".join(scopy[3:]) + } + return response + ##################### # HANDLE EVENTS # ##################### @@ -736,6 +897,7 @@ class Unrealircd6(IProtocol): self.__Irc.User.update_nickname(uid, newnickname) self.__Irc.Client.update_nickname(uid, newnickname) self.__Irc.Admin.update_nickname(uid, newnickname) + self.__Irc.Reputation.update(uid, newnickname) return None @@ -856,6 +1018,8 @@ class Unrealircd6(IProtocol): self.__Logs.info(f"# VERSION : {version} ") self.__Logs.info(f"################################################") + self.send_sjoin(self.__Config.SERVICE_CHANLOG) + if self.__Base.check_for_new_version(False): self.send_priv_msg( nick_from=self.__Config.SERVICE_NICKNAME, @@ -875,6 +1039,10 @@ class Unrealircd6(IProtocol): for module in self.__Irc.ModuleUtils.model_get_loaded_modules().copy(): module.class_instance.cmd(server_msg_copy) + # Join saved channels & load existing modules + self.__Irc.join_saved_channels() + self.__Irc.ModuleUtils.db_load_all_existing_modules(self.__Irc) + return None except IndexError as ie: self.__Logs.error(f"{__name__} - Key Error: {ie}") @@ -988,14 +1156,42 @@ class Unrealircd6(IProtocol): dnickname = self.__Config.SERVICE_NICKNAME dchanlog = self.__Config.SERVICE_CHANLOG GREEN = self.__Config.COLORS.green + RED = self.__Config.COLORS.red NOGC = self.__Config.COLORS.nogc + for module in self.__Irc.ModuleUtils.model_get_loaded_modules().copy(): + module.class_instance.cmd(serverMsg) + + # SASL authentication + # ['@s2s-md/..', ':001', 'UID', 'adator__', '0', '1755987444', '...', 'desktop-h1qck20.mshome.net', '001XLTT0U', '0', '+iwxz', '*', 'Clk-EC2256B2.mshome.net', 'rBKAAQ==', ':...'] + + uid = serverMsg[8] + nickname = serverMsg[3] + sasl_obj = self.__Irc.Sasl.get_sasl_obj(uid) + if sasl_obj: + if sasl_obj.auth_success: + self.__Irc.insert_db_admin(sasl_obj.client_uid, sasl_obj.username, sasl_obj.level, sasl_obj.language) + self.send_priv_msg(nick_from=dnickname, + msg=tr("[ %sSASL AUTH%s ] - %s (%s) is now connected successfuly to %s", GREEN, NOGC, nickname, sasl_obj.username, dnickname), + channel=dchanlog) + self.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Successfuly connected to %s", dnickname)) + else: + self.send_priv_msg(nick_from=dnickname, + msg=tr("[ %sSASL AUTH%s ] - %s provided a wrong password for this username %s", RED, NOGC, nickname, sasl_obj.username), + channel=dchanlog) + self.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Wrong password!")) + + # Delete sasl object! + self.__Irc.Sasl.delete_sasl_client(uid) + return None + + # If no sasl authentication then auto connect via fingerprint if self.__Irc.Admin.db_auth_admin_via_fingerprint(fingerprint, uid): admin = self.__Irc.Admin.get_admin(uid) account = admin.account if admin else '' self.send_priv_msg(nick_from=dnickname, - msg=tr("[ %sSASL AUTO AUTH%s ] - %s (%s) is now connected successfuly to %s", GREEN, NOGC, nickname, account, dnickname), - channel=dchanlog) + msg=tr("[ %sSASL AUTO AUTH%s ] - %s (%s) is now connected successfuly to %s", GREEN, NOGC, nickname, account, dnickname), + channel=dchanlog) self.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Successfuly connected to %s", dnickname)) return None @@ -1254,7 +1450,7 @@ class Unrealircd6(IProtocol): except Exception as err: self.__Logs.error(f'General Error: {err}') - def on_sasl(self, serverMsg: list[str], psasl: 'Sasl') -> Optional['MSasl']: + def on_sasl(self, serverMsg: list[str]) -> Optional['MSasl']: """Handle SASL coming from a server Args: @@ -1267,7 +1463,7 @@ class Unrealircd6(IProtocol): # [':irc.local.org', 'SASL', 'defender-dev.deb.biz.st', '0014ZZH1F', 'S', 'EXTERNAL', 'zzzzzzzkey'] # [':irc.local.org', 'SASL', 'defender-dev.deb.biz.st', '00157Z26U', 'C', 'sasakey=='] # [':irc.local.org', 'SASL', 'defender-dev.deb.biz.st', '00157Z26U', 'D', 'A'] - + psasl = self.__Irc.Sasl sasl_enabled = False for smod in self.__Settings.SMOD_MODULES: if smod.name == 'sasl': @@ -1307,6 +1503,7 @@ class Unrealircd6(IProtocol): sasl_obj.fingerprint = str(sCopy[6]) self.send2socket(f":{self.__Config.SERVEUR_LINK} SASL {self.__Settings.MAIN_SERVER_HOSTNAME} {sasl_obj.client_uid} C +") + self.on_sasl_authentication_process(sasl_obj) return sasl_obj case 'C': @@ -1319,14 +1516,64 @@ class Unrealircd6(IProtocol): sasl_obj.username = username sasl_obj.password = password + self.on_sasl_authentication_process(sasl_obj) return sasl_obj elif sasl_obj.mechanisme == "EXTERNAL": sasl_obj.message_type = sasl_message_type + + self.on_sasl_authentication_process(sasl_obj) return sasl_obj except Exception as err: self.__Logs.error(f'General Error: {err}', exc_info=True) + def on_sasl_authentication_process(self, sasl_model: 'MSasl') -> bool: + s = sasl_model + if sasl_model: + def db_get_admin_info(*, username: Optional[str] = None, password: Optional[str] = None, fingerprint: Optional[str] = None) -> Optional[dict[str, Any]]: + if fingerprint: + mes_donnees = {'fingerprint': fingerprint} + query = f"SELECT user, level, language FROM {self.__Config.TABLE_ADMIN} WHERE fingerprint = :fingerprint" + else: + mes_donnees = {'user': username, 'password': self.__Utils.hash_password(password)} + query = f"SELECT user, level, language FROM {self.__Config.TABLE_ADMIN} WHERE user = :user AND password = :password" + + result = self.__Base.db_execute_query(query, mes_donnees) + user_from_db = result.fetchone() + if user_from_db: + return {'user': user_from_db[0], 'level': user_from_db[1], 'language': user_from_db[2]} + else: + return None + + if s.message_type == 'C' and s.mechanisme == 'PLAIN': + # Connection via PLAIN + admin_info = db_get_admin_info(username=s.username, password=s.password) + if admin_info is not None: + s.auth_success = True + s.level = admin_info.get('level', 0) + s.language = admin_info.get('language', 'EN') + self.send2socket(f":{self.__Config.SERVEUR_LINK} SASL {self.__Settings.MAIN_SERVER_HOSTNAME} {s.client_uid} D S") + self.send2socket(f":{self.__Config.SERVEUR_LINK} 903 {s.username} :SASL authentication successful") + else: + self.send2socket(f":{self.__Config.SERVEUR_LINK} SASL {self.__Settings.MAIN_SERVER_HOSTNAME} {s.client_uid} D F") + self.send2socket(f":{self.__Config.SERVEUR_LINK} 904 {s.username} :SASL authentication failed") + + elif s.message_type == 'S' and s.mechanisme == 'EXTERNAL': + # Connection using fingerprints + admin_info = db_get_admin_info(fingerprint=s.fingerprint) + + if admin_info is not None: + s.auth_success = True + s.level = admin_info.get('level', 0) + s.username = admin_info.get('user', None) + s.language = admin_info.get('language', 'EN') + self.send2socket(f":{self.__Config.SERVEUR_LINK} SASL {self.__Settings.MAIN_SERVER_HOSTNAME} {s.client_uid} D S") + self.send2socket(f":{self.__Config.SERVEUR_LINK} 903 {s.username} :SASL authentication successful") + else: + # "904 :SASL authentication failed" + self.send2socket(f":{self.__Config.SERVEUR_LINK} SASL {self.__Settings.MAIN_SERVER_HOSTNAME} {s.client_uid} D F") + self.send2socket(f":{self.__Config.SERVEUR_LINK} 904 {s.username} :SASL authentication failed") + def on_md(self, serverMsg: list[str]) -> None: """Handle MD responses [':001', 'MD', 'client', '001MYIZ03', 'certfp', ':d1235648...'] diff --git a/core/classes/rehash.py b/core/classes/rehash.py index 72a2465..3f85ed3 100644 --- a/core/classes/rehash.py +++ b/core/classes/rehash.py @@ -33,14 +33,8 @@ def restart_service(uplink: 'Irc', reason: str = "Restarting with no reason!") - uplink.Client.CLIENT_DB.clear() # Clear Client object uplink.Base.garbage_collector_thread() - # Reload configuration - uplink.Config = uplink.Loader.ConfModule.Configuration(uplink.Loader).get_config_model() - uplink.Base = uplink.Loader.BaseModule.Base(uplink.Loader) - uplink.Protocol = uplink.Loader.PFactory.get() uplink.Logs.debug(f'[{uplink.Config.SERVICE_NICKNAME} RESTART]: Reloading configuration!') - uplink.Protocol.send_squit(server_id=uplink.Config.SERVEUR_ID, server_link=uplink.Config.SERVEUR_LINK, reason="Defender Power off") - uplink.Logs.debug('Restarting Defender ...') uplink.IrcSocket.shutdown(socket.SHUT_RDWR) uplink.IrcSocket.close() @@ -49,11 +43,19 @@ def restart_service(uplink: 'Irc', reason: str = "Restarting with no reason!") - time.sleep(0.5) uplink.Logs.warning('-- Waiting for socket to close ...') + # Reload configuration + uplink.Loader.Config = uplink.Loader.ConfModule.Configuration(uplink.Loader).get_config_model() + uplink.Loader.Base = uplink.Loader.BaseModule.Base(uplink.Loader) + + for mod in REHASH_MODULES: + importlib.reload(sys.modules[mod]) + + uplink.Protocol = uplink.Loader.PFactory.get() + uplink.Protocol.register_command() + uplink.init_service_user() uplink.Utils.create_socket(uplink) uplink.Protocol.send_link() - uplink.join_saved_channels() - uplink.ModuleUtils.db_load_all_existing_modules(uplink) uplink.Config.DEFENDER_RESTART = 0 def rehash_service(uplink: 'Irc', nickname: str) -> None: @@ -70,13 +72,13 @@ def rehash_service(uplink: 'Irc', nickname: str) -> None: channel=uplink.Config.SERVICE_CHANLOG ) uplink.Utils = sys.modules['core.utils'] - uplink.Config = uplink.Loader.ConfModule.Configuration(uplink.Loader).get_config_model() - uplink.Config.HSID = config_model_bakcup.HSID - uplink.Config.DEFENDER_INIT = config_model_bakcup.DEFENDER_INIT - uplink.Config.DEFENDER_RESTART = config_model_bakcup.DEFENDER_RESTART - uplink.Config.SSL_VERSION = config_model_bakcup.SSL_VERSION - uplink.Config.CURRENT_VERSION = config_model_bakcup.CURRENT_VERSION - uplink.Config.LATEST_VERSION = config_model_bakcup.LATEST_VERSION + uplink.Loader.Config = uplink.Loader.ConfModule.Configuration(uplink.Loader).get_config_model() + uplink.Loader.Config.HSID = config_model_bakcup.HSID + uplink.Loader.Config.DEFENDER_INIT = config_model_bakcup.DEFENDER_INIT + uplink.Loader.Config.DEFENDER_RESTART = config_model_bakcup.DEFENDER_RESTART + uplink.Loader.Config.SSL_VERSION = config_model_bakcup.SSL_VERSION + uplink.Loader.Config.CURRENT_VERSION = config_model_bakcup.CURRENT_VERSION + uplink.Loader.Config.LATEST_VERSION = config_model_bakcup.LATEST_VERSION conf_bkp_dict: dict = config_model_bakcup.to_dict() config_dict: dict = uplink.Config.to_dict() @@ -105,8 +107,9 @@ def rehash_service(uplink: 'Irc', nickname: str) -> None: uplink.Commands = uplink.Loader.CommandModule.Command(uplink.Loader) uplink.Commands.DB_COMMANDS = uplink.Settings.get_cache('db_commands') - uplink.Base = uplink.Loader.BaseModule.Base(uplink.Loader) + uplink.Loader.Base = uplink.Loader.BaseModule.Base(uplink.Loader) uplink.Protocol = uplink.Loader.PFactory.get() + uplink.Protocol.register_command() # Reload Service modules for module in uplink.ModuleUtils.model_get_loaded_modules().copy(): diff --git a/core/classes/reputation.py b/core/classes/reputation.py index 859f62c..3ee0d47 100644 --- a/core/classes/reputation.py +++ b/core/classes/reputation.py @@ -53,7 +53,7 @@ class Reputation: bool: True if updated """ - reputation_obj = self.get_Reputation(uid) + reputation_obj = self.get_reputation(uid) if reputation_obj is None: return False @@ -89,7 +89,7 @@ class Reputation: return result - def get_Reputation(self, uidornickname: str) -> Optional[MReputation]: + def get_reputation(self, uidornickname: str) -> Optional[MReputation]: """Get The User Object model Args: @@ -116,7 +116,7 @@ class Reputation: str|None: Return the UID """ - reputation_obj = self.get_Reputation(uidornickname) + reputation_obj = self.get_reputation(uidornickname) if reputation_obj is None: return None @@ -132,7 +132,7 @@ class Reputation: Returns: str|None: the nickname """ - reputation_obj = self.get_Reputation(uidornickname) + reputation_obj = self.get_reputation(uidornickname) if reputation_obj is None: return None @@ -149,7 +149,7 @@ class Reputation: bool: True if exist """ - reputation_obj = self.get_Reputation(uidornickname) + reputation_obj = self.get_reputation(uidornickname) if isinstance(reputation_obj, MReputation): return True diff --git a/core/classes/settings.py b/core/classes/settings.py index 2eccdac..fa503aa 100644 --- a/core/classes/settings.py +++ b/core/classes/settings.py @@ -8,7 +8,6 @@ from core.definition import MSModule, MAdmin if TYPE_CHECKING: from core.classes.user import User - from core.classes.admin import Admin class Settings: """This Class will never be reloaded. @@ -25,7 +24,11 @@ class Settings: CONSOLE: bool = False MAIN_SERVER_HOSTNAME: str = None + MAIN_SERVER_ID: str = None + PROTOCTL_PREFIX_MODES_SIGNES : dict[str, str] = {} + PROTOCTL_PREFIX_SIGNES_MODES : dict[str, str] = {} PROTOCTL_USER_MODES: list[str] = [] + PROTOCTL_CHANNEL_MODES: list[str] = [] PROTOCTL_PREFIX: list[str] = [] SMOD_MODULES: list[MSModule] = [] @@ -42,7 +45,7 @@ class Settings: __INSTANCE_OF_USER_UTILS: Optional['User'] = None """Instance of the User Utils class""" - __CURRENT_ADMIN: Optional['MAdmin'] = None + __CURRENT_ADMIN: Optional['MAdmin'] = None """The Current Admin Object Model""" __LOGGER: Optional[Logger] = None @@ -79,6 +82,7 @@ class Settings: @property def global_translation(self) -> dict[str, list[list[str]]]: + """Get/set global translation variable""" return self.__TRANSLATION @global_translation.setter @@ -87,6 +91,7 @@ class Settings: @property def global_lang(self) -> str: + """Global default language.""" return self.__LANG @global_lang.setter @@ -103,6 +108,7 @@ class Settings: @property def current_admin(self) -> MAdmin: + """Current admin data model.""" return self.__CURRENT_ADMIN @current_admin.setter @@ -111,6 +117,7 @@ class Settings: @property def global_logger(self) -> Logger: + """Global logger Instance""" return self.__LOGGER @global_logger.setter diff --git a/core/classes/user.py b/core/classes/user.py index db0b50a..aff0963 100644 --- a/core/classes/user.py +++ b/core/classes/user.py @@ -55,7 +55,7 @@ class User: return False user_obj.nickname = new_nickname - + self.Logs.debug(f"UID ({uid}) has benn update with new nickname ({new_nickname}).") return True def update_mode(self, uidornickname: str, modes: str) -> bool: diff --git a/core/definition.py b/core/definition.py index 5e826af..d8a6e05 100644 --- a/core/definition.py +++ b/core/definition.py @@ -93,6 +93,7 @@ class MReputation(MainModel): umodes: str = None vhost: str = None fingerprint: str = None + tls_cipher: str = None isWebirc: bool = False isWebsocket: bool = False remote_ip: str = None @@ -368,4 +369,14 @@ class MSasl(MainModel): fingerprint: Optional[str] = None language: str = "EN" auth_success: bool = False - level: int = 0 \ No newline at end of file + level: int = 0 + +@dataclass +class MRegister: + command_name: str + func: Any + +@dataclass +class MIrcdCommand: + command_name: str + func: Any \ No newline at end of file diff --git a/core/irc.py b/core/irc.py index 689e8e9..3239c1b 100644 --- a/core/irc.py +++ b/core/irc.py @@ -165,10 +165,10 @@ class Irc: try: self.init_service_user() self.Protocol: 'IProtocol' = self.Loader.PFactory.get() + self.Protocol.register_command() self.Protocol.send_link() # Etablir le link en fonction du protocol choisi self.signal = True # Une variable pour initier la boucle infinie - self.join_saved_channels() # Join existing channels - time.sleep(3) + # self.join_saved_channels() # Join existing channels # self.ModuleUtils.db_load_all_existing_modules(self) while self.signal: @@ -219,7 +219,7 @@ class Irc: except ssl.SSLEOFError as soe: self.Logs.error(f"SSLEOFError: {soe}") except AttributeError as atte: - self.Logs.critical(f"AttributeError: {atte}") + self.Logs.critical(f"AttributeError: {atte}", exc_info=True) except Exception as e: self.Logs.critical(f"General Error: {e}", exc_info=True) @@ -260,9 +260,9 @@ class Irc: # This is only to reference the method return None - ############################################## + # -------------------------------------------- # FIN CONNEXION IRC # - ############################################## + # -------------------------------------------- def build_command(self, level: int, module_name: str, command_name: str, command_description: str) -> None: """This method build the commands variable @@ -489,116 +489,12 @@ class Irc: return None self.Logs.debug(f">> {self.Utils.hide_sensitive_data(original_response)}") - # parsed_protocol = self.Protocol.parse_server_msg(original_response.copy()) - pos, parsed_protocol = self.Protocol.get_ircd_protocol_poisition(cmd=original_response) - match parsed_protocol: - case 'PING': - self.Protocol.on_server_ping(serverMsg=original_response) + pos, parsed_protocol = self.Protocol.get_ircd_protocol_poisition(cmd=original_response, log=True) - case 'SERVER': - self.Protocol.on_server(serverMsg=original_response) - - case 'SJOIN': - self.Protocol.on_sjoin(serverMsg=original_response) - - case 'EOS': - self.Protocol.on_eos(serverMsg=original_response) - - case 'UID': - try: - self.Protocol.on_uid(serverMsg=original_response) - for module in self.ModuleUtils.model_get_loaded_modules().copy(): - module.class_instance.cmd(original_response) - - # SASL authentication - # ['@s2s-md/..', ':001', 'UID', 'adator__', '0', '1755987444', '...', 'desktop-h1qck20.mshome.net', '001XLTT0U', '0', '+iwxz', '*', 'Clk-EC2256B2.mshome.net', 'rBKAAQ==', ':...'] - dnickname = self.Config.SERVICE_NICKNAME - dchanlog = self.Config.SERVICE_CHANLOG - uid = original_response[8] - nickname = original_response[3] - sasl_obj = self.Sasl.get_sasl_obj(uid) - if sasl_obj: - if sasl_obj.auth_success: - self.insert_db_admin(sasl_obj.client_uid, sasl_obj.username, sasl_obj.level, sasl_obj.language) - self.Protocol.send_priv_msg(nick_from=dnickname, - msg=tr("[ %sSASL AUTH%s ] - %s (%s) is now connected successfuly to %s", GREEN, NOGC, nickname, sasl_obj.username, dnickname), - channel=dchanlog) - self.Protocol.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Successfuly connected to %s", dnickname)) - else: - self.Protocol.send_priv_msg(nick_from=dnickname, - msg=tr("[ %sSASL AUTH%s ] - %s provided a wrong password for this username %s", RED, NOGC, nickname, sasl_obj.username), - channel=dchanlog) - self.Protocol.send_notice(nick_from=dnickname, nick_to=nickname, msg=tr("Wrong password!")) - - # Delete sasl object! - self.Sasl.delete_sasl_client(uid) - - return None - except Exception as err: - self.Logs.error(f'General Error: {err}') - - case 'QUIT': - self.Protocol.on_quit(serverMsg=original_response) - - case 'PROTOCTL': - self.Protocol.on_protoctl(serverMsg=original_response) - - case 'SVS2MODE': - self.Protocol.on_svs2mode(serverMsg=original_response) - - case 'SQUIT': - self.Protocol.on_squit(serverMsg=original_response) - - case 'PART': - self.Protocol.on_part(serverMsg=original_response) - - case 'VERSION': - self.Protocol.on_version_msg(serverMsg=original_response) - - case 'UMODE2': - self.Protocol.on_umode2(serverMsg=original_response) - - case 'NICK': - self.Protocol.on_nick(serverMsg=original_response) - - case 'REPUTATION': - self.Protocol.on_reputation(serverMsg=original_response) - - case 'SMOD': - self.Protocol.on_smod(original_response) - - case 'SASL': - sasl_response = self.Protocol.on_sasl(original_response, self.Sasl) - self.on_sasl_authentication_process(sasl_response) - - case 'MD': - self.Protocol.on_md(serverMsg=original_response) - - case 'PRIVMSG': - self.Protocol.on_privmsg(serverMsg=original_response) - - case 'SLOG': # TODO - self.Logs.debug(f"[!] TO HANDLE: {parsed_protocol}") - - case 'PONG': # TODO - self.Logs.debug(f"[!] TO HANDLE: {parsed_protocol}") - - case 'MODE': # TODO - #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6...', ':001', 'MODE', '#a', '+nt', '1723207536'] - #['@unrealircd.org/userhost=adator@localhost;...', ':001LQ0L0C', 'MODE', '#services', '-l'] - self.Logs.debug(f"[!] TO HANDLE: {parsed_protocol}") - - case '320': # TODO - #:irc.deb.biz.st 320 PyDefender IRCParis07 :is in security-groups: known-users,webirc-users,tls-and-known-users,tls-users - self.Logs.debug(f"[!] TO HANDLE: {parsed_protocol}") - - case '318': # TODO - #:irc.deb.biz.st 318 PyDefender IRCParis93 :End of /WHOIS list. - self.Logs.debug(f"[!] TO HANDLE: {parsed_protocol}") - - case None: - self.Logs.debug(f"[!] TO HANDLE: {original_response}") + for parsed in self.Protocol.Handler.get_ircd_commands(): + if parsed.command_name.upper() == parsed_protocol: + parsed.func(original_response) if len(original_response) > 2: if original_response[2] != 'UID': @@ -1154,7 +1050,8 @@ class Irc: self.Base.execute_periodic_action() for chan_name in self.Channel.UID_CHANNEL_DB: - self.Protocol.send_mode_chan(chan_name.name, '-l') + # self.Protocol.send_mode_chan(chan_name.name, '-l') + self.Protocol.send_set_mode('-l', channel_name=chan_name.name) for client in self.Client.CLIENT_DB: self.Protocol.send_svslogout(client) @@ -1207,7 +1104,7 @@ class Irc: self.Protocol.send_notice( nick_from=dnickname, nick_to=fromuser, - msg=tr('%s - %sNot Loaded%s', module, GREEN, NOGC) + msg=tr('%s - %sNot Loaded%s', module, RED, NOGC) ) case 'show_timers': diff --git a/defender.py b/defender.py index 6b5e1bc..81ec0f5 100644 --- a/defender.py +++ b/defender.py @@ -1,7 +1,7 @@ from core import installation ############################################# -# @Version : 6.2 # +# @Version : 6.3 # # Requierements : # # Python3.10 or higher # # SQLAlchemy, requests, psutil # diff --git a/mods/clone/mod_clone.py b/mods/clone/mod_clone.py index 29a1dd6..ee73e63 100644 --- a/mods/clone/mod_clone.py +++ b/mods/clone/mod_clone.py @@ -78,11 +78,11 @@ class Clone: self.__load_module_configuration() self.Channel.db_query_channel(action='add', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL) - self.Protocol.send_join_chan(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL) + self.Protocol.send_sjoin(self.Config.CLONE_CHANNEL) + self.Protocol.send_set_mode('+o', nickname=self.Config.SERVICE_NICKNAME, channel_name=self.Config.CLONE_CHANNEL) + self.Protocol.send_set_mode('+nts', channel_name=self.Config.CLONE_CHANNEL) + self.Protocol.send_set_mode('+k', channel_name=self.Config.CLONE_CHANNEL, params=self.Config.CLONE_CHANNEL_PASSWORD) - self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {self.Config.CLONE_CHANNEL} +o {self.Config.SERVICE_NICKNAME}") - self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +nts") - self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +k {self.Config.CLONE_CHANNEL_PASSWORD}") def __create_tables(self) -> None: """Methode qui va créer la base de donnée si elle n'existe pas. @@ -127,8 +127,8 @@ class Clone: self.Settings.set_cache('UID_CLONE_DB', self.Clone.UID_CLONE_DB) self.Channel.db_query_channel(action='del', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL) - self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -nts") - self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -k {self.Config.CLONE_CHANNEL_PASSWORD}") + self.Protocol.send_set_mode('-nts', channel_name=self.Config.CLONE_CHANNEL) + self.Protocol.send_set_mode('-k', channel_name=self.Config.CLONE_CHANNEL) self.Protocol.send_part_chan(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL) self.Irc.Commands.drop_command_by_module(self.module_name) @@ -148,7 +148,8 @@ class Clone: match command: case 'PRIVMSG': - return self.Utils.handle_on_privmsg(self, cmd) + self.Utils.handle_on_privmsg(self, cmd) + return None case 'QUIT': return None diff --git a/mods/clone/utils.py b/mods/clone/utils.py index e2b5759..495252e 100644 --- a/mods/clone/utils.py +++ b/mods/clone/utils.py @@ -174,17 +174,17 @@ def create_new_clone(uplink: 'Clone', faker_instance: 'Faker', group: str = 'Def return True -def handle_on_privmsg(uplink: 'Clone', srvmsg: list[str]): +def handle_on_privmsg(uplink: 'Clone', srvmsg: list[str]) -> None: - uid_sender = uplink.Irc.Utils.clean_uid(srvmsg[1]) + parser = uplink.Protocol.parse_privmsg(srvmsg) + uid_sender = uplink.Irc.Utils.clean_uid(parser.get('uid_sender', None)) senderObj = uplink.User.get_user(uid_sender) - if senderObj.hostname in uplink.Config.CLONE_LOG_HOST_EXEMPT: - return - - if not senderObj is None: - senderMsg = ' '.join(srvmsg[4:]) - clone_obj = uplink.Clone.get_clone(srvmsg[3]) + if senderObj is not None: + if senderObj.hostname in uplink.Config.CLONE_LOG_HOST_EXEMPT: + return + senderMsg = parser.get('message', None) + clone_obj = uplink.Clone.get_clone(parser.get('uid_reciever', None)) if clone_obj is None: return @@ -196,3 +196,5 @@ def handle_on_privmsg(uplink: 'Clone', srvmsg: list[str]): msg=final_message, channel=uplink.Config.CLONE_CHANNEL ) + + return None diff --git a/mods/command/utils.py b/mods/command/utils.py index b7a40dc..d7ef806 100644 --- a/mods/command/utils.py +++ b/mods/command/utils.py @@ -134,17 +134,20 @@ def set_operation(uplink: 'Command', cmd: list[str], channel_name: Optional[str] return False if len(cmd) == 1: - uplink.Protocol.send2socket(f":{dnickname} MODE {channel_name} {mode} {client}") + # uplink.Protocol.send2socket(f":{service_id} MODE {channel_name} {mode} {client}") + uplink.Protocol.send_set_mode(mode, nickname=client, channel_name=channel_name) return None # deop nickname if len(cmd) == 2: nickname = cmd[1] - uplink.Protocol.send2socket(f":{service_id} MODE {channel_name} {mode} {nickname}") + # uplink.Protocol.send2socket(f":{service_id} MODE {channel_name} {mode} {nickname}") + uplink.Protocol.send_set_mode(mode, nickname=nickname, channel_name=channel_name) return None nickname = cmd[2] - uplink.Protocol.send2socket(f":{service_id} MODE {channel_name} {mode} {nickname}") + # uplink.Protocol.send2socket(f":{service_id} MODE {channel_name} {mode} {nickname}") + uplink.Protocol.send_set_mode(mode, nickname=nickname, channel_name=channel_name) return None def set_ban(uplink: 'Command', cmd: list[str], action: Literal['+', '-'], client: str) -> None: diff --git a/mods/defender/mod_defender.py b/mods/defender/mod_defender.py index b861607..c5a674d 100644 --- a/mods/defender/mod_defender.py +++ b/mods/defender/mod_defender.py @@ -365,7 +365,7 @@ class Defender: release_code = cmd[1] jailed_nickname = self.User.get_nickname(fromuser) jailed_UID = self.User.get_uid(fromuser) - get_reputation = self.Reputation.get_Reputation(jailed_UID) + get_reputation = self.Reputation.get_reputation(jailed_UID) if get_reputation is None: self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=" No code is requested ...") @@ -551,7 +551,7 @@ class Defender: msg=f"This nickname ({str(cmd[2])}) is not connected to the network!") return None - client_to_release = self.Reputation.get_Reputation(client_obj.uid) + client_to_release = self.Reputation.get_reputation(client_obj.uid) if client_to_release is None: p.send_notice(nick_from=dnickname, diff --git a/mods/defender/utils.py b/mods/defender/utils.py index bf85d0d..5c3d155 100644 --- a/mods/defender/utils.py +++ b/mods/defender/utils.py @@ -87,7 +87,7 @@ def handle_on_sjoin(uplink: 'Defender', srvmsg: list[str]): return if confmodel.reputation == 1: - get_reputation = irc.Reputation.get_Reputation(parsed_UID) + get_reputation = irc.Reputation.get_reputation(parsed_UID) if parsed_chan != gconfig.SALON_JAIL: p.send2socket(f":{gconfig.SERVICE_ID} MODE {parsed_chan} +b ~security-group:unknown-users") @@ -138,18 +138,20 @@ def handle_on_slog(uplink: 'Defender', srvmsg: list[str]): return None def handle_on_nick(uplink: 'Defender', srvmsg: list[str]): - """_summary_ + """Handle nickname changes. >>> srvmsg = ['@unrealircd.org...', ':001MZQ0RB', 'NICK', 'newnickname', '1754663712'] + >>> [':97KAAAAAC', 'NICK', 'testinspir', '1757360740'] Args: irc_instance (Irc): The Irc instance srvmsg (list[str]): The Server MSG confmodel (ModConfModel): The Module Configuration """ - uid = uplink.Loader.Utils.clean_uid(str(srvmsg[1])) p = uplink.Protocol + parser = p.parse_nick(srvmsg) + uid = uplink.Loader.Utils.clean_uid(parser.get('uid', None)) confmodel = uplink.ModConfig - get_reputation = uplink.Reputation.get_Reputation(uid) + get_reputation = uplink.Reputation.get_reputation(uid) jail_salon = uplink.Config.SALON_JAIL service_id = uplink.Config.SERVICE_ID @@ -159,7 +161,7 @@ def handle_on_nick(uplink: 'Defender', srvmsg: list[str]): # Update the new nickname oldnick = get_reputation.nickname - newnickname = srvmsg[3] + newnickname = parser.get('newnickname', None) get_reputation.nickname = newnickname # If ban in all channel is ON then unban old nickname an ban the new nickname @@ -170,20 +172,21 @@ def handle_on_nick(uplink: 'Defender', srvmsg: list[str]): p.send2socket(f":{service_id} MODE {chan.name} +b {newnickname}!*@*") def handle_on_quit(uplink: 'Defender', srvmsg: list[str]): - """_summary_ + """Handle on quit message >>> srvmsg = ['@unrealircd.org...', ':001MZQ0RB', 'QUIT', ':Quit:', 'quit message'] Args: uplink (Irc): The Defender Module instance srvmsg (list[str]): The Server MSG """ p = uplink.Protocol + parser = p.parse_quit(srvmsg) confmodel = uplink.ModConfig ban_all_chan = uplink.Base.int_if_possible(confmodel.reputation_ban_all_chan) - final_UID = uplink.Loader.Utils.clean_uid(str(srvmsg[1])) + final_UID = uplink.Loader.Utils.clean_uid(str(parser.get('uid', None))) jail_salon = uplink.Config.SALON_JAIL service_id = uplink.Config.SERVICE_ID - get_user_reputation = uplink.Reputation.get_Reputation(final_UID) + get_user_reputation = uplink.Reputation.get_reputation(final_UID) if get_user_reputation is not None: final_nickname = get_user_reputation.nickname @@ -204,6 +207,7 @@ def handle_on_uid(uplink: 'Defender', srvmsg: list[str]): uplink (Defender): The Defender instance srvmsg (list[str]): The Server MSG """ + parser_uid = uplink.Protocol.parse_uid(srvmsg) gconfig = uplink.Config irc = uplink.Irc confmodel = uplink.ModConfig @@ -213,10 +217,10 @@ def handle_on_uid(uplink: 'Defender', srvmsg: list[str]): return None # Get User information - _User = irc.User.get_user(str(srvmsg[8])) + _User = irc.User.get_user(parser_uid.get('uid', None)) if _User is None: - irc.Logs.warning(f'This UID: [{srvmsg[8]}] is not available please check why') + irc.Logs.warning(f'This UID: [{parser_uid.get("uid", None)}] is not available please check why') return # If user is not service or IrcOp then scan them @@ -249,7 +253,8 @@ def handle_on_uid(uplink: 'Defender', srvmsg: list[str]): #################### # ACTION FUNCTIONS # #################### - +# [:] UID []+ : +# [:] UID nickname hopcount timestamp username hostname uid servicestamp umodes virthost cloakedhost ip :gecos def action_on_flood(uplink: 'Defender', srvmsg: list[str]): confmodel = uplink.ModConfig @@ -318,7 +323,7 @@ def action_add_reputation_sanctions(uplink: 'Defender', jailed_uid: str ): p = uplink.Protocol confmodel = uplink.ModConfig - get_reputation = irc.Reputation.get_Reputation(jailed_uid) + get_reputation = irc.Reputation.get_reputation(jailed_uid) if get_reputation is None: irc.Logs.warning(f'UID {jailed_uid} has not been found') @@ -404,7 +409,7 @@ def action_apply_reputation_santions(uplink: 'Defender') -> None: # Suppression des éléments dans {UID_DB} et {REPUTATION_DB} for chan in irc.Channel.UID_CHANNEL_DB: if chan.name != salon_jail and ban_all_chan == 1: - get_user_reputation = irc.Reputation.get_Reputation(uid) + get_user_reputation = irc.Reputation.get_reputation(uid) p.send2socket(f":{service_id} MODE {chan.name} -b {get_user_reputation.nickname}!*@*") # Lorsqu'un utilisateur quitte, il doit être supprimé de {UID_DB}. diff --git a/version.json b/version.json index 3a5286e..c641feb 100644 --- a/version.json +++ b/version.json @@ -1,5 +1,5 @@ { - "version": "6.2.6", + "version": "6.3.0", "requests": "2.32.3", "psutil": "6.0.0",