内存写入 隐藏模块注入

已于 2022-08-23 20:29:41 修改
阅读量1.7k 收藏 8
点赞数 4
文章标签： c语言 c++ 安全 winapi windows
于 2020-09-11 13:54:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pluginL/article/details/108532502
版权

啦啦啦啦啦啦

思路:
1.获取自身SizeOfImage ImageBase
2.远程申请注入进程SizeOfImage大小的内存 内存位置随机 获得内存位置:ProcessAddr
3.申请一段SizeOfImage大小缓冲区，写入自身程序 内存位置：ImageBase
4.修复Image重定位表(参数为:ProcessAddr)
5.写入缓冲区ProcessAddr,SizeOfImage
6.远程线程申请入口点为DWORD WINAPI(LPVOID lparameter)
7.入口点修复导入表，因为有的dll没有在进程里加载，有的dll入口点不对
//main下面的代码是自己写的函数，如果要复制粘贴记得整理
//注释写的不好后期加的不然里面都没有注释😓

#include "MyTools.h"
#include "MyTools2.h"
//IATHook测试是否注入成功 ImportTable修复是否成功
LPVOID pOldFunAddr = GetProcAddress(LoadLibrary("user32.dll"), "MessageBoxA");

INT WINAPI MyMessageBox(HWND hwnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
	typedef INT(WINAPI *MESSAGEBOX) (HWND hwnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);
	DWORD dwRet = ((MESSAGEBOX)pOldFunAddr)(hwnd, "HOOK SUCEESS", "WARNING", uType);
	printf("parameter:%x %x %x %x return:%x\n", hwnd, lpText, lpCaption, uType, dwRet);
	return 0;
}

VOID IATHook(LPVOID pOldFunAddr, LPVOID MyMessageBox,LPVOID lparameter) {
	HMODULE imageBase = (HMODULE)lparameter;
	PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)imageBase;
	PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)((DWORD)pNtHeader + 4);
	PIMAGE_OPTIONAL_HEADER32 pOptionalHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pFileHeader +
		IMAGE_SIZEOF_FILE_HEADER);
	PIMAGE_IMPORT_DESCRIPTOR pImportDes = (PIMAGE_IMPORT_DESCRIPTOR)(pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress + (DWORD)imageBase);
	while (pImportDes->OriginalFirstThunk && pImportDes->FirstThunk) {
		PDWORD pIATthunk = (PDWORD)(pImportDes->FirstThunk + (DWORD)imageBase);
		while (*pIATthunk) {
			if (*pIATthunk == (DWORD)pOldFunAddr) {
				DWORD a = 0;
				if (!VirtualProtect(pIATthunk,10, PAGE_EXECUTE_READWRITE,&a)) {
					printf("VirtualProtectEx faild\n");
					MessageBox(0, "VirtualProtectEx", 0, 0);
					return;
				}
				*pIATthunk = (DWORD)MyMessageBox;
				break;
			}
			pIATthunk++;
		}
		pImportDes++;
	}
}
//入口点
VOID entry(LPVOID lparameter) {
	//修复导入表
	FixMemoryIATDirectory(lparameter, (HANDLE)0xFFFFFFFF);
	IATHook(pOldFunAddr, MyMessageBox, lparameter);
	MessageBox(0, 0, 0, 0);
	//反向HOOK一下就是卸载HOOK
	IATHook(MyMessageBox, pOldFunAddr, lparameter);
	MessageBox(0, 0, 0, 0);
	ExitProcess(0);
	
}
VOID ModuleInject(LPCSTR processName) {
	HANDLE hSelfHandle = GetCurrentProcess();
	HANDLE hSelfThread = GetCurrentThread();
	DWORD SizeOfImage;
	HMODULE imageBase = GetModuleHandle(NULL);
	CHAR selfPath[256] = { 0 };
	//获得所需要的Info
	if (!GetModuleFileName(NULL, selfPath, 255)) {
		printf("GetModuleFileName faild\n");
		return;
	}
	if (!GetProcessInfo(selfPath, &SizeOfImage)) {
		printf("GetProcessInfo faild\n");
		return;
	}
	LPVOID lpImageBuffer = malloc(SizeOfImage);
	//获取自身ImageBuffer
	if (!ReadProcessMemory(hSelfHandle, imageBase, lpImageBuffer, SizeOfImage, 0)) {
		printf("ReadProcessMemory faild\n");
		return;
	}
	//创建进程
	STARTUPINFO si = { 0 };
	si.cb = sizeof(si);
	PROCESS_INFORMATION pi;
	if (!CreateProcess(processName, 0, 0, 0, FALSE, CREATE_NEW_CONSOLE, 0, 0, &si, &pi)) {
		printf("CreateProcess faild\n");
		return;
	}
	LPVOID lpImageBase;
	if (!(lpImageBase = VirtualAllocEx(pi.hProcess, NULL, SizeOfImage, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE))) {
		printf("VirtualAllocEx faild\n");
		return;
	}
	//修复重定位
	if (!FixImageBaseRelocation(&lpImageBuffer, (DWORD)lpImageBase)) {
		printf("FixImageBaseRelocation faild\n");
		return;
	}
	if (!WriteProcessMemory(pi.hProcess, lpImageBase, lpImageBuffer, SizeOfImage, 0)) {
		printf("WriteProcessMemory faild\n");
		return;
	}
	//计算entry在进程里的位置
	DWORD entryAddr = (DWORD)entry + (DWORD)lpImageBase - (DWORD)imageBase;
	printf("%x = %x + %x - %x\n", entryAddr, entry, lpImageBase, imageBase);
	//跨进程创建线程执行entry
	HANDLE hThead = CreateRemoteThread(pi.hProcess, 0, 0, (LPTHREAD_START_ROUTINE)entryAddr, lpImageBase, 0, 0);
	if (!hThead) {
		printf("CreateRemoteThread faild\n");
		return;
	}
	WaitForSingleObject(hThead, -1);
	printf("ModuleIndect Sucessed");
	free(lpImageBuffer);
}
int main() {
	ModuleInject("X:\\xxx\\xxx.exe");
}

