游戏内存修改器

CMemScanner.h(内存扫描器类):

#ifndef CMEMSCANNER_H
#define  CMEMSCANNER_H

#include  < stdio.h >
#include  " AddrList.h "
#include  " PageList.h "

class  CMemScanner   // 内存扫描器类
{
private :
    HANDLE m_hProcess;   // 待扫描进程句柄
public :
    CAddrList  *  m_lpAddrList;   // 地址列表对象指针
private :
    BOOL EnableDebugPrivilege();   // 提升应用程序权限，使能调试特权函数
    BOOL GetScanRegion(CPageList  *  lpPageList);   // 获取扫描范围
public :
    CMemScanner();   // 类构造函数
     ~ CMemScanner();   // 类析构函数
    BOOL SetProcessForScanner(DWORD dwProcessId);   // 设置欲扫描的进程
    BOOL ScanFirst(DWORD dwValue);   // 第一次扫描函数
    BOOL ScanNext(DWORD dwValue);   // 下一次扫描函数
    BOOL WriteMemory(DWORD dwAddr, DWORD dwValue);   // 修改内存函数
    BOOL ReadMemory(DWORD dwAddr,DWORD  *  lpValue);   // 读取内存函数
};

#endif

CMemScanner.cpp:

#include  " stdafx.h "
#include  " MemScanner.h "

// 类构造函数
CMemScanner::CMemScanner()
{
    m_hProcess  =  NULL;   // 初始化类成员变量
    m_lpAddrList  =  NULL;
    EnableDebugPrivilege();   // 提升应用程序权限，使拥有调试特权
}

// 类析构函数
CMemScanner:: ~ CMemScanner()
{
     if (m_hProcess)
        ::CloseHandle(m_hProcess);
     if (m_lpAddrList)
        delete m_lpAddrList;
}

// 设置欲扫描的进程
BOOL CMemScanner::SetProcessForScanner(DWORD dwProcessId)
{
     if (m_hProcess)
        ::CloseHandle(m_hProcess);
    
    m_hProcess  =  ::OpenProcess(PROCESS_QUERY_INFORMATION  |  PROCESS_VM_READ  |  PROCESS_VM_WRITE  |  PROCESS_VM_OPERATION, FALSE, dwProcessId);   // 打开欲扫描进程句柄
     // m_hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);   // 打开欲扫描进程句柄
     if (m_hProcess)   // OpenProcess函数调用失败返回值为零
         return  TRUE;
     else   
         return  FALSE;
}
    
// 第一次扫描函数
BOOL CMemScanner::ScanFirst(DWORD dwValue)
{
    CPageList  *  lpPageList  =  NULL;
    CAddrList  *  lpAddrList  =  NULL;
     int  i,j;
     char   *  lpBuf  =  NULL;
    MEMORY_BASIC_INFORMATION stMemInfo   =  { 0 };

     if ( ! m_hProcess)
         return  FALSE;

    lpPageList  =   new  CPageList( 100 );   // 构造一个页面列表对象，初始大小或步进值为100个DWORD
     if ( ! GetScanRegion(lpPageList))   // 获取扫描范围
         return  FALSE;
    
    lpAddrList  =   new  CAddrList( 100 );   // 构造一个地址列表对象，初始大小或步进值为100个DWORD
    
     for (i  =   0 ; i  <  lpPageList  -> m_nPageListCnt; i ++ )   // 循环扫描已提交页面
    {
        lpBuf  =   new   char [lpPageList  -> m_lpPageSizeList[i]];
         if ( ! ::ReadProcessMemory(m_hProcess,(LPCVOID)(lpPageList  -> m_lpPageBaseAddrList[i]),lpBuf,lpPageList  -> m_lpPageSizeList[i],NULL))   // 读取已提交的一块内存，失败返回零
        {
             if (lpPageList)
                delete lpPageList;
             return  FALSE;
        }
        
         for (j  =   0 ; j  <  lpPageList  -> m_lpPageSizeList[i]  -   3 ; j ++ )   // 逐个比较这一块已提交的内存
        {
             if (dwValue  ==   * (DWORD  * )(lpBuf  +  j))   // 等于要扫描的值
                lpAddrList  -> AddToAddrList((DWORD)(lpPageList  -> m_lpPageBaseAddrList[i]  +  j));   // 添加数据到地址列表
        }
        
         if (lpBuf)
            delete lpBuf;
    }
     if (m_lpAddrList)   // 删除原地址列表
        delete m_lpAddrList;
    m_lpAddrList  =  lpAddrList;   // 保存新地址列表
     if (lpPageList)   // 删除页面列表
        delete lpPageList;
     return  TRUE;
}

