class Tip: def __init__(self): self.parser = Parser() self.config = Config() self.badges = Badges() self.colors = Colors() self.colors_script = ColorsScript() def print_random_tip(self): if os.path.exists(self.config.path_config['base_paths']['tips_path']): tips = list() all_tips = os.listdir( self.config.path_config['base_paths']['tips_path']) for tip in all_tips: tips.append(tip) if tips: tip = "" while not tip: random_tip = random.randint(0, len(tips) - 1) tip = self.colors_script.parse_colors_script( self.config.path_config['base_paths']['tips_path'] + tips[random_tip]) self.badges.output_empty(self.colors.END + "HatSploit Tip: " + tip + self.colors.END) else: self.badges.output_warning("No tips detected.") else: self.badges.output_warning("No tips detected.")
class Banner: def __init__(self): self.parser = Parser() self.config = Config() self.badges = Badges() self.colors = Colors() self.colors_script = ColorsScript() def print_random_banner(self): if os.path.exists( self.config.path_config['base_paths']['banners_path']): banners = list() all_banners = os.listdir( self.config.path_config['base_paths']['banners_path']) for banner in all_banners: banners.append(banner) if banners: banner = "" while not banner: random_banner = random.randint(0, len(banners) - 1) banner = self.colors_script.parse_colors_script( self.config.path_config['base_paths']['banners_path'] + banners[random_banner]) self.badges.output_empty(self.colors.END + banner + self.colors.END) else: self.badges.output_warning("No banners detected.") else: self.badges.output_warning("No banners detected.")
class Loader: def __init__(self): self.badges = Badges() self.importer = Importer() self.config = Config() def load_update_process(self): remote_config = requests.get( 'https://raw.githubusercontent.com/EntySec/HatSploit/main/config/core_config.yml', stream=True) remote_config = remote_config.content if self.config.get_config_file(remote_config)['details']['version'] != \ self.config.core_config['details']['version']: self.badges.output_warning( "Your HatSploit Framework is out-dated.") self.badges.output_information("Consider running ./update.sh") time.sleep(1) def load_components(self): self.importer.import_all() def load_everything(self): self.load_update_process() self.load_components() def load_all(self): loading_process = threading.Thread(target=self.load_everything) loading_process.start() base_line = "Loading the HatSploit Framework..." cycle = 0 while loading_process.is_alive(): for char in "/-\|": status = base_line + char + "\r" cycle += 1 if status[cycle % len(status)] in list(string.ascii_lowercase): status = status[:cycle % len(status)] + status[cycle % len( status)].upper() + status[cycle % len(status) + 1:] elif status[cycle % len(status)] in list( string.ascii_uppercase): status = status[:cycle % len(status)] + status[cycle % len( status)].lower() + status[cycle % len(status) + 1:] sys.stdout.write(self.badges.P + status) time.sleep(.1) sys.stdout.flush() loading_process.join()
class TCP: def __init__(self): self.badges = Badges() self.exceptions = Exceptions() @staticmethod def get_local_host(): try: server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) server.connect(("192.168.1.1", 80)) local_host = server.getsockname()[0] server.close() local_host = local_host except Exception: local_host = "127.0.0.1" return local_host @staticmethod def tcp_request(host, port, data, buffer_size=1024, timeout=10): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(timeout) sock.connect((host, int(port))) sock.send(data.encode()) output = sock.recv(buffer_size) sock.close() return output.decode().strip() @staticmethod def check_tcp_port(host, port, timeout=10): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(timeout) if sock.connect_ex((host, int(port))) == 0: sock.close() return True sock.close() return False def connect(self, remote_host, remote_port, timeout=None): address = remote_host + ':' + str(remote_port) self.badges.output_process("Connecting to " + address + "...") try: server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.settimeout(timeout) server.connect((remote_host, int(remote_port))) self.badges.output_process("Establishing connection...") except socket.timeout: self.badges.output_warning("Connection timeout.") raise self.exceptions.GlobalException except Exception: self.badges.output_error("Failed to connect to " + address + "!") raise self.exceptions.GlobalException return server def listen(self, local_host, local_port, timeout=None): try: server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.settimeout(timeout) server.bind((local_host, int(local_port))) server.listen(1) self.badges.output_process("Listening on port " + str(local_port) + "...") client, address = server.accept() self.badges.output_process("Connecting to " + address[0] + "...") self.badges.output_process("Establishing connection...") server.close() except socket.timeout: self.badges.output_warning("Timeout waiting for connection.") server.close() raise self.exceptions.GlobalException except Exception: self.badges.output_error("Failed to listen on port " + str(local_port) + "!") raise self.exceptions.GlobalException return client, address[0]
class Modules: def __init__(self): self.types = Types() self.badges = Badges() self.sessions = Sessions() self.payloads = Payloads() self.local_storage = LocalStorage() self.importer = Importer() def check_exist(self, name): if self.check_style(name): all_modules = self.local_storage.get("modules") if all_modules: for database in all_modules.keys(): modules = all_modules[database] category = self.get_category(name) platform = self.get_platform(name) if category in modules.keys(): if platform in modules[category].keys(): module = self.get_name(name) if module in modules[category][platform].keys(): return True return False def check_imported(self, name): imported_modules = self.local_storage.get("imported_modules") if imported_modules: if name in imported_modules.keys(): return True return False @staticmethod def check_style(name): if len(name.split('/')) >= 3: return True return False def check_current_module(self): if self.local_storage.get("current_module"): if len(self.local_storage.get("current_module")) > 0: return True return False def get_module_object(self, category, platform, name): module_full_name = self.get_full_name(category, platform, name) if self.check_exist(module_full_name): database = self.get_database(module_full_name) return self.local_storage.get( "modules")[database][category][platform][name] return None def get_current_module_object(self): if self.check_current_module(): return self.local_storage.get_array( "current_module", self.local_storage.get("current_module_number")) return None def get_current_module_platform(self): if self.check_current_module(): return self.local_storage.get_array( "current_module", self.local_storage.get( "current_module_number")).details['Platform'] return None def get_current_module_name(self): if self.check_current_module(): return self.local_storage.get_array( "current_module", self.local_storage.get( "current_module_number")).details['Module'] return None def get_database(self, name): if self.check_style(name): all_modules = self.local_storage.get("modules") if all_modules: for database in all_modules.keys(): modules = all_modules[database] category = self.get_category(name) platform = self.get_platform(name) if category in modules.keys(): if platform in modules[category].keys(): module = self.get_name(name) if module in modules[category][platform].keys(): return database return None def get_category(self, name): if self.check_style(name): return name.split('/')[0] return None def get_platform(self, name): if self.check_style(name): return name.split('/')[1] return None def get_name(self, name): if self.check_style(name): return os.path.join(*(name.split(os.path.sep)[2:])) return None @staticmethod def get_full_name(category, platform, name): return category + '/' + platform + '/' + name def compare_types(self, value_type, value): if value_type and not value_type.lower == 'all': if value_type.lower() == 'mac': if not self.types.is_mac(value): self.badges.output_error( "Invalid value, expected valid MAC!") return False if value_type.lower() == 'ip': if not self.types.is_ip(value): self.badges.output_error( "Invalid value, expected valid IP!") return False if value_type.lower() == 'ipv4': if not self.types.is_ipv4(value): self.badges.output_error( "Invalid value, expected valid IPv4!") return False if value_type.lower() == 'ipv6': if not self.types.is_ipv6(value): self.badges.output_error( "Invalid value, expected valid IPv6!") return False if value_type.lower() == 'ipv4_range': if not self.types.is_ipv4_range(value): self.badges.output_error( "Invalid value, expected valid IPv4 range!") return False if value_type.lower() == 'ipv6_range': if not self.types.is_ipv6_range(value): self.badges.output_error( "Invalid value, expected valid IPv6 range!") return False if value_type.lower() == 'port': if not self.types.is_port(value): self.badges.output_error( "Invalid value, expected valid port!") return False if value_type.lower() == 'port_range': if not self.types.is_port_range(value): self.badges.output_error( "Invalid value, expected valid port range!") return False if value_type.lower() == 'number': if not self.types.is_number(value): self.badges.output_error( "Invalid value, expected valid number!") return False if value_type.lower() == 'integer': if not self.types.is_integer(value): self.badges.output_error( "Invalid value, expected valid integer!") return False if value_type.lower() == 'float': if not self.types.is_float(value): self.badges.output_error( "Invalid value, expected valid float!") return False if value_type.lower() == 'boolean': if not self.types.is_boolean(value): self.badges.output_error( "Invalid value, expected valid boolean!") return False if value_type.lower() == 'session': module_platform = self.get_current_module_platform() if not self.sessions.check_exist(module_platform, value): return False return True def set_current_module_option(self, option, value): if self.check_current_module(): current_module = self.get_current_module_object() if not hasattr(current_module, "options") and not hasattr( current_module, "payload"): self.badges.output_warning("Module has no options.") return if hasattr(current_module, "payload") and option.lower() == "payload": if self.payloads.check_exist(value): module_name = self.get_current_module_name() platform = self.payloads.get_platform(value) architecture = self.payloads.get_architecture(value) name = self.payloads.get_name(value) payload = self.payloads.get_payload_object( platform, architecture, name) module_payload = current_module.payload valid = 0 if module_payload['Types'] is None or payload[ 'Type'] in module_payload['Types']: valid += 1 if module_payload['Categories'] is None or payload[ 'Category'] in module_payload['Categories']: valid += 1 if module_payload['Platforms'] is None or payload[ 'Platform'] in module_payload['Platforms']: valid += 1 if module_payload['Architectures'] is None or payload[ 'Architecture'] in module_payload['Architectures']: valid += 1 if valid == 4: if not self.payloads.add_payload( module_name, platform, architecture, name): self.badges.output_error( "Invalid payload, expected valid payload!") return self.badges.output_information(option + " ==> " + value) self.local_storage.set_module_payload( "current_module", self.local_storage.get("current_module_number"), value) return self.badges.output_error( "Incompatible payload type, category or platform!") return self.badges.output_error( "Invalid payload, expected valid payload!") return if hasattr(current_module, "options"): if option in current_module.options.keys(): value_type = current_module.options[option]['Type'] if self.compare_types(value_type, value): self.badges.output_information(option + " ==> " + value) self.local_storage.set_module_option( "current_module", self.local_storage.get("current_module_number"), option, value) return if hasattr(current_module, "payload"): current_payload = self.payloads.get_current_payload() if current_payload and hasattr(current_payload, "options"): if option in current_payload.options.keys(): value_type = current_payload.options[option]['Type'] if self.compare_types(value_type, value): self.badges.output_information(option + " ==> " + value) self.local_storage.set_payload_option( current_module.details['Module'], current_payload.details['Payload'], option, value) else: self.badges.output_error("Unrecognized option!") else: self.badges.output_error("Unrecognized option!") else: self.badges.output_warning("No module selected.") def import_module(self, category, platform, name): modules = self.get_module_object(category, platform, name) try: module_object = self.importer.import_module(modules['Path']) if not self.local_storage.get("imported_modules"): self.local_storage.set("imported_modules", dict()) self.local_storage.update( "imported_modules", {self.get_full_name(category, platform, name): module_object}) except Exception: return None return module_object def add_module(self, category, platform, name): modules = self.get_module_object(category, platform, name) not_installed = list() for dependence in modules['Dependencies']: if not self.importer.import_check(dependence): not_installed.append(dependence) if not not_installed: imported_modules = self.local_storage.get("imported_modules") full_name = self.get_full_name(category, platform, name) if self.check_imported(full_name): module_object = imported_modules[full_name] self.add_to_global(module_object) else: module_object = self.import_module(category, platform, name) if module_object: if hasattr(module_object, "payload"): payload_name = module_object.payload['Value'] platform = self.payloads.get_platform(payload_name) architecture = self.payloads.get_architecture( payload_name) name = self.payloads.get_name(payload_name) self.badges.output_process("Using default payload " + payload_name + "...") if self.payloads.check_exist(payload_name): if self.payloads.add_payload( full_name, platform, architecture, name): self.add_to_global(module_object) return self.badges.output_error("Invalid default payload!") return self.add_to_global(module_object) else: self.badges.output_error( "Failed to select module from database!") else: self.badges.output_error( "Module depends this dependencies which is not installed:") for dependence in not_installed: self.badges.output_empty(" * " + dependence) def add_to_global(self, module_object): if self.check_current_module(): self.local_storage.add_array("current_module", '') self.local_storage.set( "current_module_number", self.local_storage.get("current_module_number") + 1) self.local_storage.set_array( "current_module", self.local_storage.get("current_module_number"), module_object) else: self.local_storage.set("current_module", []) self.local_storage.set("current_module_number", 0) self.local_storage.add_array("current_module", '') self.local_storage.set_array( "current_module", self.local_storage.get("current_module_number"), module_object)
class Jobs: def __init__(self): self.exceptions = Exceptions() self.tables = Tables() self.badges = Badges() self.local_storage = LocalStorage() self.modules = Modules() self.job_process = None def stop_dead(self): jobs = self.local_storage.get("jobs") if jobs: for job_id in list(jobs): if not jobs[job_id]['job_process'].is_alive(): self.delete_job(job_id) def check_jobs(self): if not self.local_storage.get("jobs"): return True return False def check_module_job(self, module_name): jobs = self.local_storage.get("jobs") if jobs: for job_id in jobs.keys(): if jobs[job_id]['module_name'] == module_name: return True return False def exit_jobs(self): if self.check_jobs(): return True self.badges.output_warning("You have some running jobs.") if self.badges.input_question("Exit anyway? [y/N] ").lower() in [ 'yes', 'y' ]: self.badges.output_process("Stopping all jobs...") self.stop_all_jobs() return True return False def stop_all_jobs(self): if not self.check_jobs(): for job_id in list(self.local_storage.get("jobs").keys()): self.delete_job(job_id) def stop_job(self, job): if job.is_alive(): exc = ctypes.py_object(SystemExit) res = ctypes.pythonapi.PyThreadState_SetAsyncExc( ctypes.c_long(job.ident), exc) if res == 0: raise self.exceptions.GlobalException if res > 1: ctypes.pythonapi.PyThreadState_SetAsyncExc(job.ident, None) raise self.exceptions.GlobalException def start_job(self, job_function, job_arguments): self.job_process = threading.Thread(target=job_function, args=job_arguments) self.job_process.setDaemon(True) self.job_process.start() def delete_job(self, job_id): if not self.check_jobs(): job_id = int(job_id) if job_id in list(self.local_storage.get("jobs").keys()): try: self.stop_job( self.local_storage.get("jobs")[job_id]['job_process']) self.local_storage.delete_element("jobs", job_id) except Exception: self.badges.output_error("Failed to stop job!") else: self.badges.output_error("Invalid job id!") else: self.badges.output_error("Invalid job id!") def create_job(self, job_name, module_name, job_function, job_arguments=()): self.start_job(job_function, job_arguments) if not self.local_storage.get("jobs"): self.local_storage.set("jobs", dict()) job_id = len(self.local_storage.get("jobs")) job_data = { job_id: { 'job_name': job_name, 'module_name': module_name, 'job_process': self.job_process } } self.local_storage.update("jobs", job_data) return job_id