//功能:获取ImageSize 
//IN LPCSTR processPath,OUT PDWORD imageSize
BOOL GetProcessInfo(LPCSTR processPath, PDWORD imageSize) {
	if (processPath == NULL) {
		return FALSE;
	}

	LPVOID pFileBuffer;
	DWORD dwFileSize = ReadPEFile(processPath, &pFileBuffer);
	if (!dwFileSize) {
		printf("ReadPEFile faild\n");
		return FALSE;
	}
	PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
	PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)((DWORD)pNtHeader + 4);
	PIMAGE_OPTIONAL_HEADER32 pOptionalHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pFileHeader +
		IMAGE_SIZEOF_FILE_HEADER);
	*imageSize = pOptionalHeader->SizeOfImage;

	free(pFileBuffer);
	return TRUE;
}

//功能修复Image的重定位表
//无OUT
BOOL FixImageBaseRelocation(LPVOID* pImageBuffer, DWORD newImageBase) {
	PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)*pImageBuffer;
	PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)((DWORD)pNtHeader + 4);
	PIMAGE_OPTIONAL_HEADER32 pOptionalHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pFileHeader +
		IMAGE_SIZEOF_FILE_HEADER);
	PIMAGE_DATA_DIRECTORY pDataDirectory = (PIMAGE_DATA_DIRECTORY)pOptionalHeader->DataDirectory;
	if (pDataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress == NULL) {
		printf("没有重定位表\n");
		return TRUE;
	}
	PIMAGE_BASE_RELOCATION pBaseRelocation = (PIMAGE_BASE_RELOCATION)(pDataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress + (DWORD)*pImageBuffer);

	DWORD imageBase = pOptionalHeader->ImageBase;
	pOptionalHeader->ImageBase = newImageBase;
	DWORD imageOffeset = pOptionalHeader->ImageBase - imageBase;

	while (pBaseRelocation->SizeOfBlock != 0 && pBaseRelocation->VirtualAddress != 0) {
		DWORD sizeOfWord = (pBaseRelocation->SizeOfBlock - 8) / 2;
		PWORD pWord = (PWORD)((DWORD)pBaseRelocation + 8);
		for (int i = 0; i < sizeOfWord; i++) {
			if (*pWord >> 12 != 0) {
				PDWORD offsetAddr = (PDWORD)(pBaseRelocation->VirtualAddress + (*pWord & 0xFFF) + (DWORD)*pImageBuffer);
				*offsetAddr = *offsetAddr + imageOffeset;
				pWord++;
				continue;
			}
			pWord++;
		}
		pBaseRelocation = (PIMAGE_BASE_RELOCATION)((DWORD)pBaseRelocation + pBaseRelocation->SizeOfBlock);
	}

	return 1;
}

