def __init__(self): self.badges = Badges() self.importer = Importer() self.modules_tests = ModulesTests() self.plugins_tests = PluginsTests() self.payloads_tests = PayloadsTests()
def __init__(self): self.badges = Badges() self.importer = Importer() self.modules_checks = ModulesChecks() self.plugins_checks = PluginsChecks() self.payloads_checks = PayloadsChecks()
class PerformTests: def __init__(self): self.badges = Badges() self.importer = Importer() self.modules_tests = ModulesTests() self.plugins_tests = PluginsTests() self.payloads_tests = PayloadsTests() def perform_tests(self): self.importer.import_database() statuses = list() self.badges.output_process("Performing modules test...") statuses.append(self.modules_tests.perform_test()) self.badges.output_process("Performing plugins test...") statuses.append(self.plugins_tests.perform_test()) self.badges.output_process("Performing payloads test...") statuses.append(self.payloads_tests.perform_test()) for status in statuses: if status: self.badges.output_error("Not all tests passed!") sys.exit(1) self.badges.output_success("All tests passed!")
def __init__(self): self.types = Types() self.badges = Badges() self.sessions = Sessions() self.payloads = Payloads() self.local_storage = LocalStorage() self.importer = Importer()
class ModulesChecks: def __init__(self): self.badges = Badges() self.importer = Importer() self.local_storage = LocalStorage() self.modules = Modules() def perform_check(self): fail = False all_modules = self.local_storage.get("modules") if all_modules: for database in all_modules.keys(): self.badges.output_process("Checking modules from " + database + " database...") modules = all_modules[database] for category in modules.keys(): for platform in modules[category].keys(): for module in modules[category][platform].keys(): try: _ = self.importer.import_module( modules[category][platform][module] ['Path']) self.badges.output_success( self.modules.get_full_name( category, platform, module) + ': OK') except Exception: self.badges.output_error( self.modules.get_full_name( category, platform, module) + ': FAIL') fail = True return fail
class HatSploitCommand(Command): plugins = Plugins() local_storage = LocalStorage() importer = Importer() details = { 'Category': "plugin", 'Name': "load", 'Authors': ['Ivan Nikolsky (enty8080)'], 'Description': "Load specified plugin.", 'Usage': "load <plugin>", 'MinArgs': 1 } def import_plugin(self, database, plugin): loaded_plugins = dict() plugins = self.local_storage.get("plugins")[database][plugin] try: loaded_plugins[plugin] = self.importer.import_plugin( plugins['Path']) except Exception: return None return loaded_plugins def add_plugin(self, database, plugin): plugins = self.local_storage.get("plugins")[database][plugin] not_installed = list() for dependence in plugins['Dependencies']: if not self.importer.import_check(dependence): not_installed.append(dependence) if not not_installed: plugin_object = self.import_plugin(database, plugin) if plugin_object: if self.local_storage.get("loaded_plugins"): self.local_storage.update("loaded_plugins", plugin_object) else: self.local_storage.set("loaded_plugins", plugin_object) self.local_storage.get("loaded_plugins")[plugin].run() self.output_success("Successfully loaded " + plugin + " plugin!") else: self.output_error("Failed to load plugin!") else: self.output_error( "Plugin depends this dependencies which is not installed:") for dependence in not_installed: self.output_empty(" * " + dependence) def run(self, argc, argv): plugin = argv[0] self.output_process("Loading " + plugin + " plugin...") if not self.plugins.check_loaded(plugin): if self.plugins.check_exist(plugin): database = self.plugins.get_database(plugin) self.add_plugin(database, plugin) else: self.output_error("Invalid plugin!") else: self.output_error("Already loaded!")
class PayloadsTests: def __init__(self): self.badges = Badges() self.importer = Importer() self.local_storage = LocalStorage() self.payloads = Payloads() def perform_test(self): fail = False all_payloads = self.local_storage.get("payloads") if all_payloads: for database in all_payloads.keys(): self.badges.output_process("Testing payloads from " + database + " database...") payloads = all_payloads[database] for platform in payloads.keys(): for architecture in payloads[platform].keys(): for payload in payloads[platform][architecture].keys(): try: _ = self.importer.import_payload( payloads[platform][architecture][payload] ['Path']) self.badges.output_success( self.payloads.get_full_name( platform, architecture, payload) + ': OK') except Exception: self.badges.output_error( self.payloads.get_full_name( platform, architecture, payload) + ': FAIL') fail = True return fail
class HatSploitCommand(Command): importer = Importer() local_storage = LocalStorage() modules = Modules() details = { 'Category': "module", 'Name': "use", 'Authors': [ 'Ivan Nikolsky (enty8080)' ], 'Description': "Use specified module.", 'Usage': "use <module>", 'MinArgs': 1 } def check_if_already_used(self, module): if self.modules.check_current_module(): if module == self.modules.get_current_module_name(): return True return False def run(self, argc, argv): module = argv[0] category = self.modules.get_category(module) platform = self.modules.get_platform(module) name = self.modules.get_name(module) if not self.check_if_already_used(module): if self.modules.check_exist(module): self.modules.add_module(category, platform, name) else: self.output_error("Invalid module!")
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 PluginsChecks: def __init__(self): self.badges = Badges() self.importer = Importer() self.local_storage = LocalStorage() def perform_check(self): fail = False all_plugins = self.local_storage.get("plugins") if all_plugins: for database in all_plugins.keys(): self.badges.output_process("Checking plugins from " + database + " database...") plugins = all_plugins[database] for plugin in plugins.keys(): try: _ = self.importer.import_plugin(plugins[plugin]['Path']) self.badges.output_success(plugin + ': OK') except Exception: self.badges.output_error(plugin + ': FAIL') fail = True return fail
def __init__(self): self.importer = Importer() self.local_storage = LocalStorage() self.badges = Badges()
class Payloads: def __init__(self): self.importer = Importer() self.local_storage = LocalStorage() self.badges = Badges() def check_exist(self, name): if self.check_style(name): all_payloads = self.local_storage.get("payloads") if all_payloads: for database in all_payloads.keys(): payloads = all_payloads[database] platform = self.get_platform(name) architecture = self.get_architecture(name) if platform in payloads.keys(): if architecture in payloads[platform].keys(): payload = self.get_name(name) if payload in payloads[platform][ architecture].keys(): return True return False @staticmethod def check_style(name): if len(name.split('/')) >= 3: return True return False def get_platform(self, name): if self.check_style(name): return name.split('/')[0] return None def get_architecture(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 def get_payload_object(self, platform, architecture, name): payload_full_name = self.get_full_name(platform, architecture, name) if self.check_exist(payload_full_name): database = self.get_database(payload_full_name) return self.local_storage.get( "payloads")[database][platform][architecture][name] return None def get_database(self, name): if self.check_style(name): all_payloads = self.local_storage.get("payloads") if all_payloads: for database in all_payloads.keys(): payloads = all_payloads[database] platform = self.get_platform(name) architecture = self.get_architecture(name) if platform in payloads.keys(): if architecture in payloads[platform].keys(): payload = self.get_name(name) if payload in payloads[platform][ architecture].keys(): return database return None @staticmethod def get_full_name(platform, architecture, name): return platform + '/' + architecture + '/' + name 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_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_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 import_payload(self, module_name, platform, architecture, name): payloads = self.get_payload_object(platform, architecture, name) try: payload_object = self.importer.import_payload(payloads['Path']) current_module_name = module_name imported_payloads = self.local_storage.get("imported_payloads") if imported_payloads: if current_module_name in imported_payloads.keys(): imported_payloads[current_module_name].update({ payload_object.details['Payload']: copy.copy(payload_object) }) else: imported_payloads.update({ current_module_name: { payload_object.details['Payload']: copy.copy(payload_object) } }) else: imported_payloads = { current_module_name: { payload_object.details['Payload']: copy.copy(payload_object) } } self.local_storage.set("imported_payloads", imported_payloads) except Exception: return None return payload_object def check_imported(self, module_name, name): imported_payloads = self.local_storage.get("imported_payloads") current_module_name = module_name if imported_payloads: if current_module_name in imported_payloads.keys(): if name in imported_payloads[current_module_name].keys(): return True return False def get_current_payload(self): imported_payloads = self.local_storage.get("imported_payloads") current_module_object = self.get_current_module_object() current_module_name = current_module_object.details['Module'] if hasattr(current_module_object, "payload"): name = current_module_object.payload['Value'] if current_module_name in imported_payloads.keys(): if name in imported_payloads[current_module_name].keys(): return imported_payloads[current_module_name][name] return None def add_payload(self, module_name, platform, architecture, name): payloads = self.get_payload_object(platform, architecture, name) not_installed = list() for dependence in payloads['Dependencies']: if not self.importer.import_check(dependence): not_installed.append(dependence) if not not_installed: full_name = self.get_full_name(platform, architecture, name) if not self.check_imported(module_name, full_name): payload_object = self.import_payload(module_name, platform, architecture, name) if not payload_object: self.badges.output_error( "Failed to select payload from database!") return False else: self.badges.output_error( "Payload depends this dependencies which is not installed:") for dependence in not_installed: self.badges.output_empty(" * " + dependence) return False return True
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)
def __init__(self): self.badges = Badges() self.importer = Importer() self.config = Config()