进程注入
动态修改其它进程的代码,实现DLL注入
动态修改其它进程的代码,实现DLL注入传统的远程进程控制方式有利用HOOK技术注入DLL,和利用远线程在目标进程中建立新的执行线程的方式.远线程不被win9x所支持,而hook技术会对目标进程性能造成一定的影响.并具可以通过枚举消息链的方式发现.本文给出一种动态修改目标进程代码,注入DLL到目标进程的方法,效率高,不需要额外线程.缺点是使用难度大于上面二种办法,并且修改目标代码的方法,受到编译器的影响.使用不同的编译器时,需要根据编译器调整动态代码修改方式.动态修改目标进程代码,使其加载自已的DLL的思路如下:1. 得到目标进程句柄.2. 在目标进程中分配一块可执行可读写的内存.3. 写入加载DLL的代码到分配出来的内存中.4. 修正动态写入的代码中的地址(LoadLibrary地址,DLL名字地址).5. 修改目标进程本身的代码,使其执行到被修改代码时,跳到加载DLL的代码处.6. 加载完DLL后,修正目标进程原来的代码,并跳回去继续执行.这个过程中需要注意的地方是. 对寄存器的保护,堆栈的平衡.其中第5步需要修改一块目标进程一定会执行的代码,消息循环是个不错的地方.这里以记事本为例.打开ollydbg,在TranslateMessage函数下断点,中断后如下:010029FC |. /75 14 |jnz short notepad.01002A12010029FE |. |8D45 E0 |lea eax,dword ptr ss:[ebp-20]01002A01 |. |50 |push eax ; /pMsg01002A02 |. |FF15 98120001 |call dword ptr ds:[<&USER32.Translat>;/TranslateMessage01002A08 |. |8D45 E0 |lea eax,dword ptr ss:[ebp-20]01002A0B |. |50 |push eax ; /pMsg01002A0C |. |FF15 94120001 |call dword ptr ds:[<&USER32.Dispatch>;/DispatchMessageW01002A12 |> /56 push esi01002A13 |. 56 |push esi01002A14 |. 8D45 E0 |lea eax,dword ptr ss:[ebp-20]01002A17 |. 56 |push esi01002A18 |. 50 |push eax01002A19 |. FFD7 |call edi0x01002A02处是个不错的地方,可以动态修改它. 改成mov eax, 加载dll的代码地址jmp eax需要注意的是,此程序基址在不同的系统上有可能不一样,可以从PE头中得到映像基址.所以此处的0x1002A02也许在你的机器上是另一个地址,请使用OD自行确定.(我是winxp sp2)找到修改点后,然后就是分配可执行可读写内存,写入下面一段代码进去pusha//eax中是LoadLibrary函数地址,暂时为0xffffffff//由程序动态改成真实函数地址mov eax, 0xffffffff//要加载的DLL的名字地址,暂时为0xffffffff//由程序动态改成真实地址mov ebx, 0xffffffffpush ebx//调用LoadLibrary,加载自已的DLL//这样DLL就注入到目标进程了call eaxpopa//恢复0x1002A02处的代码,并跳回去执行//选执eax寄存器是因为0x1002A02后面的代码没有直接使用到eaxmov eax, CODE_OFFSETmov dword ptr [eax], 0x129815FFmov dword ptr [eax+4], 0x458D0100jmp eax下面的代码是在加载DLL后,修正目标进程原有的代码mov eax, CODE_OFFSETmov dword ptr [eax], 0x129815FFmov dword ptr [eax+4], 0x458D01000x129815FF 0x458D0100 即为原有代码(字节顺序是倒过来的, 0x129815FF 倒过来即是FF159812, 0x458D0100倒过来即是00018D45,请注意和下面代码对比01002A02 |. |FF15 98120001 |call dword ptr ds:[<&USER32.Translat>;/TranslateMessage01002A08 |. |8D45 E0 |lea eax,dword ptr ss:[ebp-20]其它基本上就是编码了,例子如下,测试时,请自行编写一个Test.dll ,放在记事本同一个目录下,不同的编译器,不同的系统请自行修正一些细节:(我是使用的Release模式,Debug模式代码会不同的)#include <iostream>#include <windows.h>#include <psapi.h>using std::cout;using std::cin;using std::endl;//记事本的映象基址,不同的系统可能不一样//这个值可以从PE头中读取#define NOTEPAD_IMAGE_BASE 0x1000000;#define CODE_OFFSET 0x1002A02;//用来测试的DLL名const char *dllname = "Test.dll";void loaddll(){__asm{pusha//eax中是LoadLibrary函数地址,暂时为0xffffffff//由程序动态改成真实函数地址mov eax, 0xffffffff//要加载的DLL的名字地址,暂时为0xffffffff//由程序动态改成真实地址mov ebx, 0xffffffffpush ebx//调用LoadLibrary,加载自已的DLL//这样DLL就注入到目标进程了call eaxpopa//恢复0x1002A02处的代码,并跳回去执行//选执eax寄存器是因为0x1002A02后面的代码没有直接使用到eax mov eax, CODE_OFFSETmov dword ptr [eax], 0x129815FFmov dword ptr [eax+4], 0x458D0100jmp eax}}#pragma pack(push) //保存对齐状态#pragma pack(1) //设定为1字节对齐struct JmpCode{byte op;char* address;WORD jmp;};#pragma pack(pop)int main(){//找记事本主窗口句柄HWND wnd = FindWindow(NULL, "无标题- 记事本");if (!IsWindow(wnd)){cout << "记事窗口没找到" << std::endl;return 1;}//读取进程ID,和进程句柄DWORD pid;HANDLE ph;GetWindowThreadProcessId(wnd, &pid);ph = OpenProcess(PROCESS_ALL_ACCESS, false, pid);//在记事本进程中分配一页可读写可执行的虚拟内存void *address = VirtualAllocEx(ph, NULL, 4096, MEM_COMMIT,PAGE_EXECUTE_READWRITE);//写代码的地址(写在字符串后面)char *code = (char*)address + strlen(dllname) + 1;if (NULL == address){cout << "分配远端内存失败" << std::endl;return 1;}DWORD ws;//把代码写到内存页中WriteProcessMemory(ph, code, &loaddll, 4000, &ws);//把DLL名写到内存页中WriteProcessMemory(ph, address, dllname, strlen(dllname), &ws);//把loadlibrary的地址写到eax 0xfffffff处,把0xffffffff替换为真正的地址//code+9为eax 0xffffffff中0xffffffff处的偏移,通过反汇编工具查看+ 9是为了跳过//编译器给loadll函数生成的框架HMODULE module = LoadLibrary("kernel32.dll");FARPROC pro = GetProcAddress(module, "LoadLibraryA");WriteProcessMemory(ph, code + 9, &pro, 4, &ws);//把dllname的地址写到ebx 0xffffffff处,把dllname作为参数WriteProcessMemory(ph, code + 14, &address, 4, &ws);//修改记事本消息循环处的代码.JmpCode jmp;jmp.op = 0xB8;jmp.address = code + 6; //这段代码是mov eax, 地址jmp.jmp = 0xE0FF; //jmp eaxaddress = (void*)CODE_OFFSET;//让代码段可读写VirtualProtectEx(ph, address, 4096, PAGE_EXECUTE_READWRITE, &ws);//改写目标处的代码,让其跳到自已的代码处执行WriteProcessMemory(ph, address, &jmp, 8, &ws);return 0;}运行,测试,OK! Test.dll被正确加载,目标进程现在是你的了,随便玩吧.。
木马注入远程进程
个我多个 ｄ （ ｕ 动志 链接库）文件。 自从
来，动志链接库一直是其基础．Ｗｉｄ ｗｓ ｎｏ ＡＩ Ｐ 中的所有函数都包含在Ｄ Ｌ 。 个最 Ｌ中 ３
重要的ＤＬ 是Ｋｅｎ ３ ．ｌ、 ｓ ｒ２ ｄｌ Ｌ ｒ ｄ ２ ｄｌ Ｕ ｅ３ ．ｌ 和
Ｉ ｔｌ Ａｌ Ｄｅ］ 合键 ．也就看不到该程 Ｍｉｒｓ ｆ 公司推出 Ｗｉｄ ｗｓ 作系统以 Ｃ ｒ＋ ｔ ＋ １ 组 ｃ ｏｏ ｔ ｎｏ 操
步骤 ：
（ 用 Ｆ ｎ ｄ Ｗ ｄ １ ） ｉ ｉｎ Ｏ Ｗ 和
ｌＳａ ｔ ｄ ｅｓ／ 线程开始执行的地址 ｐ ｔｒＡｄ ｒｓ， ／ Ｌ Ｖ Ｄ ｌＰ ｒｍｅｅ ， ／ 向传给 Ｐ ＯＩ ｐ ａａ ｔｒ／ 指 线程函数的变量
维普资讯
木 马注入远程进程
李银兵’ 闰敬
Ｉ 唐 山 学院 计算 中 ０ ￣ ０ ６ ００ ２ ．唐 山 师范 学 院计 算机 科 学 系 ０ ５ ０ ５Ｏ０
干个线 程 ，线 程是操 作系统 分配处 理器
时间的 基本单 位 ，一个线程 是一个 执行
Ｉ２ ｒｌ ｉ 。Ｋｅｎ ｌ２ ｄ 包含用于管理内 ｒｅ３ ．ｌ ｌ Ｘ ／０ ０ Ｐ ２ ０ 的任务管理器．Ｗｉｄ ｗｓ Ｘ ／ ｎ ｏ Ｐ ＧＤ ３ ．ｌ ２０ 的任务管理器均能轻 世显示 出木 马进 存， ００ 进程 和线程的各个函数Ｉ ｓ ｒ２ 山ｌ ｅ ３ ． 包 Ｕ
含用于执行用 户界面任务 （ 如宙 口的创建 和消总． 的传送 ） 的各个函数， ＤＩ２叫 包 Ｇ ３． 现在 有很 多木马程 序 ．有的 术马是 使用进 程注入技 术实现 隐藏 ，进程注 入 含用于画 图和 显示文本 的各个函数 ＤＬＬ由多个功能 函数构 成，它不能 恶意 的 ，盗窃 用 户的关 键 信息和 材 料 ， 技术是将 自己的代码嵌八到正运行的进程 ｎ ｏ 中不同进程间的地 拽立运行 ， 一 般都是 由其它 进程加 载并 甚至给 用户带来经济上的损失。大部分木 的技 术。在 Ｗｉ ｄ ｗｓ Ｌ 文件不能独立运行．所 马在进程查看器 中看不到 ，所以查杀木马 址空阃是 隔离的 ，每 个进程 都有 自己的 调用的 因为 Ｄ Ｌ Ｌ ，假设有 不太容 易，其 中进程的隐藏是木马比较关 私有内 存地址 空间 ，一 个进 程无法 访问 以在进程列表中井不会出现 Ｄ Ｌ 个木 马ＤＬ 通过 别的进程来运行它 ． １， 那 键的技术。奉文探 讨了木马的隐 藏技术， 另一个进 程的 内存地址 空间 ，如果 要编 使读者掌握木马隐藏的原理 ．从而使读者 写能够 与其他进 程进行 通信 的程序 ，或 么无论是入侵检测软 件还是进程 列表 中． 可以 用时发现木马并将其清除 ，有效地保 者能够对其他进程进行操作的应用程序将 都 只会 出现宿 主进程 而并不 会出现木 马 例如 要困难得 多。 但仍有 多种方 法可以打 破 ＤＬＬ，如果高 主进 程是可信 进程 （ 护 自己的资料和信息 。 Ｘ Ｌ ＲＥ Ｅ Ｅ ， Ｌ 进程 的界 限 ，访问 另一个进 程的地址 空 Ｅ Ｐ Ｏ Ｒ． Ｘ ） 那 幺木马ＤＬ 作 为宿
新文化运动为中国文化和教育的现代化进程注入了新的思想和活力
新文化运动为中国文化和教育的现代化进程注入了新的思想和活力新文化运动，是二十世纪初期中国历史上的一个社会思潮运动，它的思想和实践在当时中国社会和文化界引起了极大的关注和影响。
这场运动的发生，旨在推动中国文化和教育的现代化进程，为之注入新的思想和活力。
一、新文化运动的背景新文化运动的背景，是中国向近代化转型的过程中所面临的一系列深刻变革。
在科技、政治和文化等各个领域，中国正在面临着自身的局限和外部的挑战。
一方面，中国作为一个传统文化大国，尚存着很强的保守主义思想，习俗，缺乏对现代文明的包容和理解。
另一方面，外来的西方文化思潮也对中国文化展开了冲击和挑战，揭示中国文化的缺陷和落后。
在这个背景下，众多思想家，学者和文化活动家开始探讨中国文化和教育的转型之路。
他们批判传统的观念和习惯，拥抱某些西方的文化思潮。
新文化运动就是这些先进思想的缩影。
二、新文化运动的主要思想和活动新文化运动的主要思想是“以民为本”，强调个人权利和个性发展，并将个人解放和社会进步视为一体。
他们倡导提高全民的文化水平，推动社会的民主化和现代化，并立足于新世纪的情境下，对世界走向、人类状况进行思考，要求中国文化必须与时俱进，才能在世界舞台上立足。
在新文化运动中，“文学革新”是其中的一个重要核心。
王国维、辛亥革命先驱梁启超等一系列著名学者和文化活动家的关注和介入，进一步促成文化运动的影响力，激发中国人民的阅读兴趣，同时也批判了传统文化中的种种不足和缺陷。
同时，张养浩等著名学者和文化活动家，积极推动新文化运动，在新文学的创作和运动中，更加突出新的人性关怀，侧重个性表达，倡导表达真实的人类条件、情感，在一定程度上形成一个氛围，对文化思想的新观念进行宣传和推动。
新文化运动的另一个核心观念是“以科学为尊”，他们批判了那些抱持着宗教、迷信观念的民众，并通过科学研究，对中国自然、人文、社会及历史等各个方面深入了解，提高大众的文化素质。
这种关注和推动，最终促成了中国近代教育和文化的迅速发展。
frida-inject使用详解
frida-inject使用详解Frida是一款功能强大的动态插桩工具，可以用于在运行时修改、分析和监视Android、iOS、Windows、macOS和Linux等多个平台上的应用程序。
Frida-inject是Frida提供的一个命令行工具，用于将Frida的JavaScript脚本注入到目标进程中。
使用Frida-inject可以实现一些高级功能，如Hooking方法、修改应用程序行为、绕过某些安全措施等。
下面是使用Frida-inject的详细步骤：1. 安装Frida：首先需要在你的设备上安装Frida。
你可以从Frida的官方网站（https://www.frida.re）上下载适合你平台的安装包，或者通过包管理器进行安装。
安装完成后，你可以在命令行中输入"frida --version"来验证安装是否成功。
2. 准备JavaScript脚本：编写一个Frida的JavaScript脚本，用于实现你想要的功能。
你可以在脚本中使用Frida的API进行一些操作，比如Hooking方法、修改变量、发送消息等。
详细的API文档可以在Frida的官方网站上找到。
3. 执行注入操作：打开终端，进入到Frida-inject的安装目录，执行下面的命令注入脚本到目标进程中：```frida-inject -p <pid or process name> -n <library name> -s <pathto JavaScript script>```- `-p`参数指定目标进程的ID或名称。
- `-n`参数指定要注入的库的名称。
这个库将包含你的JavaScript脚本。
- `-s`参数指定要注入的JavaScript脚本的路径和文件名。
执行这个命令后，Frida-inject会将指定的库加载到目标进程中，并执行库中的JavaScript脚本。
linux 进程注入原理
linux 进程注入原理进程注入是指将代码注入到另一个进程中，使其在目标进程中执行。
在Linux系统中，进程注入是一种常见的技术，它可以在不影响目标进程的情况下，向其添加新的功能或修改其行为。
本文将介绍Linux进程注入的原理、分类、实现方式以及安全风险，帮助读者更好地理解和应用该技术。
一、进程注入的原理Linux系统中的进程是由内核管理的，每个进程都有自己的地址空间和资源使用情况。
进程注入技术利用了Linux系统的这种特性，通过将代码注入到目标进程的地址空间中，使其在目标进程中执行。
具体来说，进程注入的过程可以分为以下几个步骤：1. 找到目标进程的地址空间首先需要找到目标进程的地址空间，通常可以通过读取系统信息、使用工具探测或者调试器辅助等方法来实现。
2. 将代码加载到目标进程的地址空间中将需要注入的代码加载到目标进程的地址空间中，可以使用系统调用、内存映射或者直接写入等方法来实现。
3. 修改目标进程的执行流程在目标进程中加载代码后，需要修改其执行流程，使其能够执行注入的代码。
这通常需要修改目标进程的代码或数据段，使其能够跳转到注入的代码处执行。
二、进程注入的分类根据注入方式的不同，可以将进程注入分为动态注入和静态注入两种类型。
动态注入是指在目标进程运行时，将代码注入到其地址空间中，使其执行。
而静态注入则是将需要注入的代码与目标进程的二进制文件一起编译或链接，使其成为目标进程的一部分。
三、实现方式1. 使用系统调用系统调用是Linux系统提供的一种接口，用于与内核进行交互。
通过系统调用可以将代码注入到目标进程中，使其执行。
常用的系统调用包括ptrace、mmap、exec等。
其中，ptrace可以用来监视目标进程的运行情况，mmap可以用来将代码加载到目标进程的地址空间中，exec可以用来替换目标进程的执行映像。
2. 使用内存映射内存映射是Linux系统提供的一种将物理内存区域映射到进程地址空间的技术。
32位程序注入64位DLL到64位进程
32位程序注⼊64位DLL到64位进程向其它进程注⼊DLL通常的做法是通过调⽤CreateRemoteThread这个API在⽬标进程内创建⼀个远程线程。
⽤这个线程来调⽤LoadLibraryA或LoadLibraryW（下⽂统称LoadLibrary）以实现让⽬标进程载⼊指定的DLL⽂件。
使⽤CreateRemoteThread创建⼀个远程线程须要传⼊⼀个线程过程函数的地址，⽽且这个函数地址是须要在⽬标进程中有效的。
因为LoadLibrary是kernel32.dll的导出函数。
所以对于执⾏在同⼀个系统上的同为32位的进程或同为64位的进程能够假定彼此进程内的LoadLibrary函数的地址是同样的。
⽽且CreateRemoteThread的线程过程函数和LoadLibrary的參数个数同样，且參数都是指针。
因此通常都是直接将LoadLibrary作为CreateRemoteThread的过程函数。
然后使⽤VirtualAllocEx在⽬标进程中分配内存，使⽤WriteProcessMemory往这块内存中写⼊DLL⽂件路径。
将这块内存的地址作为线程过程函数（LoadLibrary）的參数。
在64位的Windows操作系统上32位进程中的LoadLibrary函数地址与64位进程的函数地址不同。
因此假设想对64位进程注⼊DLL。
简单的做法就是使⽤64位进程来运⾏注⼊⼯作。
可是假设能让32位进程注⼊64位DLL到64位进程显然更好。
在⼀番Google之后找到了。
这篇⽂章的作者研究出来⼀种在Wow64进程中运⾏x64代码的⽅法，⽽且将其封装成了。
本⽂就是介绍怎样使⽤这个库实现Wow64环境下32位进程向64位进程注⼊DLL。
Wow64环境下32位程序注⼊64位DLL到64位进程32位进程难以注⼊DLL进64位进程是因为两个进程内LoadLibrary的地址不同。
32位进程⽆法知道64位进程的LoadLibrary函数地址。
DLL注入技术应用研究
DLL注入技术应用研究DLL（动态链接库）注入技术是一种常见的恶意软件攻击技术，它通过将恶意DLL文件加载到目标进程中，从而实现对目标进程的操控和控制。
本文将从DLL注入技术的原理、分类、应用以及防范等方面进行研究。
一、DLL注入技术的原理DLL注入技术的基本原理是通过修改目标进程的内存空间，将恶意DLL文件加载到目标进程的地址空间中，并在目标进程的执行流中插入钩子，以实现对目标进程的控制。
DLL注入技术可以绕过系统的安全机制，实现对系统资源的非法调用和利用。
二、DLL注入技术的分类1.进程注入：将恶意DLL注入到指定的进程中，实现对该进程的操控。
进程注入可以分为远程注入和本地注入两种方式。
远程注入是通过远程线程注入技术，将DLL注入到远程主机中的目标进程中；本地注入是在本地系统中将DLL注入到目标进程中。
2.线程注入：将恶意DLL注入到目标线程中，以实现对线程的控制和操控。
线程注入可以分为远程线程注入和本地线程注入两种方式。
远程线程注入是通过在目标进程中创建远程线程，将DLL注入到目标线程中；本地线程注入是在当前进程中的线程中将DLL注入到目标线程中。
三、DLL注入技术的应用1.行为监控：通过将恶意DLL注入到目标进程中，可以监控目标进程的行为，获取目标进程的敏感信息，如密码、账号、通信内容等。
2.进程劫持：通过将恶意DLL注入到目标进程中，可以劫持目标进程的执行流，实现对目标进程的控制和操控。
进程劫持可以用于木马病毒的传播，实现对目标系统的远程控制。
3.代码注入：通过将恶意DLL注入到目标进程中，可以修改目标进程的代码逻辑，实现对目标进程的控制。
代码注入可以用于修改目标程序的功能，增加或删除一些功能，或实现其他违规操作。
四、DLL注入技术的防范1.使用安全开发规范：开发人员在编写程序时，应遵循安全开发规范，尽量避免使用不安全的API函数和接口，从根源上避免DLL注入的发生。
2.加强进程间通信的安全性：加强进程间通信的安全性，防止恶意DLL通过进程间通信传播。
DLL的11种注入方法
闲着没事整理了一下DLL的N种注入方法，对学习外挂的朋友，应该有用！第一种方法：利用CreateRemoteThread 远程建立线程的方式注入DLL．首先，我们要提升自己的权限，因为远程注入必不可免的要访问到目标进程的内存空间，如果没有足够的系统权限，将无法作任何事．下面是这个函数是用来提升我们想要的权限用的．function EnableDebugPriv : Boolean;varhToken : THANDLE;tp : TTokenPrivileges;rl : Cardinal;beginresult := false;//打开进程令牌环OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES or TOKEN_QUERY, hToken);//获得进程本地唯一IDif LookupPrivilegeValue(nil, 'SeDebugPrivilege',tp.Privileges[0].Luid) thenbegintp.PrivilegeCount := 1;tp.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;//调整权限result := AdjustTokenPrivileges(hToken, False, tp,sizeof(tp), nil, rl);end;end;关于OpenProcessToken() 和AdjustTokenPrivileges() 两个API的简单介绍：OpenProcessToken()：获得进程访问令牌的句柄．function OpenProcessToken(ProcessHandle: THandle; //要修改访问权限的进程句柄DesiredAccess: DWORD; //指定你要进行的操作类型var TokenHandle: THandle): BOOL; //返回的访问令牌指针AdjustTokenPrivileges() ：调整进程的权限．function AdjustTokenPrivileges(TokenHandle: THandle; // 访问令牌的句柄DisableAllPrivileges: BOOL; // 决定是进行权限修改还是除能（Disable）所有权限const NewState: TTokenPrivileges; // 指明要修改的权限,是一个指向TOKEN_PRIVILEGES结构的指针，该结构包含一个数组，数据组的每个项指明了权限的类型和要进行的操作;BufferLength: DWORD; //结构PreviousState的长度,如果PreviousState为空，该参数应为0var PreviousState: TTokenPrivileges; // 指向TOKEN_PRIVILEGES结构的指针，存放修改前的访问权限的信息var ReturnLength: DWORD //实际PreviousState结构返回的大小) : BOOL;远程注入DLL其实是通过CreateRemoteThread 建立一个远程线程调用LoadLibrary 函数来加载我们指定的DLL，可是如何能让远程线程知道我要加载DLL呢，要知道在Win32系统下，每个进程都拥有自己的4G虚拟地址空间，各个进程之间都是相互独立的。
32位进程注入64位进程和32位进程
Win7 64下32位进程注入64位进程和32位进程1. 32位进程注入32位dll到32位进程win7以来CreateRemoteThread加入了session隔离的概念，因此单纯的调用CreateRemoteThread会在某些情况下出错。
解决办法是调用比CreateRemoteThread更底层的NtCreateThread。
具体见代码了。
至于NtCreateThread的一个参数为什么是0x1fffff, windbg 调试CreateRemoteThread在NtCreateThread下个断点，看参数就知道了，它就在那里，没有为什么。
代码在这里：/wxdvc/article/details/8116193原理：远程线程注入是这样的,首先在当前运行的进程中找到目标进程，然后将我们的dll的内容写入目标进程的私有空间中，最后通过关键的API：CreateRemoteThread创建线程。
该线程只执行一个任务：loadlibrary加载我们的dll。
下面通过实例解释，例子中注入的进程是“explorer.exe”（个人认为玩弄这个进程异常的舒爽~~~~吼吼吼吼~~~~~~）具体实现：1.找到目标原理简单，我们首先获得目前时刻正在运行的进程的列表，然后通过遍历搜索，找到列表中我们想要的进程，然后记录下进程的ID号。
hProcessSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);这个函数用来获得当前进程的快照。
（啪！说人话！）哦，就是获得当前进程的列表啊。
然后通过下面的代码按顺序遍历这个列表，通过字符串对比，找到我们的目标：explorer.exe。
上代码！[cpp]view plaincopy1.//获取目标进程的ID2. if(Process32First(hProcessSnap,&pe32)) //获取第一个进程3. {4. do{5.char te[MAX_PATH];6. strcpy(te,pe32.szExeFile);7. if(strcmp(te, INJECT_PROCESS_NAME) == 0)8. {9. dwRemoteProcessId=pe32.th32ProcessID;10. printf("%d\n",dwRemoteProcessId);11. break;12. }13. }14. while(Process32Next(hProcessSnap,&pe32));//获取下一个进程15. }16. else17. {18. return -1;19. }找到目标进程后，用dwRemoteProcessId记录下进程ID。
线程注入原理
线程注入原理全文共四篇示例，供读者参考第一篇示例：线程注入原理是指在计算机程序运行过程中，利用特定的技术手段向目标进程中注入一个线程，从而达到修改目标进程内部状态、窃取敏感信息等目的的一种攻击手法。
线程注入是一种常见的恶意软件攻击技朧，被广泛应用于计算机病毒、间谍软件、后门等恶意程序中。
线程注入的实现原理主要包括以下几个步骤：定位目标进程、创建注入线程、注入线程代码、执行注入线程。
具体来说，线程注入过程可以分为如下几个关键步骤：1. 定位目标进程：在进行线程注入之前，需要首先定位目标进程。
通过遍历系统中所有进程，寻找目标进程的进程标识符（PID），获取目标进程的句柄（handle），以便后续的注入操作。
2. 创建注入线程：接下来，利用系统API或其他相关工具，创建一个新的线程，并将目标进程的句柄与新线程进行关联。
新线程即为将要注入到目标进程中的恶意线程。
3. 注入线程代码：在创建完毕注入线程后，需要将恶意代码注入到新线程中。
恶意代码可以是实现特定功能的Shellcode或其他恶意程序代码。
这些代码可以用于获取敏感信息、执行恶意操作或者窃取目标进程的数据。
4. 执行注入线程：最后一步是执行注入线程。
将恶意线程注入到目标进程中，并通过线程调度器调度执行。
一旦注入线程被执行，恶意代码就会开始在目标进程的上下文中运行，实现对目标进程的攻击目的。
线程注入原理虽然可以实现一些恶意功能，但同时也具有一定的风险和局限性。
在实际应用中，线程注入可能会被杀毒软件、防火墙等安全工具检测到并拦截，从而无法顺利地执行。
另外，由于线程注入会直接修改目标进程的内部状态，存在导致目标程序崩溃或异常退出的风险，因此需要慎重使用。
总的来说，线程注入原理是一种常见的恶意攻击手法，通过向目标进程中注入恶意线程实现对目标进程的攻击。
在进行防范时，可以通过安全软件、补丁及权限控制等措施，有效减少线程注入攻击的发生。
同时，对于开发人员来说，在编写程序时应该严格控制进程间通信的权限，并对用户输入、外部调用等进行充分的检查和过滤，以防止恶意线程的注入。
游戏进程注入和DX后台原理剖析
游戏进程注入和DX后台原理剖析这2个要一起讲，因为真正的dx后台（dx转gdi除外），是需要注入游戏进程的注入游戏进程有多种方式，输入法注入，网络注入，注册表注入都先不说了，先说一下常用的首先，Hook，所使用的API setwindowshookex，百度或者MSDN，最好查MSDN，比较详细随便用个消息注入进程，你就可以在游戏当中做任何事情了，其中有个参数作为回调函数传入，也就是当收到消息的时候首先做我们回调函数中的事情，函数原型如下：LRESULT CALLBACK HookProc(int nCode,WPARAM wParam,LPARAM lParam);HookProc是回调函数名。
nCode参数是Hook代码，Hook子程使用这个参数来确定任务。
这个参数的值依赖于Hook类型，每一种Hook都有自己的Hook代码特征字符集。
wParam和lParam参数的值依赖于Hook代码，但是它们的典型值是包含了关于发送或者***消息的信息另外一种常用方法就是远程线程了，使用API createremotethread该函数的原型如下：HANDLE CreateRemoteThread(HANDLE hProcess,LPSECURITY_ATTRIBUTES lpThreadAttributes,SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);参数说明：hProcess：目标进程的句柄lpThreadAttributes：指向线程的安全描述结构体的指针，一般设置为NULL，表示使用默认的安全级别dwStackSize：线程堆栈大小，一般设置为0，表示使用默认的大小，一般为1MlpStartAddress：线程函数的地址lpParameter：线程参数dwCreationFlags：线程的创建方式CREATE_SUSPENDED 线程以挂起方式创建lpThreadId：输出参数，记录创建的远程线程的ID好了，注入先介绍这二种，现在我们已经进入游戏进程当中了，然后我们看下真正感兴趣的DX的后台其实原理很简单，拦截dx接口函数，就是让dx的函数在执行之前或之后，首先执行我们的代码，比如你要读写屏，肯定要在其之前Hook，比如你要发送键盘鼠标消息，那就要在DInput的获取数据接口执行之后，替换其数据，让其传出我们的数据，就可以达到后台DX 键盘或者鼠标了只是现在DX相关文档有点少，我下面罗列出几个关键的接口，只要Hook了下面的几个接口，那么后台鼠标键盘，后台抓图，写屏，降cpu等等，都不是问题了首先我们来看DDraw，你要知道D3d是对DDraw的继承，因此我们先来看DDraw，对于2D游戏来说，我们Hook哪里才能得到图像呢？当然是blt,和fastblt，通常fastblt得到的往往是构成屏幕的一部分图片，比如角色，背景等等单一图片，因此从blt中可以得到内存画面表面，也就能完全抓到后台图像了，顺便说一下，主表面就是显示器表面，有人曾经说dx直接写屏，因此不可能后台，这有一定的道理，因为如果你Hook了主表面，那么游戏被什么挡住，也就会抓到什么图，因此要Hook到内存表面才行，在其显示之前，就将其读出，我是用Delphi做的，用Delphi的人也比较少，具体代码我就不写了，感兴趣的欢迎组个团队，大家一起做项目然后我们再来看D3d，这个可以通过Hook present来读取，当然还可以降CPU，写屏等等，和DDraw同理最后是对DInput的hook，鼠标和键盘以及手柄都是通过这个来获取数据的，hook目标：GetDeviceData,GetDeviceState，一个缓冲模式，一个立即模式，键盘，鼠标，手柄数值统统按照常量，定义在DX SDK头文件中，可以参考我发布那个DX后台键盘插件压缩包中的说明文件所有这些必须在目标进程当中进行，否则，就不能截获到正确的数据这种做法是有一些弊端的，首先修改游戏内存是侵犯著作法的，呵呵，我也是听Leo说的，您可能心里想，这谁管那么多？呵呵，那么我们说点更实际的，NP有的是不能Hook的，过NP也有很多手段，比如恢复API，暴力破解等等，我不想研究也不太喜欢那种东西，最初我软件常常被破解，不过我很希望跟喜欢这种事情的人合作，后来的加密也是破解组织的人帮我指导的！看过《编程高手箴言》的，可能些印象，dll在内存中映射来映射去，很容易出问题，这种情况尤其在游戏多开的时候可能还有一部分人不太明白，而高手一看就知道该怎么做了，希望能够抛砖引玉，大家多多讨论最后预告一下后面一段时间我将要发布的插件，*DLL注入插件（将您的DLL注入到目标进程，让你的脚本也能达到wai挂效果），*DX后台抓图插件，*降CPU插件，*DX写屏插件就这样吧，我不是太喜欢做破解方面的事情，欢迎喜欢这种事情的人与我合作！如果将脚本注入到游戏中可以使用前台命令实现后台找图和鼠标键盘操作.脚本注入，呵呵，有点创意，dll能注入，脚本也能注入，dll中只要包含脚本解释器即可，只是前台命令变后台效果，并非你想象的那么简单，注入也未必能够实现，让我想想脚本注入之后会有什么比较好的呢？首先速度快，其次读写内存方便，直接调用游戏Call也方便"dll在内存中映射来映射去，很容易出问题，这种情况尤其在游戏多开的时候"出问题??ms不会没想到这些问题的,同一应用程序在内存中有多个实例的时候,那多个实例就会共享这个应用程序的代码页和数据页,也就是同一份代码页和数据页内存会映射到多个实例进程中,似乎就跟内存共享一样,但不是其中一个修改都会被修改,然后就会导致出问题的,被映射到多个进程的同一块内存会被设置copy on write属性的,顾名思义就是在内存修改的时候自己进程就会有一份拷贝,就是避免你说的游戏多开的时候会出问题呵呵,怪不得你不是很了解破解者方面,想要破解或者说是逆向这方面肯定会去了解系统底层的,系统机制就是其中一方面...。
dll 注入 传递 参数
dll 注入传递参数
DLL注入是一种常见的技术，用于向另一个进程中注入自定义的动态链接库（DLL）。
这种技术通常用于修改或增强目标进程的行为，比如监视其活动、记录日志、甚至修改其内部数据。
传递参数是指在注入DLL时向目标进程传递额外的信息或指令，以便DLL能够根据这些参数执行特定的操作。
在进行DLL注入时，传递参数通常通过以下几种方式实现：
1. 注册表或配置文件，在注入DLL之前，可以将需要传递的参数写入注册表或配置文件中，然后在DLL中读取这些参数来执行相应的操作。
2. 远程线程参数，在注入DLL时，可以将参数作为远程线程的参数传递给目标进程，然后在DLL中获取这些参数并进行处理。
3. 环境变量，将参数设置为环境变量，然后在DLL中读取这些环境变量来获取参数信息。
4. 命令行参数，在启动目标进程时，可以将参数作为命令行参
数传递给目标进程，然后在DLL中获取这些参数并进行处理。
无论采用哪种方式，传递参数都需要考虑安全性和可靠性。
确
保传递的参数经过验证和过滤，以防止恶意注入或不良影响目标进
程的稳定性。
另外，需要注意不同操作系统和目标进程的架构可能
会对传递参数的方式产生影响，需要根据具体情况进行调整和适配。
总之，DLL注入传递参数是一项复杂的技术，需要仔细考虑目
的和安全性，并根据具体情况选择合适的实现方式。
cobalt strike的注入手法
cobalt strike的注入手法
Cobalt Strike是一种渗透测试工具，用于模拟和评估网络攻击。
该工具具有多种注入技术，以实现对目标系统的控制和渗透。
以下是Cobalt Strike的一些常见注入手法：
1. 注入系统进程：Cobalt Strike可以使用系统进程（如explorer.exe）来进行注入，以绕过防火墙和杀毒软件的检测。
这种手法通常可以通过DLL注入、进程替换等技术实现。
2. 注入服务进程：Cobalt Strike可以注入已经运行的服务进程，以获取系统权限或执行恶意操作。
这种手法可以通过修改服务配置、DLL注入等方式来实现。
3. 注入用户进程：Cobalt Strike可以通过欺骗用户或通过漏洞利用，将恶意代码注入到用户进程中，以获取用户权限或执行特定任务。
4. 注入浏览器进程：Cobalt Strike可以利用浏览器漏洞，将恶意代码注入到目标浏览器进程中，以获取用户信息、执行恶意操作等。
需要注意的是，以上注入手法都需要具备一定的技术功底，并且在实际渗透测试中应遵守法律和道德规范。
使用Cobalt Strike进行渗透测试时，应事先获得授
权，并确保在合法的范围内使用。
syringe.exe用法
syringe.exe用法Syringe.exe是一个通用的注射工具，它可以用来执行各种注射操作。
通常，它被用来注入代码或者动态链接库(DLL)文件到一个特定的进程中，来修改进程的行为。
Syringe.exe可以用于多种目的，比如调试和修改程序。
在这篇文章中，我将一步一步地向您介绍Syringe.exe的用法和相关的注射操作。
如果您是一个初学者，不用担心，我会尽力让这个过程简单易懂。
让我们开始吧！第一步：下载和安装Syringe.exe首先，您需要从可信赖的网站下载Syringe.exe。
确保选择一个与您的操作系统兼容的版本。
下载完成后，运行安装程序，并按照提示完成安装。
第二步：选择目标进程在注射之前，您需要选择一个目标进程。
目标进程是您要向其中注入代码或DLL文件的进程。
您可以在Syringe.exe的界面上选择目标进程，或者通过指定进程ID的方式选择。
第三步：选择注入方法接下来，您需要选择一个合适的注入方法。
Syringe.exe通常支持多种注入方法，比如远程线程注入、加载器注入和代码注入。
每种方法都有自己的优点和适用场景，选择正确的注入方法对于注射的成功非常重要。
第四步：选择注入载荷在选择注入方法之后，您需要选择一个注入载荷。
注入载荷是您要注入到目标进程中的代码或DLL文件。
Syringe.exe支持多种载荷类型，比如二进制文件、源代码或者动态链接库文件。
根据您的需求选择合适的载荷。
第五步：配置注射参数接下来，您需要配置注射的参数。
这些参数包括进程ID、载荷路径、载荷类型以及其他注射相关的选项。
确保您提供正确的参数，以便Syringe.exe能够成功地执行注射操作。
第六步：执行注射操作当所有的参数都配置好之后，您可以点击“注射”按钮来执行注射操作。
Syringe.exe将会根据您提供的参数，将代码或DLL文件注入到目标进程中。
同时，Syringe.exe还会生成一个注射日志，用于记录注射操作的结果和任何可能出现的错误。
sandboxie注入原理
sandboxie注入原理Sandboxie注入原理解析Sandboxie是一款先进的隔离环境软件，它允许用户在计算机中创建一个虚拟的隔离空间，以防止恶意软件对计算机系统的攻击。
它的注入原理是通过在操作系统内核层级创建一个虚拟环境，将应用程序隔离开来，使得恶意软件无法对操作系统进行修改或破坏。
当用户在Sandboxie中运行一个应用程序时，Sandboxie会将该应用程序隔离在一个虚拟的环境中。
这个虚拟环境与操作系统的真实环境相互独立，它拥有自己的文件系统、注册表和进程空间。
这样，当应用程序运行时，它只能在虚拟环境中进行操作，而无法对操作系统的真实环境产生任何影响。
在Sandboxie的注入原理中，有两个关键概念：进程注入和文件重定向。
进程注入是指Sandboxie将应用程序的运行进程注入到虚拟环境中，使得应用程序只能在虚拟环境中运行。
文件重定向是指Sandboxie将应用程序对文件的读写操作重定向到虚拟环境中的文件系统，而不是操作系统的真实文件系统。
具体来说，当用户在Sandboxie中运行一个应用程序时，Sandboxie 首先会创建一个与该应用程序相对应的虚拟环境。
然后，Sandboxie 会将应用程序的运行进程注入到虚拟环境中，并将该进程与真实环境中的进程隔离开来。
在应用程序运行时，Sandboxie会监控它对文件的读写操作，并将这些操作重定向到虚拟环境中的文件系统。
通过这种注入原理，Sandboxie实现了对应用程序的隔离保护。
无论应用程序是否受到恶意软件的感染，它都无法对操作系统的真实环境产生任何影响。
即使应用程序执行了恶意操作或者被感染了病毒，也只会在虚拟环境中造成影响，而不会对操作系统造成实质性的破坏。
Sandboxie的注入原理是通过在操作系统内核层级创建一个虚拟环境，将应用程序隔离开来，使得恶意软件无法对操作系统进行修改或破坏。
它通过进程注入和文件重定向来实现应用程序的隔离保护，确保计算机系统的安全性和稳定性。
dll注入原理
DLL注入原理简介在计算机领域中，DLL（Dynamic Link Library，动态链接库）是一种包含函数、数据和资源的可执行文件。
DLL注入是一种技术，它允许一个进程将其代码注入到另一个进程的地址空间中，以便在目标进程中运行自定义代码。
DLL注入在软件开发、系统调试、恶意软件分析等领域具有重要的应用。
DLL注入的原理DLL注入的基本原理是将一个DLL文件注入到目标进程的地址空间中，并强制目标进程加载并执行该DLL文件中的代码。
DLL注入一般分为以下几个步骤：1. 选择目标进程在进行DLL注入之前，首先需要选择一个目标进程，即将要注入的进程。
目标进程可以是任何正在运行的进程，但需要注意的是必须具有足够的权限来修改目标进程的地址空间。
2. 创建远程线程在注入DLL之前，需要在目标进程中创建一个远程线程。
远程线程是在一个进程的上下文中运行的线程，可以通过API函数创建。
3. 加载DLL文件将DLL文件加载到目标进程的地址空间中。
可以使用API函数LoadLibrary来实现DLL文件的加载。
这个函数将返回DLL模块的基地址，即加载到目标进程的内存中的DLL的起始地址。
4. 获取加载的DLL模块句柄通过GetModuleHandle函数获取之前加载的DLL模块的句柄，以便后续调用DLL模块中的函数。
5. 获取函数地址通过GetProcAddress函数获取DLL模块中需要调用的函数的地址。
可以通过函数名或者函数的序号来查找函数地址。
6. 执行注入代码在远程线程中执行注入代码，即调用DLL模块中的函数。
通过在远程线程的上下文中设置指令指针为DLL模块中函数的地址，从而实现注入。
7. 清理注入在注入代码执行完毕后，需要进行注入的清理工作。
可以通过远程线程发送指令给目标进程，使之从其地址空间中卸载已经注入的DLL模块。
DLL注入的技术实现DLL注入可以通过各种技术手段来实现，下面介绍几种常用的DLL注入技术：1. LoadLibrary注入LoadLibrary注入是一种常见的DLL注入技术，它通过调用目标进程的LoadLibrary函数来加载DLL文件。
sandboxie注入原理
sandboxie注入原理
Sandboxie是一款Windows平台的沙盘工具，主要用于实现进程隔离和保护系统资源。
其注入原理主要通过以下几个方面来实现：
1. 驱动程序注入：Sandboxie驱动程序（SbieDrv.sys）通过直接挂钩内核对象（如类型、进程、线程等）来实现对内核资源的访问控制。
此外，它还会拦截一些系统调用，如OpenProcedure，以控制文件磁盘访问和注册表操作。
2. DLL注入：Sandboxie会向沙盒中的进程注入一个名为SbieDll的动态链接库。
这个DLL会挂钩沙盒进程中所有的重要API，如ZwCreateFile、ZwOpenKey等，从而控制进程对系统资源的访问。
当沙盒中的进程尝试访问系统资源时，SbieDll会将请求转发给Sandboxie驱动程序进行审批。
3. 消息钩子：为了控制窗口消息，Sandboxie驱动程序会拦截一些窗口消息，如win32kNtUserCallHwndParamLock、win32kNtUserDestroyWindow等。
通过这种方式，Sandboxie可以阻止沙盒中的进程发送或接收某些窗口消息，从而保护系统不受恶意代码的影响。
4. 进程监控：Sandboxie驱动程序会维护一个列表，用于存储所有已知的沙盒进程。
当一个新的进程被创建时，如果其父进程是沙盒进程，那么新进程也会被添加到这个列表中。
这样，Sandboxie就可以监控沙盒中的进程活动，并拒绝非沙盒进程访问沙盒资源。
通过以上原理，Sandboxie能够实现对沙盒内进程的严格控制，确保沙盒与外部系统的隔离性。
在安全测试、病毒检测、软件开发等领域具有广泛的应用。
演讲稿当代大学生如何在实现中华民族伟大复兴中国梦进程中注入青春能量
亲爱的老师、同学们:大家好!今天我演讲的题目是《中国梦,我的梦》，什么是梦?什么是中国梦?历史的点点滴滴如散落在偌大沙滩上的沙石贝壳,我悄悄走过，贪婪地看着这些晶莹宝贵的财富，时而拾起一两颗打动心灵的贝壳，寄出一份梦想，蹲下投放。
中国梦,流淌在岁月。
沙滩_上有一颗饱经沧桑的贝壳, 那是中国遥遥五千年的故事。
从黄帝开创历史到如今的我们诵读历史，我看到太多太多的事迹，每个中国人都拥有着同样的中国梦。
富强!富强!中国梦的口号在继续。
中国梦流淌过每个日日夜夜、每个中国人的内心。
不管有多大的困难，地震、泥石流、洪灾,还是会有饱经沧桑后成功的微笑。
俱往矣,数风流人物,还看今朝。
收藏岁月流淌过的每--个中国梦, 战于世，立一生之梦沙滩上有一颗闪亮的贝壳，那是中国奥运会、世博、嫦娥_二号成功发射的故事。
当-阵阵掌声雷鸣般响起，当世界举目投足于中国时，我知道，中国的光芒已散发在世界的每一一个角落。
中国梦还在继续，我们的视线还在执着，默默献上自己微薄的力量。
这是一个梦,一个叫作中国梦, -个被每一个中国人所深呼的梦。
我以心的维度仰视奖牌下每一个奋斗的身影,倾听每一声临近中国梦的足音,俯身捧起岁月流淌过的荣誉,扬手敬礼，大声喊出自己的中国梦。
沙滩上有一颗铭记的贝壳，那是羁旅在外的中国人的故事。
我清楚的看到，有人客于异国，却随身带着中国的泥土，有人在奥运会直播前呐喊中国万岁，有人在参加外国记者采访时说:”我是中国人，我们都共有一-个梦,她叫中国梦!”是的,那就是我们的中国梦，-份信仰，--份怀念，--份奋斗, 到处都迷漫着中国梦的味道。
就算在异国他乡，我们都还能轻哼着国歌的旋律，心怀着祖国，铭记着中国梦，力创美好未来。
潮起潮落,我坐在偌大的沙滩上，看着眼前正在富强的中国，阳光透过云彩照射在我身上。
我站了起来，嘴角轻轻咧开，怀着一份坚强，一份荣耀，一份铭记,轻轻拾起几颗贝壳，珍藏在身,勉励自己，心中已准备好，种下中国梦,创造美好的未来。
chaosblade 原理
chaosblade 原理
Chaosblade 是一种用于模拟系统故障和性能问题的工具，可以帮助开发人员和运维人员测试系统的稳定性和可靠性。
其原理主要分为两个方面：
1. 进程注入：Chaosblade 通过在目标进程中注入代码，来模拟系统故障和性能问题。
它使用了不同的注入技术，例如 Linux 的动态链接器（LD_PRELOAD）、编译器插桩（Clang/LLVM）或者使用 gdb 调试工具。
通过注入自定义的代码，Chaosblade 可以在目标进程中执行特定的行为，例如延迟系统调用、模拟IO错误、模拟CPU异常等。
2. 系统调用挂钩：Chaosblade 还可以通过挂钩系统调用的方式来模拟系统故障和性能问题。
它使用Linux内核提供的ptrace
机制来截获目标进程的系统调用，并在执行系统调用之前或之后插入自定义的行为。
通过挂钩系统调用，Chaosblade 可以模拟一些常见的故障情况，例如拒绝服务攻击、网络延迟、文件IO错误等。
总之，Chaosblade 主要通过进程注入和系统调用挂钩的方式，模拟系统故障和性能问题。
通过这些模拟，可以帮助开发人员和运维人员测试和验证系统的鲁棒性和可靠性，以提高系统的稳定性和可靠性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程注入#pragma comment(lib,"ntdll.lib")typedef long NTSTA TUS;NTSYSAPI NTSTATUS NTAPI ZwUnmapViewOfSection( HANDLE ProcessHandle, PVOID BaseAddress );typedef struct _ChildProcessInfo{DWORD dwBaseAddress;DWORD dwReserve;} CHILDPROCESS;char szIePath[MAX_PATH];BOOL FindIePath(char *IePath,int *dwBuffSize);BOOL InjectProcess(void);DWORD GetSelfImageSize(HMODULE hModule);BOOL CreateInjectProcess(PPROCESS_INFORMA TION pi,PCONTEXT pThreadCxt,CHILDPROCESS *pChildProcess);int main(void){if (InjectProcess() ){printf("This is my a test code,made by shadow3.\r\n");}else{MessageBox(NULL,"进程插入完成","Text",MB_OK);}return 0;}BOOL FindIePath(char *IePath,int *dwBuffSize){char szSystemDir[MAX_PA TH];GetSystemDirectory(szSystemDir,MAX_PATH);szSystemDir[2] = '\0'lstrcat(szSystemDir,"\\Program Files\\Internet Explorer\\iexplore.exe");lstrcpy(IePath, szSystemDir);return TRUE;}BOOL InjectProcess(void){char szModulePath[MAX_PATH];DWORD dwImageSize = 0;STARTUPINFO si = {0};PROCESS_INFORMA TION pi;CONTEXT ThreadCxt;DWORD *PPEB;DWORD dwWrite = 0;CHILDPROCESS stChildProcess;LPVOID lpVirtual = NULL;PIMAGE_DOS_HEADER pDosheader = NULL;PIMAGE_NT_HEADERS pVirPeHead = NULL;HMODULE hModule = NULL;ZeroMemory(szModulePath,MAX_PATH);ZeroMemory(szIePath,MAX_PA TH);GetModuleFileName(NULL,szModulePath,MAX_PA TH); FindIePath(szIePath,NULL);if ( lstrcmpiA(szIePath,szModulePath) == 0 ){return FALSE;}hModule = GetModuleHandle(NULL);if ( hModule == NULL ){return FALSE;}pDosheader = (PIMAGE_DOS_HEADER)hModule;pVirPeHead = (PIMAGE_NT_HEADERS)((DWORD)hModule + pDosheader->e_lfanew); dwImageSize = GetSelfImageSize(hModule);if ( CreateInjectProcess(&pi, &ThreadCxt ,&stChildProcess) ){printf("CHILD PID: [%d]\r\n",pi.dwProcessId);if ( ZwUnmapViewOfSection(pi.hProcess,(LPVOID)stChildProcess.dwBaseAddress) == 0 ){lpVirtual = VirtualAllocEx(pi.hProcess,(LPVOID)hModule,dwImageSize,MEM_RESERVE │MEM_COMMIT, PAGE_EXECUTE_READWRITE);if ( lpVirtual ){printf("Unmapped and Allocated Mem Success.\r\n");}}else{printf("ZwUnmapViewOfSection() failed.\r\n");return TRUE;}if ( lpVirtual ){PPEB = (DWORD *)ThreadCxt.Ebx;// 重写装载地址WriteProcessMemory(pi.hProcess,&PPEB[2],&lpVirtual,sizeof(DWORD),&dwWrite);if ( WriteProcessMemory(pi.hProcess,lpVirtual,hModule,dwImageSize,&dwWrite) ){printf("image inject into process success.\r\n");ThreadCxt.ContextFlags = CONTEXT_FULL;if ( (DWORD)lpVirtual == stChildProcess.dwBaseAddress ){ThreadCxt.Eax = (DWORD)pVirPeHead->OptionalHeader.ImageBase + pVirPeHead->OptionalHeader.AddressOfEntryPoint;}else{ThreadCxt.Eax = (DWORD)lpVirtual + pVirPeHead->OptionalHeader.AddressOfEntryPoint;}#ifdef DEBUGprintf("EAX = [0x%08x]\r\n",ThreadCxt.Eax);printf("EBX = [0x%08x]\r\n",ThreadCxt.Ebx);printf("ECX = [0x%08x]\r\n",ThreadCxt.Ecx);printf("EDX = [0x%08x]\r\n",ThreadCxt.Edx);printf("EIP = [0x%08x]\r\n",ThreadCxt.Eip);#endifSetThreadContext(pi.hThread, &ThreadCxt);ResumeThread(pi.hThread);}else{printf("WirteMemory Failed,code:%d\r\n",GetLastError());TerminateProcess(pi.hProcess, 0);}}else{printf("VirtualMemory Failed,code:%d\r\n",GetLastError()); TerminateProcess(pi.hProcess, 0);}}return TRUE;}DWORD GetSelfImageSize(HMODULE hModule){DWORD dwImageSize;_asm{mov ecx,0x30mov eax, fs:[ecx]mov eax, [eax + 0x0c]mov esi, [eax + 0x0c]add esi,0x20lodsdmov dwImageSize,eax}return dwImageSize;}BOOL CreateInjectProcess(PPROCESS_INFORMA TION pi,PCONTEXT pThreadCxt,CHILDPROCESS *pChildProcess){STARTUPINFO si = {0};DWORD *PPEB;DWORD read;// 使用挂起模式启动ieif( CreateProcess(NULL,szIePath,NULL,NULL,0,CREATE_SUSPENDED,NULL,NULL,&si,pi) ){pThreadCxt->ContextFlags = CONTEXT_FULL; GetThreadContext(pi->hThread, pThreadCxt);PPEB = (DWORD *)pThreadCxt->Ebx;// 得到ie的装载基地址ReadProcessMemory(pi->hProcess,&PPEB[2],(LPVOID)&(pChildProcess->dwBaseAddress), sizeof(DWORD),&read);return TRUE ;}return FALSE;}////////////////////////////////////////// HookApi_JMP.h//使用JMP法写的一个HOOK API的类#include#ifndef _HOOK_API_JMP_#define _HOOK_API_JMP_class CHookApi_Jmp{public:HANDLE hProc;void Unlock(void);void Lock(void);BOOL Initialize(LPCTSTR ModuleName, LPCTSTR ApiName, FARPROC lpNewFunc); void SetHookOn(void);void SetHookOff(void);CHookApi_Jmp(void);virtual ~CHookApi_Jmp();protected:BYTE m_OldFunc[8];BYTE m_NewFunc[8];FARPROC m_lpHookFunc;CRITICAL_SECTION m_cs;};#endif//---------------------------------------------------------------------------#pragma hdrstop#include "HookApi_JMP.h"#pragma package(smart_init)//---------------------------------------------------------------------------CHookApi_Jmp::CHookApi_Jmp(void){InitializeCriticalSection(&m_cs);}//---------------------------------------------------------------------------CHookApi_Jmp::~CHookApi_Jmp(){CloseHandle(hProc);DeleteCriticalSection(&m_cs);}//---------------------------------------------------------------------------void CHookApi_Jmp::SetHookOn(void){DWORD dwOldFlag;if(VirtualProtectEx(hProc,m_lpHookFunc,5,PAGE_READWRITE,&dwOldFlag)){if(WriteProcessMemory(hProc,m_lpHookFunc,m_NewFunc,5,0)){if(VirtualProtectEx(hProc,m_lpHookFunc,5,dwOldFlag,&dwOldFlag))return;}}MessageBox(NULL,"SetHookOn","fail",MB_OK); return;}//---------------------------------------------------------------------------void CHookApi_Jmp::SetHookOff(void){DWORD dwOldFlag;if(VirtualProtectEx(hProc,m_lpHookFunc,5,PAGE_READWRITE,&dwOldFlag)){if(WriteProcessMemory(hProc,m_lpHookFunc,m_OldFunc,5,0)){if(VirtualProtectEx(hProc,m_lpHookFunc,5,dwOldFlag,&dwOldFlag))return;}} MessageBox(NULL,"SetHookOff","fail",MB_OK); return;}//---------------------------------------------------------------------------BOOL CHookApi_Jmp::Initialize(LPCTSTR ModuleName, LPCTSTR ApiName, FARPROC lpNewFunc){m_lpHookFunc = GetProcAddress(GetModuleHandle(ModuleName),ApiName);hProc = GetCurrentProcess();DWORD dwOldFlag;if(VirtualProtectEx(hProc,m_lpHookFunc,5,PAGE_READWRITE,&dwOldFlag)){if(ReadProcessMemory(hProc,m_lpHookFunc,m_OldFunc,5,0)){if(VirtualProtectEx(hProc,m_lpHookFunc,5,dwOldFlag,&dwOldFlag)){m_NewFunc[0]=0xe9;DWORD*pNewFuncAddress;pNewFuncAddress=(DWORD*)&m_NewFunc[1];*pNewFuncAddress=(DWORD)lpNewFunc-(DWORD)m_lpHookFunc-5;return TRUE;}}} return FALSE;}//---------------------------------------------------------------------------void CHookApi_Jmp::Lock(void) //多线程下使用{EnterCriticalSection(&m_cs);}//---------------------------------------------------------------------------void CHookApi_Jmp::Unlock(void){LeaveCriticalSection(&m_cs);}//---------------------------------------------------------------------------。