// 下一次扫描函数
BOOL CMemScanner::ScanNext(DWORD dwValue)
{
    CAddrList  *  lpAddrList  =  NULL;
    DWORD dwBuf  =   0 ;
     int  i;

     if ( ! m_hProcess)
         return  FALSE;

    lpAddrList  =   new  CAddrList( 100 );   // 构造一个地址列表对象，初始大小或步进值为100个DWORD

     for (i  =   0 ; i  <  m_lpAddrList  -> m_nAddrListCnt; i ++ )
    {
         if ( ! ::ReadProcessMemory(m_hProcess,(LPCVOID)(m_lpAddrList  -> m_lpAddrList[i]), & dwBuf, sizeof  dwBuf,NULL))
        {
             if (lpAddrList)
                delete lpAddrList;
             return  FALSE;
        }

         if (dwValue  ==  dwBuf)   // 等于要扫描的值
            lpAddrList  -> AddToAddrList(m_lpAddrList  -> m_lpAddrList[i]);   // 添加数据到地址列表
    }
    
     if (m_lpAddrList)   // 删除原地址列表
        delete m_lpAddrList;
    m_lpAddrList  =  lpAddrList;   // 保存新地址列表
     return  TRUE;
}

// 修改内存函数
BOOL CMemScanner::WriteMemory(DWORD dwAddr, DWORD dwValue)
{
    DWORD dwOldProtect;
    MEMORY_BASIC_INFORMATION stMemInfo   =  { 0 };

     if ( ! m_hProcess)
         return  FALSE;

     if ( ! ::VirtualQueryEx(m_hProcess,(LPCVOID)dwAddr, & stMemInfo, sizeof (stMemInfo)))
         return  FALSE;
     if ( ! ::VirtualProtectEx(m_hProcess,(LPVOID)dwAddr, sizeof (DWORD),PAGE_READWRITE, & dwOldProtect))
         return  FALSE;
    
     if (::WriteProcessMemory(m_hProcess,(LPVOID)dwAddr, & dwValue, sizeof (DWORD), NULL))
    {
        ::VirtualProtectEx(m_hProcess,(LPVOID)dwAddr, sizeof (DWORD),dwOldProtect, 0 );
         return  TRUE;
    }
     else
    {
        ::VirtualProtectEx(m_hProcess,(LPVOID)dwAddr, sizeof (DWORD),dwOldProtect, 0 );
         return  FALSE;
    }
}

// 读取内存函数
BOOL CMemScanner::ReadMemory(DWORD dwAddr,DWORD  *  lpValue)
{
     if ( ! m_hProcess)
         return  FALSE;

     return  ::ReadProcessMemory(m_hProcess,(LPVOID)dwAddr,lpValue, sizeof (DWORD), 0 );
}

// 提升应用程序权限，使能调试特权函数
BOOL CMemScanner::EnableDebugPrivilege()
{
    HANDLE hProcess  =  NULL;
    HANDLE hToken  =  NULL;
    LUID uID  =  { 0 };
    TOKEN_PRIVILEGES stToken_Privileges  =  { 0 };

    hProcess  =  ::GetCurrentProcess();   // 获取当前应用程序进程句柄
    
     if ( ! ::OpenProcessToken(hProcess,TOKEN_ADJUST_PRIVILEGES, & hToken))   // 打开当前进程的访问令牌句柄(OpenProcessToken函数调用失败返回值为零)
         return  FALSE;

     if ( ! ::LookupPrivilegeValue(NULL,SE_DEBUG_NAME, & uID))   // 获取权限名称为"SetDebugPrivilege"的LUID(LookupPrivilegeValue函数调用失败返回值为零)
         return  FALSE;

    stToken_Privileges.PrivilegeCount  =   1 ;   // 欲调整的权限个数
    stToken_Privileges.Privileges[ 0 ].Luid  =  uID;   // 权限的LUID
    stToken_Privileges.Privileges[ 0 ].Attributes  =  SE_PRIVILEGE_ENABLED;   // 权限的属性,SE_PRIVILEGE_ENABLED为使能该权限
    
     if ( ! ::AdjustTokenPrivileges(hToken,FALSE, & stToken_Privileges, sizeof  stToken_Privileges,NULL,NULL))   // 调整访问令牌里的指定权限(AdjustTokenPrivileges函数调用失败返回值为零)
         return  FALSE;

     if (::GetLastError()  !=  ERROR_SUCCESS)   // 查看权限是否调整成功
         return  FALSE;

    ::CloseHandle(hToken);
     return  TRUE;
}

