/[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 230 by william, Sat Jun 2 18:31:40 2012 UTC revision 231 by william, Sun Jun 3 12:36:47 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 : IPatchMemory, IReadMemory      internal class ProcessMemoryReader : IMemoryReader, IMemoryWriter, IFileWriter
18      {      {
19    
20          public ProcessMemoryReader()          public ProcessMemoryReader()
# Line 68  namespace Sojaner.MemoryScanner Line 68  namespace Sojaner.MemoryScanner
68              }              }
69          }          }
70    
         #region WriteProcessMemoryToFile  
         public bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)  
         {  
             RamDumper dumper = new RamDumper();  
             return dumper.DumpMemoryToFile(ReadProcess, filename, MemoryAddress, bytesToRead, out bytesRead);  
         }  
         #endregion  
   
         #region ReadProcessMemory  
         public void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)  
         {  
             RamDumper dumper = new RamDumper();  
             dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead, out data);  
         }  
         //public void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead,out sbyte[] data)  
         //{  
         //    RamDumper dumper = new RamDumper();  
         //    dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead, out data);  
         //}  
         #endregion  
   
         #region ReadProcessMemory  
         public bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)  
         {  
             RamDumper dumper = new RamDumper();  
             return dumper.ReadFirstNonZeroByte(ReadProcess, MemoryAddress, bytesToRead, out address);  
         }  
         #endregion  
         #region WriteProcessMemory  
         public void WriteProcessMemory(UIntPtr MemoryAddress, byte byteToWrite, out int bytesWritten)  
         {  
             WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);  
         }  
         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();  
         }  
         #endregion  
   
71    
         #region IPatchMemory members  
         public bool PatchMemory(uint address, byte value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             byte check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, sbyte value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             sbyte check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, ushort value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             ushort check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, short value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             short check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, uint value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             uint check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, int value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             int check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, ulong value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             ulong check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         public bool PatchMemory(uint address, long value)  
         {  
             int bytesWritten;  
             byte[] bitData = BitConverter.GetBytes(value);  
             WriteProcessMemory((UIntPtr)address, bitData, out bytesWritten);  
             CloseHandle();  
             long check = 0;  
             ReadMemory(address, out check);  
             if (check == value) return true;  
             return false;  
         }  
         #endregion  
         #region IReadMemory members  
         public bool ReadMemory(uint address, out byte value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = bitData[0];  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out sbyte value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = Convert.ToSByte(bitData[0]);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out ushort value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = BitConverter.ToUInt16(bitData, 0);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out short value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = BitConverter.ToInt16(bitData, 0);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out uint value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = BitConverter.ToUInt32(bitData, 0);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out int value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = BitConverter.ToInt32(bitData, 0);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out ulong value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = BitConverter.ToUInt64(bitData, 0);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         public bool ReadMemory(uint address, out long value)  
         {  
             try  
             {  
                 value = 0;  
                 int bytesReadSize;  
                 byte[] bitData;  
                 ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);  
                 value = BitConverter.ToInt64(bitData, 0);  
                 return true;  
             }  
             catch  
             {  
                 value = 0x00;  
                 return false;  
             }  
         }  
         #endregion  
72    
73          #region RamDumper          #region RamDumper
74          private interface IRamDumper          //private interface IRamDumper
75          {          //{
76             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);
77             void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data);          //    void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data);
78          }          //}
79          private class RamDumper : IRamDumper          private class RamDumper
80          {          {
81              public RamDumper() { }              public RamDumper() { }
             private void InitMemoryDump(out uint byte_alignment)  
             {  
                 byte_alignment = 102400; // get memory in 100mb chunks  
             }  
82              #region IRamDumper members              #region IRamDumper members
             #region DumpMemoryToFile  
             public bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)  
             {  
                 //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));  
                 bytesRead = 0;  
                 uint byte_alignment = 0;  
                 // get common init parameters  
                 InitMemoryDump(out byte_alignment);  
                 uint address = MemoryAddress;  
                 uint _bytesToRead = bytesToRead;  
                 byte[] buffer = new byte[] { };  
                 try  
                 {  
                     FileInfo fi = new FileInfo(filename);  
                     if (fi.Exists)  
                         fi.Delete();  
                     using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))  
                     {  
                         BinaryWriter bw = new BinaryWriter(fs);  
                         //foreach (byte b in data) { bw.Write(b); }  
   
                         for (uint i = 0; i <= bytesToRead; )  
                         {  
                             if (_bytesToRead < byte_alignment)  
                             {  
                                 _bytesToRead = bytesToRead;  
                                 buffer = new byte[_bytesToRead];  
                             }  
                             else  
                             {  
                                 _bytesToRead = byte_alignment;  
                                 buffer = new byte[byte_alignment];  
                             }  
                             IntPtr ptrBytesRead;  
   
                             ProcessMemoryReader.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  
                             {  
                                 i += byte_alignment;  
                                 address += byte_alignment;  
                             }  
   
   
                         }  
                         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));  
                     return true;  
                 }  
                 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));  
                     logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");  
                     logger.Error.WriteLine(ex.ToString());  
                 }  
                 catch (Exception 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));  
                     logger.Error.WriteLine("DumpMemory(): Exception");  
                     logger.Error.WriteLine(ex.ToString());  
                 }  
                 return false;  
             }  
             #endregion  
