Logo



win32注入dll源码(win32 dll)

电脑报C:\WINNT\system32\services.exe:KERNEL32.LoadLibraryA缓冲区溢出是怎么回事?

win32注入dll源码你滴电脑被攻击拉!

估计你的已经成win32注入dll源码了肉鸡了!

具体的就是这个了!win32注入dll源码我复制的呵呵!希望对你有帮助

DLL的远程注入技术

作者:未知 文章来源:网络 点击数:198 更新时间:2006-3-23

DLL的远程注入技术是目前Win32病毒广泛使用的一种技术。使用这种技术的病毒体通常位于一个DLL中,在系统启动的时候,一个EXE程序会将这个DLL加载至某些系统进程(如Explorer.exe)中运行。这样一来,普通的进程管理器就很难发现这种病毒了,而且即使发现了也很难清除,因为只要病毒寄生的进程不终止运行,那么这个DLL就不会在内存中卸载,用户也就无法在资源管理器中删除这个DLL文件,真可谓一箭双雕哉。

记得2003年QQ尾巴病毒肆虐的时候,就已经有些尾巴病毒的变种在使用这种技术了。到了2004年初,我曾经尝试着仿真了一个QQ尾巴病毒,但独是跳过了DLL的远程加载技术。直到最近在学校论坛上看到了几位朋友在探讨这一技术,便忍不住将这一尘封已久的技术从我的记忆中拣了出来,以满足广大的技术爱好者们。

必备知识

在阅读本文之前,你需要了解以下几个API函数:

OpenProcess - 用于打开要寄生的目标进程。

VirtualAllocEx/VirtualFreeEx - 用于在目标进程中分配/释放内存空间。

WriteProcessMemory - 用于在目标进程中写入要加载的DLL名称。

CreateRemoteThread - 远程加载DLL的核心内容,用于控制目标进程调用API函数。

LoadLibrary - 目标进程通过调用此函数来加载病毒DLL。

在此我只给出了简要的函数说明,关于函数的详细功能和介绍请参阅MSDN。

示例程序

我将在以下的篇幅中用一个简单的示例Virus.exe来实现这一技术。这个示例的界面如下图:

首先运行Target.exe,这个文件是一个用Win32 Application向导生成的“Hello, World”程序,用来作为寄生的目标进程。

然后在界面的编辑控件中输入进程的名称“Target.exe”,单击“注入DLL”按钮,这时候Virus.exe就会将当前目录下的DLL.dll注入至Target.exe进程中。

在注入DLL.dll之后,你也可以单击“卸载DLL”来将已经注入的DLL卸载。

点这里下载示例程序

模拟的病毒体DLL.dll

这是一个简单的Win32 DLL程序,它仅由一个入口函数DllMain组成:

BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )

switch ( fdwReason )

case DLL_PROCESS_ATTACH:

MessageBox( NULL, _T("DLL已进入目标进程。"), _T("信息"), MB_ICONINFORMATION );

break;

case DLL_PROCESS_DETACH:

MessageBox( NULL, _T("DLL已从目标进程卸载。"), _T("信息"), MB_ICONINFORMATION );

break;

return TRUE;

如你所见,这里我在DLL被加载和卸载的时候调用了MessageBox,这是用来显示我的远程注入/卸载工作是否成功完成。而对于一个真正的病毒体来说,它往往就是处理DLL_PROCESS_ATTACH事件,在其中加入了启动病毒代码的部分:

case DLL_PROCESS_ATTACH:

StartVirus();

break;

注入!

现在要开始我们的注入工作了。首先,我们需要找到目标进程:

DWORD FindTarget( LPCTSTR lpszProcess )

DWORD dwRet = 0;

HANDLE hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );

PROCESSENTRY32 pe32;

pe32.dwSize = sizeof( PROCESSENTRY32 );

Process32First( hSnapshot, pe32 );

do

if ( lstrcmpi( pe32.szExeFile, lpszProcess ) == 0 )

dwRet = pe32.th32ProcessID;

break;

} while ( Process32Next( hSnapshot, pe32 ) );

CloseHandle( hSnapshot );

return dwRet;

这里我使用了Tool Help函数库,当然如果你是NT系统的话,也可以选择PSAPI函数库。这段代码的目的就是通过给定的进程名称来在当前系统中查找相应的进程,并返回该进程的ID。得到进程ID后,就可以调用OpenProcess来打开目标进程了:

