/[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 167 by william, Mon May 28 08:31:56 2012 UTC revision 235 by william, Sun Jun 3 12:44:26 2012 UTC
# Line 5  using System.Diagnostics; Line 5  using System.Diagnostics;
5  using System.Threading;  using System.Threading;
6  using System.Runtime.InteropServices;  using System.Runtime.InteropServices;
7  using RomCheater.Logging;  using RomCheater.Logging;
 using RomCheater.Core;  
8  using System.IO;  using System.IO;
9    using Sojaner.MemoryScanner.MemoryProviers;
10    
11  namespace Sojaner.MemoryScanner  namespace Sojaner.MemoryScanner
12  {  {
# 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      internal class ProcessMemoryReader : IMemoryReader, IMemoryWriter, IFileWriter
18      {      {
19    
20          public ProcessMemoryReader()          public ProcessMemoryReader()
# Line 38  namespace Sojaner.MemoryScanner Line 38  namespace Sojaner.MemoryScanner
38    
39          private Process m_ReadProcess = null;          private Process m_ReadProcess = null;
40    
41          private IntPtr m_hProcess = IntPtr.Zero;          private static IntPtr m_hProcess = IntPtr.Zero;
42    
43          public void OpenProcess()          public void OpenProcess()
44          {          {
# Line 69  namespace Sojaner.MemoryScanner Line 69  namespace Sojaner.MemoryScanner
69          }          }
70    
71    
72          public bool DumpMemory(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)  
73            #region RamDumper
74            //private interface IRamDumper
75            //{
76            //    bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead);
77            //    void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data);
78            //}
79            private class RamDumper
80          {          {
81              bytesRead = 0;              public RamDumper() { }
82              uint byte_alignment = 102400; // write to file in 100mb chunks              #region IRamDumper members
83              uint address = MemoryAddress;              #region DumpMemoryToByteArray
84              uint _bytesToRead = bytesToRead;              public void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
85              byte[] buffer = new byte[] { };              {
86              try                  data = new byte[] { };
87              {                  //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));
88                  FileInfo fi = new FileInfo(filename);                  bytesRead = 0;
89                  if (fi.Exists)                  uint byte_alignment = 1;
90                      fi.Delete();                  // get common init parameters
91                  using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))                  //InitMemoryDump(out byte_alignment);
92                    uint address = MemoryAddress;
93                    uint _bytesToRead = bytesToRead;
94                    byte[] buffer = new byte[] { };
95                    try
96                  {                  {
97                      BinaryWriter bw = new BinaryWriter(fs);                      using (MemoryStream ms = new MemoryStream())
                     //foreach (byte b in data) { bw.Write(b); }  
   
                     for (uint i = 0; i <= bytesToRead;)  
98                      {                      {
99                          if (_bytesToRead < byte_alignment)                          BinaryWriter bw = new BinaryWriter(ms);
100                          {                          //foreach (byte b in data) { bw.Write(b); }
101                              _bytesToRead = bytesToRead;  
102                              buffer = new byte[_bytesToRead];                          for (uint i = 0; i <= bytesToRead; )
                         }  
                         else  
                         {  
                             _bytesToRead = byte_alignment;  
                             buffer = new byte[byte_alignment];  
                         }  
                         IntPtr ptrBytesRead;  
                         ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);  
                         bytesRead = ptrBytesRead.ToInt32();  
                         bw.Write(buffer);  
                         bw.Flush();  
                           
                         if (_bytesToRead < byte_alignment)  
                         {  
                             i += _bytesToRead;  
                             address += _bytesToRead;  
                         }  
                         else  
103                          {                          {
104                              i += byte_alignment;                              if (_bytesToRead < byte_alignment)
105                              address += byte_alignment;                              {
106                          }                                  _bytesToRead = bytesToRead;
107                                    buffer = new byte[_bytesToRead];
108                                }
109                                else
110                                {
111                                    _bytesToRead = byte_alignment;
112                                    buffer = new byte[byte_alignment];
113                                }
114                                IntPtr ptrBytesRead;
115                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
116                                bytesRead = ptrBytesRead.ToInt32();
117                                bw.Write(buffer);
118                                bw.Flush();
119    
120                                if (_bytesToRead < byte_alignment)
121                                {
122                                    i += _bytesToRead;
123                                    address += _bytesToRead;
124                                }
125                                else
126                                {
127                                    i += byte_alignment;
128                                    address += byte_alignment;
129                                }
130    
131    
132                                                    }
133                            bw.Close();
134                            data = ms.ToArray();
135                      }                      }
136                      bw.Close();                      //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));
137                  }                  }
138                  return true;                  catch (OutOfMemoryException ex)
             }  
             catch (OutOfMemoryException ex)  
             {  
                 logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");  
                 logger.Error.WriteLine(ex.ToString());  
             }  
             catch (Exception ex)  
             {  
                 logger.Error.WriteLine("DumpMemory(): Exception");  
                 logger.Error.WriteLine(ex.ToString());  
             }  
             return false;  
         }  
   
         public byte[] ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead)  
         {  
             bytesRead = 0;  
             uint address = MemoryAddress;  
             List<byte[]> aligned_array_list = new List<byte[]>();  
             try  
             {  
                 uint byte_alignment = 512; // 4mb alignment  
                 
   
                 for (uint i = 0; i <= bytesToRead; i += byte_alignment)  
139                  {                  {
140                      byte[] buffer = new byte[byte_alignment];                      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));
141                      uint bytes_to_read = byte_alignment;                      logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
142                      IntPtr ptrBytesRead;                      logger.Error.WriteLine(ex.ToString());
143                      ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, bytes_to_read, out ptrBytesRead);                  }
144                      bytesRead = ptrBytesRead.ToInt32();                  catch (Exception ex)
145                      aligned_array_list.Add(buffer);                                      {
146                      address += byte_alignment;                      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));
147                        logger.Error.WriteLine("DumpMemory(): Exception");
148                        logger.Error.WriteLine(ex.ToString());
149                  }                  }
   
                 //List<byte> big_array = new List<byte>();  
                 //foreach (byte[] aligned_array in aligned_array_list) { foreach (byte b in aligned_array) { big_array.Add(b); } }  
   
                 return new byte[] { };  
             }  
             catch (OutOfMemoryException ex)  
             {  
                 logger.Error.WriteLine("ReadProcessMemory(): OutOfMemoryException");  
                 logger.Error.WriteLine(ex.ToString());  
             }  
             catch (Exception ex)  
             {  
                 logger.Error.WriteLine("ReadProcessMemory(): Exception");  
                 logger.Error.WriteLine(ex.ToString());  
150              }              }
151              return new byte[] { };              #endregion
152                #endregion
153          }          }
154            #endregion
         public void WriteProcessMemory(UIntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)  
         {  
             IntPtr ptrBytesWritten;  
             ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);  
   
             bytesWritten = ptrBytesWritten.ToInt32();  
         }  
   
   
