D老师写的极域紫菜工具

Owinhos

2026-07-29 10:11:07

发布于：浙江

99阅读

0回复

0点赞

新帖因重大调用Bug已弃用

请使用新帖使用的开源项目极域工具包，密码`bbzl`

因部分地址可能被老师禁用，请执行以下bash命令（以管理员身份运行cmd）：

sc stop tdnetfilter
taskkill /f /im prochelper64.exe
taskkill /f /im masterhelper.exe

Q：什么是管理员啊？
A：

Deepseek写的，不喜勿喷

使用前必读！！！

1.本工具仅为分享使用，请在24小时内删除并恢复
2.使用本工具即您同意并知道如果被教师发现的后果
3.若使用本工具使用导致的设备故障、教师教训，不负任何责任！！

注意：编译时请加入`-std=c++11`以编译

如果发现按一次快捷键没用可以多按几次，测试5次左右可以成功被检测到

经过测试，按Shift是可以成功触发的

战绩：

1版本：单文件版，无关闭防御

#include <Windows.h>
#include <iostream>
#include <atomic>
#include <thread>
#include <string>
#include <tlhelp32.h>

std::atomic<bool> g_running(true);
std::atomic<bool> g_topMostEnabled(false);
std::atomic<bool> g_isMinimized(false);
std::atomic<bool> g_minimizeMode(false);  // false=结束模式, true=最小化模式
HWND g_hConsole = NULL;
HWND g_studentMainWnd = NULL;
std::atomic<bool> g_studentMainActive(false);
std::atomic<bool> g_autoTriggered(false);

// =============================================
// 前向声明
// =============================================
bool IsStudentMainRunning();
HWND FindStudentMainWindowHandle();
void KillStudentMain();
void ToggleMode();

// =============================================
// 强制结束 StudentMain（按K无视规则）
void KillStudentMain() {
    std::cout << "\n[K键] 强制结束 StudentMain！" << std::endl;
    system("taskkill /f /im StudentMain.exe");
    g_studentMainWnd = NULL;
    g_isMinimized = false;
    std::cout << "[执行] StudentMain 进程已结束" << std::endl;
}

// =============================================
// 检测 StudentMain.exe 进程是否存在
bool IsStudentMainRunning() {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return false;
    }

    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);

    bool found = false;
    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                found = true;
                break;
            }
        } while (Process32Next(hSnapshot, &pe32));
    }

    CloseHandle(hSnapshot);
    return found;
}

// =============================================
// 查找 StudentMain 窗口句柄
HWND FindStudentMainWindowHandle() {
    HWND hWnd = NULL;

    EnumWindows([](HWND hwnd, LPARAM lParam) -> BOOL {
        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);

        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot != INVALID_HANDLE_VALUE) {
            PROCESSENTRY32 pe32;
            pe32.dwSize = sizeof(PROCESSENTRY32);
            if (Process32First(hSnapshot, &pe32)) {
                do {
                    if (pe32.th32ProcessID == processId) {
                        if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                            if (IsWindowVisible(hwnd) || IsIconic(hwnd)) {
                                *(HWND*)lParam = hwnd;
                                CloseHandle(hSnapshot);
                                return FALSE;
                            }
                        }
                        break;
                    }
                } while (Process32Next(hSnapshot, &pe32));
            }
            CloseHandle(hSnapshot);
        }
        return TRUE;
    }, (LPARAM)&hWnd);

    return hWnd;
}

// =============================================
// 根据模式执行操作（任意键触发）
void TargetOperation() {
    if (g_minimizeMode) {
        std::cout << "\n[目标操作] 检测到按键释放，最小化 StudentMain..." << std::endl;
        if (!IsStudentMainRunning()) {
            std::cout << "[系统] StudentMain 进程不存在" << std::endl;
            g_autoTriggered = true;
            return;
        }

        if (g_studentMainWnd == NULL || !IsWindow(g_studentMainWnd)) {
            g_studentMainWnd = FindStudentMainWindowHandle();
            if (g_studentMainWnd == NULL) {
                std::cout << "[系统] 未找到 StudentMain 窗口" << std::endl;
                g_autoTriggered = true;
                return;
            }
        }

        if (!IsWindow(g_studentMainWnd)) {
            g_studentMainWnd = FindStudentMainWindowHandle();
            if (g_studentMainWnd == NULL) {
                std::cout << "[系统] StudentMain 窗口已关闭" << std::endl;
                g_autoTriggered = true;
                return;
            }
        }

        ShowWindow(g_studentMainWnd, SW_MINIMIZE);
        g_isMinimized = true;
        std::cout << "[执行] StudentMain 窗口已最小化" << std::endl;
    } else {
        std::cout << "\n[目标操作] 检测到按键释放，结束 StudentMain..." << std::endl;
        system("taskkill /f /im StudentMain.exe");
        g_studentMainWnd = NULL;
        g_isMinimized = false;
        std::cout << "[执行] StudentMain 进程已结束" << std::endl;
    }
    g_autoTriggered = true;
}

// =============================================
// 切换模式
void ToggleMode() {
    g_minimizeMode = !g_minimizeMode;
    if (g_minimizeMode) {
        std::cout << "[系统] 模式切换: 按任意键 -> 最小化 StudentMain" << std::endl;
    } else {
        std::cout << "[系统] 模式切换: 按任意键 -> 结束 StudentMain" << std::endl;
    }
}

// =============================================
// 检查窗口是否处于全屏状态
bool IsFullScreenWindow(HWND hwnd) {
    if (hwnd == NULL) return false;

    RECT windowRect;
    GetWindowRect(hwnd, &windowRect);
    int winWidth = windowRect.right - windowRect.left;
    int winHeight = windowRect.bottom - windowRect.top;

    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);

    bool isFullWidth = (winWidth >= screenWidth - 10);
    bool isFullHeight = (winHeight >= screenHeight - 10);

    LONG_PTR style = GetWindowLongPtr(hwnd, GWL_STYLE);
    bool noCaption = !(style & WS_CAPTION);

    return (isFullWidth && isFullHeight) && noCaption;
}