// 打开目标进程

HANDLE hProcess = OpenProcess( PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, dwProcessID );

现在有必要说一下OpenProcess第一个参数所指定的三种权限。在Win32系统下,每个进程都拥有自己的4G虚拟地址空间,各个进程之间都相互独立。如果一个进程需要完成跨进程的工作的话,那么它必须拥有目标进程的相应操作权限。在这里,PROCESS_CREATE_THREAD表示我可以通过返回的进程句柄在该进程中创建新的线程,也就是调用CreateRemoteThread的权限;同理,PROCESS_VM_OPERATION则表示在该进程中分配/释放内存的权限,也就是调用VirtualAllocEx/VirtualFreeEx的权限;PROCESS_VM_WRITE表示可以向该进程的地址空间写入数据,也就是调用WriteProcessMemory的权限。

至此目标进程已经打开,那么我们该如何来将DLL注入其中呢?在这之前,我请你看一行代码,是如何在本进程内显式加载DLL的:

HMODULE hDll = LoadLibrary( "DLL.dll" );

那么,如果能控制目标进程调用LoadLibrary,不就可以完成DLL的远程注入了么?的确是这样,我们可以通过CreateRemoteThread将LoadLibrary作为目标进程的一个线程来启动,这样就可以完成“控制目标进程调用LoadLibrary”的工作了。到这里,也许你会想当然地写下类似这样的代码:

DWORD dwID;

LPVOID pFunc = LoadLibraryA;

HANDLE hThread = CreateRemoteThread( hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, (LPVOID)"DLL.dll", 0, dwID );

不过结果肯定会让你大失所望——注入DLL失败!

嗯嗯,那么现在让我们来分析一下失败的原因吧。我是前说过,在Win32系统下,每个进程都拥有自己的4G虚拟地址空间,各个进程之间都是相互独立的。在这里,我们当作参数传入的字符串"DLL.dll"其实是一个数值,它表示这个字符串位于Virus.exe地址空间之中的地址,而这个地址在传给Target.exe之后,它指向的东西就失去了有效性。举个例子来说,譬如A、B两栋大楼,我住在A楼的401;那么B楼的401住的是谁我当然不能确定——也就是401这个门牌号在B楼失去了有效性,而且如果我想要入住B楼的话,我就必须请B楼的楼长为我在B楼中安排新的住处(当然这个新的住处是否401也就不一定了)。

由此看来,我就需要做这么一系列略显繁杂的手续——首先在Target.exe目标进程中分配一段内存空间,然后向这段空间写入我要加载的DLL名称,最后再调用CreateRemoteThread。这段代码就成了这样:

// 向目标进程地址空间写入DLL名称

DWORD dwSize, dwWritten;

dwSize = lstrlenA( lpszDll ) + 1;

LPVOID lpBuf = VirtualAllocEx( hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE );

if ( NULL == lpBuf )

CloseHandle( hProcess );

// 失败处理

if ( WriteProcessMemory( hProcess, lpBuf, (LPVOID)lpszDll, dwSize, dwWritten ) )

// 要写入字节数与实际写入字节数不相等,仍属失败

if ( dwWritten != dwSize )

VirtualFreeEx( hProcess, lpBuf, dwSize, MEM_DECOMMIT );

CloseHandle( hProcess );

// 失败处理

else

CloseHandle( hProcess );

// 失败处理

// 使目标进程调用LoadLibrary,加载DLL

DWORD dwID;

LPVOID pFunc = LoadLibraryA;

HANDLE hThread = CreateRemoteThread( hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, lpBuf, 0, dwID );

需要说的有两点,一是由于我要在目标进程中为ANSI字符串来分配内存空间,所以这里凡是和目标进程相关的部分,都明确使用了后缀为“A”的API函数——当然,如果要使用Unicode字符串的话,可以换作后缀是“W”的API;第二,在这里LoadLibrary的指针我是取的本进程的LoadLibraryA的地址,这是因为LoadLibraryA/LoadLibraryW位于kernel32.dll之中,而Win32下每个应用程序都会把kernel32.dll加载到进程地址空间中一个固定的地址,所以这里的函数地址在Target.exe中也是有效的。

在调用LoadLibrary完毕之后,我们就可以做收尾工作了:

// 等待LoadLibrary加载完毕

