通过WriteProcessMemory改写进程的内存

http://www.cnblogs.com/feiyucq/archive/2009/10/21/1587628.html

以PROCESS_ALL_ACCESS权限打开进程以后既能够使用ReadProcessMemory读取程序内存，也能够使用WriteProcessMemory改敲代码的内存，这也是一些内存补丁使用的招数，下面是程序的实现代码

#include <windows.h>
#include <tlhelp32.h>
BOOL CALLBACK EnumChildWindowProc(HWND hWnd,LPARAM lParam);//枚举记事本中的子窗体
char mess[999999];
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
{
    HWND nphWnd=::FindWindow("notepad",NULL);
    if(nphWnd)
    {
        char temp[1024];
        PROCESSENTRY32 pe32;
        pe32.dwSize=sizeof(pe32);
        HANDLE hProcessSnap=::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);//获得进程列表的快照，第一个參数能够有其它选项，具体请參考MSDN
        if(hProcessSnap==INVALID_HANDLE_VALUE)
        {
            ::MessageBox(NULL,"CreateToolhelp32Snapshot error","error",MB_OK);
            return 0;
        }
        HANDLE hProcess;
        BOOL bMore=::Process32First(hProcessSnap,&pe32);//获得第一个进程的信息
        while(bMore)
        {
            ::wsprintf(temp,"%s",pe32.szExeFile);
            if(!::strcmp(temp,"button.exe"))
            {
                hProcess=::OpenProcess(PROCESS_ALL_ACCESS,false,(DWORD)pe32.th32ProcessID);
                if(hProcess==NULL)
                {
                    ::wsprintf(temp,"%s","打开进程失败!");
                    ::strcat(mess,temp);
                }
                else
                {
                    ::wsprintf(temp,"%s","打开进程成功!");
                    ::strcat(mess,temp);
                    //改写内存中内容
                    int tmp=97;//ascii:a
                    DWORD dwNumberOfBytesRead;
                    if(!::WriteProcessMemory(hProcess,(LPVOID)0x0040505d,&tmp,1,&dwNumberOfBytesRead))
                    {
                        ::wsprintf(temp,"%s","写入失败");
                        ::strcat(mess,temp);
                    }
                    else
                    {
                        ::wsprintf(temp,"%s","写入成功");
                        ::strcat(mess,temp);
                    }
                }
                break;
            }
            bMore=::Process32Next(hProcessSnap,&pe32);//获得其它进程信息
        }
        ::EnumChildWindows(nphWnd,EnumChildWindowProc,0);//获得记事本的edit窗体，打印进程信息
        return 0;
    }
    else
    {
        ::MessageBox(NULL,"please open notepad","error",MB_OK);
        return 0;
    }
}
BOOL CALLBACK EnumChildWindowProc(HWND hWnd,LPARAM lParam)
{
    char temp1[256];
    if(hWnd)
    {
        ::GetClassName(hWnd,temp1,255);
        if(!::strcmp(temp1,"Edit"))//得到edit子窗体句柄
        {
            ::SendMessage(hWnd,WM_SETTEXT,0,(LPARAM)mess);
            return 0;
        }
    }
    return true;
}

程序的功能是改写名为button.exe程序中内存地址为0x0040505d的值为97，即ASCII值的a，此处内存的原内容为ASCII值的m

被改动的程序实现代码例如以下：

