/[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 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 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 void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
81          {          {
82              bytesRead = 0;              RamDumper dumper = new RamDumper();
83              uint byte_alignment = 102400; // write to file in 100mb chunks              dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead, out data);
84              uint address = MemoryAddress;          }
85              uint _bytesToRead = bytesToRead;          //public void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead,out sbyte[] data)
86              byte[] buffer = new byte[] { };          //{
87              try          //    RamDumper dumper = new RamDumper();
88              {          //    dumper.DumpMemoryToByteArray(ReadProcess, MemoryAddress, bytesToRead, out bytesRead, out data);
89                  FileInfo fi = new FileInfo(filename);          //}
90                  if (fi.Exists)          #endregion
                     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); }  
91    
92                      for (uint i = 0; i <= bytesToRead;)          #region ReadProcessMemory
93                      {          public bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
94                          if (_bytesToRead < byte_alignment)          {
95                          {              RamDumper dumper = new RamDumper();
96                              _bytesToRead = bytesToRead;              return dumper.ReadFirstNonZeroByte(ReadProcess, MemoryAddress, bytesToRead, out address);
97                              buffer = new byte[_bytesToRead];          }
98                          }          #endregion
99                          else          #region WriteProcessMemory
100                          {          public void WriteProcessMemory(UIntPtr MemoryAddress, byte byteToWrite, out int bytesWritten)
101                              _bytesToRead = byte_alignment;          {
102                              buffer = new byte[byte_alignment];              WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);
103                          }          }
104                          IntPtr ptrBytesRead;          public void WriteProcessMemory(UIntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
105                          ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);          {
106                          bytesRead = ptrBytesRead.ToInt32();              IntPtr ptrBytesWritten;
107                          bw.Write(buffer);              ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);
108                          bw.Flush();              bytesWritten = ptrBytesWritten.ToInt32();
109                                    }
110                          if (_bytesToRead < byte_alignment)          #endregion
                         {  
                             i += _bytesToRead;  
                             address += _bytesToRead;  
                         }  
                         else  
                         {  
                             i += byte_alignment;  
                             address += byte_alignment;  
                         }  
111    
112                            
113                      }          #region IPatchMemory members
114                      bw.Close();          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;                  return true;
214              }              }
215              catch (OutOfMemoryException ex)              catch
216              {              {
217                  logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");                  value = 0x00;
218                  logger.Error.WriteLine(ex.ToString());                  return false;
219              }              }
220              catch (Exception ex)          }
221            public bool ReadMemory(uint address, out sbyte value)
222            {
223                try
224              {              {
225                  logger.Error.WriteLine("DumpMemory(): Exception");                  value = 0;
226                  logger.Error.WriteLine(ex.ToString());                  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              }              }
             return false;  
237          }          }
238            public bool ReadMemory(uint address, out ushort value)
         public byte[] ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead)  
239          {          {
             bytesRead = 0;  
             uint address = MemoryAddress;  
             List<byte[]> aligned_array_list = new List<byte[]>();  
240              try              try
241              {              {
242                  uint byte_alignment = 512; // 4mb alignment                  value = 0;
243                                  int bytesReadSize;
244                    byte[] bitData;
245                  for (uint i = 0; i <= bytesToRead; i += byte_alignment)                  ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
246                  {                  value = BitConverter.ToUInt16(bitData, 0);
247                      byte[] buffer = new byte[byte_alignment];                  return true;
                     uint bytes_to_read = byte_alignment;  
                     IntPtr ptrBytesRead;  
                     ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, bytes_to_read, out ptrBytesRead);  
                     bytesRead = ptrBytesRead.ToInt32();  
                     aligned_array_list.Add(buffer);                      
                     address += byte_alignment;  
                 }  
   
                 //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[] { };  
248              }              }
249              catch (OutOfMemoryException ex)              catch
250              {              {
251                  logger.Error.WriteLine("ReadProcessMemory(): OutOfMemoryException");                  value = 0x00;
252                  logger.Error.WriteLine(ex.ToString());                  return false;
253              }              }
254              catch (Exception ex)          }
255            public bool ReadMemory(uint address, out short value)
256            {
257                try
258              {              {
259                  logger.Error.WriteLine("ReadProcessMemory(): Exception");                  value = 0;
260                  logger.Error.WriteLine(ex.ToString());                  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              }              }
             return new byte[] { };  
271          }          }
272            public bool ReadMemory(uint address, out uint value)
         public void WriteProcessMemory(UIntPtr MemoryAddress, byte[] bytesToWrite, out int bytesWritten)  
