Esempio n. 1
0
        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
            {
            }
        }
Esempio n. 2
0
        public override string Dump(bool simpleFormat)
        {
            string save_buf = "";

            save_buf += MemoryHelper.GetStringOfValueType(ValueType) + "|";
            save_buf += MemoryHelper.BytesToString(data) + "|";
            return(save_buf);
        }
Esempio n. 3
0
        public override void Refresh()
        {
            MemoryHelper memoryHelper = new MemoryHelper();

            memoryHelper.InitMemoryHandler(Type, CompareType.NONE);

            memoryHelper.SetBytesByType(ulong.Parse(Address, NumberStyles.HexNumber), memoryHelper.StringToBytes(value_));
            value_ = memoryHelper.BytesToString(memoryHelper.GetBytesByType(ulong.Parse(Address, NumberStyles.HexNumber)));
        }
Esempio n. 4
0
        private void pointer_list_view_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.RowIndex < 0)
            {
                return;
            }
            PointerResult pointerResult = pointerResults[e.RowIndex];

            ulong  baseAddress = pointerResult.GetBaseAddress(processManager.MappedSectionList);
            ulong  tailAddress = pointerList.GetTailAddress(pointerResult, processManager.MappedSectionList);
            string data        = MemoryHelper.BytesToString(MemoryHelper.GetBytesByType(tailAddress));
            string dataType    = MemoryHelper.GetStringOfValueType(MemoryHelper.ValueType);
            string description = "";

            for (int oIdx = 0; oIdx < pointerResult.Offsets.Length; ++oIdx)
            {
                description += "+" + pointerResult.Offsets[oIdx].ToString("X");
            }
            description = (string)baseAddress.ToString("X") + description;
            mainForm.new_pointer_cheat(baseAddress, pointerResult.Offsets.ToList(), dataType, data, false, description);
        }
Esempio n. 5
0
        private void pointer_list_view_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.RowIndex < 0)
            {
                return;
            }
            PointerResult pointerResult = pointerResults[e.RowIndex];

            ulong  baseAddress = pointerResult.GetBaseAddress(processManager.MappedSectionList);
            ulong  tailAddress = pointerList.GetTailAddress(pointerResult, processManager.MappedSectionList);
            string data        = MemoryHelper.BytesToString(MemoryHelper.GetBytesByType(tailAddress));
            string dataType    = MemoryHelper.GetStringOfValueType(MemoryHelper.ValueType);

            mainForm.new_pointer_cheat(baseAddress, pointerResult.Offsets.ToList(), dataType, data, false, "");
        }
Esempio n. 6
0
        private void update_result_list_view(BackgroundWorker worker, bool refresh, int start, float percent)
        {
            worker.ReportProgress(start);

            List <ListViewItem> listViewItems = new List <ListViewItem>();

            bool[] mappedSectionCheckeSet = new bool[processManager.MappedSectionList.Count];

            ulong  totalResultCount = processManager.MappedSectionList.TotalResultCount();
            ulong  curResultCount   = 0;
            string value_type       = MemoryHelper.GetStringOfValueType(memoryHelper.ValueType);

            const int MAX_RESULTS_NUM = 0x1000;

            for (int idx = 0; idx < processManager.MappedSectionList.Count; ++idx)
            {
                MappedSection mapped_section = processManager.MappedSectionList[idx];
                ResultList    result_list    = mapped_section.ResultList;
                if (result_list == null)
                {
                    continue;
                }
                if (!mapped_section.Check)
                {
                    continue;
                }

                mappedSectionCheckeSet[idx] = result_list.Count > 0;

                for (result_list.Begin(); !result_list.End(); result_list.Next())
                {
                    if (curResultCount >= MAX_RESULTS_NUM)
                    {
                        break;
                    }

                    uint   memory_address_offset = 0;
                    byte[] memory_value          = null;

                    result_list.Get(ref memory_address_offset, ref memory_value);

                    curResultCount++;
                    ListViewItem lvi = new ListViewItem();

                    lvi.Text = String.Format("{0:X}", memory_address_offset + mapped_section.Start);

                    if (refresh && !worker.CancellationPending)
                    {
                        memory_value = memoryHelper.GetBytesByType(memory_address_offset + mapped_section.Start);
                        result_list.Set(memory_value);
                        worker.ReportProgress(start + (int)(100.0f * curResultCount / MAX_RESULTS_NUM));
                    }

                    lvi.SubItems.Add(value_type);
                    lvi.SubItems.Add(memoryHelper.BytesToString(memory_value));
                    lvi.SubItems.Add(memoryHelper.BytesToHexString(memory_value));
                    lvi.SubItems.Add(processManager.MappedSectionList.GetSectionName(idx));

                    listViewItems.Add(lvi);
                }
            }

            WorkerReturn workerReturn = new WorkerReturn();

            workerReturn.ListViewItems          = listViewItems;
            workerReturn.MappedSectionCheckeSet = mappedSectionCheckeSet;
            workerReturn.Results = totalResultCount;

            worker.ReportProgress(start + (int)(100 * percent), workerReturn);
        }