83              #region DumpMemoryToByteArray              #region DumpMemoryToByteArray
84              public void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)              public void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
85              {              {
# Line 458  namespace Sojaner.MemoryScanner Line 112  namespace Sojaner.MemoryScanner
112                                  buffer = new byte[byte_alignment];                                  buffer = new byte[byte_alignment];
113                              }                              }
114                              IntPtr ptrBytesRead;                              IntPtr ptrBytesRead;
   
115                              ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);                              ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
116                              bytesRead = ptrBytesRead.ToInt32();                              bytesRead = ptrBytesRead.ToInt32();
117                              bw.Write(buffer);                              bw.Write(buffer);
# Line 496  namespace Sojaner.MemoryScanner Line 149  namespace Sojaner.MemoryScanner
149                  }                  }
150              }              }
151              #endregion              #endregion
             #region DumpMemoryToByteArray (sbyte)  
             //public void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out sbyte[] data)  
             //{  
             //    data = new sbyte[] { };  
             //    //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));  
             //    bytesRead = 0;  
             //    uint byte_alignment = 1;  
             //    // get common init parameters  
             //    //InitMemoryDump(out byte_alignment);  
             //    uint address = MemoryAddress;  
             //    uint _bytesToRead = bytesToRead;  
             //    sbyte[] buffer = new sbyte[] { };  
             //    try  
             //    {  
             //        using (MemoryStream ms = new MemoryStream())  
             //        {  
             //            BinaryWriter bw = new BinaryWriter(ms);  
             //            //foreach (byte b in data) { bw.Write(b); }  
   
             //            for (uint i = 0; i <= bytesToRead; )  
             //            {  
             //                if (_bytesToRead < byte_alignment)  
             //                {  
             //                    _bytesToRead = bytesToRead;  
             //                    buffer = new sbyte[_bytesToRead];  
             //                }  
             //                else  
             //                {  
             //                    _bytesToRead = byte_alignment;  
             //                    buffer = new sbyte[byte_alignment];  
             //                }  
             //                IntPtr ptrBytesRead;  
   
             //                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, (byte[])(Array)buffer, _bytesToRead, out ptrBytesRead);  
             //                bytesRead = ptrBytesRead.ToInt32();  
             //                bw.Write((byte[])(Array)buffer);  
             //                bw.Flush();  
   
             //                if (_bytesToRead < byte_alignment)  
             //                {  
             //                    i += _bytesToRead;  
             //                    address += _bytesToRead;  
             //                }  
             //                else  
             //                {  
             //                    i += byte_alignment;  
             //                    address += byte_alignment;  
             //                }  
   
   
             //            }  
             //            bw.Close();  
             //            data = (sbyte[])(Array)ms.ToArray();  
             //        }  
             //        //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));  
             //    }  
             //    catch (OutOfMemoryException ex)  
             //    {  
             //        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));  
             //        logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");  
             //        logger.Error.WriteLine(ex.ToString());  
             //    }  
             //    catch (Exception ex)  
             //    {  
             //        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));  
             //        logger.Error.WriteLine("DumpMemory(): Exception");  
             //        logger.Error.WriteLine(ex.ToString());  
             //    }  
             //}  
             #endregion  
             #endregion  
   
             #region ReadFirstNonZeroByte  
             public bool ReadFirstNonZeroByte(Process ppid, uint MemoryAddress, uint bytesToRead, out uint address)  
             {  
                 //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));  
                 address = 0;  
                 uint byte_alignment = 1;  
                 // get common init parameters  
                 //InitMemoryDump(out byte_alignment);  
                 uint mem_address = MemoryAddress;  
                 uint _bytesToRead = bytesToRead;  
                 byte[] buffer = new byte[] { };  
                 try  
                 {  
                     //using (MemoryStream ms = new MemoryStream())  
                     //{  
                     //    //BinaryWriter bw = new BinaryWriter(ms);  
                     //    //foreach (byte b in data) { bw.Write(b); }  
                         for (uint i = 0; i <= bytesToRead; )  
                         {  
                             if (_bytesToRead < byte_alignment)  
                             {  
                                 _bytesToRead = bytesToRead;  
                                 buffer = new byte[_bytesToRead];  
                             }  
                             else  
                             {  
                                 _bytesToRead = byte_alignment;  
                                 buffer = new byte[byte_alignment];  
                             }  
                             IntPtr ptrBytesRead;  
                             ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)mem_address, buffer, _bytesToRead, out ptrBytesRead);  
                             //bw.Write(buffer);  
                             //bw.Flush();  
                             if (_bytesToRead < byte_alignment)  
                             {  
                                 i += _bytesToRead;  
                                 mem_address += _bytesToRead;  
                             }  
                             else  
                             {  
                                 i += byte_alignment;  
                                 mem_address += byte_alignment;  
                             }  
                             for (uint j = 0; j < buffer.Length; j++)  
                             {  
                                 if (buffer[j] != 0)  
                                 {  
                                     address = mem_address;  
                                     break;  
                                 }  
                             }  
                             if (address != 0)  
                                 break;  
                         }  
                     //    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));  
                     return true;  
                 }  
                 catch (OutOfMemoryException ex)  
                 {  
                     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));  
                     logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");  
                     logger.Error.WriteLine(ex.ToString());  
                 }  
                 catch (Exception ex)  
                 {  
                     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));  
                     logger.Error.WriteLine("DumpMemory(): Exception");  
                     logger.Error.WriteLine(ex.ToString());  
                 }  
                 return false;  
             }  