//功能:修复进程指定位置PE格式的进程
//无OUT
BOOL FixMemoryIATDirectory(LPVOID imageBase,HANDLE hProcess) {
	MessageBox(0, "Hello", 0, 0);
	PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)imageBase;
	PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)((DWORD)pNtHeader + 4);
	PIMAGE_OPTIONAL_HEADER32 pOptionalHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER);
	PIMAGE_DATA_DIRECTORY pDataDirectory = (PIMAGE_DATA_DIRECTORY)pOptionalHeader->DataDirectory;
	if (pDataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress == NULL) {
		printf("没有IAT表\n");
		return 0;
	}
	PIMAGE_IMPORT_DESCRIPTOR pImportDes = (PIMAGE_IMPORT_DESCRIPTOR)
		 (pDataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress + (DWORD)imageBase);
	while (pImportDes->OriginalFirstThunk != NULL && pImportDes->FirstThunk != NULL) {
		LPSTR lpDllName = (LPSTR)(pImportDes->Name + (DWORD)imageBase);
		HINSTANCE hModule = GetModuleHandle(lpDllName);
		if (!hModule) {
			hModule = LoadLibraryA(lpDllName);
			if (!hModule) {
				printf("hModule获取失败\n");
				return FALSE;
			}
		}
		PDWORD pIntThunk = (PDWORD)(pImportDes->OriginalFirstThunk + (DWORD)imageBase);
		PIMAGE_THUNK_DATA pIATThunk = (PIMAGE_THUNK_DATA)(pImportDes->FirstThunk + (DWORD)imageBase);
		while (*pIntThunk) {
			LPVOID lpFunAddr;
			if (*pIntThunk & IMAGE_ORDINAL_FLAG) {
				lpFunAddr = GetProcAddress(hModule, (LPCSTR)(*pIntThunk - IMAGE_ORDINAL_FLAG));
			} else {
				PIMAGE_IMPORT_BY_NAME pImportByName = (PIMAGE_IMPORT_BY_NAME)(*pIntThunk + (DWORD)imageBase);
				lpFunAddr = GetProcAddress(hModule, pImportByName->Name);
				WriteProcessMemory(hProcess, pIATThunk, &lpFunAddr, 4, 0);
			}
			pIATThunk->u1.Function = (DWORD)lpFunAddr;
			pIntThunk++;
			pIATThunk++;
		}
		pImportDes++;
	}
	return TRUE;
}
123qweqew
关注
隐藏模块（无模块注入）
qq_15900895的博客
01-08 1527
隐藏模块（无模块注入）实现 隐藏模块（无模块注入） 代码 // memoryLoad.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include "stdlib.h" #include "PeTools.h" DWORD WINAPI InjectEntry(LPVOID lpParam) { //RepairIAT(lpParam); //定义PE头的信息 PIMAGE_DO
使用DLL进行远程线程注入，实现穿墙与隐藏进程
最新发布
sunjiaoya的博客
09-14 127
简介大多数后门或病毒要想初步实现隐藏进程，即不被像任务管理器这样典型的RING3级进程管理器找到过于明显的不明进程，其中比较著名的方法就是通过远程线程注入的方法注入将恶意进程的DLL文件注入系统认可的正常进程，你会发现任务管理器以及找不到独立出现的恶意进程项了。反向连接型后门采用这种技术，注入防火墙认可的进程（例如大部分系统进程，像explorer.exe就很常见）还能够获得一定的穿墙效果。进程注入虽然已经是将近10年前的技术了，但是今天出现的很多新型黑客技术大多数还是基于这类老技术演变而来的。
内存马实战（持续更新中）
qq_44657899的博客
05-16 2368
计划 复现以下框架的内存马注入： shiro（aes base64 加密） 普通内存马 冰蝎马 WebSocket马 xxl-job filter马 冰蝎马 netty内存马 agent内存马 JNDI（字节码里执行） SpringBoot spel表达式注入（spring cloud gateway） Struts2的ognl表达式注入 Tomcat的EL表达式注入 参考：https://gv7.me/articles/2022/the-spring-cloud-gatewa
隐藏注入的dll
08-12
隐藏注入进程的dll,让我们的模块来无影去无踪
用dll注入的方式隐藏进程
Fido
06-07 1101
上次那个改变键盘布局的程序，被同学很容易的就在任务管理器里找出来杀掉了，不爽！想个办法把它藏起来。　　google了一下，发现隐藏进程的方法有很多。可以用rundll，但那样任务管理器里还是会多出个进程，引起怀疑。还可以写注册表里AppInit_Dlls一项，但我试了一下，结果一改就开不了机，可能是我的dll没写好吧。再有就是注入了，代码注入很隐蔽，但还要遇到代码定位，API定位等问题，麻烦，还是
内存注入dll 无痕迹
08-22
内存中 注入dll 需要黑月编译 任何32位进程
DLL的注入与隐藏
12-26
易语言的dll注入与隐藏，是易语言源代码~~有兴趣的朋友可以去看看
进程内存写入实现模块隐藏
07-06
用进程内存写入模块实现模块隐藏，输入进程ID号就能实现注入自身并隐藏。
易语言实现DLL的注入 与 隐藏源码.zip
01-22
综上所述，易语言实现DLL注入和隐藏源码涉及了操作系统级的编程技术，包括进程操作、内存管理以及代码保护策略。通过学习和掌握这些技术，开发者可以提高软件的功能性和安全性。同时，也要注意合理使用，避免滥用...
内存写入注入
weixin_44711063的博客
03-06 2629
内存写入注入 如果进程A本身就给了其他进程申请和写入空间的权限，那我只要将模块复制到指定进程A的空间里面，再修改一些表，再利用远程线程或者hook也就能让我们的模块在进程A运行，这就是内存写入注入 思路 只要我进程A允许进程B有写入操作就可以实现注入。这样实现了隐藏模块的注入 拓展：若是不允许别的进程有写入操作，但应该也会允许系统进程有写入操作，只要我将注入功能注入到系统进程里面，让系统进程对进程A进行内存写入注入就可以了。相当于内存写入注入+伪装合法软件注入 步骤 1、内存写入： 获取当前模块句柄，得
易语言DLL隐藏模块
07-18
2. **隐藏技术**：隐藏模块通常会采用一些技巧，比如在内存中动态生成并执行DLL，不将其写入磁盘，减少被检测的可能性。此外，还可能使用进程注入技术，将DLL加载到其他进程中，以混淆执行路径。 3. **文本_字节集...
内存注入工具
07-25
用途很广的内存注入工具用途很广的内存注入工具，一直留着
进程中dll模块的隐藏
xjh_Love_paopao的专栏
07-21 1570
 http://netroc682.spaces.live.com/        为了避免自己的某个dll模块被别人检测出来，有时候希望在自己加载一个dll之后，或者将dll注入到他人进程之后避免被检查出来。这就需要想办法抹掉这个dll的模块信息，使得Toolhelp、psapi等枚举模块的API无法枚举它。        我们可以先简单看看Windows枚举进程内模块的办法吧：  