WaitForSingleObject( hThread, INFINITE );

// 释放目标进程中申请的空间

VirtualFreeEx( hProcess, lpBuf, dwSize, MEM_DECOMMIT );

CloseHandle( hThread );

CloseHandle( hProcess );

在此解释一下WaitForSingleObject一句。由于我们是通过CreateRemoteThread在目标进程中另外开辟了一个LoadLibrary的线程,所以我们必须等待这个线程运行完毕才能够释放那段先前申请的内存。

好了,现在你可以尝试着整理这些代码并编译运行。运行Target.exe,然后开启一个有模块查看功能的进程查看工具(在这里我使用我的July)来查看Target.exe的模块,你会发现在注入DLL之前,Target.exe中并没有DLL.dll的存在:

在调用了注入代码之后,DLL.dll就位于Target.exe的模块列表之中了:

矛盾相生

记得2004年初我将QQ尾巴病毒成功仿真后,有很多网友询问我如何才能杀毒,不过我都没有回答——因为当时我研究的重点并非病毒的寄生特性。这一寄生特性直到今天可以说我才仿真完毕,那么,我就将解毒的方法也一并公开吧。

和DLL的注入过程类似,只不过在这里使用了两个API:GetModuleHandle和FreeLibrary。出于篇幅考虑,我略去了与注入部分相似或相同的代码:

// 使目标进程调用GetModuleHandle,获得DLL在目标进程中的句柄

DWORD dwHandle, dwID;

LPVOID pFunc = GetModuleHandleA;

HANDLE hThread = CreateRemoteThread( hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, lpBuf, 0, dwID );

// 等待GetModuleHandle运行完毕

WaitForSingleObject( hThread, INFINITE );

// 获得GetModuleHandle的返回值

GetExitCodeThread( hThread, dwHandle );

// 释放目标进程中申请的空间

VirtualFreeEx( hProcess, lpBuf, dwSize, MEM_DECOMMIT );

CloseHandle( hThread );

// 使目标进程调用FreeLibrary,卸载DLL

pFunc = FreeLibrary;

hThread = CreateRemoteThread( hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, (LPVOID)dwHandle, 0, dwID );

// 等待FreeLibrary卸载完毕

WaitForSingleObject( hThread, INFINITE );

CloseHandle( hThread );

CloseHandle( hProcess );

用这个方法可以卸载一个进程中的DLL模块,当然包括那些非病毒体的DLL。所以,这段代码还是谨慎使用为好。

在完成卸载之后,如果没有别的程序加载这个DLL,你就可以将它删除了。

到此为止,整个的技术细节我就讲完了。不过,我还是不能免俗地再次强调:李马发表本文及其源代码仅作技术讨论之用,请勿将此技术用作破坏之途,李马本人也不为各种可能出现的后果负任何责任

VC 如何WIN32DLL里面写代码

建立WIN32 DLL;库 添加C++文件,直接写就可以了

不知道我有没有读懂你的意思.

您好,我还不太懂这些win32的引用,按照您昨天说的我把 [DllImport("user32.dll")]

给你封装到一个类里了。添加这个类的代码到同一namespace里,所有划红线的方法前加上 WIN32API.

