注入进程

合集下载

进行DLL注入的三种方法

进行DLL注入的三种方法
在WINDOWS中,每个进程都有自己独立的地址空间,这样一个应用程序就无法进入另一个进程的地址空间而不会破坏另一个进程的运行,这样使得系统更加的稳定。但这样一来,相反的,如果我们要对我们感兴趣的进程进行操作也就变得复杂起来。比如,我们要为另一个进程创建的窗口建立子类或是要想从其中一个感兴趣的进程中取得一些有趣的信息(比如你想得到WIN2000用户登录的密码)。而DLL注入技术就是正好可以解决这些问题。DLL注入就是将DLL插入到其它你指定的进程的地址空间中,使得我们可以对感兴趣的进程进行操作。
}
//---------------------------------------
// 安装钩子函数
bool __declspec(dllexport) __stdcall SetHook(DWORD dwThreadId)
{
if (dwThreadId != 0)
{
// 因为没有适当的工具可以取得线程ID,也为了简单起见,所以这里新创建了一个记事本进程,以便取得它的线程ID,对其安装钩子,把我们的DLL注入到记事本进程中。
bRet = CreateProcess(NULL,
"c:\\winnt\\system32\\notepad.exe",
}
return true;
}
// 钩子函数
LRESULT CALLBACK __declspec(dllexport) __stdcall
MyProc(int nCode, WPARAM wParam, LPARAM lParam)
{
// 因为只是演示DLL注入,所以这里什么也不做,交给系统处理
return;

dll注入原理

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文件。

动态修改其它进程的代码,实现DLL注入

动态修改其它进程的代码,实现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被正确加载,目标进程现在是你的了,随便玩吧.。

cobalt strike的注入手法

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进行渗透测试时,应事先获得授
权,并确保在合法的范围内使用。

chaosblade 原理

chaosblade 原理

chaosblade 原理
Chaosblade 是一种用于模拟系统故障和性能问题的工具,可以帮助开发人员和运维人员测试系统的稳定性和可靠性。

其原理主要分为两个方面:
1. 进程注入:Chaosblade 通过在目标进程中注入代码,来模拟系统故障和性能问题。

它使用了不同的注入技术,例如 Linux 的动态链接器(LD_PRELOAD)、编译器插桩(Clang/LLVM)或者使用 gdb 调试工具。

通过注入自定义的代码,Chaosblade 可以在目标进程中执行特定的行为,例如延迟系统调用、模拟IO错误、模拟CPU异常等。

2. 系统调用挂钩:Chaosblade 还可以通过挂钩系统调用的方式来模拟系统故障和性能问题。

它使用Linux内核提供的ptrace
机制来截获目标进程的系统调用,并在执行系统调用之前或之后插入自定义的行为。

通过挂钩系统调用,Chaosblade 可以模拟一些常见的故障情况,例如拒绝服务攻击、网络延迟、文件IO错误等。

总之,Chaosblade 主要通过进程注入和系统调用挂钩的方式,模拟系统故障和性能问题。

通过这些模拟,可以帮助开发人员和运维人员测试和验证系统的鲁棒性和可靠性,以提高系统的稳定性和可靠性。

木马注入远程进程

木马注入远程进程

个我多个 d ( u 动志 链接库)文件。 自从
来,动志链接库一直是其基础.Wid ws no AI P 中的所有函数都包含在D L 。 个最 L中 3
重要的DL 是Ken 3 .l、 s r2 dl L r d 2 dl U e3 .l 和
I tl Al De] 合键 .也就看不到该程 Mirs f 公司推出 Wid ws 作系统以 C r+ t + 1 组 c oo t no 操
步骤 :
( 用 F n d W d 1 ) i in O W 和
lSa t d es/ 线程开始执行的地址 p trAd rs, / L V D lP rmee , / 向传给 P OI p aa tr/ 指 线程函数的变量
维普资讯
木 马注入远程进程
李银兵’ 闰敬
I 唐 山 学院 计算 中 0  ̄ 0 6 00 2 .唐 山 师范 学 院计 算机 科 学 系 0 5 0 5O0
干个线 程 ,线 程是操 作系统 分配处 理器
时间的 基本单 位 ,一个线程 是一个 执行
I2 rl i 。Ken l2 d 包含用于管理内 re3 .l l X /0 0 P 2 0 的任务管理器.Wid ws X / n o P GD 3 .l 20 的任务管理器均能轻 世显示 出木 马进 存, 00 进程 和线程的各个函数I s r2 山l e 3 . 包 U
含用于执行用 户界面任务 ( 如宙 口的创建 和消总. 的传送 ) 的各个函数, DI2叫 包 G 3. 现在 有很 多木马程 序 .有的 术马是 使用进 程注入技 术实现 隐藏 ,进程注 入 含用于画 图和 显示文本 的各个函数 DLL由多个功能 函数构 成,它不能 恶意 的 ,盗窃 用 户的关 键 信息和 材 料 , 技术是将 自己的代码嵌八到正运行的进程 n o 中不同进程间的地 拽立运行 , 一 般都是 由其它 进程加 载并 甚至给 用户带来经济上的损失。大部分木 的技 术。在 Wi d ws L 文件不能独立运行.所 马在进程查看器 中看不到 ,所以查杀木马 址空阃是 隔离的 ,每 个进程 都有 自己的 调用的 因为 D L L ,假设有 不太容 易,其 中进程的隐藏是木马比较关 私有内 存地址 空间 ,一 个进 程无法 访问 以在进程列表中井不会出现 D L 个木 马DL 通过 别的进程来运行它 . 1, 那 键的技术。奉文探 讨了木马的隐 藏技术, 另一个进 程的 内存地址 空间 ,如果 要编 使读者掌握木马隐藏的原理 .从而使读者 写能够 与其他进 程进行 通信 的程序 ,或 么无论是入侵检测软 件还是进程 列表 中. 可以 用时发现木马并将其清除 ,有效地保 者能够对其他进程进行操作的应用程序将 都 只会 出现宿 主进程 而并不 会出现木 马 例如 要困难得 多。 但仍有 多种方 法可以打 破 DLL,如果高 主进 程是可信 进程 ( 护 自己的资料和信息 。 X L RE E E , L 进程 的界 限 ,访问 另一个进 程的地址 空 E P O R. X ) 那 幺木马DL 作 为宿

linux 进程注入原理

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位进程

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函数地址。

常见的十种代码注入技术

常见的十种代码注入技术

常见的⼗种代码注⼊技术Process injection is a widespread defense evasion technique employed often within malware and fileless adversary tradecraft, and entails running custom code within the address space of another process. Process injection improves stealth, and some techniques also achieve persistence. Although there are numerous process injection techniques, in this blog I present ten techniques seen in the wild that run malware code on behalf of another process. I additionally provide screenshots for many of these techniques to facilitate reverse engineering and malware analysis, assisting detection and defense against these common techniques.进程注⼊是⼀种⼴泛使⽤的躲避检测的技术,通常⽤于恶意软件或者⽆⽂件技术。

其需要在另⼀个进程的地址空间内运⾏特制代码,进程注⼊改善了不可见性,同时⼀些技术也实现了持久性。

尽管⽬前有许多进程注⼊技术,但在这篇⽂章中,我将会介绍⼗种在野发现的,在另⼀个程序的地址空间执⾏恶意代码的进程注⼊技术,并提供这些技术应⽤的截图,以便于逆向⼯程和恶意软件分析,然后协助检测并防御这些进程注⼊技术。

DLL注入技术应用研究

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的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虚拟地址空间,各个进程之间都是相互独立的。

dll 注入 传递 参数

dll 注入 传递 参数

dll 注入传递参数
DLL注入是一种常见的技术,用于向另一个进程中注入自定义的动态链接库(DLL)。

这种技术通常用于修改或增强目标进程的行为,比如监视其活动、记录日志、甚至修改其内部数据。

传递参数是指在注入DLL时向目标进程传递额外的信息或指令,以便DLL能够根据这些参数执行特定的操作。

在进行DLL注入时,传递参数通常通过以下几种方式实现:
1. 注册表或配置文件,在注入DLL之前,可以将需要传递的参数写入注册表或配置文件中,然后在DLL中读取这些参数来执行相应的操作。

2. 远程线程参数,在注入DLL时,可以将参数作为远程线程的参数传递给目标进程,然后在DLL中获取这些参数并进行处理。

3. 环境变量,将参数设置为环境变量,然后在DLL中读取这些环境变量来获取参数信息。

4. 命令行参数,在启动目标进程时,可以将参数作为命令行参
数传递给目标进程,然后在DLL中获取这些参数并进行处理。

无论采用哪种方式,传递参数都需要考虑安全性和可靠性。


保传递的参数经过验证和过滤,以防止恶意注入或不良影响目标进
程的稳定性。

另外,需要注意不同操作系统和目标进程的架构可能
会对传递参数的方式产生影响,需要根据具体情况进行调整和适配。

总之,DLL注入传递参数是一项复杂的技术,需要仔细考虑目
的和安全性,并根据具体情况选择合适的实现方式。

shellcode注入执行技术学习

shellcode注入执行技术学习

shellcode注⼊执⾏技术学习shellcode 注⼊执⾏技术学习注⼊执⾏⽅式CreateThreadCreateRemoteThreadQueueUserAPCCreateThread是⼀种⽤于执⾏Shellcode的技术,⽽CreateRemoteThread和QueueUserAPC是Shellcode注⼊的形式。

以下是使⽤三种不同技术运⾏shellcode的过程的⾼级概述CreateThreadAllocate memory in the current processCopy shellcode into the allocated memoryModify the protections of the newly allocated memory to allow execution of code from within that memory spaceCreate a thread with the base address of the allocated memory segmentWait on the thread handle to return翻译:1、在当前进程中分配内存2、将shellcode复制到分配的内存中3、修改新分配的内存的保护,以允许从该内存空间中执⾏代码4、⽤分配的内存段的基地址创建⼀个线程5、等待线程句柄返回⽰例代码:// dllmain.cpp : 定义 DLL 应⽤程序的⼊⼝点。

#include "stdafx.h"#include<windows.h>#include<iostream>HANDLE My_hThread = NULL;unsigned char shellcode[] = "shellcode"; //CS或msf⽣成的shellcodeDWORD WINAPI ceshi(LPVOID pParameter){__asm{mov eax, offset shellcodejmp eax}return 0;}BOOL APIENTRY DllMain( HMODULE hModule,DWORD ul_reason_for_call,LPVOID lpReserved){switch (ul_reason_for_call){case DLL_PROCESS_ATTACH://初次调⽤dll时执⾏下⾯代码My_hThread = ::CreateThread(NULL, 0, &ceshi, 0, 0, 0);//新建线程case DLL_THREAD_ATTACH:case DLL_THREAD_DETACH:case DLL_PROCESS_DETACH:break;}return TRUE;}extern"C" _declspec(dllexport) void test(){int a;a = 0;}CreateRemoteThreadGet the process ID of the process to inject intoOpen the target processAllocate executable memory within the target processWrite shellcode into the allocated memoryCreate a thread in the remote process with the start address of the allocated memory segment翻译:1、获取要注⼊的进程的进程ID2、打开⽬标进程3、在⽬标进程内分配可执⾏内存4、将shellcode写⼊分配的内存5、使⽤分配的内存段的起始地址在远程进程中创建线程⽰例代码:#include "stdafx.h"#include <Windows.h>#include<stdio.h>#include "iostream"//隐藏运⾏程序时的cmd窗⼝#pragma comment( linker, "/subsystem:windows /entry:mainCRTStartup" )using namespace std;//使⽤CS或msf⽣成的C语⾔格式的上线shellcodeunsigned char shellcode[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2...........";BOOL injection(){wchar_t Cappname[MAX_PATH] = { 0 };STARTUPINFO si;PROCESS_INFORMATION pi;LPVOID lpMalwareBaseAddr;LPVOID lpnewVictimBaseAddr;HANDLE hThread;DWORD dwExitCode;BOOL bRet = FALSE;//把基地址设置为⾃⼰shellcode数组的起始地址lpMalwareBaseAddr = shellcode;//获取系统路径,拼接字符串找到calc.exe的路径GetSystemDirectory(Cappname, MAX_PATH);_tcscat(Cappname, L"\\calc.exe");//打印注⼊提⽰// printf("被注⼊的程序名:%S\r\n", Cappname);ZeroMemory(&si, sizeof(si));si.cb = sizeof(si);ZeroMemory(&pi, sizeof(pi));//创建calc.exe进程if (CreateProcess(Cappname, NULL, NULL, NULL,FALSE, CREATE_SUSPENDED//CREATE_SUSPENDED新进程的主线程会以暂停的状态被创建,直到调⽤ResumeThread函数被调⽤时才运⾏。

游戏进程注入和DX后台原理剖析

游戏进程注入和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属性的,顾名思义就是在内存修改的时候自己进程就会有一份拷贝,就是避免你说的游戏多开的时候会出问题呵呵,怪不得你不是很了解破解者方面,想要破解或者说是逆向这方面肯定会去了解系统底层的,系统机制就是其中一方面...。

线程注入原理

线程注入原理

线程注入原理全文共四篇示例,供读者参考第一篇示例:线程注入原理是指在计算机程序运行过程中,利用特定的技术手段向目标进程中注入一个线程,从而达到修改目标进程内部状态、窃取敏感信息等目的的一种攻击手法。

线程注入是一种常见的恶意软件攻击技朧,被广泛应用于计算机病毒、间谍软件、后门等恶意程序中。

线程注入的实现原理主要包括以下几个步骤:定位目标进程、创建注入线程、注入线程代码、执行注入线程。

具体来说,线程注入过程可以分为如下几个关键步骤:1. 定位目标进程:在进行线程注入之前,需要首先定位目标进程。

通过遍历系统中所有进程,寻找目标进程的进程标识符(PID),获取目标进程的句柄(handle),以便后续的注入操作。

2. 创建注入线程:接下来,利用系统API或其他相关工具,创建一个新的线程,并将目标进程的句柄与新线程进行关联。

新线程即为将要注入到目标进程中的恶意线程。

3. 注入线程代码:在创建完毕注入线程后,需要将恶意代码注入到新线程中。

恶意代码可以是实现特定功能的Shellcode或其他恶意程序代码。

这些代码可以用于获取敏感信息、执行恶意操作或者窃取目标进程的数据。

4. 执行注入线程:最后一步是执行注入线程。

将恶意线程注入到目标进程中,并通过线程调度器调度执行。

一旦注入线程被执行,恶意代码就会开始在目标进程的上下文中运行,实现对目标进程的攻击目的。

线程注入原理虽然可以实现一些恶意功能,但同时也具有一定的风险和局限性。

在实际应用中,线程注入可能会被杀毒软件、防火墙等安全工具检测到并拦截,从而无法顺利地执行。

另外,由于线程注入会直接修改目标进程的内部状态,存在导致目标程序崩溃或异常退出的风险,因此需要慎重使用。

总的来说,线程注入原理是一种常见的恶意攻击手法,通过向目标进程中注入恶意线程实现对目标进程的攻击。

在进行防范时,可以通过安全软件、补丁及权限控制等措施,有效减少线程注入攻击的发生。

同时,对于开发人员来说,在编写程序时应该严格控制进程间通信的权限,并对用户输入、外部调用等进行充分的检查和过滤,以防止恶意线程的注入。

syringe.exe用法

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还会生成一个注射日志,用于记录注射操作的结果和任何可能出现的错误。

electron 注入方法

electron 注入方法

electron 注入方法
在Electron中,注入方法通常指的是在渲染进程中向主进程或
者Node.js环境中注入代码或函数的过程。

这种注入方法可以实现
渲染进程和主进程之间的通信,以及在渲染进程中执行一些需要特
权访问的操作。

一种常见的注入方法是使用`ipcRenderer`和`ipcMain`模块进
行进程间通信。

通过这种方式,渲染进程可以向主进程发送消息,
主进程也可以向渲染进程发送消息。

这种双向通信的机制可以用来
实现注入代码或者函数的目的。

另一种常见的注入方法是使用`remote`模块,它允许渲染进程
直接调用主进程中的模块和方法。

通过这种方式,可以在渲染进程
中直接调用主进程中的功能,实现代码的注入。

除此之外,还可以通过`webContents.executeJavaScript`方法
来在渲染进程中执行JavaScript代码,从而实现对渲染进程的注入。

总的来说,Electron中的注入方法是通过进程间通信和直接调
用主进程的方法来实现的,开发者可以根据具体的需求选择合适的
注入方法来实现代码或函数的注入。

这样可以实现更灵活和强大的Electron应用程序。

进程注入原理

进程注入原理

进程注入原理
嘿,朋友们!今天咱来聊聊进程注入原理。

这玩意儿啊,就像是一场奇妙的魔术表演!
你想啊,一个程序就像一个小世界,它自己在那运行得好好的。

可突然,就有别的东西神不知鬼不觉地溜进去了,还能在里面捣鼓一番。

这是不是很神奇?
进程注入呢,简单来说,就是让一些代码偷偷摸摸地钻进正在运行的进程里面。

这就好比你正在家里安静地看电视呢,突然有人没打招呼就从窗户爬进来了,还在你家走来走去。

这怎么能行呢?
它的方法有很多呢。

比如说,有直接把代码塞进去的,就像硬塞给别人一个东西一样。

还有通过一些巧妙的手段,让进程自己稀里糊涂地就把外来代码给接纳了。

这就好像用花言巧语哄得别人心甘情愿地让你进去。

那为啥要搞这个进程注入呢?哎呀,这用处可大了去了!有时候是为了给程序加点新功能,就像给汽车加装个新零件似的,让它跑得更快更稳。

但要是被坏人利用了,那可就糟糕啦!他们能偷偷摸摸地搞破坏,窃取信息啥的,这可真是让人头疼啊!
咱就说,这进程注入要是用好了,那是如虎添翼;要是用坏了,那可就是大祸临头啊!就像一把锋利的刀,在厨师手里能做出美味佳肴,在坏人手里那可就是凶器了。

你说这进程注入是不是很有意思?它就像个隐藏在程序世界里的小精灵,一会儿好一会儿坏的。

咱可得把它给搞清楚,不能让它随便捣乱呀!不然咱的电脑、手机啥的不就遭殃了吗?
所以啊,大家一定要多了解了解进程注入原理,知道怎么防范那些坏家伙利用它来搞坏事。

别等到自己的宝贝设备出了问题才后悔莫及呀!这可不是开玩笑的,这关系到咱的信息安全、财产安全呢!大家可都得上点心啊!别不当回事儿!
原创不易,请尊重原创,谢谢!。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

标题: 一种注入进程,获得完全操控的方法之一作者: menting时间: 2007-12-05 17:26链接: /showthread.php?t=56036详细信息:好长时间没贴东西了,今天就来贴点东西,废话就不说了直接进入主题,喜欢的就支持,不喜欢的就看乐和!!今天说点什么呢~我们今天就说HOOK,实际提到这个大家都知道它的功用,如果要是抓取消息那肯定是用下面的函数://----------------------------------------------------------------------::SetWindowsHookA(int nFilterType,HOOKPROC pfnFilterProc);::CallNextHookEx(HHOOK hhk,int Code,WPARAM wParam,LPARAM lParam); ::UnhookWindowsHook(int nCode,HOOKPROC pfnFilterProc);//它们的参数我就不说了,实在是太多了!!//---------------------------------------------------------------------------今天我就给大家说一种别的方法来抓取WINDOWS消息的方法,这种方法虽然有点局限性,但是我感觉很不错的哦!用我的方法,可以抓取一个进程中的所有窗口的消息。

不信就跟我一体来试试,如果看不太明白,那只好去学学相关知识了。

我们选择的方法就是HOOK API的方法。

很多朋友都说网络上流传的HOOK API的很多,但是我碰到的都是HOOK那个MessageBoxA函数,没什么意思,今天我就给大家一个全能的方法,我们不用了解太多PE结构,非要在IAT表中修改,我们先来看看我们要处理的API为:/*------------------------------------------------------------------------------------函数原型:LRESULT CallWindowProc(WNDPROC lpPrevWndFunc,HWND hWnd.UINT Msg,WPARAM wParam,LPARAM IParam);参数:lpPrevWndFunc:指向前一个窗口过程的指针。

如果该值是通过调用GetWindowLong函数,并将该函数中的nlndex参数设为GWL_WNDPROC或DWL_DLGPROC而得到的,那么它实际上要么是窗口或者对话框的地址,要么就是代表该地址的句柄。

hWnd:指向接收消息的窗口过程的句柄。

Msg:指定消息类型。

wParam:指定其余的、消息特定的信息。

该参数的内容与Msg参数值有关。

IParam:指定其余的、消息特定的信息。

该参数的内容与Msg参数值有关。

返回值:返回值指定了消息处理结果,它与发送的消息有关-----------------------------------------------------------------------------------*/我想一般对这个函数,比较陌生点,用的人就不多了,就像我有时用ntdll.dll 中LdrGetDllHandle这类函数一样。

因为它的功能很多时候都不用知道的:)。

