/[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 204 by william, Thu May 31 09:08:24 2012 UTC
# 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 68  namespace Sojaner.MemoryScanner Line 68  namespace Sojaner.MemoryScanner
68              }              }
69          }          }
70    
71            #region WriteProcessMemoryToFile
72            public bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
73            {
74                RamDumper dumper = new RamDumper();
75                return dumper.DumpMemoryToFile(ReadProcess, filename, MemoryAddress, bytesToRead, out bytesRead);
76            }
77            #endregion
78    
79          public bool DumpMemory(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)          #region ReadProcessMemory
80            public byte[] ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead)
81          {          {
82              bytesRead = 0;              RamDumper dumper = new RamDumper();
83              uint byte_alignment = 102400; // write to file in 100mb chunks              return dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead);
84              uint address = MemoryAddress;          }
85              uint _bytesToRead = bytesToRead;          #endregion
86              byte[] buffer = new byte[] { };  
87              try          #region ReadProcessMemory
88            public bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
89            {
90                RamDumper dumper = new RamDumper();
91                return dumper.ReadFirstNonZeroByte(ReadProcess, MemoryAddress, bytesToRead, out address);
92            }
93            #endregion
94            #region WriteProcessMemory
95            public void WriteProcessMemory(UIntPtr MemoryAddress, byte byteToWrite, out int bytesWritten)
96            {
97                WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);
98            }
99            public void WriteProcessMemory(UIntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
100            {
101                IntPtr ptrBytesWritten;
102                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);
103                bytesWritten = ptrBytesWritten.ToInt32();
104            }
105            #endregion
106    
107            #region RamDumper
108            private interface IRamDumper
109            {
110               bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead);
111               byte[] DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead);
112            }
113            private class RamDumper : IRamDumper
114            {
115                public RamDumper() { }
116                private void InitMemoryDump(out uint byte_alignment)
117              {              {
118                  FileInfo fi = new FileInfo(filename);                  byte_alignment = 102400; // get memory in 100mb chunks
119                  if (fi.Exists)              }
120                      fi.Delete();              #region IRamDumper members
121                  using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))              #region DumpMemoryToFile
122                public bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
123                {
124                    //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));
125                    bytesRead = 0;
126                    uint byte_alignment = 0;
127                    // get common init parameters
128                    InitMemoryDump(out byte_alignment);
129                    uint address = MemoryAddress;
130                    uint _bytesToRead = bytesToRead;
131                    byte[] buffer = new byte[] { };
132                    try
133                  {                  {
134                      BinaryWriter bw = new BinaryWriter(fs);                      FileInfo fi = new FileInfo(filename);
135                      //foreach (byte b in data) { bw.Write(b); }                      if (fi.Exists)
136                            fi.Delete();
137                      for (uint i = 0; i <= bytesToRead;)                      using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))
138                      {                      {
139                          if (_bytesToRead < byte_alignment)                          BinaryWriter bw = new BinaryWriter(fs);
140                          {                          //foreach (byte b in data) { bw.Write(b); }
141                              _bytesToRead = bytesToRead;  
142                              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  
143                          {                          {
144                              i += byte_alignment;                              if (_bytesToRead < byte_alignment)
145                              address += byte_alignment;                              {
146                          }                                  _bytesToRead = bytesToRead;
147                                    buffer = new byte[_bytesToRead];
148                                }
149                                else
150                                {
151                                    _bytesToRead = byte_alignment;
152                                    buffer = new byte[byte_alignment];
153                                }
154                                IntPtr ptrBytesRead;
155    
156                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
157                                bytesRead = ptrBytesRead.ToInt32();
158                                bw.Write(buffer);
159                                bw.Flush();
160    
161                                if (_bytesToRead < byte_alignment)
162                                {
163                                    i += _bytesToRead;
164                                    address += _bytesToRead;
165                                }
166                                else
167                                {
168                                    i += byte_alignment;
169                                    address += byte_alignment;
170                                }
171    
172    
173                                                    }
174                            bw.Close();
175                      }                      }
176                      bw.Close();                      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", ppid.Id, ppid.ProcessName));
177                        return true;
178                  }                  }
179                  return true;                  catch (OutOfMemoryException ex)
180              }                  {
181              catch (OutOfMemoryException ex)                      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", ppid.Id, ppid.ProcessName));
182              {                      logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
183                  logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");                      logger.Error.WriteLine(ex.ToString());
184                  logger.Error.WriteLine(ex.ToString());                  }
185                    catch (Exception ex)
186                    {
187                        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", ppid.Id, ppid.ProcessName));
188                        logger.Error.WriteLine("DumpMemory(): Exception");
189                        logger.Error.WriteLine(ex.ToString());
190                    }
191                    return false;
192              }              }
193              catch (Exception ex)              #endregion
194                #region DumpMemoryToByteArray
195                public byte[] DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead)
196              {              {
197                  logger.Error.WriteLine("DumpMemory(): Exception");                  //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));
198                  logger.Error.WriteLine(ex.ToString());                  bytesRead = 0;
199              }                  uint byte_alignment = 1;
200              return false;                  // get common init parameters
201          }                  //InitMemoryDump(out byte_alignment);
202                    uint address = MemoryAddress;
203                    uint _bytesToRead = bytesToRead;
204                    byte[] buffer = new byte[] { };
205                    try
206                    {
207                        using (MemoryStream ms = new MemoryStream())
208                        {
209                            BinaryWriter bw = new BinaryWriter(ms);
210                            //foreach (byte b in data) { bw.Write(b); }
211    
212                            for (uint i = 0; i <= bytesToRead; )
213                            {
214                                if (_bytesToRead < byte_alignment)
215                                {
216                                    _bytesToRead = bytesToRead;
217                                    buffer = new byte[_bytesToRead];
218                                }
219                                else
220                                {
221                                    _bytesToRead = byte_alignment;
222                                    buffer = new byte[byte_alignment];
223                                }
224                                IntPtr ptrBytesRead;
225    
226                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
227                                bytesRead = ptrBytesRead.ToInt32();
228                                bw.Write(buffer);
229                                bw.Flush();
230    
231                                if (_bytesToRead < byte_alignment)
232                                {
233                                    i += _bytesToRead;
234                                    address += _bytesToRead;
235                                }
236                                else
237                                {
238                                    i += byte_alignment;
239                                    address += byte_alignment;
240                                }
241    
         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  
                 
242    
243                  for (uint i = 0; i <= bytesToRead; i += byte_alignment)                          }
244                            bw.Close();
245                            return ms.ToArray();
246                        }
247                        //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));
248                    }
249                    catch (OutOfMemoryException ex)
250                  {                  {
251                      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));
252                      uint bytes_to_read = byte_alignment;                      logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
253                      IntPtr ptrBytesRead;                      logger.Error.WriteLine(ex.ToString());
                     ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, bytes_to_read, out ptrBytesRead);  
                     bytesRead = ptrBytesRead.ToInt32();  
                     aligned_array_list.Add(buffer);                      
                     address += byte_alignment;  
