[DLL 劫持] 修改 IAT ，让程序启动时加载自己的 DLL

最新推荐文章于 2023-04-09 12:52:49 发布
最新推荐文章于 2023-04-09 12:52:49 发布
阅读量980 收藏 6
点赞数
分类专栏： DLL注入/劫持
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simon798/article/details/110239170
版权

请转到以下链接食用 🐷

原理参考：
🥙：https://www.cnblogs.com/LyShark/p/13697577.html

代码1（部分情况下有修复内存对齐的 bug）：

#include <windows.h>
#include <iostream>
#include <exception>
#include <string>

using namespace std;

ULONG32 PEAlign(ULONG32 dwNumber, ULONG32 dwAlign)
{
    return(((dwNumber + dwAlign - 1) / dwAlign) * dwAlign);
}

BOOL AddNewSection(const string& strTargetFile, ULONG ulNewSectionSize)
{
    BOOL bOk = FALSE;
    HANDLE TargetFileHandle = nullptr;
    HANDLE MappingHandle = nullptr;
    PVOID FileData = nullptr;
    ULONG ulFileSize = 0;
    PIMAGE_NT_HEADERS pNtHeaders = NULL;
    PIMAGE_SECTION_HEADER pNewSectionHeader = NULL;
    PIMAGE_SECTION_HEADER pLastSectionHeader = NULL;
    DWORD FileSize = 0;
    DWORD FileOffset = 0;
    DWORD VirtualSize = 0;
    DWORD VirtualOffset = 0;
    PCHAR pNewSectionContent = NULL;
    DWORD dwWrittenLength = 0;

    // 打开文件
    TargetFileHandle = CreateFileA(strTargetFile.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (TargetFileHandle == INVALID_HANDLE_VALUE)
    {
        goto EXIT;
    }

    ulFileSize = GetFileSize(TargetFileHandle, NULL);
    if (INVALID_FILE_SIZE == ulFileSize)
    {
        goto EXIT;
    }

    // 映射文件
    MappingHandle = CreateFileMappingA(TargetFileHandle, NULL, PAGE_READWRITE, 0, ulFileSize, NULL);
    if (MappingHandle == NULL)
    {
        goto EXIT;
    }

    // 得到缓存头
    FileData = MapViewOfFile(MappingHandle, FILE_MAP_ALL_ACCESS, 0, 0, ulFileSize);
    if (FileData == NULL)
    {
        goto EXIT;
    }

    // 判断是否是PE文件
    if (((PIMAGE_DOS_HEADER)FileData)->e_magic != IMAGE_DOS_SIGNATURE)
    {
        goto EXIT;
    }

    pNtHeaders = (PIMAGE_NT_HEADERS)((ULONG_PTR)FileData + ((PIMAGE_DOS_HEADER)FileData)->e_lfanew);
    if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
    {
        goto EXIT;
    }

    // 判断是否可以增加一个新节
    if ((pNtHeaders->FileHeader.NumberOfSections + 1) * sizeof(IMAGE_SECTION_HEADER) > pNtHeaders->OptionalHeader.SizeOfHeaders)
    {
        goto EXIT;
    }

    // 得到新节的起始地址， 最后的起始地址
    pNewSectionHeader = (PIMAGE_SECTION_HEADER)(pNtHeaders + 1) + pNtHeaders->FileHeader.NumberOfSections;
    pLastSectionHeader = pNewSectionHeader - 1;

    // 对齐RVA和偏移
    FileSize = PEAlign(ulNewSectionSize, pNtHeaders->OptionalHeader.FileAlignment);
    FileOffset = PEAlign(pLastSectionHeader->PointerToRawData + pLastSectionHeader->SizeOfRawData, pNtHeaders->OptionalHeader.FileAlignment);
    VirtualSize = PEAlign(ulNewSectionSize, pNtHeaders->OptionalHeader.SectionAlignment);
    VirtualOffset = PEAlign(pLastSectionHeader->VirtualAddress + pLastSectionHeader->Misc.VirtualSize, pNtHeaders->OptionalHeader.SectionAlignment);

    // 填充新节表
    memcpy(pNewSectionHeader->Name, "Inject", strlen("Inject"));
    pNewSectionHeader->VirtualAddress = VirtualOffset;
    pNewSectionHeader->Misc.VirtualSize = VirtualSize;
    pNewSectionHeader->PointerToRawData = FileOffset;
    pNewSectionHeader->SizeOfRawData = FileSize;
    pNewSectionHeader->Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;

    // 修改IMAGE_NT_HEADERS
    pNtHeaders->FileHeader.NumberOfSections++;
    pNtHeaders->OptionalHeader.SizeOfImage += VirtualSize;
    pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;
    pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;

    // 添加新节到文件尾部
    SetFilePointer(TargetFileHandle, 0, 0, FILE_END);
    pNewSectionContent = new CHAR[FileSize];
    RtlZeroMemory(pNewSectionContent, FileSize);
    dwWrittenLength = 0;
    if (!WriteFile(TargetFileHandle, pNewSectionContent, FileSize, &dwWrittenLength, nullptr))
    {
        goto EXIT;
    }

    bOk = TRUE;
EXIT:
    if (TargetFileHandle != NULL)
    {
        CloseHandle(TargetFileHandle);
        TargetFileHandle = nullptr;
    }
    if (FileData != NULL)
    {
        UnmapViewOfFile(FileData);
        FileData = nullptr;
    }
    if (MappingHandle != NULL)
    {
        CloseHandle(MappingHandle);
        MappingHandle = nullptr;
    }
    return bOk;
}

PIMAGE_SECTION_HEADER GetOwnerSection(PIMAGE_NT_HEADERS pNTHeaders, DWORD dwRVA)
{
    int i;
    PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)(pNTHeaders + 1);
    for (i = 0; i < pNTHeaders->FileHeader.NumberOfSections; i++)
    {
        if ((dwRVA >= (pSectionHeader + i)->VirtualAddress) && (dwRVA <= ((pSectionHeader + i)->VirtualAddress + (pSectionHeader + i)->SizeOfRawData)))
        {
            return ((PIMAGE_SECTION_HEADER)(pSectionHeader + i));
        }
    }
    return PIMAGE_SECTION_HEADER(NULL);
}