// 获取扫描范围
BOOL CMemScanner::GetScanRegion(CPageList  *  lpPageList)
{
    SYSTEM_INFO stSysInfo  =  { 0 };
     int  nAppStartAddr  =   0 ,nAppEndAddr  =   0 ;
    MEMORY_BASIC_INFORMATION stMemInfo   =  { 0 };
     int  i;

    ::GetSystemInfo( & stSysInfo);
    nAppStartAddr  =  ( int )stSysInfo.lpMinimumApplicationAddress;   // 应用程序私有地址空间的起始地址
    nAppEndAddr  =  ( int )stSysInfo.lpMaximumApplicationAddress;   // 应用程序私有地址空间的终止地址
    
     for (i  =  nAppStartAddr; i  <  nAppEndAddr;)
    {
         if ( ! ::VirtualQueryEx(m_hProcess,(LPCVOID)i, & stMemInfo, sizeof (stMemInfo)))   // 查询基地址从i开始的页面的属性
             return  FALSE;

         if (stMemInfo.State  ==  MEM_COMMIT)   // 该页面是已提交的并且属性是可读写和可执行的
             if (stMemInfo.Protect  ==  PAGE_READWRITE  ||  stMemInfo.Protect  ==  PAGE_EXECUTE_READWRITE)
                lpPageList  -> AddToPageList((DWORD)stMemInfo.BaseAddress,(DWORD)stMemInfo.RegionSize);   // 添加数据到页面列表
        
        i  =  i  +  stMemInfo.RegionSize;   // 跳到下一个页面基址
    }
     return  TRUE;
}

AddrList.h(地址列表类):

#ifndef CADDRLIST_H
#define  CADDRLIST_H

#include  < windows.h >

class  CAddrList
{
private :
     int  m_nAddrListMaxCnt;   // 地址列表最大计数
     int  m_nStep;   // 调用realloc时相对原列表空间大小的步进值
public :
    DWORD  *  m_lpAddrList;   // 地址列表指针
     int  m_nAddrListCnt;   // 地址列表计数
public :
    CAddrList( int  nStep);   // 类构造函数
     ~ CAddrList();   // 类析构函数
     void  AddToAddrList(DWORD dwAddr);   // 添加数据到地址列表
};

#endif

AddrList.cpp

#include  " stdafx.h "
#include  " AddrList.h "

// 类构造函数
CAddrList::CAddrList( int  nStep)
{
    m_nAddrListCnt  =   0 ;
    m_nStep  =  nStep;
    m_nAddrListMaxCnt  =  nStep;
    m_lpAddrList  =  (DWORD  * )malloc(m_nAddrListMaxCnt  *   sizeof (DWORD));
}

// 类析构函数
CAddrList:: ~ CAddrList()
{
     if (m_lpAddrList)
        free(m_lpAddrList);
}

// 添加数据到地址列表
void  CAddrList::AddToAddrList(DWORD dwAddr)
{
     if (m_nAddrListMaxCnt  <=  m_nAddrListCnt)
    {
        m_nAddrListMaxCnt  =  m_nAddrListMaxCnt  +  m_nStep;
        m_lpAddrList  =  (DWORD  * )realloc(m_lpAddrList,m_nAddrListMaxCnt   *   sizeof (DWORD));
    }
    m_lpAddrList[m_nAddrListCnt]  =  dwAddr;
    m_nAddrListCnt ++ ;
}

PageList.h(页面列表类):

#ifndef CPAGELIST_H
#define  CPAGELIST_H

#include  < windows.h >

class  CPageList   // 页面列表类
{
private :
     int  m_nPageListMaxCnt;   // 页面列表最大计数(以上两个列表的计数，相同)
     int  m_nStep;   // 每次realloc时相对原来空间大小的步进值
public :
    DWORD  *  m_lpPageBaseAddrList;   // 页面基址列表指针
    DWORD  *  m_lpPageSizeList;   // 页面大小列表指针
     int  m_nPageListCnt;   // 页面列表计数(以上两个列表的计数，相同)
public :
    CPageList( int  nStep);   // 类构造函数
     ~ CPageList();   // 类析构函数
     void  AddToPageList(DWORD dwPageBaseAddr,DWORD dwPageSize);   // 添加数据到页面列表
};

#endif

PageList..cpp

#include  " stdafx.h "
#include  " PageList.h "

// 类构造函数
CPageList::CPageList( int  nStep)
{
    m_nPageListCnt  =   0 ;
    m_nStep  =  nStep;
    m_nPageListMaxCnt  =  nStep;
    m_lpPageBaseAddrList  =  (DWORD  * )malloc(m_nPageListMaxCnt  *   sizeof (DWORD));
    m_lpPageSizeList  =  (DWORD  * )malloc(m_nPageListMaxCnt  *   sizeof (DWORD));
}

// 类析构函数
CPageList:: ~ CPageList()
{
     if (m_lpPageBaseAddrList)
        free(m_lpPageBaseAddrList);
     if (m_lpPageSizeList)
        free(m_lpPageSizeList);
}