我们为了能抓到消息,而且不用HOOK这类API函数,我们要在这个函数上做手脚,或许可以对DefWindowProc()这个函数也做手脚,但是我想我要一个就可以了呵呵!因为我这里举例是用自定义消息为例子的,为什么要用自定义消息呢!我还想说明一点问题就是远程注入进程。

实际对于一个进程来讲,只要给它放个DLL那么它就不得不听你的了,我们可以给这个DLL发送一些命令,让它按照命令来操作我们的目标进程。

有的时候我就特别的喜欢‘该死’,他做的系统就给我们一个空间,也就是0x400-0x7FF是为用户自定义的消息,我们就可以用如下的方法来设置命令:#define WM_CMD_EXIT WM_USER+100 //退出进程#define WM_CMD_GETHWND WM_USER+101 //获取HWND句柄#define WM_CMD_GETCAPTION WM_USER+102 //获取窗口名称……等等,我们还可以调用进程的内部函数,让进程做我们想让它做的。

实际就举个例子来将,发给命令过去,让QQ不断显示广告,或定时显示广告,我们几乎就完全操作了进程了。

如果没道德,想抓取别人的隐私,那也是顺手而已。

可是我在发这篇贴的时候,还是想过是否要发,因为我觉得我手里的东西就是把双刃剑,能杀这边,也能杀那边。

