processor_killer.py

import customtkinter as ctk
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageDraw
import subprocess
import os
import threading
import time # CHANGED: Imported time for time.sleep() in the thread
from datetime import datetime, timedelta
import ctypes
import sys
import ast
from cryptography.fernet import Fernet
import json

from CTkMessagebox import CTkMessagebox

class ProcessorKillerWindow(ctk.CTkToplevel):
    def __init__(self, master):
        super().__init__(master)
        self.title("Processor Killer")
        self.geometry("880x540")
        self.minsize(700, 500)
        self.maxsize(900, 540)
        self.configure(fg_color="#181a20")
        try:
            self.iconbitmap("icon/process_killer.ico")
        except Exception:
            pass

        # Encryption
        self.encryption_key = b'X7Z0k2aY5FqznQUMGDfLnFzCzyTqxJbWuJAUBKyoPNs='
        self.enc = Fernet(self.encryption_key)

        # --- Variables ---
        self.target_name = []
        self.options = ['Once Every', 'After']
        self.abort = False
        self.details = []
        self.already_saved = False
        self.file_path = None
        self.formatted_apps = []

        # --- Tkinter variables ---
        self.toggle_admin_var = ctk.IntVar()
        self.toggle_indefinite_var = ctk.IntVar(value=1)
        self.toggle_timed_var = ctk.IntVar(value=0)
        self.toggle_hide_var = ctk.IntVar()
        self.toggle_force_var = ctk.IntVar()
        self.minutes_var = ctk.DoubleVar(value=1)
        self.dropdown_var = ctk.StringVar(value=self.options[0])

        self.icon_image = ctk.CTkImage(light_image=self.make_circle_icon("icon/process_killer.ico", 44),
                                       dark_image=self.make_circle_icon("icon/process_killer.ico", 44),
                                       size=(44, 44))
        self.create_layout()
        self.check_admin()
        self.autoload()
        self.load_scanned_apps()
        self.protocol("WM_DELETE_WINDOW", self.autosave)

    def create_layout(self):
        # ... (This function remains unchanged, no need to copy it again)
        self.menu = ctk.CTkSegmentedButton(self, values=["Save", "Save As...", "Load Profile", "Exit", "Camouflage", "Manual", "About"], command=self.handle_menu)
        self.menu.pack(pady=10, padx=18, fill="x")
        self.menu.set("") 
        
        title_frame = ctk.CTkFrame(self, fg_color="transparent")
        title_frame.pack(pady=(0, 10), padx=18, fill="x")
        ctk.CTkLabel(title_frame, image=self.icon_image, text="").pack(side="left", padx=(0, 15))
        ctk.CTkLabel(title_frame, text="Processor Killer", font=("Segoe UI", 32, "bold"), text_color="#00d4ff").pack(side="left")

        main_panes = ctk.CTkFrame(self, fg_color="transparent")
        main_panes.pack(fill="both", expand=True, padx=18)
        main_panes.grid_columnconfigure(1, weight=1)
        main_panes.grid_rowconfigure(0, weight=1)

        left_pane = ctk.CTkFrame(main_panes, fg_color="#23262f", corner_radius=18)
        left_pane.grid(row=0, column=0, sticky="nswe", padx=(0, 10))

        right_pane = ctk.CTkFrame(main_panes, fg_color="#23262f", corner_radius=18)
        right_pane.grid(row=0, column=1, sticky="nswe")
        right_pane.grid_columnconfigure((0, 2), weight=1)
        right_pane.grid_rowconfigure(1, weight=1)
        
        ctk.CTkLabel(left_pane, text="Controls", font=("Segoe UI", 18, "bold")).pack(pady=15)
        self.btn_add = ctk.CTkButton(left_pane, text="Add Target", command=self.choose_target)
        self.btn_add.pack(fill="x", padx=15, pady=6)
        self.btn_remove = ctk.CTkButton(left_pane, text="Remove Target", command=self.withdraw_target)
        self.btn_remove.pack(fill="x", padx=15, pady=6)
        self.btn_scan = ctk.CTkButton(left_pane, text="Scan Apps", command=self.initiate_scan)
        self.btn_scan.pack(fill="x", padx=15, pady=6)
        self.ch_admin = ctk.CTkCheckBox(left_pane, text="Request Admin", variable=self.toggle_admin_var, command=self.toggle_admin)
        self.ch_admin.pack(fill="x", padx=15, pady=10, side="bottom")

        ctk.CTkLabel(right_pane, text="Scanned Apps", font=("Segoe UI", 16, "bold")).grid(row=0, column=0, pady=(15, 5))
        ctk.CTkLabel(right_pane, text="Targets", font=("Segoe UI", 16, "bold")).grid(row=0, column=2, pady=(15, 5))

        self.l2 = tk.Listbox(right_pane, selectmode="multiple", height=10, bg="#181a20", fg="#fafaff", font=("Segoe UI", 12), bd=0, highlightthickness=0, selectbackground="#00d4ff", selectforeground="#181a20")
        self.l2.grid(row=1, column=0, sticky="nswe", padx=15, pady=(0,15))
        
        self.btn_to_targets = ctk.CTkButton(right_pane, text="→", width=40, command=self.add_scanned_targets)
        self.btn_to_targets.grid(row=1, column=1, padx=10)

        self.l1 = tk.Listbox(right_pane, height=10, bg="#181a20", fg="#fafaff", font=("Segoe UI", 12), bd=0, highlightthickness=0, state="disabled")
        self.l1.grid(row=1, column=2, sticky="nswe", padx=15, pady=(0,15))

        bottom_frame = ctk.CTkFrame(self, fg_color="transparent")
        bottom_frame.pack(fill="x", padx=18, pady=10)

        f_attack_type = ctk.CTkFrame(bottom_frame)
        f_attack_type.pack(side="left", padx=(0,10))
        self.ch_indefinite = ctk.CTkCheckBox(f_attack_type, text="Indefinite", variable=self.toggle_indefinite_var, command=self.toggle_attack1)
        self.ch_indefinite.pack(side="left", padx=10, pady=10)
        self.ch_timed = ctk.CTkCheckBox(f_attack_type, text="Timed", variable=self.toggle_timed_var, command=self.toggle_attack2)
        self.ch_timed.pack(side="left", padx=10, pady=10)
        
        f_timed_opts = ctk.CTkFrame(bottom_frame)
        f_timed_opts.pack(side="left", padx=(0,10))
        self.choice = ctk.CTkComboBox(f_timed_opts, variable=self.dropdown_var, values=self.options, width=120, state="disabled")
        self.choice.pack(side="left", padx=10, pady=10)
        self.entry_minutes = ctk.CTkEntry(f_timed_opts, width=60, textvariable=self.minutes_var, state="disabled")
        self.entry_minutes.pack(side="left", padx=(0,5), pady=10)
        ctk.CTkLabel(f_timed_opts, text="min").pack(side="left", padx=(0,10), pady=10)
        
        f_extra_opts = ctk.CTkFrame(bottom_frame)
        f_extra_opts.pack(side="left", padx=(0,10))
        # CHANGED: The command for the hide checkbox is updated
        self.ch_hide = ctk.CTkCheckBox(f_extra_opts, text="Hide Window", variable=self.toggle_hide_var, command=self._on_toggle_hide)
        self.ch_hide.pack(side="left", padx=10, pady=10)
        self.ch_force = ctk.CTkCheckBox(f_extra_opts, text="Force Block", variable=self.toggle_force_var)
        self.ch_force.pack(side="left", padx=10, pady=10)

        self.btn_block = ctk.CTkButton(bottom_frame, text="Block", fg_color="#ff4444", hover_color="#cc0000", text_color="#181a20", font=("Segoe UI", 16, "bold"), command=self.initiate_taskkill)
        self.btn_block.pack(side="right", fill="x", expand=True, ipady=5)

        self.all_features = [self.btn_add, self.btn_remove, self.btn_scan, self.btn_to_targets, self.ch_indefinite, self.ch_timed, self.entry_minutes, self.choice, self.ch_hide, self.ch_force]

    # --- REVERTED: Admin rights logic ---
    def check_admin(self):
        # This function can check but won't disable the button anymore
        is_admin = False
        try:
            is_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
        except AttributeError:
            pass # Not on Windows
        if is_admin:
            self.toggle_admin_var.set(1)
            self.ch_admin.configure(text="Admin Active", state="disabled")
            
    def toggle_admin(self):
        # Reverted to a simple notification
        CTkMessagebox(title='Info', message="This feature is for the standalone executable version. It will attempt to relaunch the app with admin rights.")
        # We reset the checkbox because the action wasn't performed
        self.toggle_admin_var.set(0)

    # --- NEW: Improved Hide Window Logic ---
    def _on_toggle_hide(self):
        if self.toggle_hide_var.get() == 1:
            CTkMessagebox(
                title='Hide Window Confirmation',
                message="When blocking starts, both this window and the SENTRY main window will be hidden to save resources.\n\nTo show them again and stop the attack, create a file named '0000.txt' in this application's directory.",
                icon="info"
            )
            # Ensure the file doesn't exist before starting
            if os.path.exists('0000.txt'):
                os.remove('0000.txt')

    def _handle_window_visibility(self):
        # This function runs periodically in the background thread to check visibility
        if self.toggle_hide_var.get() == 1:
            if os.path.exists("0000.txt"):
                # Use 'after' to schedule UI changes on the main thread
                self.after(0, self.master.deiconify)
                self.after(0, self.deiconify)
                self.after(0, self.stop_attack)
                os.remove('0000.txt')
            else:
                # Hide windows if they aren't already hidden
                if self.winfo_viewable(): self.after(0, self.withdraw)
                if self.master.winfo_viewable(): self.after(0, self.master.withdraw)

    # --- NEW: Non-Blocking Attack Thread ---
    def _blocking_thread_worker(self):
        """This function runs in a separate thread to avoid freezing the UI."""
        
        # Handle the "After" case which is not a loop
        if self.toggle_timed_var.get() == 1 and self.dropdown_var.get() == self.options[1]: # 'After'
            delay_seconds = self.minutes_var.get() * 60
            time.sleep(delay_seconds)
            if not self.abort:
                force = self.toggle_force_var.get() == 1
                for x in self.target_name: self.taskkill(x, force=force)
                self.after(0, self.stop_attack) # Schedule stop on main thread
            return

        # Main loop for "Indefinite" and "Once Every" modes
        while not self.abort:
            self._handle_window_visibility()
            
            force = self.toggle_force_var.get() == 1
            for x in self.target_name: self.taskkill(x, force=force)
            
            # Determine sleep duration
            if self.toggle_indefinite_var.get() == 1:
                sleep_duration = 1  # 1 second for indefinite
            else: # "Once Every"
                sleep_duration = self.minutes_var.get() * 60
            
            # Sleep for the required duration, but check for abort frequently
            for _ in range(int(sleep_duration)):
                if self.abort: break
                time.sleep(1)

    def initiate_taskkill(self):
        if not self.target_name:
            CTkMessagebox(title='Error', message='No targets selected! Cannot start.', icon="cancel")
            return
        
        self.abort = False
        self.btn_block.configure(text="Stop", fg_color="#00aa00", hover_color="#008800", command=self.stop_attack)
        self.disable_everything()
        
        # Start the background thread
        threading.Thread(target=self._blocking_thread_worker, daemon=True).start()

    def stop_attack(self):
        self.abort = True
        self.enable_everything()
        self.btn_block.configure(text="Block", fg_color="#ff4444", hover_color="#cc0000", command=self.initiate_taskkill)
        
        # Ensure windows are visible when stopped
        if not self.winfo_viewable(): self.deiconify()
        if not self.master.winfo_viewable(): self.master.deiconify()

    # --- (All other functions from your script remain here, unchanged) ---
    def make_circle_icon(self, img_path, size):
        try:
            img = Image.open(img_path).convert("RGBA").resize((size, size), Image.Resampling.LANCZOS)
        except Exception:
            img = Image.new("RGBA", (size, size), (60, 65, 80, 255))
            draw = ImageDraw.Draw(img)
            draw.ellipse((0, 0, size, size), fill=(60, 65, 80, 255))
            return img
        mask = Image.new("L", (size, size), 0)
        draw = ImageDraw.Draw(mask)
        draw.ellipse((0, 0, size, size), fill=255)
        img.putalpha(mask)
        return img
    def handle_menu(self, value):
        if value == "Save": self.savefile()
        elif value == "Save As...": self.saveasfile()
        elif value == "Load Profile": self.loadfile(False)
        elif value == "Exit": self.autosave()
        elif value == "Camouflage": self.camouflage()
        elif value == "Manual": self.manual()
        elif value == "About": self.about()
        self.after(100, lambda: self.menu.set(""))
    def scan_apps(self):
        self.btn_scan.configure(text="Scanning...", state="disabled")
        scan_app_script = """
        $registryPaths = @("HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*","HKLM:\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*","HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*")
        function Get-MainExecutable($installPath) { if ($installPath -and (Test-Path $installPath)) { $exeFiles = Get-ChildItem -Path $installPath -Filter "*.exe" -Recurse -ErrorAction SilentlyContinue | Where-Object { $_.Name -notmatch "uninstall|setup|helper|update" } | Sort-Object Length -Descending; if ($exeFiles) { return $exeFiles[0].FullName } }; return $null }
        $installedApps = foreach ($path in $registryPaths) { Get-ItemProperty $path -ErrorAction SilentlyContinue | Where-Object { $_.DisplayName } | ForEach-Object { $mainExe = Get-MainExecutable $_.InstallLocation; [PSCustomObject]@{ Name = $_.DisplayName; MainExecutable = $mainExe } } }
        $installedApps | Where-Object { $_.MainExecutable } | ConvertTo-Json -Compress
        """
        try:
            result = subprocess.run(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", scan_app_script], capture_output=True, text=True, check=True)
            app_details = json.loads(result.stdout)
            self.formatted_apps = [[app["Name"], app["MainExecutable"]] for app in app_details]
        except Exception as e:
            CTkMessagebox(title='Error', message='Failed to scan apps. This often requires admin rights.', icon="cancel")
            self.btn_scan.configure(text="Re-Scan Apps", state="normal")
            return
        self.l2.delete(0, tk.END)
        for app in self.formatted_apps:
            self.l2.insert(tk.END, app[0])
        self.details = self.formatted_apps
        self.encrypt_everything()
        with open('scanned_apps.json', 'wb') as f:
            f.write(self.details.encode('utf-8'))
        self.details = []
        self.btn_scan.configure(text="Re-Scan Apps", state="normal")
    def taskkill(self, app_name, force=False):
        command = ['taskkill', '/IM', app_name, '/T']
        if force:
            command.append('/F')
        subprocess.run(command, creationflags=subprocess.CREATE_NO_WINDOW, capture_output=True)
    def load_scanned_apps(self):
        if os.path.exists('scanned_apps.json'):
            with open('scanned_apps.json', 'rb') as f:
                file_content = f.read()
            decrypted_content = self.decrypt_everything(file_content)
            if not decrypted_content: return
            try:
                self.formatted_apps = ast.literal_eval(decrypted_content.decode('utf-8'))
                self.l2.delete(0, tk.END)
                for app in self.formatted_apps:
                    self.l2.insert(tk.END, app[0])
            except:
                return
    def initiate_scan(self):
        threading.Thread(target=self.scan_apps, daemon=True).start()
    def add_scanned_targets(self):
        selected_indices = self.l2.curselection()
        if not selected_indices:
            CTkMessagebox(title='Error', message='No apps selected from the scan list.', icon="cancel")
            return
        for i in selected_indices:
            path = self.formatted_apps[i][1]
            exe_name = self.app_full_name(path)
            if exe_name not in self.target_name:
                self.target_name.append(exe_name)
        self.rebuild_target_listbox()
    def app_full_name(self, path):
        return os.path.basename(path)
    def rebuild_target_listbox(self):
        self.l1.configure(state="normal")
        self.l1.delete(0, tk.END)
        for i, name in enumerate(self.target_name):
            self.l1.insert(tk.END, f'{i+1}: {name}')
        self.l1.configure(state="disabled")
    def choose_target(self):
        dialog = ctk.CTkInputDialog(text="Enter target .exe name (e.g., chrome.exe):", title="Add Custom Target")
        custom_target = dialog.get_input()
        if custom_target:
            self.target_name.append(custom_target if custom_target.endswith('.exe') else custom_target + '.exe')
            self.rebuild_target_listbox()
    def withdraw_target(self):
        dialog = ctk.CTkInputDialog(text="Enter number of target to remove:", title="Remove Target")
        to_remove_str = dialog.get_input()
        try:
            to_remove_idx = int(to_remove_str) - 1
            if 0 <= to_remove_idx < len(self.target_name):
                self.target_name.pop(to_remove_idx)
                self.rebuild_target_listbox()
            else:
                raise ValueError
        except (ValueError, TypeError):
            CTkMessagebox(title='Error', message='Invalid number.', icon="cancel")
    def toggle_attack1(self):
        if self.toggle_indefinite_var.get() == 1:
            self.toggle_timed_var.set(0)
            self.entry_minutes.configure(state="disabled")
            self.choice.configure(state="disabled")
        else:
            self.toggle_timed_var.set(1)
            self.entry_minutes.configure(state="normal")
            self.choice.configure(state="readonly")
    def toggle_attack2(self):
        if self.toggle_timed_var.get() == 1:
            self.toggle_indefinite_var.set(0)
            self.entry_minutes.configure(state="normal")
            self.choice.configure(state="readonly")
        else:
            self.toggle_indefinite_var.set(1)
            self.entry_minutes.configure(state="disabled")
            self.choice.configure(state="disabled")
    def disable_everything(self):
        for widget in self.all_features:
            widget.configure(state="disabled")
        self.menu.configure(state="disabled")
    def enable_everything(self):
        for widget in self.all_features:
            widget.configure(state="normal")
        self.menu.configure(state="normal")
        self.toggle_attack2() if self.toggle_timed_var.get() else self.toggle_attack1()
    def gather_details(self):
        self.details = [self.target_name, self.toggle_indefinite_var.get(), self.toggle_timed_var.get(), self.dropdown_var.get(), self.minutes_var.get(), self.toggle_hide_var.get(), self.toggle_force_var.get()]
        self.encrypt_everything()
    def execute_details(self):
        loaded_targets = self.details[0]
        self.target_name = []
        for x in loaded_targets:
            self.target_name.append(x)
        self.rebuild_target_listbox()
        self.toggle_indefinite_var.set(self.details[1])
        self.toggle_timed_var.set(self.details[2])
        self.dropdown_var.set(self.details[3])
        self.minutes_var.set(self.details[4])
        self.toggle_hide_var.set(self.details[5])
        self.toggle_force_var.set(self.details[6])
        if self.toggle_timed_var.get() == 1:
            self.toggle_attack2()
        else:
            self.toggle_attack1()
    def loadfile(self, is_autoload):
        if not is_autoload:
            open_path = filedialog.askopenfilename(defaultextension=".json", filetypes=[("JSON Files", "*.json")])
            if not open_path: return
            self.file_path = open_path
        if not self.file_path or not os.path.exists(self.file_path):
            if is_autoload and os.path.exists('path.json'): os.remove('path.json')
            return
        with open(self.file_path, 'rb') as f:
            file_content = f.read()
        decrypted_content = self.decrypt_everything(file_content)
        if not decrypted_content: 
            msg = 'Auto-load failed! File is corrupted.' if is_autoload else 'Cannot load file! It is corrupted.'
            CTkMessagebox(title='Error', message=msg, icon="cancel")
            return
        try:
            self.details = ast.literal_eval(decrypted_content.decode('utf-8'))
            self.execute_details()
            self.already_saved = True
            self.title(f"Processor Killer - {os.path.basename(self.file_path)}")
        except Exception as e:
            CTkMessagebox(title='Error', message=f'Failed to parse file content: {e}', icon="cancel")
    def savefile(self):
        if not self.already_saved or not self.file_path:
            return self.saveasfile()
        self.gather_details()
        with open(self.file_path, 'wb') as f:
            f.write(self.details.encode('utf-8'))
        self.title(f"Processor Killer - {os.path.basename(self.file_path)} (Saved)")
        return self.savepath()
    def saveasfile(self):
        temp_path = filedialog.asksaveasfilename(defaultextension=".json", filetypes=[("JSON Files", "*.json")])
        if not temp_path: return False
        self.file_path = temp_path
        self.already_saved = True
        return self.savefile()
    def autoload(self):
        if os.path.exists('path.json'):
            with open('path.json', 'r') as f:
                self.file_path = f.read()
            self.loadfile(is_autoload=True)
    def savepath(self):
        with open('path.json', 'w') as f:
            f.write(self.file_path)
        return True
    def encrypt_everything(self):
        details_as_string = str(self.details)
        self.details = self.enc.encrypt(details_as_string.encode('utf-8')).decode('utf-8')
    def decrypt_everything(self, encrypted_text):
        try:
            return self.enc.decrypt(encrypted_text)
        except:
            return False
    def autosave(self):
        if self.abort: self.stop_attack()
        msg = CTkMessagebox(title="Save?", message="You have unsaved changes. Do you want to save before closing?", icon="question", option_1="Cancel", option_2="No", option_3="Yes")
        response = msg.get()
        if response == "Yes":
            if self.savefile(): self.destroy()
        elif response == "No":
            self.destroy()
    def show_scrollable_message(self, text):
        msg_box = ctk.CTkToplevel(self)
        msg_box.title("Information")
        msg_box.geometry("450x300")
        msg_box.attributes("-topmost", True)
        msg_box.grab_set()
        content_frame = ctk.CTkFrame(msg_box, fg_color="transparent")
        content_frame.pack(pady=10, padx=10, fill="both", expand=True)
        msg_box.protocol("WM_DELETE_WINDOW", msg_box.destroy)
        try:
            info_icon = ctk.CTkImage(Image.open("icon/help.ico"), size=(40, 40))
            icon_label = ctk.CTkLabel(content_frame, image=info_icon, text="")
            icon_label.pack(side="left", padx=(0, 10), anchor="n")
        except Exception:
            pass
        text_box = ctk.CTkTextbox(content_frame, wrap="word", fg_color="transparent", height=200)
        text_box.pack(side="left", fill="both", expand=True)
        text_box.insert("0.0", text)
        text_box.configure(state="disabled")
        ok_button = ctk.CTkButton(msg_box, text="OK", command=msg_box.destroy)
        ok_button.pack(pady=10)
        self.wait_window(msg_box)
    def manual(self):
        manual_text = """
This tool allows you to block any application by its executable name (e.g., 'chrome.exe').
- Add Target: Manually add an app's .exe name.
- Remove Target: Remove a target by its number in the list.
- Scan Apps: Automatically finds installed applications. Select them from the left list and click the '→' button to add them as targets.
Attack Options:
- Indefinite Block: Continuously tries to kill the target apps.
- Timed Block:
  - Once Every [X] minutes: Kills the apps every X minutes.
  - After [X] minutes: Kills the apps once after X minutes and then stops.
- Hide Window: Hides the UI when blocking starts. To show the window and stop the attack, create a file named "0000.txt" in the same directory as the application.
- Force Block: Uses a more aggressive method to kill processes.
Profiles:
- Use the menu to Save, Save As..., and Load your list of targets and settings. The app will auto-load your last used profile on startup.
        """
        self.show_scrollable_message(manual_text)
    def about(self):
        CTkMessagebox(title="About", message="Processor Killer\nPart of the SENTRY Security Suite\nOriginal Logic by Aaditya Kandel")
    def camouflage(self):
        CTkMessagebox(title="Camouflage", message="This feature is only available in the standalone executable version of this application.")