进程防注入代码（注入系统进程）

今天给各位分享进程防注入代码的知识，其中也会对注入系统进程进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、防止某个进程被注入，应该怎么设置呢
• 2、易语言进程反注入源码
• 3、Delphi注入进程代码
• 4、怎么防止远程线程注入
• 5、MFC/VC++进程自我保护（通过远程线程注入或HOOK）
• 6、怎么防止目标进程被dll注入

防止某个进程被注入，应该怎么设置呢

某个进程被注入？你确定是被注入么？你如果能发现这点的话证明你电脑会不少，但是这个也应该会啊……网上有一款软件，能锁定注册列表，直到你主动取消为止！但是名字我忘记了……你可以搜索一下试试

易语言进程反注入源码

进程是否存在 (“dnf.exe”) .如果真 (bool) 输入法.激活 (取句柄2 (输入法.清除注入 (取特定目录 (10) ＋“\\Sougoo.ime”) 输入法.卸载 (

Delphi注入进程代码

可以注入的, 只要先找到进程的句柄,注意OpenProcess时的权限,然后用VirtualAllocEx 远程分配内存保存代码块, 再用CreateRemoteThread 建远程执行并WaitForSingleObject等待运行完毕返回就OK了,这里有一个远程注入代码块, 并卸载目标进程已加载的DLL的代码,贴给你吧: 卸载非本进程的DLL模块 - Pascal

编辑 | 删除 | 权限设置 | 更多▼ 设置置顶

推荐日志

转到私密记事本

楚天 发表于2007年08月13日 23:49 阅读(69) 评论(3)

分类： Pascal 权限: 公开

这些都是牛人们玩剩的东东了,再写在这里意义不大!

但对于我这等菜鸟还得努力学习学习..没什么技术含

量, 但搜索了许久, 都没找到一个完整的Pascal版代

码, 所以自己试着参考牛人的网文DIY了一个.献丑了!

//*********************************************************

unit UntFreeRemoteLibrary; interface uses Windows, Dialogs; //此结构体用于保存线程注入函数的各项参数

type

lpParameters = ^TParameters;

TParameters = record

P_FreeLibrary :Cardinal;

P_GetModuleHandle :Cardinal;

P_TargetLibName :array[0..MAX_PATH] of Char;//:pChar;

end; implementation //将注入远程进程执行的函数代码

//必须在传入lpParameters结构体指针之前填充两个函数指针及目标DLL名

function FreeRemoteLib(Param :lpParameters):Boolean;stdcall;

type

pGetModuleHandle = function(hLibrary :pChar):Cardinal;stdcall;

pFreeLibrary = function(hLibrary :Cardinal):Boolean;stdcall;

var

pGetModHandle :pGetModuleHandle;

pFreeLib :pFreeLibrary;

hLib :Cardinal;

begin

pGetModHandle := pGetModuleHandle(Param^.P_GetModuleHandle); //得到 GetModuleHandle 的地址

hLib := pGetModHandle(Param^.P_TargetLibName); //调用 GetModuleHandle 返回DLL的句柄

pFreeLib := pFreeLibrary(Param^.P_FreeLibrary); //得到 FreeLibrary 的地址

result := pFreeLib(hLib); //调用 FreeLibrary 将DLL卸载

end;

// 将远程进程内的DLL卸载掉!

// 参数一为进程ID, 参数二为目标进程的DLL模块名

function FreeRemoteLibrary(pId:Cardinal; strLibName:String):Boolean;

var

hProc :Cardinal;

lpParam :Pointer;

lpProc :Pointer;

Parameters :TParameters;

hKernel32 :Cardinal;

wt :Cardinal;

hThread :Cardinal;

Const

NULL = 0;

begin

result := false;

if pId = NULL then

begin

ShowMessage('“进程ID”无效！');

exit;

end;

//得到进程句柄, 注意 dwDesiredAccess 的权限

hProc := OpenProcess(PROCESS_ALL_ACCESS, FALSE, pId);

if hProc = NULL then

begin

ShowMessage('获取“进程句柄”失败！');

exit;

end;

//分配存放参数的内存

lpParam := VirtualAllocEx(hProc, nil, SizeOf(Parameters), MEM_COMMIT, PAGE_READWRITE);

if lpParam = nil then

begin

CloseHandle(hProc);

ShowMessage('在远程进程地址空间内为线程函数分配“结构体参数”内存失败！');

exit;

end;

//分配存放函数的内存, 也可以定义一个空函数在FreeRemoteLib的后面.然后用地址求差得到FreeRemoteLib函数代码段长度

lpProc := VirtualAllocEx(hProc, nil, 5*1024, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

if lpProc = nil then

begin

VirtualFreeEx(hProc, lpParam, SizeOf(Parameters), MEM_DECOMMIT);

CloseHandle(hProc);

ShowMessage('在远程进程地址空间内为“线程注入函数”分配内存失败！');

exit;

end;

//初始化 Parameters 的地址

ZeroMemory(@Parameters, SizeOf(Parameters));

hKernel32 := GetModuleHandle(KERNEL32);

//传入两个函数指针

Parameters.P_GetModuleHandle := CARDINAL(GetProcAddress(hKernel32, 'GetModuleHandleA'));

Parameters.P_FreeLibrary := CARDINAL(GetProcAddress(hKernel32, 'FreeLibrary'));

//传入目标动态库的名

move(strLibName[1], Parameters.P_TargetLibName, Length(strLibName));

//向在远程进程新申请的地址空间写进数据结构

if not WriteProcessMemory(hProc, lpParam, @Parameters, SizeOf(Parameters), wt) then

begin

VirtualFreeEx(hProc, lpProc, 5*1024, MEM_DECOMMIT);

VirtualFreeEx(hProc, lpParam, SizeOf(Parameters), MEM_DECOMMIT);

ShowMessage('在远程进程地址空间内写入“结构体参数”失败！');

CloseHandle(hProc);

exit;

end;

//向在远程进程新申请的地址空间写进自定义代码段

if not WriteProcessMemory(hProc, lpProc, @FreeRemoteLib, 5*1024, wt) then

begin

VirtualFreeEx(hProc, lpProc, 5*1024, MEM_DECOMMIT);

VirtualFreeEx(hProc, lpParam, SizeOf(Parameters), MEM_DECOMMIT);

ShowMessage('在远程进程地址空间内写入“线程注入函数”失败！');

CloseHandle(hProc);

exit;

end;

//创建远程线程并传入数据结构的指针

hThread := CreateRemoteThread(hProc, nil, NULL, lpProc, lpParam, 0, wt);

if hThread = NULL then

begin

VirtualFreeEx(hProc, lpProc, 5*1024, MEM_DECOMMIT);

VirtualFreeEx(hProc, lpParam, SizeOf(Parameters), MEM_DECOMMIT);

ShowMessage('在远程进程地址空间内创建线程失败！');

CloseHandle(hProc);

exit;

end;

WaitForSingleObject(hThread, INFINITE); //挂起, 等待线程执行返回

VirtualFreeEx(hProc, lpProc, 5*1024, MEM_DECOMMIT); //内存回收工作

VirtualFreeEx(hProc, lpParam, SizeOf(Parameters), MEM_DECOMMIT);

CloseHandle(hProc);

result := true;

end;

怎么防止远程线程注入

流氓软件的技术五花八门，任何一项功能都有可能成为流氓技术，就象武器，用好了可以伸张正义，用歪了却成为罪恶的帮凶。

首先我从win32下的一些流氓着数分析开始:

1。我想做为一个流氓软件，首先要做到的是实时运行，譬如在注册表的run下，在boot下增加它的启动。这应该是比较老的方法，以前 3721好象就是在run下，但是现在一般的人都知道了。

2。作为流氓软件，已经改变了以前一些木马的特性了，他没必要使自己一定要实时启动了，而是需要自己的时候再启动，譬如说打开一个浏览器窗口，这是一般流氓软件的方法，因为他需要连上网才能有利益可图，所以浏览器肯定是流氓软件必定监控的进程。

3。使用BHO插件,这种技术早先特别流行，这是微软提供的接口，本意是让IE浏览器可以扩充功能。每当一个ie浏览器启动的时候，都会调用BHO下必要的插件，流氓软件就是利用这一点。监控了浏览器所有事件与信息。

4。还有最笨的办法就是利用进程快照监控进程，判断有它自己所监控的进程启动，就使用atl得到浏览器指针，从而监控浏览器所有事件与信息。

5，还有一种方法就是使用spi，这是我在网上看到的。spi是分层协议，当winsock2启动的时候都会调用它的dll,可以监控所有应用层数据包。从而监控用户信息，而且能实时启动。

6。hook方法，hook技术可以所应用太广泛了，特别是监控方面。所以流氓软件也不会错过。首先应用的是api函数hook，譬如windows核心编程里的apihook类，或者微软的detous都可以完成，两者方法其实相同就是修改IDT函数入口地址。api hook钩住createprocess 就可以监控进程，比进程快照性能更强，可以钩住spi下的函数可以完成spi下的所有功能。还有消息hook，鼠标消息，键盘消息，日子消息等等钩子，方法实在太多，都可以利用。

上面列举了一些流氓软件的使用方法，但是流氓软件的一个特性是他无法卸载。所以它又要使用下面的方法了

因为上面的很多方法都可以删除注册表卸载他们，那怎么办呢，那就会时时监控，它会在它的进程，或者线程里监控注册表项，设置一个循环监控，发现没了就继续安装，增加。我想这应该是很多流氓软件的技术。

那现在又出现了一个新问题，那就是流氓软件的进程线程要是结束掉怎么办呢???看西面

7。一种方法就是上面的api hook技术，钩住openprocess ,用自己的函数判断只要打开的是自己进程就返回正确，使用这种方法，用户或者一般的软件就无法结束它的进程了。

8。还有一种是上面象bho,spi根本没有进程。一般的用户也无法删除他

9。还有一种方法是远程线程，这个技术用的也很普遍，首先是象api hook一样向目标进程里申请一段内存空间，然后使用自己映射过去，然后使用CreateRemoteThread创建远程线程。一般很多流氓软件或者以前的一些木马程序，都是把线程注入到系统进程譬如explorer,service等等，使用用户或者一般的杀毒软件很难处理或者结束。。

10。注册成服务后，也可以简单的隐藏进程。还有更可笑的是把自己的进程名跟一些系统进程名譬如lsass相同后,也就无法结束了。

从我上面列举的方法已经差不多可以形成好几款流氓软件了。但是你别高兴太早，因为这些技术只是应用层的，现在出现了一堆驱动层的反流氓软件工具，譬如超级兔子，完美卸载，木马克星，雅虎助手，还有现在火热的360安全卫士。

这些反流氓软件的方法删除以上流氓软件软件就比较简单。优先于流氓软件启动，截获所有访问流氓软件文件的irp，然后删除注册表项，删除文件。轻松的完成了反流氓任务。

为了针对这些反流氓软件，流氓软件出现了内核层的了。

1。首先是使用文件过滤驱动，保护自己的文件，流氓软件过滤了create里对于自己文件的所有fileopen外的所有irp和SetInformation下所有的irp，从而有效的保护了自己的文件。

2。内核级hook技术，可hook住所有公开的或者未公开的内核函数，譬如zwcreatefile,zwSetInformation,也可以有效的保护文件。

3。驱动层下的流氓软件还使用内核级hook技术，替换Regdeletekey,RegDeleteValueKey,RegSetValueKey从而有效的保护了注册表

4。利用内核级hook技术还有隐藏进程，或者监控进程，重起进程。

对于上面的流氓软件的方法一些驱动层下的反流氓软件工具又有点束手无策了。因为同是驱动程序相互拦截irp等于大家都无法操作，反流氓软件工具的删除irp会被拦截，或者删除函数会被替换。删除注册表函数会被替换。虽然驱动的加载有先后，但是无法保证能完全的删除流氓软件，从而出现了一些更顶级的反流氓软件，他直接发删除文件irp到文件系统.,删除注册表也直接发送到文件系统。这类流氓软件又能有效的完成了反流氓任务，但是根据我了解，这样的软件不多。现在火热的360安全卫士都还只是使用了笨办法，优先于驱动流氓软件启动，创建一个驱动流氓软件同设备名的设备，，使流氓驱动创建不成功。具我了解他优先于流氓驱动启动是把自己创建于PNP_TDI这个组下面，就是简单的ndis就能优先于360启动。如果前面的组，那360就束手无策了。所以对付这类流氓驱动只能用直接发irp到文件系统。

流氓软件又怎么来防止直接发irp到文件系统的反流氓软件呢?rootkit,我看很多对于rootkit有误解，很多都认为hook也是rootkit.呵呵，rootkit说白了就是嵌入操作系统文件。你不是发irp到文件系统吗?，可是我把文件系统给改了，不过rootkit根据我的观察unix或者linex下比较多，在windows下还是比较少的，因为需要使用汇编了，哎太晚了，不写了，我想如果流氓软件做到这个技术程度，它也没必要做流氓了，直接做操作系统得了。

MFC/VC++进程自我保护（通过远程线程注入或HOOK）

//dll 代码:

#include windows.h

char pNew[8] = {0};

char pOld[8] = {0};

HMODULE hModu = NULL;

DWORD dwOldApi = 0;

void HookApiOn(char* pDllName, char* pApiName,FARPROC pFunc)

{

DWORD dwOld = 0;

DWORD flag = 0;

hModu = LoadLibrary(pDllName);

dwOldApi = (DWORD)GetProcAddress(hModu,pApiName);

VirtualProtect((LPVOID)dwOldApi,5,PAGE_READWRITE,dwOld);

char*p = (char*)dwOldApi;

DWORD dd = (DWORD)pFunc - dwOldApi -5 ; //jmp lebel:5个字节

pNew[0] = 0xE9;

*(DWORD*)(pNew[1]) = dd;

ReadProcessMemory(GetCurrentProcess(),(LPVOID)dwOldApi,(LPVOID)pOld,5,flag);

//memcpy((void*)pOld,(const void*)dwOldApi,5);

WriteProcessMemory(GetCurrentProcess(),(LPVOID)dwOldApi,(LPVOID)pNew,5,flag);

VirtualProtect((LPVOID)dwOldApi,5,dwOld,NULL);

return ;

}

void HookApiOff()

{

DWORD dwOld = 0;

DWORD flag = 0;

VirtualProtect((LPVOID)dwOldApi,5,PAGE_READWRITE,dwOld);

WriteProcessMemory(GetCurrentProcess(),(LPVOID)dwOldApi,(LPVOID)pOld,5,flag);

VirtualProtect((LPVOID)dwOldApi,5,dwOld,NULL);

return ;

}

void _stdcall my_MessageBoxW( HWND hWnd ,LPCWSTR lpText,LPCWSTR lpCaption,UINT uType)

{

HookApiOff();

if(IDNO == MessageBoxW(NULL,L"程序非法调用了MessageBoxW函数，是否阻止?",L"提示",MB_YESNO))

MessageBoxW(hWnd,lpText,lpCaption,uType);

HookApiOn("user32.dll","MessageBoxW",(FARPROC)my_MessageBoxW);

}

void InstallAllHook()

{

HookApiOn("user32.dll","MessageBoxW",(FARPROC)my_MessageBoxW);

return ;

}

BOOL APIENTRY DllMain( HANDLE hModule,

DWORD ul_reason_for_call,

LPVOID lpReserved

)

{

switch(ul_reason_for_call)

{

case DLL_PROCESS_ATTACH:

InstallAllHook();

break;

}

return TRUE;

//.exe实现进程注入的代码:此处注入到任务管理器中

#include windows.h

#include stdio.h

#define Dll_Name "F:\\workspqce\\Jmp_Hook\\Debug\\jmp_dll.dll"

BOOL EnablePrivilege()

{

HANDLE hToken = NULL;

if(OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,hToken))

{

TOKEN_PRIVILEGES tkp= {0};

LookupPrivilegeValue( NULL,SE_DEBUG_NAME,tkp.Privileges[0].Luid );//修改进程权限

tkp.PrivilegeCount=1;

tkp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;

AdjustTokenPrivileges( hToken,FALSE,tkp,sizeof tkp,NULL,NULL );//通知系统修改进程权限

return( (GetLastError()==ERROR_SUCCESS) );

}

return FALSE;

}

BOOL InjectDll(DWORD dwProcessId)

{

HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcessId);

if(!hProcess)

return FALSE;

LPVOID pszDllName = VirtualAllocEx(hProcess,NULL,strlen(Dll_Name)+1,MEM_COMMIT,PAGE_READWRITE);

if(!pszDllName)

return FALSE;

if(!WriteProcessMemory(hProcess,pszDllName,Dll_Name,strlen(Dll_Name),NULL))

return FALSE;

PTHREAD_START_ROUTINE tsr = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),"LoadLibraryA");

if(!tsr)

return FALSE;

HANDLE hRemote = CreateRemoteThread(hProcess,NULL,0,tsr,pszDllName,0,NULL);

if(!hRemote)

return FALSE;

WaitForSingleObject(hRemote,INFINITE);

VirtualFreeEx(hProcess,pszDllName,strlen(Dll_Name)+1,MEM_RELEASE);

return true;

}

int main()

{

DWORD dwProcessId = 0;

HWND hWindow = FindWindow(NULL,"Windows 任务管理器");

GetWindowThreadProcessId(hWindow,dwProcessId);

if(EnablePrivilege())

InjectDll(dwProcessId);

return 0;

}

怎么防止目标进程被dll注入

只要搞清楚什么是“注入”，和注入其它进程的方式，就知道怎么防御了。所谓注入，就是程序把自己的代码放到别的进程的地址空间去执行，来对这个进程进行操作，获得、修改进程的数据等。把自己的代码放入别的进程的地址空间，可以让别的进程加载自己的DLL，也可以直接在别的进程地址空间创建远程线程。进程注入的方法主要有：（1）修改HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs，全局注入DLL到所有使用User32.dll的进程；（2）消息钩子；（3）CreateRemoteThread；（4）Fake DLL。防（1），用RD；防（2）和（3），在AD里对应的是访问内存和钩子；防（4）一定程度上可以用FD。白+黑也是（4），但是没啥好办法防（无限弹窗流就不要说了）。

这是我的想法，我也才接触不久防止某进程被注入（武装该进程）也可以等于：阻止所有程序注入（去掉后来程序的武装）应用程序配置为： * ----（所有程序）自定义规则：全部允许 -----（程序可以做任何事）受保护的文件/目录 那一项的排除中 -----（程序唯独不能做这件事）阻止的文件/文件夹 选你要保护的那个进程想法而已，规则是不是这么写的 就不知道了我现在还开的学习模式，打算一直学习一周再开始使用

关于进程防注入代码和注入系统进程的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。