反极域 最全极域杀手 信息课脱控

目录

什么是极域

简介 

功能 

新增功能

特性增强

如何干掉极域

方法一  命令行    推荐指数  2

cmd杀

ntsd杀

方法二  极域万能密码内部脱控    推荐指数  3

方法三   关闭相关服务项及网络之类    推荐指数  3

方法四   U盘程序杀    推荐指数  4~5

极域杀手大杂烩

 推荐软件1：JiYuTrainer

 推荐软件2：ByeBye极域

推荐软件3：22-8-9-可关闭他人极域（冷麟）

 推荐软件4：原创软件

重要方法：广播时脱控

免责声明

---

什么是极域

以下摘自百度百科 不代表本人的任何观点

简介 

极域电子教室v1.0可在最短的时间里为您构造最强大的多媒体网络教室。极域电子教室经过严格的软、硬件测试过程，支持Windows全系列操作系统，允许在跨网段校园网上进行多频道教学，对各种网卡、声卡及显卡都能体现良好的性能，不会出现任何不稳定迹象，是一套集易用性好、兼容性强、稳定性高于一身的教学系统。

此软件是一种多媒体教学网络平台。它代表着一种全新的教学方式，利用一套软件，在现有的电脑网络设备上，实现教师机对学生机的广播、监控、屏幕录制、屏幕回放、语音教学等操作来统一地进行管理与监控，辅助学生完成电脑软件的学习、使用。此系统融合了数字化、网络化的先进思想，突破传统教室对时空的限制，既实现传统课堂教学中老师与学生、学生与学生间的交流，又符合电脑教学轻松、互动的自身特点，从而是一次教学方式飞跃。 　新版不仅增加了一批新功能，而且对现有的大部分功能进行了增强和优化。增加了对Windows Vista的支持，软件翻译成了15个国家和地区的语言，全面支持Unicode编码。网络传输性能和可靠性得到进一步增强。支持安卓系统等全新版本。

功能 

新增功能

1.屏幕广播

除了原来的全屏和窗口广播模式外，增加了绑定窗口模式。老师可以选择屏幕的某个部分广播给学生，以增加教学的直观性。

2.监控转播

监控时抓取快照。老师可以在监控学生的时候，对学生画面拍快照，保存学生画面的截图。

3.班级模型管理

新增加班级模型管理按钮，并设计了单独的管理界面，实现对班级模型的统一管理。

4.屏幕录制

屏幕录制经过全面技术革新，可以直接录制成 ASF 文件，也可以用Windows自带的Media Player直接播放。

屏幕录制的音视频不再分两个文件存放，保证了录制的文件的音视频同步性。

屏幕录制可以选择质量方案，以便客户在录制的文件尺寸和质量上，根据需要取舍。

屏幕录制提示小红点闪烁，录制过程更加直观。

提供屏幕录制转换器，以便早期的客户把老版本的文件转换为ASF文件。

5.远程设置

远程设置新增桌面主题设置，桌面背景设置，屏幕保护方案设置。

远程设置可以设置学生的频道号和音量。

远程设置可以设置学生的卸载密码，是否启用进程保护，断线锁屏，热键退出。

6.远程命令

新增可以远程关闭所有学生正在执行的应用程序。

7.分组管理

分组管理可以新建，删除，重命名分组。添加和删除分组中的成员。

分组信息随班级模型永久保存，下次上课可以直接使用保存的分组。

8.随堂小考

使用此功能，教师可以启动快速的单题考试或随堂调查，并立即给出结果。

9.系统日志

显示和自动保存系统运行过程中的关键事件，包括学生登录登出，电池电量，资源不足，提交文件等。

特性增强

1.操作界面

老师和学生的使用界面经过专业的可用性测试，界面元素设计和布局经过较大升级，有效地提高了软件整体的易用性。

2.学生演示

开始学生演示前，老师可以选择接收演示的学生集合。该集合可以是全体或部分学生，一个或多个分组。

3.网络影院

网络影院支持脱机工作，以便老师在课前确认准备的片源是否可用。

网络影院支持暂挂功能，以便老师让一节课未播放完的片子暂停，下节课自动从上次停止的地方继续播放。

网络影院支持更多的格式，MP4和MOV等720p和1080p的高清片源。