152              #endregion              #endregion
153          }          }
154          #endregion          #endregion
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          public 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 704  namespace Sojaner.MemoryScanner Line 212  namespace Sojaner.MemoryScanner
212    
213    
214          }          }
215    
216            #region IMemoryReader Members
217            public bool ReadFirstNonZeroByte(uint MemoryAddress, int 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                int byte_alignment = 1;
222                // get common init parameters
223                //InitMemoryDump(out byte_alignment);
224                uint mem_address = MemoryAddress;
225                int _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 (int 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, int bytesToRead, out int bytesRead, out byte[] data)
290            {
291                byte[] buffer = new byte[] { };
292                IntPtr ptrBytesRead;
293                uint _bytesToRead = (uint)bytesToRead;
294                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)MemoryAddress, buffer, _bytesToRead, out ptrBytesRead);
295                bytesRead = ptrBytesRead.ToInt32();
296                data = buffer;
297            }
298            #endregion
299    
300            #region IMemoryWriter Members
301            public void WriteProcessMemory(uint MemoryAddress, byte byteToWrite, out int bytesWritten)
302            {
303                WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);
304            }
305            public void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
306            {
307                IntPtr ptrBytesWritten;
308                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (UIntPtr)MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);
309                bytesWritten = ptrBytesWritten.ToInt32();
310            }
311            #endregion
312    
313            #region IFileWriter Members
314    
315            public bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, int bytesToRead, out int bytesRead)
316            {
317                //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));
318                bytesRead = 0;
319                int byte_alignment = 102400;
320                uint address = MemoryAddress;
321                int _bytesToRead = bytesToRead;
322                byte[] buffer = new byte[] { };
323                try
324                {
325                    FileInfo fi = new FileInfo(filename);
326                    if (fi.Exists)
327                        fi.Delete();
328                    using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))
329                    {
330                        BinaryWriter bw = new BinaryWriter(fs);
331                        //foreach (byte b in data) { bw.Write(b); }
332    
333                        for (int i = 0; i <= bytesToRead; )
334                        {
335                            if (_bytesToRead < byte_alignment)
336                            {
337                                _bytesToRead = bytesToRead;
338                                buffer = new byte[_bytesToRead];
339                            }
340                            else
341                            {
342                                _bytesToRead = byte_alignment;
343                                buffer = new byte[byte_alignment];
344                            }
345                            ReadProcessMemory(address, _bytesToRead, out bytesRead, out buffer);
346                            bw.Write(buffer);
347                            bw.Flush();
348    
349                            if (_bytesToRead < byte_alignment)
350                            {
351                                i += _bytesToRead;
352                                address += (uint)_bytesToRead;
353                            }
354                            else
355                            {
356                                i += byte_alignment;
357                                address += (uint)byte_alignment;
358                            }
359    
360    
361                        }
362                        bw.Close();
363                    }
364                    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));
365                    return true;
366                }
367                catch (OutOfMemoryException ex)
368                {
369                    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));
370                    logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
371                    logger.Error.WriteLine(ex.ToString());
372                }
373                catch (Exception ex)
374                {
375                    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));
376                    logger.Error.WriteLine("DumpMemory(): Exception");
377                    logger.Error.WriteLine(ex.ToString());
378                }
379                return false;
380            }
381    
382            #endregion
383      }      }
384      #endregion      #endregion
385  }  }

Legend:
Removed from v.230  
changed lines
  Added in v.231

  ViewVC Help
Powered by ViewVC 1.1.22