// 添加数据到页面列表
void  CPageList::AddToPageList(DWORD dwPageBaseAddr,DWORD dwPageSize)
{
     if (m_nPageListMaxCnt  <=  m_nPageListCnt)
    {
        m_nPageListMaxCnt  =  m_nPageListMaxCnt  +  m_nStep;
        m_lpPageBaseAddrList  =  (DWORD  * )realloc(m_lpPageBaseAddrList,m_nPageListMaxCnt  *   sizeof (DWORD));
        m_lpPageSizeList  =  (DWORD  * )realloc(m_lpPageSizeList,m_nPageListMaxCnt  *   sizeof (DWORD));
    }
     // char Buf[128] = {0};
     // sprintf(Buf,"总%d,当%d",m_nPageListMaxCnt,m_nPageListCnt);
     // MessageBox(NULL,Buf,"222",0);
    m_lpPageBaseAddrList[m_nPageListCnt]  =  dwPageBaseAddr;   // 该页面的基址
    m_lpPageSizeList[m_nPageListCnt]  =  dwPageSize;   // 该页的大小
    m_nPageListCnt ++ ;
}

GameEditor.h(应用程序类)

//  GameEditor.h : main header file for the GAMEEDITOR application
//

#if  !defined(AFX_GAMEEDITOR_H__AC0A553E_7E31_49B9_BA63_FF72A2CE15F8__INCLUDED_)
#define  AFX_GAMEEDITOR_H__AC0A553E_7E31_49B9_BA63_FF72A2CE15F8__INCLUDED_

#if  _MSC_VER > 1000
#pragma  once
#endif   //  _MSC_VER > 1000

#ifndef __AFXWIN_H__
     #error  include 'stdafx.h' before including this file for PCH
#endif

#include  " resource.h "          //  main symbols

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorApp:
//  See GameEditor.cpp for the implementation of this class
//

class  CGameEditorApp :  public  CWinApp
{
public :
    CGameEditorApp();

//  Overrides
     //  ClassWizard generated virtual function overrides
     // {{AFX_VIRTUAL(CGameEditorApp)
     public :
     virtual  BOOL InitInstance();
     // }}AFX_VIRTUAL

//  Implementation

     // {{AFX_MSG(CGameEditorApp)
         //  NOTE - the ClassWizard will add and remove member functions here.
         //     DO NOT EDIT what you see in these blocks of generated code !
     // }}AFX_MSG
    DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////// //

// {{AFX_INSERT_LOCATION}}
//  Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif   //  !defined(AFX_GAMEEDITOR_H__AC0A553E_7E31_49B9_BA63_FF72A2CE15F8__INCLUDED_)

GameEditor.cpp

//  GameEditor.cpp : Defines the class behaviors for the application.
//

#include  " stdafx.h "
#include  " GameEditor.h "
#include  " GameEditorDlg.h "

#ifdef _DEBUG
#define  new DEBUG_NEW
#undef  THIS_FILE
static   char  THIS_FILE[]  =  __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorApp

BEGIN_MESSAGE_MAP(CGameEditorApp, CWinApp)
     // {{AFX_MSG_MAP(CGameEditorApp)
         //  NOTE - the ClassWizard will add and remove mapping macros here.
         //     DO NOT EDIT what you see in these blocks of generated code!
     // }}AFX_MSG
    ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorApp construction

CGameEditorApp::CGameEditorApp()
{
     //  TODO: add construction code here,
     //  Place all significant initialization in InitInstance
}

/////////////////////////////////////////////////////////////////////////// //
//  The one and only CGameEditorApp object

CGameEditorApp theApp;

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorApp initialization

BOOL CGameEditorApp::InitInstance()
{
    AfxEnableControlContainer();

     //  Standard initialization
     //  If you are not using these features and wish to reduce the size
     //   of your final executable, you should remove from the following
     //   the specific initialization routines you do not need.

#ifdef _AFXDLL
    Enable3dControls();             //  Call this when using MFC in a shared DLL
#else
    Enable3dControlsStatic();     //  Call this when linking to MFC statically
#endif

    CGameEditorDlg dlg;
    m_pMainWnd  =   & dlg;
     int  nResponse  =  dlg.DoModal();
     if  (nResponse  ==  IDOK)
    {
         //  TODO: Place code here to handle when the dialog is
         //   dismissed with OK
    }
     else   if  (nResponse  ==  IDCANCEL)
    {
         //  TODO: Place code here to handle when the dialog is
         //   dismissed with Cancel
    }

     //  Since the dialog has been closed, return FALSE so that we exit the
     //   application, rather than start the application's message pump.
     return  FALSE;
}

GameEditorDlg.h(主对话框类)

//  GameEditorDlg.h : header file
//

#if  !defined(AFX_GAMEEDITORDLG_H__457F57F1_F4EA_4B2B_BA4C_3220F297B11F__INCLUDED_)
#define  AFX_GAMEEDITORDLG_H__457F57F1_F4EA_4B2B_BA4C_3220F297B11F__INCLUDED_

#if  _MSC_VER > 1000
#pragma  once
#endif   //  _MSC_VER > 1000

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorDlg dialog
#include  " MemScanner.h "    // 包含内存扫描器类头文件

class  CGameEditorDlg :  public  CDialog
{
//  Construction
public :
    CGameEditorDlg(CWnd *  pParent  =  NULL);     //  standard constructor

public :
     void  UpdataProcessList();   // 更新进程列表函数
     void  UpdataAddrList();   // 更新地址列表函数

//  Dialog Data
     // {{AFX_DATA(CGameEditorDlg)
     enum  { IDD  =  IDD_GAMEEDITOR_DIALOG };
    CListCtrl    m_clsAddrList;
    CListCtrl    m_clsProcessList;
     // }}AFX_DATA