// =============================================
// 检查窗口是否有任务栏按钮
bool HasTaskbarButton(HWND hwnd) {
    if (hwnd == NULL) return false;

    LONG_PTR exStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);

    if (exStyle & WS_EX_TOOLWINDOW) {
        return false;
    }

    if (!IsWindowVisible(hwnd) && !IsIconic(hwnd)) {
        return false;
    }

    HWND hOwner = GetWindow(hwnd, GW_OWNER);
    if (hOwner != NULL) {
        return false;
    }

    if (!IsWindowEnabled(hwnd)) {
        return false;
    }

    RECT rect;
    GetWindowRect(hwnd, &rect);
    if (rect.right <= rect.left || rect.bottom <= rect.top) {
        return false;
    }

    return true;
}

// =============================================
// 查找 StudentMain 是否有可见窗口（全屏 + 任务栏可见）
bool HasStudentMainWindow() {
    bool found = false;

    EnumWindows([](HWND hwnd, LPARAM lParam) -> BOOL {
        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);

        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot != INVALID_HANDLE_VALUE) {
            PROCESSENTRY32 pe32;
            pe32.dwSize = sizeof(PROCESSENTRY32);
            if (Process32First(hSnapshot, &pe32)) {
                do {
                    if (pe32.th32ProcessID == processId) {
                        if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                            if (HasTaskbarButton(hwnd)) {
                                if (IsFullScreenWindow(hwnd)) {
                                    *(bool*)lParam = true;
                                    CloseHandle(hSnapshot);
                                    return FALSE;
                                }
                            }
                        }
                        break;
                    }
                } while (Process32Next(hSnapshot, &pe32));
            }
            CloseHandle(hSnapshot);
        }
        return TRUE;
    }, (LPARAM)&found);

    return found;
}