网络影院传输更可靠，同步性更好。

4.黑屏肃静

黑屏肃静功能升级为全局功能，老师可以在执行功能的过程中开始和停止黑屏功能。

黑屏功能被细分为黑屏和解除黑屏两个按钮，老师随时可以对选定的学生黑屏和解除黑屏。

学生黑屏窗口增加举手的提示信息。

5.文件分发

文件分发增加了对已存在文件的处理策略，用户可以选择覆盖和不覆盖。

文件分发设立了单独的发送工具栏，便于操作。

文件分发更加可靠和稳定。

6.电子点名

老师可以从主界面上直接访问电子点名功能按钮，增加了该功能的可用性。

7.分组教学

分组教学直接使用既有分组信息，老师不需要再临时创建分组。

老师可以监控每个分组的教学过程，以了解分组教学的进度。

8.分组讨论

分组讨论可以使用既有分组信息，老师不需要再临时创建分组。

9.视频直播

增加引导客户选择视频设备的提示画面，以便客户快速完成摄像头设备的设置。

10.远程登录

支持 Vista 系统的远程登录。

11.登录前接收广播

支持 Vista 系统的登录前接收广播。

12.作业提交

学生提交作业需经过老师审批通过后才能提交。老师可以选择接收和拒绝学生提交的文件。

13.远程消息

老师可以允许和阻止学生发送文字消息。

如何干掉极域

以下操作Win 10 可行

方法一  命令行    推荐指数  2

cmd杀

win + R 打开运行框 后输入cmd 打开 （最好以管理员权限运行）

输入以下指令：

taskkill /f /im StudentMain.exe /t

即可。

优点：简单粗暴

缺点：1.教师端上你对应的窗口黑屏，可能被发现，且你无法收到教师下发的文件，开启的广播等。2.可能会失败，即返回拒绝访问。

ntsd杀

ntsd是一个用户态进程调试工具，从Windows 2000就开始被附随在System32目录下。它能够结束除System、smss.exe、csrss.exe、lsass.exe及各种rootkit程序外所有的程序。但在Windows Vista及以上版本的Windows中不含ntsd， 必须手动下载至电脑中才可使用。且使用较麻烦，有兴趣的同学可以百度搜索了解。可参考这里

方法二  极域万能密码内部脱控    推荐指数  3

首先，记住极域万能密码：

mythware_super_password

So，如何使用呢？

现在看向任务栏，打开系统托盘（单击那个小箭头 “^”）

然后找到极域的图标，右键，点设置，输入万能密码解锁

接着你就看着办吧

找到网络 把那个数字改成其他的即可（对于每一个频道都有不同意义，可上网百度结果，此处不多赘述）

优点：在同学面前破解密码很酷

缺点：1.教师端上你对应的窗口黑屏，可能被发现，且你无法收到教师下发的文件，开启的广播等。（和命令行杀的第一个缺点一样）

方法三   关闭相关服务项及网络之类    推荐指数  3

启用windows防火墙，勾选“阻止所有传入连接”或禁用本地连接

或者拔掉网线？

缺点：1.教师端上你对应的窗口黑屏，可能被发现，且你无法收到教师下发的文件，开启的广播等。（和命令行杀的第一个缺点一样）2.没有优点

方法四   U盘程序杀    推荐指数  4~5

一切的一切，先卸载极域可能的U盘驱动（极域可能以此禁止U盘插入）

同cmd杀一样，以管理员权限运行cmd，输入以下命令行：

sc stop TDFileFilter 
sc delete TDFileFilter 

别告诉我你直接在机房下软件

将以下文件下载到U盘中并在机房中运行

蓝奏云下载

极域杀手大杂烩

 推荐软件1：JiYuTrainer

详细资料可下载软件后查看其帮助文件（单击“？”按钮）

优点：高级，牛逼，帅翻

缺点：过于高级，老师结束广播时你的电脑在教师端显示的界面可能会有1s~2s的蓝屏，经验丰富到外太空的老师可能会怀疑

Tips：建议仔细研究后再在机房运行

 推荐软件2：ByeBye极域

优点：不需要注入DLL等有风险操作，可直接将全屏广播改为窗口广播，基本功能如解除键盘锁等它都有

