private void PointerCheckerPointer_Tick(object sender, EventArgs e)
{
if (!Pointer)
{
return;
}
try
{
ValueType valueType = MemoryHelper.GetValueTypeByString(type_box.Text);
long base_address = 0;
for (int i = 0; i < offset_box_list.Count; ++i)
{
long address = long.Parse(offset_box_list[i].Text, System.Globalization.NumberStyles.HexNumber);
if (i != offset_box_list.Count - 1)
{
byte[] next_address = MemoryHelper.ReadMemory((ulong)(address + base_address), 8);
base_address = BitConverter.ToInt64(next_address, 0);
offset_label_list[i].Text = base_address.ToString("X");
}
else
{
MemoryHelper.InitMemoryHandler(valueType, CompareType.NONE, true);
byte[] data = MemoryHelper.ReadMemory((ulong)(address + base_address), MemoryHelper.Length);
offset_label_list[i].Text = MemoryHelper.BytesToString(data);
}
}
}
catch
{
}
}
public GameInfo()
{
string process_name = "";
string section_name = "";
ulong id_offset = 0;
ulong version_offset = 0;
int section_prot = 0;
switch (Util.Version)
{
case 405:
process_name = GAME_INFO_4_05_PROCESS_NAME;
section_name = GAME_INFO_4_05_SECTION_NAME;
id_offset = GAME_INFO_4_05_ID_OFFSET;
version_offset = GAME_INFO_4_05_VERSION_OFFSET;
section_prot = GAME_INFO_4_05_SECTION_PROT;
break;
case 455:
process_name = GAME_INFO_4_55_PROCESS_NAME;
section_name = GAME_INFO_4_55_SECTION_NAME;
id_offset = GAME_INFO_4_55_ID_OFFSET;
version_offset = GAME_INFO_4_55_VERSION_OFFSET;
section_prot = GAME_INFO_4_55_SECTION_PROT;
break;
default:
break;
}
try
{
ProcessManager processManager = new ProcessManager();
ProcessInfo processInfo = processManager.GetProcessInfo(process_name);
MemoryHelper memoryHelper = new MemoryHelper(false, processInfo.pid);
MappedSectionList mappedSectionList = processManager.MappedSectionList;
mappedSectionList.InitMemorySectionList(processInfo);
List <MappedSection> sectionList = mappedSectionList.GetMappedSectionList(section_name, section_prot);
if (sectionList.Count != 1)
{
return;
}
GameID = System.Text.Encoding.Default.GetString(memoryHelper.ReadMemory(sectionList[0].Start + id_offset, 16));
GameID = GameID.Trim(new char[] { '\0' });
Version = System.Text.Encoding.Default.GetString(memoryHelper.ReadMemory(sectionList[0].Start + version_offset, 16));
Version = Version.Trim(new char[] { '\0' });
}
catch
{
}
}
private void update_ui(int page, long line)
{
hexBox.LineInfoOffset = (uint)((ulong)section.Start + (ulong)(page_size * page));
int mem_size = page_size;
if (section.Length - page_size * page < mem_size)
{
mem_size = section.Length - page_size * page;
}
if (CheatList.IS_DEV && this.hexBox.ByteProvider != null)
{
}
else
{
byte[] dst = memoryHelper.ReadMemory(section.Start + (ulong)page * page_size, (int)mem_size);
MemoryViewByteProvider dataProvider = new MemoryViewByteProvider(dst);
//hexBox.ByteProvider = new MemoryViewByteProvider(dst);
hexBox.ByteProvider = dataProvider;
}
if (line != 0)
{
hexBox.SelectionStart = line * hexBox.BytesPerLine + column;
hexBox.SelectionLength = 4;
hexBox.ScrollByteIntoView((line + hexBox.Height / (int)hexBox.CharSize.Height - 1) * hexBox.BytesPerLine + column);
}
}
public void PointerSearchInit(ProcessManager processManager, MemoryHelper memoryHelper, PointerList pointerList)
{
ulong address = this.Start;
int length = this.Length;
const int buffer_length = 1024 * 1024 * 128;
while (length != 0)
{
int cur_length = buffer_length;
if (cur_length > length)
{
cur_length = length;
length = 0;
}
else
{
length -= cur_length;
}
byte[] buffer = memoryHelper.ReadMemory(address, (int)cur_length);
memoryHelper.CompareWithMemoryBufferPointerScanner(processManager, buffer, pointerList, address);
address += (ulong)cur_length;
}
}
private void update_ui(int page, long line)
{
hexBox.LineInfoOffset = (uint)((ulong)section.Start + (ulong)(page_size * page));
int mem_size = page_size;
if (section.Length - page_size * page < mem_size)
{
mem_size = section.Length - page_size * page;
}
byte[] dst = memoryHelper.ReadMemory(section.Start + (ulong)page * page_size, (int)mem_size);
hexBox.ByteProvider = new MemoryViewByteProvider(dst);
if (line != 0)
{
hexBox.SelectionStart = line * hexBox.BytesPerLine + column;
hexBox.SelectionLength = 4;
if (hexBox.ColumnInfoVisible)
{
line -= 2;
}
hexBox.ScrollByteIntoView((line + hexBox.Height / (int)hexBox.CharSize.Height - 1) * hexBox.BytesPerLine + column);
}
}
public override void Refresh()
{
if (value_.Length % 2 != 0)
{
value_ += "0";
}
value_ = MemoryHelper.bytes_to_hex_string(MemoryHelper.ReadMemory(ulong.Parse(Address, NumberStyles.HexNumber), value_.Length / 2));
}
public GameInfo()
{
Dictionary <string, object> gameInfo = gameInfos[0];
if (gameInfos.ContainsKey(Util.Version))
{
gameInfo = gameInfos[Util.Version];
}
string process_name = (string)gameInfo["process_name"];
string section_name = (string)gameInfo["section_name"];
ulong id_offset = Convert.ToUInt64(gameInfo["id_offset"]);
ulong version_offset = Convert.ToUInt64(gameInfo["version_offset"]);
int section_prot = Convert.ToInt32(gameInfo["section_prot"]);
try
{
ProcessManager processManager = new ProcessManager();
ProcessInfo processInfo = processManager.GetProcessInfo(process_name);
MemoryHelper memoryHelper = new MemoryHelper(false, processInfo.pid);
MappedSectionList mappedSectionList = processManager.MappedSectionList;
mappedSectionList.InitMemorySectionList(MemoryHelper.GetProcessMaps(processInfo.pid));
List <MappedSection> sectionList = mappedSectionList.GetMappedSectionList(section_name, section_prot);
if (sectionList.Count != 1)
{
return;
}
GameID = System.Text.Encoding.Default.GetString(memoryHelper.ReadMemory(sectionList[0].Start + id_offset, 16));
GameID = GameID.Trim(new char[] { '\0' });
Version = System.Text.Encoding.Default.GetString(memoryHelper.ReadMemory(sectionList[0].Start + version_offset, 16));
Version = Version.Trim(new char[] { '\0' });
}
catch
{
}
}
private ulong GetAddress()
{
ulong address = BitConverter.ToUInt64(Address.GetRuntime(), 0);
int i = 0;
for (; i < Offsets.Count - 1; ++i)
{
Byte[] new_address = MemoryHelper.ReadMemory((ulong)((long)address + Offsets[i].Offset), 8);
address = BitConverter.ToUInt64(new_address, 0);
}
if (i < Offsets.Count)
{
address += (ulong)Offsets[i].Offset;
}
return(address);
}
public AddressList getFilteredAddressList(ProcessManager processManager, MemoryHelper memoryHelper,
string value, BackgroundWorker worker, ref ulong percent_len, int start, float percent)
{
AddressList filtered_list = new AddressList();
worker.ReportProgress(start);
if (!Check)
{
return(filtered_list);
}
ulong address = this.Start;
int length = this.Length;
const int block_length = 1024 * 1024 * 128;
while (length != 0)
{
int cur_length = block_length;
if (cur_length > length)
{
cur_length = length;
length = 0;
}
else
{
length -= cur_length;
}
percent_len += (ulong)cur_length;
worker.ReportProgress(start + (int)(((float)percent_len / processManager.TotalMemorySize) * 100 * percent));
byte[] buffer = MemoryHelper.ReadMemory(address, (int)cur_length);
byte[] match_value = memoryHelper.StringToBytes(value);
memoryHelper.CompareWithFilterList(match_value, address, buffer, filtered_list);
address += (ulong)cur_length;
}
return(filtered_list);
}
private void dump_dialog(int sectionID)
{
if (sectionID >= 0)
{
MappedSection section = processManager.MappedSectionList[sectionID];
sfdSaveFile.Filter = "Binary files (*.bin)|*.bin|All files (*.*)|*.*";
sfdSaveFile.FilterIndex = 1;
sfdSaveFile.RestoreDirectory = true;
sfdSaveFile.FileName = (string)lstSection.Items[lstSection.SelectedIndex];
if (sfdSaveFile.ShowDialog() == DialogResult.OK)
{
byte[] buffer = memoryHelper.ReadMemory(section.Start, (int)section.Length);
FileStream myStream = new FileStream(sfdSaveFile.FileName, FileMode.OpenOrCreate);
myStream.Write(buffer, 0, buffer.Length);
myStream.Close();
}
}
}
private void sectionDump_Click(object sender, EventArgs e)
{
if (section_list_box.SelectedIndex >= 0)
{
MappedSection section = processManager.MappedSectionList[section_list_box.SelectedIndex];
save_file_dialog.Filter = "Binary files (*.bin)|*.bin|All files (*.*)|*.*";
save_file_dialog.FilterIndex = 1;
save_file_dialog.RestoreDirectory = true;
save_file_dialog.FileName = (string)section_list_box.Items[section_list_box.SelectedIndex];
if (save_file_dialog.ShowDialog() == DialogResult.OK)
{
byte[] buffer = MemoryHelper.ReadMemory(section.Start, (int)section.Length);
FileStream myStream = new FileStream(save_file_dialog.FileName, FileMode.OpenOrCreate);
myStream.Write(buffer, 0, buffer.Length);
myStream.Close();
}
}
}
public void UpdateResultList(ProcessManager processManager, MemoryHelper memoryHelper,
string default_value_0_str, string default_value_1_str, bool is_hex, bool newScan, int thread_id)
{
if (!Check)
{
ResultList = null;
return;
}
ResultList new_result_list = new ResultList(memoryHelper.Length, memoryHelper.Alignment);
ulong address = this.Start;
uint base_address = 0;
int length = this.Length;
const int buffer_length = 1024 * 1024 * 128;
while (length != 0)
{
int cur_length = buffer_length;
if (cur_length > length)
{
cur_length = length;
length = 0;
}
else
{
length -= cur_length;
}
byte[] buffer = memoryHelper.ReadMemory(address, (int)cur_length, thread_id);
byte[] default_value_0 = null;
if (memoryHelper.ParseFirstValue)
{
if (is_hex)
{
default_value_0 = memoryHelper.HexStringToBytes(default_value_0_str);
}
else
{
default_value_0 = memoryHelper.StringToBytes(default_value_0_str);
}
}
byte[] default_value_1 = null;
if (memoryHelper.ParseSecondValue)
{
if (is_hex)
{
default_value_1 = memoryHelper.HexStringToBytes(default_value_1_str);
}
else
{
default_value_1 = memoryHelper.StringToBytes(default_value_1_str);
}
}
if (newScan)
{
memoryHelper.CompareWithMemoryBufferNewScanner(default_value_0, default_value_1, buffer, new_result_list, base_address);
}
else
{
memoryHelper.CompareWithMemoryBufferNextScanner(default_value_0, default_value_1, buffer, ResultList, new_result_list);
}
address += (ulong)cur_length;
base_address += (uint)cur_length;
}
ResultList = new_result_list;
}
private void HexEdit_Load(object sender, EventArgs e)
{
this.hexBox.LineInfoOffset = (uint)section.Start;
this.buffer = memoryHelper.ReadMemory(section.Start, (int)section.Length);
update_ui(page);
}
public override byte[] GetRuntime()
{
return(MemoryHelper.ReadMemory(GetAddress(), MemoryHelper.Length));
}
private byte[] GetData(int index, bool reset)
{
ulong address = this.getAddress();
BatchCode code = Codes[index];
byte[] data = null;
string value = code.value;
if (reset)
{
value = code.reset;
}
ValueType vtype = code.vtype;
int size = code.size;
int psize = size + code.skip;
decimal baseVal = 0;
byte[] stepData = null;
if (code.step != 0)
{
string hexStr = String.Format("{0:X}", code.step);
stepData = NumberBytesHelper.HexToBytes(hexStr);
}
if (value.StartsWith("0x"))
{
string str = value.Substring(2);
data = MemoryHelper.string_to_hex_bytes(str);
if (size < 9)
{
string[] strs = new string[str.Length / 2];
for (int i = 0; i < strs.Length; i++)
{
strs[i] = str.Substring(i * 2, 2);
}
Array.Reverse(strs);
str = String.Join("", strs);
baseVal = ulong.Parse(str, NumberStyles.HexNumber);
}
}
else
{
baseVal = Convert.ToDecimal(value);
data = this.convertValue(baseVal, vtype);
}
if (BatchType.VALUE.Equals(code.batchType))
{
return(data);
}
int dataSize = code.GetDataSize();
int offset = code.offset;
address = address + (ulong)offset;
byte[] buff = null;
if (CheatList.IS_DEV)
{
buff = new byte[dataSize];
}
else
{
buff = MemoryHelper.ReadMemory(address, dataSize);
}
decimal val = baseVal;
int pos = 0;
NumberExcluder excluder = code.excluder;
bool ignore = false;
int begin = code.begin + 1;
int end = code.target + 1;
switch (code.batchType)
{
case BatchType.FOR:
for (int i = begin; i < end; i++)
{
if (excluder != null)
{
ignore = excluder.Match(i);
}
if (!ignore)
{
if (size < 9 && val != baseVal)
{
data = this.convertValue(val, vtype);
}
Buffer.BlockCopy(data, 0, buff, pos, code.size);
pos += psize;
}
if (!reset)
{
if (size < 9)
{
val += code.step;
}
else if (stepData != null)
{
data = NumberBytesHelper.Add(data, stepData);
}
}
}
break;
}
return(buff);
}