     //  ClassWizard generated virtual function overrides
     // {{AFX_VIRTUAL(CGameEditorDlg)
     public :
     virtual  BOOL PreTranslateMessage(MSG *  pMsg);
     protected :
     virtual   void  DoDataExchange(CDataExchange *  pDX);     //  DDX/DDV support
     // }}AFX_VIRTUAL

//  Implementation
protected :
    HICON m_hIcon;
    BOOL m_bFirst;   // 是否是第一次搜索标志
public :
    CMemScanner m_clsMemScanner;   // 内存扫描器对象

     //  Generated message map functions
     // {{AFX_MSG(CGameEditorDlg)
     virtual  BOOL OnInitDialog();
    afx_msg  void  OnPaint();
    afx_msg HCURSOR OnQueryDragIcon();
    afx_msg  void  OnSearch();
    afx_msg  void  OnDblclkProcesslist(NMHDR *  pNMHDR, LRESULT *  pResult);
    afx_msg  void  OnReset();
    afx_msg  void  OnDblclkAddrlist(NMHDR *  pNMHDR, LRESULT *  pResult);
     // }}AFX_MSG
    DECLARE_MESSAGE_MAP()
};

// {{AFX_INSERT_LOCATION}}
//  Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif   //  !defined(AFX_GAMEEDITORDLG_H__457F57F1_F4EA_4B2B_BA4C_3220F297B11F__INCLUDED_)

GameEditorDlg.cpp

//  GameEditorDlg.cpp : implementation file
//

#include  " stdafx.h "
#include  " GameEditor.h "
#include  " GameEditorDlg.h "
#include  < tlhelp32.h >

#ifdef _DEBUG
#define  new DEBUG_NEW
#undef  THIS_FILE
static   char  THIS_FILE[]  =  __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorDlg dialog
#include  " ModifyDlg.h "    //

CGameEditorDlg::CGameEditorDlg(CWnd *  pParent  /* =NULL */ )
    : CDialog(CGameEditorDlg::IDD, pParent)
{
     // {{AFX_DATA_INIT(CGameEditorDlg)
         //  NOTE: the ClassWizard will add member initialization here
     // }}AFX_DATA_INIT
     //  Note that LoadIcon does not require a subsequent DestroyIcon in Win32
    m_hIcon  =  AfxGetApp() -> LoadIcon(IDR_MAINFRAME);
}

void  CGameEditorDlg::DoDataExchange(CDataExchange *  pDX)
{
    CDialog::DoDataExchange(pDX);
     // {{AFX_DATA_MAP(CGameEditorDlg)
    DDX_Control(pDX, IDL_ADDRLIST, m_clsAddrList);
    DDX_Control(pDX, IDL_PROCESSLIST, m_clsProcessList);
     // }}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CGameEditorDlg, CDialog)
     // {{AFX_MSG_MAP(CGameEditorDlg)
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_BN_CLICKED(IDB_SEARCH, OnSearch)
    ON_NOTIFY(NM_DBLCLK, IDL_PROCESSLIST, OnDblclkProcesslist)
    ON_BN_CLICKED(IDB_RESET, OnReset)
    ON_NOTIFY(NM_DBLCLK, IDL_ADDRLIST, OnDblclkAddrlist)
     // }}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////// //
//  CGameEditorDlg message handlers

BOOL CGameEditorDlg::OnInitDialog()
{
    CDialog::OnInitDialog();

     //  Set the icon for this dialog.  The framework does this automatically
     //   when the application's main window is not a dialog
    SetIcon(m_hIcon, TRUE);             //  Set big icon
    SetIcon(m_hIcon, FALSE);         //  Set small icon
    
     //  TODO: Add extra initialization here
    DWORD dwStyle;

    m_clsProcessList.InsertColumn( 0 , " Name " ,LVCFMT_IMAGE  |  LVCFMT_LEFT, 120 );   // 初始化进程列表框控件
    m_clsProcessList.InsertColumn( 1 , " PID " ,LVCFMT_CENTER, 50 );

    dwStyle  =  m_clsProcessList.GetExtendedStyle();
    dwStyle  =  dwStyle  |  LVS_EX_FULLROWSELECT  |  LVS_EX_GRIDLINES;   // 设置选择一整行和高亮显示选择行的扩展风格
    m_clsProcessList.SetExtendedStyle(dwStyle);

    m_clsAddrList.InsertColumn( 0 , " 序号 " ,LVCFMT_CENTER, 80 );   // 初始化地址列表框控件
    m_clsAddrList.InsertColumn( 1 , " 地址 " ,LVCFMT_CENTER, 120 );
    m_clsAddrList.InsertColumn( 2 , " 当前值 " ,LVCFMT_CENTER, 130 );

    dwStyle  =  m_clsAddrList.GetExtendedStyle();
    dwStyle  =  dwStyle  |  LVS_EX_FULLROWSELECT  |  LVS_EX_GRIDLINES;   // 设置选择一整行和高亮显示选择行的扩展风格
    m_clsAddrList.SetExtendedStyle(dwStyle);

    m_bFirst  =  TRUE;
    UpdataProcessList();   // 更新进程列表
     return  TRUE;   //  return TRUE  unless you set the focus to a control
}

//  If you add a minimize button to your dialog, you will need the code below
//   to draw the icon.  For MFC applications using the document/view model,
//   this is automatically done for you by the framework.

void  CGameEditorDlg::OnPaint() 
{
     if  (IsIconic())
    {
        CPaintDC dc( this );  //  device context for painting

        SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(),  0 );

         //  Center icon in client rectangle
         int  cxIcon  =  GetSystemMetrics(SM_CXICON);
         int  cyIcon  =  GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect( & rect);
         int  x  =  (rect.Width()  -  cxIcon  +   1 )  /   2 ;
         int  y  =  (rect.Height()  -  cyIcon  +   1 )  /   2 ;

         //  Draw the icon
        dc.DrawIcon(x, y, m_hIcon);
    }
     else
    {
        CDialog::OnPaint();
    }
}

//  The system calls this to obtain the cursor to display while the user drags
//   the minimized window.
HCURSOR CGameEditorDlg::OnQueryDragIcon()
{
     return  (HCURSOR) m_hIcon;
}

void  CGameEditorDlg::OnSearch()   // 搜索按钮单击事件处理过程
{
     //  TODO: Add your control notification handler code here
    DWORD dwProcessId,dwValue;
    CString strTip;

     if (GetDlgItem(IDE_PID)  -> GetWindowTextLength()  <=   0 )
    {
        MessageBox( " 请双击进程列表框选择一个目标进程！ " );
         return ;
    }

     if (GetDlgItem(IDE_SEARCH)  -> GetWindowTextLength()  <=   0 )
    {
        MessageBox( " 请输入一个搜索值！ " );
        GetDlgItem(IDE_SEARCH)  -> SetFocus();
         return ;
    }

    dwProcessId  =  GetDlgItemInt(IDE_PID);   // 获取进程ID文本框的值
    dwValue  =  GetDlgItemInt(IDE_SEARCH);   // 获取用户输入搜索文本框的值

     if (m_bFirst)   // 第一次搜索
    {
         if ( ! m_clsMemScanner.SetProcessForScanner(dwProcessId))
        {
            MessageBox( " 打开目标进程时失败！ " );
             return ;
        }
        m_clsMemScanner.ScanFirst(dwValue);
         if (m_clsMemScanner.m_lpAddrList  -> m_nAddrListCnt)
            m_bFirst  =  FALSE;
    }
     else
    {
        m_clsMemScanner.ScanNext(dwValue);
    }
    UpdataAddrList();   // 更新地址列表
    
    strTip.Format( " 总共搜索到%d个结果！ " ,(m_clsMemScanner.m_lpAddrList  -> m_nAddrListCnt));
    MessageBox(strTip);
}

void  CGameEditorDlg::UpdataProcessList()   // 更新进程列表函数
{
    HANDLE hSnapShot;
    PROCESSENTRY32 stProcessEntry32  =  { 0 };
     int  nIndex;
    CString strItemText;

    hSnapShot  =  ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0 );
     if (hSnapShot  ==  INVALID_HANDLE_VALUE)
         return ;