// =============================================
// 【修复】切换窗口置顶
// 移除所有BringWindowToTop/SetForegroundWindow，置顶不激活窗口
// 搭配WS_EX_NOACTIVATE，提高层级竞争能力
void ToggleTopMost() {
    if (g_hConsole == NULL) return;

    g_topMostEnabled = !g_topMostEnabled;
    LONG_PTR exStyle = GetWindowLongPtr(g_hConsole, GWL_EXSTYLE);

    if (g_topMostEnabled) {
        // ========== 重点：删掉 WS_EX_NOACTIVATE！只保留 WS_EX_TOPMOST ==========
        exStyle |= WS_EX_TOPMOST;
        exStyle &= ~WS_EX_NOACTIVATE;
        SetWindowLongPtr(g_hConsole, GWL_EXSTYLE, exStyle);
        // SWP_NOACTIVATE：仅本次置顶调用不激活，不影响鼠标点击
        SetWindowPos(g_hConsole, HWND_TOPMOST, 0, 0, 0, 0,
            SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
        std::cout << "[系统] 窗口置顶已开启" << std::endl;
    } else {
        exStyle &= ~WS_EX_TOPMOST;
        SetWindowLongPtr(g_hConsole, GWL_EXSTYLE, exStyle);
        SetWindowPos(g_hConsole, HWND_NOTOPMOST, 0, 0, 0, 0,
            SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
        std::cout << "[系统] 窗口置顶已关闭" << std::endl;
    }
}
// =============================================
// 【修复】保持窗口置顶线程
// 删除强制激活代码，只维持顶层，永不抢焦点
void KeepTopMost() {
    while (g_running) {
        if (g_hConsole && g_topMostEnabled) {
            // 仅维持顶层，无任何激活操作
            SetWindowPos(g_hConsole, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
        }
        Sleep(150);
    }
}

// =============================================
// 强力解锁键盘
void ForceUnlockKeyboard() {
    INPUT inputs[20] = {};
    int inputCount = 0;

    int allKeys[] = {
        VK_CONTROL, VK_MENU, VK_SHIFT, VK_LWIN, VK_RWIN,
        VK_CAPITAL, VK_NUMLOCK, VK_SCROLL, VK_TAB,
        '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'
    };

    for (int key : allKeys) {
        if (GetAsyncKeyState(key) & 0x8000) {
            inputs[inputCount].type = INPUT_KEYBOARD;
            inputs[inputCount].ki.wVk = key;
            inputs[inputCount].ki.dwFlags = KEYEVENTF_KEYUP;
            inputCount++;
            if (inputCount >= 20) break;
        }
    }

    if (inputCount > 0) {
        SendInput(inputCount, inputs, sizeof(INPUT));
        std::cout << "[系统] 释放了 " << inputCount << " 个锁定的按键" << std::endl;
    }
}

// =============================================
// 键盘监控线程
void KeyboardMonitor() {
    bool lastStudentMainState = false;
    bool hasWindow = false;
    bool wasLocked = false;
    bool keyPressed[256] = {false};
    bool f2Pressed = false;
    bool f3Pressed = false;
    bool kPressed = false;

    std::cout << "[系统] 键盘监控已启动，等待 StudentMain 全屏窗口出现..." << std::endl;
    std::cout << "[系统] K  键 - 强制结束 StudentMain (无视规则)" << std::endl;
    std::cout << "[系统] F2 切换窗口置顶 | F3 切换模式" << std::endl;
    std::cout << "[系统] 当前模式: 结束 StudentMain" << std::endl;

    while (g_running) {
        // ============================================
        // K 键 - 强制结束（无视规则）
        // ============================================
        bool kState = (GetAsyncKeyState('K') & 0x8000) != 0;
        if (kState && !kPressed) {
            KillStudentMain();
            kPressed = true;
        }
        if (!kState) {
            kPressed = false;
        }

        // ============================================
        // F2 - 切换置顶
        // ============================================
        bool f2State = (GetAsyncKeyState(VK_F2) & 0x8000) != 0;
        if (f2State && !f2Pressed) {
            ToggleTopMost();
            f2Pressed = true;
        }
        if (!f2State) {
            f2Pressed = false;
        }

        // ============================================
        // F3 - 切换模式
        // ============================================
        bool f3State = (GetAsyncKeyState(VK_F3) & 0x8000) != 0;
        if (f3State && !f3Pressed) {
            ToggleMode();
            f3Pressed = true;
        }
        if (!f3State) {
            f3Pressed = false;
        }

        // ============================================
        // 检测 StudentMain
        // ============================================
        bool isRunning = IsStudentMainRunning();

        if (isRunning) {
            hasWindow = HasStudentMainWindow();
            if (g_studentMainWnd == NULL || !IsWindow(g_studentMainWnd)) {
                g_studentMainWnd = FindStudentMainWindowHandle();
            }
        } else {
            hasWindow = false;
            g_studentMainWnd = NULL;
            g_isMinimized = false;
        }

        g_studentMainActive = hasWindow;

        if (hasWindow) {
            if (!lastStudentMainState) {
                std::cout << "[系统] StudentMain 全屏窗口已出现（任务栏可见）！" << std::endl;
                if (g_minimizeMode) {
                    std::cout << "[系统] 当前模式: 按任意键 -> 最小化 StudentMain" << std::endl;
                } else {
                    std::cout << "[系统] 当前模式: 按任意键 -> 结束 StudentMain" << std::endl;
                }
                std::cout << "[系统] 按 K 键可强制结束（无视规则）" << std::endl;

                ForceUnlockKeyboard();

                for (int i = 0; i < 256; i++) {
                    keyPressed[i] = false;
                }
                g_autoTriggered = false;
                wasLocked = true;
            }

            for (int key = 0; key < 256; key++) {
                // 跳过鼠标键(1-5)和特殊键
                if (key == 0 || key == VK_ESCAPE || key == VK_F2 || key == VK_F3 || key == 'K') continue;
                if (key >= 1 && key <= 5) continue;

                bool isPressed = (GetAsyncKeyState(key) & 0x8000) != 0;

                if (keyPressed[key] && !isPressed && !g_autoTriggered) {
                    TargetOperation();
                    ForceUnlockKeyboard();

                    g_autoTriggered = true;
                    for (int i = 0; i < 256; i++) {
                        keyPressed[i] = false;
                    }
                    break;
                }

                keyPressed[key] = isPressed;
            }

        } else {
            if (lastStudentMainState) {
                std::cout << "[系统] StudentMain 全屏窗口已关闭或不是全屏状态" << std::endl;
                g_autoTriggered = false;
                wasLocked = false;
                g_isMinimized = false;
            }

            if (wasLocked) {
                for (int i = 0; i < 256; i++) {
                    keyPressed[i] = false;
                }
                wasLocked = false;
            }
        }

        lastStudentMainState = hasWindow;

        if (hasWindow) {
            Sleep(50);
        } else {
            Sleep(300);
        }
    }
}

// =============================================
// 控制台关闭事件处理
BOOL WINAPI ConsoleCtrlHandler(DWORD dwCtrlType) {
    switch (dwCtrlType) {
        case CTRL_C_EVENT:
        case CTRL_BREAK_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT:
            std::cout << "\n[系统] 禁止强制关闭！请按 ESC 键或点击 X 正常退出" << std::endl;
            return TRUE;
        default:
            return FALSE;
    }
}

// =============================================
// 窗口过程 - 拦截关闭消息
LRESULT CALLBACK ConsoleWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_CLOSE:
            if (g_running) {
                g_running = false;
            }
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        case WM_SYSCOMMAND:
            if (wParam == SC_CLOSE) {
                if (g_running) {
                    g_running = false;
                }
                return 0;
            }
            break;
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

// =============================================
// 子类化控制台窗口
void SubclassConsoleWindow() {
    if (g_hConsole == NULL) return;
    SetWindowLongPtr(g_hConsole, GWLP_WNDPROC, (LONG_PTR)ConsoleWndProc);
}

// =============================================
// 键盘监听 (ESC 退出)
void KeyboardListener() {
    HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
    if (hInput == INVALID_HANDLE_VALUE) {
        std::cerr << "无法获取控制台输入句柄!" << std::endl;
        return;
    }

    DWORD dwMode;
    GetConsoleMode(hInput, &dwMode);
    SetConsoleMode(hInput, dwMode & ~ENABLE_MOUSE_INPUT & ~ENABLE_WINDOW_INPUT);

    INPUT_RECORD irBuffer[128];
    DWORD dwEventsRead;

    while (g_running) {
        if (ReadConsoleInput(hInput, irBuffer, 128, &dwEventsRead)) {
            for (DWORD i = 0; i < dwEventsRead; i++) {
                if (irBuffer[i].EventType == KEY_EVENT) {
                    KEY_EVENT_RECORD& keyEvent = irBuffer[i].Event.KeyEvent;

                    if (keyEvent.bKeyDown && keyEvent.wVirtualKeyCode == VK_ESCAPE) {
                        g_running = false;
                        break;
                    }
                }
            }
        }
        Sleep(1);
    }
}

// =============================================
// 主函数
// =============================================
int main() {
    system("cls");

    // 检查管理员权限
    HANDLE hToken;
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken)) {
        TOKEN_ELEVATION elevation;
        DWORD size = sizeof(TOKEN_ELEVATION);
        if (GetTokenInformation(hToken, TokenElevation, &elevation, size, &size)) {
            if (!elevation.TokenIsElevated) {
                std::cout << "========================================" << std::endl;
                std::cout << "警告: 程序未以管理员身份运行!" << std::endl;
                std::cout << "建议: 右键 -> 以管理员身份运行" << std::endl;
                std::cout << "========================================" << std::endl;
                std::cout << std::endl;
            }
        }
        CloseHandle(hToken);
    }

    g_hConsole = GetConsoleWindow();
    if (g_hConsole == NULL) {
        std::cerr << "无法获取控制台窗口句柄!" << std::endl;
        return 1;
    }

    SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
    SubclassConsoleWindow();

    SetConsoleTitle(TEXT("StudentMain 自动对抗工具"));

    std::cout << "========================================" << std::endl;
    std::cout << "    StudentMain 自动对抗工具" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << "功能说明：" << std::endl;
    std::cout << "  - 检测 StudentMain 全屏窗口（任务栏可见）" << std::endl;
    std::cout << "  - 检测到按键释放自动执行操作" << std::endl;
    std::cout << "  - 强力解除键盘锁定" << std::endl;
    std::cout << std::endl;
    std::cout << "快捷键：" << std::endl;
    std::cout << "  K   - 强制结束 StudentMain (无视规则)" << std::endl;
    std::cout << "  F2  - 切换窗口置顶" << std::endl;
    std::cout << "  F3  - 切换模式 (结束 <-> 最小化)" << std::endl;
    std::cout << "  ESC - 退出程序" << std::endl;
    std::cout << std::endl;
    std::cout << "当前模式：结束 StudentMain" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << std::endl;

    // 启动置顶保持线程
    std::thread topMostThread(KeepTopMost);

    // 启动键盘监控线程
    std::thread monitorThread(KeyboardMonitor);

    // 键盘监听在主线程
    KeyboardListener();

    // 等待线程结束
    if (topMostThread.joinable()) {
        topMostThread.join();
    }
    if (monitorThread.joinable()) {
        monitorThread.join();
    }

    // 退出前关闭置顶
    if (g_hConsole) {
        LONG_PTR exStyle = GetWindowLongPtr(g_hConsole, GWL_EXSTYLE);
        exStyle &= ~(WS_EX_TOPMOST | WS_EX_NOACTIVATE);
        SetWindowLongPtr(g_hConsole, GWL_EXSTYLE, exStyle);
        SetWindowPos(g_hConsole, HWND_NOTOPMOST, 0, 0, 0, 0,
            SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
    }

    // 退出前恢复 StudentMain 窗口
    if (g_studentMainWnd && IsWindow(g_studentMainWnd) && g_isMinimized) {
        ShowWindow(g_studentMainWnd, SW_RESTORE);
    }

    system("cls");
    std::cout << "\n程序已安全退出" << std::endl;
    return 0;
}

2版本：两个cpp，有防杀

1.主程序 `studentmain_guard.cpp`

#include <Windows.h>
#include <iostream>
#include <atomic>
#include <thread>
#include <string>
#include <tlhelp32.h>

std::atomic<bool> g_running(true);
std::atomic<bool> g_topMostEnabled(false);
std::atomic<bool> g_isMinimized(false);
std::atomic<bool> g_minimizeMode(false);  // false=结束模式, true=最小化模式
HWND g_hConsole = NULL;
HWND g_studentMainWnd = NULL;
std::atomic<bool> g_studentMainActive(false);
std::atomic<bool> g_autoTriggered(false);

// =============================================
// 前向声明
// =============================================
bool IsStudentMainRunning();
HWND FindStudentMainWindowHandle();
void KillStudentMain();
void ToggleMode();

// =============================================
// 强制结束 StudentMain（按K无视规则）
void KillStudentMain() {
    std::cout << "\n[K键] 强制结束 StudentMain！" << std::endl;
    system("taskkill /f /im StudentMain.exe");
    g_studentMainWnd = NULL;
    g_isMinimized = false;
    std::cout << "[执行] StudentMain 进程已结束" << std::endl;
}

// =============================================
// 检测 StudentMain.exe 进程是否存在
bool IsStudentMainRunning() {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return false;
    }
    
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    
    bool found = false;
    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                found = true;
                break;
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    
    CloseHandle(hSnapshot);
    return found;
}

// =============================================
// 检测保护进程是否存在
bool IsProtectorRunning() {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return false;
    }
    
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    
    bool found = false;
    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, "protector.exe") == 0) {
                found = true;
                break;
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    
    CloseHandle(hSnapshot);
    return found;
}

