From 7134d9737c2d6e3e49c10608d0ba548a64210108 Mon Sep 17 00:00:00 2001 From: Maximilien Rigaut Date: Wed, 22 Jun 2022 21:33:29 +0200 Subject: [PATCH 1/3] Ajusted arguments --- discordHelper.py | 24 ++++++++++++++ modules/agnostic_paths.py | 17 ++++++---- .../argument_parser.py | 33 ++++--------------- modules/test_interface.py | 2 -- 4 files changed, 41 insertions(+), 35 deletions(-) create mode 100644 discordHelper.py rename spideyDetector.py => modules/argument_parser.py (73%) diff --git a/discordHelper.py b/discordHelper.py new file mode 100644 index 0000000..d9c37e8 --- /dev/null +++ b/discordHelper.py @@ -0,0 +1,24 @@ +#!/usr/bin/python3 + +""" Main program """ + +from modules import test_interface, agnostic_paths, argument_parser +import sys + + +if __name__ == "__main__": + args = argument_parser.parse(sys.argv[1:]) + agnostic_path = agnostic_paths.AgnosticPaths(ptb=args.ptb, force_path=args.force_path) + try: + spd = test_interface.run_check(args, agnostic_path) + + except FileNotFoundError as er: + print(er) + sys.exit(1) + except OSError as er: + print(er.strerror) + sys.exit(1) + + if spd == 0: + print("Discord Helper could not find anything wrong with your discord install!") # TODO: Everything should be in the run_all_tests() + sys.exit(spd) diff --git a/modules/agnostic_paths.py b/modules/agnostic_paths.py index 5a8f9f2..ba0e728 100644 --- a/modules/agnostic_paths.py +++ b/modules/agnostic_paths.py @@ -11,16 +11,19 @@ class AgnosticPaths: An agnostic path object, containing all methods to access the files and folders in a standard discord install """ - def __init__(self, ptb, force_path=""): + def __init__(self, ptb, force_path=None): """ :param ptb: Whether the discord is a public beta install (ptb="PTB") or not (ptb="") :type ptb: str - :param forced_path: An alternative discord install path, usefull to test the script on a non standard install - :type forced_path: str + :param force_path: An alternative discord install path, usefull to test the script on a non standard install + :type force_path: str """ self.ptb = ptb self.os = self.get_os() - self.force_path = force_path[0] + if force_path is not None: + self.force_path = force_path[0] + else: + self.force_path = None self.main_path = self._get_path() self.version = self.get_version() self._update_path() @@ -47,12 +50,12 @@ class AgnosticPaths: def _get_path(self): """ - Return the base path of the install, note that the self.main_path is not returned, + Return the base path of the install, note that the self.main_path is not returned, and this method is meant to be used at init only - :return: Base path of the install (minus the version on windows) + :return: Base path of the install (minus the version on Windows) :rtype: str """ - if self.force_path != "": + if self.force_path is not None: return self.force_path if self.os == 'windows': return os.path.join(os.path.expanduser('~'), "AppData", "Local", f"Discord{self.ptb}") diff --git a/spideyDetector.py b/modules/argument_parser.py similarity index 73% rename from spideyDetector.py rename to modules/argument_parser.py index bc3fd7c..39fe8f0 100644 --- a/spideyDetector.py +++ b/modules/argument_parser.py @@ -1,13 +1,7 @@ -#!/usr/bin/python3 - -""" Main program """ - -from modules import test_interface, agnostic_paths import argparse -import sys -def parse(_args): # TODO: Move this to a arg_parsing module +def parse(_args): parser = argparse.ArgumentParser( prog="Spidey Detector", description='Checks for corrupt discord install' @@ -28,26 +22,13 @@ def parse(_args): # TODO: Move this to a arg_parsing module parser.add_argument('--analyze', action='store_true', help="Analyze the files in the discord folder for known js obfuscators") parser.add_argument('--all', action='store_true', help="Run all tests in parallel, and wait for a potential interupt") parser.add_argument('--launch', action='store_true', help="Launch the discord client after the tests are done") - parser.add_argument("--force-path", nargs=1, default="", help="Bypass the automatic path discovery with given path") + parser.add_argument("--force-path", nargs=1, default=None, help="Bypass the automatic path discovery with given path") parser.add_argument("--only-known-paths", "--fast", action='store_true', help="Only run the check on the known paths") parser.add_argument("--no-eval", action="store_true", help="Check for the eval function wich is a HUGE red flag") parser.add_argument("--const-abuse", "--no-const", action="store_true", help="Check for the abuse of the const: keyword, wich is massively used for obfucation") + parser.add_argument("--gen-data", "--generate-data", "--gen", action="store_true", help="Generate data for the analysis") + parser.add_argument("--gen-data-path", "--generate-data-path", "--gen-path", nargs=1, default="", help="Path to generate the data in") + parser.add_argument("--database", "--db", nargs=1, default="", help="Alternative database for the analysis") + parser.add_argument("--continue", action="store_true", help="Continue the analysis in case of failure") + return parser.parse_args(_args) - - -if __name__ == "__main__": - args = parse(sys.argv[1:]) - agnostic_path = agnostic_paths.AgnosticPaths(ptb=args.ptb, force_path=args.force_path) - try: - spd = test_interface.run_check(args, agnostic_path) - - except FileNotFoundError as er: - print(er) - sys.exit(1) - except OSError as er: - print(er.strerror) - sys.exit(1) - - if spd == 0: - print("TestRunner could not find anything wrong with your discord install!") # TODO: Everything should be in the run_all_tests() - sys.exit(spd) diff --git a/modules/test_interface.py b/modules/test_interface.py index ac571e9..9abba99 100644 --- a/modules/test_interface.py +++ b/modules/test_interface.py @@ -48,7 +48,6 @@ class TestRunner: classes = {} try: for module_name, values in _TEST_MODULES.items(): - print(values[0]) if self.args.__getattribute__(module_name): modules[values[0]] = importlib.import_module(f"modules.{values[0]}") classes[values[0]] = getattr(modules[values[0]], values[1]) @@ -68,7 +67,6 @@ class TestRunner: for module_name, test_class in self.loaded_test_classes.items(): tc = test_class(self.args, self.agnostic_path, None) tc.run_test() - print(tc) def run_check(args, agnpath): # Todo, skip the is_infected check and defer everything to the exec_all_tests From abb45db79da1bcd4806ed7b88620dd10c45645d6 Mon Sep 17 00:00:00 2001 From: Maximilien Rigaut Date: Wed, 22 Jun 2022 23:02:18 +0200 Subject: [PATCH 2/3] Fiddling with threads --- modules/spidey_test.py | 19 +++++++++++++- modules/test_interface.py | 52 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 69 insertions(+), 2 deletions(-) diff --git a/modules/spidey_test.py b/modules/spidey_test.py index 7132318..1d91270 100644 --- a/modules/spidey_test.py +++ b/modules/spidey_test.py @@ -1,3 +1,4 @@ +import asyncio import os @@ -17,6 +18,7 @@ class SpideyTest: self.os_name = agnpath.os self.main_path = agnpath.main_path self.test_data = test_data + self.alive = True def run_test(self): """ @@ -25,6 +27,9 @@ class SpideyTest: :return: Whether any of the index.js is more than one line :rtype: bool """ + import random, time + # Wait a random amount of time to make sure the files are loaded + time.sleep(random.randint(1, 5)) paths = self.get_path() self.is_infected = False lines = 0 @@ -75,4 +80,16 @@ class SpideyTest: :rtype: (int, str) """ # TODO: Make use of a global_dict - return (self.get_status_code(), "") + return self.get_status_code(), "" + + +async def main(args, agnpath, test_data): + """ + The main function of the test. + :return: The status of the test + :rtype: (int, str) + """ + spidey_test = SpideyTest(args, agnpath, test_data) + await asyncio.sleep(5) + spidey_test.run_test() + return spidey_test.get_status() diff --git a/modules/test_interface.py b/modules/test_interface.py index 9abba99..2f28504 100644 --- a/modules/test_interface.py +++ b/modules/test_interface.py @@ -1,3 +1,4 @@ +import threading import os import re import sys @@ -35,6 +36,7 @@ class TestRunner: self.loaded_test_modules = {} self.loaded_test_classes = {} + self.list_of_tests = [] self.update_module_list() self.exec_all_tests() @@ -58,18 +60,66 @@ class TestRunner: self.loaded_test_modules.update(modules) self.loaded_test_classes.update(classes) + def test_controller(self, rate=1): + """ + Controller for the tests. + :param rate: The rate at which the controller will check the tests + :type rate: int + :return: 1 if all test ran, 0 if one or more tests failed, 2 if the user stopped the tests + """ + l_test = len(self.list_of_tests) + while True: + still_running = 0 + for t in self.list_of_tests: + if t.is_alive(): + still_running += 1 + if still_running == 0: + return 1 + + def test_killer(self): + """ + Kills the tests if the user press enter + """ + while True: + if input() == "": + for t in self.list_of_tests: + t.terminate() + return + def exec_all_tests(self): """ Executes all the tests (later in parallel), get their result as they finishes :return: The number of test ran, success, failures, skipped (with ran = success+failures+skip) :rtype: (int,int,int,int) # TODO: Change this to a nametuple """ + self.list_of_tests = [] + for module_name, test_class in self.loaded_test_classes.items(): tc = test_class(self.args, self.agnostic_path, None) - tc.run_test() + tc.daemon = True + tc = threading.Thread(target=tc.run_test) + self.list_of_tests.append(tc) + tc.start() + + # Launch a controller to allow the user to stop the tests + # controller = threading.Thread(target=self.test_launcher) + + # Allow the user to stop the tests + tk = threading.Thread(target=self.test_killer) + tk.start() + + for t in self.list_of_tests: + t.join() + + if tk.is_alive(): + tk.terminate() + + # await asyncio.gather(*list_of_tests) + # tc.run_test() def run_check(args, agnpath): # Todo, skip the is_infected check and defer everything to the exec_all_tests + test_selected = True spd = TestRunner(args, agnpath) if not spd.is_infected: return 0 From c90c6972d9a4d0be4447af4f7d23d5a8fd1bfc11 Mon Sep 17 00:00:00 2001 From: Maximilien Rigaut Date: Thu, 23 Jun 2022 15:22:32 +0200 Subject: [PATCH 3/3] Working multithread, with a clusterfk of useless info and no good info and report --- discordHelper.py | 13 +-- modules/internal_io.py | 17 ++++ modules/spidey_test.py | 51 +++-------- modules/test_interface.py | 179 ++++++++++++++++++++++++++------------ modules/test_template.py | 30 ++++--- 5 files changed, 174 insertions(+), 116 deletions(-) create mode 100644 modules/internal_io.py diff --git a/discordHelper.py b/discordHelper.py index d9c37e8..259d9ce 100644 --- a/discordHelper.py +++ b/discordHelper.py @@ -9,16 +9,5 @@ import sys if __name__ == "__main__": args = argument_parser.parse(sys.argv[1:]) agnostic_path = agnostic_paths.AgnosticPaths(ptb=args.ptb, force_path=args.force_path) - try: - spd = test_interface.run_check(args, agnostic_path) - except FileNotFoundError as er: - print(er) - sys.exit(1) - except OSError as er: - print(er.strerror) - sys.exit(1) - - if spd == 0: - print("Discord Helper could not find anything wrong with your discord install!") # TODO: Everything should be in the run_all_tests() - sys.exit(spd) + test_interface.run_check(args, agnostic_path) \ No newline at end of file diff --git a/modules/internal_io.py b/modules/internal_io.py new file mode 100644 index 0000000..c42822e --- /dev/null +++ b/modules/internal_io.py @@ -0,0 +1,17 @@ +""" +Internal interfacting objects. +""" + +from collections import namedtuple + + +global_status = namedtuple('global_status', 'total_tests, tests_finished, tests_failed, tests_running, tests_skipped', defaults=(0, 0, 0, 0, 0)) +test_status = namedtuple('test_status', 'name, status, message', defaults=(None, None, None)) +return_code_dict = { + 2: "The test was not run", + 3: "The test is running", + 0: "The test is a success", + 1: "Test has failed", + 4: "Test found problems", +} + diff --git a/modules/spidey_test.py b/modules/spidey_test.py index 1d91270..3da8a46 100644 --- a/modules/spidey_test.py +++ b/modules/spidey_test.py @@ -1,9 +1,10 @@ import asyncio import os +from modules import test_template -class SpideyTest: - def __init__(self, args, agnpath, test_data): +class SpideyTest(test_template.TestTemplate): + def __init__(self, args, agnpath, test_data, queue): """ Simple test runner, for testing the detection of Spidey viruses. :param args: List of arguments @@ -12,13 +13,10 @@ class SpideyTest: :type agnpath: agnostic_path.AgnosticPath :param test_data: The data to be tested :type test_data: str + :param queue: The queue to put the status in + :type queue: queue.Queue """ - self.ptb = args.ptb - self.agnostic_path = agnpath - self.os_name = agnpath.os - self.main_path = agnpath.main_path - self.test_data = test_data - self.alive = True + super().__init__(args, agnpath, test_data, queue) def run_test(self): """ @@ -52,7 +50,12 @@ class SpideyTest: "is corrupted. We suggest uninstalling discord and deleting all its files before reinstalling.\n" "If you've recently downloaded a .exe directly sent from someone, " "do also consider a clean windows reinstall.") - return self.is_infected + print("Spidey test finished") + + self.set_status(0) + status = self.get_status() + self.queue.append(status) + return self.get_status_code() def get_path(self): """ @@ -63,33 +66,3 @@ class SpideyTest: discord_modules = self.agnostic_path("modules", "discord_modules-1", "discord_modules") discord_desktop_core = self.agnostic_path("modules", "discord_desktop_core-1", "discord_desktop_core") return discord_modules, discord_desktop_core - - def get_status_code(self): - """ - The status code of the test - :return: 0: The test was not run, 1: The test is running, 2: The test is a success, 3: Test has failed, 4: Test found problems - :rtype: int - """ - # TODO: Add this to a global_dict - return 0 - - def get_status(self): - """ - Return the status of the test, as a string, as the test is ran - :return: "Test is running", "Test was not run", "Test was run and nothing was detected", "Test was run and some problems were detected (list of problems)" - :rtype: (int, str) - """ - # TODO: Make use of a global_dict - return self.get_status_code(), "" - - -async def main(args, agnpath, test_data): - """ - The main function of the test. - :return: The status of the test - :rtype: (int, str) - """ - spidey_test = SpideyTest(args, agnpath, test_data) - await asyncio.sleep(5) - spidey_test.run_test() - return spidey_test.get_status() diff --git a/modules/test_interface.py b/modules/test_interface.py index 2f28504..956fee3 100644 --- a/modules/test_interface.py +++ b/modules/test_interface.py @@ -1,8 +1,10 @@ -import threading -import os -import re import sys import importlib +import threading +import time +import queue +from collections import deque +from modules.internal_io import global_status, test_status, return_code_dict """ All modules that can be tested @@ -12,6 +14,7 @@ argparse argument : [module_name, class_name] _TEST_MODULES = { "spidey": ["spidey_test", "SpideyTest"], } +POST_RUN_ALLOWED = False class TestRunner: @@ -38,6 +41,9 @@ class TestRunner: self.loaded_test_classes = {} self.list_of_tests = [] self.update_module_list() + + self.finished_tests = deque() + self.exec_all_tests() def update_module_list(self): @@ -48,6 +54,7 @@ class TestRunner: """ modules = {} classes = {} + module_name = None try: for module_name, values in _TEST_MODULES.items(): if self.args.__getattribute__(module_name): @@ -60,72 +67,136 @@ class TestRunner: self.loaded_test_modules.update(modules) self.loaded_test_classes.update(classes) - def test_controller(self, rate=1): - """ - Controller for the tests. - :param rate: The rate at which the controller will check the tests - :type rate: int - :return: 1 if all test ran, 0 if one or more tests failed, 2 if the user stopped the tests - """ - l_test = len(self.list_of_tests) - while True: - still_running = 0 - for t in self.list_of_tests: - if t.is_alive(): - still_running += 1 - if still_running == 0: - return 1 - - def test_killer(self): - """ - Kills the tests if the user press enter - """ - while True: - if input() == "": - for t in self.list_of_tests: - t.terminate() - return - def exec_all_tests(self): """ - Executes all the tests (later in parallel), get their result as they finishes + Executes all the tests, get their result as they finishes :return: The number of test ran, success, failures, skipped (with ran = success+failures+skip) :rtype: (int,int,int,int) # TODO: Change this to a nametuple """ self.list_of_tests = [] - for module_name, test_class in self.loaded_test_classes.items(): - tc = test_class(self.args, self.agnostic_path, None) - tc.daemon = True - tc = threading.Thread(target=tc.run_test) - self.list_of_tests.append(tc) - tc.start() + for i in range(10): + print(f"Starting test {module_name}") + tc = test_class(self.args, self.agnostic_path, None, self.finished_tests) + tc = threading.Thread(target=tc.run_test, args=()) + tc.name = str(module_name) + tc.daemon = True + self.list_of_tests.append(tc) + tc.start() - # Launch a controller to allow the user to stop the tests + # Launch a controller to allow the user to stop all tests # controller = threading.Thread(target=self.test_launcher) - # Allow the user to stop the tests - tk = threading.Thread(target=self.test_killer) - tk.start() + tc = threading.Thread(target=self.controller_test, args=()) + tc.daemon = True + tc.start() - for t in self.list_of_tests: + # Await the end of the tests or the user interruption + tc = threading.Thread(target=self.post_test_runner, args=()) + tc.start() + + # Wait for the end of the tests + tc = threading.Thread(target=self.test_waiter, args=()) + tc.daemon = True + tc.start() + + return self.is_infected, self.detections, self.test_run + + def controller_test(self): + """ + Kills the tests if the user press enter + """ + print("Press enter to stop the tests: ") + while True: + if input() == "": + if not self.is_infected: + global POST_RUN_ALLOWED + POST_RUN_ALLOWED = True + return + + def post_test_runner(self): + """ + Runs the post test runner if all tests are finished + """ + global POST_RUN_ALLOWED + if self.args.launch: + while True: + if POST_RUN_ALLOWED: + print("Running post test runner") + return 0 + time.sleep(0.5) + return 0 + + def test_waiter(self): + """ + Waits for the end of the tests + :return: + """ + for t in self.list_of_tests: # Can only proceed if all tests are finished t.join() - if tk.is_alive(): - tk.terminate() + # When all tests are finished or the user stopped the tests, we can proceed + if not self.is_infected: + global POST_RUN_ALLOWED + POST_RUN_ALLOWED = True - # await asyncio.gather(*list_of_tests) - # tc.run_test() + def get_exit_code(self): + """ + Gets the exit code of the tests + :return: The exit code + :rtype: int + """ + global POST_RUN_ALLOWED + if POST_RUN_ALLOWED: + for t in self.list_of_tests: + if t.is_alive(): + return 2 # 2 means that the user stopped the tests before the end + return self.is_infected # The user didn't stop the tests + + return -1 # The program is not finished yet + + def get_status(self): + """ + Gets the status of the tests + :return: The status + :rtype: str + """ + nb_tests = len(self.list_of_tests) + nb_tests_success = 0 + nb_tests_failure = 0 + nb_tests_skipped = 0 + for test in self.finished_tests: + print(f"Test {test.name} finished with status {test.status}") + if test.status == 0: + nb_tests_success += 1 + elif test.status == 1: + nb_tests_failure += 1 + elif test.status == 2: + nb_tests_skipped += 1 + + nb_tests_ran = nb_tests_success + nb_tests_failure + nb_tests_skipped + nb_test_running = nb_tests - nb_tests_ran + return global_status( + total_tests=nb_test_running, + tests_finished=nb_tests_ran, + tests_failed=nb_tests_failure, + tests_running=nb_test_running, + tests_skipped=nb_tests_skipped, + ) -def run_check(args, agnpath): # Todo, skip the is_infected check and defer everything to the exec_all_tests - test_selected = True - spd = TestRunner(args, agnpath) - if not spd.is_infected: - return 0 - else: - return 1 +def run_check(args, agnpath): + """ + Runs all operations selected in the config + :param args: List of arguments + :param agnpath: Annostic path to the discord folder + :return: None + """ + tr = TestRunner(args, agnpath) # All operation are executed in parallel and the user can stop them + print("Waiting for the end of the tests") + while tr.get_exit_code() == -1: + print(tr.get_status()) + time.sleep(0.5) -if __name__ == "__main__": - pass + sys.exit(tr.get_exit_code()) diff --git a/modules/test_template.py b/modules/test_template.py index e9f2d66..88dcd5f 100644 --- a/modules/test_template.py +++ b/modules/test_template.py @@ -1,5 +1,12 @@ +""" +A global template for all tests. +""" + +from modules import internal_io + + class TestTemplate: - def __init__(self, args, agnpath, test_data): + def __init__(self, args, agnpath, test_data, queue): """ Simple test template. :param args: List of arguments @@ -17,13 +24,14 @@ class TestTemplate: self.is_infected = False self.status_code = 0 self.status = "Test not yet initialized." - self.return_code_dict = { - 0: "The test was not run", - 1: "The test is running", - 2: "The test is a success", - 3: "Test has failed", - 4: "Test found problems", - } + self.queue = queue + + def name(self): + """ + :return: Name of the test + :rtype: str + """ + return str(self.__class__.__name__) def get_status_code(self): """ @@ -37,15 +45,15 @@ class TestTemplate: :return: Status at the time of call. :rtype: str """ - return self.status + return internal_io.test_status(self.name(), self.status_code, self.status) - @static + @staticmethod def get_status_from_code(code): """ :return: Description of the status code :rtype: str """ - return self.return_code_dict[code] + return internal_io.return_code_dict[code] def set_status(self, statuscode: int): """