用DLL控制Windows中进程的方法

【 tulaoshi.com - 编程语言 】

　　在Microsoft Windows中，每个进程都有它自己的私有地址空间。当使用&&keyword=%D6%B8%D5%EB&Submit=+%CB%D1%CB%F7+"指针来引用内存时，&&keyword=%D6%B8%D5%EB&Submit=+%CB%D1%CB%F7+"指针的值将引用你自己进程的地址空间中的一个内存地址。你的进程不能创建一銎湟用属于另一个进程的内存&&keyword=%D6%B8%D5%EB&Submit=+%CB%D1%CB%F7+"指针。因此，如果你的进程存在一个错误，改写了一个随机地址系内存，那么这个错误不会影响另一个进程使用的内存。Windows 98 在Windows 98下运行的各个进程共享2 GB的地址空间，该地址空间从0x80000000至0xFFFFFFFF。只有内存映像文件和统组件才能映射到这个区域。

　　独立的地址空间对于编程人员和用户来说都是非常有利的。对于编程人员来说，系统更容易捕获随意的内存读取和写入操作。对于用户来说，/Article/czxt/Index.html"操作系统将变得更加健壮，因个应用程序无法破坏另一个进程或/Article/czxt/Index.html"操作系统的运行。当然，/Article/czxt/Index.html"操作系统的这个健壮特性是要冻代价的，因为要编写能够与其他进程进行通信，或者能够对其他进程进行操作的应用程序难得多。

　　有些情况下，必须打破进程的界限，访问另一个进程的地址空间，这些情况包括：

　　当你想要为另一个进程创建的窗口建立子类时。
　　当你需要调试帮助时（例如，当你需要确定另一个进程正在使用哪个DLL时）。
　　当你想要挂接其他进程时。

　　这里将介绍两种方法，可以用来将DLL插入到另一个进程的地址空间中。一旦你的DLL进入另一个进程的地址空间，就可以对另一个进程为所欲为。这一定会使你非常害怕，因此，究竟应该怎样做，要三思而后行。

　　1 插入DLL：一个例子

　　假设你想为由另一个进程创建的窗口建立一个子类。你可能记得，建立子类就能够改变窗口的行为特性。若要建立子类，只需要调用SetWindowLongPtr&&函数，改变窗口的内婵中的窗口过程地址，指向一个新的（你自己的） WndProc。Platform SDK文档说，应用程虿能为另一个进程创建的窗口建立子类。这并不完全正确。为另一个进程的窗口建立子类的关键问题与进程地址空间的边界有关。

　　当调用下面所示的SetWindowsLongPtr&&函数，建立一个窗口的子类时，你告诉系统，发送到或者显示在hwnd设定的窗口中的所有消息都应该送往MySubclassProc，而不是送往口的正常窗口过程：

　　进程A中代码：

EXE file：
LRESUlT WndProc(HWND hend,UNIT uMsg,...){.....}
USER32.DLL file
LONG DispatchMessage(CONST MSG*msg)
{
LONG lRet;
WNDPROC lpfnWndProc=
(WNDPROC)GetWindowLongPtr(msg,hwnd,GWLP_WNDPROC
);
lRet=lpfnWndProc(msg.hwnd,msg.message,msg.wParam,mag.
lParam);
return lRet;
}
进程B中：
EXE file
void Somefunc(void)
{
HWND hwnd=Findwindow("class A",NULL);
SetWindowLongPtr(hwnd,GWLP_WNDPROC,MySubclassProc);
}
USER32.DLL file ......

　　换句话说，当系统需要将消息发送到指定窗口的WndProc时，要查看它的地址，然后直接调用WndProc。在本例中，系统发现MySubclassProc&&函数的地址与窗口相关联，因此就直接调用MySubclassProc&&函数。

　　为另一个进程创建的窗口建立子类时遇到的问题是，建立子类的过程位于另一个地址空间中。下面举个例子，说明窗口过程是如何接受消息的。进程A正在运行，并且已经创建了一个窗口。文件User32.dll被映射到进程A的地址空间中。