// =============================================
// 启动保护进程（完全隐藏）
void StartProtector() {
    if (IsProtectorRunning()) {
        return;
    }
    
    char path[MAX_PATH];
    GetModuleFileNameA(NULL, path, MAX_PATH);
    
    std::string exePath(path);
    size_t pos = exePath.find_last_of("\\/");
    if (pos != std::string::npos) {
        exePath = exePath.substr(0, pos + 1);
    }
    
    std::string protectorExe = exePath + "protector.exe";
    
    if (GetFileAttributesA(protectorExe.c_str()) == INVALID_FILE_ATTRIBUTES) {
        std::cout << "[系统] 找不到保护程序: " << protectorExe << std::endl;
        return;
    }
    
    STARTUPINFOA si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    
    si.dwFlags = STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_HIDE;
    
    if (CreateProcessA(protectorExe.c_str(), NULL, NULL, NULL, FALSE, 
                       DETACHED_PROCESS | CREATE_NO_WINDOW, 
                       NULL, NULL, &si, &pi)) {
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        std::cout << "[系统] 保护进程已启动 (后台)" << std::endl;
    } else {
        std::cout << "[系统] 无法启动保护进程: " << protectorExe << std::endl;
    }
}

// =============================================
// 查找 StudentMain 窗口句柄
HWND FindStudentMainWindowHandle() {
    HWND hWnd = NULL;
    
    EnumWindows([](HWND hwnd, LPARAM lParam) -> BOOL {
        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);
        
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot != INVALID_HANDLE_VALUE) {
            PROCESSENTRY32 pe32;
            pe32.dwSize = sizeof(PROCESSENTRY32);
            if (Process32First(hSnapshot, &pe32)) {
                do {
                    if (pe32.th32ProcessID == processId) {
                        if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                            if (IsWindowVisible(hwnd) || IsIconic(hwnd)) {
                                *(HWND*)lParam = hwnd;
                                CloseHandle(hSnapshot);
                                return FALSE;
                            }
                        }
                        break;
                    }
                } while (Process32Next(hSnapshot, &pe32));
            }
            CloseHandle(hSnapshot);
        }
        return TRUE;
    }, (LPARAM)&hWnd);
    
    return hWnd;
}