#include <windows.h>
#include <stdio.h>
LRESULT CALLBACK _procWinMain(HWND,UINT,WPARAM,LPARAM);
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
    HWND hWinMain,hButton1,hButton2;
    MSG stMsg;
    WNDCLASSEX stWndClass;
    RtlZeroMemory(&stWndClass,sizeof(stWndClass));//WNDCLASSEX结构置零
    //注冊窗体类
    stWndClass.hCursor=::LoadCursor(0,IDC_ARROW);
    stWndClass.hInstance=hInstance;
    stWndClass.cbSize=sizeof(WNDCLASSEX);
    stWndClass.style=CS_HREDRAW||CS_VREDRAW;
    stWndClass.lpfnWndProc=_procWinMain;
    stWndClass.hbrBackground=(HBRUSH)GetStockObject(BLACK_BRUSH);
    stWndClass.lpszClassName="myclass";
    ::RegisterClassEx(&stWndClass);
    //建立并显示窗体
    hWinMain=::CreateWindowEx(WS_EX_CLIENTEDGE,"myclass","firstwindow",WS_OVERLAPPEDWINDOW,100,100,600,400,NULL,NULL,hInstance,NULL);
    //建立button
    hButton1=::CreateWindowEx(NULL,"BUTTON","button1",WS_VISIBLE|WS_CHILD,300,200,60,20,hWinMain,(HMENU)1,hInstance,NULL);
    hButton2=::CreateWindowEx(NULL,"BUTTON","button2",WS_VISIBLE|WS_CHILD,100,200,60,20,hWinMain,(HMENU)2,hInstance,NULL);
    
    ::ShowWindow(hWinMain,SW_SHOWNORMAL);
    ::UpdateWindow(hWinMain);
    while(1)
    {
        if(::GetMessage(&stMsg,NULL,0,0)==0)//消息为WM_QUIT
            break;
        else
        {
            ::TranslateMessage(&stMsg);
            ::DispatchMessage(&stMsg);
        }
    }
    return 0;
}
LRESULT CALLBACK _procWinMain(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
    if(uMsg==WM_CLOSE)
    {
        ::DestroyWindow(hWnd);
    }
    else if(uMsg==WM_DESTROY)
    {
        ::PostQuitMessage(NULL);
    }
    else if(uMsg==WM_COMMAND)
    {
        char temp1[256],temp2[256];
        ::itoa((int)wParam,temp1,10);
        ::strcpy(temp2,"wParam: ");
        ::strcat(temp2,temp1);
        ::strcat(temp2," lParam: ");
        ::itoa((int)lParam,temp1,10);
        ::strcat(temp2,temp1);
        ::strcat(temp2," mess");
        ::MessageBox(NULL,temp2,"command",MB_OK);
    }
    else
    {
        return ::DefWindowProc(hWnd,uMsg,wParam,lParam);
    }
    return 0;
}

这个程序的功能是在窗体上建立两个button，点击不论什么一个button都会弹出一个对话框，输出button回调函数的wParam、lParam參数的值，外加一段字符串“mess”，我们要改动的就是字符串“mess”的第一个字符“m”为“a”。

将两端代码编译以后先打开button程序，点击窗体上的随意一个按钮，应该弹出例如以下的对话框

--------------------------------------------------------------------------------------华丽的切割线------------------------------------------------------------------------------

http://www.cppblog.com/windcsn/archive/2006/04/20/5981.html

这一篇主要讲了怎样使用消息进行进程间通信

近期在写个程序的时候须要在进程间通讯，详细需求是这样。

1.       主要有两个进程：一个进程作为被请求进程，我们称为 SERVER 进程；还有一个进程是请求进程，称为 CLIENG 进程。

2.       SERVER 进程提供一些服务，其完毕计算功能；而 CLIENT 进程须要在它运行完计算之后将结果取会。

 

因为计算结果可能是一个结构，也可能是一个复杂的数据，所以通过消息来在进程传递信息是有限的。还有一方面通常是单方向的通讯，实际上这里的需求有一个双向性，看下图：

这里两个进程都能够有自己的窗体，因此实际上我们能够通过消息来通知对方。但细致一想，请求服务通过windows消息是没有问题的，通知结果通过消息是不妥当的，实际上我们须要在请求服务完以后马上得到运行结果，而使用windows消息可能有时间上的问题，并且同步很麻烦。

想要的结果是在 CLIENT 请求服务以后马上得到返回结果，但我们能够改变一下思路就easy多了：结果不是有 SERVER 返回，而由 CLIENG 自己去获取。这样，我们能够在请求消息的时候使用 SendMessage 来发送这个请求。这是必须的， SendMessage 发送消息是同步的方式，必须等到消息处理完成之后才返回，而这正是我们想要的结果。那么 CLIENT 怎么样才干获得 SERVER 进程的结果来。

