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 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 Console:
def __init__(self):
self.io = IO()
self.tip = Tip()
self.jobs = Jobs()
self.execute = Execute()
self.loader = Loader()
self.config = Config()
self.badges = Badges()
self.banner = Banner()
self.colors = Colors()
self.local_storage = LocalStorage()
self.modules = Modules()
self.exceptions = Exceptions()
self.history = self.config.path_config['base_paths']['history_path']
def check_root(self):
if os.getuid() == 0:
return True
self.badges.output_error("Operation not permitted!")
return False
def check_install(self):
if os.path.exists(self.config.path_config['base_paths']['root_path']):
return True
self.badges.output_error("HatSploit is not installed!")
self.badges.output_information("Consider running ./install.sh")
return False
def start_hsf(self):
try:
self.loader.load_all()
except Exception:
sys.exit(1)
def launch_menu(self):
while True:
try:
if not self.modules.check_current_module():
prompt = '(hsf)> '
else:
module = self.modules.get_current_module_name()
name = self.modules.get_current_module_object(
).details['Name']
prompt = '(hsf: ' + self.modules.get_category(
module
) + ': ' + self.colors.RED + name + self.colors.END + ')> '
commands, arguments = self.io.input(prompt)
self.jobs.stop_dead()
self.execute.execute_command(commands, arguments)
if self.local_storage.get("history"):
readline.write_history_file(self.history)
except (KeyboardInterrupt, EOFError,
self.exceptions.GlobalException):
pass
except Exception as e:
self.badges.output_error("An error occurred: " + str(e) + "!")
def enable_history_file(self):
if not os.path.exists(self.history):
open(self.history, 'w').close()
readline.read_history_file(self.history)
def launch_shell(self):
using_history = self.local_storage.get("history")
if using_history:
self.enable_history_file()
readline.parse_and_bind("tab: complete")
version = self.config.core_config['details']['version']
codename = self.config.core_config['details']['codename']
if self.config.core_config['console']['clear']:
self.badges.output_empty(self.colors.CLEAR, end='')
if self.config.core_config['console']['banner']:
self.banner.print_random_banner()
if self.config.core_config['console']['header']:
plugins = self.local_storage.get("plugins")
modules = self.local_storage.get("modules")
payloads = self.local_storage.get("payloads")
plugins_total = 0
modules_total = 0
payloads_total = 0
if payloads:
for database in payloads.keys():
for payload_platform in payloads[database].keys():
for payload_architecture in payloads[database][
payload_platform].keys():
payloads_total += len(
payloads[database][payload_platform]
[payload_architecture])
if plugins:
for database in plugins.keys():
plugins_total += len(plugins[database])
if modules:
for database in modules.keys():
for module_category in modules[database].keys():
for module_platform in modules[database][
module_category].keys():
modules_total += len(
modules[database][module_category]
[module_platform])
header = ""
header += f"{self.colors.END}\n"
if codename and not codename.isspace():
header += f" --=( {self.colors.YELLOW}HatSploit Framework {codename} {version}{self.colors.END}\n"
else:
header += f" --=( {self.colors.YELLOW}HatSploit Framework {version}{self.colors.END}\n"
header += f"--==--=( Developed by EntySec ({self.colors.LINE}https://entysec.netlify.app/{self.colors.END})\n"
header += f" --=( {modules_total} modules | {payloads_total} payloads | {plugins_total} plugins\n"
header += f"{self.colors.END}"
self.badges.output_empty(header)
if self.config.core_config['console']['tip']:
self.tip.print_random_tip()
self.badges.output_empty("")
def shell(self):
self.start_hsf()
self.launch_shell()
self.launch_menu()
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)