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!")
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 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 Handler(http.server.SimpleHTTPRequestHandler):
def log_request(self, fmt, *args):
pass
def do_GET(self):
self.badges = Badges()
self.badges.output_success(
f"Connection from {self.client_address[0]}!")
self.badges.output_process("Sending payload stage...")
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(bytes(self.payload, "utf8"))
self.badges.output_success("Payload sent successfully!")
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
class Sessions:
def __init__(self):
self.badges = Badges()
self.local_storage = LocalStorage()
def add_session(self, session_platform, session_type, session_host,
session_port, session_object):
if not self.local_storage.get("sessions"):
self.local_storage.set("sessions", dict())
session_id = 0
if session_platform in self.local_storage.get("sessions").keys():
sessions = self.local_storage.get("sessions")
session_id = len(sessions[session_platform])
sessions[session_platform][int(session_id)] = {
'type': session_type,
'host': session_host,
'port': session_port,
'object': session_object
}
else:
sessions = {
session_platform: {
int(session_id): {
'type': session_type,
'host': session_host,
'port': session_port,
'object': session_object
}
}
}
self.local_storage.update("sessions", sessions)
return session_id
def check_session_exist(self, session_platform, session_id):
sessions = self.local_storage.get("sessions")
if sessions:
if session_platform in sessions.keys():
if int(session_id) in sessions[session_platform].keys():
return True
return False
def spawn_interactive_connection(self, session_platform, session_id):
sessions = self.local_storage.get("sessions")
if self.check_session_exist(session_platform, session_id):
self.badges.output_process("Interacting with session " +
str(session_id) + "...")
self.badges.output_success("Interactive connection spawned!")
self.badges.output_information("Type commands below.\n")
sessions[session_platform][int(session_id)]['object'].interact()
else:
self.badges.output_error("Invalid session given!")
def close_session(self, session_platform, session_id):
sessions = self.local_storage.get("sessions")
if self.check_session_exist(session_platform, session_id):
try:
sessions[session_platform][int(session_id)]['object'].close()
del sessions[session_platform][int(session_id)]
if not sessions[session_platform]:
del sessions[session_platform]
self.local_storage.update("sessions", sessions)
except Exception:
self.badges.output_error("Failed to close session!")
else:
self.badges.output_error("Invalid session given!")
def get_session(self, session_platform, session_type, session_id):
sessions = self.local_storage.get("sessions")
if self.check_session_exist(session_platform, session_id):
if session_type == sessions[session_platform][int(
session_id)]['type']:
return sessions[session_platform][int(session_id)]['object']
self.badges.output_error("Session with invalid type!")
return None
return None