我们知道， WINDOWS 下每一个进程都有自己的地址空间，普通情况下一个进程訪问你一个进程的地址是不对的，最简单的是提示该地址无效，程序崩溃。当然还是有非常多中方式来读取对方进程的地址空间上的数据。

1．  能够做一个 DLL ，利用注入 DLL 的方式，来将该 DLL 注入到远程进程的地址空间上，然后通过 DLL 的 API 来读取。这个方式有点麻烦，还必须写一个 DLL ，还要注入 DLL 。

2．  使用 WriteProcessMemory 和 ReadProcessMemory 来读写远程进程的内存。这样的方式相对照较简单，其有一个參数远程进程的 HANDLE 指示你须要读写哪个进程的内存。当然，使用这两个函数是须要远程进程的地址空间的，这个地址是通过 VirtualAllocEx 来分配的，其通过 VirtualFreeEx 来释放。这两个 API 也有一个进程句柄參数。

有人问，为什么不使用 WM_COPYDATA 来传递大块数据？好，该消息是能够传递大块数据，但我们的应用中须要消息的双向，所以这里使用 WM_COPYDATA 是不合适的。

 

以下我们看一下第 2 种方法的详细步骤：

1．  找到对方进程的窗体。

2．  找到他的进程 ID

3．  使用 PROCESS_VM_OPERATION| PROCESS_VM_WRITE|PROCESS_VM_READ 标志来打开该进程，得到该继承的 HANDLE 。

4．  使用 VirtualAllocEx 来在该进程上分配适当大小的内存，得到一个地址，这个地址是远程进程的，通过不同的方式来改动该地址上的值是无效的。

5．  假设须要传递一些參数到远程进程，我们能够在该内存上写一些内容，通过 WriteProcessMemory 来完毕

6．  使用 SendMessage 来发送请求服务消息，同一时候将上面分配的内存地址作为參数传递给远程进程。

7．  远程进程得到指定消息后处理该消息，取得參数，计算结果，将结果写到指定的地址。因为这个地址是远程进程自己的地址空间，其操作这块内存的方法没有什么特别之处。

8．  SendMessage 消息返回， CLIENT 知道后，从上面的内存地址中读取返回结果；这里必须使用 ReadProcessMemory 来读取。好了，整个过程结束。

9．  调用 VritualFreeEx 将上面的内存释放。

这里须要强调两点：

1．  打开进程的时候必须设置对虚拟内存可操作、可写、可读，假设仅仅是可写，那么 ReadProcessMemory 将读取不对。

2．  必须释放该内存。

 

以下是部分程序：

CLIENT 程序：

#define     WM_COMPAREIMAGE WM_USER +100

 

void CTestCompareDlg::OnBnClickedButton1()

{

    HANDLE hProcess = NULL;

    DWORD dwProcessId = 0;

    HWND hServerWnd = ::FindWindow(NULL,"CompareServer");

    if(hServerWnd == NULL)

    {

       //Need create the process

       return ;

    }

    ::GetWindowThreadProcessId(hServerWnd,&dwProcessId);

    hProcess = OpenProcess(PROCESS_VM_OPERATION|

       PROCESS_VM_WRITE|PROCESS_VM_READ,FALSE,dwProcessId);

    if(hProcess == NULL) return ;

 

    MyInfo * pMyInfo = NULL;

 

    pMyInfo = (MyInfo *)VirtualAllocEx(hProcess,NULL,

       sizeof(MyInfo),MEM_COMMIT,PAGE_READWRITE);

 

    if(pMyInfo == NULL) return ;

    MyInfo myInfo;

    myInfo.blue = 20.01;

    myInfo.red = 3333;

 

    WriteProcessMemory(hProcess,pMyInfo,&myInfo,sizeof(MyInfo),NULL);

 

    ::SendMessage(hServerWnd,WM_COMPAREIMAGE,sizeof(MyInfo),(LPARAM)pMyInfo);

   

    DWORD dwRead = 0;

    MyInfo myInfo2;

    BOOL bRet = ::ReadProcessMemory(hProcess,pMyInfo,&myInfo2,sizeof(MyInfo),&dwRead);

 

    dwRead = GetLastError();

    m_log.Format("red =%.2f,blue=%.2f",myInfo2.blue,myInfo2.red);

    TRACE(m_log);

    VirtualFreeEx(hProcess,pMyInfo,0,MEM_RELEASE);

    UpdateData(FALSE);

}

 

