Кресты / Говнокод #28181 Ссылка на оригинал

+1

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
  26. 26
  27. 27
  28. 28
  29. 29
  30. 30
  31. 31
  32. 32
  33. 33
  34. 34
  35. 35
  36. 36
  37. 37
  38. 38
  39. 39
  40. 40
  41. 41
  42. 42
  43. 43
  44. 44
  45. 45
  46. 46
  47. 47
  48. 48
  49. 49
  50. 50
  51. 51
  52. 52
  53. 53
  54. 54
  55. 55
  56. 56
  57. 57
  58. 58
  59. 59
  60. 60
  61. 61
  62. 62
  63. 63
  64. 64
  65. 65
  66. 66
  67. 67
  68. 68
  69. 69
  70. 70
  71. 71
  72. 72
  73. 73
  74. 74
  75. 75
  76. 76
  77. 77
  78. 78
  79. 79
  80. 80
  81. 81
  82. 82
  83. 83
  84. 84
  85. 85
  86. 86
  87. 87
  88. 88
  89. 89
  90. 90
  91. 91
  92. 92
  93. 93
  94. 94
  95. 95
  96. 96
  97. 97
class Memory 
 { 
 public: 
         Memory() : hProcess{ nullptr }, pID{ 0 } {} 
         ~Memory() { SafeCloseHandle(hProcess); } 
  
         bool Attach(const char* _Process, DWORD rights) 
         { 
                 HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 
  
                 if (hSnap == INVALID_HANDLE_VALUE) 
                         return false; 
  
                 PROCESSENTRY32 pe{ sizeof(PROCESSENTRY32) }; 
  
                 while (Process32Next(hSnap, &pe)) 
                         if (!strcmp(pe.szExeFile, _Process)) 
                         { 
                                 SafeCloseHandle(hSnap); 
                                 pID = pe.th32ProcessID; 
  
                                 hProcess = OpenProcess(rights, 0, pe.th32ProcessID); 
  
 #ifdef _DEBUG || DEBUG 
                                 if (hProcess) // Ok 
                                 { 
                                         std::cout << "Attaching to process: " << _Process << " -> "; 
                                         ColoredMessage("OK!", LGREEN, true); 
                                 } 
 #endif // DEBUG 
  
                                 return true; 
                         } 
  
 #ifdef _DEBUG || DEBUG 
                 std::cout << "Attaching to process: " << _Process << " -> "; 
                 ColoredMessage("FAIL!", LRED, true); 
 #endif // DEBUG 
  
                 SafeCloseHandle(hSnap); 
                 return false; 
         } 
  
         PModule GetModule(const char* _Module) 
         { 
                 HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pID); 
  
                 if (hSnap == INVALID_HANDLE_VALUE) 
                         return PModule{ 0, 0 }; 
  
                 MODULEENTRY32 mEntry{ sizeof(MODULEENTRY32) }; 
  
                 while (Module32Next(hSnap, &mEntry)) 
                         if (!strcmp(mEntry.szModule, _Module)) 
                         { 
                                 SafeCloseHandle(hSnap); 
  
                                 return PModule{ (DWORD)mEntry.hModule, mEntry.modBaseSize }; 
                         } 
  
 #ifdef _DEBUG || DEBUG 
                 std::cout << "Getting module: "; ColoredMessage("FAIL!", LRED, true); 
 #endif // DEBUG 
  
  
                 SafeCloseHandle(hSnap); 
                 return PModule{ 0, 0 }; 
         } 
  
         template <class _Ty> 
         _Ty read(DWORD _Addr) 
         { 
                 DWORD _dwRead; 
                 _Ty _Val; 
  
 #ifdef _DEBUG || DEBUG  
                 if (!ReadProcessMemory(hProcess, (LPCVOID)_Addr, &_Val, sizeof(_Ty), &_dwRead)) 
                 { 
                         std::cout << "Reading the memory: "; 
                         ColoredMessage("FAIL!", LRED, true); 
                 } 
 #else // DEBUG  
                 ReadProcessMemory(hProcess, (LPCVOID)_Addr, &_Val, sizeof(_Ty), &_dwRead) 
 #endif 
                         return _Val; 
         } 
  
         template <class _Ty> 
         void write(DWORD _Addr, _Ty _Val) 
         { 
                 DWORD _dwWrite; 
  
 #ifdef _DEBUG || DEBUG  
                 if (!WriteProcessMemory(hProcess, (LPVOID)_Addr, &_Val, sizeof(_Ty), &_dwWrite)) 
                 { 
                         std::cout << "Writing the memory: "; 
                         ColoredMessage("FAIL!", LRED, true);

Ладно.

Запостил: Ddddddddd Ddddddddd, (Updated )

Комментарии (17) RSS

  • ava guest # +1

    `hProcess{ nullptr }, pID{ 0 }`, ахаа, пробелы мы любим, делать ненужное мы любим.

    В остальном, здоровья тому, кто это будет дебажить и/или облепливать тестами.
    Ответить

      • ava guest # 0 ⇈

        Пустые фигурные скобки --- особый тип valu initialization, называемый zero initialization.

        hProcess{ nullptr }, pID{ 0 } == hProcess{}, pID{}
        Ответить

      • ava guest # 0 ⇈

        Это да, но тут он просто для дебаггинга (к слову, использование стандартного потока вывода вместо потока ошибок, тоже прелесть).
        Ответить

        • ava Ddddddddd # Ссылка на оригинал 0 ⇈

          "вместо потока ошибок", ты имеешь ввиду лучше эксепшены или ран тайм эрроры кидать?
          Ответить

          • ava nyTuH_nugop # Ссылка на оригинал 0 ⇈

            страус >> труп еще и перемешан с кастомными цветастыми сообщениями.
            Ответить

          • ava guest # 0 ⇈

            Ну, есть много методов обработки ошибок, а данном случаи, тут, как я понимаю, по большей части precondition и poscondition, исключения не особо сюда. Я про то, что вместо небуферизированный потока ошибок использован буферизированный стандартный поток вывода. Если программа упадёт *без* сброса буфера (тот случай, когда std::endl не был бы грехом), вывод не произойдёт.

            Ну и, да, как обозначил товарищ выше кастомные ошибки _без дебаг-информации_ это тоже что-то из сказочного.
            Ответить

  • ava Support # Ссылка на оригинал 0

    > PROCESSENTRY32 pe{ sizeof(PROCESSENTRY32) };

    Грязная обертка над memset?
    Ответить

Добавить комментарий

Переведи на "PHP", guest!

    А не использовать ли нам bbcode?

    ↑
    8
    ↓