    m_clsProcessList.DeleteAllItems();   // 删除进程列表框所有项
    nIndex  =   0 ;

    stProcessEntry32.dwSize  =   sizeof  stProcessEntry32;
     if (::Process32First(hSnapShot, & stProcessEntry32))
    { 
         do
        {     
            strItemText  =  stProcessEntry32.szExeFile;
            m_clsProcessList.InsertItem(nIndex,strItemText, 0 );
            strItemText.Format( " %d " ,stProcessEntry32.th32ProcessID);
            m_clsProcessList.SetItemText(nIndex, 1 ,strItemText);
            nIndex ++ ;
        } 
         while (::Process32Next(hSnapShot,  & stProcessEntry32)); 
    }
     // strItemText.Format("总共进程数：%d",nIndex);
     // MessageBox(strItemText);
    ::CloseHandle(hSnapShot);
}

void  CGameEditorDlg::OnDblclkProcesslist(NMHDR *  pNMHDR, LRESULT *  pResult)   // 进程列表框鼠标双击事件处理过程
{
     //  TODO: Add your control notification handler code here
     int  nIndex;
    CString strItemText;

    nIndex  =  ( int )m_clsProcessList.GetFirstSelectedItemPosition();   // 获取进程列表框当前所选择的行的索引号(从1开始)
     if ( ! nIndex)   // 索引号为0则未选择任何一行
         return ;

    strItemText  =  m_clsProcessList.GetItemText(nIndex  -   1 , 0 );   // 获取进程列表框指定行和列的文本值(从0开始);
    SetDlgItemText(IDE_PNAME,strItemText);   // 设置进程名称文本框内容
    strItemText  =  m_clsProcessList.GetItemText(nIndex  -   1 , 1 );   // 获取进程列表框指定行和列的文本值(从0开始);
    SetDlgItemText(IDE_PID,strItemText);   // 设置进程ID文本框内容
    m_bFirst  =  TRUE;

     * pResult  =   0 ;
}