SERVER 程序：

LRESULT    CMyWindow::OnCompareImage(HWND hWnd,WPARAM wParam,LPARAM lParam)

{

    if(wParam <sizeof(MyInfo)) return -1;

    MyInfo * pMyInfo = (MyInfo *)lParam;

 

    sprintf(m_strLog,"client:red=%.2f,blue=%.2f",pMyInfo->red,pMyInfo->blue);

    ::TextOut(GetDC(hWnd),0,50,m_strLog,strlen(m_strLog));

    pMyInfo->blue = 1.0;

    pMyInfo->red = 2.0;

    return 0;

}

--------------------------------------------------------------------------------------华丽的切割线------------------------------------------------------------------------------

http://www.hackbase.com/tech/2012-05-30/66582.html

这一篇主要讲述了怎样创建远程线程， 实际上没有讲dll注入

所谓DLL注入就是将一个DLL放进某个进程的地址空间里，让它成为那个进程的一部分。要实现DLL注入，首先须要打开目标进程。
　　hRemoteProcess = OpenProcess(　PROCESS_CREATE_THREAD | //同意远程创建线程
　　PROCESS_VM_OPERATION　| //同意远程VM操作
　　PROCESS_VM_WRITE,　//同意远程VM写
　　FALSE, dwRemoteProcessId )
　　因为我们后面须要写入远程进程的内存地址空间并建立远程线程，所以须要申请足够的权限（PROCESS_CREATE_THREAD、VM_OPERATION、VM_WRITE）。
　　假设进程打不开，以后的操作就别想了。进程打开后，就能够建立远线程了，只是别急，先想想这个远线程的线程函数是什么？我们的目的是注入一个DLL。并且我们知道用LoadLibrary能够载入一个DLL到本进程的地址空间。于是，自然会想到假设能够在目标进程中调用LoadLibrary，不就能够把DLL载入到目标进程的地址空间了吗？对！就是这样。远线程就在这儿用了一次，建立的远线程的线程函数就是LoadLibrary，而參数就是要注入的DLL的文件名称。(这里须要自己想一想，注意到了吗，线程函数ThreadProc和LoadLibrary函数很相似，返回值，參数个数都一样) 另一个问题，LoadLibrary这个函数的地址在哪儿？或许你会说，这个简单，GetProcAddress就能够得出。于是代码就出来了。
　　char *pszLibFileRemote="my.dll";
　　PTHREAD_START_ROUTINE pfnStartAddr = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle("Kernel32"), "LoadLibraryA");
　　CreateRemoteThread( hRemoteProcess, NULL, 0, pfnStartAddr, pszLibFileRemote, 0, NULL);
　　可是不正确！不要忘了，这是远线程，不是在你的进程里，而pszLibFileRemote指向的是你的进程里的数据，到了目标进程，这个指针都不知道指向哪儿去了，相同pfnStartAddr这个地址上的代码到了目标进程里也不知道是什么了，不知道是不是你想要的LoadLibraryA了。可是，问题总是能够解决的，Windows有些非常强大的API函数，他们能够在目标进程里分配内存，能够将你的进程中的数据复制到目标进程中。因此pszLibFileRemote的问题能够攻克了。
　　char *pszLibFileName="my.dll";//注意，这个一定要是全路径文件名称，除非它在系统文件夹里；原因大家自己想想。
　　//计算DLL路径名须要的内存空间
　　int cb = (1 + lstrlenA(pszLibFileName)) * sizeof(char);
　　//使用VirtualAllocEx函数在远程进程的内存地址空间分配DLL文件名称缓冲区
　　pszLibFileRemote = (char *) VirtualAllocEx( hRemoteProcess, NULL, cb, MEM_COMMIT, PAGE_READWRITE);
　　//使用WriteProcessMemory函数将DLL的路径名拷贝到远程进程的内存空间
　　iReturnCode = WriteProcessMemory(hRemoteProcess, pszLibFileRemote, (PVOID) pszLibFileName, cb, NULL);
　　OK，如今目标进程也认识pszLibFileRemote了，可是pfnStartAddr好像不好办，我怎么可能知道LoadLibraryA在目标进程中的地址呢？事实上Windows为我们攻克了这个问题，LoadLibraryA这个函数是在Kernel32.dll这个核心DLL里的，而这个DLL非常特殊，无论对于哪个进程，Windows总是把它载入到同样的地址上去。因此你的进程中LoadLibraryA的地址和目标进程中LoadLibraryA的地址是同样的(事实上，这个DLL里的全部函数都是如此)。至此，DLL注入结束了。
 
 
[cpp]
/*  
远程注入explorer.exe，不停Beep,注入完就退出。  
*/    
#include <windows.h>      
#include <stdio.h>      
#include <tlhelp32.h>     
#include <Shlwapi.h>     
#include <tchar.h>     
#pragma comment(lib,"Shlwapi.lib")     
#pragma comment(linker, "/BASE:0x14000000")     
    
