/[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 369 by william, Sun Jun 10 03:14:42 2012 UTC revision 370 by william, Sun Jun 10 05:40:24 2012 UTC
# Line 17  namespace Sojaner.MemoryScanner Line 17  namespace Sojaner.MemoryScanner
17      #region ProcessMemoryReader class      #region ProcessMemoryReader class
18      //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
19      //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
20      internal class ProcessMemoryReader : IMemoryReader, IMemoryWriter, IFileWriter      internal class ProcessMemoryReader : IMemoryReader, IMemoryWriter, IFileWriter, IPatchMemory,IReadMemory
21      {      {
22    
23          public ProcessMemoryReader()          public ProcessMemoryReader()
# Line 304  namespace Sojaner.MemoryScanner Line 304  namespace Sojaner.MemoryScanner
304                      }                      }
305                      else                      else
306                      {                      {
307                            //buffer_list.Add((byte)'?');
308                          buffer_list.Add(0);                          buffer_list.Add(0);
309                          _MemoryAddress++;                          _MemoryAddress++;
310                      }                      }
# Line 445  namespace Sojaner.MemoryScanner Line 446  namespace Sojaner.MemoryScanner
446          }          }
447          #endregion          #endregion
448          #endregion          #endregion
449    
450            #region IPatchMemory members
451            #region public virtual bool PatchMemory(int address, byte value)
452            public virtual bool PatchMemory(int address, byte value)
453            {
454                byte[] bitData = BitConverter.GetBytes(value);
455                UIntPtr ptrBytesWritten;
456                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
457                if (ptrBytesWritten.ToUInt32() == 0)
458                    return false;
459                byte check = 0;
460                ReadMemory(address, out check);
461                if (check == value) return true;
462                return false;
463            }
464            #endregion
465            #region public virtual bool PatchMemory(int address, sbyte value)
466            public virtual bool PatchMemory(int address, sbyte value)
467            {
468                byte[] bitData = BitConverter.GetBytes(value);
469                UIntPtr ptrBytesWritten;
470                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
471                if (ptrBytesWritten.ToUInt32() == 0)
472                    return false;
473                sbyte check = 0;
474                ReadMemory(address, out check);
475                if (check == value) return true;
476                return false;
477            }
478            #endregion
479            #region public virtual bool PatchMemory(int address, ushort value)
480            public virtual bool PatchMemory(int address, ushort value)
481            {
482                byte[] bitData = BitConverter.GetBytes(value);
483                UIntPtr ptrBytesWritten;
484                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
485                if (ptrBytesWritten.ToUInt32() == 0)
486                    return false;
487                ushort check = 0;
488                ReadMemory(address, out check);
489                if (check == value) return true;
490                return false;
491            }
492            #endregion
493            #region public virtual bool PatchMemory(int address, short value)
494            public virtual bool PatchMemory(int address, short value)
495            {          
496                byte[] bitData = BitConverter.GetBytes(value);
497                UIntPtr ptrBytesWritten;
498                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
499                if (ptrBytesWritten.ToUInt32() == 0)
500                    return false;
501                short check = 0;
502                ReadMemory(address, out check);
503                if (check == value) return true;
504                return false;
505            }
506            #endregion
507            #region public virtual bool PatchMemory(int address, uint value)
508            public virtual bool PatchMemory(int address, uint value)
509            {
510                byte[] bitData = BitConverter.GetBytes(value);
511                UIntPtr ptrBytesWritten;
512                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
513                if (ptrBytesWritten.ToUInt32() == 0)
514                    return false;
515                uint check = 0;
516                ReadMemory(address, out check);
517                if (check == value) return true;
518                return false;
519            }
520            #endregion
521            #region public virtual bool PatchMemory(int address, int value)
522            public virtual bool PatchMemory(int address, int value)
523            {
524                byte[] bitData = BitConverter.GetBytes(value);
525                UIntPtr ptrBytesWritten;
526                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
527                if (ptrBytesWritten.ToUInt32() == 0)
528                    return false;
529                int check = 0;
530                ReadMemory(address, out check);
531                if (check == value) return true;
532                return false;
533            }
534            #endregion
535            #region public virtual bool PatchMemory(int address, ulong value)
536            public virtual bool PatchMemory(int address, ulong value)
537            {
538                byte[] bitData = BitConverter.GetBytes(value);
539                UIntPtr ptrBytesWritten;
540                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
541                if (ptrBytesWritten.ToUInt32() == 0)
542                    return false;
543                ulong check = 0;
544                ReadMemory(address, out check);
545                if (check == value) return true;
546                return false;
547            }
548            #endregion
549            #region public virtual bool PatchMemory(int address, long value)
550            public virtual bool PatchMemory(int address, long value)
551            {
552                byte[] bitData = BitConverter.GetBytes(value);
553                UIntPtr ptrBytesWritten;
554                ProcessMemoryReaderApi.WriteProcessMemory(m_hProcess, (IntPtr)address, bitData, (uint)bitData.Length, out ptrBytesWritten);
555                if (ptrBytesWritten.ToUInt32() == 0)
556                    return false;
557                long check = 0;
558                ReadMemory(address, out check);
559                if (check == value) return true;
560                return false;
561            }
562            #endregion
563            #endregion
564    
565            #region IReadMemory members
566            #region public virtual bool ReadMemory(int address, out byte value)
567            public virtual bool ReadMemory(int address, out byte value)
568            {
569                value = 0;          
570                try
571                {
572                    int bytesRead;
573                    uint size = sizeof(byte);
574                    byte[] bitData = new byte[size];
575                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
576                    if (bytesRead == 0)
577                        return false;
578                    value = bitData[0];
579                    return true;
580                }
581                catch
582                {
583                    value = 0x00;
584                    return false;
585                }
586            }
587            #endregion
588            #region public virtual bool ReadMemory(int address, out sbyte value)
589            public virtual bool ReadMemory(int address, out sbyte value)
590            {
591                value = 0;          
592                try
593                {
594                    int bytesRead;
595                    uint size = sizeof(sbyte);
596                    byte[] bitData = new byte[size];
597                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
598                    if (bytesRead == 0)
599                        return false;
600                    value = Convert.ToSByte(bitData[0]);
601                    return true;
602                }
603                catch
604                {
605                    value = 0x00;
606                    return false;
607                }
608            }
609            #endregion
610            #region public virtual bool ReadMemory(int address, out ushort value)
611            public virtual bool ReadMemory(int address, out ushort value)
612            {
613                value = 0;          
614                try
615                {
616                    int bytesRead;
617                    uint size = sizeof(ushort);
618                    byte[] bitData = new byte[size];
619                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
620                    if (bytesRead == 0)
621                        return false;
622                    value = BitConverter.ToUInt16(bitData, 0);
623                    return true;
624                }
625                catch
626                {
627                    value = 0x00;
628                    return false;
629                }
630            }
631            #endregion
632            #region public virtual bool ReadMemory(int address, out short value)
633            public virtual bool ReadMemory(int address, out short value)
634            {
635                value = 0;          
636                try
637                {
638                    int bytesRead;
639                    uint size = sizeof(short);
640                    byte[] bitData = new byte[size];
641                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
642                    if (bytesRead == 0)
643                        return false;
644                    value = BitConverter.ToInt16(bitData, 0);
645                    return true;
646                }
647                catch
648                {
649                    value = 0x00;
650                    return false;
651                }
652            }
653            #endregion
654            #region public virtual bool ReadMemory(int address, out uint value)
655            public virtual bool ReadMemory(int address, out uint value)
656            {
657                value = 0;          
658                try
659                {
660                    int bytesRead;
661                    uint size = sizeof(uint);
662                    byte[] bitData = new byte[size];
663                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
664                    if (bytesRead == 0)
665                        return false;
666                    value = BitConverter.ToUInt32(bitData, 0);
667                    return true;
668                }
669                catch
670                {
671                    value = 0x00;
672                    return false;
673                }
674            }
675            #endregion
676            #region public virtual bool ReadMemory(int address, out int value)
677            public virtual bool ReadMemory(int address, out int value)
678            {
679                value = 0;          
680                try
681                {
682                    int bytesRead;
683                    uint size = sizeof(int);
684                    byte[] bitData = new byte[size];
685                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
686                    if (bytesRead == 0)
687                        return false;
688                    value = BitConverter.ToInt32(bitData, 0);
689                    return true;
690                }
691                catch
692                {
693                    value = 0x00;
694                    return false;
695                }
696            }
697            #endregion
698            #region public virtual bool ReadMemory(int address, out ulong value)
699            public virtual bool ReadMemory(int address, out ulong value)
700            {
701                value = 0;          
702                try
703                {
704                    int bytesRead;
705                    uint size = sizeof(ulong);
706                    byte[] bitData = new byte[size];
707                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
708                    if (bytesRead == 0)
709                        return false;
710                    value = BitConverter.ToUInt64(bitData, 0);
711                    return true;
712                }
713                catch
714                {
715                    value = 0x00;
716                    return false;
717                }
718            }
719            #endregion
720            #region public virtual bool ReadMemory(int address, out long value)
721            public virtual bool ReadMemory(int address, out long value)
722            {
723                value = 0;          
724                try
725                {
726                    int bytesRead;
727                    uint size = sizeof(long);
728                    byte[] bitData = new byte[size];
729                    ProcessMemoryReader.ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)address, bitData, size, out bytesRead);
730                    if (bytesRead == 0)
731                        return false;
732                    value = BitConverter.ToInt64(bitData, 0);
733                    return true;
734                }
735                catch
736                {
737                    value = 0x00;
738                    return false;
739                }
740            }
741            #endregion
742            #endregion
743      }      }
744      #endregion      #endregion
745  }  }

Legend:
Removed from v.369  
changed lines
  Added in v.370

  ViewVC Help
Powered by ViewVC 1.1.22