内存修改器


 

 

#include <windows.h>
#include <iostream>
#include <Tlhelp32.h>
#include <process.h>
#include <commctrl.h>
#include "resource.h"

#pragma comment(lib,"comctl32.lib")

#define ID_STATUSBAR  1
#define ID_TIME	100
using namespace std;

BOOL CALLBACK DialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK GetProcessList (HWND hwnd);
BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
BOOL EnablePrivilege(PCTSTR szPrivilege, BOOL fEnable);
HWND	hList1;
HWND	hList2;
HWND	hWinStatus;
bool	lock;

typedef struct 
{
	DWORD	value;
	HANDLE  hProcess;
}arglist;


#include "Search.h"

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
{
	InitCommonControls();
	EnablePrivilege(SE_DEBUG_NAME, TRUE);
	DialogBoxParam (hInstance, MAKEINTRESOURCE(IDD_DIALOG), NULL, DialogProc, 0);
	EnablePrivilege(SE_DEBUG_NAME, FALSE);
	return 1;
}

BOOL CALLBACK DialogProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	HICON	hIcon;
	static HINSTANCE	hInstance	= GetModuleHandle (NULL);
	static int ID,index;
	static HWND	hEdit1,hEdit2,hEdit3;
	static TCHAR	szBuffer[10];
	static arglist	arg;
	static TCHAR szFree[]=L"   空闲中......";
	static TCHAR szSearch[]=L"  搜索中,请耐心等候......";
	static TCHAR szLock[]=L"取消锁定";
	static TCHAR szUnlock[]=L"内存数值锁定";
	static DWORD var,addr;
	static HBITMAP	hBitmap;

	switch (message)
	{
		case WM_INITDIALOG:
			hIcon	= LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1) );
			SendMessage (hwnd,WM_SETICON,ICON_BIG, (LPARAM)hIcon);
			
			hEdit1	= GetDlgItem(hwnd, IDC_EDIT1);
			hEdit2	= GetDlgItem(hwnd, IDC_EDIT2);
			hEdit3	= GetDlgItem(hwnd, IDC_EDIT3);
			SendDlgItemMessage (hwnd, IDC_EDIT1,EM_LIMITTEXT, 8,  0);
			SendDlgItemMessage (hwnd, IDC_EDIT2,EM_LIMITTEXT, 12, 0);
			SendDlgItemMessage (hwnd, IDC_EDIT3, EM_LIMITTEXT, 8, 0);

			hList1	= GetDlgItem (hwnd, IDC_LIST1);
			hList2	= GetDlgItem (hwnd, IDC_LIST2);
			EnableWindow (GetDlgItem (hwnd, IDC_BUTTON3), FALSE);//灰化修改按钮
			EnableWindow (GetDlgItem (hwnd, IDC_BUTTON1), FALSE);

			hWinStatus	= CreateStatusWindow(WS_CHILD | WS_VISIBLE | SBS_SIZEGRIP,NULL,hwnd,ID_STATUSBAR);
			//SendMessage,hWinStatus,SB_SETPARTS,4,offset dwStatusWidth
			SendMessage(hWinStatus,SB_SETTEXT,0, (LPARAM)szFree);

			GetProcessList (hwnd);
			return true;

		case WM_COMMAND:
			switch (LOWORD (wParam))
			{
				case IDC_LIST1:
					break;

				case IDC_LIST2:
					char item[20];
					if (HIWORD(wParam) == LBN_SELCHANGE)
					{
						index	= SendMessage (hList2, LB_GETCURSEL,0, 0);
						SendMessageA (hList2, LB_GETTEXT, index, (LPARAM)item);
						SetDlgItemTextA (hwnd, IDC_EDIT2, item);
					}
					break;

				case IDOK:
					GetProcessList(hwnd);//刷新
					break;

				case IDCANCEL:
					EndDialog (hwnd, 0);
					break;

				case IDC_EDIT1:
					EnableWindow(GetDlgItem(hwnd, IDC_BUTTON1), GetDlgItemText (hwnd, IDC_EDIT1, szBuffer, 4)) ;
					break;

				case IDC_EDIT3:
					EnableWindow(GetDlgItem(hwnd, IDC_BUTTON3), GetDlgItemText (hwnd, IDC_EDIT3, szBuffer, 4)) ;
					break;

				case IDC_BUTTON1:
					DWORD value;
					HANDLE	hProcess;

					value	= GetDlgItemInt (hwnd, IDC_EDIT1,NULL, FALSE);
					//if (!value)
					{
					//	MessageBox (hwnd, TEXT("请输入搜索数值"), NULL, MB_OK);
					//	break;
					}
					index	= SendMessage (hList1, LB_GETCURSEL,0, 0);
					ID		= SendMessage (hList1, LB_GETITEMDATA, index, 0);
					EnableWindow(GetDlgItem(hwnd, IDC_LIST1), FALSE) ;
					//if ( hProcess = OpenProcess (PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, NULL, ID) )
					if ( hProcess = OpenProcess (PROCESS_VM_READ|PROCESS_VM_WRITE|PROCESS_VM_OPERATION, NULL, ID) )
						//if (!Search (hProcess, value))
						//	MessageBox (hwnd, TEXT("搜索失败"), NULL, MB_OK);
					{
						arg.hProcess	= hProcess;
						arg.value		= value;
						SendMessage (hList2, LB_RESETCONTENT, 0, 0);
						_beginthread(Search,NULL, &arg);
						SendMessage(hWinStatus,SB_SETTEXT,0, (LPARAM)szSearch);
					}
					else
					{
						MessageBox (hwnd, TEXT("打开进程失败"), NULL, MB_OK);
						EnableWindow(GetDlgItem(hwnd, IDC_LIST1), TRUE) ;
					}
					break;

				case IDC_BUTTON2:
					SendMessage (hList2, LB_RESETCONTENT, 0, 0);
					Init();
					EnableWindow(GetDlgItem(hwnd, IDC_LIST1), TRUE) ;
					SendMessage(hWinStatus,SB_SETTEXT,0, (LPARAM)szFree);
					break;

				case IDC_BUTTON3:
					char szNum[12];
					GetDlgItemTextA(hwnd, IDC_EDIT2,szNum,sizeof(szNum));
					sscanf (szNum,"%lX",&addr);
					var	= GetDlgItemInt (hwnd, IDC_EDIT3, NULL, FALSE);
					
					if (!var)
					{
						MessageBox (hwnd, TEXT("请输入修改数值"), NULL, MB_OK);
						break;
					}
					if (WriteMemory (addr, var))
						MessageBox (hwnd, TEXT("修改成功!"), TEXT("提示"), MB_OK);
					else
						MessageBox (hwnd, TEXT("修改失败!"), NULL, MB_OK);
					break;

				case IDC_BUTTON4:
					if (lock == false)
					{
						SendMessage (hwnd, WM_COMMAND, IDC_BUTTON3, 0);
						if (!var)
						{
							break;
						}
						EnableWindow (GetDlgItem (hwnd, IDC_BUTTON1), FALSE);//灰化按钮
						EnableWindow (GetDlgItem (hwnd, IDC_BUTTON2), FALSE);
						EnableWindow (GetDlgItem (hwnd, IDC_BUTTON3), FALSE);
						EnableWindow (hEdit1, FALSE);
						EnableWindow (hEdit2, FALSE);
						EnableWindow (hEdit3, FALSE);
						
						SetTimer (hwnd, ID_TIME, 100, NULL);
						SetDlgItemText(hwnd, IDC_BUTTON4, szLock);
						SendMessage(hWinStatus,SB_SETTEXT,0, (LPARAM)TEXT("内存锁定中..."));
						lock	= true;
					}
					else
					{
						KillTimer (hwnd, ID_TIME);
						
						EnableWindow (GetDlgItem (hwnd, IDC_BUTTON1), TRUE);//激活按钮
						EnableWindow (GetDlgItem (hwnd, IDC_BUTTON2), TRUE);
						EnableWindow (GetDlgItem (hwnd, IDC_BUTTON3), TRUE);
						EnableWindow (hEdit1, TRUE);
						EnableWindow (hEdit2, TRUE);
						EnableWindow (hEdit3, TRUE);

						SetDlgItemText(hwnd, IDC_BUTTON4, szUnlock);
						SendMessage(hWinStatus,SB_SETTEXT,0, (LPARAM)szFree);
						lock	= false;
					}
					break;

				case ID_ABOUT:
					DialogBox (GetModuleHandle (NULL), TEXT ("AboutBox"), hwnd, AboutDlgProc);
					break;
				/*case IDCANCEL:
					HANDLE	h;
					index	= SendMessage (hList, LB_GETCURSEL,0, 0);
					ID		= SendMessage (hList, LB_GETITEMDATA, index, 0);
					if ( h = OpenProcess (PROCESS_TERMINATE, NULL, ID) )
					{
						TerminateProcess (h, -1);
						CloseHandle (h);
						Sleep (100);
						GetProcessList (hwnd);
					}
					else
						MessageBox (hwnd, TEXT("无法结束指定进程"),NULL, MB_OK);
					break;*/
			}
			return true;

		case WM_TIMER:
			if (!WriteMemory (addr, var))
			{
				MessageBox (hwnd, TEXT("内存锁定失败"),NULL, MB_OK);
				lock	= true;
				SendMessage (hwnd, WM_COMMAND, IDC_BUTTON4, 0);
			}
			return true;

		case WM_PAINT:
			HDC	hdc, hdcMem ;
			PAINTSTRUCT ps ;
		    hBitmap	= LoadBitmap(hInstance, L"BitBlt");

			hdc = BeginPaint(hwnd, &ps);
			hdcMem = CreateCompatibleDC(hdc);
			SelectObject(hdcMem, hBitmap);

			StretchBlt (hdc, 0, 0, 500, 500,hdcMem, 0, 0, 500, 500, MERGECOPY) ;

			DeleteDC(hdcMem);
			EndPaint (hwnd, &ps);
			return true;

		case WM_CLOSE:
			KillTimer (hwnd, ID_TIME);
			EndDialog (hwnd, 0);
			return true;
	}
	return false;
}

