无DLL文件实现远程线程注入获取进程列表

已于 2024-09-14 18:13:04 修改
阅读量985 收藏 15
点赞数 13
文章标签： windows 安全 安全威胁分析
于 2024-09-14 18:11:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunjiaoya/article/details/142263866
版权

简介

背景知识

ASLR (地址空间布局随机化): 是一种安全机制，用来防止内存攻击。它通过随机化程序在内存中的地址来防止攻击者预测代码的位置。DLL（如 kernel32.dll 和 ntdll.dll）的加载基址可能不同于不同的进程启动时。

导入表 (Import Address Table, IAT): 每个进程的IAT用于将导入的函数名称解析为实际的函数地址。这个表在进程加载时由操作系统填充。当一个进程调用一个导入的函数（例如 CloseHandle），它实际上通过IAT间接调用该函数的真实地址。

在之前的章节中，笔者曾介绍过有关于远程线程注入的知识，将后门.dll文件注入explorer.exe中实现绕过防火墙反弹后门。但一个.exe文件总要在注入时捎上一个.dll文件着实是怪麻烦的，那么有没有什么方法能够不适用.dll文件实现注入呢？
答案是有的，我们可以直接将功能写在线程函数中，然后直接将整个函数注入，这个方法相较之于DLL注入会稍微复杂一些，适用于对一些体积比较小的程序进行注入，实际上这种方式属于注入动态shellcode。但是要注意动态链接库的地址重定位问题，因为在不同进程中只有kernel32.dll、ntdll、kernelbase的基地址是相同的，而其他DLL由于ASLR，会导致这三个dll外的函数已经被随机化或者指向了错误的内存区域，这就导致注入进程的崩溃。所以最好要在远程线程函数中手动利用LoadLibrary和GetProcessAddress函数强制加载一遍DLL文件。
第二个问题是下面代码为啥要传入CloseHandle的指针，然后在远程线程函数中使用函数指针而不是直接调用对应函数呢？虽然Kernel32.dll在不同进程的基地址一样，在Kernel32.dll中相同的函数名的函数在不同进程的地址也应该一样，但是不同进程的导入表地址不一样 ，我们在代码中直接调用一个系统函数，实际上是从导入表中去调用的，导入表在开启ASLR进程下就会发生变化，如何直接调用CloseHandle，是将你原进程里面导入表地址用到了远程进程里，自然就导致注入进程崩溃了。
这就是一个典型的导入表调用汇编：
在这里插入图片描述
具体解释：
1.导入表问题: CloseHandle 函数在源进程的导入表中已经被解析为某个地址。但在远程进程中，由于每个进程的导入表是不同的，CloseHandle 的地址可能并不指向目标进程中的正确位置。目标进程中的 CloseHandle 地址也许已经被随机化或者指向了错误的内存区域，这就导致了崩溃。
2.ASLR的影响: 虽然 kernel32.dll 在所有进程的基地址是一样的，但每个进程的导入表（IAT）的位置可能不同，并且导入表本身可能由于 ASLR 而被随机化。直接调用源进程中的 CloseHandle 实际上是在使用源进程的IAT，而不是目标进程的IAT，这会导致引用无效的内存地址。
直接使用 CloseHandle（这是一个普通的函数调用，而不是函数指针调用），此调用依赖于导入表。在注入的远程线程中，导入表的地址是随机的（由于 ASLR），因此直接调用会导致目标进程崩溃，因为它试图通过一个不正确的地址（对应于源进程的导入表）调用 CloseHandle
总结：直接使用了普通函数调用（依赖导入表），导致在目标进程中，地址不正确，从而引发注入进程崩溃。

**解决方法：**Visual Studio在编译此类功能的文件时建议关闭编译器的“/GS”选项或者使用关键字__declspec(safebuffers)，因为开启GS插入栈保护代码，这其中调用的函数由于重定位的问题会导致导致注入进程的崩溃。

typedef struct _RemoteProcessInfo {
    DWORD pid;  // 进程ID
    WCHAR processName[MAX_PATH];  // 进程名称
}RemoteProcessInfo;