内存注入(IAT Hook 和Inline Hook)
06-02
本压缩包有我自己写的内存注入程序与测试程序,并附有相应的源码..会用MessageBox 去Hook 指定的函数
windows内存注入
u012795264的博客
10-31 3815
针对Windows内存注入的方式大概也就那么几个，分别为使用函数QueueUserAPC DLL注入，调用SetWindowsHookEx注入，code cave注入和前不久的PowerLoaderEx内存注入。 利用AtomBombing技术后，它可以和其它的合法进程建立一个不会被查杀的通讯。比如我们可以让Chrome.exe和shellcode.exe进行通信，进程中只有chrome.exe，杀
X64位内存注入DLL技术(可躲避检测DLL,破解盗用DLL)
热门推荐
hzw320的博客
03-02 1万+
说到易语言对64位进程注入dll方面， 虽然我们Game-EC模块里面已经有对64位程序进行注入dll的功能了，但是 在这几天新年里，除了忙着像大多数人一样走亲访友拜年，剩余的时间也没闲着，研究开发了另外一种对64位程序进程进行注入dll的功能，今天给大家带来的是最近开发的新功能里面其中一个64位内存注入dll，也是属于64位游戏辅助开发方面的。 因为之前有不少开发64位游戏辅助的学员建议我，希望能出个隐藏64位dll的功能就好了，因为注入游戏dll经常遇见被游戏枚举dll方法就能检测到是否有第三方dll（
内存注入模块-易语言
06-12
内存注入模块-易语言
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值