//#define NoWindow     
    
#ifdef NoWindow     
#pragma comment(linker,"/subsystem:windows /FILEALIGN:0x200 /ENTRY:main")     
#pragma comment(linker,"/INCREMENTAL:NO /IGNORE:4078")     
#pragma comment(linker,"/MERGE:.idata=.text /MERGE:.data=.text /MERGE:.rdata=.text /MERGE:.text=Anskya /SECTION:Anskya,EWR")      
#endif     
    
typedef int (__stdcall *fnMessageBoxA)(HWND, LPCSTR, LPCSTR, UINT);    
typedef int (__stdcall *fnBeep)(int,int);    
    
#define ProcessName "services.exe"//"rundll32.exe"//"svchost.exe"//"explorer.exe"//"avp.exe"//"lsass.exe"//     
    
//    
//依据进程名，获得进程ID     
DWORD GetProcessID(char *FileName)    
{    
    HANDLE hProcess;    
    PROCESSENTRY32 pe;    
    BOOL bRet;    
    //进行进程快照     
    hProcess=::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);    
    //開始进程查找     
    bRet=::Process32First(hProcess,&pe);    
    //循环比較，得出ProcessID     
    while(bRet)    
    {    
        if(strcmp(FileName,pe.szExeFile)==0)    
            return pe.th32ProcessID;    
        else    
            bRet=::Process32Next(hProcess,&pe);    
    }    
    //返回得到的ProcessID     
//  printf("Process not found! ");     
    return 9999;    
}    
//   
//远程注入函数 www.2cto.com      
void __stdcall RmoteThread()    
{    
     HMODULE hMod,hMod2;    
     fnMessageBoxA myMessageBoxA;    
     fnBeep myBeep;    
     char* path[MAX_PATH];    
    
     hMod = GetModuleHandle("user32.dll");    
     hMod2 = GetModuleHandle("kernel32.dll");    
     myMessageBoxA = (fnMessageBoxA)GetProcAddress(hMod, (LPCSTR)"MessageBoxA");    
     myBeep = (fnBeep)GetProcAddress(hMod2, (LPCSTR)"Beep");    
/*for(int i=0;i<30;i++)  
{  
    myBeep(800,400);  
}  
*/    
//   while(1)     
     for(int i=0;i<6;i++)    
     {    
         Beep(600,100);    
         Sleep(200);    
     }    
     GetModuleFileName(NULL,(char*)path,MAX_PATH);    
//   myMessageBoxA(NULL, (char*)path, NULL, 64);     
}    
    