Esempio n. 7
0
 public override string Display()
 {
     return(MemoryHelper.BytesToString(data));
 }
Esempio n. 8
0
 public override string ToString(bool simple)
 {
     return(MemoryHelper.BytesToString(data));
 }
Esempio n. 9
0
        private void update_result_list_view(BackgroundWorker worker, string value_type, bool refresh, int start, float percent)
        {
            worker.ReportProgress(start, 0);

            List <ListViewItem> listViewItems          = new List <ListViewItem>();
            HashSet <int>       mappedSectionCheckeSet = new HashSet <int>();

            ulong totalAddressCount = processManager.TotalAddressCount();
            ulong curAddressCount   = 0;

            for (int idx = 0; idx < processManager.MappedSectionList.Count; ++idx)
            {
                MappedSection mapped_section = processManager.MappedSectionList[idx];
                AddressList   address_list   = mapped_section.AddressList;
                if (address_list.Count > 0)
                {
                    mappedSectionCheckeSet.Add(idx);
                }
                for (int i = 0; i < address_list.Count; i++)
                {
                    if (curAddressCount >= 0x10000)
                    {
                        break;
                    }

                    curAddressCount++;
                    ListViewItem lvi = new ListViewItem();

                    lvi.Text = String.Format("{0:X}", address_list[i].AddressOffset + mapped_section.Start);

                    byte[] match_bytes = BitConverter.GetBytes(address_list[i].MemoryValue);

                    if (refresh)
                    {
                        match_bytes = memoryHelper.GetBytesByType(address_list[i].AddressOffset + mapped_section.Start);
                        Address address_tmp = new Address();
                        address_tmp.AddressOffset = address_list[i].AddressOffset;
                        address_tmp.MemoryValue   = memoryHelper.BytesToUlong(match_bytes);
                        address_list[i]           = address_tmp;
                    }

                    string value_output = memoryHelper.BytesToString(match_bytes);

                    lvi.SubItems.Add(value_type);
                    lvi.SubItems.Add(value_output);
                    lvi.SubItems.Add(MemoryHelper.bytes_to_hex_string(match_bytes));
                    lvi.SubItems.Add(processManager.GetSectionName(idx));

                    listViewItems.Add(lvi);

                    if (i % 500 == 0)
                    {
                        worker.ReportProgress(start + (int)(i / (float)curAddressCount * 100 * percent));
                    }
                }
            }

            WorkerReturn workerReturn = new WorkerReturn();

            workerReturn.ListViewItems          = listViewItems;
            workerReturn.MappedSectionCheckeSet = mappedSectionCheckeSet;
            workerReturn.Results = totalAddressCount;

            worker.ReportProgress(start + (int)(100 * percent), workerReturn);
        }