BOOL CALLBACK GetProcessList (HWND hwnd)
{
	PROCESSENTRY32	stProcess;
	HANDLE	hSnapShot;
	RtlZeroMemory (&stProcess, sizeof (stProcess) );
	SendMessage (hList1, LB_RESETCONTENT, 0, 0);
	stProcess.dwSize	= sizeof (stProcess);
	hSnapShot	= CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
	bool res	= Process32First (hSnapShot, &stProcess);
	while ( res)
	{
		int index	= SendMessage (hList1, LB_ADDSTRING, 0, (LPARAM)stProcess.szExeFile);
		SendMessage (hList1, LB_SETITEMDATA, index, stProcess.th32ProcessID);
		res	= Process32Next (hSnapShot, &stProcess);
	}
	CloseHandle (hSnapShot);
	return true;
}

BOOL CALLBACK AboutDlgProc (HWND hwnd, UINT message, 
                            WPARAM wParam, LPARAM lParam)
{
     switch (message)
     {
     case WM_INITDIALOG :
          return TRUE ;
          
     case WM_COMMAND :
          switch (LOWORD (wParam))
          {
		  case IDOK :
			  EndDialog (hwnd, 0) ;
			  MessageBox (NULL, TEXT("因为箱子里放的是变压器"), TEXT("嗯嗯"), MB_OK);
			  return TRUE;

          case IDCANCEL :
               EndDialog (hwnd, 0) ;
			   MessageBox (NULL, TEXT("不想知道的是猪"), TEXT("haha"), MB_OK);
               return TRUE ;
          }
          break ;
     }
     return FALSE ;
}