　　对User32.dll文件的映射是为了接收和发送在进程A中运行的任何线程创建的任何窗口中发送和显示的消息。当User32.dll的映像发现一个消息时，它首先要确定窗口的WndProc的地址，然后调用该地址，传递窗口的句柄、消息和wParam和lParam值。当WndProc处理该消息后，User32.dll便循环运行，并等待另一个窗口消息被处理。

　　进程B中的线程试图为进程A中的线程创建的窗口建立子类现在假设你的进程是进程B，你想为进程A中的线程创建的窗口建立子类。你在进程B中的代码必须首先确定你想要建立子类的窗口的句柄。这个操作使用的方法很多。上面的例子只是调用FindWindow&&函数来获得需要的窗口。接着，进程B中的线程调用SetWindowLongPtr&&函数，试图改变窗口的WndProc的地址。请注意我说的“试图”二字。这个&&函数调用⒉进行什么操作，它只是返回NULL。SetWindowLongPtr&&函数中的代码要查看是否有一个进程正在试图改变另一个进程创建的窗口的WndProc地址，然后将忽略这个&&函数的调用。

　　如果SetWindowLongPtr&&函数能够改变窗口的WndProc，那将出现什么情况呢？系统将把MySubclassProc的地址与特定的窗口关联起来。然后，当有一条消息被发送到这个窗口中时，进程A中的User32代码将检索该消息，获得MySubclassProc的地址，并试图调用这个地址。但是，这时可能遇到一个大问题。MySubclassProc将位于进程B的地址空间中，而进程A是个活动进程。显然，如果User32想要调用该地址，它就要调用进程A的地址空间中的一个地址，这就可能造成内存访问的违规。

　　为了避免这个问题的产生，应该让系统知道M y S u b c l a s s P r o c是在进程B的地址空间中，然后，在调用子类的过程之前，让系统执行一次上下文转换。M i c r o s o f t没有实现这个辅助&&函数功能，原因是：应用程序很少需要为其他进程的线程创建的窗口建立子类。大多数应用程序只是为它们自己创建的窗口建立子类，Wi n d o w s的内存结构并不阻止这种创建操作。

　　切换活动进程需要占用许多C P U时间。

　　进程B中的线程必须执行M y S u b c l a s s P r o c中的代码。系统究竟应该使用哪个线程呢？是现有的线程，还是新线程呢？

　　U s e r 3 2 . d l l怎样才能说明与窗口相关的地址是用于另一个进程中的过程，还是用于同一个进程中的过程呢？

　　由于对这个问题的解决并没有什么万全之策，因此M i c r o s o f t决定不让S e t Wi n d o w s L o n g P t r改变另一个进程创建的窗口过程。不过仍然可以为另一个进程创建的窗口建立子类—只需要用另一种方法来进行这项操作。这并不是建立子类的问题，而是进程的地址空间边界的问题。如果能将你的子类过程的代码放入进程A的地址空间，就可以方便地调用S e t Wi n d o w L o n g P t r&&函数，将进程A的地址传递给M y S u b c l a s s P r o c&&函数。我将这个方法称为将D L L“插入”进程的地址空间。有若干种方法可以用来进行这项操作。下面将逐个介绍它们

　　2.通过挂钩插入DLL

　　可以使用挂钩将D L L插入进程的地址空间。为了使挂钩能够像它们在1 6位Wi n d o w s中那样工作，M i c r o s o f t不得不设计了一种方法，使得D L L能够插入另一个进程的地址空间中。

　　下面让我们来看一个例子。进程A（类似Microsoft Spy++的一个实用程序）安装了一个挂钩W N _ G E T M E S S A G E，以便查看系统中的各个窗口处理的消息。该挂钩是通过调用下面的S e t Wi n d o w s H o o k E x&&函数来安装的：

　　第一个参数W H _ G E T M E S S A G E用于指明要安装的挂钩的类型。第二个参数G e t M s g P r o c用于指明窗口准备处理一个消息时系统应该调用的&&函数的地址（在你的刂房占渲校５三个参数h i n s t D l l用于指明包含G e t M s g P r o c&&函数的D L L。在Wi n d o w s中，D L L的h i n s t D l l的值用于标识DLL被映射到的进程的地址空间中的虚拟内存地址。最后一个参数0用于指明要挂接的线程。