// 
// 提升应用级调试权限     
BOOL EnablePrivilege(HANDLE hToken,LPCTSTR szPrivName,BOOL fEnable)    
{    
    TOKEN_PRIVILEGES tp;    
    tp.PrivilegeCount = 1;    
    LookupPrivilegeValue(NULL,szPrivName,&tp.Privileges[0].Luid);    
    tp.Privileges[0].Attributes = fEnable ? SE_PRIVILEGE_ENABLED:0;    
    AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL);    
    return((GetLastError() == ERROR_SUCCESS));    
}    
// 
///说明: 插入代码,远程线程为RmoteThread()     
///參数: Pid = 进程PID     
///返回: 成功True,否则False     
    
bool InjectExe(DWORD Pid)    
{    
     bool       status = false;    
     LPVOID     pBaseAddr = NULL;    
     HMODULE    hMod = GetModuleHandle(NULL);    
     LONG       hNHOffset = PIMAGE_DOS_HEADER(hMod)->e_lfanew;    
     HANDLE     hThread,    
                hProcess,    
                hToken;    
     DWORD      cbImage;    
    
     //cbImage=内存中整个PE映像体的尺寸     
     cbImage= PIMAGE_NT_HEADERS((DWORD)hMod + (DWORD)hNHOffset)->OptionalHeader.SizeOfImage;    
    
     //重要，否则不能注入lsass     
     OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&hToken);    
     EnablePrivilege(hToken,SE_DEBUG_NAME,TRUE);    
    
     hProcess  = OpenProcess(PROCESS_ALL_ACCESS, TRUE, Pid);    
     if (hProcess == NULL)    
     {    
#ifdef debug     
         MessageBoxA(NULL, "错误OpenProcess", NULL, 64);    
#endif     
         goto Err;    
     }    
    
     //释放远程内存     
     VirtualFreeEx(hProcess, LPVOID(hMod), 0, MEM_RELEASE);    
     //分配远程内存     
     pBaseAddr = VirtualAllocEx(hProcess, LPVOID(hMod), cbImage, MEM_COMMIT | MEM_RESERVE,    
                                PAGE_EXECUTE_READWRITE);    
     if (pBaseAddr == NULL)    
     {    
#ifdef debug     
         MessageBoxA(NULL, "VirtualAllocEx failed", NULL, 64);    
#endif     
         goto Err;    
     }    
    
     //写进去,将本进程的整个PE体 全写进目标进程，够狠～     
     if (!WriteProcessMemory(hProcess, pBaseAddr, LPVOID(hMod), cbImage, NULL))    
     {    
#ifdef debug     
         MessageBoxA(NULL, "WriteProcessMemory failed", NULL, 64);    
#endif     
         goto Err;    
     }    
    
     hThread = CreateRemoteThread(hProcess, NULL, NULL,     
         (LPTHREAD_START_ROUTINE)&RmoteThread, NULL, NULL, NULL);    
     if (hThread == NULL)    
     {    
#ifdef debug     
         MessageBoxA(NULL, "CreateRemoteThread failed", NULL, 64);    
#endif     
         goto Err;    
     }    
    
//   WaitForSingleObject(hThread, INFINITE);     
     CloseHandle(hThread);    
     CloseHandle(hProcess);    
     status = TRUE;    
     return status; //自己返回即可，不要VirtualFreeEx;，否则宿主就挂了!     
Err:    
     if (pBaseAddr != NULL)    
          VirtualFreeEx(hProcess, pBaseAddr, 0, MEM_RELEASE);    
     if (hProcess != NULL)    
         CloseHandle(hProcess);    
    
     return status;    
}    
//     
int main()    
{    
    char aa[]="aBcDdddFFFF asfd";    
    strupr((char*)aa);    
    printf(aa);    
    
     if (!InjectExe(GetProcessID(ProcessName)))    
         Beep(1800,500);    
     return 0;    
}