/[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 88 by william, Wed May 9 20:52:20 2012 UTC revision 167 by william, Mon May 28 08:31:56 2012 UTC
# Line 4  using System.Text; Line 4  using System.Text;
4  using System.Diagnostics;  using System.Diagnostics;
5  using System.Threading;  using System.Threading;
6  using System.Runtime.InteropServices;  using System.Runtime.InteropServices;
7    using RomCheater.Logging;
8    using RomCheater.Core;
9    using System.IO;
10    
11  namespace Sojaner.MemoryScanner  namespace Sojaner.MemoryScanner
12  {  {
# Line 65  namespace Sojaner.MemoryScanner Line 68  namespace Sojaner.MemoryScanner
68              }              }
69          }          }
70    
71          public byte[] ReadProcessMemory(IntPtr MemoryAddress, uint bytesToRead, out int bytesRead)  
72            public bool DumpMemory(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
73          {          {
74              byte[] buffer = new byte[bytesToRead];              bytesRead = 0;
75                uint byte_alignment = 102400; // write to file in 100mb chunks
76                uint address = MemoryAddress;
77                uint _bytesToRead = bytesToRead;
78                byte[] buffer = new byte[] { };
79                try
80                {
81                    FileInfo fi = new FileInfo(filename);
82                    if (fi.Exists)
83                        fi.Delete();
84                    using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))
85                    {
86                        BinaryWriter bw = new BinaryWriter(fs);
87                        //foreach (byte b in data) { bw.Write(b); }
88    
89              IntPtr ptrBytesRead;                      for (uint i = 0; i <= bytesToRead;)
90              ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead);                      {
91                            if (_bytesToRead < byte_alignment)
92                            {
93                                _bytesToRead = bytesToRead;
94                                buffer = new byte[_bytesToRead];
95                            }
96                            else
97                            {
98                                _bytesToRead = byte_alignment;
99                                buffer = new byte[byte_alignment];
100                            }
101                            IntPtr ptrBytesRead;
102                            ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
103                            bytesRead = ptrBytesRead.ToInt32();
104                            bw.Write(buffer);
105                            bw.Flush();
106                            
107                            if (_bytesToRead < byte_alignment)
108                            {
109                                i += _bytesToRead;
110                                address += _bytesToRead;
111                            }
112                            else
113                            {
114                                i += byte_alignment;
115                                address += byte_alignment;
116                            }
117    
118                            
119                        }
120                        bw.Close();
121                    }
122                    return true;
123                }
124                catch (OutOfMemoryException ex)
125                {
126                    logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
127                    logger.Error.WriteLine(ex.ToString());
128                }
129                catch (Exception ex)
130                {
131                    logger.Error.WriteLine("DumpMemory(): Exception");
132                    logger.Error.WriteLine(ex.ToString());
133                }
134                return false;
135            }
136    
137              bytesRead = ptrBytesRead.ToInt32();          public byte[] ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead)
138            {
139                bytesRead = 0;
140                uint address = MemoryAddress;
141                List<byte[]> aligned_array_list = new List<byte[]>();
142                try
143                {
144                    uint byte_alignment = 512; // 4mb alignment
145                  
146    
147                    for (uint i = 0; i <= bytesToRead; i += byte_alignment)
148                    {
149                        byte[] buffer = new byte[byte_alignment];
150                        uint bytes_to_read = byte_alignment;
151                        IntPtr ptrBytesRead;
152                        ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, bytes_to_read, out ptrBytesRead);
153                        bytesRead = ptrBytesRead.ToInt32();
154                        aligned_array_list.Add(buffer);                    
155                        address += byte_alignment;
156                    }
157    
158                    //List<byte> big_array = new List<byte>();
159                    //foreach (byte[] aligned_array in aligned_array_list) { foreach (byte b in aligned_array) { big_array.Add(b); } }
160    
161              return buffer;                  return new byte[] { };
162                }
163                catch (OutOfMemoryException ex)
164                {
165                    logger.Error.WriteLine("ReadProcessMemory(): OutOfMemoryException");
166                    logger.Error.WriteLine(ex.ToString());
167                }
168                catch (Exception ex)
169                {
170                    logger.Error.WriteLine("ReadProcessMemory(): Exception");
171                    logger.Error.WriteLine(ex.ToString());
172                }
173                return new byte[] { };
174          }          }
175    
176          public void WriteProcessMemory(IntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)          public void WriteProcessMemory(UIntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
177          {          {
178              IntPtr ptrBytesWritten;              IntPtr ptrBytesWritten;
179              ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);              ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);
# Line 132  namespace Sojaner.MemoryScanner Line 228  namespace Sojaner.MemoryScanner
228              //                  SIZE_T * lpNumberOfBytesRead  // number of bytes read              //                  SIZE_T * lpNumberOfBytesRead  // number of bytes read
229              //                  );              //                  );
230              [DllImport("kernel32.dll")]              [DllImport("kernel32.dll")]
231              public static extern Int32 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);              public static extern Int32 ReadProcessMemory(IntPtr hProcess, UIntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);
232    
233              //          BOOL WriteProcessMemory(              //          BOOL WriteProcessMemory(
234              //                  HANDLE hProcess,                // handle to process              //                  HANDLE hProcess,                // handle to process
# Line 142  namespace Sojaner.MemoryScanner Line 238  namespace Sojaner.MemoryScanner
238              //                  SIZE_T * lpNumberOfBytesWritten // count of bytes written              //                  SIZE_T * lpNumberOfBytesWritten // count of bytes written
239              //                  );              //                  );
240              [DllImport("kernel32.dll")]              [DllImport("kernel32.dll")]
241              public static extern Int32 WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesWritten);              public static extern Int32 WriteProcessMemory(IntPtr hProcess, UIntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesWritten);
242    
243    
244          }          }

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

  ViewVC Help
Powered by ViewVC 1.1.22