void  CGameEditorDlg::UpdataAddrList()   // 更新地址列表函数
{
     int  nCount,i;
    DWORD dwAddr,dwValue  =   0 ;
    CString strItemText;

    m_clsAddrList.DeleteAllItems();   // 删除地址列表框所有项

    nCount  =  m_clsMemScanner.m_lpAddrList  -> m_nAddrListCnt;
     for (i  =   0 ; i  <  nCount; i ++ )
    {
        dwAddr  =  m_clsMemScanner.m_lpAddrList  -> m_lpAddrList[i];
        m_clsMemScanner.ReadMemory(dwAddr, & dwValue);
        strItemText.Format( " %d " ,i  +   1 );
        m_clsAddrList.InsertItem(i,strItemText, 0 );
        strItemText.Format( " 0x%08X " ,dwAddr);
        m_clsAddrList.SetItemText(i, 1 ,strItemText);
        strItemText.Format( " %d " ,dwValue);
        m_clsAddrList.SetItemText(i, 2 ,strItemText);
    }
}

void  CGameEditorDlg::OnReset()   // 重置按钮单击事件处理过程
{
     //  TODO: Add your control notification handler code here
    m_bFirst  =  TRUE;
}

void  CGameEditorDlg::OnDblclkAddrlist(NMHDR *  pNMHDR, LRESULT *  pResult)   // 地址列表框鼠标双击事件处理过程
{
     //  TODO: Add your control notification handler code here
     int  nIndex  =   0 ;
    
    nIndex  =  ( int )m_clsAddrList.GetFirstSelectedItemPosition();   // 获取进程列表框当前所选择的行的索引号(从1开始)
     if ( ! nIndex)   // 索引号为0则未选择任何一行
         return ;
    
    CModifyDlg clsModifyDlg  =   new  CModifyDlg( this );
    clsModifyDlg.m_lpMainDlg  =   this ;
    clsModifyDlg.m_strModifyAddr  =  m_clsAddrList.GetItemText(nIndex  -   1 , 1 );   // 获取进程列表框指定行和列的文本值(从0开始);
     if (clsModifyDlg.DoModal()  ==   1 )   // 显示修改内存模态对话框
        UpdataAddrList();   // 更新地址列表
    delete clsModifyDlg;

     * pResult  =   0 ;
}

BOOL CGameEditorDlg::PreTranslateMessage(MSG *  pMsg) 
{
     //  TODO: Add your specialized code here and/or call the base class
     if (pMsg  ->  message  ==  WM_KEYDOWN)
    {
         switch (pMsg  ->  wParam)
        {
         case  VK_RETURN:   // 屏蔽回车键
         case  VK_ESCAPE:   // 屏蔽ESC键
             return  TRUE;
        }
    }
     return  CDialog::PreTranslateMessage(pMsg);
}

ModifyDlg.h(修改对话框类)

#if  !defined(AFX_MODIFYDLG_H__540F01D9_9707_4D58_885D_3131C1FA4AB8__INCLUDED_)
#define  AFX_MODIFYDLG_H__540F01D9_9707_4D58_885D_3131C1FA4AB8__INCLUDED_

#if  _MSC_VER > 1000
#pragma  once
#endif   //  _MSC_VER > 1000
//  ModifyDlg.h : header file
//

/////////////////////////////////////////////////////////////////////////// //
//  CModifyDlg dialog
#include  " GameEditorDlg.h "

class  CModifyDlg :  public  CDialog
{
//  Construction
public :
    CModifyDlg(CWnd *  pParent  =  NULL);    //  standard constructor

//  Dialog Data
     // {{AFX_DATA(CModifyDlg)
     enum  { IDD  =  IDD_MODIFYDLG };
         //  NOTE: the ClassWizard will add data members here
     // }}AFX_DATA


//  Overrides
     //  ClassWizard generated virtual function overrides
     // {{AFX_VIRTUAL(CModifyDlg)
     public :
     virtual  BOOL PreTranslateMessage(MSG *  pMsg);
     protected :
     virtual   void  DoDataExchange(CDataExchange *  pDX);     //  DDX/DDV support
     // }}AFX_VIRTUAL

//  Implementation
protected :
    HICON m_hIcon;
public :
    CGameEditorDlg  *  m_lpMainDlg;   // 主窗口对象指针
    CString m_strModifyAddr;   // 从主窗口传递过来的用户欲修改的内存的地址值