//提升当前进程权限(调试权限)
BOOL EnablePrivilege(PCTSTR szPrivilege, BOOL fEnable) {

   // Enabling the debug privilege allows the application to see
   // information about service applications
   BOOL fOk = FALSE;    // Assume function fails
   HANDLE hToken;

   // Try to open this process's access token
   if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, 
      &hToken)) {

      // Attempt to modify the given privilege
      TOKEN_PRIVILEGES tp;
      tp.PrivilegeCount = 1;
      LookupPrivilegeValue(NULL, szPrivilege, &tp.Privileges[0].Luid);
      tp.Privileges[0].Attributes = fEnable ? SE_PRIVILEGE_ENABLED : 0;
      AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
      fOk = (GetLastError() == ERROR_SUCCESS);

      // Don't forget to close the token handle
      CloseHandle(hToken);
   }
   return(fOk);
}


 

#ifndef SEARCH_H
#define SEARCH_H

#include <windows.h>
#define MAX_SIZE 20*1024
void Search(void *arg);
//bool Search(HANDLE hProc, DWORD dwValue);
bool FirstSearch(DWORD dwValue);
bool NextSearch (DWORD dwValue);
bool WriteMemory(DWORD dwAddr, DWORD dwValue);
bool CompareAPage (DWORD baseAdd, DWORD dwValue);

DWORD	List[MAX_SIZE];
DWORD	Listcnt;
bool	First = 1;
HANDLE	hProcess;
const DWORD dwOneGB = 1024*1024*1024;	// 1GB
const DWORD dwOnePage = 4*1024;		// 4KB

void Init()
{
	memcpy (List, "\0", sizeof (List) );
	Listcnt = 0;
	First	= 1;
}

void Search(void *arg)
{
	TCHAR	szResult[20];
	hProcess	= ((arglist*)arg)->hProcess;
	if ( First)
	{
		FirstSearch(((arglist*)arg)->value);
	    First	= 0;
	}
	else
		NextSearch (((arglist*)arg)->value);
	wsprintf (szResult, L"搜索完毕,发现%lu个结果", Listcnt);
	SendMessage(hWinStatus,SB_SETTEXT,0, (LPARAM)szResult);
}

