/[RomCheater]/trunk/Win32/Sojaner.MemoryScanner/MemoryScanner.cs
ViewVC logotype

Diff of /trunk/Win32/Sojaner.MemoryScanner/MemoryScanner.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 228 by william, Thu May 31 09:08:24 2012 UTC revision 229 by william, Sat Jun 2 18:31:40 2012 UTC
# Line 14  namespace Sojaner.MemoryScanner Line 14  namespace Sojaner.MemoryScanner
14      #region ProcessMemoryReader class      #region ProcessMemoryReader class
15      //Thanks goes to Arik Poznanski for P/Invokes and methods needed to read and write the Memory      //Thanks goes to Arik Poznanski for P/Invokes and methods needed to read and write the Memory
16      //For more information refer to "Minesweeper, Behind the scenes" article by Arik Poznanski at Codeproject.com      //For more information refer to "Minesweeper, Behind the scenes" article by Arik Poznanski at Codeproject.com
17      public class ProcessMemoryReader      public class ProcessMemoryReader : IPatchMemory, IReadMemory
18      {      {
19    
20          public ProcessMemoryReader()          public ProcessMemoryReader()
# Line 77  namespace Sojaner.MemoryScanner Line 77  namespace Sojaner.MemoryScanner
77          #endregion          #endregion
78    
79          #region ReadProcessMemory          #region ReadProcessMemory
80          public byte[] ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead)          public void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
81          {          {
82              RamDumper dumper = new RamDumper();              RamDumper dumper = new RamDumper();
83              return dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead);              dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead, out data);
84          }          }
85            //public void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead,out sbyte[] data)
86            //{
87            //    RamDumper dumper = new RamDumper();
88            //    dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead, out data);
89            //}
90          #endregion          #endregion
91    
92          #region ReadProcessMemory          #region ReadProcessMemory
# Line 104  namespace Sojaner.MemoryScanner Line 109  namespace Sojaner.MemoryScanner
109          }          }
110          #endregion          #endregion
111    
112    
113            #region IPatchMemory members
114            public bool PatchMemory(uint address, byte value)
115            {
116                int bytesWritten;
117                byte[] bitData = BitConverter.GetBytes(value);
118                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
119                CloseHandle();
120                byte check = 0;
121                ReadMemory(address, out check);
122                if (check == value) return true;
123                return false;
124            }
125            public bool PatchMemory(uint address, sbyte value)
126            {
127                int bytesWritten;
128                byte[] bitData = BitConverter.GetBytes(value);
129                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
130                CloseHandle();
131                sbyte check = 0;
132                ReadMemory(address, out check);
133                if (check == value) return true;
134                return false;
135            }
136            public bool PatchMemory(uint address, ushort value)
137            {
138                int bytesWritten;
139                byte[] bitData = BitConverter.GetBytes(value);
140                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
141                CloseHandle();
142                ushort check = 0;
143                ReadMemory(address, out check);
144                if (check == value) return true;
145                return false;
146            }
147            public bool PatchMemory(uint address, short value)
148            {
149                int bytesWritten;
150                byte[] bitData = BitConverter.GetBytes(value);
151                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
152                CloseHandle();
153                short check = 0;
154                ReadMemory(address, out check);
155                if (check == value) return true;
156                return false;
157            }
158            public bool PatchMemory(uint address, uint value)
159            {
160                int bytesWritten;
161                byte[] bitData = BitConverter.GetBytes(value);
162                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
163                CloseHandle();
164                uint check = 0;
165                ReadMemory(address, out check);
166                if (check == value) return true;
167                return false;
168            }
169            public bool PatchMemory(uint address, int value)
170            {
171                int bytesWritten;
172                byte[] bitData = BitConverter.GetBytes(value);
173                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
174                CloseHandle();
175                int check = 0;
176                ReadMemory(address, out check);
177                if (check == value) return true;
178                return false;
179            }
180            public bool PatchMemory(uint address, ulong value)
181            {
182                int bytesWritten;
183                byte[] bitData = BitConverter.GetBytes(value);
184                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
185                CloseHandle();
186                ulong check = 0;
187                ReadMemory(address, out check);
188                if (check == value) return true;
189                return false;
190            }
191            public bool PatchMemory(uint address, long value)
192            {
193                int bytesWritten;
194                byte[] bitData = BitConverter.GetBytes(value);
195                WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);
196                CloseHandle();
197                long check = 0;
198                ReadMemory(address, out check);
199                if (check == value) return true;
200                return false;
201            }
202            #endregion
203            #region IReadMemory members
204            public bool ReadMemory(uint address, out byte value)
205            {
206                try
207                {
208                    value = 0;
209                    int bytesReadSize;
210                    byte[] bitData;
211                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
212                    value = bitData[0];
213                    return true;
214                }
215                catch
216                {
217                    value = 0x00;
218                    return false;
219                }
220            }
221            public bool ReadMemory(uint address, out sbyte value)
222            {
223                try
224                {
225                    value = 0;
226                    int bytesReadSize;
227                    byte[] bitData;
228                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
229                    value = Convert.ToSByte(bitData[0]);
230                    return true;
231                }
232                catch
233                {
234                    value = 0x00;
235                    return false;
236                }
237            }
238            public bool ReadMemory(uint address, out ushort value)
239            {
240                try
241                {
242                    value = 0;
243                    int bytesReadSize;
244                    byte[] bitData;
245                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
246                    value = BitConverter.ToUInt16(bitData, 0);
247                    return true;
248                }
249                catch
250                {
251                    value = 0x00;
252                    return false;
253                }
254            }
255            public bool ReadMemory(uint address, out short value)
256            {
257                try
258                {
259                    value = 0;
260                    int bytesReadSize;
261                    byte[] bitData;
262                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
263                    value = BitConverter.ToInt16(bitData, 0);
264                    return true;
265                }
266                catch
267                {
268                    value = 0x00;
269                    return false;
270                }
271            }
272            public bool ReadMemory(uint address, out uint value)
273            {
274                try
275                {
276                    value = 0;
277                    int bytesReadSize;
278                    byte[] bitData;
279                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
280                    value = BitConverter.ToUInt32(bitData, 0);
281                    return true;
282                }
283                catch
284                {
285                    value = 0x00;
286                    return false;
287                }
288            }
289            public bool ReadMemory(uint address, out int value)
290            {
291                try
292                {
293                    value = 0;
294                    int bytesReadSize;
295                    byte[] bitData;
296                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
297                    value = BitConverter.ToInt32(bitData, 0);
298                    return true;
299                }
300                catch
301                {
302                    value = 0x00;
303                    return false;
304                }
305            }
306            public bool ReadMemory(uint address, out ulong value)
307            {
308                try
309                {
310                    value = 0;
311                    int bytesReadSize;
312                    byte[] bitData;
313                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
314                    value = BitConverter.ToUInt64(bitData, 0);
315                    return true;
316                }
317                catch
318                {
319                    value = 0x00;
320                    return false;
321                }
322            }
323            public bool ReadMemory(uint address, out long value)
324            {
325                try
326                {
327                    value = 0;
328                    int bytesReadSize;
329                    byte[] bitData;
330                    ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
331                    value = BitConverter.ToInt64(bitData, 0);
332                    return true;
333                }
334                catch
335                {
336                    value = 0x00;
337                    return false;
338                }
339            }
340            #endregion
341    
342          #region RamDumper          #region RamDumper
343          private interface IRamDumper          private interface IRamDumper
344          {          {
345             bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead);             bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead);
346             byte[] DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead);             void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data);
347          }          }
348          private class RamDumper : IRamDumper          private class RamDumper : IRamDumper
349          {          {
# Line 192  namespace Sojaner.MemoryScanner Line 427  namespace Sojaner.MemoryScanner
427              }              }
428              #endregion              #endregion
429              #region DumpMemoryToByteArray              #region DumpMemoryToByteArray
430              public byte[] DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead)              public void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
431              {              {
432                    data = new byte[] { };
433                  //logger.Info.WriteLine("Dumping memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));                  //logger.Info.WriteLine("Dumping memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
434                  bytesRead = 0;                  bytesRead = 0;
435                  uint byte_alignment = 1;                  uint byte_alignment = 1;
# Line 242  namespace Sojaner.MemoryScanner Line 478  namespace Sojaner.MemoryScanner
478    
479                          }                          }
480                          bw.Close();                          bw.Close();
481                          return ms.ToArray();                          data = ms.ToArray();
482                      }                      }
483                      //logger.Info.WriteLine("Succefully dumped memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));                      //logger.Info.WriteLine("Succefully dumped memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
484                  }                  }
# Line 258  namespace Sojaner.MemoryScanner Line 494  namespace Sojaner.MemoryScanner
494                      logger.Error.WriteLine("DumpMemory(): Exception");                      logger.Error.WriteLine("DumpMemory(): Exception");
495                      logger.Error.WriteLine(ex.ToString());                      logger.Error.WriteLine(ex.ToString());
496                  }                  }
                 return new byte[]{};  