254                  }                  }
255                    catch (Exception ex)
256                  //List<byte> big_array = new List<byte>();                  {
257                  //foreach (byte[] aligned_array in aligned_array_list) { foreach (byte b in aligned_array) { big_array.Add(b); } }                      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));
258                        logger.Error.WriteLine("DumpMemory(): Exception");
259                  return new byte[] { };                      logger.Error.WriteLine(ex.ToString());
260              }                  }
261              catch (OutOfMemoryException ex)                  return new byte[]{};
             {  
                 logger.Error.WriteLine("ReadProcessMemory(): OutOfMemoryException");  
                 logger.Error.WriteLine(ex.ToString());  
262              }              }
263              catch (Exception ex)              #endregion
264                #endregion
265    
266                #region ReadFirstNonZeroByte
267                public bool ReadFirstNonZeroByte(Process ppid, uint MemoryAddress, uint bytesToRead, out uint address)
268              {              {
269                  logger.Error.WriteLine("ReadProcessMemory(): Exception");                  //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));
270                  logger.Error.WriteLine(ex.ToString());                  address = 0;
271                    uint byte_alignment = 1;
272                    // get common init parameters
273                    //InitMemoryDump(out byte_alignment);
274                    uint mem_address = MemoryAddress;
275                    uint _bytesToRead = bytesToRead;
276                    byte[] buffer = new byte[] { };
277                    try
278                    {
279                        //using (MemoryStream ms = new MemoryStream())
280                        //{
281                        //    //BinaryWriter bw = new BinaryWriter(ms);
282                        //    //foreach (byte b in data) { bw.Write(b); }
283                            for (uint i = 0; i <= bytesToRead; )
284                            {
285                                if (_bytesToRead < byte_alignment)
286                                {
287                                    _bytesToRead = bytesToRead;
288                                    buffer = new byte[_bytesToRead];
289                                }
290                                else
291                                {
292                                    _bytesToRead = byte_alignment;
293                                    buffer = new byte[byte_alignment];
294                                }
295                                IntPtr ptrBytesRead;
296                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)mem_address, buffer, _bytesToRead, out ptrBytesRead);
297                                //bw.Write(buffer);
298                                //bw.Flush();
299                                if (_bytesToRead < byte_alignment)
300                                {
301                                    i += _bytesToRead;
302                                    mem_address += _bytesToRead;
303                                }
304                                else
305                                {
306                                    i += byte_alignment;
307                                    mem_address += byte_alignment;
308                                }
309                                for (uint j = 0; j < buffer.Length; j++)
310                                {
311                                    if (buffer[j] != 0)
312                                    {
313                                        address = mem_address;
314                                        break;
315                                    }
316                                }
317                                if (address != 0)
318                                    break;
319                            }
320                        //    bw.Close();
321                        //}
322                        //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));
323                        return true;
324                    }
325                    catch (OutOfMemoryException ex)
326                    {
327                        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));
328                        logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
329                        logger.Error.WriteLine(ex.ToString());
330                    }
331                    catch (Exception ex)
332                    {
333                        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));
334                        logger.Error.WriteLine("DumpMemory(): Exception");
335                        logger.Error.WriteLine(ex.ToString());
336                    }
337                    return false;
338              }              }
339              return new byte[] { };              #endregion
340          }          }
341            #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();  
         }  
   
   
342          /// <summary>          /// <summary>
343          /// ProcessMemoryReader is a class that enables direct reading a process memory          /// ProcessMemoryReader is a class that enables direct reading a process memory
344          /// </summary>          /// </summary>
345          class ProcessMemoryReaderApi          public class ProcessMemoryReaderApi
346          {          {
347              // constants information can be found in <winnt.h>              // constants information can be found in <winnt.h>
348              [Flags]              [Flags]

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

  ViewVC Help
Powered by ViewVC 1.1.22