//远程线程函数参数
typedef struct _RemoteParam
{
    LPVOID lpvMP32FWAdress;
    LPVOID lpvMP32NWAddress;
    LPVOID lpvMCHdlAddress;
    LPVOID lpvVirAllocAdress;
    LPVOID lpvCTH32SnapshotAddress;
    LPVOID lpvProcessInfoAddress;
    size_t nProcessSize;
}RemoteParam;

注入代码：

/************************************************************************
 * Function:远程线程函数（主体）
 * Name : ThreadProc
 * Param: lprp	传到远程线程的参数
 * Return: success->0,fail->win32 error code
 * **********************************************************************/
__declspec(safebuffers) DWORD WINAPI ThreadProc(RemoteParam* lprp) {
	// 类型定义
	typedef LPVOID(WINAPI* MVirtualAllocEx)(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flAllocationType, IN DWORD flProtect);
	typedef HANDLE(WINAPI* MCreateToolhelp32Snapshot)(IN DWORD dwFlags, IN DWORD th32ProcessID);
	typedef BOOL(WINAPI* MProcess32FirstW)(IN HANDLE hSnapshot, OUT PROCESSENTRY32W* lppe);
	typedef BOOL(WINAPI* MProcess32NextW)(IN HANDLE hSnapshot, OUT PROCESSENTRY32W* lppe);
	typedef BOOL(WINAPI* MCloseHandle)(IN HANDLE hObject);

	// 初始化函数指针
	MVirtualAllocEx MAllocMem = (MVirtualAllocEx)lprp->lpvVirAllocAdress;
	MCreateToolhelp32Snapshot MCreateSnapshot = (MCreateToolhelp32Snapshot)lprp->lpvCTH32SnapshotAddress;
	MProcess32FirstW MProcessFirstW = (MProcess32FirstW)lprp->lpvMP32FWAdress;
	MProcess32NextW MProcessNextW = (MProcess32NextW)lprp->lpvMP32NWAddress;
	MCloseHandle MCloseHd = (MCloseHandle)lprp->lpvMCHdlAddress;

	if (!MCreateSnapshot || !MAllocMem || !MProcessFirstW || !MProcessNextW || !MCloseHd) {
		return 0;
	}

	// 拍摄进程快照
	HANDLE hSnapshot = MCreateSnapshot(TH32CS_SNAPPROCESS, 0);
	if (hSnapshot == INVALID_HANDLE_VALUE) {
		return 0;
	}

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

	// 首先计算所需的内存大小
	size_t processCount = 0;

	// 获取进程数量
	if (MProcessFirstW(hSnapshot, &pe32)) {
		do {
			processCount++;
		} while (MProcessNextW(hSnapshot, &pe32));
	}

	// 根据进程数量动态分配内存
	SIZE_T allocSize = sizeof(RemoteProcessInfo) * processCount;
	RemoteProcessInfo* pProcessArray = (RemoteProcessInfo*)MAllocMem(NULL, allocSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
	if (!pProcessArray) {
		MCloseHd(hSnapshot);
		return 0;
	}

	// 填充进程信息
	int i = 0;
	if (MProcessFirstW(hSnapshot, &pe32)) {
		do {
			if (i >= processCount) break;
			pProcessArray[i].pid = pe32.th32ProcessID;
			wcscpy(pProcessArray[i].processName, pe32.szExeFile);
			i++;
		} while (MProcessNextW(hSnapshot, &pe32));
	}

	// 将分配的内存地址和大小存回到 RemoteParam 结构体
	lprp->lpvProcessInfoAddress = pProcessArray;
	lprp->nProcessSize = processCount;

	MCloseHd(hSnapshot);
	return 0;
}


/************************************************************************
 * Function:从目标进程获取进程信息的函数
 * Name : GetProcessInfoByR3Injection
 * Param: vecProcessInfo	应用层进程信息
 * Return: success->0,fail->win32 error code
 * **********************************************************************/
DWORD GetProcessInfoByR3Injection(std::vector<PROCESS_INFORMATION*>& vecProcessInfo)
{
	ULONG pid = 0;
	HANDLE hSnapshot = NULL;
	PROCESSENTRY32 pe32 = { 0 };
	DWORD dwResult = ERROR_SUCCESS;

	// 启用调试权限
	EnableDebugPrivilege();

	dwResult = GetProcessPidByName(L"Taskmgr.exe", &pid);
	if (dwResult != ERROR_SUCCESS) {
		LOGI("get Taskmgr pid fail,%d", dwResult);
		dwResult = GetProcessPidByName(L"explorer.exe", &pid);
		if (dwResult != ERROR_SUCCESS) {
			LOGE("get explorer pid fail,%d", dwResult);
			return dwResult;
		}
		else {
			LOGI("get explorer pid success:%d", pid);
		}
	}

	HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
	if (hProc == NULL) {
		dwResult = GetLastError();
		LOGE("OpenProcess fail, pid:%d, err:%d", pid, dwResult);
		return dwResult;
	}

	RemoteParam* rp = (RemoteParam*)malloc(sizeof(RemoteParam));
	if (!rp) {
		LOGE("Failed to allocate memory for RemoteParam.");
		CloseHandle(hProc);
		return ERROR_OUTOFMEMORY;
	}
	ZeroMemory(rp, sizeof(RemoteParam));

	HMODULE hMod = GetModuleHandle(L"Kernel32.dll");
	if (hMod == NULL) {
		free(rp);
		CloseHandle(hProc);
		dwResult = GetLastError();
		LOGE("get Kernel32.dll handle fail, err:%d", dwResult);
		return dwResult;
	}

	rp->lpvMP32FWAdress = (LPVOID)GetProcAddress(hMod, "Process32FirstW");
	rp->lpvMP32NWAddress = (LPVOID)GetProcAddress(hMod, "Process32NextW");
	rp->lpvVirAllocAdress = (LPVOID)GetProcAddress(hMod, "VirtualAlloc");
	rp->lpvCTH32SnapshotAddress = (LPVOID)GetProcAddress(hMod, "CreateToolhelp32Snapshot");
	rp->lpvMCHdlAddress = (LPVOID)GetProcAddress(hMod, "CloseHandle");

	// 在目标进程中分配内存用于存储 RemoteParam
	RemoteParam* pRemoteParam = (RemoteParam*)VirtualAllocEx(hProc, 0, sizeof(RemoteParam), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
	if (!pRemoteParam) {
		LOGE("Failed to allocate memory in target process.");
		free(rp);
		CloseHandle(hProc);
		return ERROR_OUTOFMEMORY;
	}

	// 将参数数据写入目标进程
	if (!WriteProcessMemory(hProc, pRemoteParam, rp, sizeof(RemoteParam), 0)) {
		dwResult = GetLastError();
		LOGE("WriteProcessMemory failed. Error code: %d", dwResult);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hProc);
		return dwResult;
	}

	// 分配远程线程代码空间
	LPVOID pRemoteThread = VirtualAllocEx(hProc, 0, 1024 * 4, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
	if (!pRemoteThread) {
		dwResult = GetLastError();
		LOGE("Failed to allocate 4K memory in target process.");
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hProc);
		return dwResult;
	}

	// 将线程函数写入到目标进程
	if (!WriteProcessMemory(hProc, pRemoteThread, &ThreadProc, 1024 * 4, 0)) {
		dwResult = GetLastError();
		LOGE("WriteProcessMemory failed. Error code: %d", dwResult);
		VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hProc);
		return dwResult;
	}

	// 在目标进程中创建远程线程来执行 ThreadProc
	HANDLE hThread = CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)pRemoteThread, (LPVOID)pRemoteParam, 0, NULL);
	if (hThread == NULL) {
		dwResult = GetLastError();
		LOGE("CreateRemoteThread fail, pid:%d, err:%d", pid, dwResult);
		VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hProc);
		return dwResult;
	}
	else {
		LOGI("Create remote thread success, tid:%p,", hThread);
	}

	// 等待远程线程完成
	DWORD dwWait = 5 * 1000; // 5 秒超时
	WaitForSingleObject(hThread, dwWait);

	// 从目标进程读取 RemoteParam 信息
	if (!ReadProcessMemory(hProc, pRemoteParam, rp, sizeof(RemoteParam), NULL)) {
		dwResult = GetLastError();
		LOGE("Failed to read remote process memory, error:%d", dwResult);
		VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hThread);
		CloseHandle(hProc);
		return dwResult;
	}

	// 确保读取的 nProcessSize 值是有效的
	if (rp->nProcessSize == 0) {
		LOGE("Invalid process size value from remote process.");
		if (rp->lpvProcessInfoAddress) { // 释放远程线程分配的内存
			VirtualFreeEx(hProc, rp->lpvProcessInfoAddress, 0, MEM_RELEASE);
		}
		VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hThread);
		CloseHandle(hProc);
		return ERROR_INVALID_PARAMETER;
	}

	// 读取远程线程分配的内存中的进程信息
	SIZE_T processInfoSize = rp->nProcessSize * sizeof(RemoteProcessInfo);
	RemoteProcessInfo* pProcessInfoArray = (RemoteProcessInfo*)malloc(processInfoSize);
	if (!pProcessInfoArray) {
		LOGE("Failed to allocate memory on heap.");
		if (rp->lpvProcessInfoAddress) { // 释放远程线程分配的内存
			VirtualFreeEx(hProc, rp->lpvProcessInfoAddress, 0, MEM_RELEASE);
		}
		VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hThread);
		CloseHandle(hProc);
		return ERROR_OUTOFMEMORY;
	}

	// 从目标进程读取实际的进程信息
	if (!ReadProcessMemory(hProc, rp->lpvProcessInfoAddress, pProcessInfoArray, processInfoSize, NULL)) {
		dwResult = GetLastError();
		LOGE("Failed to read process information from remote process memory, error:%d", dwResult);
		free(pProcessInfoArray);
		if (rp->lpvProcessInfoAddress) { // 释放远程线程分配的内存
			VirtualFreeEx(hProc, rp->lpvProcessInfoAddress, 0, MEM_RELEASE);
		}
		VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
		VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
		free(rp);
		CloseHandle(hThread);
		CloseHandle(hProc);
		return dwResult;
	}

	// 将获取到的信息转换为 vecProcessInfo 格式
	for (size_t i = 0; i < rp->nProcessSize; ++i) {
		if (pProcessInfoArray[i].pid == 0 || wcslen(pProcessInfoArray[i].processName) == 0) {
			continue;
		}

		PROCESS_INFORMATION* pProcessInfo = (PROCESS_INFORMATION*)malloc(sizeof(PROCESS_INFORMATION));
		if (pProcessInfo == nullptr) {
			dwResult = ERROR_OUTOFMEMORY;
			LOGE("Failed to allocate memory for process information.");
			break;
		}
		memset(pProcessInfo, 0, sizeof(PROCESS_INFORMATION));

		pProcessInfo->Pid = pProcessInfoArray[i].pid;
		std::wstring wstrFilePath = std::wstring(pProcessInfoArray[i].processName);
		auto pTempPath = wcharTochar(wstrFilePath.c_str());
		if (pTempPath) {
			strcpy_s(pProcessInfo->szProcessName, MAX_PATH, pTempPath.get());
		}
		vecProcessInfo.push_back(pProcessInfo);
	}

	// 释放远程线程分配的内存
	if (rp->lpvProcessInfoAddress) {
		VirtualFreeEx(hProc, rp->lpvProcessInfoAddress, 0, MEM_RELEASE);
	}

	// 释放分配的内存和资源
	free(pProcessInfoArray);
	free(rp);

	VirtualFreeEx(hProc, pRemoteThread, 0, MEM_RELEASE);
	VirtualFreeEx(hProc, pRemoteParam, 0, MEM_RELEASE);
	CloseHandle(hThread);
	CloseHandle(hProc);

	return dwResult;
}