// =============================================
// 根据模式执行操作（任意键触发）
void TargetOperation() {
    if (g_minimizeMode) {
        std::cout << "\n[目标操作] 检测到按键释放，最小化 StudentMain..." << std::endl;
        if (!IsStudentMainRunning()) {
            std::cout << "[系统] StudentMain 进程不存在" << std::endl;
            g_autoTriggered = true;
            return;
        }
        
        if (g_studentMainWnd == NULL || !IsWindow(g_studentMainWnd)) {
            g_studentMainWnd = FindStudentMainWindowHandle();
            if (g_studentMainWnd == NULL) {
                std::cout << "[系统] 未找到 StudentMain 窗口" << std::endl;
                g_autoTriggered = true;
                return;
            }
        }
        
        if (!IsWindow(g_studentMainWnd)) {
            g_studentMainWnd = FindStudentMainWindowHandle();
            if (g_studentMainWnd == NULL) {
                std::cout << "[系统] StudentMain 窗口已关闭" << std::endl;
                g_autoTriggered = true;
                return;
            }
        }
        
        ShowWindow(g_studentMainWnd, SW_MINIMIZE);
        g_isMinimized = true;
        std::cout << "[执行] StudentMain 窗口已最小化" << std::endl;
    } else {
        std::cout << "\n[目标操作] 检测到按键释放，结束 StudentMain..." << std::endl;
        system("taskkill /f /im StudentMain.exe");
        g_studentMainWnd = NULL;
        g_isMinimized = false;
        std::cout << "[执行] StudentMain 进程已结束" << std::endl;
    }
    g_autoTriggered = true;
}

// =============================================
// 切换模式
void ToggleMode() {
    g_minimizeMode = !g_minimizeMode;
    if (g_minimizeMode) {
        std::cout << "[系统] 模式切换: 按任意键 -> 最小化 StudentMain" << std::endl;
    } else {
        std::cout << "[系统] 模式切换: 按任意键 -> 结束 StudentMain" << std::endl;
    }
}

// =============================================
// 检查窗口是否处于全屏状态
bool IsFullScreenWindow(HWND hwnd) {
    if (hwnd == NULL) return false;
    
    RECT windowRect;
    GetWindowRect(hwnd, &windowRect);
    int winWidth = windowRect.right - windowRect.left;
    int winHeight = windowRect.bottom - windowRect.top;
    
    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
    
    bool isFullWidth = (winWidth >= screenWidth - 10);
    bool isFullHeight = (winHeight >= screenHeight - 10);
    
    LONG_PTR style = GetWindowLongPtr(hwnd, GWL_STYLE);
    bool noCaption = !(style & WS_CAPTION);
    
    return (isFullWidth && isFullHeight) && noCaption;
}

// =============================================
// 检查窗口是否有任务栏按钮
bool HasTaskbarButton(HWND hwnd) {
    if (hwnd == NULL) return false;
    
    LONG_PTR exStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
    
    if (exStyle & WS_EX_TOOLWINDOW) {
        return false;
    }
    
    if (!IsWindowVisible(hwnd) && !IsIconic(hwnd)) {
        return false;
    }
    
    HWND hOwner = GetWindow(hwnd, GW_OWNER);
    if (hOwner != NULL) {
        return false;
    }
    
    if (!IsWindowEnabled(hwnd)) {
        return false;
    }
    
    RECT rect;
    GetWindowRect(hwnd, &rect);
    if (rect.right <= rect.left || rect.bottom <= rect.top) {
        return false;
    }
    
    return true;
}

// =============================================
// 查找 StudentMain 是否有可见窗口（全屏 + 任务栏可见）
bool HasStudentMainWindow() {
    bool found = false;
    
    EnumWindows([](HWND hwnd, LPARAM lParam) -> BOOL {
        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);
        
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot != INVALID_HANDLE_VALUE) {
            PROCESSENTRY32 pe32;
            pe32.dwSize = sizeof(PROCESSENTRY32);
            if (Process32First(hSnapshot, &pe32)) {
                do {
                    if (pe32.th32ProcessID == processId) {
                        if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                            if (HasTaskbarButton(hwnd)) {
                                if (IsFullScreenWindow(hwnd)) {
                                    *(bool*)lParam = true;
                                    CloseHandle(hSnapshot);
                                    return FALSE;
                                }
                            }
                        }
                        break;
                    }
                } while (Process32Next(hSnapshot, &pe32));
            }
            CloseHandle(hSnapshot);
        }
        return TRUE;
    }, (LPARAM)&found);
    
    return found;
}