　　对于一个线程来说，它可以调用S e t Wi n d o w s H o o k E x&&函数，传递系统中的另一个线程的I D。通过为这个参数传递0，就告诉系统说，我们想要挂接系统中的所有G U I线程。

　　现在让我们来看一看将会发生什么情况：

　　1) 进程B中的一个线程准备将一条消息发送到一个窗口。

　　2) 系统查看该线程上是否已经安装了W H _ G E T M E S S A G E挂钩。

　　3) 系统查看包含G e t M s g P r o c&&函数的D L L是否被映射到进程B的地址空间中。

　　4) 如果该D L L尚未被映射，系统将强制该D L L映射到进程B的地址空间，并且将进程B中的D L L映像的自动跟踪计数递增1。

　　5) 当D L L的h i n s t D l l用于进程B时，系统查看该&&函数，并检查该D L L的h i n s t D l l是否与它用于进程A时所处的位置相同。

　　如果两个h i n s t D l l是在相同的位置上，那么G e t M s g P r o c&&函数的内存地址在两个进程的地址空间中的位置也是相同的。在这种情况下，系统只需要调用进程A的地址空间中的G e t M s g P r o c&&函数即可。

　　如果h i n s t D l l的位置不同，那么系统必须确定进程B的地址空间中G e t M s g P r o c&&函数的虚拟内存地址。这个地址可以使用下面的公式来确定：

　　将GetMsgProc A的地址减去hinstDll A的地址，就可以得到G e t M s g P r o c&&函数的地址位移（以字节为计量单位）。将这个位移与hinstDll B的地址相加，就得出G e t M s g P r o c&&函数在用于进程B的地址空间中该D L L的映像时它的位置。

　　6) 系统将进程B中的D L L映像的自动跟踪计数递增1。

　　7) 系统调用进程B的地址空间中的G e t M s g P r o c&&函数。

　　8) 当G e t M s g P r o c&&函数返回时，系统将进程B中的D L L映像的自动跟踪计数递减1。

　　注意，当系统插入或者映射包含挂钩过滤器&&函数的D L L时，整个D L L均被映射，而只是挂钩过滤器&&函数被映射。这意味着D L L中包含的任何一个&&函数或所有&&函数现在都存在，并且可以从进程B的环境下运行的线程中调用。

　　若要为另一个进程中的线程创建的窗口建立子类，首先可以在创建该窗口的挂钩上设置一个W H _ G E T M E S S A G E挂钩，然后，当G e t M s g P r o c&&函数被调用时，调用S e t Wi n d o w L o n g P t r&&函数 来建立窗口的子类。当然，子类的过程必须与G e t M s g P r o c&&函数位于同一个D LL中。

　　与插入D L L的注册表方法不同，这个方法允许你在另一个进程的地址空间中不再需要DL L时删除该D L L的映像，方法是调用下面的&&函数：

　　当一个线程调用U n h o o k Wi n d o w s H o o k E x&&函数时，系统将遍历它必须将D L L插入到的各个进程的内部列表，并且对D L L的自动跟踪计数进行递减。当自动跟踪计数时，D L L就自动从进程的地址空间中被删除。应该记得，就在系统调用G e t M s g P r o c前，它对D L L的自动跟踪计数进行了递增（见上面的第6个步骤）。

　　该自动跟踪计数没有递增，那么当进程B的线程试图执行G e t M s g P r o c&&函数中的代胧，系统中运行的另一个线程就可以调用U n l o o k Wi n d o w s H o o k E x&&函数。

　　这一切意味着不能撤消该窗口的子类并且立即撤消该挂钩。该挂钩必须在该子类的寿命期内保持有效状态。

　　3.使用远程线程插入DLL

　　插入D L L的另一个方法是使用远程线程。这种方法具有更大的灵活性。它要求你懂得若干个Wi n d o w s特性、如进程、线程、线程同步、虚拟内存管理、D L L和U n i c o d e等（如果对这些特性不清楚，请参阅本书中的有关章节）。Wi n d o w s的大多数&&函数市斫讨欢宰己进行操作。