DWORD RVAToFOA(PIMAGE_NT_HEADERS pNTHeaders, DWORD dwRVA)
{
    DWORD _offset;
    PIMAGE_SECTION_HEADER section;

    // 找到偏移所在节
    section = GetOwnerSection(pNTHeaders, dwRVA);
    if (section == NULL)
    {
        return(0);
    }

    // 修正偏移
    _offset = dwRVA + section->PointerToRawData - section->VirtualAddress;

    return(_offset);
}

BOOL AddNewImportDescriptor(const string& strTargetFile, const string& strInjectDllName, const string& strFunctionName)
{
    BOOL bOk = FALSE;
    ULONG ulFileSize = 0;
    HANDLE TargetFileHandle = nullptr;
    HANDLE MappingHandle = nullptr;
    PVOID FileData = nullptr;
    PIMAGE_IMPORT_DESCRIPTOR pImportTable = nullptr;
    PIMAGE_NT_HEADERS pNtHeaders = NULL;
    BOOL  bBoundImport = FALSE;
    PIMAGE_SECTION_HEADER pNewSectionHeader = NULL;
    PBYTE pNewSectionData = NULL;
    PBYTE pNewImportDescriptor = NULL;
    INT i = 0;
    DWORD dwDelt = 0;
    PIMAGE_THUNK_DATA pNewThunkData = NULL;
    PBYTE pszDllName = NULL;
    PIMAGE_IMPORT_BY_NAME pImportByName = NULL;

    // 打开文件
    TargetFileHandle = CreateFileA(strTargetFile.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (TargetFileHandle == INVALID_HANDLE_VALUE)
    {
        goto EXIT;
    }

    ulFileSize = GetFileSize(TargetFileHandle, NULL);
    if (INVALID_FILE_SIZE == ulFileSize)
    {
        goto EXIT;
    }

    // 映射文件
    MappingHandle = CreateFileMappingA(TargetFileHandle, NULL, PAGE_READWRITE, 0, ulFileSize, NULL);
    if (MappingHandle == NULL)
    {
        goto EXIT;
    }

    // 得到缓存头
    FileData = MapViewOfFile(MappingHandle, FILE_MAP_ALL_ACCESS, 0, 0, ulFileSize);
    if (FileData == NULL)
    {
        goto EXIT;
    }

    // 判断是否是PE文件
    if (((PIMAGE_DOS_HEADER)FileData)->e_magic != IMAGE_DOS_SIGNATURE)
    {
        goto EXIT;
    }

    pNtHeaders = (PIMAGE_NT_HEADERS)((ULONG_PTR)FileData + ((PIMAGE_DOS_HEADER)FileData)->e_lfanew);
    if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
    {
        goto EXIT;
    }

    // 得到原导入表
    pImportTable = (PIMAGE_IMPORT_DESCRIPTOR)((ULONG_PTR)FileData + RVAToFOA(pNtHeaders, pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress));

    // 判断是否使用了绑定导入表
    if (pImportTable->Characteristics == 0 && pImportTable->FirstThunk != 0)
    {
        bBoundImport = TRUE;
        pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;
        pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;
    }

    // 找到自己添加的新节
    pNewSectionHeader = (PIMAGE_SECTION_HEADER)(pNtHeaders + 1) + pNtHeaders->FileHeader.NumberOfSections - 1;
    pNewSectionData = pNewSectionHeader->PointerToRawData + (PBYTE)FileData;
    pNewImportDescriptor = pNewSectionData;

    // 往新节中拷贝原导入表内容
    i = 0;
    while (pImportTable->FirstThunk != 0 || pImportTable->Characteristics != 0)
    {
        memcpy(pNewSectionData + i * sizeof(IMAGE_IMPORT_DESCRIPTOR), pImportTable, sizeof(IMAGE_IMPORT_DESCRIPTOR));
        pImportTable++;
        pNewImportDescriptor += sizeof(IMAGE_IMPORT_DESCRIPTOR);
        i++;
    }

    // 复制最后一个描述符
    memcpy(pNewImportDescriptor, pNewImportDescriptor - sizeof(IMAGE_IMPORT_DESCRIPTOR), sizeof(IMAGE_IMPORT_DESCRIPTOR));

    // 计算修正值
    dwDelt = pNewSectionHeader->VirtualAddress - pNewSectionHeader->PointerToRawData;

    // pNewImportDescriptor 当前指向要构造的新描述符 再空出一个空描述符作为导入表的结束符 所以是 2 *
    pNewThunkData = PIMAGE_THUNK_DATA(pNewImportDescriptor + 2 * sizeof(IMAGE_IMPORT_DESCRIPTOR));
    pszDllName = (PBYTE)(pNewThunkData + 2);
    memcpy(pszDllName, strInjectDllName.c_str(), strInjectDllName.length());

    // 确定 DllName 的位置
    pszDllName[strInjectDllName.length() + 1] = 0;

    // 确定 IMAGE_IMPORT_BY_NAM 的位置
    pImportByName = (PIMAGE_IMPORT_BY_NAME)(pszDllName + strInjectDllName.length() + 1);

    // 初始化 IMAGE_THUNK_DATA
    pNewThunkData->u1.Ordinal = (DWORD_PTR)pImportByName - (DWORD_PTR)FileData + /*加上修正值 - 这里应该填充在内存中的地址*/dwDelt;

    // 初始化 IMAGE_IMPORT_BY_NAME
    pImportByName->Hint = 1;
    memcpy(pImportByName->Name, strFunctionName.c_str(), strFunctionName.length());
    pImportByName->Name[strFunctionName.length() + 1] = 0;

    // 初始化 PIMAGE_IMPORT_DESCRIPTOR
    if (bBoundImport)
    {
        ((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->OriginalFirstThunk = 0;
    }
    else
    {
        ((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->OriginalFirstThunk = dwDelt + (DWORD_PTR)pNewThunkData - (DWORD_PTR)FileData;
    }
    ((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->FirstThunk = dwDelt + (DWORD_PTR)pNewThunkData - (DWORD_PTR)FileData;
    ((PIMAGE_IMPORT_DESCRIPTOR)pNewImportDescriptor)->Name = dwDelt + (DWORD_PTR)pszDllName - (DWORD_PTR)FileData;

    // 修改导入表入口
    pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = pNewSectionHeader->VirtualAddress;
    pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = (i + 1) * sizeof(IMAGE_IMPORT_DESCRIPTOR);

    bOk = TRUE;
EXIT:
    if (TargetFileHandle != NULL)
    {
        CloseHandle(TargetFileHandle);
        TargetFileHandle = nullptr;
    }

    if (FileData != NULL)
    {
        UnmapViewOfFile(FileData);
        FileData = nullptr;
    }

    if (MappingHandle != NULL)
    {
        CloseHandle(MappingHandle);
        MappingHandle = nullptr;
    }
    return bOk;
}

BOOL AddImportTable(const string& strTargetFile, const string& strInjectDllName, const string& strFunctionName)
{
    BOOL bOk = FALSE;

    if (!AddNewSection(strTargetFile, 256))
    {
        goto end;
    }

    if (!AddNewImportDescriptor(strTargetFile, strInjectDllName, strFunctionName))
    {
        goto end;
    }

    bOk = TRUE;
end:
    return bOk;
}


int main()
{
    getchar();
    AddImportTable("被注入进程.exe", "要注入的模块.dll", "模块导出函数名");

    system("pause");
    return true;
}

代码2（测试正常，推荐）：

// 这段代码要放在文件头部才能生效 (。・∀・)ノ
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif

BOOL iatInsertDll(CONST TCHAR dllName[MAX_PATH],CONST TCHAR funcName[MAX_PATH],CONST TCHAR sourceFile[MAX_PATH],CONST TCHAR targetFile[MAX_PATH])
{
	BOOL ret = FALSE;
	PTCHAR pExe = nullptr;									// 原文件二进制
	UINT fileSize = 0;												// 文件大小
	FILE* pfin = nullptr;											// 输入文件
	FILE* pfout = nullptr;										// 输出文件
	TCHAR injectStr[64] = { 0 };								// 导入函数字符信息
	UINT injectStrLen = 0;										// 字符信息长度
	UINT injectStrThunk = 0;									// 以 '\0' 结尾的 dll 名字符串
	IMAGE_DOS_HEADER dos_header;											// dos 头
	IMAGE_NT_HEADERS* nt_headers_ptr;									// nt 头
	IMAGE_SECTION_HEADER* section_headers;						// 可选头
	IMAGE_IMPORT_DESCRIPTOR* import_descriptor;				// 导入表
	IMAGE_IMPORT_DESCRIPTOR newImportStruct;					// 新导入项（非导入表）
	LONG IatOffset = 0;											// 导入表所在区段 rof 、rva 差值
	LONG finalSectionOffset = 0;							// 最后一个区段 rof 、 rva 的差值
	LONG finalSectionEnd = 0;								// 最后一个区段末尾rof
	UINT finalSectionIndex = 0;							// 最后一个区段的下标
	INT importCount = -1;										// 导入函数个数
	ULONG injectAddr = 0;									// 要插入的导入函数地址
	PTCHAR szEndPad = { 0 };																			// 末尾填充字符串
	UINT padLen = 0;																			// 填充长度

	// 只读方式打开二进制文件
	pfin = fopen(sourceFile, "rb");
	if (!pfin)
	{
		printf("fopen failed. \n");
		goto end;
	}

	// 将文件二进制读入内存
	fseek(pfin, 0, SEEK_END);
	fileSize = ftell(pfin);
	fseek(pfin, 0, SEEK_SET);
	pExe = (char*)malloc(fileSize);
	fread(pExe, fileSize, 1, pfin);
	fclose(pfin);

	// 拼接插入dll 和导入函数的字符信息
	sprintf(injectStr, "%s%c%c%c%s%c%c%c%c%c", dllName, 0, 0, 0, funcName, 0, 0, 0, 0, 0);
	injectStrLen = strlen(dllName) + 3 + strlen(funcName) + 5;
	injectStrThunk = strlen(dllName) + 1;

	// 判断是否为有效的 pe 文件
	dos_header = *(IMAGE_DOS_HEADER*)(pExe);
	nt_headers_ptr = (IMAGE_NT_HEADERS*)(pExe + dos_header.e_lfanew);
	if (dos_header.e_magic != 0x5A4D || (*nt_headers_ptr).Signature != 0x4550)
	{
		printf("Invalid PE file. \n");
		goto end;
	}

	// 计算可选头
	section_headers =
		(IMAGE_SECTION_HEADER*)
		(pExe
			+ dos_header.e_lfanew
			+ sizeof((*nt_headers_ptr).Signature)
			+ sizeof((*nt_headers_ptr).FileHeader)
			+ (*nt_headers_ptr).FileHeader.SizeOfOptionalHeader);

	// 计算最后一个区段的下标
	finalSectionIndex = (*nt_headers_ptr).FileHeader.NumberOfSections - 1;

	// 计算最后一个 区段的 rof 和 rva 的差值
	finalSectionOffset = section_headers[finalSectionIndex].PointerToRawData - section_headers[finalSectionIndex].VirtualAddress;

	// 计算最后一个区段的末尾 rof
	finalSectionEnd = section_headers[finalSectionIndex].PointerToRawData + section_headers[finalSectionIndex].SizeOfRawData;

	// 找到导入表所在区段 rof、rva 的差值
	for (int i = finalSectionIndex; i > -1; i--)
		// 因为是 i-- ，所以区段的 VirtualAddress 是越来越小的，当 VirtualAddress 首次小于导入表的 VirtualAddress 时，说明导入表在这个区段中
		if (section_headers[i].VirtualAddress <= (*nt_headers_ptr).OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)
		{
			IatOffset = section_headers[i].PointerToRawData - section_headers[i].VirtualAddress;
			break;
		}

	// 计算导入表 rof（=区段rof+导入表所在区段的段内偏移）
	import_descriptor =
		(IMAGE_IMPORT_DESCRIPTOR*)
		(pExe
			+ (*nt_headers_ptr).OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress
			+ IatOffset);

	// 计算导入函数个数
	while (import_descriptor[++importCount].OriginalFirstThunk);

	// 重定向导入表到最后一个区段末尾
	(*nt_headers_ptr).OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = finalSectionEnd - finalSectionOffset;

	// 调整 pe 以适应新的导入表（扩充大小、内存对齐、可写）
	(*nt_headers_ptr).OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size += sizeof(IMAGE_IMPORT_DESCRIPTOR);
	(*nt_headers_ptr).OptionalHeader.SizeOfImage += (*nt_headers_ptr).OptionalHeader.SectionAlignment;
	section_headers[finalSectionIndex].SizeOfRawData += (*nt_headers_ptr).OptionalHeader.SectionAlignment;
	section_headers[finalSectionIndex].Misc.VirtualSize += (*nt_headers_ptr).OptionalHeader.SectionAlignment;
	section_headers[finalSectionIndex].Characteristics |= IMAGE_SCN_MEM_WRITE;

// 计算扩充后的导入函数地址
	injectAddr = (importCount + 2) * sizeof(IMAGE_IMPORT_DESCRIPTOR) + finalSectionEnd - finalSectionOffset;

	// 在导入字符信息后追加导入函数地址信息（让新副本找到导入函数）
	*(DWORD*)(injectStr + injectStrLen - 4) = injectAddr + injectStrThunk;

	// 初始化导入项信息
	newImportStruct.OriginalFirstThunk = injectAddr + injectStrLen - 4;			// 给 Name 留（inject_strlen - 4）长度的空位
	newImportStruct.TimeDateStamp = 0;
	newImportStruct.ForwarderChain = 0;
	newImportStruct.Name = injectAddr;																	// Name 是扩充后的导入函数头部地址
	newImportStruct.FirstThunk = injectAddr + injectStrLen - 4;						// 新导入函数 rva （紧随头部地址之后） 

	// 写方式打开二进制文件，拷贝一份副本
	pfout = fopen(targetFile, "wb");
	if (!pfout)
	{
		printf("fopen failed. \n");
		goto end;
	}
	fwrite(pExe, finalSectionEnd, 1, pfout);

	// 修改新副本导入表地址
	fwrite(import_descriptor, importCount * sizeof(IMAGE_IMPORT_DESCRIPTOR), 1, pfout);

	// 追加新导入项
	fwrite(&newImportStruct, sizeof(IMAGE_IMPORT_DESCRIPTOR), 1, pfout);

	// 填充 sizeof(IMAGE_IMPORT_DESCRIPTOR) 个 '\0' ,表示导入表结构到此结束
	fwrite("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", sizeof(IMAGE_IMPORT_DESCRIPTOR), 1, pfout);

	// 设置导入函数字符串信息
	fwrite(injectStr, injectStrLen, 1, pfout);

	// 将文件填充到正确的对齐位置
	padLen = (*nt_headers_ptr).OptionalHeader.SectionAlignment - (importCount + 2) * sizeof(IMAGE_IMPORT_DESCRIPTOR) - injectStrLen;
	szEndPad = (PTCHAR)calloc(1, padLen);
	fwrite(szEndPad, padLen, 1, pfout);
	

	ret = TRUE;
end:
	if (pfin)
	{
		fclose(pfin);
	}
	if (pfout)
	{
		fclose(pfout);
	}
	if (pExe)
	{
		free(pExe);
	}
	if (szEndPad)
	{
		free(szEndPad);
	}
	return ret;
}

int main()
{
	iatInsertDll("Insert.dll", "justExport", "before.exe", "after.exe");

	return 0;
}

在这里插入图片描述

注意，如果要注入 x64 进程，记得改下 PE 的结构体类型（64）. 🙃

(-: LYSM :-)
关注
专栏目录
易语言lsp劫持_[原创]不用导出任何函数的DLL劫持注入,完美!
weixin_39935319的博客
12-21 2736
.最近在写SOCKS5代理,用的是LSP.代理成功了,但是因为LSP模块没办法隐藏,各种三方模块啊删除PE头,强制删除文件,游戏都会闪退想来想去,就想到这个法子,HOOK LdrLoadDll返回的模块句柄把返回句柄替换成真实的DLL句柄,这种劫持的方式好处就是不用任何导出函数不管什么是DLL劫持都可以,只要你能替换原来的DLL,LSP也挺方便的,哈哈哈不过这种lsp劫持注入,只能用API HOO...
深入理解反射式dll注入技术
m0_67698950的博客
06-22 1464
前言dll 注入技术是让某个进程主动加载指定的 dll 的技术。恶意软件为了提高隐蔽性，通常会使用 dll 注入技术将自身的恶意代码以 dll 的形式注入高可信进程。常规的 dll 注入技术使用 LoadLibraryA() 函数来使被注入进程加载指定的 dll。常规dll注入的方式一个致命的缺陷是需要恶意的 dll 以文件的形式存储在受害者主机上。这样使得常规 dll 注入技术在受害者主机上留下痕迹较大，很容易被 edr 等安全产品检测到。为了弥补这个缺陷，stephen fewer 提出了反射式 dll
SetDll DLL自动注入，让EXE启动时加载自己的DLL
11-04
可以让EXE在启动的时候加载自己做的DLL，填写自己做的DLL名后选择EXE即可，这样目标程序在启动时就会加载刚才的DLL
如何让windows启动后,自动加载一个DLL
09-25 1192
在以下注册表项中找到下面的位置：HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Windows\AppInit_DLLs其中指定的所有DLL都会加载到每个Microsoft会话上运行的基于Windows的应用程序中。也就是说所有GUI程序都会被挂上该动态库。lz可以自己详细google一下AppI...
修改IAT，HOOK API
mybirdsky的专栏
01-14 836
2007年08月16日 09:30:00 ////write by Gxter////本程序是用寻找并修改(Improt Address Table)的方法来实现HOOK一个API函数#include >windows.h#include >stdio.h#include >tchar.h#define UNICODE#define _UNICODEPIMAGE_DOS_HEADER
API钩子(IAT修改方式)
weixin_33935777的博客
05-23 521
在Windows下，主要有两种方式来对系统API调用的拦截，一种是修改PE文件的IAT导入表，使API地址重定向；另一种方式就是把在API函数开始地址的机器码改成jmp的指令的机器码，来实现函数的跳转。 一、原理 PE结构的模块(exe/dll/...)，有一个IAT表，保存着该模块使用到的API函数的地址，在默认的隐式API调用时，会先跳转到该IAT...
HOOKAPI之修改IAT法则
lxslove的专栏
10-29 1992
HOOK是一种WINDOWS下存在很久的技术了。 HOOK一般分两种1。HOOK MESSAGE  2。HOOK API 本问讨论的是HOOK API之修改IAT。（如果你是HOOK高手就不要看了） 在最初学HOOK-API的时候通常都是通过覆盖地址和修改IAT的方法。通过这两种技术，我们基本都可以实现对本进程的API函数进行HOOK了。但是在高兴之余会有点遗憾，怎么才能HOOK其他进程的API函
使用API-HOOK修改IAT的地址
CHkylin的博客
08-23 1079
api-hook
cpp-SuperDllHijack一种通用Dll劫持技术不再需要手工导出Dll的函数接口了
08-16
传统的Dll劫持依赖于程序加载Dll时遵循的搜索路径，通过将恶意Dll放置在搜索路径的优先位置，达到优先加载的效果。但SuperDllHijack采用了更高级的策略，它利用Windows系统内部的机制，如延迟加载（Delay Load）和...
[web安全]深入理解反射式dll注入技术
HBohan的博客
03-23 2099
一、前言 dll注入技术是让某个进程主动加载指定的dll的技术。恶意软件为了提高隐蔽性，通常会使用dll注入技术将自身的恶意代码以dll的形式注入高可信进程。 常规的dll注入技术使用LoadLibraryA()函数来使被注入进程加载指定的dll。常规dll注入的方式一个致命的缺陷是需要恶意的dll以文件的形式存储在受害者主机上。这样使得常规dll注入技术在受害者主机上留下痕迹较大，很容易被edr等安全产品检测到。为了弥补这个缺陷，stephen fewer提出了反射式dll注入技术并在github开源，反
X64 Iat Hook msimg32 源码
12-17
- 当程序运行并调用DLL函数时，会先查找IAT中的地址并跳转执行。 - IAT Hook的基本思想是替换IAT中的函数指针，使其指向我们自己的代码，我们的代码在执行完毕后再调用原始函数。 2. **X64架构下的钩子实现**： ...
VC实现搜索IAT HOOK API
12-07 427
// //本程序是用寻找并修改(Improt Address Table)的方法来实现HOOK一个API函数 #include #include #include #define   UNICODE #define   _UNICODE PIMAGE_DOS_HEADER   pDosHeader; PIMAGE_NT_HEADERS   pNTHeade
HOOK API 之修改IAT实现进程隐藏
tian028的博客
03-13 1049
1 ．技术与实现 每个调用的 API 函数地址都保存在 IAT 表中。 API 函数调用时，每个输入节（ IMPORT SECTION ）所指向的 IAT 结构如下图所示。 程序中每个调用API 函数的CALL指令所使用的地址都是相应函数登记在IAT表的地址。所以为了截获API 函数，我们将IAT表中的地址换成用户自己的API PROXY函数地址，这样每个API调用都是先调用用户自己的A...
正确的加载自己写的dll
l460602540的专栏
10-25 1122
怎么能让程序正确的加载自己写的dll （1）把dll放在程序的debug目录下，在进行关联。 （2）直接把DLL放在c:\windows\system目录下 （3）添加环境变量      a，system（set Path = %Path%d:\\mydll）；   b，BOOL WINAPI SetDlldirctory(LPCTSTR LpPathName);   顺便给自己补
Hook技术：IAT Hook详细讨论修改IAT地址和恢复
weixin_43742894的博客
05-16 2608
IAT Hook是Ring3层常用的Hook之一，主要思路大家都知道，就是修改IAT中的函数地址。
有关EXE加载和调用DLL函数的例子；用ATL函数修改注册表和内存存贮的一些认识(一)
dawang2006的专栏
08-08 1475
/////////////////////////////////////////////RegEditExe.cpp   (EXE工程的)#include "RegExcute.h"int _tmain(int argc, _TCHAR* argv[]){ int x; long i; printf( "Input your action:/n" ); printf( "1:Add/n" ); 
11、dll 在程序中的加载方法
SKT allsunday的博客
08-07 609
一般程序要使用到dll中的函数，但是实际的dll中函数地址 的提供方法分两种， runtime提供dll 直接在runtime 提供dll，在程序运行过程中，先把dll载入到内存，此时如果卸载该dll，例如，freedll（dllname）；程序照样运行，这时你就可以写个新的dll，又加入到内存，再把上一次用到dll 中函数地址的指针变一下（指向其他内存），就可以继续用新的dll，于是有了新的功能，并且不用去关闭程序，做到实时的dll更新。 #define GET_STATE(name) DWORD WIN
常见系统权限维持的方法
最新发布
weixin_62369433的博客
04-09 373
权限维持是黑客攻击中的一个重要环节，如果攻击者获得了系统管理员权限，就能够完全控制系统，进行各种恶意操作。
new:一种DLL插入方案
08-20 1191
 by killvxk： typedef unsigned long DWORD;typedef unsigned short WORD;typedef unsigned char BYTE;__declspec(dllimport) DWORD PsLookupProcessByProcessId(HANDLE ProcessId,PEPROCESS* pProcess);__decls
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值