// =============================================
// 切换窗口置顶
void ToggleTopMost() {
    if (g_hConsole == NULL) return;
    
    g_topMostEnabled = !g_topMostEnabled;
    
    if (g_topMostEnabled) {
        SetWindowLong(g_hConsole, GWL_EXSTYLE, 
                      GetWindowLong(g_hConsole, GWL_EXSTYLE) | WS_EX_TOPMOST);
        SetWindowPos(g_hConsole, HWND_TOPMOST, 0, 0, 0, 0, 
                     SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
        BringWindowToTop(g_hConsole);
        SetForegroundWindow(g_hConsole);
        std::cout << "[系统] 窗口置顶已开启" << std::endl;
    } else {
        SetWindowLong(g_hConsole, GWL_EXSTYLE, 
                      GetWindowLong(g_hConsole, GWL_EXSTYLE) & ~WS_EX_TOPMOST);
        SetWindowPos(g_hConsole, HWND_NOTOPMOST, 0, 0, 0, 0, 
                     SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
        std::cout << "[系统] 窗口置顶已关闭" << std::endl;
    }
}

// =============================================
// 保持窗口置顶
void KeepTopMost() {
    while (g_running) {
        if (g_hConsole && g_topMostEnabled) {
            SetWindowPos(g_hConsole, HWND_TOPMOST, 0, 0, 0, 0, 
                         SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
            
            if (GetForegroundWindow() != g_hConsole) {
                BringWindowToTop(g_hConsole);
                SetForegroundWindow(g_hConsole);
            }
        }
        Sleep(100);
    }
}

// =============================================
// 强力解锁键盘
void ForceUnlockKeyboard() {
    INPUT inputs[20] = {};
    int inputCount = 0;
    
    int allKeys[] = {
        VK_CONTROL, VK_MENU, VK_SHIFT, VK_LWIN, VK_RWIN,
        VK_CAPITAL, VK_NUMLOCK, VK_SCROLL, VK_TAB,
        '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'
    };
    
    for (int key : allKeys) {
        if (GetAsyncKeyState(key) & 0x8000) {
            inputs[inputCount].type = INPUT_KEYBOARD;
            inputs[inputCount].ki.wVk = key;
            inputs[inputCount].ki.dwFlags = KEYEVENTF_KEYUP;
            inputCount++;
            if (inputCount >= 20) break;
        }
    }
    
    if (inputCount > 0) {
        SendInput(inputCount, inputs, sizeof(INPUT));
        std::cout << "[系统] 释放了 " << inputCount << " 个锁定的按键" << std::endl;
    }
}

// =============================================
// 监控保护进程（双向保护）
void MonitorProtector() {
    bool protectorStarted = false;
    
    while (g_running) {
        if (!IsProtectorRunning()) {
            if (protectorStarted) {
                std::cout << "[系统] 保护进程被结束，正在重启..." << std::endl;
            }
            StartProtector();
            protectorStarted = true;
            Sleep(2000);
        }
        Sleep(1000);
    }
}

// =============================================
// 键盘监控线程
void KeyboardMonitor() {
    bool lastStudentMainState = false;
    bool hasWindow = false;
    bool wasLocked = false;
    bool keyPressed[256] = {false};
    bool f2Pressed = false;
    bool f3Pressed = false;
    bool kPressed = false;
    
    std::cout << "[系统] 键盘监控已启动，等待 StudentMain 全屏窗口出现..." << std::endl;
    std::cout << "[系统] K  键 - 强制结束 StudentMain (无视规则)" << std::endl;
    std::cout << "[系统] F2 切换窗口置顶 | F3 切换模式" << std::endl;
    std::cout << "[系统] 当前模式: 结束 StudentMain" << std::endl;
    
    while (g_running) {
        // ============================================
        // K 键 - 强制结束（无视规则）
        // ============================================
        bool kState = (GetAsyncKeyState('K') & 0x8000) != 0;
        if (kState && !kPressed) {
            KillStudentMain();
            kPressed = true;
        }
        if (!kState) {
            kPressed = false;
        }
        
        // ============================================
        // F2 - 切换置顶
        // ============================================
        bool f2State = (GetAsyncKeyState(VK_F2) & 0x8000) != 0;
        if (f2State && !f2Pressed) {
            ToggleTopMost();
            f2Pressed = true;
        }
        if (!f2State) {
            f2Pressed = false;
        }
        
        // ============================================
        // F3 - 切换模式
        // ============================================
        bool f3State = (GetAsyncKeyState(VK_F3) & 0x8000) != 0;
        if (f3State && !f3Pressed) {
            ToggleMode();
            f3Pressed = true;
        }
        if (!f3State) {
            f3Pressed = false;
        }
        
        // ============================================
        // 检测 StudentMain
        // ============================================
        bool isRunning = IsStudentMainRunning();
        
        if (isRunning) {
            hasWindow = HasStudentMainWindow();
            if (g_studentMainWnd == NULL || !IsWindow(g_studentMainWnd)) {
                g_studentMainWnd = FindStudentMainWindowHandle();
            }
        } else {
            hasWindow = false;
            g_studentMainWnd = NULL;
            g_isMinimized = false;
        }
        
        g_studentMainActive = hasWindow;
        
        if (hasWindow) {
            if (!lastStudentMainState) {
                std::cout << "[系统] StudentMain 全屏窗口已出现（任务栏可见）！" << std::endl;
                if (g_minimizeMode) {
                    std::cout << "[系统] 当前模式: 按任意键 -> 最小化 StudentMain" << std::endl;
                } else {
                    std::cout << "[系统] 当前模式: 按任意键 -> 结束 StudentMain" << std::endl;
                }
                std::cout << "[系统] 按 K 键可强制结束（无视规则）" << std::endl;
                
                ForceUnlockKeyboard();
                
                for (int i = 0; i < 256; i++) {
                    keyPressed[i] = false;
                }
                g_autoTriggered = false;
                wasLocked = true;
            }
            
            for (int key = 0; key < 256; key++) {
                // 跳过鼠标键(1-5)和特殊键
                if (key == 0 || key == VK_ESCAPE || key == VK_F2 || key == VK_F3 || key == 'K') continue;
                if (key >= 1 && key <= 5) continue;
                
                bool isPressed = (GetAsyncKeyState(key) & 0x8000) != 0;
                
                if (keyPressed[key] && !isPressed && !g_autoTriggered) {
                    TargetOperation();
                    ForceUnlockKeyboard();
                    
                    g_autoTriggered = true;
                    for (int i = 0; i < 256; i++) {
                        keyPressed[i] = false;
                    }
                    break;
                }
                
                keyPressed[key] = isPressed;
            }
            
        } else {
            if (lastStudentMainState) {
                std::cout << "[系统] StudentMain 全屏窗口已关闭或不是全屏状态" << std::endl;
                g_autoTriggered = false;
                wasLocked = false;
                g_isMinimized = false;
            }
            
            if (wasLocked) {
                for (int i = 0; i < 256; i++) {
                    keyPressed[i] = false;
                }
                wasLocked = false;
            }
        }
        
        lastStudentMainState = hasWindow;
        
        if (hasWindow) {
            Sleep(50);
        } else {
            Sleep(300);
        }
    }
}

// =============================================
// 控制台关闭事件处理
BOOL WINAPI ConsoleCtrlHandler(DWORD dwCtrlType) {
    switch (dwCtrlType) {
        case CTRL_C_EVENT:
        case CTRL_BREAK_EVENT:
        case CTRL_CLOSE_EVENT:
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT:
            std::cout << "\n[系统] 禁止强制关闭！请按 ESC 键或点击 X 正常退出" << std::endl;
            return TRUE;
        default:
            return FALSE;
    }
}

// =============================================
// 窗口过程 - 拦截关闭消息
LRESULT CALLBACK ConsoleWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_CLOSE:
            if (g_running) {
                g_running = false;
            }
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        case WM_SYSCOMMAND:
            if (wParam == SC_CLOSE) {
                if (g_running) {
                    g_running = false;
                }
                return 0;
            }
            break;
    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

// =============================================
// 子类化控制台窗口
void SubclassConsoleWindow() {
    if (g_hConsole == NULL) return;
    SetWindowLongPtr(g_hConsole, GWLP_WNDPROC, (LONG_PTR)ConsoleWndProc);
}

// =============================================
// 键盘监听 (ESC 退出)
void KeyboardListener() {
    HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
    if (hInput == INVALID_HANDLE_VALUE) {
        std::cerr << "无法获取控制台输入句柄!" << std::endl;
        return;
    }

    DWORD dwMode;
    GetConsoleMode(hInput, &dwMode);
    SetConsoleMode(hInput, dwMode & ~ENABLE_MOUSE_INPUT & ~ENABLE_WINDOW_INPUT);

    INPUT_RECORD irBuffer[128];
    DWORD dwEventsRead;

    while (g_running) {
        if (ReadConsoleInput(hInput, irBuffer, 128, &dwEventsRead)) {
            for (DWORD i = 0; i < dwEventsRead; i++) {
                if (irBuffer[i].EventType == KEY_EVENT) {
                    KEY_EVENT_RECORD& keyEvent = irBuffer[i].Event.KeyEvent;
                    
                    if (keyEvent.bKeyDown && keyEvent.wVirtualKeyCode == VK_ESCAPE) {
                        g_running = false;
                        break;
                    }
                }
            }
        }
        Sleep(1);
    }
}

// =============================================
// 主函数
// =============================================
int main() {
    system("cls");
    
    // 检查管理员权限
    HANDLE hToken;
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken)) {
        TOKEN_ELEVATION elevation;
        DWORD size = sizeof(TOKEN_ELEVATION);
        if (GetTokenInformation(hToken, TokenElevation, &elevation, size, &size)) {
            if (!elevation.TokenIsElevated) {
                std::cout << "========================================" << std::endl;
                std::cout << "警告: 程序未以管理员身份运行!" << std::endl;
                std::cout << "建议: 右键 -> 以管理员身份运行" << std::endl;
                std::cout << "========================================" << std::endl;
                std::cout << std::endl;
            }
        }
        CloseHandle(hToken);
    }
    
    g_hConsole = GetConsoleWindow();
    if (g_hConsole == NULL) {
        std::cerr << "无法获取控制台窗口句柄!" << std::endl;
        return 1;
    }

    SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
    SubclassConsoleWindow();

    SetConsoleTitle(TEXT("StudentMain 自动对抗工具 (双向保护)"));

    std::cout << "========================================" << std::endl;
    std::cout << "    StudentMain 自动对抗工具 (双向保护)" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << "功能说明：" << std::endl;
    std::cout << "  - 检测 StudentMain 全屏窗口（任务栏可见）" << std::endl;
    std::cout << "  - 检测到按键释放自动执行操作" << std::endl;
    std::cout << "  - 双向进程保护（互相守护）" << std::endl;
    std::cout << "  - 强力解除键盘锁定" << std::endl;
    std::cout << std::endl;
    std::cout << "快捷键：" << std::endl;
    std::cout << "  K   - 强制结束 StudentMain (无视规则)" << std::endl;
    std::cout << "  F2  - 切换窗口置顶" << std::endl;
    std::cout << "  F3  - 切换模式 (结束 <-> 最小化)" << std::endl;
    std::cout << "  ESC - 退出程序" << std::endl;
    std::cout << std::endl;
    std::cout << "当前模式：结束 StudentMain" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << std::endl;

    // 启动保护进程
    StartProtector();

    // 启动保护进程监控线程
    std::thread protectorMonitor(MonitorProtector);
    
    std::thread topMostThread(KeepTopMost);
    std::thread monitorThread(KeyboardMonitor);
    
    KeyboardListener();

    if (topMostThread.joinable()) {
        topMostThread.join();
    }
    if (monitorThread.joinable()) {
        monitorThread.join();
    }
    if (protectorMonitor.joinable()) {
        protectorMonitor.join();
    }

    if (g_hConsole) {
        SetWindowLong(g_hConsole, GWL_EXSTYLE, 
                      GetWindowLong(g_hConsole, GWL_EXSTYLE) & ~WS_EX_TOPMOST);
        SetWindowPos(g_hConsole, HWND_NOTOPMOST, 0, 0, 0, 0, 
                     SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
    }

    if (g_studentMainWnd && IsWindow(g_studentMainWnd) && g_isMinimized) {
        ShowWindow(g_studentMainWnd, SW_RESTORE);
    }

    system("cls");
    std::cout << "\n程序已安全退出" << std::endl;
    return 0;
}

2.保护程序 `protector.cpp`

#include <Windows.h>
#include <string>
#include <tlhelp32.h>

bool IsProcessRunning(const std::string& processName) {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return false;
    }
    
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    
    bool found = false;
    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, processName.c_str()) == 0) {
                found = true;
                break;
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    
    CloseHandle(hSnapshot);
    return found;
}