155          /// <summary>          /// <summary>
156          /// ProcessMemoryReader is a class that enables direct reading a process memory          /// ProcessMemoryReader is a class that enables direct reading a process memory
157          /// </summary>          /// </summary>
158          class ProcessMemoryReaderApi          private class ProcessMemoryReaderApi
159          {          {
160              // constants information can be found in <winnt.h>              // constants information can be found in <winnt.h>
161              [Flags]              [Flags]
# Line 242  namespace Sojaner.MemoryScanner Line 212  namespace Sojaner.MemoryScanner
212    
213    
214          }          }
215    
216            #region IMemoryReader Members
217            public bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
218            {
219                //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));
220                address = 0;
221                uint byte_alignment = 1;
222                // get common init parameters
223                //InitMemoryDump(out byte_alignment);
224                uint mem_address = MemoryAddress;
225                uint _bytesToRead = bytesToRead;
226                byte[] buffer = new byte[] { };
227                try
228                {
229                    //using (MemoryStream ms = new MemoryStream())
230                    //{
231                    //    //BinaryWriter bw = new BinaryWriter(ms);
232                    //    //foreach (byte b in data) { bw.Write(b); }
233                    for (uint i = 0; i <= bytesToRead; )
234                    {
235                        if (_bytesToRead < byte_alignment)
236                        {
237                            _bytesToRead = bytesToRead;
238                            buffer = new byte[_bytesToRead];
239                        }
240                        else
241                        {
242                            _bytesToRead = byte_alignment;
243                            buffer = new byte[byte_alignment];
244                        }
245                        int bytesRead = 0;
246                        ReadProcessMemory(mem_address, _bytesToRead, out bytesRead, out buffer);
247                        //bw.Write(buffer);
248                        //bw.Flush();
249                        if (_bytesToRead < byte_alignment)
250                        {
251                            i += _bytesToRead;
252                            mem_address += (uint)_bytesToRead;
253                        }
254                        else
255                        {
256                            i += byte_alignment;
257                            mem_address += (uint)byte_alignment;
258                        }
259                        for (uint j = 0; j < buffer.Length; j++)
260                        {
261                            if (buffer[j] != 0)
262                            {
263                                address = mem_address;
264                                break;
265                            }
266                        }
267                        if (address != 0)
268                            break;
269                    }
270                    //    bw.Close();
271                    //}
272                    //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));
273                    return true;
274                }
275                catch (OutOfMemoryException ex)
276                {
277                    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", ReadProcess.Id, ReadProcess.ProcessName));
278                    logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
279                    logger.Error.WriteLine(ex.ToString());
280                }
281                catch (Exception ex)
282                {
283                    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", ReadProcess.Id, ReadProcess.ProcessName));
284                    logger.Error.WriteLine("DumpMemory(): Exception");
285                    logger.Error.WriteLine(ex.ToString());
286                }
287                return false;
288            }
289            public void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
290            {
291                byte[] buffer = new byte[] { };
292                IntPtr ptrBytesRead;
293                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)MemoryAddress, buffer, bytesToRead, out ptrBytesRead);
294                bytesRead = ptrBytesRead.ToInt32();
295                data = buffer;
296            }
297            #endregion
298    
299            #region IMemoryWriter Members
300            public void WriteProcessMemory(uint MemoryAddress, byte byteToWrite, out int bytesWritten)
301            {
302                WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);
303            }
304            public void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
305            {
306                IntPtr ptrBytesWritten;
307                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (UIntPtr)MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);
308                bytesWritten = ptrBytesWritten.ToInt32();
309            }
310            #endregion
311    
312            #region IFileWriter Members
313    
314            public bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
315            {
316                //logger.Info.WriteLine("Dumping memory (0x{0:x8}-0x{1:x8}) from pid=({3}) to file {2}", MemoryAddress, MemoryAddress + bytesToRead, filename, string.Format("0x{0:x4} {1}.exe", ppid.Id, ppid.ProcessName));
317                bytesRead = 0;
318                uint byte_alignment = 102400;
319                uint address = MemoryAddress;
320                uint _bytesToRead = bytesToRead;
321                byte[] buffer = new byte[] { };
322                try
323                {
324                    FileInfo fi = new FileInfo(filename);
325                    if (fi.Exists)
326                        fi.Delete();
327                    using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))
328                    {
329                        BinaryWriter bw = new BinaryWriter(fs);
330                        //foreach (byte b in data) { bw.Write(b); }
331    
332                        for (uint i = 0; i <= bytesToRead; )
333                        {
334                            if (_bytesToRead < byte_alignment)
335                            {
336                                _bytesToRead = bytesToRead;
337                                buffer = new byte[_bytesToRead];
338                            }
339                            else
340                            {
341                                _bytesToRead = byte_alignment;
342                                buffer = new byte[byte_alignment];
343                            }
344                            ReadProcessMemory(address, _bytesToRead, out bytesRead, out buffer);
345                            bw.Write(buffer);
346                            bw.Flush();
347    
348                            if (_bytesToRead < byte_alignment)
349                            {
350                                i += _bytesToRead;
351                                address += (uint)_bytesToRead;
352                            }
353                            else
354                            {
355                                i += byte_alignment;
356                                address += (uint)byte_alignment;
357                            }
358    
359    
360                        }
361                        bw.Close();
362                    }
363                    logger.Info.WriteLine("Succefully dumped memory (0x{0:x8}-0x{1:x8}) from pid=({3}) to file {2}", MemoryAddress, MemoryAddress + bytesToRead, filename, string.Format("0x{0:x4} {1}.exe", ReadProcess.Id, ReadProcess.ProcessName));
364                    return true;
365                }
366                catch (OutOfMemoryException ex)
367                {
368                    logger.Error.WriteLine("Failed to dump memory (0x{0:x8}-0x{1:x8}) from pid=({3}) to file {2}", MemoryAddress, MemoryAddress + bytesToRead, filename, string.Format("0x{0:x4} {1}.exe", ReadProcess.Id, ReadProcess.ProcessName));
369                    logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
370                    logger.Error.WriteLine(ex.ToString());
371                }
372                catch (Exception ex)
373                {
374                    logger.Error.WriteLine("Failed to dump memory (0x{0:x8}-0x{1:x8}) from pid=({3}) to file {2}", MemoryAddress, MemoryAddress + bytesToRead, filename, string.Format("0x{0:x4} {1}.exe", ReadProcess.Id, ReadProcess.ProcessName));
375                    logger.Error.WriteLine("DumpMemory(): Exception");
376                    logger.Error.WriteLine(ex.ToString());
377                }
378                return false;
379            }
380    
381            #endregion
382      }      }
383      #endregion      #endregion
384  }  }

Legend:
Removed from v.167  
changed lines
  Added in v.235

  ViewVC Help
Powered by ViewVC 1.1.22