497              }              }
498              #endregion              #endregion
499                #region DumpMemoryToByteArray (sbyte)
500                //public void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out sbyte[] data)
501                //{
502                //    data = new sbyte[] { };
503                //    //logger.Info.WriteLine("Dumping memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
504                //    bytesRead = 0;
505                //    uint byte_alignment = 1;
506                //    // get common init parameters
507                //    //InitMemoryDump(out byte_alignment);
508                //    uint address = MemoryAddress;
509                //    uint _bytesToRead = bytesToRead;
510                //    sbyte[] buffer = new sbyte[] { };
511                //    try
512                //    {
513                //        using (MemoryStream ms = new MemoryStream())
514                //        {
515                //            BinaryWriter bw = new BinaryWriter(ms);
516                //            //foreach (byte b in data) { bw.Write(b); }
517    
518                //            for (uint i = 0; i <= bytesToRead; )
519                //            {
520                //                if (_bytesToRead < byte_alignment)
521                //                {
522                //                    _bytesToRead = bytesToRead;
523                //                    buffer = new sbyte[_bytesToRead];
524                //                }
525                //                else
526                //                {
527                //                    _bytesToRead = byte_alignment;
528                //                    buffer = new sbyte[byte_alignment];
529                //                }
530                //                IntPtr ptrBytesRead;
531    
532                //                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, (byte[])(Array)buffer, _bytesToRead, out ptrBytesRead);
533                //                bytesRead = ptrBytesRead.ToInt32();
534                //                bw.Write((byte[])(Array)buffer);
535                //                bw.Flush();
536    
537                //                if (_bytesToRead < byte_alignment)
538                //                {
539                //                    i += _bytesToRead;
540                //                    address += _bytesToRead;
541                //                }
542                //                else
543                //                {
544                //                    i += byte_alignment;
545                //                    address += byte_alignment;
546                //                }
547    
548    
549                //            }
550                //            bw.Close();
551                //            data = (sbyte[])(Array)ms.ToArray();
552                //        }
553                //        //logger.Info.WriteLine("Succefully dumped memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
554                //    }
555                //    catch (OutOfMemoryException ex)
556                //    {
557                //        logger.Error.WriteLine("Failed to dump memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
558                //        logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
559                //        logger.Error.WriteLine(ex.ToString());
560                //    }
561                //    catch (Exception ex)
562                //    {
563                //        logger.Error.WriteLine("Failed to dump memory (0x{0:x8}-0x{1:x8}) from pid=({2})", MemoryAddress, MemoryAddress + bytesToRead, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
564                //        logger.Error.WriteLine("DumpMemory(): Exception");
565                //        logger.Error.WriteLine(ex.ToString());
566                //    }
567                //}
568                #endregion
569              #endregion              #endregion
570    
571              #region ReadFirstNonZeroByte              #region ReadFirstNonZeroByte

Legend:
Removed from v.228  
changed lines
  Added in v.229

  ViewVC Help
Powered by ViewVC 1.1.22