void StartMainProgram() {
    char path[MAX_PATH];
    GetModuleFileNameA(NULL, path, MAX_PATH);
    
    std::string exePath(path);
    size_t pos = exePath.find_last_of("\\/");
    if (pos != std::string::npos) {
        exePath = exePath.substr(0, pos + 1);
    }
    
    std::string mainExe = exePath + "studentmain_guard.exe";
    
    STARTUPINFOA si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    
    if (CreateProcessA(mainExe.c_str(), NULL, NULL, NULL, FALSE, 
                       0, NULL, NULL, &si, &pi)) {
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
    }
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    HWND hWnd = GetConsoleWindow();
    if (hWnd) {
        ShowWindow(hWnd, SW_HIDE);
    }
    
    if (!IsProcessRunning("studentmain_guard.exe")) {
        StartMainProgram();
        Sleep(2000);
    }
    
    while (true) {
        if (!IsProcessRunning("studentmain_guard.exe")) {
            StartMainProgram();
            Sleep(2000);
        }
        Sleep(1000);
    }
    
    return 0;
}

放在同一文件夹并都编译，打开主程序并点击关闭按钮即可开启后台模式

由于最小化功能有MinGW的硬性问题，D老师还做了一个还原工具

#include <Windows.h>
#include <iostream>
#include <string>
#include <tlhelp32.h>