比如 WIN32API.GetWindowDC

     public static class WIN32API{

        [DllImport("gdi32.dll", EntryPoint = "DeleteObject")]

        [return: MarshalAs(UnmanagedType.Bool)]

        public static extern bool DeleteObject([In] IntPtr hObject);

        [DllImport("gdi32.dll", EntryPoint = "DeleteDC")]

        public static extern bool DeleteDC([In] IntPtr hdc);

        [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC", SetLastError=true)]

        public static extern IntPtr CreateCompatibleDC(IntPtr hdc);

        [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap")]

        public static extern IntPtr CreateCompatibleBitmap([In] IntPtr hdc, int nWidth, int nHeight);

        [DllImport("gdi32.dll", EntryPoint = "BitBlt", SetLastError = true)]

        [return: MarshalAs(UnmanagedType.Bool)]

        public static extern bool BitBlt([In] IntPtr hdc, int nXDest, int nYDest, int nWidth, int nHeight, [In] IntPtr hdcSrc, int nXSrc, int nYSrc, CopyPixelOperation dwRop);

        [DllImport("gdi32.dll", EntryPoint = "SelectObject")]

        public static extern IntPtr SelectObject([In] IntPtr hdc, [In] IntPtr hgdiobj);

        [DllImport("user32.dll", EntryPoint = "GetWindowDC", SetLastError=true)]

        public static extern IntPtr GetWindowDC(IntPtr hWnd);

        [DllImport("user32.dll")]

        public static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);

还有,你这是想截取窗口的某个控件的截图?

将dll注入某个目标进程之后如何在当前程序操纵目标进程中的dll函数执行?

(DYNAMIC LINK LIBRARY)和Windows系统紧密相关。

收容了几乎一切WIN32

,提供了绝大多数功能调用。DLL(

)注入技术,就是把要注入的代码写到DLL中,然后让目标进程加载这个DLL。对DLL的注入方式及应用进行探讨,从而使之更好地发挥作用。

在Win32环境下,应用程序都要直接或间接地调用

。而在Windows

中,

中的所有函数都是通过

库(DLL)来调用。在Windows下,每个进程都有自己的私有

,当该进程的线程运行的时候,该线程只能访问属于它的进程的内存,而不能以任何方式读写其他进程的私有

,应用程序很少能被其他应用程序打断,这使得整个系统更加稳定。然而,这种机制使得我们需要访问其他进程的特定资源的时候操作变得非常麻烦。所谓DLL注入技术,就是把要注入的代码写到DLL中,然后让目标进程加载这个DLL。一旦程序代码进入…

我也不是很懂,大致是使某一个应用程序,调用这个dll,所以可以让你看不到他的运行,这就是所谓的注入

关于win32汇编写DLL

HWND CreateWindowEx(

DWORD dwExStyle, // 窗口的扩展风格

LPCTSTR lpClassName, // 指向注册类名的指针

LPCTSTR lpWindowName, // 指向窗口名称的指针

DWORD dwStyle, // 窗口风格

int x, // 窗口的水平位置

int y, // 窗口的垂直位置

int nWidth, // 窗口的宽度

int nHeight, // 窗口的高度

HWND hWndParent, // 父窗口的句柄

HMENU hMenu, // 菜单的句柄或是子窗口的标识符

HINSTANCE hInstance, // 应用程序实例的句柄

LPVOID lpParam // 指向窗口的创建数据

你没有写注册类名,

szButton db 'button'.0

offset szButton

这样写应该就可以了

dll注入后怎么让目标程序运行dll中的函数

动态链接库(DYNAMIC LINK LIBRARY)和Windows系统紧密相关。动态链接库收容了几乎一切WIN32 API函数,提供了绝大多数功能调用。DLL(动态链接库)注入技术,就是把要注入的代码写到DLL中,然后让目标进程加载这个DLL。对DLL的注入方式及应用进行探讨,从而使之更好地发挥作用。

0前言在Win32环境下,应用程序都要直接或间接地调用API函数。而在Windows操作系统中,Windows API中的所有函数都是通过动态链接库(DLL)来调用。在Windows下,每个进程都有自己的私有地址空间,当该进程的线程运行的时候,该线程只能访问属于它的进程的内存,而不能以任何方式读写其他进程的私有地址空间,应用程序很少能被其他应用程序打断,这使得整个系统更加稳定。然而,这种机制使得我们需要访问其他进程的特定资源的时候操作变得非常麻烦。所谓DLL注入技术,就是把要注入的代码写到DLL中,然后让目标进程加载这个DLL。一旦程序代码进入…

我也不是很懂,大致是使某一个应用程序,调用这个dll,所以可以让你看不到他的运行,这就是所谓的注入

求易语言钩子注入dll及home呼出源码

易语言钩子DLL注入源码及源码说明2010-04-06 13:52[所有要使用到的API]

.版本 2

.DLL命令 LoadLibraryA, 整数型,"kernel32.dll","LoadLibraryA"

.参数 lpLibFileName, 文本型

.DLL命令 SetWindowsHookExA, 整数型, "user32.dll", "SetWindowsHookExA", 公开, SetWindowsHookEx

.参数 钩子类型, 整数型, , idHook

.参数 回调函数地址, 整数型, , lpfn

.参数 实例句柄, 整数型, , hmod

.参数 线程ID, 整数型, , dwThreadId

.DLL命令 FreeLibrary, 整数型, "kernel32.dll", "FreeLibrary", , 释放指定的动态链接库,它们早先是用LoadLibrary ;API函数装载的 非零表示成功,零表示失败。会设置GetLastError

.参数 库句柄, 整数型, , hLibModule,要释放的一个库句柄,在VB里使用只能用这个函数释放那些由应用程序明确装载的DLL。对LoadLibrary的每一次调用都应该有一个对应的FreeLibrary调用;

.DLL命令 UnhookWindowsHookEx, 整数型, "user32.dll", "UnhookWindowsHookEx", , UnhookWindowsHookEx

.参数 钩子句柄, 整数型, , hHook

.DLL命令 CallNextHookEx, 整数型, "user32.dll", "CallNextHookEx", 公开, CallNextHookEx

.参数 钩子句柄, 整数型, , hHook

.参数 代码值, 整数型, , ncode

.参数 附加参数1, 整数型, , wParam

.参数 附加参数2, 整数型, 传址, lParam

.DLL命令 GetProcAddress, 整数型, "kernel32.dll", "GetProcAddress", , 取进程路径

.参数 模块句柄, 整数型, , hModule

.参数 进程名称, 文本型, , lpProcName

.DLL命令 GetCurrentThreadId, 整数型, "kernel32.dll", "GetCurrentThreadId"

.DLL命令 获取特别文件夹位置_, 整数型, "shell32.dll", "SHGetSpecialFolderLocation"

.参数 窗口句柄, 整数型, , hwndOwner

.参数 文件夹位置, 整数型, , nFolder

.参数 结构, 项目标识符列表_, 传址, pIdl

.DLL命令 从列表id取路径_, 整数型, "shell32.dll", "SHGetPathFromIDListA", , $(b)

.参数 结构指针, 整数型, , pIdl

.参数 路径, 文本型, 传址, pszPath

.DLL命令 CallWindowProcA, 整数型, "user32.dll", "CallWindowProcA"

.参数 动态调用代码, 字节集, , 一定要用本人编写的

.参数 子程序, 子程序指针, , 子程序指针

.参数 参数, 整数型, 数组, 为整数数组,参数1为成员1…类推;文本型和字节集型(自定义结构)为指针

.参数 参数数目, 整数型, , 一定要和参数数组相符,不然会出错

.参数 是否C调用, 整数型, , 真为cdecl调用方式,假为stdcall调用方式(即标准WINAPI方式)

[这里函数所有代码和一个自定义类型,API代码在左边]

.版本 2

.程序集 程序集1

.程序集变量 临时呼出热键, 整数型

.程序集变量 临时载入窗口, 窗口

.程序集变量 钩子模块句柄, 整数型, , "1000"

.程序集变量 钩子句柄, 整数型, , "1000"

.程序集变量 钩子IDx, 整数型

.程序集变量 x, 整数型

.程序集变量 钩子句柄1, 整数型

.程序集变量 temp目录, 文本型

.程序集变量 xxx, 整数型

.程序集变量 热键钩子句柄, 整数型

.程序集变量 第一次, 逻辑型

.子程序 调用_调用子程序, 整数型, 公开, 呼叫某个函数 可以传入无限个参数 返回函数返回值

.参数 子程序指针, 子程序指针, , 指定函数

.参数 参数, 整数型, 可空 数组, 指定参数 可以不写, 参数为数组 格式为 参数[1]=xxx 参数[2]=xxx 文本型或字节集请用 转换指针 格式2 加入成员(参数,xxx)

.局部变量 动态调用代码, 字节集

动态调用代码 = { 85, 139, 236, 86, 139, 117, 16, 141, 78, 255, 133, 201, 124, 21, 139, 69, 12, 141, 4, 136, 65, 139, 16, 137, 85, 16, 255, 117, 16, 131, 232, 4, 73, 117, 242, 255, 85, 8, 137, 69, 12, 139, 69, 20, 133, 192, 116, 13, 141, 4, 181, 0, 0, 0, 0, 137, 69, 16, 3, 101, 16, 139, 69, 12, 94, 93, 194, 16, 0 }

返回 (CallWindowProcA (动态调用代码, 子程序指针, 参数, 取数组成员数 (参数), 0))

.子程序 操作_取特定目录, 文本型, 公开, 取特定的目录(返回所要取的指定目录名 无效返回空)

.参数 欲获取目录类型, 整数型, 可空, 0我的桌面 1临时目录 5我的文档 6我的收藏夹 7我的启动 11我的开始菜单 20系统字体 36Windows安装目录 37系统目录 [99更多]

.局部变量 路径, 文本型

.局部变量 标示结构, 项目标识符列表_

.局部变量 目录类型, 整数型

.如果真 (欲获取目录类型 = 99)

输出调试文本 (“0我的桌面 2我的程序 5我的文档 6我的收藏夹 7我的启动 8我最近的文档 9我的发送到 11我的开始菜单 13我的音乐 14我的视频 16我的桌面 20系统字体 22开始菜单组 23程序组 24启动组 25桌面 31收藏夹 32我的浏览器临时目录 33我的Cookies 34我的历史记录 36Windows安装目录 37系统目录 38文件安装目录 39我的图片 40用户目录 41系统目录 46文档 47管理工具 48我的管理工具 53音乐 54图片 55视频”)

.如果真结束

.如果 (欲获取目录类型 = 1)

目录类型 = 34

.否则

目录类型 = 欲获取目录类型

.如果结束

获取特别文件夹位置_ (0, 目录类型, 标示结构)

路径 = 取空白文本 (255)

从列表id取路径_ (标示结构.结构大小, 路径)

.如果真 (路径 = “”)

返回 (“”)

.如果真结束

.如果真 (欲获取目录类型 = 1)

路径 = 子文本替换 (路径, “History”, “Temp”, , , 真)

.如果真结束

返回 (路径 + “\”)

.子程序 注入_安装钩子DLL, 整数型, 公开, DLL注入 返回0=失败 整数型 DLL接口(代码值,参数1,参数2)

.参数 线程ID, 整数型, , -1 全局钩子

.参数 DLL全名, 文本型, , DLL全名

.参数 DLL接口, 文本型, 可空, 默认 整数型 钩子接口(代码值,参数1,参数2)

.局部变量 临时变量, 整数型

.局部变量 目录, 文本型

.局部变量 窗口句柄, 整数型

.如果真 (是否为空 (DLL接口) = 真)

DLL接口 = “钩子接口”

.如果真结束

.如果真 (线程ID = 0)

返回 (0)

.如果真结束

.如果真 (线程ID = -1)

线程ID = 0

.如果真结束

钩子IDx = 钩子IDx + 1

钩子模块句柄 [钩子IDx] = LoadLibraryA (DLL全名)

钩子句柄 [钩子IDx] = SetWindowsHookExA (3, GetProcAddress (钩子模块句柄 [钩子IDx], DLL接口), 钩子模块句柄 [钩子IDx], 线程ID)

目录 = 操作_取特定目录 (1)

写配置项 (目录 + “ada.ini”, “ada”, “钩子句柄”, 到文本 (钩子句柄 [钩子IDx]))

输出调试文本 (钩子IDx, 钩子模块句柄 [钩子IDx], 钩子句柄 [钩子IDx])

返回 (钩子IDx)

.版本 2

.子程序 注入_卸载钩子DLL, 逻辑型, 公开

.参数 钩子ID, 整数型, 可空, 卸载所有时无效

.参数 卸载所有, 逻辑型, 可空

.局部变量 xx, 整数型

.如果真 (卸载所有)

.如果真 (钩子IDx > 0)

.计次循环首 (钩子IDx, xx)

.如果真 (钩子模块句柄 [xx] ≠ 0)

FreeLibrary (钩子模块句柄 [xx])

UnhookWindowsHookEx (钩子句柄 [xx])

.如果真结束

.计次循环尾 ()

.如果真结束

返回 (真)

.如果真结束

.如果真 (钩子ID > 0)

.如果真 (钩子模块句柄 [钩子ID] ≠ 0)

FreeLibrary (钩子模块句柄 [钩子ID])

UnhookWindowsHookEx (钩子句柄 [钩子ID])

返回 (真)

.如果真结束

.如果真结束

返回 (假)

.子程序 注入_初始化钩子DLL, 整数型, 公开, DLL用.

.参数 代码值, 整数型

.参数 参数1, 整数型

.参数 参数2, 整数型

.参数 初始, 子程序指针

.局部变量 xxxx, 整数型

.如果真 (钩子句柄1 = 0)

temp目录 =操作_取特定目录 (1)

钩子句柄1 = 到整数 (读配置项 (temp目录 + “ada.ini”, “ada”, “钩子句柄”, ))

.如果真结束

.如果真 (第一次 = 假)

第一次 = 真

调用_调用子程序 (初始)

.如果真结束

返回 (CallNextHookEx (钩子句柄1, 代码值, 参数1, 参数2))

.子程序 注入_设置呼出窗口, 逻辑型, 公开

.参数 设置热键, 整数型

.参数 呼出窗口, 窗口

临时呼出热键 = 设置热键

临时载入窗口 = 呼出窗口

热键钩子句柄 = SetWindowsHookExA (2, 到整数 (呼出键接口), 0, GetCurrentThreadId ())

.如果真 (热键钩子句柄 > 0)

返回 (真)

.如果真结束

返回 (假)

.子程序 呼出键接口, 整数型

.参数 一, 整数型

.参数 二, 整数型

.参数 三, 整数型

.如果真 (一 = 0 且 二 = 临时呼出热键 且 三 > 0)

.如果 (是否已创建 (临时载入窗口))

.如果 (临时载入窗口.可视)

临时载入窗口.可视= 假

.否则

临时载入窗口.可视= 真

.如果结束

.否则

载入 (临时载入窗口, , 假)

临时载入窗口.Esc键关闭= 假

临时载入窗口.最小化按钮= 真

.如果结束

.如果真结束

返回 (CallNextHookEx (热键钩子句柄, 一, 二, 三))

.版本 2

.数据类型 项目标识符列表_, , ITEMIDLIST

.成员 结构大小, 整数型, , , cb

.成员 标识符长度, 字节型, , "255", abID

此函数是用来调用指针函数的.就是CALL

取目录用这个我就不解释了

下面是源码主要函数

函数解释:

本函数参数1为要HOOK的线程ID,参数2为要注入的DLL名,参数3[可空]为DLL接口名字空则为"钩子接口".

下面解释是如何实现的:

1.首先使用LoadLibraryA获取DLL模块地址.

2.然后设置SetWindowsHookExA

参数一为HOOK类型,使用WH_GETMESSAGE(3) Hook来监视从GetMessage or PeekMessage函数返回息。

参数二为接口地址,就是说把消息返回转接到的位置,当然我们这里所使用的是我们DLL所公开的那个函数

参数三为接口模块的句柄即DLL的句柄(地址)

参数四为将要被HOOK的线程ID(0为全局HOOK,不推荐使用全局HOOK)

3.设置完后将钩子句柄写配置项到临时目录(后面将要使用).

说白了其实这个才是真正的接口(DLL里的接口只是在做转接而已),

我先讲这个函数是如何实现的(上面已经说了这才是真正的接口).

1,钩子句柄是一个程序集变量,先判断这个变量是否为0,如果等于0那么就是说这个函数第一次被使用,

第一次使用将读去上个函数写在临时目录的钩子句柄.

2.用一个逻辑变量(程序集变量或全局变量),来判断这个消息钩子是否第一次运行(为了防止后面调用

子程序被多次调用),是的话调用一个子程序(自己设置)

3.使用CallNextHookEx(呼叫下一个钩子)把当前HOOK的信息在传送回被HOOK的钩子里,那个钩子我们

就不用管了.

下来说下到底如何使用

首先在你的EXE程序里写这个(我就不多说这是干吗的了).

然后在DLL里写上这个代码(有人可能觉得眼熟,好像在什么地方见过,对了这个代码和

外挂作坊的钩子注入差不多)

下来说明下按键呼出窗口的函数

用变量把当前参数存起来(主要方便接口调用)

1.为当前运行线程设置一个键盘钩子

2.[接口]设置按键判断,如果按下我们设置的键将呼出窗口,如果这个窗口没创建将判断创建,

如果已经创建再次按下则会隐藏,

载入后的窗口把用ESC关闭的属性弄成假,不需要ESC关闭

3.最后就是再呼叫下以前的钩子.

最后就是卸载钩子DLL了.

判断是否要卸载全部的钩子,如果是就循环将现有钩子DLL全部卸载.

不是就按着ID来卸载

卸载方法:

1.FreeLibrary就是卸载一个载入的DLL

2.UnhookWindowsHookEx乃是卸载这个HOOK

-.-OK了这就是 钩子DLL注入,谢谢大家阅读,如果看不明白,

  win32注入dll源码 


评论


最新评论