bool FirstSearch(DWORD dwValue)
{
	if(hProcess == NULL)
		return FALSE;
	// 查看操作系统类型,以决定开始地址
	DWORD dwBase;
	OSVERSIONINFO vi = { sizeof(vi) };
	GetVersionEx(&vi);
	if (vi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
		dwBase = 4*1024*1024;		// Windows 98系列,4MB	
	else
		dwBase = 640*1024;		// Windows NT系列,64KB

	for (dwBase = 1024*1024;dwBase < 2 * dwOneGB ; dwBase += dwOnePage)
		CompareAPage (dwBase, dwValue);

	return true;
}

bool NextSearch (DWORD dwValue)
{
	DWORD dwReadValue, num=Listcnt;
	Listcnt	= 0;
	char Item[20];
	SendMessage (hList2, LB_RESETCONTENT, 0, 0);
	for (unsigned int i=0; i < num; i++)
	{
		if( ReadProcessMemory(hProcess, (LPVOID)List[i], &dwReadValue, sizeof(DWORD), NULL))
			if (dwReadValue == dwValue)
			{
				List[Listcnt++]	= List[i];
				sprintf (Item, "0x%08lX", List[i]);
				SendMessageA (hList2, LB_ADDSTRING, 0, (LPARAM)Item);
			}
	}
	return true;
}

bool WriteMemory(DWORD dwAddr, DWORD dwValue)
{
	return WriteProcessMemory (hProcess, (LPVOID)dwAddr, &dwValue, sizeof (DWORD), NULL);
}

bool CompareAPage (DWORD baseAdd, DWORD dwValue)
{
	BYTE PageData[4096];
	char Item[20];
	if ( !ReadProcessMemory (hProcess, (LPCVOID)baseAdd, PageData, dwOnePage, NULL) )
		return false;

	DWORD	*p;
	for (unsigned int i=0; i < (DWORD)4*1024 - 3; i++)
	{
		p	= (DWORD*)&PageData[i];
		if (p[0] == dwValue)
		{
			if (Listcnt >= MAX_SIZE)
				return false;
			List[Listcnt]	= baseAdd + i;
			sprintf (Item, "0x%08lX", List[Listcnt]);  
			SendMessageA (hList2, LB_ADDSTRING, 0, (LPARAM)Item);
			Listcnt++;
		}
	}
	return true;
}

#endif


 

//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by 内存修改器.rc
//
#define IDD_DIALOG1                     101
#define IDD_DIALOG                      101
#define IDI_ICON                        102
#define IDR_MENU                        103
#define IDI_ICON1                       110
#define IDB_BITMAP1                     111
#define IDC_LIST1                       1001
#define IDC_LIST2                       1002
#define IDC_EDIT1                       1003
#define IDC_BUTTON1                     1004
#define IDC_BUTTON2                     1005
#define IDC_EDIT2                       1006
#define IDC_EDIT3                       1007
#define IDC_BUTTON3                     1008
#define IDC_BUTTON4                     1009
#define ID_40001                        40001
#define ID_ABOUT                        40002

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        112
#define _APS_NEXT_COMMAND_VALUE         40003
#define _APS_NEXT_CONTROL_VALUE         1010
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif


 

通用内存修改器+注入器源码 .版本 2 .支持库 iext .程序集 窗口程序集1 .程序集变量 停止搜索, 逻辑型 .程序集变量 搜索结果, 整数型, , "0" .程序集变量 列表框_十六进制, 逻辑型 .子程序 _窗口1_鼠标左键被按下1, 逻辑型, , 事件拦截 .参数 横向位置, 整数型 .参数 纵向位置, 整数型 .参数 功能键状态, 整数型 鼠标显示 () 返回 (真) .子程序 _窗口1_位置被改变 .如果真 (位置 = 2) 位置 = 1 可视 = 假 .如果真结束 .子程序 _窗口1_可否被关闭, 逻辑型 位置 = 1 可视 = 假 返回 (假) .子程序 _窗口1_创建完毕 宽度 = 412 高度 = 317 鼠标显示 () 内存操作.提升权限 () 内存操作.打开进程 () 编辑框_结束地址.内容 = 到文本 (到数值 (&RunDllHostCallBack)) 事件拦截.鼠标左键被按下 (取窗口句柄 (), &_窗口1_鼠标左键被按下1) 监视热键 (&回调热键事件, #Home键) .子程序 回调热键事件 可视 = 真 .子程序 _组合框_搜索类型_列表项被选择, , , 搜索功能区 .判断开始 (组合框_搜索类型.现行选中项 = 0) 编辑框_搜索数据.输入方式 = 7 ' 输入整数 .判断 (组合框_搜索类型.现行选中项 = 1) 编辑框_搜索数据.输入方式 = 8 ' 输入长整数 .判断 (组合框_搜索类型.现行选中项 = 2) 编辑框_搜索数据.输入方式 = 9 ' 输入小数 .判断 (组合框_搜索类型.现行选中项 = 3) 编辑框_搜索数据.输入方式 = 10 ' 输入双精度小数 .默认 编辑框_搜索数据.输入方式 = 0 ' 输入文本 .判断结束 .子程序 _组合框_搜索类型2_列表项被选择 .判断开始 (组合框_搜索类型2.现行选中项 = 5) 编辑框_搜索数据.输入方式 = 0 ' 输入文本 .判断 (组合框_搜索类型2.现行选中项 = 4) 编辑框_搜索数据.输入方式 = 7 ' 输入整数 .默认 _组合框_搜索类型_列表项被选择 () .判断结束 .子程序 获取搜索数据, 字节集 .局部变量 待搜索数据, 字节集 .判断开始 (组合框_搜索类型2.现行选中项 = 4) 待搜索数据 = 到字节集 (到整数 (编辑框_搜索数据.内容)) .判断 (组合框_搜索类型2.现行选中项 = 5) 待搜索数据 = 到字节集 (编辑框_搜索数据.内容) .判断 (组合框_搜索类型.现行选中项 = 0) 待搜索数据 = 到字节集 (到整数 (编辑框_搜索数据.内容)) .判断 (组合框_搜索类型.现行选中项 = 1) 待搜索数据 = 到字节集 (到长整数 (编辑框_搜索数据.内容)) .判断 (组合框_搜索类型.现行选中项 = 2) 待搜索数据 = 到字节集 (到小数 (编辑框_搜索数据.内容)) .判断 (组合框_搜索类型.现行选中项 = 3) 待搜索数据 = 到字节集 (到数值 (编辑框_搜索数据.内容)) .判断 (组合框_搜索类型.现行选中项 = 4) 待搜索数据 = 到字节集 (编辑框_搜索数据.内容) .判断 (组合框_搜索类型.现行选中项 = 5) .如果 (取文本左边 (编辑框_搜索数据.内容, 1) = “{”) 待搜索数据 = 还原字节集 (编辑框_搜索数据.内容) .否则 待搜索数据 = 还原字节集2 (编辑框_搜索数据.内容) .如果结束 .默认 .判断结束 返回 (待搜索数据) .子程序 _按钮_开始搜索_被单击 .如果真 (按钮_开始搜索.标题 = “<初始>”) 连续赋值 (假, 按钮_开始搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 组合框_搜索类型2.可视, 编辑框_搜索数据.禁止, 按钮_智能搜集.禁止, 编辑框_搜集代码.可视, 组合框_显示数据类型.可视) 连续赋值 (真, 按钮_再次搜索.禁止, 按钮_智能搜集.可视) 组合框_搜索类型2.现行选中项 = 0 超级列表框1.全部删除 () 按钮_开始搜索.标题 = “首次搜索” 编辑框_搜索数据.内容 = “” .如果真结束 .如果真 (编辑框_搜索数据.内容 = “”) 编辑框_搜索数据.获取焦点 () 标签_搜索.标题 = “请您输入待搜索的数据→” 标签_搜索.文本颜色 = #红色 返回 () .如果真结束 按钮_智能搜集.禁止 = 真 按钮_智能搜集.可视 = 假 按钮_停止.可视 = 真 搜索内存并显示 (真) .子程序 搜索内存并显示 .参数 是否首次搜索, 逻辑型, 可空 .局部变量 计次, 整数型 .局部变量 时间, 整数型 .局部变量 结果数目, 整数型 .局部变量 索引, 整数型 时间 = 取启动时间 () 进度条1.位置 = 0 超级列表框1.全部删除 () 标签_搜索.文本颜色 = #绿色 标签_搜索.标题 = “正在进行搜索...” 停止搜索 = 假 连续赋值 (真, 按钮_开始搜索.禁止, 按钮_再次搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 编辑框_搜索数据.禁止) .如果 (是否首次搜索) .判断开始 (单选框1.选中) 索引 = 0 .判断 (单选框2.选中) 索引 = 1 .判断 (单选框3.选中) 索引 = 2 .判断 (单选框4.选中) 索引 = 3 .判断 (单选框5.选中) 索引 = 4 .判断 (单选框6.选中) 索引 = 十六到十 (编辑框_首次搜索偏移量.内容) .默认 .判断结束 组合框_搜索类型2.可视 = 真 结果数目 = 内存操作.搜索 (获取搜索数据 (), 搜索结果, &回调进度, 到整数 (编辑框_起始地址.内容), 到整数 (编辑框_结束地址.内容), 索引, 选择框_深入搜索.选中) .否则 .判断开始 (组合框_搜索类型2.现行选中项 = 1) 索引 = -4 .判断 (组合框_搜索类型2.现行选中项 = 2) 索引 = -3 .判断 (组合框_搜索类型2.现行选中项 = 3) 索引 = -2 .判断 (组合框_搜索类型2.现行选中项 = 4) 索引 = -5 .判断 (组合框_搜索类型2.现行选中项 = 5) 索引 = -6 .默认 索引 = -1 .判断结束 结果数目 = 内存操作.再次搜索 (获取搜索数据 (), 搜索结果, &回调进度, 索引) .如果结束 .如果 (列表框_十六进制) ' 10进制为真 16进制为假 .计次循环首 (选择 (结果数目 > 3000, 3000, 结果数目), 计次) ' 只显示5000个到列表 .如果 (内存操作.是否静态地址 (搜索结果 [计次])) .如果 (内存操作.是否基址 (搜索结果 [计次])) 索引 = 1 .否则 索引 = 0 .如果结束 超级列表框1.插入表项 (0, 十到十六 (搜索结果 [计次], 真), 索引, , , 搜索结果 [计次]) .否则 超级列表框1.插入表项 (-1, 十到十六 (搜索结果 [计次], 真), -1, , , 搜索结果 [计次]) .如果结束 .计次循环尾 () .否则 .计次循环首 (选择 (结果数目 > 5000, 5000, 结果数目), 计次) .如果 (内存操作.是否静态地址 (搜索结果 [计次])) .如果 (内存操作.是否基址 (搜索结果 [计次])) 索引 = 1 .否则 索引 = 0 .如果结束 超级列表框1.插入表项 (0, 十到十六 (搜索结果 [计次], 真), 索引, , , 搜索结果 [计次]) .否则 超级列表框1.插入表项 (-1, 十到十六 (搜索结果 [计次], 真), -1, , , 搜索结果 [计次]) .如果结束 .计次循环尾 () .如果结束 .判断开始 (组合框_搜索类型.现行选中项 = 0) 超级列表框1.置列标题 (1, “整数”) 超级列表框1.置列宽 (1, 100) .判断 (组合框_搜索类型.现行选中项 = 1) 超级列表框1.置列标题 (1, “长整数”) 超级列表框1.置列宽 (1, 160) .判断 (组合框_搜索类型.现行选中项 = 2) 超级列表框1.置列标题 (1, “小数”) 超级列表框1.置列宽 (1, 100) .判断 (组合框_搜索类型.现行选中项 = 3) 超级列表框1.置列标题 (1, “双精度小数”) 超级列表框1.置列宽 (1, 160) .判断 (组合框_搜索类型.现行选中项 = 4) 超级列表框1.置列标题 (1, “文本”) 超级列表框1.置列宽 (1, 100) .判断 (组合框_搜索类型.现行选中项 = 5) 超级列表框1.置列标题 (1, “字节集”) 超级列表框1.置列宽 (1, 200) .默认 .判断结束 组合框_显示数据类型.现行选中项 = 组合框_搜索类型.现行选中项 + 1 组合框_显示数据类型.可视 = 真 标签_搜索.标题 = “搜索结果:” + 到文本 (结果数目) + “ 用时:” + 到文本 (取启动时间 () - 时间) + “毫秒” 按钮_开始搜索.标题 = “<初始>” 连续赋值 (假, 按钮_开始搜索.禁止, 按钮_再次搜索.禁止, 组合框_搜索类型2.禁止, 编辑框_搜索数据.禁止, 按钮_停止.可视) _组合框_搜索类型_列表项被选择 () 选择夹_内存.现行子夹 = 0 .子程序 回调进度, 逻辑型 .参数 进度, 整数型 进度条1.位置 = 进度 返回 (停止搜索) .子程序 _按钮_再次搜索_被单击 搜索内存并显示 () .子程序 _按钮_智能搜集_被单击 .如果真 (编辑框_搜索数据.内容 = “”) 编辑框_搜索数据.获取焦点 () 标签_搜索.标题 = “请您输入待搜索的数据→” 标签_搜索.文本颜色 = #红色 返回 () .如果真结束 创建线程 (&智能搜集线程) .子程序 智能搜集线程 .局部变量 结果代码, 文本型, , "0" .局部变量 计次, 整数型 .局部变量 时间, 整数型 .局部变量 索引, 整数型 时间 = 取启动时间 () 进度条1.位置 = 0 超级列表框1.全部删除 () 标签_搜索.文本颜色 = #绿色 标签_搜索.标题 = “正在进行智能搜集...” 停止搜索 = 假 连续赋值 (真, 编辑框_搜集代码.可视, 按钮_智能搜集.禁止, 按钮_开始搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 编辑框_搜索数据.禁止, 按钮_停止.可视) .判断开始 (单选框1.选中) 索引 = 0 .判断 (单选框2.选中) 索引 = 1 .判断 (单选框3.选中) 索引 = 2 .判断 (单选框4.选中) 索引 = 3 .判断 (单选框5.选中) 索引 = 4 .判断 (单选框6.选中) 索引 = 十六到十 (编辑框_首次搜索偏移量.内容) .默认 .判断结束 .计次循环首 (内存操作.搜集代码 (获取搜索数据 (), 结果代码, &回调进度, 到整数 (编辑框_起始地址.内容), 到整数 (编辑框_结束地址.内容)), 计次) 编辑框_搜集代码.加入文本 (结果代码 [计次] + #换行符) .计次循环尾 () 标签_搜索.标题 = “搜索结果:” + 到文本 (取数组成员数 (结果代码)) + “ 用时:” + 到文本 (取启动时间 () - 时间) + “毫秒” 按钮_开始搜索.标题 = “<初始>” 连续赋值 (假, 按钮_开始搜索.禁止, 按钮_停止.可视) 选择夹_内存.现行子夹 = 0 .子程序 _按钮_停止_被单击 停止搜索 = 真 连续赋值 (假, 按钮_开始搜索.禁止, 组合框_搜索类型.禁止, 组合框_搜索类型2.禁止, 组合框_搜索类型2.可视, 编辑框_搜索数据.禁止, 按钮_智能搜集.禁止, 编辑框_搜集代码.可视, 按钮_停止.可视) 连续赋值 (真, 按钮_再次搜索.禁止, 按钮_智能搜集.可视) 超级列表框1.全部删除 () 按钮_开始搜索.标题 = “首次搜索” 选择夹_内存.现行子夹 = 0 .子程序 _组合框_显示数据类型_列表项被选择 .局部变量 当前文本, 文本型 当前文本 = 组合框_显示数据类型.取项目文本 (组合框_显示数据类型.现行选中项) 超级列表框1.置列标题 (1, 当前文本) .判断开始 (当前文本 = “整数”) 超级列表框1.置列宽 (1, 100) .判断 (当前文本 = “长整数”) 超级列表框1.置列宽 (1, 160) .判断 (当前文本 = “小数”) 超级列表框1.置列宽 (1, 100) .判断 (当前文本 = “双精度小数”) 超级列表框1.置列宽 (1, 160) .判断 (当前文本 = “文本”) 超级列表框1.置列宽 (1, 100) .判断 (当前文本 = “字节集”) 超级列表框1.置列宽 (1, 200) .默认 超级列表框1.置列宽 (1, 160) .判断结束 编辑框_搜索数据.获取焦点 () .子程序 _超级列表框1_表头被单击 .参数 被单击列索引, 整数型 .局部变量 计次, 整数型 .局部变量 临时地址, 文本型 .如果真 (被单击列索引 = 0) .如果 (超级列表框1.取列标题 (0) = “地址(10进制)”) .计次循环首 (超级列表框1.取表项数 (), 计次) 超级列表框1.置标题 (计次 - 1, 0, 十到十六 (超级列表框1.取表项数值 (计次 - 1), 真)) .计次循环尾 () 超级列表框1.置列标题 (0, “地址(16进制)”) 列表框_十六进制 = 真 .否则 .计次循环首 (超级列表框1.取表项数 (), 计次) 超级列表框1.置标题 (计次 - 1, 0, 到文本 (超级列表框1.取表项数值 (计次 - 1))) .计次循环尾 () 超级列表框1.置列标题 (0, “地址(10进制)”) 列表框_十六进制 = 假 .如果结束 .如果真结束 .如果真 (被单击列索引 = 1) .判断开始 (超级列表框1.取列标题 (1) = “数据(字符串)”) 超级列表框1.置列标题 (1, “整数”) 超级列表框1.置列宽 (1, 100) .判断 (超级列表框1.取列标题 (1) = “整数”) 超级列表框1.置列标题 (1, “长整数”) 超级列表框1.置列宽 (1, 160) .判断 (超级列表框1.取列标题 (1) = “长整数”) 超级列表框1.置列标题 (1, “小数”) 超级列表框1.置列宽 (1, 100) .判断 (超级列表框1.取列标题 (1) = “小数”) 超级列表框1.置列标题 (1, “双精度小数”) 超级列表框1.置列宽 (1, 160) .判断 (超级列表框1.取列标题 (1) = “双精度小数”) 超级列表框1.置列标题 (1, “文本”) 超级列表框1.置列宽 (1, 100) .判断 (超级列表框1.取列标题 (1) = “文本”) 超级列表框1.置列标题 (1, “字节集”) 超级列表框1.置列宽 (1, 200) .默认 超级列表框1.置列标题 (1, “数据(字符串)”) 超级列表框1.置列宽 (1, 160) .判断结束 .如果真结束 .子程序 _超级列表框1_左键单击表项 .局部变量 地址, 整数型 .局部变量 内存属性, 内存属性 .如果真 (超级列表框1.现行选中项 = -1) 返回 () .如果真结束 地址 = 超级列表框1.取表项数值 (超级列表框1.现行选中项) 编辑框_内存属性.内容 = “地址:” + 十到十六 (地址, 真) + “ (” + 到文本 (地址) + “)” + #换行符 内存属性 = 内存操作.查询内存属性 (地址) 编辑框_内存属性.加入文本 (“状态:” + 到文本 (内存属性.状态) + “ (保护:” + 到文本 (内存属性.保护) + “,原始:” + 到文本 (内存属性.原始保护) + “)” + #换行符) ' 编辑框_内存属性.加入文本 (“原始保护:” + 到文本 (内存属性.原始保护) + #换行符) 编辑框_内存属性.加入文本 (“区域大小:” + 到文本 (内存属性.区域大小) + #换行符) 编辑框_内存属性.加入文本 (“区域基址:” + 十到十六 (内存属性.区域基地址, 真) + “ (” + 到文本 (内存属性.区域基地址) + “)” + #换行符) 编辑框_内存属性.加入文本 (“区域偏移量:” + 十到十六 (地址 - 内存属性.区域基地址) + #换行符) 编辑框_内存属性.加入文本 (“分配基址:” + 十到十六 (内存属性.分配基地址, 真) + “ (” + 到文本 (内存属性.分配基地址) + “)” + #换行符) 编辑框_内存属性.加入文本 (“分配偏移量:” + 十到十六 (地址 - 内存属性.分配基地址)) 选择夹_内存.现行子夹 = 1 超级列表框1.获取焦点 () .子程序 _时钟_刷新搜索结果_周期事件 .局部变量 列标题, 文本型 .局部变量 计次, 整数型 .局部变量 数据, 字节集 .局部变量 文本, 文本型 列标题 = 超级列表框1.取列标题 (1) .计次循环首 (超级列表框1.取表项数 (), 计次) 数据 = 内存操作.读取 (超级列表框1.取表项数值 (计次 - 1), 8) .判断开始 (列标题 = “字节集”) 文本 = 查看字节集 (数据) .判断 (列标题 = “数据(字符串)”) 文本 = 查看字节集2 (数据) .判断 (列标题 = “整数”) 文本 = 到文本 (取字节集数据 (数据, #整数型, )) .判断 (列标题 = “长整数”) 文本 = 到文本 (取字节集数据 (数据, #长整数型, )) .判断 (列标题 = “小数”) 文本 = 到文本 (取字节集数据 (数据, #小数型, )) .判断 (列标题 = “双精度小数”) 文本 = 到文本 (取字节集数据 (数据, #双精度小数型, )) .判断 (列标题 = “文本”) 文本 = 取字节集数据 (数据, #文本型, ) .默认 .判断结束 .如果真 (超级列表框1.取标题 (计次 - 1, 1) ≠ 文本) 超级列表框1.置标题 (计次 - 1, 1, 文本) .如果真结束 .如果真 (计次 > 300) ' 太多了,刷新会卡的. 跳出循环 () .如果真结束 .计次循环尾 () .子程序 _超级列表框1_右键单击表项 .如果真 (超级列表框1.现行选中项 ≠ -1) 弹出菜单 (列表框1菜单, , ) .如果真结束 .子程序 _超级列表框2_右键单击表项 .如果 (超级列表框2.现行选中项 ≠ -1) 弹出菜单 (列表框2菜单, , ) .否则 弹出菜单 (列表框2菜单2, , ) .如果结束 .子程序 _超级列表框1_被双击, 逻辑型, , 到添加地址 .参数 横向位置, 整数型 .参数 纵向位置, 整数型 .参数 功能键状态, 整数型 .如果真 (超级列表框1.现行选中项 ≠ -1) _添加到列表_被选择 () .如果真结束 .子程序 _超级列表框2_被双击, 逻辑型, , 到修改地址 .参数 横向位置, 整数型 .参数 纵向位置, 整数型 .参数 功能键状态, 整数型 .局部变量 类型, 文本型 .如果真 (超级列表框2.现行选中项 ≠ -1) _修改地址_被选择 () .如果真结束 .子程序 _按钮_添加地址_被单击, , , 添加地址 载入 (窗口2, , 假) 窗口2.按钮_删除地址.可视 = 假 窗口2.标题 = “添加地址” .子程序 _时钟_锁定保存地址_周期事件, , , 锁定地址 .局部变量 计次, 整数型 .局部变量 数据, 字节集 .局部变量 文本, 文本型 .局部变量 待锁定数据, 字节集 .局部变量 类型, 整数型 .计次循环首 (超级列表框2.取表项数 (), 计次) 类型 = 到数值 (超级列表框2.取标题 (计次 - 1, 3)) .如果 (超级列表框2.取标题 (计次 - 1, 4) = “1”) 文本 = 超级列表框2.取标题 (计次 - 1, 1) .判断开始 (类型 = 0) 待锁定数据 = 到字节集 (到整数 (文本)) .判断 (类型 = 1) 待锁定数据 = 到字节集 (到长整数 (文本)) .判断 (类型 = 2) 待锁定数据 = 到字节集 (到小数 (文本)) .判断 (类型 = 3) 待锁定数据 = 到字节集 (到数值 (文本)) .判断 (类型 = 4) 待锁定数据 = 到字节集 (文本) + { 0 } .判断 (类型 = 5) 待锁定数据 = 还原字节集 (文本) .默认 .判断结束 内存操作.写入 (超级列表框2.取表项数值 (计次 - 1), 待锁定数据) .否则 数据 = 内存操作.读取 (超级列表框2.取表项数值 (计次 - 1), 8) .判断开始 (类型 = 0) 文本 = 到文本 (取字节集数据 (数据, #整数型, )) .判断 (类型 = 1) 文本 = 到文本 (取字节集数据 (数据, #长整数型, )) .判断 (类型 = 2) 文本 = 到文本 (取字节集数据 (数据, #小数型, )) .判断 (类型 = 3) 文本 = 到文本 (取字节集数据 (数据, #双精度小数型, )) .判断 (类型 = 4) 文本 = 取字节集数据 (数据, #文本型, ) .判断 (类型 = 5) 文本 = 查看字节集 (数据) .默认 .判断结束 .如果真 (超级列表框2.取标题 (计次 - 1, 1) ≠ 文本) 超级列表框2.置标题 (计次 - 1, 1, 文本) .如果真结束 .如果结束 .计次循环尾 () .子程序 _超级列表框2_检查框状态被改变 .参数 表项索引, 整数型 .参数 检查框状态, 整数型 超级列表框2.置标题 (表项索引, 4, 到文本 (检查框状态)) .子程序 _添加到列表_被选择, , , 添加地址 选择夹_内存.现行子夹 = 0 载入 (窗口2, , 假) 窗口2.按钮_删除地址.可视 = 假 窗口2.标题 = “添加地址” 窗口2.编辑框_地址.内容 = 到文本 (超级列表框1.取表项数值 (超级列表框1.现行选中项)) 窗口2.组合框_搜索类型.现行选中项 = 组合框_搜索类型.现行选中项 窗口2.编辑框_说明.内容 = 窗口2.编辑框_地址.内容 _按钮_读_被单击 () .子程序 _复制数据_被选择 置剪辑板文本 (超级列表框1.取标题 (超级列表框1.现行选中项, 1)) .子程序 _内存编辑器1_被选择, , , 载入内存编辑器1 编辑器_地址 = 超级列表框1.取表项数值 (超级列表框1.现行选中项) 载入 (窗口3, , 假) .子程序 _修改地址_被选择, , , 修改地址 载入 (窗口2, , 假) 窗口2.按钮_删除地址.可视 = 真 窗口2.标题 = “修改地址” 窗口2.编辑框_地址.内容 = 到文本 (超级列表框2.取表项数值 (超级列表框2.现行选中项)) 窗口2.编辑框_说明.内容 = 超级列表框2.取标题 (超级列表框2.现行选中项, 0) 窗口2.编辑框_数据.内容 = 超级列表框2.取标题 (超级列表框2.现行选中项, 1) 窗口2.组合框_搜索类型.现行选中项 = 到数值 (超级列表框2.取标题 (超级列表框2.现行选中项, 3)) .子程序 _查看属性_被选择, , , 查看属性 .局部变量 地址, 整数型 .局部变量 内存属性, 内存属性 .如果真 (超级列表框2.现行选中项 = -1) 返回 () .如果真结束 地址 = 超级列表框2.取表项数值 (超级列表框2.现行选中项) 编辑框_内存属性.内容 = “地址:” + 十到十六 (地址, 真) + “ (” + 到文本 (地址) + “)” + #换行符 内存属性 = 内存操作.查询内存属性 (地址) 编辑框_内存属性.加入文本 (“状态:” + 到文本 (内存属性.状态) + “ (保护:” + 到文本 (内存属性.保护) + “,原始:” + 到文本 (内存属性.原始保护) + “)” + #换行符) ' 编辑框_内存属性.加入文本 (“原始保护:” + 到文本 (内存属性.原始保护) + #换行符) 编辑框_内存属性.加入文本 (“区域大小:” + 到文本 (内存属性.区域大小) + #换行符) 编辑框_内存属性.加入文本 (“区域基址:” + 十到十六 (内存属性.区域基地址, 真) + “ (” + 到文本 (内存属性.区域基地址) + “)” + #换行符) 编辑框_内存属性.加入文本 (“区域偏移量:” + 十到十六 (地址 - 内存属性.区域基地址) + #换行符) 编辑框_内存属性.加入文本 (“分配基址:” + 十到十六 (内存属性.分配基地址, 真) + “ (” + 到文本 (内存属性.分配基地址) + “)” + #换行符) 编辑框_内存属性.加入文本 (“分配偏移量:” + 十到十六 (地址 - 内存属性.分配基地址)) 选择夹_内存.现行子夹 = 1 .子程序 _移除地址_被选择, , , 删除1 .如果真 (超级列表框2.现行选中项 ≠ -1) 超级列表框2.删除表项 (超级列表框2.现行选中项) .如果真结束 .子程序 _清空地址_被选择 超级列表框2.全部删除 () .子程序 _导入表_被选择 .局部变量 文本组1, 文本型, , "0" .局部变量 文本组2, 文本型, , "0" .局部变量 计次, 整数型 .局部变量 a, 整数型 通用对话框1.初始目录 = 取特殊目录 () 通用对话框1.类型 = 0 .如果真 (通用对话框1.打开 ()) 超级列表框2.全部删除 () 文本组1 = 分割文本 (到文本 (读入文件 (通用对话框1.文件名)), #换行符, ) .计次循环首 (取数组成员数 (文本组1), 计次) 文本组2 = 分割文本 (文本组1 [计次], “|”, ) .如果真 (取数组成员数 (文本组2) = 4) a = 内存操作.取代码地址 (文本组2 [4]) 超级列表框2.插入表项 (, 文本组2 [1], , , , a) .如果真 (a = 0) 超级列表框2.置标题 (计次 - 1, 0, “失效!”) .如果真结束 超级列表框2.置标题 (计次 - 1, 1, 文本组2 [2]) 超级列表框2.置标题 (计次 - 1, 3, 文本组2 [3]) 超级列表框2.置标题 (计次 - 1, 5, 文本组2 [4]) a = 到数值 (文本组2 [3]) .判断开始 (a = 0) 超级列表框2.置标题 (计次 - 1, 2, “整数型”) .判断 (a = 1) 超级列表框2.置标题 (计次 - 1, 2, “长整数”) .判断 (a = 2) 超级列表框2.置标题 (计次 - 1, 2, “小数型”) .判断 (a = 3) 超级列表框2.置标题 (计次 - 1, 2, “长小数”) .判断 (a = 4) 超级列表框2.置标题 (计次 - 1, 2, “文本型”) .判断 (a = 5) 超级列表框2.置标题 (计次 - 1, 2, “字节集”) .默认 .判断结束 .如果真结束 .计次循环尾 () .如果真结束 .子程序 _导出表_被选择 .局部变量 数据, 字节集 .局部变量 计次, 整数型 通用对话框1.初始目录 = 取特殊目录 () 通用对话框1.类型 = 1 .如果真 (通用对话框1.打开 ()) .计次循环首 (超级列表框2.取表项数 (), 计次) 数据 = 数据 + 到字节集 (超级列表框2.取标题 (计次 - 1, 0) + “|” + 超级列表框2.取标题 (计次 - 1, 1) + “|” + 超级列表框2.取标题 (计次 - 1, 3) + “|” + 超级列表框2.取标题 (计次 - 1, 5) + #换行符) .计次循环尾 () 写到文件 (通用对话框1.文件名, 数据) .如果真结束 .子程序 _导入表2_被选择 _导入表_被选择 () .子程序 _从列表中移除_被选择, , , 删除2 .如果真 (超级列表框1.现行选中项 ≠ -1) 超级列表框1.删除表项 (超级列表框1.现行选中项) .如果真结束 .子程序 _内存编辑器2_被选择, , , 载入内存编辑器2 编辑器_地址 = 超级列表框2.取表项数值 (超级列表框2.现行选中项) 载入 (窗口3, , 假)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值