下载vB3.0版本
下载vB4.0版本
极域安装包
开网
开网2.0
小黄杀毒
路径：此电脑->本地磁盘C：->Program Files(x86)->Mythware
//开网
#include <iostream>
#include <windows.h>
#include <tlhelp32.h>
#include <tchar.h>
bool IsProcessRunning(const TCHAR* processName);
bool IsServiceRunning(const TCHAR* serviceName);
bool StopService(const TCHAR* serviceName);
bool KillProcessByName(const TCHAR* processName);
int main() {
std::cout << "正在尝试恢复网络..." << std::endl;
const TCHAR* serviceName = TEXT("tdnetfilter");
if (IsServiceRunning(serviceName)) {
std::cout << "检测到网络过滤服务 (" << serviceName << ")，正在尝试停止..." << std::endl;
if (StopService(serviceName)) {
std::cout << "服务停止成功。" << std::endl;
} else {
std::cout << "服务停止失败，请确保以管理员身份运行。" << std::endl;
}
} else {
std::cout << "网络过滤服务未运行，跳过。" << std::endl;
}
const TCHAR* helperProcesses[] = {TEXT("MasterHelper.exe"), TEXT("StudentMain.exe")};
for (const TCHAR* processName : helperProcesses) {
if (IsProcessRunning(processName)) {
std::cout << "检测到进程 " << processName << "，正在尝试结束..." << std::endl;
if (KillProcessByName(processName)) {
std::cout << "进程结束成功。" << std::endl;
} else {
std::cout << "进程结束失败，请确保以管理员身份运行。" << std::endl;
}
}
}
std::cout << "操作执行完毕，请尝试访问网络。" << std::endl;
system("pause");
return 0;
}
bool IsProcessRunning(const TCHAR* processName) {
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE) return false;
PROCESSENTRY32 pe;
pe.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hSnapshot, &pe)) {
do {
if (_tcsicmp(pe.szExeFile, processName) == 0) {
CloseHandle(hSnapshot);
return true;
}
} while (Process32Next(hSnapshot, &pe));
}
CloseHandle(hSnapshot);
return false;
}
bool IsServiceRunning(const TCHAR* serviceName) {
SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
if (!hSCManager) return false;
SC_HANDLE hService = OpenService(hSCManager, serviceName, SERVICE_QUERY_STATUS);
if (!hService) {
CloseServiceHandle(hSCManager);
return false;
}
SERVICE_STATUS status;
bool isRunning = false;
if (QueryServiceStatus(hService, &status)) {
isRunning = (status.dwCurrentState == SERVICE_RUNNING);
}
CloseServiceHandle(hService);
CloseServiceHandle(hSCManager);
return isRunning;
}
bool StopService(const TCHAR* serviceName) {
SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (!hSCManager) return false;
SC_HANDLE hService = OpenService(hSCManager, serviceName, SERVICE_STOP | SERVICE_QUERY_STATUS);
if (!hService) {
CloseServiceHandle(hSCManager);
return false;
}
SERVICE_STATUS status;
bool result = ControlService(hService, SERVICE_CONTROL_STOP, &status);
CloseServiceHandle(hService);
CloseServiceHandle(hSCManager);
return result;
}
bool KillProcessByName(const TCHAR* processName) {
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE) return false;
PROCESSENTRY32 pe;
pe.dwSize = sizeof(PROCESSENTRY32);
bool killedAny = false;
if (Process32First(hSnapshot, &pe)) {
do {
if (_tcsicmp(pe.szExeFile, processName) == 0) {
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
if (hProcess) {
if (TerminateProcess(hProcess, 0)) {
killedAny = true;
}
CloseHandle(hProcess);
}
}
} while (Process32Next(hSnapshot, &pe));
}
CloseHandle(hSnapshot);
return killedAny;
}
//开网2.0
#include <iostream>
#include <windows.h>
#include <tlhelp32.h>
#include <tchar.h>
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
LONG WINAPI MyRegDeleteTree(HKEY hKey, LPCTSTR lpSubKey) {
HKEY hSubKey;
LONG lResult;
TCHAR szKeyName[256];
DWORD dwIndex = 0;
lResult = RegOpenKeyEx(hKey, lpSubKey, 0, KEY_READ | KEY_WRITE, &hSubKey);
if (lResult != ERROR_SUCCESS) {
return lResult;
}
while (RegEnumKey(hSubKey, dwIndex, szKeyName, 256) == ERROR_SUCCESS) {
MyRegDeleteTree(hSubKey, szKeyName);
dwIndex++;
}
RegCloseKey(hSubKey);
return RegDeleteKey(hKey, lpSubKey);
}
bool IsProcessRunning(const TCHAR* processName);
bool IsServiceRunning(const TCHAR* serviceName);
bool StopService(const TCHAR* serviceName);
bool KillProcessByName(const TCHAR* processName);
bool DisableFirewallRulesViaCMD();
bool ResetGroupPolicy();
bool ClearWFPFilters();
bool UnblockApplicationNetwork();
void EnablePrivilege();
int main() {
MessageBox(NULL,"请等到显示恢复成功再关闭程序","开网2.0",MB_OK);
EnablePrivilege();
std::cout << "========================================" << std::endl;
std::cout << " 高级网络限制解除工具 v2.0" << std::endl;
std::cout << "========================================" << std::endl;
std::cout << "正在尝试恢复网络..." << std::endl;
std::cout << std::endl;
const TCHAR* serviceName = TEXT("tdnetfilter");
if (IsServiceRunning(serviceName)) {
std::cout << "[1/7] 检测到网络过滤服务 (" << serviceName << ")，正在尝试停止..." << std::endl;
if (StopService(serviceName)) {
std::cout << " ? 服务停止成功。" << std::endl;
} else {
std::cout << " ? 服务停止失败，请确保以管理员身份运行。" << std::endl;
}
} else {
std::cout << "[1/7] 网络过滤服务未运行，跳过。" << std::endl;
}
std::cout << "[2/7] 检查并结束极域相关进程..." << std::endl;
const TCHAR* helperProcesses[] = {TEXT("MasterHelper.exe"), TEXT("StudentMain.exe"), TEXT("Student.exe"), TEXT("ClassCtrl.exe")};
for (int i = 0; i < 4; i++) {
const TCHAR* processName = helperProcesses[i];
if (IsProcessRunning(processName)) {
std::cout << " 检测到进程 " << processName << "，正在尝试结束..." << std::endl;
if (KillProcessByName(processName)) {
std::cout << " ? 进程结束成功。" << std::endl;
} else {
std::cout << " ? 进程结束失败。" << std::endl;
}
}
}
std::cout << "[3/7] 检查并禁用阻止程序的防火墙规则..." << std::endl;
if (DisableFirewallRulesViaCMD()) {
std::cout << " ? 已禁用阻止性防火墙规则。" << std::endl;
} else {
std::cout << " ? 未找到或无法禁用相关防火墙规则。" << std::endl;
}
std::cout << "[4/7] 重置应用程序网络策略..." << std::endl;
if (ResetGroupPolicy()) {
std::cout << " ? 组策略重置成功。" << std::endl;
} else {
std::cout << " ? 组策略重置可能不完整。" << std::endl;
}
std::cout << "[5/7] 清除WFP网络过滤层..." << std::endl;
if (ClearWFPFilters()) {
std::cout << " ? WFP过滤器已清除。" << std::endl;
} else {
std::cout << " ? WFP清除失败。" << std::endl;
}
std::cout << "[6/7] 解除应用程序网络锁定..." << std::endl;
if (UnblockApplicationNetwork()) {
std::cout << " ? 应用程序网络限制已解除。" << std::endl;
} else {
std::cout << " ? 部分应用程序可能仍需手动解除限制。" << std::endl;
}
std::cout << "[7/7] 刷新网络设置..." << std::endl;
system("ipconfig /flushdns > nul 2>&1");
system("netsh wininet reset proxy > nul 2>&1");
std::cout << " ? 网络设置已刷新。" << std::endl;
std::cout << std::endl;
std::cout << "========================================" << std::endl;
std::cout << "操作执行完毕！" << std::endl;
std::cout << "请尝试运行之前被限制的应用程序。" << std::endl;
std::cout << "========================================" << std::endl;
MessageBox(NULL,"恢复网络成功","开网2.0",MB_OK);
system("pause");
return 0;
}
void EnablePrivilege() {
HANDLE hToken;
TOKEN_PRIVILEGES tp;
LUID luid;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
return;
}
if (LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid)) {
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
}
CloseHandle(hToken);
}
bool DisableFirewallRulesViaCMD() {
FILE* bat = fopen("temp_firewall.bat", "w");
if (!bat) return false;
fprintf(bat, "@echo off\n");
fprintf(bat, "netsh advfirewall set allprofiles state off > nul 2>&1\n");
fprintf(bat, "netsh firewall set opmode mode=disable > nul 2>&1\n");
fprintf(bat, "del temp_firewall.bat\n");
fclose(bat);
system("temp_firewall.bat > nul 2>&1");
return true;
}
bool ResetGroupPolicy() {
HKEY hKey;
bool result = false;
if (RegOpenKeyEx(HKEY_CURRENT_USER,
TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Group Policy Objects"),
0, KEY_SET_VALUE | KEY_WRITE, &hKey) == ERROR_SUCCESS) {
MyRegDeleteTree(hKey, TEXT(""));
RegCloseKey(hKey);
result = true;
}
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("Software\\Policies\\Microsoft\\Windows\\Safer"),
0, KEY_SET_VALUE | KEY_WRITE, &hKey) == ERROR_SUCCESS) {
MyRegDeleteTree(hKey, TEXT(""));
RegCloseKey(hKey);
result = true;
}
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("Software\\Policies\\Microsoft\\Windows\\SrpV2"),
0, KEY_SET_VALUE | KEY_WRITE, &hKey) == ERROR_SUCCESS) {
MyRegDeleteTree(hKey, TEXT(""));
RegCloseKey(hKey);
result = true;
}
system("gpupdate /force > nul 2>&1");
return result;
}
bool ClearWFPFilters() {
SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (!hSCManager) return false;
bool result = false;
SC_HANDLE hService = OpenService(hSCManager, TEXT("BFE"), SERVICE_STOP | SERVICE_START | SERVICE_QUERY_STATUS);
if (hService) {
SERVICE_STATUS status;
if (QueryServiceStatus(hService, &status) && status.dwCurrentState == SERVICE_RUNNING) {
if (ControlService(hService, SERVICE_CONTROL_STOP, &status)) {
Sleep(2000);
}
StartService(hService, 0, NULL);
result = true;
}
CloseServiceHandle(hService);
}
hService = OpenService(hSCManager, TEXT("MpsSvc"), SERVICE_STOP | SERVICE_START);
if (hService) {
SERVICE_STATUS status;
ControlService(hService, SERVICE_CONTROL_STOP, &status);
Sleep(1000);
StartService(hService, 0, NULL);
result = true;
CloseServiceHandle(hService);
}
CloseServiceHandle(hSCManager);
system("netsh advfirewall reset > nul 2>&1");
return result;
}
bool UnblockApplicationNetwork() {
HKEY hKey;
if (RegOpenKeyEx(HKEY_CURRENT_USER,
TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"),
0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
DWORD autoDetect = 1;
RegSetValueEx(hKey, TEXT("AutoDetect"), 0, REG_DWORD, (BYTE*)&autoDetect, sizeof(autoDetect));
DWORD proxyEnable = 0;
RegSetValueEx(hKey, TEXT("ProxyEnable"), 0, REG_DWORD, (BYTE*)&proxyEnable, sizeof(proxyEnable));
RegCloseKey(hKey);
}
return true;
}
bool IsProcessRunning(const TCHAR* processName) {
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE) return false;
PROCESSENTRY32 pe;
pe.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hSnapshot, &pe)) {
do {
if (_tcsicmp(pe.szExeFile, processName) == 0) {
CloseHandle(hSnapshot);
return true;
}
} while (Process32Next(hSnapshot, &pe));
}
CloseHandle(hSnapshot);
return false;
}
bool IsServiceRunning(const TCHAR* serviceName) {
SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
if (!hSCManager) return false;
SC_HANDLE hService = OpenService(hSCManager, serviceName, SERVICE_QUERY_STATUS);
if (!hService) {
CloseServiceHandle(hSCManager);
return false;
}
SERVICE_STATUS status;
bool isRunning = false;
if (QueryServiceStatus(hService, &status)) {
isRunning = (status.dwCurrentState == SERVICE_RUNNING);
}
CloseServiceHandle(hService);
CloseServiceHandle(hSCManager);
return isRunning;
}
bool StopService(const TCHAR* serviceName) {
SC_HANDLE hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (!hSCManager) return false;
SC_HANDLE hService = OpenService(hSCManager, serviceName, SERVICE_STOP | SERVICE_QUERY_STATUS);
if (!hService) {
CloseServiceHandle(hSCManager);
return false;
}
SERVICE_STATUS status;
bool result = ControlService(hService, SERVICE_CONTROL_STOP, &status);
CloseServiceHandle(hService);
CloseServiceHandle(hSCManager);
return result;
}
bool KillProcessByName(const TCHAR* processName) {
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE) return false;
PROCESSENTRY32 pe;
pe.dwSize = sizeof(PROCESSENTRY32);
bool killedAny = false;
if (Process32First(hSnapshot, &pe)) {
do {
if (_tcsicmp(pe.szExeFile, processName) == 0) {
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
if (hProcess) {
if (TerminateProcess(hProcess, 0)) {
killedAny = true;
}
CloseHandle(hProcess);
}
}
} while (Process32Next(hSnapshot, &pe));
}
CloseHandle(hSnapshot);
return killedAny;
}
//vB4.0
#include <bits/stdc++.h>
#include <windows.h>
#define ll long long
using namespace std;
namespace dj {
inline void cd(int x) {
Sleep(x);
system("cls");
}
bool axj(long long key) {
return (GetKeyState(key) < 0) ? (true) : (false);
}
struct hl {
long long h,l;
};
void de(int x) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),x);
}
bool ax(long long key) {
return (GetKeyState(key) < 0) ? (true) : (false);
}
hl wz(bool x = 1, bool n = 1) {
HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
HWND h = GetForegroundWindow();
CONSOLE_FONT_INFO consoleCurrentFont;
hl hl;
POINT p;
if (x) {
GetCursorPos(&p);
ScreenToClient(h, &p);
} else {
GetCursorPos(&p);
}
if (n) {
GetCurrentConsoleFont(hOutput, FALSE, &consoleCurrentFont);
p.x /= consoleCurrentFont.dwFontSize.X;
p.y /= consoleCurrentFont.dwFontSize.Y;
}
hl.h = p.y + 1;
hl.l = p.x + 1;
return hl;
}
void ycbj() {
HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
DWORD mode;
GetConsoleMode(hStdin, &mode);
mode &= ~ENABLE_QUICK_EDIT_MODE;
SetConsoleMode(hStdin, mode);
return;
}
void ycgb() {
CONSOLE_CURSOR_INFO cursor;
cursor.bVisible = FALSE;
cursor.dwSize = sizeof(cursor);
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorInfo(handle, &cursor);
return;
}
inline void ydgb(long long h, long long l) {
COORD pos = { l - 1,h - 1 };
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hOut, pos);
return;
}
bool pdbj(int y,int x,int x1,int x2,int ys,string zt) {
ycgb();
ycbj();
hl z=wz(1,1);
bool a=0;
if(z.h==y&&z.l>=x1&&z.l<=x2) {
ydgb(y,x);
de(ys*16);
cout<<zt;
de(ys);
if(axj(VK_LBUTTON)) {
a=1;
}
} else {
ydgb(y,x);
de(ys);
cout<<zt;
}
de(15);
return a;
}
};
using namespace dj;
int cnt=0,yx=0;
bool keyStates[256] = {false},k=0;
const string STUDENT_MAIN_PATH = "C:\\Program Files (x86)\\Mythware\\极域课堂管理系统软件V6.0 2016 豪华版\\StudentMain.exe";
bool IsRunAsAdmin() {
BOOL bIsAdmin = FALSE;
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
PSID pAdministratorSid = NULL;
do {
if (!AllocateAndInitializeSid(&NtAuthority, 2,
SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0, &pAdministratorSid)) {
break;
}
if (!CheckTokenMembership(NULL, pAdministratorSid, &bIsAdmin)) {
bIsAdmin = FALSE;
}
} while (false);
if (pAdministratorSid) {
FreeSid(pAdministratorSid);
pAdministratorSid = NULL;
}
return (bool)bIsAdmin;
}
void RequestAdminPrivileges() {
char szPath[MAX_PATH] = {0};
if (GetModuleFileNameA(NULL, szPath, MAX_PATH)) {
HINSTANCE hResult = ShellExecuteA(NULL, "runas", szPath, NULL, NULL, SW_SHOWNORMAL);
if (hResult <= (HINSTANCE)32) {
if (GetLastError() == ERROR_CANCELLED) {
cout << "用户拒绝了管理员权限请求，程序可能无法正常工作！"<<endl<<endl;
cout << "按任意键继续（某些功能可能受限）..."<<endl<<endl;
system("pause >nul");
}
} else {
exit(0);
}
}
}
void killjiyu() {
if(GetAsyncKeyState('B')) {
cnt++;
cout<<"第"<<cnt<<"次肘击极域，情况：";
system("taskkill /F /IM StudentMain.exe /T");
Sleep(1000);
}
}
void cqjy() {
if (GetAsyncKeyState('C')) {
if (!keyStates['C']) {
string startCmd = "start \"\" \"" + STUDENT_MAIN_PATH + "\"";
int result = system(startCmd.c_str());
if (result == 0) {
cout<<"启动极域客户端成功!"<<endl<<endl;
} else {
cout<<"启动极域失败！请检查路径是否正确："<<STUDENT_MAIN_PATH<<endl<<endl;
cout<<"请确认极域安装路径，并修改代码中的 STUDENT_MAIN_PATH 常量"<<endl<<endl;
}
keyStates['C'] = true;
}
} else {
keyStates['C'] = false;
}
}
void cxcc() {
if(k==1&&yx>=10) {
system("taskkill /F /IM StudentMain.exe /T");
yx=0;
}
}
int main() {
HWND console = GetConsoleWindow();
MoveWindow(console, 580, 280, 400, 400, TRUE);
system("title 极域杀手vB4.0版本");
bool isAdmin = IsRunAsAdmin();
if (!isAdmin) {
cout<<endl<<"检测到程序未以管理员权限运行"<<endl<<endl;
cout<<"正在请求管理员权限，请稍候..."<<endl<<endl;
Sleep(2000);
RequestAdminPrivileges();
isAdmin = IsRunAsAdmin();
system("cls");
cout<<endl<< "警告：程序将在受限模式下运行！"<<endl<<endl;
cout<<"部分需要管理员权限的功能可能无法使用。"<<endl<<endl;
Sleep(3000);
system("cls");
}
while(1) {
pdbj(2,1,1,8,15,"简易频道");
pdbj(4,1,1,8,15,"详细频道");
pdbj(6,1,1,8,15,"功能频道");
pdbj(8,1,1,8,15,"高级频道");
cout<<endl<<endl<<"B.杀死极域"<<endl<<endl;
cout<<"C.重启极域"<<endl<<endl;
killjiyu();
cqjy();
if(pdbj(2,1,1,8,15,"简易频道")) {
system("cls");
while(1) {
pdbj(2,1,1,5,15,"任务管理器");
pdbj(4,1,1,5,15,"退出简易频道");
cout<<endl<<endl<<"B.杀死极域"<<endl<<endl;
cout<<"C.重启极域"<<endl<<endl;
killjiyu();
cqjy();
if(pdbj(2,1,1,5,15,"任务管理器")) {
system("start taskmgr.exe");
cout<<" 已打开任务管理器";
}
if(pdbj(4,1,1,5,15,"退出简易频道")) {
break;
}
cout<<endl;
yx++;
Sleep(100);
cxcc();
system("cls");
}
}
if(pdbj(4,1,1,8,15,"详细频道")) {
system("cls");
while(1) {
pdbj(2,1,1,14,15,"任务管理器");
pdbj(4,1,1,14,15,"BCOI");
pdbj(6,1,1,14,15,"更多版本");
pdbj(8,1,1,14,15,"删除极域文件夹");
pdbj(10,1,1,14,15,"后台运行");
pdbj(12,1,1,14,15,"CMD");
pdbj(14,1,1,14,15,"退出详细频道");
cout<<endl<<endl<<"B.杀死极域"<<endl<<endl;
cout<<"C.重启极域"<<endl<<endl;
killjiyu();
cqjy();
if(pdbj(2,1,1,14,15,"任务管理器")) {
system("start taskmgr.exe");
cout<<" 已打开任务管理器";
}
if(pdbj(4,1,1,14,15,"BCOI")) {
system("start https://www.bcoi.cn");
cout<<" 已打开BCOI";
}
if(pdbj(6,1,1,14,15,"更多版本")) {
system("start https://www.bcoi.cn/d/gfhd/blog/616");
cout<<" 已打开更多版本";
}
if(pdbj(8,1,1,14,15,"删除极域文件夹")) {
system("rmdir /s /q \"C:\\Program Files (x86)\\Mythware\" >nul 2>&1");
cout<<" 已删除极域文件夹";
}
if(pdbj(10,1,1,14,15,"后台运行")) {
cout<<" 当后台运行时,按S键显示终端";
Sleep(3000);
HWND hwnd = GetConsoleWindow();
ShowWindow(hwnd, SW_HIDE);
}
if(GetAsyncKeyState('S')) {
HWND hwnd = GetConsoleWindow();
ShowWindow(hwnd, SW_SHOW);
}
if(pdbj(12,1,1,14,15,"CMD")) {
system("start cmd");
cout<<" 已打开CMD";
}
if(pdbj(14,1,1,14,15,"退出详细频道")) {
break;
}
cout<<endl;
yx++;
Sleep(100);
cxcc();
system("cls");
}
}
if(pdbj(6,1,1,8,15,"功能频道")) {
system("cls");
while(1) {
pdbj(2,1,1,10,15,"计算器");
pdbj(4,1,1,10,15,"记事本");
pdbj(6,1,1,10,15,"画图工具");
pdbj(8,1,1,10,15,"控制面板");
pdbj(10,1,1,10,15,"退出功能频道");
cout<<endl<<endl<<"B.杀死极域"<<endl<<endl;
cout<<"C.重启极域"<<endl<<endl;
killjiyu();
cqjy();
if(pdbj(2,1,1,10,15,"计算器")) {
system("start calc");
cout<<" 已打开计算器";
}
if(pdbj(4,1,1,10,15,"记事本")) {
system("start notepad");
cout<<" 已打开记事本";
}
if(pdbj(6,1,1,10,15,"画图工具")) {
system("start mspaint");
cout<<" 已打开画图工具";
}
if(pdbj(8,1,1,10,15,"控制面板")) {
system("start control");
cout<<" 已打开控制面板";
}
if(pdbj(10,1,1,10,15,"退出功能频道")) {
break;
}
cout<<endl;
yx++;
Sleep(100);
cxcc();
system("cls");
}
}
if(pdbj(8,1,1,8,15,"高级频道")) {
system("cls");
while(1) {
pdbj(2,1,1,16,15,"全方位查杀极域");
pdbj(4,1,1,16,15,"全方位删除极域文件夹");
pdbj(6,1,1,16,15,"全面扫描并修复系统");
pdbj(10,1,1,16,15,"U盘解禁");
if(k==0) {
pdbj(8,1,1,16,15,"持续查杀极域(未开启)");
} else {
pdbj(8,1,1,16,15,"持续查杀极域(正在运行)");
}
pdbj(12,1,1,16,15,"退出高级频道");
cout<<endl<<endl<<"B.杀死极域"<<endl<<endl;
cout<<"C.重启极域"<<endl<<endl;
killjiyu();
cqjy();
if(pdbj(2,1,1,16,15,"全方位查杀极域")) {
system("sc stop JYService >nul 2>&1");
system("sc config JYService start= disabled >nul 2>&1");
system("taskkill /im MythwareService.exe /f >nul 2>&1");
system("taskkill /im StudentService_Proxy.exe /f >nul 2>&1");
system("taskkill /im StudentMain.exe /f >nul 2>&1");
system("taskkill /im XStudent.exe /f >nul 2>&1");
system("taskkill /im XTRudent.exe /f >nul 2>&1");
system("taskkill /im GATESRV.exe /f >nul 2>&1");
system("taskkill /im DispcapHelper.exe /f >nul 2>&1");
system("taskkill /im MasterHelper.exe /f >nul 2>&1");
system("taskkill /im ProcHelper64.exe /f >nul 2>&1");
system("taskkill /im Student.exe /f >nul 2>&1");
system("taskkill /im JYService.exe /f >nul 2>&1");
system("taskkill /im jyclass.exe /f >nul 2>&1");
cout<<" 已全方位查杀极域";
Sleep(1000);
}
if(pdbj(4,1,1,16,15,"全方位删除极域文件夹")) {
system("sc stop JYService >nul 2>&1");
system("sc config JYService start= disabled >nul 2>&1");
system("taskkill /im MythwareService.exe /f >nul 2>&1");
system("taskkill /im StudentService_Proxy.exe /f >nul 2>&1");
system("taskkill /im StudentMain.exe /f >nul 2>&1");
system("taskkill /im XStudent.exe /f >nul 2>&1");
system("taskkill /im XTRudent.exe /f >nul 2>&1");
system("taskkill /im GATESRV.exe /f >nul 2>&1");
system("taskkill /im DispcapHelper.exe /f >nul 2>&1");
system("taskkill /im MasterHelper.exe /f >nul 2>&1");
system("taskkill /im ProcHelper64.exe /f >nul 2>&1");
system("taskkill /im Student.exe /f >nul 2>&1");
system("taskkill /im JYService.exe /f >nul 2>&1");
system("taskkill /im jyclass.exe /f >nul 2>&1");
system("rmdir /s /q \"C:\\Program Files (x86)\\Mythware\" >nul 2>&1");
system("del /f /s /q \"C:\\Program Files (x86)\\Mythware\\*.*\" >nul 2>&1");
cout<<" 已全方位删除极域文件夹";
Sleep(1000);
}
if(pdbj(6,1,1,16,15,"全面扫描并修复系统")) {
system("cls");
cout<<" 为您全面扫描并修复系统"<<endl<<endl;
system("sfc /scannow");
}
if(pdbj(10,1,1,16,15,"U盘解禁")) {
system("cls");
cout<<" 为您解禁U盘"<<endl<<endl<<endl;
system("taskkill /im GATESRV.exe /f & taskkill /im MasterHelper.exe /f & sc stop TdNetFilter");
system("sc stop TDFileFilter ");
system("sc delete TDFileFilter");
MessageBox(NULL,"U盘解禁完成！", "JIYU_KILLER vB4.0",MB_OK);
MessageBox(NULL,"若仍异常，彻底卸载极域学生端后重试", "JIYU_KILLER vB4.0",MB_OK);
Sleep(2000);
}
if(k==0) {
if(pdbj(8,1,1,16,15,"持续查杀极域(未开启)")) {
cout<<" 已为您打开持续查杀极域，系统将每3秒查杀一次极域";
k=1;
Sleep(2000);
}
} else {
if(pdbj(8,1,1,16,15,"持续查杀极域(正在运行)")) {
cout<<" 已为您关闭持续查杀极域";
k=0;
Sleep(2000);
}
}
if(pdbj(12,1,1,16,15,"退出高级频道")) {
break;
}
cout<<endl;
yx++;
Sleep(100);
cxcc();
system("cls");
}
}
cout<<endl;
yx++;
Sleep(100);
cxcc();
system("cls");
}
return 0;
}
//小黄杀毒
#define WIN32_LEAN_AND_MEAN
#define _WIN32_WINNT 0x0501
#include <bits/stdc++.h>
#include <windows.h>
#include <shellapi.h>
#include <cstring>
#include <string>
#include <atomic>
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "advapi32.lib")
#pragma comment(lib, "shell32.lib")
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
HHOOK g_hKeyboardHook = NULL;
HHOOK g_hMouseHook = NULL;
std::atomic<bool> g_bInputLocked(false);
std::atomic<bool> g_bRunning(true);
HWND g_hMainWnd = NULL;
NOTIFYICONDATAA g_nid = {};
#define WM_TRAYICON (WM_APP + 1)
#define IDM_EXIT 1001
#define IDM_CLOSE 1002
#define IDM_TOPMOST 1003
#define IDM_MINIMIZE 1004
// 右键菜单相关全局变量
HWND g_hContextMenuWnd = NULL; // 当前右键点击的窗口句柄
void Log(const char* msg) {
OutputDebugStringA(msg);
}
bool DetectInputHijack(DWORD vkCode, DWORD flags) {
if (flags & LLKHF_INJECTED) {
Log("[小黄杀毒] 检测到模拟键盘输入，可能被远程控制！\n");
return true;
}
static DWORD lastKeyTime = 0;
static int rapidKeyCount = 0;
DWORD currentTime = GetTickCount();
if (currentTime - lastKeyTime < 10) {
rapidKeyCount++;
if (rapidKeyCount > 5) {
Log("[小黄杀毒] 检测到异常键盘输入频率！\n");
return true;
}
} else {
rapidKeyCount = 0;
}
lastKeyTime = currentTime;
return false;
}
void UnlockInputDevices() {
Log("[小黄杀毒] 正在解锁键盘和鼠标...\n");
ReleaseCapture();
if (g_hKeyboardHook) {
UnhookWindowsHookEx(g_hKeyboardHook);
g_hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc,
GetModuleHandle(NULL), 0);
}
if (g_hMouseHook) {
UnhookWindowsHookEx(g_hMouseHook);
g_hMouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseProc,
GetModuleHandle(NULL), 0);
}
if (g_hMainWnd) {
SetForegroundWindow(g_hMainWnd);
SetFocus(g_hMainWnd);
}
g_bInputLocked = false;
Log("[小黄杀毒] 键盘和鼠标已解锁！\n");
}
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
if (nCode >= 0) {
KBDLLHOOKSTRUCT* pKbStruct = (KBDLLHOOKSTRUCT*)lParam;
if (DetectInputHijack(pKbStruct->vkCode, pKbStruct->flags)) {
g_bInputLocked = true;
UnlockInputDevices();
return 1;
}
if (g_bInputLocked) {
return 1;
}
}
return CallNextHookEx(g_hKeyboardHook, nCode, wParam, lParam);
}
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam) {
if (nCode >= 0) {
MSLLHOOKSTRUCT* pMsStruct = (MSLLHOOKSTRUCT*)lParam;
if (pMsStruct->flags & LLMHF_INJECTED) {
Log("[小黄杀毒] 检测到模拟鼠标输入，可能被远程控制！\n");
g_bInputLocked = true;
UnlockInputDevices();
return 1;
}
if (g_bInputLocked) {
return 1;
}
}
return CallNextHookEx(g_hMouseHook, nCode, wParam, lParam);
}
bool InitInputProtection() {
g_hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc,
GetModuleHandle(NULL), 0);
g_hMouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseProc,
GetModuleHandle(NULL), 0);
if (!g_hKeyboardHook || !g_hMouseHook) {
Log("[小黄杀毒] 钩子安装失败！请以管理员权限运行。\n");
return false;
}
Log("[小黄杀毒] 键盘鼠标保护已启用\n");
return true;
}
void StopInputProtection() {
if (g_hKeyboardHook) {
UnhookWindowsHookEx(g_hKeyboardHook);
g_hKeyboardHook = NULL;
}
if (g_hMouseHook) {
UnhookWindowsHookEx(g_hMouseHook);
g_hMouseHook = NULL;
}
Log("[小黄杀毒] 键盘鼠标保护已停止\n");
}
bool IsWindowForcedTopmost(HWND hWnd) {
LONG exStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
return (exStyle & WS_EX_TOPMOST) != 0;
}
// 切换窗口置顶状态
void ToggleWindowTopmost(HWND hWnd) {
LONG exStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
if (exStyle & WS_EX_TOPMOST) {
// 取消置顶
SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
Log("[小黄杀毒] 已取消窗口置顶\n");
} else {
// 设置置顶
SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
Log("[小黄杀毒] 已设置窗口置顶\n");
}
}
void MakeWindowMinimizable(HWND hWnd) {
ShowWindow(hWnd, SW_SHOW);
LONG style = GetWindowLong(hWnd, GWL_STYLE);
if (!(style & WS_MINIMIZEBOX)) {
SetWindowLong(hWnd, GWL_STYLE, style | WS_MINIMIZEBOX);
}
LONG exStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
if (exStyle & WS_EX_TOPMOST) {
SetWindowLong(hWnd, GWL_EXSTYLE, exStyle & ~WS_EX_TOPMOST);
SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
}
SetWindowPos(hWnd, NULL, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
char buf[256];
sprintf(buf, "[小黄杀毒] 已将窗口 0x%p 改为可最小化\n", hWnd);
Log(buf);
}
// 显示窗口右键菜单
void ShowWindowContextMenu(HWND hWnd, int x, int y) {
g_hContextMenuWnd = hWnd;
HMENU hMenu = CreatePopupMenu();
// 根据窗口当前置顶状态显示不同文本
bool isTopmost = IsWindowForcedTopmost(hWnd);
AppendMenuA(hMenu, MF_STRING, IDM_TOPMOST, isTopmost ? "取消置顶" : "置顶");
AppendMenuA(hMenu, MF_STRING, IDM_MINIMIZE, "最小化");
AppendMenuA(hMenu, MF_SEPARATOR, 0, NULL);
AppendMenuA(hMenu, MF_STRING, IDM_CLOSE, "关闭");
SetForegroundWindow(g_hMainWnd);
TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, x, y, 0, g_hMainWnd, NULL);
DestroyMenu(hMenu);
}
// 鼠标钩子增强：检测窗口标题栏右键点击
LRESULT CALLBACK MouseProcEnhanced(int nCode, WPARAM wParam, LPARAM lParam) {
if (nCode >= 0) {
MSLLHOOKSTRUCT* pMsStruct = (MSLLHOOKSTRUCT*)lParam;
// 原有功能：检测模拟鼠标输入
if (pMsStruct->flags & LLMHF_INJECTED) {
Log("[小黄杀毒] 检测到模拟鼠标输入，可能被远程控制！\n");
g_bInputLocked = true;
UnlockInputDevices();
return 1;
}
// 新增功能：检测右键点击（WM_RBUTTONUP）
if (wParam == WM_RBUTTONUP) {
POINT pt = pMsStruct->pt;
HWND hWnd = WindowFromPoint(pt);
// 获取点击位置的窗口
if (hWnd) {
// 获取窗口标题
char windowTitle[256];
GetWindowTextA(hWnd, windowTitle, sizeof(windowTitle));
// 检查是否点击在标题栏区域
RECT rc;
GetWindowRect(hWnd, &rc);
int titleBarHeight = GetSystemMetrics(SM_CYCAPTION);
// 简单判断：点击位置在窗口顶部标题栏区域
if (pt.y >= rc.top && pt.y <= rc.top + titleBarHeight) {
// 检查是否为强制置顶窗口
if (IsWindowForcedTopmost(hWnd)) {
Log("[小黄杀毒] 检测到强制置顶窗口右键点击，显示菜单\n");
ShowWindowContextMenu(hWnd, pt.x, pt.y);
}
}
}
}
if (g_bInputLocked) {
return 1;
}
}
return CallNextHookEx(g_hMouseHook, nCode, wParam, lParam);
}
BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam) {
if (!IsWindowVisible(hWnd)) return TRUE;
char windowTitle[256];
GetWindowTextA(hWnd, windowTitle, sizeof(windowTitle));
if (strlen(windowTitle) == 0) return TRUE;
if (IsWindowForcedTopmost(hWnd)) {
char buf[512];
sprintf(buf, "[小黄杀毒] 发现强制置顶窗口: %s (0x%p)\n", windowTitle, hWnd);
Log(buf);
MakeWindowMinimizable(hWnd);
}
return TRUE;
}
void ScanAndFixTopmostWindows() {
Log("[小黄杀毒] 正在扫描强制置顶窗口...\n");
EnumWindows(EnumWindowsProc, 0);
Log("[小黄杀毒] 强制置顶扫描完成\n");
}
DWORD WINAPI TopmostMonitorThread(LPVOID lpParam) {
while (g_bRunning) {
ScanAndFixTopmostWindows();
Sleep(5000);
}
return 0;
}
bool ShowShutdownConfirmDialog() {
int result = MessageBoxA(
g_hMainWnd,
"小黄杀毒 - 关机确认\n\n系统正在尝试关机。\n您是否确认要关闭计算机？\n\n点击「是」继续关机\n点击「否」取消关机",
"小黄杀毒 - 关机保护",
MB_YESNO | MB_ICONQUESTION | MB_SYSTEMMODAL | MB_TOPMOST
);
Log(result == IDYES ? "[小黄杀毒] 用户确认关机\n" : "[小黄杀毒] 用户取消了关机\n");
return (result == IDYES);
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_CREATE:
{
g_nid.cbSize = sizeof(NOTIFYICONDATAA);
g_nid.hWnd = hWnd;
g_nid.uID = 1;
g_nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
g_nid.uCallbackMessage = WM_TRAYICON;
g_nid.hIcon = LoadIcon(NULL, IDI_APPLICATION);
strcpy(g_nid.szTip, "小黄杀毒 - 运行中");
Shell_NotifyIconA(NIM_ADD, &g_nid);
Log("[小黄杀毒] 主窗口已创建，托盘图标已添加\n");
break;
}
case WM_TRAYICON:
{
if (lParam == WM_RBUTTONUP) {
HMENU hMenu = CreatePopupMenu();
AppendMenuA(hMenu, MF_STRING, IDM_EXIT, "退出");
SetForegroundWindow(hWnd);
POINT pt;
GetCursorPos(&pt);
TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hWnd, NULL);
DestroyMenu(hMenu);
}
break;
}
case WM_COMMAND:
{
switch (LOWORD(wParam)) {
case IDM_EXIT:
DestroyWindow(hWnd);
break;
case IDM_CLOSE:
if (g_hContextMenuWnd && IsWindow(g_hContextMenuWnd)) {
PostMessage(g_hContextMenuWnd, WM_CLOSE, 0, 0);
Log("[小黄杀毒] 已关闭窗口\n");
}
break;
case IDM_TOPMOST:
if (g_hContextMenuWnd && IsWindow(g_hContextMenuWnd)) {
ToggleWindowTopmost(g_hContextMenuWnd);
}
break;
case IDM_MINIMIZE:
if (g_hContextMenuWnd && IsWindow(g_hContextMenuWnd)) {
ShowWindow(g_hContextMenuWnd, SW_MINIMIZE);
Log("[小黄杀毒] 已最小化窗口\n");
}
break;
}
break;
}
case WM_QUERYENDSESSION:
{
Log("[小黄杀毒] 收到关机请求，弹出确认对话框...\n");
if (ShowShutdownConfirmDialog()) {
return TRUE;
} else {
return FALSE;
}
}
case WM_ENDSESSION:
{
if (wParam) {
Log("[小黄杀毒] 系统正在关机，程序即将退出...\n");
g_bRunning = false;
PostQuitMessage(0);
}
return 0;
}
case WM_DESTROY:
{
Shell_NotifyIconA(NIM_DELETE, &g_nid);
PostQuitMessage(0);
return 0;
}
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
bool CreateMainWindow(HINSTANCE hInstance) {
const char CLASS_NAME[] = "LittleYellowAntivirusClass";
WNDCLASSEXA wc = {};
wc.cbSize = sizeof(WNDCLASSEXA);
wc.lpfnWndProc = WndProc;
wc.hInstance = hInstance;
wc.lpszClassName = CLASS_NAME;
if (!RegisterClassExA(&wc)) {
return false;
}
g_hMainWnd = CreateWindowExA(
0, CLASS_NAME, "小黄杀毒", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, 400, 200,
NULL, NULL, hInstance, NULL
);
if (!g_hMainWnd) {
return false;
}
ShowWindow(g_hMainWnd, SW_HIDE);
UpdateWindow(g_hMainWnd);
return true;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow) {
HWND hWnd = GetConsoleWindow();
ShowWindow(hWnd, SW_HIDE);
BOOL bIsAdmin = FALSE;
PSID pAdminGroup = NULL;
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
if (AllocateAndInitializeSid(&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
&pAdminGroup)) {
CheckTokenMembership(NULL, pAdminGroup, &bIsAdmin);
FreeSid(pAdminGroup);
}
if (!bIsAdmin) {
MessageBoxA(NULL,
"小黄杀毒需要管理员权限才能正常运行。\n请右键点击程序，选择「以管理员身份运行」。",
"小黄杀毒 - 权限不足", MB_OK | MB_ICONWARNING);
return 1;
}
if (!CreateMainWindow(hInstance)) {
MessageBoxA(NULL, "无法创建主窗口！", "小黄杀毒 - 错误", MB_OK | MB_ICONERROR);
return 1;
}
if (!InitInputProtection()) {
MessageBoxA(NULL, "键盘鼠标保护初始化失败！", "小黄杀毒 - 错误", MB_OK | MB_ICONERROR);
return 1;
}
HANDLE hTopmostThread = CreateThread(NULL, 0, TopmostMonitorThread, NULL, 0, NULL);
if (hTopmostThread) {
CloseHandle(hTopmostThread);
}
MessageBoxA(NULL,
"小黄杀毒已启动，正在后台保护您的系统。\n\n功能：\n"
"- 键盘鼠标反控制\n"
"- 反强制置顶窗口\n"
"- 关机确认保护\n\n"
"您可以通过系统托盘图标右键退出程序。\n"
"在强制置顶窗口标题栏右键可打开控制菜单。",
"小黄杀毒", MB_OK | MB_ICONINFORMATION);
Log("[小黄杀毒] 系统保护已启动\n");
MSG msg;
while (g_bRunning && GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
StopInputProtection();
Log("[小黄杀毒] 程序已退出\n");
return 0;
}
sc delete TDFileFiltr
gf25051
LV 7
@
2026-3-5 14:17:47