参考：
1.https://www.cnblogs.com/PeterZ1997/p/9532065.html
2.https://blog.csdn.net/sandeel/article/details/5387708

远方的白桦树
关注
远程线程注入--DLL注入(C++)
啊渊的专栏
08-26 172
远程线程注入（Remote Thread Injection）是指通过创建远程线程的方式将代码注入到另一个进程的地址空间中。下面是一个简单的 C++ 示例，展示如何通过远程线程注入一个 DLL 到目标进程中。
DLL远程线程注入源码
01-20
本文将深入解析DLL远程线程注入的概念、原理及其在VC++和VB环境下的实现方法。 DLL是Windows操作系统中的一种共享库，它包含可由多个执行程序同时使用的函数和资源。远程线程注入则是通过在目标进程中创建一个新的...
安全之路 —— 无DLL文件实现远程线程注入
dengdao1372的博客
08-24 267
简介 在之前的章节中，笔者曾介绍过有关于远程线程注入的知识，将后门.dll文件注入explorer.exe中实现绕过防火墙反弹后门。但一个.exe文件总要在注入时捎上一个.dll文件着实是怪麻烦的，那么有没有什么方法能够不适用.dll文件实现注入呢？ 答案是有的，我们可以直接将功能写在线程函数中，然后直接将整个函数注入，这个方法相较之于DLL注入会稍微复杂...
3.1 DLL注入：常规远程线程注入
CSDN
09-13 1万+
动态链接库注入技术是一种特殊的技术，它允许在运行的进程中注入DLL动态链接库，从而改变目标进程的行为。DLL注入的实现方式有许多，典型的实现方式为远程线程注入，该注入方式的注入原理是利用了`Windows`系统中提供的`CreateRemoteThread()`这个API函数,该函数第四个参数是准备运行的线程，我们将`LoadLibrary()`函数填入其中，这样就可以执行远程进程中的`LoadLibrary()`函数，进而将我们自己准备的DLL加载到远程进程空间中执行，DLL在被装载后则会自动执行初始化部
C/C++ 实现远程线程DLL注入
热门推荐
CSDN
06-21 1万+
远程线程注入是最常用的一种注入技术，该技术利用的核心API是 `CreateRemoteThread()` 这个API可以运行远程线程，其次通过创建的线程调用 `LoadLibraryA()` 这个函数动态载入指定的DLL即可实现运行DLL，消息钩子注入原理是利用Windows系统中`SetWindowsHookEx()`这个API函数，它可以拦截目标进程的消息到指定的DLL中导出的函数，利用这个特性，我们可以将DLL注入到指定进程中，
C/C++ 远程DLL线程注入
CSDN
07-16 7396
DLL远程线程注入是一种技术，常用于在一个进程的地址空间中加载并执行动态链接库（DLL）。这种注入方式通常涉及到两个进程：目标进程和注入进程。
驱动开发：内核远程线程实现DLL注入
CSDN
06-22 6547
在笔者上一篇文章`《驱动开发：内核RIP劫持实现DLL注入》`介绍了通过劫持RIP指针控制程序执行流实现插入DLL的目的，本章将继续探索全新的注入方式，通过`NtCreateThreadEx`这个内核函数实现注入DLL的目的，需要注意的是该函数在微软系统中未被导出使用时需要首先得到该函数的入口地址，`NtCreateThreadEx`函数最终会调用`ZwCreateThread`，本章在寻找函数的方式上有所不同，前一章通过内存定位的方法得到所需地址，本章则是通过解析导出表实现。
安全之路 —— 无DLL文件实现远程进程注入
雨者
08-20 1434
简介 &amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;nbsp;在之前的章节中，笔者曾介
DLL注入——使用远程线程
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
08-30 1998
从根本上来说，DLL注入技术要求目标进程中的一个线程调用LoadLibrary来载入我们想要的DLL。由于我们不能轻易地控制别人进程中的线程，因此这种方法要求我们在目标进程中创建一个新的线程，Windows提供了创建远程线程的函数。);hProcess：用于创建线程的进程的句柄。lpThreadAttributes：指向SECURITY_ATTRIBUTES结构的指针，该结构确定返回的句柄是否可以被子进程继承。dwStackSize：堆栈的初始大小，以字节为单位。......
易语言远程线程注入DLL到游戏
511遇见
12-09 9170
远程线程注入CreateRemoteThread通过获取注入目标进程的句柄，把我们的DLL注入到目标进程内存地址，远程线程的意思是另一个进程中的线程，并非远控的意思，也就是远程线程注入是指一个进程在另一个进程中创建线程的技术， 下面我们先看一下步骤： 1、获取游戏进程句柄,0表示不继承句柄 2、在远程进程中(游戏进程中)申请内存空间，用来存放模块路径 3、WriteProcessMemor...
远程线程注入_远程_远程线程_dll注入_注入_
10-01
远程线程注入是一种在计算机编程中常见的技术，主要用于在另一个进程中执行代码，通常是用来实现调试、监控、自动化或恶意软件的功能。在这个场景中，我们关注的是"远程线程注入"和"DLL注入"这两个概念。 远程线程...
InjectDLL代码 实现远程注入线程.zip
03-28
3. "InjectDLL"：这个文件可能是实现远程线程注入的DLL文件，它包含被注入进程中执行的代码。DLL文件通常包含导出函数，这些函数将在目标进程中执行。 远程线程注入的实现涉及到对Windows API的深入理解和熟练使用...
c++down远程线程注入.rar_下载者_文件映射_线程注入_远程线程注入
09-21
总结，C++实现的远程线程注入和文件映射通信是系统编程中的高级技巧，能够帮助开发者实现跨进程的数据共享和控制。通过分析和实践提供的下载者源码，可以深入理解这两种技术的应用场景和实现方法，为后续的系统级...
c语言链表实现
2301_81172092的博客
10-12 880
c语言链表的实现以及易错点的标注
Spring Boot视频网站：安全与可扩展性设计
2401_85702623的博客
10-16 908
本次程序开发选用的数据库管理工具是MySQL数据管理工具，使用它存放数据也需要创建程序对应的数据库文件，并命名刚创建的数据库文件，有了数据库也需要创建各种数据表来充实数据库，在数据表的创建中，不仅需要对数据表命名，也需要对数据表的字段进行设计，包括每个数据表里面需要设置的字段名称，字段对应的数据类型信息，字段的主键设置这个也是不可缺少的，因为每个数据表里面的主键就是标记着这个数据表跟其他数据表相区分的唯一标志。addtime timestamp 否 CURRENT_TIMESTAMP 创建时间。
CTFHUB技能树之HTTP协议——响应包源代码
weixin_73049307的博客
10-13 539
点击“开始”没有抓取到报文，先看看网页源代码是什么情况。居然直接给出flag了，不知道这题的意义何在。是个贪吃蛇小游戏，看不出来有什么特别的地方。
域1：安全与风险管理 第2章-人员安全与风险管理
rm -rf /*
10-12 983
风险管理过程包括识别可能造成数据损坏或泄漏的因素，根据数据价值和控制措施的成本评估这些因素，并实施具有成本效益的解决方案来减轻或者降低风险。通过执行风险管理，为全面降低风险奠定基础。
等保测评：如何进行有效的安全合规性审查
最新发布
2301_79955948的博客
10-18 509
等保测评（信息安全等级保护测评）是一项至关重要的安全合规性审查工作，旨在帮助组织保障信息系统的安全性、合规性，有效应对安全风险，提升整体安全防护水平。
常见的内网渗透思路及方法（包含示例）
xixixi7777的博客
10-11 1146
内网渗透是指在企业或组织的内部网络中进行安全测试，以发现和利用网络中的安全漏洞。
使用C++实现远程线程注入技术
创建远线程注入是通过在目标进程中动态加载DLL（动态链接库）来实现对进程功能的扩展或操控。" 在Windows操作系统中，创建远线程注入是一种常见的逆向工程和恶意软件技术，它允许一个进程（注入者）在另一个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值