　　这是很好的一个特性，因为它能够防止一个进程破坏另一个进程的运行。但是，有些&&函数却允许一个进程对另一个进程进行操作。这些&&函数大部分最初是为调试程序和其他工具杓的。不过任何&&函数都可以调用这些&&函数。

　　这个D L L插入方法基本上要求目标进程中的线程调用L o a d L i b r a r y&&函数来载必要的D L L。

　　由于除了自己进程中的线程外，我们无法方便地控制其他进程中的线程，因此这种解决方案要求我们在目标进程中创建一个新线程。由于是自己创建这个线程，因此我们能够控扑执行什么代码。幸好，Wi n d o w s提供了一个称为C r e a t e R e m o t e T h r e a d的&&函数，使我们能够非常容易地在另一个进程中创建线程：

　　C r e a t e R e m o t e T h r e a d与C r e a t e T h r e a d很相似，差别在于它增加了一个参数h P r o c e s s。该参数指明拥有新创建线程的进程。参数p f n S t a r t A d d r指明线程&&函数的内存地址。当然，该内存地址与远程进程是相关的。线程&&函数的代码不能位于你自己进程的地址空间中。

　　Windows 98 在Windows 98中，C r e a t e R e m o t e T h r e a d&&函数不存在有用的实现代码，它只是返回N U L L。调用G e t L a s t E r r o r&&函数将返回E R R O R _ C A L L _ N O T _ I M P L E M E N T E D（C r e a t e T h r e a d&&函数包含用于在调用进程中创建线程的完整的实现代码）。由于C r e a t e R e m o t e T h r e a d没有实现，因此，在Windows 98下，不能使用本方法来插入D L L。

　　好了，现在你已经知道如何在另一个进程中创建线程了，但是，如何才能让该线程加载我们的D L L呢？答案很简单，那就是需要该线程调用L o a d L i b r a r y&&函数。

　　我们将详细步骤说明如下：

　　1) 使用Vi r t u a l A l l o c E x&&函数，分配远程进程的地址空间中的内存。

　　2) 使用Wr i t e P r o c e s s M e m o r y&&函数，将D L L的路径名拷贝到第一个步骤中已经分配的内存中。

　　3) 使用G e t P r o c A d d r e s s&&函数，获取L o a d L i b r a r y A或L o a dL i b r a t y W&&函数的实地址（在K e r n e l 3 2 . d l l中）。

　　4) 使用C r e a t e R e m o t e T h r e a d&&函数，在远程进程中创建一个线程，它调用正确的L o a d L i b r a r y&&函数，为它传递第一个步骤中分配的内存的地址。这时， D L L已经被插入远程进程的地址空间中，同时D L L的D l l M a i n&&函数接收到一个D L L _ P R O C E S S _ AT TA C H通知，并且能够执行需要的代码。当D l l M a in&&函数返回时，远程线程

　　从它对L o a d L i b r a r y的调用返回到B a s e T h r e a d S t a r t &&函数（第6 章中已经介绍。然后B a s e T h r e a d S t a r t调用E x i t T h r e a d，使远程线程终止运行。

　　现在远程进程拥有第一个街柚蟹峙涞哪诖婵椋鳧 L L则仍然保留在它的地址空间中。

　　若要将它删除，需要在远程线程退出后执行下面的步骤：

　　5) 使用Vi r t u a l F r e e E x&&函数，释放第一个步骤中分配的内存。

　　6) 使用G e t P r o c A d d r e s s&&函数，获得F r e e L i b r a r y&&函数的实地址（在K e r n e l 3 2 . d l l中）。

　　7) 使用C r e a t e R e m o t e T h r e a d&&函数，在远程进程中创建一个线程，它调用F r e e L i b r a r y&&函数，传递远程D L L的H I N S TA N C E。

　　这就是它的基本操作步骤。这种插入D L L的方法存在的唯一一个不足是, Windows 98并不支持这样的&&函数。只能在Windows 2000上使用这种方法。