希望学会的朋友都不要把它用于搞破坏上。

注入进程的方法太多了,我就不说了,我把它写了一个类,大家就可以拿去直接用了。

//注意的是,路径是绝对路径,才能给其它进程注入。

//----------------------------------------------------------------------------// RemoteShell.h: interface for the CRemoteShell class./////////////////////////////////////////////////////////////////////// /#if !defined(AFX_REMOTESHELL_H__6242FFA8_B8E3_4F9A_BE7D_197F76A78D03_ _INCLUDED_)#define AFX_REMOTESHELL_H__6242FFA8_B8E3_4F9A_BE7D_197F76A78D03__INCL UDED_#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000#include "tlhelp32.h"#pragma comment(lib,"th32.lib")class CRemoteShell{public:CRemoteShell();virtual ~CRemoteShell();public:public:CString m_dllPath;DWORD pId;DWORD dwSize;LPVOID pDll;HANDLE hDll;HANDLE hToken;HANDLE hProcess;LUID Luid;TOKEN_PRIVILEGES tp;public:int Release(DWORD procId=NULL);int Load(LPCTSTR dllpath,DWORD pId=NULL); //进程注入int Load(LPCTSTR dllpath,HWND hWnd); //窗口注入HANDLE GetDllHandle(LPCTSTR path,DWORD pid);};#endif // !defined(AFX_REMOTESHELL_H__6242FFA8_B8E3_4F9A_BE7D_197F76A 78D03__INCLUDED_)//-------------------------------------------------------------------------------------------// RemoteShell.cpp: implementation of the CRemoteShell class./////////////////////////////////////////////////////////////////////// /#include "stdafx.h"#include "注入程序.h"#include "RemoteShell.h"#ifdef _DEBUG#undef THIS_FILEstatic char THIS_FILE[]=__FILE__;#define new DEBUG_NEW#endif///////////////////////////////////////////////////////////////////// /// Construction/Destruction///////////////////////////////////////////////////////////////////// /CRemoteShell::CRemoteShell(){hToken =NULL;hProcess=NULL;memset(&tp,0,sizeof(TOKEN_PRIVILEGES));//取得句柄的令牌:if (!OpenProcessToken(GetCurrentProcess(), //是要修改访问权限的进程句柄TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, //指定你所需要的操作类型 &hToken)) //是返回的访问令牌指针{return ;}//获取权限的LUID值:if (!LookupPrivilegeValue(NULL, //系统的名称,如果是本地系统只要指明为NULL就可以了SE_DEBUG_NAME, //指明了权限的名称&Luid)) //返回LUID的指针{return ;}tp.PrivilegeCount = 1;tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;tp.Privileges[0].Luid = Luid;//访问令牌进行修改:if (!AdjustTokenPrivileges(hToken, //访问令牌的句柄0, //决定是进行权限修改还是除能(Disable)所有权限&tp, //指明要修改的权限,指向TOKEN_PRIVILEGES结构的指针,该结构包含一个数组,数据组的每个项指明了权限的类型和要进行的操作sizeof(TOKEN_PRIVILEGES), //是结构PreviousState的长度,如果PreviousState为空,该参数应为NULLNULL, //参数也是一个指向TOKEN_PRIVILEGES结构的指针,存放修改前的访问权限的信息,可空NULL)) //实际PreviousState结构返回的大小{return ;}}CRemoteShell::~CRemoteShell(){if(hToken!=NULL){::CloseHandle(hToken);}if(hProcess!=NULL){::CloseHandle(hProcess);}}//注入给指定进程:int CRemoteShell::Load(LPCTSTR dllpath,DWORD pId){hProcess =NULL;pDll =NULL;m_dllPath =dllpath;//如果指定进程ID为NULL,就注入给自己.if(pId==NULL){pId=::GetCurrentProcessId();}//打开进程:hProcess=::OpenProcess(PROCESS_CREATE_THREAD|PROCESS_VM_WRITE|PROCE SS_VM_OPERATION,1,pId);if(hProcess==NULL){return -20;}//分配内存:pDll=::VirtualAllocEx(hProcess,NULL,strlen(dllpath),MEM_COMMIT,PA GE_READWRITE);if(pDll==NULL){return -21;}//注入DLL:BOOL bRe=::WriteProcessMemory(hProcess,pDll,(void*)dllpath,strlen (dllpath),NULL);if(bRe==FALSE){return -22;}//获取LoadLibraryA函数地址:FARPROC pLoadDll=GetProcAddress(GetModuleHandle("kernel32.dll")," LoadLibraryA");if(pLoadDll==NULL){return -23;}//创建线程:HANDLE hRemote=CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START _ROUTINE)pLoadDll,pDll,NULL,0);//等待线程结束:::WaitForSingleObject(hRemote,INFINITE);if(hRemote!=NULL){::CloseHandle(hRemote);}if(hProcess!=NULL){::CloseHandle(hProcess);}return 0;}//注入给指定程序句柄的进程:int CRemoteShell::Load(LPCTSTR dllpath,HWND hWnd)hProcess =NULL;pDll =NULL;pId =NULL;m_dllPath =dllpath;if(hWnd!=NULL){::GetWindowThreadProcessId(hWnd,&pId);}//如果指定进程ID为NULL,就注入给自己.if(pId==NULL){pId=::GetCurrentProcessId();}//打开进程:hProcess=::OpenProcess(PROCESS_CREATE_THREAD|PROCESS_VM_WRITE|PROCE SS_VM_OPERATION,1,pId);if(hProcess==NULL){return -20;}//分配内存:pDll=::VirtualAllocEx(hProcess,NULL,strlen(dllpath),MEM_COMMIT,PA GE_READWRITE);if(pDll==NULL){return -21;}//注入DLL:BOOL bRe=::WriteProcessMemory(hProcess,pDll,(void*)dllpath,strlen (dllpath),NULL);if(bRe==FALSE){return -22;}//获取LoadLibraryA函数地址:FARPROC pLoadDll=::GetProcAddress(::GetModuleHandle("kernel32.dll "),"LoadLibraryA");if(pLoadDll==NULL){return -23;}//创建线程:HANDLE hRemote=CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START_R OUTINE)pLoadDll,pDll,NULL,0);//等待线程结束:::WaitForSingleObject(hRemote,INFINITE);hDll=GetDllHandle(dllpath,pId);if(hRemote!=NULL){::CloseHandle(hRemote);}if(hProcess!=NULL){::CloseHandle(hProcess);}return 0;}int CRemoteShell::Release(DWORD procId){DWORD id=NULL;if(hDll==NULL){return -1;}if(pId!=NULL){id=pId;}if(procId!=NULL){id=procId;}if(id!=NULL){//打开进程:hProcess=::OpenProcess(PROCESS_CREATE_THREAD|PROCESS_VM_WRITE|PROCE SS_VM_OPERATION,1,pId);if(hProcess==NULL){return -20;}//FARPROC pGetDllHandle=GetProcAddress(GetModuleHandle("ntdll.dll") ,"LdrGetDllHandle");//获取FreeLibraryA函数地址:FARPROC pFreeDll=GetProcAddress(GetModuleHandle("kernel32.dll")," FreeLibrary");if(pFreeDll==NULL){return -23;}//创建线程:HANDLE hRemote=::CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START_ROUTINE)pFreeDll,hDll,NULL,0);//等待线程结束:::WaitForSingleObject(hRemote,INFINITE);::VirtualFreeEx(hProcess,pDll,0,MEM_RELEASE);if(hRemote!=NULL){::CloseHandle(hRemote);}if(hProcess!=NULL){::CloseHandle(hProcess);}}else{AfxMessageBox("进程号为空!无法释放!");}return 0;}HANDLE CRemoteShell::GetDllHandle(LPCTSTR path,DWORD pid){if(pid==NULL){pid=::GetCurrentProcessId();}//打开进程:int num=0;BOOL bRe=FALSE;HANDLE hModule=NULL;MODULEENTRY32* minfo=new MODULEENTRY32;if(NULL!=pid){hModule=CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,pid);bRe=Module32First(hModule, minfo);for(;bRe!=0;num++){if(lstrcmp(minfo->szExePath,path)==0||lstrcmp(minfo->szModule,p ath)==0){return minfo->modBaseAddr;}bRe=::Module32Next(hModule,minfo);}}::CloseHandle(hModule);return NULL;}//----------------------------------------------------------------------------------------------我们用上面的类就可以轻松的把一个DLL注入到别的进程,并且还可以轻松的释放。

相关文档
最新文档