// =============================================
// 检测 StudentMain.exe 进程是否存在
bool IsStudentMainRunning() {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return false;
    }
    
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    
    bool found = false;
    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                found = true;
                break;
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    
    CloseHandle(hSnapshot);
    return found;
}

// =============================================
// 查找 StudentMain 窗口句柄
HWND FindStudentMainWindowHandle() {
    HWND hWnd = NULL;
    
    EnumWindows([](HWND hwnd, LPARAM lParam) -> BOOL {
        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);
        
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot != INVALID_HANDLE_VALUE) {
            PROCESSENTRY32 pe32;
            pe32.dwSize = sizeof(PROCESSENTRY32);
            if (Process32First(hSnapshot, &pe32)) {
                do {
                    if (pe32.th32ProcessID == processId) {
                        if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0) {
                            // 只要是有窗口的StudentMain，包括最小化的
                            if (IsWindowVisible(hwnd) || IsIconic(hwnd)) {
                                *(HWND*)lParam = hwnd;
                                CloseHandle(hSnapshot);
                                return FALSE;
                            }
                        }
                        break;
                    }
                } while (Process32Next(hSnapshot, &pe32));
            }
            CloseHandle(hSnapshot);
        }
        return TRUE;
    }, (LPARAM)&hWnd);
    
    return hWnd;
}

// =============================================
// 恢复 StudentMain 窗口
void RestoreStudentMain() {
    std::cout << "========================================" << std::endl;
    std::cout << "    StudentMain 紧急还原工具" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << std::endl;
    
    // 检查进程是否存在
    if (!IsStudentMainRunning()) {
        std::cout << "[错误] StudentMain 进程不存在！" << std::endl;
        std::cout << "请先启动 StudentMain 再运行此工具" << std::endl;
        system("pause");
        return;
    }
    
    // 查找窗口
    HWND hWnd = FindStudentMainWindowHandle();
    
    if (hWnd == NULL) {
        std::cout << "[错误] 未找到 StudentMain 窗口！" << std::endl;
        std::cout << "可能窗口已经关闭或隐藏" << std::endl;
        system("pause");
        return;
    }
    
    // 检查窗口是否有效
    if (!IsWindow(hWnd)) {
        std::cout << "[错误] StudentMain 窗口句柄无效！" << std::endl;
        system("pause");
        return;
    }
    
    // 获取当前窗口状态
    bool isMinimized = IsIconic(hWnd);
    bool isVisible = IsWindowVisible(hWnd);
    
    std::cout << "[信息] 找到 StudentMain 窗口" << std::endl;
    std::cout << "[信息] 窗口句柄: " << hWnd << std::endl;
    std::cout << "[信息] 最小化状态: " << (isMinimized ? "是" : "否") << std::endl;
    std::cout << "[信息] 可见状态: " << (isVisible ? "可见" : "隐藏") << std::endl;
    std::cout << std::endl;
    
    // 恢复窗口
    std::cout << "[操作] 正在恢复 StudentMain 窗口..." << std::endl;
    
    // 如果被最小化，先还原
    if (isMinimized) {
        ShowWindow(hWnd, SW_RESTORE);
    }
    
    // 如果被隐藏，显示
    if (!isVisible) {
        ShowWindow(hWnd, SW_SHOW);
    }
    
    // 置顶并激活
    SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, 
                 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
    BringWindowToTop(hWnd);
    SetForegroundWindow(hWnd);
    
    // 延迟一下再取消置顶（避免被其他窗口覆盖）
    Sleep(500);
    SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, 
                 SWP_NOMOVE | SWP_NOSIZE);
    
    std::cout << std::endl;
    std::cout << "[成功] StudentMain 窗口已恢复！" << std::endl;
    std::cout << std::endl;
    
    // 再次确认状态
    Sleep(300);
    if (IsWindowVisible(hWnd) && !IsIconic(hWnd)) {
        std::cout << "[验证] 窗口已正常显示" << std::endl;
    } else {
        std::cout << "[警告] 窗口可能未完全恢复，请手动检查" << std::endl;
    }
    
    std::cout << std::endl;
    system("pause");
}

// =============================================
// 主函数
// =============================================
int main() {
    system("cls");
    RestoreStudentMain();
    return 0;
}

有帮助，赞一个

去预览

0/2000

全部评论 11

Owinhos
置顶
提示：如果你学校的机房安装了机房管理助手那么这将不是很可以使用

2026-07-28 来自浙江
0
Quing_1024
Oh my god thas so GOOD
我要分享给老师……

2026-07-29 来自浙江
1
[典狱长]格赫罗斯
$d$

2026-07-29 来自浙江
0
[典狱长]格赫罗斯
d

2026-07-29 来自浙江
0
[典狱长]格赫罗斯
d

2026-07-29 来自浙江
0
[典狱长]格赫罗斯
d
d
d
d
d
d
d
d
d
d

d
d
d
d
d
d
d
d
d
d
d
d

d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d

d
d
d
d
\d
d
d
d
d
d
d
d
d
d

d
d
d
d
d
d
d

d

2026-07-29 来自浙江
0
被资本做局的础键
1

2026-07-28 来自广东
0
J长
d

2026-07-28 来自浙江
0
J长
d

2026-07-28 来自浙江
0
J长
d

2026-07-28 来自浙江
0
Quing_1024
牛而逼之

2026-07-28 来自浙江
0