缺点：没那么高级，有时可能会有BUG（该程序使用Alt + Home 调起主界面，但可能没打开解键盘锁导致无法调起(广播时破解可能出现该问题)）

推荐软件3：22-8-9-可关闭他人极域（冷麟）

优点：可通过极域反控制其他学生电脑，酷MAX

缺点：非针对杀极域，故没有其他软件那么完善的杀极域功能

 推荐软件4：原创软件

1.

#include<bits/stdc++.h>
#include<windows.h>	
#include<tlhelp32.h>
using namespace std;
bool getProcess(const char *procressName)
{
    char pName[MAX_PATH];
    strcpy(pName,procressName);
    CharLowerBuff(pName,MAX_PATH);                        //small text
    PROCESSENTRY32 currentProcess;
    currentProcess.dwSize = sizeof(currentProcess); 
    HANDLE hProcess = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
 
    if (hProcess == INVALID_HANDLE_VALUE)
    {
        return false;
    }
 
    bool bMore=Process32First(hProcess,&currentProcess);        //take first
    while(bMore)
    {
        CharLowerBuff(currentProcess.szExeFile,MAX_PATH);        //small text
        if (strcmp(currentProcess.szExeFile,pName)==0)            //?==
        {
            CloseHandle(hProcess);                                //clear hProcess
            return true;
        }
        bMore=Process32Next(hProcess,&currentProcess);            //next
    }
 
    CloseHandle(hProcess);    //clear hProcess
    return false;
}
int main()
{
	HWND h = GetConsoleWindow(); 
	HWND small[1009] = {};
	int s_i = 0;
	ShowWindow(h,SW_HIDE);
	int b_n = 0;
	while(true){
		if(GetAsyncKeyState(18) && GetAsyncKeyState(66)){
			s_i++;
			small[s_i] = GetForegroundWindow();
			ShowWindow(small[s_i],SW_HIDE); 
		}
		if(GetAsyncKeyState(18) && GetAsyncKeyState(78)){
			if(s_i >= 1){
				ShowWindow(small[s_i],SW_SHOWNORMAL);
				small[s_i] = NULL;
				s_i--;
			}
		}
		if(GetAsyncKeyState(18) && GetAsyncKeyState(72)){
			if(b_n == 0){
				keybd_event(VK_CONTROL,0,0,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,0,0);
				Sleep(50);
				keybd_event(68,0,0,0);
				Sleep(50);
				keybd_event(VK_CONTROL,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(68,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_CONTROL,0,0,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,0,0);
				Sleep(50);
				keybd_event(VK_RIGHT,0,0,0);
				Sleep(50);
				keybd_event(VK_CONTROL,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_RIGHT,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				b_n = 1;
			}
			else if(b_n == 1){
				keybd_event(VK_CONTROL,0,0,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,0,0);
				Sleep(50);
				keybd_event(VK_LEFT,0,0,0);
				Sleep(50);
				keybd_event(VK_CONTROL,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_LEFT,0,0,0);
				b_n = 2;
			}
			else{
				keybd_event(VK_CONTROL,0,0,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,0,0);
				Sleep(50);
				keybd_event(VK_RIGHT,0,0,0);
				Sleep(50);
				keybd_event(VK_CONTROL,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_LWIN,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				keybd_event(VK_RIGHT,0,KEYEVENTF_KEYUP,0);
				Sleep(50);
				b_n = 1;
			}
		}
		for(int i = 1;i <= s_i;i++){
			ShowWindow(small[i],SW_HIDE);
		} 
		Sleep(100);
	}
	return 0;
}

本程序通过Alt + B隐藏顶部窗口，Alt + N显示，可用于隐藏极域，也可用于偷偷打游戏之类

2.进程管理器

#include<bits/stdc++.h>
#include<windows.h>
#include<tlhelp32.h>
#include<tchar.h>
#include<ShellAPI.h>
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<string>
#include<conio.h>
using namespace std;
void color (int a) {//颜色函数
	SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), a);
}
string jylj = "C:\\Program Files (x86)\\Mythware\\极域课堂管理系统软件v6.0 2020豪华版\\StudentMain.exe";
void gqhf(bool ng){
	char y = '"';
	const char *s;
	char ans[109];
	string t = jylj;
	ans[0] = '"';
	for(int i = 0;i < t.size();i++){
		ans[i+1] = t[i];
	}
	ans[t.size()+1] = '"';
	s = ans;
	if(ng == 1){
		system("taskkill /f /im StudentMain.exe /t");
	}
	else{
		system(s);
	}  
}
typedef struct tagWNDINFO
{
	DWORD dwProcessId;
	HWND hWnd;
} WNDINFO, *LPWNDINFO;
//枚举窗口过程
static BOOL CALLBACK EnumProc(HWND hWnd, LPARAM lParam)
{
	DWORD dwProcessId;
	GetWindowThreadProcessId(hWnd, &dwProcessId);
	LPWNDINFO pInfo = (LPWNDINFO)lParam;

	if (dwProcessId == pInfo->dwProcessId)
	{
		pInfo->hWnd = hWnd;
		return FALSE;
	}
	return TRUE;
}
//获取主窗口句柄
static HWND GetProcessMainWnd()
{
	DWORD dwProcessId=::GetCurrentProcessId();
	WNDINFO wi;
	wi.dwProcessId = dwProcessId;
	wi.hWnd = NULL;
	EnumWindows(EnumProc, (LPARAM)&wi);
	return wi.hWnd;
}
HANDLE hout=GetStdHandle(STD_OUTPUT_HANDLE);
void fz(string in)    
{
    if(!OpenClipboard(NULL)|| !EmptyClipboard())    
    {   
        printf("打开或清空剪切板出错！\n");   
        return;   
    }
    HGLOBAL hMen;   
    hMen = GlobalAlloc(GMEM_MOVEABLE, ((strlen(in.c_str())+1)*sizeof(TCHAR))); 
    if (!hMen)   
    {   
        printf("分配全局内存出错！\n");    
        CloseClipboard();   
        return;         
    } 
    LPSTR lpStr = (LPSTR)GlobalLock(hMen);    
    memcpy(lpStr,in.c_str(), ((strlen(in.c_str()))*sizeof(TCHAR)));  
    lpStr[strlen(in.c_str())] = (TCHAR)0;   
    GlobalUnlock(hMen);   
    SetClipboardData(CF_TEXT, hMen);   
    CloseClipboard();   
    return;   
}  
void EnableDebugPriv(){
	HANDLE hToken;
	TOKEN_PRIVILEGES tkp;
	OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);
	LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
	tkp.PrivilegeCount = 1;
	tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
	AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, NULL, NULL);
	CloseHandle(hToken);
}
void hide()
{
    CONSOLE_CURSOR_INFO cursor_info={1,0};
    SetConsoleCursorInfo(hout, &cursor_info);
}
bool getProcess(const char *procressName)                //此函数进程名不区分大小写
{
    char pName[MAX_PATH];                                //和PROCESSENTRY32结构体中的szExeFile字符数组保持一致，便于比较
    strcpy(pName,procressName);                            //拷贝数组
    CharLowerBuff(pName,MAX_PATH);                        //将名称转换为小写
    PROCESSENTRY32 currentProcess;                        //存放快照进程信息的一个结构体
    currentProcess.dwSize = sizeof(currentProcess);        //在使用这个结构之前，先设置它的大小
    HANDLE hProcess = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);//给系统内的所有进程拍一个快照
 
    if (hProcess == INVALID_HANDLE_VALUE)
    {
        return false;
    }
 
    bool bMore=Process32First(hProcess,&currentProcess);        //获取第一个进程信息
    while(bMore)
    {
        CharLowerBuff(currentProcess.szExeFile,MAX_PATH);        //将进程名转换为小写
        if (strcmp(currentProcess.szExeFile,pName)==0)            //比较是否存在此进程
        {
            CloseHandle(hProcess);                                //清除hProcess句柄
            return true;
        }
        bMore=Process32Next(hProcess,&currentProcess);            //遍历下一个
    }
 
    CloseHandle(hProcess);    //清除hProcess句柄
    return false;
}
bool IsProcessRunAsAdmin()
{
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    PSID AdministratorsGroup;
    BOOL b = AllocateAndInitializeSid(
        &NtAuthority,
        2,
        SECURITY_BUILTIN_DOMAIN_RID,
        DOMAIN_ALIAS_RID_ADMINS,
        0, 0, 0, 0, 0, 0,
        &AdministratorsGroup);
    if(b)
    {
        CheckTokenMembership(NULL, AdministratorsGroup, &b);
        FreeSid(AdministratorsGroup);
    }
    return b == TRUE;
}
short GetAdmin(LPCSTR Param, int Showcmd)
{
    if (IsProcessRunAsAdmin())
        return 0;
    TCHAR Path[MAX_PATH];
    ZeroMemory(Path, MAX_PATH);
    ::GetModuleFileName(NULL, Path, MAX_PATH);           //获取程序路径
    HINSTANCE res;
    res = ShellExecute(NULL, "runas", Path, Param, NULL, Showcmd);
    return 0;
}
int main()
{
	HWND hWnd = ::GetForegroundWindow();
	if(getProcess("StudentMain.exe")){
		while(1){
			::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
			cout<<"检测到极域正在运行，按b以开启极域模式，按c取消";
			if(GetAsyncKeyState('B')){
				system("cls");
				Sleep(100);
				hide();
				bool yx = 0;
				bool xd = 1;
				while(1){
					::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
					cin.clear();
					if(getProcess("StudentMain.exe")){
						cout<<"极域正在运行！\n";
						color(4);
						yx = 1;
					}
					else{
						cout<<"极域未运行。\n";
						color(10);
						yx = 0;
					}
					cout<<"[1] 杀死极域\n[2] 运行极域\n[3] 重启极域\n[4] 复制极域万能密码\n[5] 挂起与恢复极域\n[6] 最小化本窗口\n[7] 最小化置顶窗口\n[8] 打开任务管理器\n[9] 退出此模式\n[q] 打开/关闭 屏幕键盘\n";
					if(GetAsyncKeyState('1')){
						if(yx == 0){
							cout<<"极域未运行！\n";  
						}
						else{
							Sleep(100); 
							cout<<"普通taskkill杀极域输入1，ntsd强制杀极域输入（需要确保包含C:/windows/ntsd.exe文件）2:";
							if(GetAsyncKeyState('1')){
								system("taskkill /F /IM StudentMain.exe /T");
							}
							else if(GetAsyncKeyState('2')){
								system("./ntsd.exe -c q -pn studentmain.exe");
							}
							Sleep(100);	
							if(getProcess("StudentMain.exe")){
								cout<<"杀死失败！\n";
							}
							else{
								cout<<"杀死成功！\n";
								cout<<"按1继续";
								Sleep(10);
								while(!GetAsyncKeyState('1')){}
								Sleep(10);
							} 					
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('2')){
						if(yx == 1){
							cout<<"极域已运行！\n"; 
						}
						else{
							gqhf(0);
							Sleep(100);
							if(getProcess("StudentMain.exe")){
								cout<<"运行成功！\n";
								Sleep(1000);
							}
							else{
								cout<<"运行失败！";
								cout<<"按1继续";
								while(!GetAsyncKeyState('1')){}
								Sleep(10);
							} 					
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('3')){					
						if(yx == 0){
							cout<<"极域未运行！\n"; 
						}
						else{
							gqhf(1);
							Sleep(100);
							if(getProcess("StudentMain.exe")){
								cout<<"杀死失败！\n";
								Sleep(1000);
							}
							else{
								cout<<"杀死成功！\n";
								gqhf(0);
								Sleep(100);
								if(getProcess("StudentMain.exe")){
									cout<<"运行成功！\n";
									Sleep(1000);
								}
								else{
									cout<<"运行失败！\n";
									cout<<"按1继续";
									while(!GetAsyncKeyState('1')){}
									Sleep(10);
								} 	
							} 					
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('4')){
						fz("mythware_super_password");
						cout<<"密码已复制！\n"; 
						Sleep(10);
					}
					else if(GetAsyncKeyState('5')){
						cout<<"挂起输入1，恢复输入2";
						while(1){
							::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
							if(GetAsyncKeyState('1')){
								gqhf(1);
								break;
							}
							if(GetAsyncKeyState('2')){
								gqhf(0);
								break;
							}						
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('6')){
						if(xd){
							ShowWindow(GetProcessMainWnd(),SW_MINIMIZE);
							xd = 0;
						}
						else{
							ShowWindow(GetProcessMainWnd(),SW_MAXIMIZE);
							xd = 1;
						}
						Sleep(100);
					}
					else if(GetAsyncKeyState('7')){
						ShowWindow(GetProcessMainWnd(),SW_MINIMIZE);
						Sleep(100);
						HWND jy = GetForegroundWindow();
						ShowWindow(jy,SW_MINIMIZE);
						Sleep(100);
						cout<<"恢复输入0";
						while(1){
							::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
							if(GetAsyncKeyState('0')){
								ShowWindow(jy,SW_MAXIMIZE);
								break;
							}
							else if(GetAsyncKeyState('6')){
								if(xd){
									ShowWindow(GetProcessMainWnd(),SW_MINIMIZE);
									xd = 0;
								}
								else{
									ShowWindow(GetProcessMainWnd(),SW_MAXIMIZE);
									xd = 1;
								}
								Sleep(10);
							}			
						}
						Sleep(10);
						//ShowWindow(GetProcessMainWnd(),SW_MAXIMIZE);
					}
					else if(GetAsyncKeyState('8')){
						system("C:\\Windows\\System32\\Taskmgr.exe");
						Sleep(10);
					}
					else if(GetAsyncKeyState('9')){
						break;
					}
					else if(GetAsyncKeyState('Q')){
						if(getProcess("osk.exe")){
							system("taskkill /f /im osk.exe /t");
						}
						system("start C:\\Windows\\System32\\osk.exe");
						Sleep(100); 
					}
					Sleep(10);
					system("cls");
				}
				cout<<"已退出！\n";
			}
			else if(GetAsyncKeyState('C')){
				break;
			}
			Sleep(10);
			system("cls");
		}
	}
	system("cls");
	bool sz_exe = 1; 
	bool jy = 1;
	if(IsProcessRunAsAdmin() == 0){
		cout<<"获取管理员权限失败！\n请用管理员模式运行，否则可能无法关闭或打开一些特殊进程！\n";
		Sleep(3000); 
	}
	else{
		cout<<"管理员权限获取成功！\n";
	}
	while(1){
		::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
		string name;
		string jg;
		int in;
		cout<<"进程管理器 V3.1.2\n1.关闭进程\n2.运行进程\n3.重启进程\n4.进程删重\n5.设置\n";
		if(jy){
			cout<<"6.极域模式\n";
		}
		cout<<"Input:";
		cin>>in;
		if(in == 1){
			cout<<"需关闭进程名：";
			if(sz_exe == 1){
				cout<<"（需要加上.exe或其他）：";
			}
			else{
				cout<<"（不需要加上.exe，将自动补全）：";
			}
			cin>>name;
			if(sz_exe == 0){
				name += ".exe";
			}
			if(!getProcess(name.c_str())){
				cout<<"此程序未运行！\n";
			}
			else{
				jg = "taskkill /F /IM " + name + " /T";
				const char* cname = jg.c_str();
				system(cname);
				Sleep(100);
				if(getProcess(name.c_str())){
					cout<<"杀死失败！\n";
				}
				else{
					cout<<"杀死成功！\n";
				}
			} 
		}
		else if(in == 2){
			cout<<"需运行进程名：";
			if(sz_exe == 1){
				cout<<"（需要加上.exe或其他）：";
			}
			else{
				cout<<"（不需要加上.exe，将自动补全）：";
			}
			cin>>name;
			if(sz_exe == 0){
				name += ".exe";
			}
			if(getProcess(name.c_str())){
				cout<<"此程序已运行！\n";
			}
			else{
				jg = "start  " + name;
				const char* cname = jg.c_str();
				system(cname);
				Sleep(100);
				if(!getProcess(name.c_str())){
					cout<<"运行失败！\n";
				}
				else{
					cout<<"运行成功！\n";
				}
			} 
		}	
		else if(in == 3){
			cout<<"需重启进程名：";
			if(sz_exe == 1){
				cout<<"（需要加上.exe或其他）：";
			}
			else{
				cout<<"（不需要加上.exe，将自动补全）："; 
			}
			cin>>name;
			if(sz_exe == 0){
				name += ".exe";
			}
			if(!getProcess(name.c_str())){
				cout<<"此程序未运行！\n";
			}
			else{
				jg = "taskkill /F /IM " + name + " /T";
				const char* cname = jg.c_str();
				system(cname);
				Sleep(100);
				if(getProcess(name.c_str())){
					cout<<"杀死失败！\n";
				}
				else{
					cout<<"杀死成功！正在准备运行！\n";
					jg = "start  " + name;
					const char* ccname = jg.c_str();
					system(ccname);
					Sleep(100);
					if(!getProcess(name.c_str())){
						cout<<"运行失败！\n";
					}
					else{
						cout<<"运行成功！\n";
					}
				}
			} 
		}	
		else if(in == 4){
			cout<<"查重进程名：";
			cin>>name;
			if(sz_exe == 0){
				name += ".exe";
			}
			if(!getProcess(name.c_str())){
				cout<<"此程序未运行！\n";
			}
			else{
				while(1){
					jg = "./ntsd.exe -c q -pn " + name;
					const char* cname = jg.c_str();
					system(cname);
					if(!getProcess(name.c_str())){
						break;
					}
				}
				cout<<"杀死成功！正在准备运行！\n";
				jg = "start  " + name;
				const char* ccname = jg.c_str();
				system(ccname);
				Sleep(100);
				if(!getProcess(name.c_str())){
					cout<<"运行失败！\n";
				}
				else{
					cout<<"运行成功！\n查重成功！\n";
				}
			} 
		}
		else if(in == 5){
			if(sz_exe){
				cout<<"是否默认加上.exe（是输入1，否则输入0）：";
				cin>>sz_exe;
				sz_exe = !sz_exe;
			}
			else{
				cout<<"是否默认不加上.exe（是输入1，否则输入0）：";
				cin>>sz_exe;
			}
			if(jy){
				cout<<"是否默认不显示极域模式（包括设置内），但可以输入6（或设置的2）仍可以打开（是输入1，否则输入0）：";
				cin>>jy;
				jy = !jy;
			}
			else{
				cout<<"是否默认显示极域模式（包括设置内）（是输入1，否则输入0）：";
				cin>>jy;
			}
			cout<<"是否更改极域路径(是输入1)：";
			string a;
			cin>>a;
			if(a == "1"){
				cout<<"当前路径：";
				cout<<jylj<<endl;
				cout<<"请输入新路径(斜杠需使用双斜杠)：";
				cin.ignore(numeric_limits<streamsize>::max(),'\n');
				getline(cin,jylj);
				cout<<"你输入的路径是："<<jylj<<endl;
				Sleep(1000);
			}
		}
		else if(in == 6){
			system("cls");
				Sleep(100);
				hide();
				bool yx = 0;
				bool xd = 1;
				while(1){
					::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
					cin.clear();
					if(getProcess("StudentMain.exe")){
						cout<<"极域正在运行！\n";
						color(4);
						yx = 1;
					}
					else{
						cout<<"极域未运行。\n";
						color(10);
						yx = 0;
					}
					cout<<"[1] 杀死极域\n[2] 运行极域\n[3] 重启极域\n[4] 复制极域万能密码\n[5] 挂起与恢复极域\n[6] 最小化本窗口\n[7] 最小化置顶窗口\n[8] 打开任务管理器\n[9] 退出此模式\n[q] 打开/关闭 屏幕键盘\n";
					if(GetAsyncKeyState('1')){
						if(yx == 0){
							cout<<"极域未运行！\n";  
						}
						else{
							Sleep(100); 
							cout<<"普通taskkill杀极域输入1，ntsd强制杀极域输入（需要确保包含C:/windows/ntsd.exe文件）2:";
							if(GetAsyncKeyState('1')){
								system("taskkill /F /IM StudentMain.exe /T");
							}
							else if(GetAsyncKeyState('2')){
								system("./ntsd.exe -c q -pn studentmain.exe");
							}
							Sleep(100);	
							if(getProcess("StudentMain.exe")){
								cout<<"杀死失败！\n";
							}
							else{
								cout<<"杀死成功！\n";
								cout<<"按1继续";
								Sleep(10);
								while(!GetAsyncKeyState('1')){}
								Sleep(10);
							} 					
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('2')){
						if(yx == 1){
							cout<<"极域已运行！\n"; 
						}
						else{
							gqhf(0);
							Sleep(100);
							if(getProcess("StudentMain.exe")){
								cout<<"运行成功！\n";
								Sleep(1000);
							}
							else{
								cout<<"运行失败！";
								cout<<"按1继续";
								while(!GetAsyncKeyState('1')){}
								Sleep(10);
							} 					
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('3')){					
						if(yx == 0){
							cout<<"极域未运行！\n"; 
						}
						else{
							gqhf(1);
							Sleep(100);
							if(getProcess("StudentMain.exe")){
								cout<<"杀死失败！\n";
								Sleep(1000);
							}
							else{
								cout<<"杀死成功！\n";
								gqhf(0);
								Sleep(100);
								if(getProcess("StudentMain.exe")){
									cout<<"运行成功！\n";
									Sleep(1000);
								}
								else{
									cout<<"运行失败！\n";
									cout<<"按1继续";
									while(!GetAsyncKeyState('1')){}
									Sleep(10);
								} 	
							} 					
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('4')){
						fz("mythware_super_password");
						cout<<"密码已复制！\n"; 
						Sleep(10);
					}
					else if(GetAsyncKeyState('5')){
						cout<<"挂起输入1，恢复输入2";
						while(1){
							::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
							if(GetAsyncKeyState('1')){
								gqhf(1);
								break;
							}
							if(GetAsyncKeyState('2')){
								gqhf(0);
								break;
							}						
						}
						Sleep(10);
					}
					else if(GetAsyncKeyState('6')){
						if(xd){
							ShowWindow(GetProcessMainWnd(),SW_MINIMIZE);
							xd = 0;
						}
						else{
							ShowWindow(GetProcessMainWnd(),SW_MAXIMIZE);
							xd = 1;
						}
						Sleep(100);
					}
					else if(GetAsyncKeyState('7')){
						ShowWindow(GetProcessMainWnd(),SW_MINIMIZE);
						Sleep(100);
						HWND jy = GetForegroundWindow();
						ShowWindow(jy,SW_MINIMIZE);
						Sleep(100);
						cout<<"恢复输入0";
						while(1){
							::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
							if(GetAsyncKeyState('0')){
								ShowWindow(jy,SW_MAXIMIZE);
								break;
							}
							else if(GetAsyncKeyState('6')){
								if(xd){
									ShowWindow(GetProcessMainWnd(),SW_MINIMIZE);
									xd = 0;
								}
								else{
									ShowWindow(GetProcessMainWnd(),SW_MAXIMIZE);
									xd = 1;
								}
								Sleep(10);
							}			
						}
						Sleep(10);
						//ShowWindow(GetProcessMainWnd(),SW_MAXIMIZE);
					}
					else if(GetAsyncKeyState('8')){
						system("C:\\Windows\\System32\\Taskmgr.exe");
						Sleep(10);
					}
					else if(GetAsyncKeyState('9')){
						break;
					}
					else if(GetAsyncKeyState('Q')){
						if(getProcess("osk.exe")){
							system("taskkill /f /im osk.exe /t");
						}
						system("start C:\\Windows\\System32\\osk.exe");
						Sleep(100); 
					}
					Sleep(10);
					system("cls");
				}
				cout<<"已退出！\n";
		} 
		system("pause");
		system("cls");
	}
	return 0;
}

比较针对极域（PS：最新版本因为我的U盘被盗且未备份：( ，故丢失，这个是老版本，鬼知道我是几岁写的（11岁？））

重要方法：广播时脱控

1.Win + G打开游戏录制界面

2.狂按Win键直到任务栏显示

3.打开系统托盘

4.同极域万能密码内部脱控的方式操作，进入设置界面

5.关掉界面（没错，不要执行任何操作）

6.Win + L 再次进入使用账户

7.再次进行步骤1和步骤2

8.在Windous搜索栏中 输入你的反极域程序路径，如E:\computer class\JiYuTrainer\JiYuTrainer.exe，大写可使用Shift + 所需字母 的方式打出来

9.单击以管理员身份运行即可 

免责声明

大部分程序来源于网络，擅自使用本文章所提及的任何软件及方法用于不正当行为所造成的一切后果均与作者无关，由您自行承担。本文章不代表本人的任何观点，本文章所提及的任何软件及方法仅供学习交流使用，严禁将其用于任何不符合法律，道德的行为。自您使用本文章所提及的任何软件及方法起，及表明您同意了该声明。