     //  Generated message map functions
     // {{AFX_MSG(CModifyDlg)
    afx_msg HBRUSH OnCtlColor(CDC *  pDC, CWnd *  pWnd, UINT nCtlColor);
    afx_msg  void  OnOk();
     virtual  BOOL OnInitDialog();
    afx_msg  void  OnCancel();
     // }}AFX_MSG
    DECLARE_MESSAGE_MAP()
};

// {{AFX_INSERT_LOCATION}}
//  Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif   //  !defined(AFX_MODIFYDLG_H__540F01D9_9707_4D58_885D_3131C1FA4AB8__INCLUDED_)

ModifyDlg.cpp

//  ModifyDlg.cpp : implementation file
//

#include  " stdafx.h "
#include  " GameEditor.h "
#include  " ModifyDlg.h "

#ifdef _DEBUG
#define  new DEBUG_NEW
#undef  THIS_FILE
static   char  THIS_FILE[]  =  __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////// //
//  CModifyDlg dialog


CModifyDlg::CModifyDlg(CWnd *  pParent  /* =NULL */ )
    : CDialog(CModifyDlg::IDD, pParent)
{
     // {{AFX_DATA_INIT(CModifyDlg)
         //  NOTE: the ClassWizard will add member initialization here
     // }}AFX_DATA_INIT
    m_hIcon  =  AfxGetApp() -> LoadIcon(IDR_MAINFRAME);
}


void  CModifyDlg::DoDataExchange(CDataExchange *  pDX)
{
    CDialog::DoDataExchange(pDX);
     // {{AFX_DATA_MAP(CModifyDlg)
         //  NOTE: the ClassWizard will add DDX and DDV calls here
     // }}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CModifyDlg, CDialog)
     // {{AFX_MSG_MAP(CModifyDlg)
    ON_WM_CTLCOLOR()
    ON_BN_CLICKED(IDB_OK, OnOk)
    ON_BN_CLICKED(IDB_CANCEL, OnCancel)
     // }}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////// //
//  CModifyDlg message handlers

HBRUSH CModifyDlg::OnCtlColor(CDC *  pDC, CWnd *  pWnd, UINT nCtlColor) 
{
    HBRUSH hbr  =  CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
    
     //  TODO: Change any attributes of the DC here
     if (pWnd  ->  GetDlgCtrlID()  ==  IDE_ADDR)
    {
        pDC -> SetBkColor(RGB( 255 , 255 , 255 ));
        pDC -> SetTextColor(RGB( 255 , 0 , 0 ));   
         return  (HBRUSH)GetStockObject(WHITE_BRUSH);
    }
     //  TODO: Return a different brush if the default is not desired
     return  hbr;
}

void  CModifyDlg::OnOk()   // 确定按钮单击事件处理过程
{
     //  TODO: Add your control notification handler code here
    DWORD dwAddr  =   0 ,dwValue  =   0 ;

     if (GetDlgItem(IDE_VALUE)  -> GetWindowTextLength()  <=   0 )
         return ;

    m_strModifyAddr  =  m_strModifyAddr.Mid( 2 );   // 去掉"0x"
    sscanf(m_strModifyAddr, " %x " , & dwAddr);   // 转换成数字

    dwValue  =  GetDlgItemInt(IDE_VALUE);
    m_lpMainDlg  -> m_clsMemScanner.WriteMemory(dwAddr,dwValue);   // 修改内存
    MessageBox( " 修改成功！ " );
    EndDialog( 1 );
}

BOOL CModifyDlg::OnInitDialog()   // 对话框初始化函数
{
    CDialog::OnInitDialog();
    
     //  TODO: Add extra initialization here
    SetIcon(m_hIcon, TRUE);             //  Set big icon
    SetIcon(m_hIcon, FALSE);         //  Set small icon

    SetDlgItemText(IDE_ADDR,m_strModifyAddr);   // 设置目标地址文本框内容

     return  TRUE;   //  return TRUE unless you set the focus to a control
                   //  EXCEPTION: OCX Property Pages should return FALSE
}

void  CModifyDlg::OnCancel()   // 取消对话框单击事件处理过程
{
     //  TODO: Add your control notification handler code here
    EndDialog( 0 );
}

BOOL CModifyDlg::PreTranslateMessage(MSG *  pMsg) 
{
     //  TODO: Add your specialized code here and/or call the base class
     if (pMsg  ->  message  ==  WM_KEYDOWN)
    {
         switch (pMsg  ->  wParam)
        {
         case  VK_RETURN:   // 屏蔽回车键
         case  VK_ESCAPE:   // 屏蔽ESC键
             return  TRUE;
        }
    }
     return  CDialog::PreTranslateMessage(pMsg);
}