273          {          {
274              IntPtr ptrBytesWritten;              try
275              ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, MemoryAddress, bytesToWrite, (uint)bytesToWrite.Length, out ptrBytesWritten);              {
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              bytesWritten = ptrBytesWritten.ToInt32();          #region RamDumper
343            private interface IRamDumper
344            {
345               bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead);
346               void DumpMemoryToByteArray(Process ppid, uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data);
347          }          }
348            private class RamDumper : IRamDumper
349            {
350                public RamDumper() { }
351                private void InitMemoryDump(out uint byte_alignment)
352                {
353                    byte_alignment = 102400; // get memory in 100mb chunks
354                }
355                #region IRamDumper members
356                #region DumpMemoryToFile
357                public bool DumpMemoryToFile(Process ppid, string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
358                {
359                    //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));
360                    bytesRead = 0;
361                    uint byte_alignment = 0;
362                    // get common init parameters
363                    InitMemoryDump(out byte_alignment);
364                    uint address = MemoryAddress;
365                    uint _bytesToRead = bytesToRead;
366                    byte[] buffer = new byte[] { };
367                    try
368                    {
369                        FileInfo fi = new FileInfo(filename);
370                        if (fi.Exists)
371                            fi.Delete();
372                        using (FileStream fs = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))
373                        {
374                            BinaryWriter bw = new BinaryWriter(fs);
375                            //foreach (byte b in data) { bw.Write(b); }
376    
377                            for (uint i = 0; i <= bytesToRead; )
378                            {
379                                if (_bytesToRead < byte_alignment)
380                                {
381                                    _bytesToRead = bytesToRead;
382                                    buffer = new byte[_bytesToRead];
383                                }
384                                else
385                                {
386                                    _bytesToRead = byte_alignment;
387                                    buffer = new byte[byte_alignment];
388                                }
389                                IntPtr ptrBytesRead;
390    
391                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
392                                bytesRead = ptrBytesRead.ToInt32();
393                                bw.Write(buffer);
394                                bw.Flush();
395    
396                                if (_bytesToRead < byte_alignment)
397                                {
398                                    i += _bytesToRead;
399                                    address += _bytesToRead;
400                                }
401                                else
402                                {
403                                    i += byte_alignment;
404                                    address += byte_alignment;
405                                }
406    
407    
408                            }
409                            bw.Close();
410                        }
411                        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));
412                        return true;
413                    }
414                    catch (OutOfMemoryException ex)
415                    {
416                        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));
417                        logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
418                        logger.Error.WriteLine(ex.ToString());
419                    }
420                    catch (Exception ex)
421                    {
422                        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));
423                        logger.Error.WriteLine("DumpMemory(): Exception");
424                        logger.Error.WriteLine(ex.ToString());
425                    }
426                    return false;
427                }
428                #endregion
429                #region DumpMemoryToByteArray
430                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));
434                    bytesRead = 0;
435                    uint byte_alignment = 1;
436                    // get common init parameters
437                    //InitMemoryDump(out byte_alignment);
438                    uint address = MemoryAddress;
439                    uint _bytesToRead = bytesToRead;
440                    byte[] buffer = new byte[] { };
441                    try
442                    {
443                        using (MemoryStream ms = new MemoryStream())
444                        {
445                            BinaryWriter bw = new BinaryWriter(ms);
446                            //foreach (byte b in data) { bw.Write(b); }
447    
448                            for (uint i = 0; i <= bytesToRead; )
449                            {
450                                if (_bytesToRead < byte_alignment)
451                                {
452                                    _bytesToRead = bytesToRead;
453                                    buffer = new byte[_bytesToRead];
454                                }
455                                else
456                                {
457                                    _bytesToRead = byte_alignment;
458                                    buffer = new byte[byte_alignment];
459                                }
460                                IntPtr ptrBytesRead;
461    
462                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)address, buffer, _bytesToRead, out ptrBytesRead);
463                                bytesRead = ptrBytesRead.ToInt32();
464                                bw.Write(buffer);
465                                bw.Flush();
466    
467                                if (_bytesToRead < byte_alignment)
468                                {
469                                    i += _bytesToRead;
470                                    address += _bytesToRead;
471                                }
472                                else
473                                {
474                                    i += byte_alignment;
475                                    address += byte_alignment;
476                                }
477    
478    
479                            }
480                            bw.Close();
481                            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));
484                    }
485                    catch (OutOfMemoryException ex)
486                    {
487                        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));
488                        logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
489                        logger.Error.WriteLine(ex.ToString());
490                    }
491                    catch (Exception ex)
492                    {
493                        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));
494                        logger.Error.WriteLine("DumpMemory(): Exception");
495                        logger.Error.WriteLine(ex.ToString());
496                    }
497                }
498                #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
570    
571                #region ReadFirstNonZeroByte
572                public bool ReadFirstNonZeroByte(Process ppid, uint MemoryAddress, uint bytesToRead, out uint address)
573                {
574                    //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));
575                    address = 0;
576                    uint byte_alignment = 1;
577                    // get common init parameters
578                    //InitMemoryDump(out byte_alignment);
579                    uint mem_address = MemoryAddress;
580                    uint _bytesToRead = bytesToRead;
581                    byte[] buffer = new byte[] { };
582                    try
583                    {
584                        //using (MemoryStream ms = new MemoryStream())
585                        //{
586                        //    //BinaryWriter bw = new BinaryWriter(ms);
587                        //    //foreach (byte b in data) { bw.Write(b); }
588                            for (uint i = 0; i <= bytesToRead; )
589                            {
590                                if (_bytesToRead < byte_alignment)
591                                {
592                                    _bytesToRead = bytesToRead;
593                                    buffer = new byte[_bytesToRead];
594                                }
595                                else
596                                {
597                                    _bytesToRead = byte_alignment;
598                                    buffer = new byte[byte_alignment];
599                                }
600                                IntPtr ptrBytesRead;
601                                ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (UIntPtr)mem_address, buffer, _bytesToRead, out ptrBytesRead);
602                                //bw.Write(buffer);
603                                //bw.Flush();
604                                if (_bytesToRead < byte_alignment)
605                                {
606                                    i += _bytesToRead;
607                                    mem_address += _bytesToRead;
608                                }
609                                else
610                                {
611                                    i += byte_alignment;
612                                    mem_address += byte_alignment;
613                                }
614                                for (uint j = 0; j < buffer.Length; j++)
615                                {
616                                    if (buffer[j] != 0)
617                                    {
618                                        address = mem_address;
619                                        break;
620                                    }
621                                }
622                                if (address != 0)
623                                    break;
624                            }
625                        //    bw.Close();
626                        //}
627                        //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));
628                        return true;
629                    }
630                    catch (OutOfMemoryException ex)
631                    {
632                        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));
633                        logger.Error.WriteLine("DumpMemory(): OutOfMemoryException");
634                        logger.Error.WriteLine(ex.ToString());
635                    }
636                    catch (Exception ex)
637                    {
638                        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));
639                        logger.Error.WriteLine("DumpMemory(): Exception");
640                        logger.Error.WriteLine(ex.ToString());
641                    }
642                    return false;
643                }
644                #endregion
645            }
646            #endregion
647          /// <summary>          /// <summary>
648          /// ProcessMemoryReader is a class that enables direct reading a process memory          /// ProcessMemoryReader is a class that enables direct reading a process memory
649          /// </summary>          /// </summary>
650          class ProcessMemoryReaderApi          public class ProcessMemoryReaderApi
651          {          {
652              // constants information can be found in <winnt.h>              // constants information can be found in <winnt.h>
653              [Flags]              [Flags]

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

  ViewVC Help
Powered by ViewVC 1.1.22