1. C++ / Говнокод #28181

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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, 22 Мая 2022

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

    • ava guest6 22.05.2022 23:35 # −1

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

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

      • ava Ddddddddd 22.05.2022 23:38 # 0

        Не нужное? Это что например?
        Ответить

        • ava guest6 23.05.2022 00:05 # 0

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

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

          • ava Ddddddddd 23.05.2022 00:08 # 0

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

          • ava 3.14159265 23.05.2022 06:43 # 0

            Вырвиглазое крестоговно.

            Особо одарённые даже int i{42} инициализируют.
            Ответить

            • ava guest6 23.05.2022 10:52 # 0

              Это uniform-initialization, 

              ES.23: Prefer the {}-initializer syntax


              А такое видели ?

              for (int i{}; i < 10; ++i )
              Ответить

              • ava Fike 23.05.2022 14:23 # +1

                > А такое видели ?

                Да. На говнокоде.
                Ответить

              • ava kcalbCube 25.05.2022 06:24 # 0

                я потратил два месяца для того что бы отучить себя использовать size_t для счётчика
                Ответить

                • ava j123123 25.05.2022 10:09 # 0

                  Что именно не так с использованием size_t для счетчика, и что ты начал использовать вместо size_t?
                  Ответить

                  • ava guest6 25.05.2022 11:07 # 0

                    int конечно, иначе у меня компилируется на C89
                    Ответить

      • ava Ddddddddd 22.05.2022 23:49 # 0

        Ебля с предпроцессором ахуенно, хуёвый код.
        Ответить

        • ava guest6 23.05.2022 00:15 # 0

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

          • ava Ddddddddd 23.05.2022 00:25 # 0

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

            • ava nyTuH_nugop 23.05.2022 00:27 # 0

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

            • ava guest6 23.05.2022 00:33 # +1

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

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

    • ava Support 23.05.2022 21:20 # 0

      > PROCESSENTRY32 pe{ sizeof(PROCESSENTRY32) };

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

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