API tools faq
paste
alien_fx_fiend

Fixing Invalid Characters + ImportsExRes + Separate 64/32bit Func

alien_fx_fiend
Dec 19th, 2024
12
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 114.85 KB | Source Code | 0 0
raw download clone embed print report
  1. #define STRICT
  2. #define WIN32_LEAN_AND_MEAN
  3. #include <Windows.h>
  4. #include <winternl.h>
  5. #include <CommCtrl.h>
  6. #include <commdlg.h>
  7. #include <string>
  8. #include <strsafe.h>
  9. #include <sstream>
  10. #include <iomanip>
  11. #include <stdio.h>
  12. #include <vector>
  13. #include <shellapi.h>
  14. //#include "helpers.h"
  15. #include "resource.h"
  16. #pragma comment(lib, "comctl32.lib")
  17.  
  18. //bool Is64BitPE(PIMAGE_NT_HEADERS pNtHeaders);
  19.  
  20. namespace PEHelpers {    
  21.     // Add these new helper functions
  22.     bool Is64BitPE(PIMAGE_NT_HEADERS pNtHeaders) {
  23.         return pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC;
  24.     }
  25.  
  26.     DWORD_PTR GetImageBase(PIMAGE_NT_HEADERS pNtHeaders) {
  27.         if (PEHelpers::Is64BitPE(pNtHeaders)) {
  28.             auto pNtHeaders64 = reinterpret_cast<PIMAGE_NT_HEADERS64>(pNtHeaders);
  29.             return static_cast<DWORD_PTR>(pNtHeaders64->OptionalHeader.ImageBase);
  30.         }
  31.         else {
  32.             auto pNtHeaders32 = reinterpret_cast<PIMAGE_NT_HEADERS32>(pNtHeaders);
  33.             return static_cast<DWORD_PTR>(pNtHeaders32->OptionalHeader.ImageBase);
  34.         }
  35.     }
  36.  
  37.     DWORD GetSizeOfImage(PIMAGE_NT_HEADERS pNtHeaders) {
  38.         if (PEHelpers::Is64BitPE(pNtHeaders)) {
  39.             auto pNtHeaders64 = reinterpret_cast<PIMAGE_NT_HEADERS64>(pNtHeaders);
  40.             return pNtHeaders64->OptionalHeader.SizeOfImage;
  41.         }
  42.         else {
  43.             auto pNtHeaders32 = reinterpret_cast<PIMAGE_NT_HEADERS32>(pNtHeaders);
  44.             return pNtHeaders32->OptionalHeader.SizeOfImage;
  45.         }
  46.     }
  47.  
  48.     bool ValidateFileSize(DWORD expectedSize, DWORD fileSize) {
  49.         // Validate against SizeOfHeaders instead of SizeOfImage
  50.         return expectedSize > 0 && expectedSize <= fileSize;
  51.     }
  52. //}
  53.  
  54.     // Replace the existing GetRvaPtr function in PEHelpers namespace with this:
  55.     DWORD_PTR GetRvaPtr(DWORD rva, PIMAGE_SECTION_HEADER pSectionHeader, WORD numberOfSections, LPVOID baseAddress) {
  56.         for (WORD i = 0; i < numberOfSections; i++) {
  57.             if (rva >= pSectionHeader[i].VirtualAddress &&
  58.                 rva < (pSectionHeader[i].VirtualAddress + pSectionHeader[i].SizeOfRawData)) {
  59.                 DWORD_PTR delta = (DWORD_PTR)baseAddress + pSectionHeader[i].PointerToRawData;
  60.                 return delta + (rva - pSectionHeader[i].VirtualAddress);
  61.             }
  62.         }
  63.         return 0;
  64.     }
  65.  
  66.     // Add to PEHelpers namespace:
  67.     bool IsRvaValid(DWORD rva, DWORD fileSize, PIMAGE_NT_HEADERS pNtHeaders) {
  68.         return rva < pNtHeaders->OptionalHeader.SizeOfImage&& rva < fileSize;
  69.     }
  70.  
  71.     // Add this new helper function in PEHelpers namespace:
  72.     PIMAGE_SECTION_HEADER GetEnclosingSectionHeader(DWORD rva, PIMAGE_SECTION_HEADER pSectionHeader, WORD numberOfSections) {
  73.         for (WORD i = 0; i < numberOfSections; i++) {
  74.             if ((rva >= pSectionHeader[i].VirtualAddress) &&
  75.                 (rva < (pSectionHeader[i].VirtualAddress + pSectionHeader[i].SizeOfRawData))) {
  76.                 return &pSectionHeader[i];
  77.             }
  78.         }
  79.         return nullptr;
  80.     }
  81.  
  82.     std::wstring GetImageCharacteristics(DWORD characteristics) {
  83.         if (characteristics & IMAGE_FILE_DLL) return L"(DLL)";
  84.         if (characteristics & IMAGE_FILE_SYSTEM) return L"(DRIVER)";
  85.         if (characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) return L"(EXE)";
  86.         return L"(UNKNOWN)";
  87.     }
  88.  
  89.     std::wstring GetSubsystem(WORD subsystem) {
  90.         switch (subsystem) {
  91.         case IMAGE_SUBSYSTEM_NATIVE: return L"(NATIVE/DRIVER)";
  92.         case IMAGE_SUBSYSTEM_WINDOWS_GUI: return L"(GUI)";
  93.         case IMAGE_SUBSYSTEM_WINDOWS_CUI: return L"(CONSOLE)";
  94.         default: return L"(UNKNOWN)";
  95.         }
  96.     }
  97.  
  98.     std::wstring GetDataDirectoryName(int DirectoryNumber) {
  99.         switch (DirectoryNumber) {
  100.         case 0: return L"Export Table";
  101.         case 1: return L"Import Table";
  102.         case 2: return L"Resource Table";
  103.         case 3: return L"Exception Entry";
  104.         case 4: return L"Security Entry";
  105.         case 5: return L"Relocation Table";
  106.         case 6: return L"Debug Entry";
  107.         case 7: return L"Copyright Entry";
  108.         case 8: return L"Global PTR Entry";
  109.         case 9: return L"TLS Entry";
  110.         case 10: return L"Configuration Entry";
  111.         case 11: return L"Bound Import Entry";
  112.         case 12: return L"IAT";
  113.         case 13: return L"Delay Import Descriptor";
  114.         case 14: return L"COM Descriptor";
  115.         default: return L"Unknown";
  116.         }
  117.     }
  118.  
  119.     std::wstring GetSectionProtection(DWORD characteristics) {
  120.         std::wstring protection = L"(";
  121.         bool needsSeparator = false;
  122.  
  123.         if (characteristics & IMAGE_SCN_MEM_EXECUTE) {
  124.             protection += L"EXECUTE";
  125.             needsSeparator = true;
  126.         }
  127.  
  128.         if (characteristics & IMAGE_SCN_MEM_READ) {
  129.             if (needsSeparator) protection += L" | ";
  130.             protection += L"READ";
  131.             needsSeparator = true;
  132.         }
  133.  
  134.         if (characteristics & IMAGE_SCN_MEM_WRITE) {
  135.             if (needsSeparator) protection += L" | ";
  136.             protection += L"WRITE";
  137.         }
  138.  
  139.         protection += L")";
  140.         return protection;
  141.     }
  142.  
  143.     PIMAGE_SECTION_HEADER GetExportSection(const PIMAGE_SECTION_HEADER pImageSectionHeader,
  144.         const int NumberOfSections,
  145.         const DWORD_PTR dExportAddress) {
  146.         for (int i = 0; i < NumberOfSections; ++i) {
  147.             const auto pCurrentSectionHeader =
  148.                 (PIMAGE_SECTION_HEADER)((DWORD_PTR)pImageSectionHeader + i * sizeof(IMAGE_SECTION_HEADER));
  149.  
  150.             if (dExportAddress >= pCurrentSectionHeader->VirtualAddress &&
  151.                 dExportAddress < pCurrentSectionHeader->VirtualAddress + pCurrentSectionHeader->Misc.VirtualSize)
  152.                 return pCurrentSectionHeader;
  153.         }
  154.         return nullptr;
  155.     }
  156.  
  157.     DWORD RvaToOffset(DWORD rva, PIMAGE_SECTION_HEADER pSectionHeader, WORD numberOfSections) {
  158.         for (WORD i = 0; i < numberOfSections; i++) {
  159.             if (rva >= pSectionHeader[i].VirtualAddress &&
  160.                 rva < (pSectionHeader[i].VirtualAddress + pSectionHeader[i].SizeOfRawData)) {
  161.                 return (rva - pSectionHeader[i].VirtualAddress) + pSectionHeader[i].PointerToRawData;
  162.             }
  163.         }
  164.         return 0;
  165.     }
  166. }
  167.  
  168. using namespace std;
  169.  
  170. // At the top of your file, change the window class name to wide string
  171. #define WINDOW_CLASS_NAME L"PEAnalyzerWindow"
  172. //const wchar_t* const WINDOW_CLASS_NAME = L"PEAnalyzerWindow";
  173.  
  174. // Use ANSI versions explicitly
  175. //#undef CreateWindow
  176. //#undef CreateWindowEx
  177. //#define CreateWindow  CreateWindowW
  178. //#define CreateWindowEx CreateWindowExW
  179.  
  180. // Helper function to replace printf with GUI output
  181. #define OUTPUT(format, ...) AppendToOutput(L##format, ##__VA_ARGS__)
  182. //#define OUTPUT(format, ...) AppendToOutput(format, ##__VA_ARGS__)
  183. //#define printf(format, ...) AppendToOutput(format, ##__VA_ARGS__)
  184.  
  185. // Window dimensions
  186. #define WINDOW_WIDTH    1024
  187. #define WINDOW_HEIGHT   768
  188. #define EDIT_MARGIN    10
  189.  
  190. // Global variables
  191. HWND g_hMainWindow = NULL;
  192. HWND g_hEditControl = NULL;
  193. HFONT g_hFont = NULL;
  194. std::wstringstream g_OutputText;
  195. WCHAR filePathW[MAX_PATH];
  196. std::vector<wchar_t> g_OutputBuffer;
  197. std::wstring tempBuffer; // Declare tempBuffer globally
  198. HWND g_hStatusBar = NULL;
  199. HWND g_hProgressBar = NULL;  // Add this with your other global variables
  200. //int virtualHeight = 100;  // Initialize with an appropriate value
  201.  
  202. // Function declarations
  203. LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  204. LRESULT CALLBACK EditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);
  205. void CreateMainWindow(HINSTANCE hInstance);
  206. void InitializeControls(HWND hwnd);
  207. void AddMenus(HWND hwnd);
  208. void OpenFileDialog(HWND hwnd);
  209. //void AnalyzePEFile(const WCHAR* filePathW);
  210. void AnalyzePEFile(const wchar_t* filePathW);
  211. HANDLE GetFileContent(const wchar_t* lpFilePath);
  212. /*void GetDataDirectories(PIMAGE_DATA_DIRECTORY pImageDataDirectory);
  213. PIMAGE_SECTION_HEADER GetSections(const PIMAGE_SECTION_HEADER pImageSectionHeader,
  214.     int NumberOfSections, DWORD dImportAddress);
  215. void GetImports32(PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor,
  216.     DWORD dRawOffset, const PIMAGE_SECTION_HEADER pImageImportSection);
  217. void GetImports64(PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor,
  218.     DWORD dRawOffset, const PIMAGE_SECTION_HEADER pImageImportSection);*/
  219. void AppendToOutput(const wchar_t* format, ...);
  220. void UpdateEditControl();
  221.  
  222. // Main window class name
  223. //const char* const WINDOW_CLASS_NAME = "PEAnalyzerWindow";
  224.  
  225. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
  226.     INITCOMMONCONTROLSEX icc = { sizeof(INITCOMMONCONTROLSEX), ICC_WIN95_CLASSES };
  227.     InitCommonControlsEx(&icc);
  228.  
  229.     // Get command line parameters in Unicode
  230.     int argc;
  231.     LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
  232.  
  233.     CreateMainWindow(hInstance);
  234.     if (!g_hMainWindow) {
  235.         LocalFree(argv);
  236.         return -1;
  237.     }
  238.  
  239.     ShowWindow(g_hMainWindow, nCmdShow);
  240.     UpdateWindow(g_hMainWindow);
  241.  
  242.     // If there's a command line parameter, process it
  243.     if (argc > 1) {
  244.         // Process the first parameter as file path
  245.         SetWindowTextW(g_hEditControl, L"");
  246.         g_OutputText.str(L"");
  247.         g_OutputText.clear();
  248.         AnalyzePEFile(argv[1]);
  249.         UpdateEditControl();
  250.     }
  251.  
  252.     LocalFree(argv);
  253.  
  254.     MSG msg = {};
  255.     while (GetMessage(&msg, NULL, 0, 0)) {
  256.         TranslateMessage(&msg);
  257.         DispatchMessage(&msg);
  258.     }
  259.  
  260.     if (g_hFont) DeleteObject(g_hFont);
  261.     return (int)msg.wParam;
  262. }
  263.  
  264. void CreateMainWindow(HINSTANCE hInstance) {
  265.     WNDCLASSEXW wc = { sizeof(WNDCLASSEXW), 0, WindowProc, 0, 0, hInstance,
  266.         LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1)),
  267.         LoadCursor(NULL, IDC_ARROW),
  268.         (HBRUSH)(COLOR_WINDOW + 1),
  269.         NULL, WINDOW_CLASS_NAME,
  270.         LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1)) };
  271.     RegisterClassExW(&wc);
  272.  
  273.     // Get screen dimensions
  274.     int screenWidth = GetSystemMetrics(SM_CXSCREEN);
  275.     int screenHeight = GetSystemMetrics(SM_CYSCREEN);
  276.  
  277.     // Calculate center position
  278.     int windowX = (screenWidth - WINDOW_WIDTH) / 2;
  279.     int windowY = (screenHeight - WINDOW_HEIGHT) / 2;
  280.  
  281.     // Remove WS_MAXIMIZEBOX and WS_THICKFRAME from the window style
  282.     DWORD style = (WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX) & ~WS_THICKFRAME;
  283.     //WS_OVERLAPPEDWINDOW ~~> style
  284.     g_hMainWindow = CreateWindowExW(0, WINDOW_CLASS_NAME, L"PE File Analyzer",
  285.         style, windowX, windowY, WINDOW_WIDTH, WINDOW_HEIGHT,
  286.         nullptr, nullptr, hInstance, nullptr);
  287. }
  288.  
  289. void InitializeControls(HWND hwnd) {
  290.     // Create status bar
  291.     g_hStatusBar = CreateWindowEx(0, STATUSCLASSNAME, NULL,
  292.         WS_CHILD | WS_VISIBLE,
  293.         0, 0, 0, 0, hwnd, NULL,
  294.         (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
  295.  
  296.     // Set up status bar parts
  297.     RECT rcClient;
  298.     GetClientRect(hwnd, &rcClient);
  299.     int statusParts[2] = { 150, rcClient.right };
  300.     SendMessage(g_hStatusBar, SB_SETPARTS, 2, (LPARAM)statusParts);
  301.  
  302.     // Create progress bar in the second part of status bar
  303.     RECT rcPart;
  304.     SendMessage(g_hStatusBar, SB_GETRECT, 1, (LPARAM)&rcPart);
  305.  
  306.     g_hProgressBar = CreateWindowEx(0, PROGRESS_CLASS, NULL,
  307.         WS_CHILD | WS_VISIBLE | PBS_SMOOTH,
  308.         rcPart.left + 5, rcPart.top + 2,
  309.         rcPart.right - rcPart.left - 10, rcPart.bottom - rcPart.top - 4,
  310.         g_hStatusBar, NULL,
  311.         (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
  312.  
  313.     // Set blue color and range
  314.     SendMessage(g_hProgressBar, PBM_SETBARCOLOR, 0, (LPARAM)RGB(0, 120, 215));  // Windows 10 blue
  315.     SendMessage(g_hProgressBar, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
  316.     SendMessage(g_hProgressBar, PBM_SETSTEP, 1, 0);
  317.  
  318.     // Get status bar height for edit control positioning
  319.     RECT rcStatus;
  320.     GetWindowRect(g_hStatusBar, &rcStatus);
  321.     int statusHeight = rcStatus.bottom - rcStatus.top;
  322.  
  323.     // Create edit control
  324.     g_hEditControl = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"",
  325.         WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL |
  326.         ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL,
  327.         EDIT_MARGIN, EDIT_MARGIN,
  328.         rcClient.right - (2 * EDIT_MARGIN),
  329.         rcClient.bottom - statusHeight - (2 * EDIT_MARGIN),
  330.         hwnd, nullptr,
  331.         (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), nullptr);
  332.  
  333.     // Create and set font
  334.     g_hFont = CreateFont(-14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, 0,
  335.         ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  336.         DEFAULT_QUALITY, DEFAULT_PITCH | FF_MODERN, L"Consolas");
  337.  
  338.     if (g_hFont)
  339.         SendMessage(g_hEditControl, WM_SETFONT, (WPARAM)g_hFont, TRUE);
  340.  
  341.     SetWindowSubclass(g_hEditControl, EditSubclassProc, 0, 0);
  342. }
  343.  
  344. void AddMenus(HWND hwnd) {
  345.     HMENU hMenuBar = CreateMenu();
  346.     HMENU hFileMenu = CreateMenu();
  347.     AppendMenu(hMenuBar, MF_POPUP, (UINT_PTR)hFileMenu, L"&File");
  348.     AppendMenu(hFileMenu, MF_STRING, 1, L"&Open\tCtrl+O");  // Updated to show shortcut
  349.     AppendMenu(hFileMenu, MF_STRING, 2, L"E&xit");
  350.     SetMenu(hwnd, hMenuBar);
  351. }
  352.  
  353. /*LRESULT CALLBACK EditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
  354.     if (uMsg == WM_KEYDOWN) {
  355.         // Check for Ctrl+O
  356.         if ((GetKeyState(VK_CONTROL) & 0x8000) && wParam == 'O') {
  357.             SendMessage(GetParent(hwnd), WM_COMMAND, 1, 0);  // Send the Open command
  358.             return 0;
  359.         }
  360.  
  361.         // Existing cases
  362.         switch (wParam) {
  363.         case VK_F1:
  364.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_F1, 0);
  365.             return 0;
  366.         case VK_ESCAPE:
  367.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_ESCAPE, 0);
  368.             return 0;
  369.         case VK_PRIOR:  // Page Up
  370.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_PRIOR, 0);
  371.             return 0;
  372.         case VK_NEXT:  // Page Down
  373.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_NEXT, 0);
  374.             return 0;
  375.         }
  376.     }
  377.     else if (uMsg == WM_MOUSEWHEEL) {
  378.         int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
  379.         if (zDelta > 0) {
  380.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_PRIOR, 0);  // Mouse Wheel Up
  381.         }
  382.         else if (zDelta < 0) {
  383.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_NEXT, 0);  // Mouse Wheel Down
  384.         }
  385.         return 0;
  386.     }
  387.     return DefSubclassProc(hwnd, uMsg, wParam, lParam);
  388. }*/
  389.  
  390. // First, add this helper function to determine if the PE file is 64-bit
  391. bool Is64BitPE(PIMAGE_NT_HEADERS pNtHeaders) {
  392.     return pNtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC;
  393. }
  394.  
  395. LRESULT CALLBACK EditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
  396.     if (uMsg == WM_KEYDOWN) {
  397.         if ((GetKeyState(VK_CONTROL) & 0x8000) && wParam == 'O') {
  398.             SendMessage(GetParent(hwnd), WM_COMMAND, 1, 0);
  399.             return 0;
  400.         }
  401.         switch (wParam) {
  402.         case VK_F1:
  403.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_F1, 0);
  404.             return 0;
  405.         case VK_ESCAPE:
  406.             SendMessage(GetParent(hwnd), WM_KEYDOWN, VK_ESCAPE, 0);
  407.             return 0;
  408.         case VK_PRIOR:
  409.             // Scroll up
  410.             SendMessage(hwnd, WM_VSCROLL, MAKELONG(SB_PAGEUP, 0), 0);
  411.             return 0;
  412.         case VK_NEXT:
  413.             // Scroll down
  414.             SendMessage(hwnd, WM_VSCROLL, MAKELONG(SB_PAGEDOWN, 0), 0);
  415.             return 0;
  416.         case VK_UP:
  417.             // Scroll one line up
  418.             SendMessage(hwnd, WM_VSCROLL, MAKELONG(SB_LINEUP, 0), 0);
  419.             return 0;
  420.         case VK_DOWN:
  421.             // Scroll one line down
  422.             SendMessage(hwnd, WM_VSCROLL, MAKELONG(SB_LINEDOWN, 0), 0);
  423.             return 0;
  424.         }
  425.     }
  426.     if (uMsg == WM_MOUSEWHEEL) {
  427.         int delta = GET_WHEEL_DELTA_WPARAM(wParam);
  428.         if (delta > 0) {
  429.             // Scroll up
  430.             SendMessage(hwnd, WM_VSCROLL, MAKELONG(SB_PAGEUP, 0), 0);
  431.         }
  432.         else {
  433.             // Scroll down
  434.             SendMessage(hwnd, WM_VSCROLL, MAKELONG(SB_PAGEDOWN, 0), 0);
  435.         }
  436.         return 0;
  437.     }
  438.     return DefSubclassProc(hwnd, uMsg, wParam, lParam);
  439. }
  440.  
  441. LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  442.     switch (uMsg) {
  443.     case WM_CREATE: InitializeControls(hwnd); AddMenus(hwnd); return 0;
  444.     case WM_SIZE:
  445.     {
  446.         RECT rcClient;
  447.         GetClientRect(hwnd, &rcClient);
  448.  
  449.         // Resize status bar
  450.         SendMessage(g_hStatusBar, WM_SIZE, 0, 0);
  451.  
  452.         // Recalculate status bar parts
  453.         int statusParts[2] = { 150, rcClient.right };
  454.         SendMessage(g_hStatusBar, SB_SETPARTS, 2, (LPARAM)statusParts);
  455.  
  456.         // Reposition progress bar
  457.         RECT rcPart;
  458.         SendMessage(g_hStatusBar, SB_GETRECT, 1, (LPARAM)&rcPart);
  459.         SetWindowPos(g_hProgressBar, NULL,
  460.             rcPart.left + 5, rcPart.top + 2,
  461.             rcPart.right - rcPart.left - 10, rcPart.bottom - rcPart.top - 4,
  462.             SWP_NOZORDER);
  463.  
  464.         // Get status bar height
  465.         RECT rcStatus;
  466.         GetWindowRect(g_hStatusBar, &rcStatus);
  467.         int statusHeight = rcStatus.bottom - rcStatus.top;
  468.  
  469.         // Resize edit control
  470.         SetWindowPos(g_hEditControl, NULL,
  471.             EDIT_MARGIN,
  472.             EDIT_MARGIN,
  473.             rcClient.right - (2 * EDIT_MARGIN),
  474.             rcClient.bottom - statusHeight - (2 * EDIT_MARGIN),
  475.             SWP_NOZORDER);
  476.         return 0;
  477.     }
  478.     /*case WM_KEYDOWN:
  479.     {
  480.         // Check if Ctrl is pressed
  481.         if (GetKeyState(VK_CONTROL) & 0x8000) {
  482.             switch (wParam) {
  483.             case 'O':  // Ctrl+O
  484.                 OpenFileDialog(hwnd);
  485.                 return 0;
  486.             }
  487.         }
  488.  
  489.         // Handle Page Up/Page Down
  490.         switch (wParam) {
  491.         case VK_PRIOR:  // Page Up
  492.             ScrollWindow(hwnd, 0, -virtualHeight, NULL, NULL);
  493.             UpdateWindow(hwnd);
  494.             return 0;
  495.         case VK_NEXT:  // Page Down
  496.             ScrollWindow(hwnd, 0, virtualHeight, NULL, NULL);
  497.             UpdateWindow(hwnd);
  498.             return 0;
  499.         case VK_F1:
  500.             MessageBoxW(hwnd,
  501.                 L"PE Header Parser 2.9 GUI-based Programmed in C++ Win32 API (1369 lines of code) by Entisoft Software(c) Evans Thorpemorton",
  502.                 L"About",
  503.                 MB_OK | MB_ICONINFORMATION);
  504.             return 0;
  505.         case VK_ESCAPE:
  506.             PostQuitMessage(0);
  507.             return 0;
  508.         }
  509.     }
  510.     break;
  511.  
  512.     case WM_MOUSEWHEEL:
  513.     {
  514.         int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
  515.         if (zDelta > 0) {
  516.             ScrollWindow(hwnd, 0, -virtualHeight, NULL, NULL);  // Mouse Wheel Up
  517.         }
  518.         else if (zDelta < 0) {
  519.             ScrollWindow(hwnd, 0, virtualHeight, NULL, NULL);  // Mouse Wheel Down
  520.         }
  521.         UpdateWindow(hwnd);
  522.         return 0;
  523.     }*/
  524.  
  525.     case WM_KEYDOWN:
  526.     {
  527.         if (GetKeyState(VK_CONTROL) & 0x8000) {
  528.             switch (wParam) {
  529.             case 'O':
  530.                 OpenFileDialog(hwnd);
  531.                 return 0;
  532.             }
  533.         }
  534.         switch (wParam) {
  535.         case VK_F1:
  536.             MessageBoxW(hwnd,
  537.                 L"PE Header Parser 4.3 GUI-based Programmed in C++ Win32 API (1546 lines of code) by Entisoft Software(c) Evans Thorpemorton",
  538.                 L"About",
  539.                 MB_OK | MB_ICONINFORMATION);
  540.             return 0;
  541.         case VK_ESCAPE:
  542.             PostQuitMessage(0);
  543.             return 0;
  544.         case VK_PRIOR:
  545.             // Scroll up
  546.             SendMessage(g_hEditControl, WM_VSCROLL, MAKELONG(SB_PAGEUP, 0), 0);
  547.             return 0;
  548.         case VK_NEXT:
  549.             // Scroll down
  550.             SendMessage(g_hEditControl, WM_VSCROLL, MAKELONG(SB_PAGEDOWN, 0), 0);
  551.             return 0;
  552.         case VK_UP:
  553.             // Scroll one line up
  554.             SendMessage(g_hEditControl, WM_VSCROLL, MAKELONG(SB_LINEUP, 0), 0);
  555.             return 0;
  556.         case VK_DOWN:
  557.             // Scroll one line down
  558.             SendMessage(g_hEditControl, WM_VSCROLL, MAKELONG(SB_LINEDOWN, 0), 0);
  559.             return 0;
  560.         }
  561.         break;
  562.     }
  563.     case WM_MOUSEWHEEL:
  564.     {
  565.         int delta = GET_WHEEL_DELTA_WPARAM(wParam);
  566.         if (delta > 0) {
  567.             // Scroll up
  568.             SendMessage(g_hEditControl, WM_VSCROLL, MAKELONG(SB_PAGEUP, 0), 0);
  569.         }
  570.         else {
  571.             // Scroll down
  572.             SendMessage(g_hEditControl, WM_VSCROLL, MAKELONG(SB_PAGEDOWN, 0), 0);
  573.         }
  574.         return 0;
  575.     }
  576.     case WM_COMMAND: if (LOWORD(wParam) == 1) OpenFileDialog(hwnd); if (LOWORD(wParam) == 2) PostQuitMessage(0); return 0;
  577.     case WM_DESTROY:
  578.         if (g_hStatusBar) DestroyWindow(g_hStatusBar);
  579.         PostQuitMessage(0);
  580.         return 0;
  581.     }
  582.     return DefWindowProc(hwnd, uMsg, wParam, lParam);
  583. }
  584.  
  585. void SetStatusText(const wchar_t* text) {
  586.     SendMessage(g_hStatusBar, SB_SETTEXT, 0, (LPARAM)text);
  587. }
  588.  
  589. void ShowProgress(int percentage) {
  590.     // Update progress bar
  591.     SendMessage(g_hProgressBar, PBM_SETPOS, (WPARAM)percentage, 0);
  592.  
  593.     // Update status text in first part
  594.     wchar_t status[256];
  595.     swprintf_s(status, L"Analyzing... %d%%", percentage);
  596.     //swprintf_s(status, L"Analyzing...");
  597.     SetStatusText(status); //commented-out
  598.     SendMessage(g_hStatusBar, SB_SETTEXT, 0, (LPARAM)status);
  599. }
  600.  
  601. void OpenFileDialog(HWND hwnd) {
  602.     WCHAR fileName[MAX_PATH] = L"";
  603.     OPENFILENAMEW ofn = { sizeof(OPENFILENAMEW), hwnd, NULL, L"Executable Files (*.exe;*.dll)\0*.exe;*.dll\0All Files (*.*)\0*.*\0", NULL, 0, 1, fileName, MAX_PATH, NULL, 0, NULL, NULL, OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY, 0, 0, L"exe", NULL, NULL, NULL };
  604.     if (GetOpenFileNameW(&ofn)) {
  605.         SetWindowTextW(g_hEditControl, L"");
  606.         g_OutputText.str(L"");
  607.         g_OutputText.clear();
  608.         AnalyzePEFile(ofn.lpstrFile);
  609.         UpdateEditControl();
  610.     }
  611. }
  612.  
  613. class FileMapper {
  614. private:
  615.     HANDLE hFile = INVALID_HANDLE_VALUE;
  616.     HANDLE hMapping = nullptr;
  617.     LPVOID lpView = nullptr;
  618.  
  619. public:
  620.     ~FileMapper() {
  621.         if (lpView) UnmapViewOfFile(lpView);
  622.         if (hMapping) CloseHandle(hMapping);
  623.         if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
  624.     }
  625.  
  626.     bool Initialize(const wchar_t* path) {
  627.         hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, nullptr,
  628.             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
  629.         if (hFile == INVALID_HANDLE_VALUE) return false;
  630.  
  631.         hMapping = CreateFileMappingW(hFile, nullptr, PAGE_READONLY, 0, 0, nullptr);
  632.         if (!hMapping) return false;
  633.  
  634.         lpView = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
  635.         return lpView != nullptr;
  636.     }
  637.  
  638.     LPVOID GetView() const { return lpView; }
  639. };
  640.  
  641. // Modified AppendToOutput to handle newlines properly:
  642. void AppendToOutput(const wchar_t* format, ...) {
  643.     std::vector<wchar_t> buffer(1024);
  644.     va_list args;
  645.     va_start(args, format);
  646.  
  647.     while (true) {
  648.         int result = _vsnwprintf(buffer.data(), buffer.size(), format, args);
  649.         if (result >= 0) break;
  650.         buffer.resize(buffer.size() * 2);
  651.     }
  652.     va_end(args);
  653.  
  654.     // Convert \n to \r\n
  655.     std::wstring output = buffer.data();
  656.     size_t pos = 0;
  657.     while ((pos = output.find(L'\n', pos)) != std::wstring::npos) {
  658.         if (pos == 0 || output[pos - 1] != L'\r') {
  659.             output.insert(pos, L"\r");
  660.             pos += 2;
  661.         }
  662.         else {
  663.             pos++;
  664.         }
  665.     }
  666.  
  667.     g_OutputText << output;
  668.     UpdateEditControl();
  669. }
  670.  
  671. /*
  672. void AppendToOutput(const wchar_t* format, ...) {
  673.     wchar_t buffer[16384]; // Ensure sufficient buffer size
  674.     va_list args;
  675.     va_start(args, format);
  676.     StringCchVPrintfW(buffer, ARRAYSIZE(buffer), format, args);
  677.     va_end(args);
  678.  
  679.     tempBuffer += buffer;
  680.  
  681.     // Update Edit Control periodically to improve performance
  682.     if (tempBuffer.size() > 8000) {
  683.         g_OutputText << tempBuffer;
  684.         tempBuffer.clear();
  685.  
  686.         SetWindowTextW(g_hEditControl, g_OutputText.str().c_str());
  687.         SendMessage(g_hEditControl, EM_SETSEL, -1, -1);
  688.         SendMessage(g_hEditControl, EM_SCROLLCARET, 0, 0);
  689.     }
  690. }
  691.  
  692.  
  693. // Final update to flush any remaining content
  694. void FlushOutput() {
  695.     if (!tempBuffer.empty()) {
  696.         g_OutputText << tempBuffer;
  697.         tempBuffer.clear();
  698.  
  699.         SetWindowTextW(g_hEditControl, g_OutputText.str().c_str());
  700.         SendMessage(g_hEditControl, EM_SETSEL, -1, -1);
  701.         SendMessage(g_hEditControl, EM_SCROLLCARET, 0, 0);
  702.     }
  703. }
  704. */
  705.  
  706.  
  707. /*
  708. //use below ^^ ALWAYS
  709. void AppendToOutput(const wchar_t* format, ...) {
  710.     va_list args;
  711.     va_start(args, format);
  712.  
  713.     // Use a vector as a dynamically resizable buffer
  714.     std::vector<wchar_t> buffer(16384); // Start with an initial size
  715.     int result = -1;
  716.  
  717.     while (true) {
  718.         // Attempt to format the string
  719.         result = _vsnwprintf(buffer.data(), buffer.size(), format, args);
  720.  
  721.         if (result >= 0 && static_cast<size_t>(result) < buffer.size()) {
  722.             // Successfully formatted within the current buffer size
  723.             break;
  724.         }
  725.  
  726.         // Resize the buffer and try again
  727.         buffer.resize(buffer.size() * 2);
  728.     }
  729.     va_end(args);
  730.  
  731.     // Convert `\n` to `\r\n` for proper display in the EditBox
  732.     std::wstring formattedOutput(buffer.data());
  733.     size_t pos = 0;
  734.     while ((pos = formattedOutput.find(L'\n', pos)) != std::wstring::npos) {
  735.         formattedOutput.replace(pos, 1, L"\r\n");
  736.         pos += 2; // Move past the replacement
  737.     }
  738.  
  739.     // Append to the global output buffer
  740.     g_OutputText << formattedOutput;
  741.  
  742.     // Update the EditBox periodically to prevent overloading
  743.     if (g_OutputText.str().size() > 8000) {
  744.         SetWindowTextW(g_hEditControl, g_OutputText.str().c_str());
  745.         SendMessage(g_hEditControl, EM_SETSEL, -1, -1);
  746.         SendMessage(g_hEditControl, EM_SCROLLCARET, 0, 0);
  747.     }
  748. }
  749. //use above ^^ ALWAYS
  750. */
  751.  
  752. //currentlatest
  753. /*void AppendToOutput(const wchar_t* format, ...) {
  754.     wchar_t buffer[4096];
  755.     va_list args;
  756.     va_start(args, format);
  757.     StringCchVPrintfW(buffer, ARRAYSIZE(buffer), format, args);
  758.     va_end(args);
  759.     g_OutputText << buffer;
  760.     SetWindowTextW(g_hEditControl, g_OutputText.str().c_str());
  761.     SendMessage(g_hEditControl, EM_SETSEL, -1, -1);
  762.     SendMessage(g_hEditControl, EM_SCROLLCARET, 0, 0);
  763. }
  764. */
  765.  
  766. //use-below-basic-failsafe-working vv
  767. //basic test function
  768. /*void AnalyzePEFile(const wchar_t* filePathW) {
  769.     OUTPUT("[+] Analyzing file: %s\n", filePathW);
  770.     LPVOID lpFileContent = GetFileContent(filePathW);
  771.     if (!lpFileContent) { OUTPUT("[-] Could not read file.\n"); return; }
  772.     PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)lpFileContent;
  773.     if (dosHeader->e_magic != IMAGE_DOS_SIGNATURE) { OUTPUT("[-] Invalid DOS signature.\n"); HeapFree(GetProcessHeap(), 0, lpFileContent); return; }
  774.     PIMAGE_NT_HEADERS ntHeaders = (PIMAGE_NT_HEADERS)((DWORD_PTR)lpFileContent + dosHeader->e_lfanew);
  775.     if (ntHeaders->Signature != IMAGE_NT_SIGNATURE) { OUTPUT("[-] Invalid NT signature.\n"); HeapFree(GetProcessHeap(), 0, lpFileContent); return; }
  776.     OUTPUT("[+] PE file analyzed successfully.\n");
  777.     HeapFree(GetProcessHeap(), 0, lpFileContent);
  778.     UpdateEditControl();
  779. }*/
  780. //use-above-basic-failsafe-working vv
  781.  
  782. //use vectors for unlimited size growth of buffer, use an alternative to editbox, check for fast loops overloading, in its primitive form it works properly! try w/o getimports3264 datadirectories getsections
  783.  
  784. void ProcessResourceDirectory(
  785.     PIMAGE_RESOURCE_DIRECTORY resDir,
  786.     int level,
  787.     const wchar_t* type,
  788.     PIMAGE_RESOURCE_DIRECTORY pResourceDir,
  789.     const wchar_t* resourceTypes[],
  790.     PIMAGE_NT_HEADERS pNtHeaders,
  791.     LPVOID lpFileContent)
  792. {
  793.     if (IsBadReadPtr(resDir, sizeof(IMAGE_RESOURCE_DIRECTORY))) {
  794.         return;
  795.     }
  796.  
  797.     auto entry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resDir + 1);
  798.     WORD totalEntries = resDir->NumberOfNamedEntries + resDir->NumberOfIdEntries;
  799.  
  800.     for (WORD i = 0; i < totalEntries; i++) {
  801.         if (IsBadReadPtr(entry + i, sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))) {
  802.             break;
  803.         }
  804.  
  805.         for (int indent = 0; indent < level; indent++) {
  806.             OUTPUT("\t");
  807.         }
  808.  
  809.         if (entry[i].NameIsString) {
  810.             auto nameEntry = (PIMAGE_RESOURCE_DIR_STRING_U)((BYTE*)pResourceDir + entry[i].NameOffset);
  811.             if (!IsBadReadPtr(nameEntry, sizeof(IMAGE_RESOURCE_DIR_STRING_U))) {
  812.                 std::vector<wchar_t> resourceName(nameEntry->Length + 1);
  813.                 wcsncpy_s(resourceName.data(), nameEntry->Length + 1,
  814.                     nameEntry->NameString, nameEntry->Length);
  815.                 resourceName[nameEntry->Length] = L'\0';
  816.  
  817.                 if (level == 0) {
  818.                     OUTPUT("Resource Type: Custom (%s)\n", resourceName.data());
  819.                 }
  820.                 else {
  821.                     OUTPUT("Name: %s\n", resourceName.data());
  822.                 }
  823.             }
  824.         }
  825.         else {
  826.             if (level == 0) {
  827.                 DWORD resourceType = entry[i].Id;
  828.                 if (resourceType < 16) {
  829.                     OUTPUT("Resource Type: %s (ID: %d)\n", resourceTypes[resourceType], resourceType);
  830.                 }
  831.                 else {
  832.                     OUTPUT("Resource Type: Custom (ID: %d)\n", resourceType);
  833.                 }
  834.             }
  835.             else {
  836.                 OUTPUT("ID: %d\n", entry[i].Id);
  837.             }
  838.         }
  839.  
  840.         if (entry[i].DataIsDirectory) {
  841.             auto nextDir = (PIMAGE_RESOURCE_DIRECTORY)((BYTE*)pResourceDir + entry[i].OffsetToDirectory);
  842.             if (!IsBadReadPtr(nextDir, sizeof(IMAGE_RESOURCE_DIRECTORY))) {
  843.                 ProcessResourceDirectory(nextDir, level + 1,
  844.                     level == 0 ? resourceTypes[min(entry[i].Id, 15)] : type,
  845.                     pResourceDir, resourceTypes, pNtHeaders, lpFileContent);
  846.             }
  847.         }
  848.         else {
  849.             auto dataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)((BYTE*)pResourceDir + entry[i].OffsetToData);
  850.             if (!IsBadReadPtr(dataEntry, sizeof(IMAGE_RESOURCE_DATA_ENTRY))) {
  851.                 for (int indent = 0; indent < level + 1; indent++) {
  852.                     OUTPUT("\t");
  853.                 }
  854.                 OUTPUT("Size: %d bytes, RVA: 0x%X\n",
  855.                     dataEntry->Size, dataEntry->OffsetToData);
  856.  
  857.                 if (type && wcscmp(type, L"Version") == 0) {
  858.                     auto versionData = (BYTE*)PEHelpers::GetRvaPtr(
  859.                         dataEntry->OffsetToData,
  860.                         IMAGE_FIRST_SECTION(pNtHeaders),
  861.                         pNtHeaders->FileHeader.NumberOfSections,
  862.                         lpFileContent);
  863.  
  864.                     if (versionData && !IsBadReadPtr(versionData, sizeof(VS_FIXEDFILEINFO))) {
  865.                         auto versionInfo = (VS_FIXEDFILEINFO*)(versionData + 40);
  866.                         if (versionInfo->dwSignature == 0xFEEF04BD) {
  867.                             for (int indent = 0; indent < level + 2; indent++) {
  868.                                 OUTPUT("\t");
  869.                             }
  870.                             OUTPUT("File Version: %d.%d.%d.%d\n",
  871.                                 HIWORD(versionInfo->dwFileVersionMS),
  872.                                 LOWORD(versionInfo->dwFileVersionMS),
  873.                                 HIWORD(versionInfo->dwFileVersionLS),
  874.                                 LOWORD(versionInfo->dwFileVersionLS));
  875.                         }
  876.                     }
  877.                 }
  878.             }
  879.         }
  880.     }
  881. }
  882.  
  883. void AnalyzePEFile(const wchar_t* filePathW) {
  884.     OUTPUT("[+] Starting PE Analysis for: %s\n\n", filePathW);
  885.  
  886.     // Initialize all variables at the start
  887.     HANDLE hFile = INVALID_HANDLE_VALUE;
  888.     HANDLE hFileMapping = nullptr;
  889.     LPVOID lpFileContent = nullptr;
  890.  
  891.     FileMapper mapper;
  892.     if (!mapper.Initialize(filePathW)) {
  893.         SetStatusText(L"Failed to open file!");
  894.         OUTPUT("[-] Failed to open file! Error: %d\r\n", GetLastError());
  895.         return;
  896.     }
  897.  
  898.     ShowProgress(20);
  899.  
  900.     hFile = CreateFileW(filePathW, GENERIC_READ, FILE_SHARE_READ, nullptr,
  901.         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
  902.     if (hFile == INVALID_HANDLE_VALUE) {
  903.         OUTPUT("[-] Failed to open file! Error: %d\n", GetLastError());
  904.         return;
  905.     }
  906.  
  907.     DWORD fileSize = GetFileSize(hFile, nullptr);
  908.     if (fileSize == INVALID_FILE_SIZE) {
  909.         CloseHandle(hFile);
  910.         OUTPUT("[-] Failed to get file size! Error: %d\n", GetLastError());
  911.         return;
  912.     }
  913.  
  914.     hFileMapping = CreateFileMappingW(hFile, nullptr, PAGE_READONLY, 0, 0, nullptr);
  915.     if (!hFileMapping) {
  916.         CloseHandle(hFile);
  917.         OUTPUT("[-] Failed to create file mapping! Error: %d\n", GetLastError());
  918.         return;
  919.     }
  920.  
  921.     lpFileContent = MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0);
  922.     if (!lpFileContent) {
  923.         CloseHandle(hFileMapping);
  924.         CloseHandle(hFile);
  925.         OUTPUT("[-] Failed to map view of file! Error: %d\n", GetLastError());
  926.         return;
  927.     }
  928.  
  929.     // Declare pNtHeaders here, outside the do-while loop.
  930.     PIMAGE_NT_HEADERS pNtHeaders = nullptr; // Initialize to nullptr
  931.  
  932.     do {
  933.         const auto pImageDosHeader = static_cast<PIMAGE_DOS_HEADER>(mapper.GetView());
  934.         if (pImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE) {
  935.             OUTPUT("[-] Invalid DOS signature!\r\n");
  936.             break;
  937.         }
  938.         ShowProgress(30);
  939.         pNtHeaders = reinterpret_cast<PIMAGE_NT_HEADERS>( // Assign pNtHeaders here
  940.             static_cast<BYTE*>(mapper.GetView()) + pImageDosHeader->e_lfanew);
  941.         if (IsBadReadPtr(pNtHeaders, sizeof(IMAGE_NT_HEADERS)) ||
  942.             pNtHeaders->Signature != IMAGE_NT_SIGNATURE) {
  943.             OUTPUT("[-] Invalid NT signature!\r\n");
  944.             break;
  945.         }
  946.         bool is64Bit = PEHelpers::Is64BitPE(pNtHeaders);
  947.         PIMAGE_NT_HEADERS32 pNtHeaders32 = nullptr;
  948.         PIMAGE_NT_HEADERS64 pNtHeaders64 = nullptr;
  949.         if (is64Bit) {
  950.             auto pNtHeaders64 = reinterpret_cast<PIMAGE_NT_HEADERS64>(pNtHeaders);
  951.         }
  952.         else {
  953.             auto pNtHeaders32 = reinterpret_cast<PIMAGE_NT_HEADERS32>(pNtHeaders);
  954.         }
  955.         DWORD_PTR imageBase = PEHelpers::GetImageBase(pNtHeaders);
  956.         DWORD sizeOfImage = PEHelpers::GetSizeOfImage(pNtHeaders);
  957.         if (pNtHeaders->FileHeader.NumberOfSections > 96) {
  958.             OUTPUT("[-] Suspicious number of sections detected!\n");
  959.             break;
  960.         }
  961.         //Move this check here after pNtHeaders is defined
  962.         if (!PEHelpers::ValidateFileSize(pNtHeaders->OptionalHeader.SizeOfHeaders, fileSize)) {
  963.             OUTPUT("[-] Invalid image size detected!\n");
  964.             return;
  965.         }
  966.  
  967.         OUTPUT("[+] PE IMAGE INFORMATION\n\n");
  968.         OUTPUT("[+] Architecture: %s\n\n", is64Bit ? "x64" : "x86");
  969.         OUTPUT("[+] DOS HEADER\n");
  970.         OUTPUT("\te_magic    : 0x%X\n", pImageDosHeader->e_magic);
  971.         OUTPUT("\te_cblp     : 0x%X\n", pImageDosHeader->e_cblp);
  972.         OUTPUT("\te_cp       : 0x%X\n", pImageDosHeader->e_cp);
  973.         OUTPUT("\te_crlc     : 0x%X\n", pImageDosHeader->e_crlc);
  974.         OUTPUT("\te_cparhdr  : 0x%X\n", pImageDosHeader->e_cparhdr);
  975.         OUTPUT("\te_minalloc : 0x%X\n", pImageDosHeader->e_minalloc);
  976.         OUTPUT("\te_maxalloc : 0x%X\n", pImageDosHeader->e_maxalloc);
  977.         OUTPUT("\te_ss       : 0x%X\n", pImageDosHeader->e_ss);
  978.         OUTPUT("\te_sp       : 0x%X\n", pImageDosHeader->e_sp);
  979.         OUTPUT("\te_csum     : 0x%X\n", pImageDosHeader->e_csum);
  980.         OUTPUT("\te_ip       : 0x%X\n", pImageDosHeader->e_ip);
  981.         OUTPUT("\te_cs       : 0x%X\n", pImageDosHeader->e_cs);
  982.         OUTPUT("\te_lfarlc   : 0x%X\n", pImageDosHeader->e_lfarlc);
  983.         OUTPUT("\te_ovno     : 0x%X\n", pImageDosHeader->e_ovno);
  984.         OUTPUT("\te_oemid    : 0x%X\n", pImageDosHeader->e_oemid);
  985.         OUTPUT("\te_oeminfo  : 0x%X\n", pImageDosHeader->e_oeminfo);
  986.         OUTPUT("\te_lfanew   : 0x%X\n\n", pImageDosHeader->e_lfanew);
  987.         OUTPUT("[+] NT HEADER\n");
  988.         OUTPUT("\tSignature  : 0x%X\n\n", pNtHeaders->Signature);
  989.  
  990.         ShowProgress(40);
  991.  
  992.         OUTPUT("[+] FILE HEADER\n");
  993.         OUTPUT("\tMachine: 0x%X\n", pNtHeaders->FileHeader.Machine);
  994.         OUTPUT("\tNumberOfSections: 0x%X\n", pNtHeaders->FileHeader.NumberOfSections);
  995.         OUTPUT("\tTimeDateStamp: 0x%X\n", pNtHeaders->FileHeader.TimeDateStamp);
  996.         OUTPUT("\tPointerToSymbolTable: 0x%X\n", pNtHeaders->FileHeader.PointerToSymbolTable);
  997.         OUTPUT("\tNumberOfSymbols: 0x%X\n", pNtHeaders->FileHeader.NumberOfSymbols);
  998.         OUTPUT("\tSizeOfOptionalHeader: 0x%X\n", pNtHeaders->FileHeader.SizeOfOptionalHeader);
  999.         OUTPUT("\tCharacteristics: 0x%X %s\n\n",
  1000.             pNtHeaders->FileHeader.Characteristics,
  1001.             PEHelpers::GetImageCharacteristics(pNtHeaders->FileHeader.Characteristics).c_str());
  1002.  
  1003.         ShowProgress(50);
  1004.  
  1005.         OUTPUT("[+] OPTIONAL HEADER\n");
  1006.         OUTPUT("\tMagic: 0x%X\n", pNtHeaders->OptionalHeader.Magic);
  1007.         OUTPUT("\tAddressOfEntryPoint: 0x%X\n", pNtHeaders->OptionalHeader.AddressOfEntryPoint);
  1008.         OUTPUT("\tImageBase: 0x%p\n", (void*)imageBase);
  1009.         OUTPUT("\tSectionAlignment: 0x%X\n", pNtHeaders->OptionalHeader.SectionAlignment);
  1010.         OUTPUT("\tFileAlignment: 0x%X\n", pNtHeaders->OptionalHeader.FileAlignment);
  1011.         OUTPUT("\tMajorOperatingSystemVersion: 0x%X\n", pNtHeaders->OptionalHeader.MajorOperatingSystemVersion);
  1012.         OUTPUT("\tMinorOperatingSystemVersion: 0x%X\n", pNtHeaders->OptionalHeader.MinorOperatingSystemVersion);
  1013.         OUTPUT("\tMajorImageVersion: 0x%X\n", pNtHeaders->OptionalHeader.MajorImageVersion);
  1014.         OUTPUT("\tMinorImageVersion: 0x%X\n", pNtHeaders->OptionalHeader.MinorImageVersion);
  1015.         OUTPUT("\tMajorSubsystemVersion: 0x%X\n", pNtHeaders->OptionalHeader.MajorSubsystemVersion);
  1016.         OUTPUT("\tMinorSubsystemVersion: 0x%X\n", pNtHeaders->OptionalHeader.MinorSubsystemVersion);
  1017.         OUTPUT("\tWin32VersionValue: 0x%X\n", pNtHeaders->OptionalHeader.Win32VersionValue);
  1018.         OUTPUT("\tSizeOfImage: 0x%X\n", sizeOfImage);
  1019.         OUTPUT("\tSizeOfHeaders: 0x%X\n", pNtHeaders->OptionalHeader.SizeOfHeaders);
  1020.         OUTPUT("\tCheckSum: 0x%X\n", pNtHeaders->OptionalHeader.CheckSum);
  1021.         OUTPUT("\tSubsystem: 0x%X %s\n",
  1022.             pNtHeaders->OptionalHeader.Subsystem,
  1023.             PEHelpers::GetSubsystem(pNtHeaders->OptionalHeader.Subsystem).c_str());
  1024.  
  1025.         OUTPUT("\n[+] DATA DIRECTORIES\n");
  1026.         for (int i = 0; i < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; i++) {
  1027.             const auto& dir = pNtHeaders->OptionalHeader.DataDirectory[i];
  1028.             if (dir.VirtualAddress != 0) {
  1029.                 if (!PEHelpers::IsRvaValid(dir.VirtualAddress, fileSize, pNtHeaders)) {
  1030.                     OUTPUT("\t%s: Invalid RVA detected!\n", PEHelpers::GetDataDirectoryName(i).c_str());
  1031.                     continue;
  1032.                 }
  1033.                 OUTPUT("\t%s:\n", PEHelpers::GetDataDirectoryName(i).c_str());
  1034.                 OUTPUT("\t\tVirtualAddress: 0x%X\n", dir.VirtualAddress);
  1035.                 OUTPUT("\t\tSize: 0x%X\n", dir.Size);
  1036.             }
  1037.         }
  1038.  
  1039.         ShowProgress(60);
  1040.         OUTPUT("\n[+] SECTION HEADERS\n");
  1041.         auto pSection = IMAGE_FIRST_SECTION(pNtHeaders);
  1042.         for (WORD i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++, pSection++) {
  1043.             if (IsBadReadPtr(pSection, sizeof(IMAGE_SECTION_HEADER))) {
  1044.                 OUTPUT("[-] Invalid section header detected!\n");
  1045.                 break;
  1046.             }
  1047.             char sectionName[IMAGE_SIZEOF_SHORT_NAME + 1] = {};
  1048.             memcpy(sectionName, pSection->Name, IMAGE_SIZEOF_SHORT_NAME);
  1049.             for (int j = 0; j < IMAGE_SIZEOF_SHORT_NAME; j++) {
  1050.                 if (!isprint(static_cast<unsigned char>(sectionName[j]))) {
  1051.                     sectionName[j] = '\0';
  1052.                 }
  1053.             }
  1054.             wchar_t wideSectionName[IMAGE_SIZEOF_SHORT_NAME + 1] = {};
  1055.             MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
  1056.                 sectionName, -1,
  1057.                 wideSectionName, IMAGE_SIZEOF_SHORT_NAME + 1);
  1058.             OUTPUT("\tSECTION: %s\n", wideSectionName);
  1059.             OUTPUT("\t\tVirtualSize: 0x%X\n", pSection->Misc.VirtualSize);
  1060.             OUTPUT("\t\tVirtualAddress: 0x%X\n", pSection->VirtualAddress);
  1061.             OUTPUT("\t\tSizeOfRawData: 0x%X\n", pSection->SizeOfRawData);
  1062.             OUTPUT("\t\tPointerToRawData: 0x%X\n", pSection->PointerToRawData);
  1063.             OUTPUT("\t\tPointerToRelocations: 0x%X\n", pSection->PointerToRelocations);
  1064.             OUTPUT("\t\tPointerToLinenumbers: 0x%X\n", pSection->PointerToLinenumbers);
  1065.             OUTPUT("\t\tNumberOfRelocations: 0x%X\n", pSection->NumberOfRelocations);
  1066.             OUTPUT("\t\tNumberOfLinenumbers: 0x%X\n", pSection->NumberOfLinenumbers);
  1067.             OUTPUT("\t\tCharacteristics: 0x%X %s\n\n",
  1068.                 pSection->Characteristics,
  1069.                 PEHelpers::GetSectionProtection(pSection->Characteristics).c_str());
  1070.         }
  1071.  
  1072.         ShowProgress(70);
  1073.  
  1074.         const auto& importDir = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
  1075.         if (importDir.VirtualAddress && importDir.Size) {
  1076.             if (!PEHelpers::IsRvaValid(importDir.VirtualAddress, fileSize, pNtHeaders)) {
  1077.                 OUTPUT("[-] Invalid import directory RVA!\n");
  1078.                 break;
  1079.             }
  1080.             OUTPUT("\n[+] IMPORT DIRECTORY\n");
  1081.             auto pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)PEHelpers::GetRvaPtr(
  1082.                 importDir.VirtualAddress,
  1083.                 IMAGE_FIRST_SECTION(pNtHeaders),
  1084.                 pNtHeaders->FileHeader.NumberOfSections,
  1085.                 lpFileContent);
  1086.             if (pImportDesc) {
  1087.                 while (pImportDesc->Name != 0) {
  1088.                     if (IsBadReadPtr(pImportDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR))) {
  1089.                         OUTPUT("[-] Invalid import descriptor detected!\n");
  1090.                         break;
  1091.                     }
  1092.                     const char* dllName = (const char*)PEHelpers::GetRvaPtr(
  1093.                         pImportDesc->Name,
  1094.                         IMAGE_FIRST_SECTION(pNtHeaders),
  1095.                         pNtHeaders->FileHeader.NumberOfSections,
  1096.                         lpFileContent);
  1097.                     if (dllName && !IsBadReadPtr(dllName, 1)) {
  1098.                         std::vector<wchar_t> wideDllName(MAX_PATH);
  1099.                         MultiByteToWideChar(CP_ACP, 0, dllName, -1, wideDllName.data(), MAX_PATH);
  1100.                         OUTPUT("\n\tDLL NAME: %s\n", wideDllName.data());
  1101.                         OUTPUT("\tCharacteristics: 0x%X\n", pImportDesc->Characteristics);
  1102.                         OUTPUT("\tTimeDateStamp: 0x%X\n", pImportDesc->TimeDateStamp);
  1103.                         OUTPUT("\tForwarderChain: 0x%X\n", pImportDesc->ForwarderChain);
  1104.                         OUTPUT("\tFirstThunk: 0x%X\n", pImportDesc->FirstThunk);
  1105.                         OUTPUT("\n\tImported Functions:\n");
  1106.  
  1107.                         if (is64Bit) {
  1108.                             auto pThunk = (PIMAGE_THUNK_DATA64)PEHelpers::GetRvaPtr(
  1109.                                 pImportDesc->OriginalFirstThunk ? pImportDesc->OriginalFirstThunk : pImportDesc->FirstThunk,
  1110.                                 IMAGE_FIRST_SECTION(pNtHeaders),
  1111.                                 pNtHeaders->FileHeader.NumberOfSections,
  1112.                                 lpFileContent);
  1113.                             while (pThunk && pThunk->u1.AddressOfData) {
  1114.                                 if (!(pThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG64)) {
  1115.                                     auto pImportByName = (PIMAGE_IMPORT_BY_NAME)PEHelpers::GetRvaPtr(
  1116.                                         (DWORD)pThunk->u1.AddressOfData,
  1117.                                         IMAGE_FIRST_SECTION(pNtHeaders),
  1118.                                         pNtHeaders->FileHeader.NumberOfSections,
  1119.                                         lpFileContent);
  1120.                                     if (pImportByName && !IsBadReadPtr(pImportByName, sizeof(IMAGE_IMPORT_BY_NAME))) {
  1121.                                         std::vector<wchar_t> wideFuncName(MAX_PATH);
  1122.                                         MultiByteToWideChar(CP_ACP, 0, (char*)pImportByName->Name, -1,
  1123.                                             wideFuncName.data(), MAX_PATH);
  1124.                                         OUTPUT("\t\t%s\n", wideFuncName.data());
  1125.                                     }
  1126.                                 }
  1127.                                 else {
  1128.                                     OUTPUT("\t\tOrdinal: %lld\n", pThunk->u1.Ordinal & 0xFFFF);
  1129.                                 }
  1130.                                 pThunk++;
  1131.                             }
  1132.                         }
  1133.                         else {
  1134.                             auto pThunk = (PIMAGE_THUNK_DATA32)PEHelpers::GetRvaPtr(
  1135.                                 pImportDesc->OriginalFirstThunk ? pImportDesc->OriginalFirstThunk : pImportDesc->FirstThunk,
  1136.                                 IMAGE_FIRST_SECTION(pNtHeaders),
  1137.                                 pNtHeaders->FileHeader.NumberOfSections,
  1138.                                 lpFileContent);
  1139.                             while (pThunk && pThunk->u1.AddressOfData) {
  1140.                                 if (!(pThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG32)) {
  1141.                                     auto pImportByName = (PIMAGE_IMPORT_BY_NAME)PEHelpers::GetRvaPtr(
  1142.                                         pThunk->u1.AddressOfData,
  1143.                                         IMAGE_FIRST_SECTION(pNtHeaders),
  1144.                                         pNtHeaders->FileHeader.NumberOfSections,
  1145.                                         lpFileContent);
  1146.                                     if (pImportByName && !IsBadReadPtr(pImportByName, sizeof(IMAGE_IMPORT_BY_NAME))) {
  1147.                                         std::vector<wchar_t> wideFuncName(MAX_PATH);
  1148.                                         MultiByteToWideChar(CP_ACP, 0, (char*)pImportByName->Name, -1,
  1149.                                             wideFuncName.data(), MAX_PATH);
  1150.                                         OUTPUT("\t\t%s\n", wideFuncName.data());
  1151.                                     }
  1152.                                 }
  1153.                                 else {
  1154.                                     OUTPUT("\t\tOrdinal: %d\n", pThunk->u1.Ordinal & 0xFFFF);
  1155.                                 }
  1156.                                 pThunk++;
  1157.                             }
  1158.                         }
  1159.                     }
  1160.                     pImportDesc++;
  1161.                 }
  1162.             }
  1163.         }
  1164.  
  1165.         ShowProgress(80);
  1166.  
  1167.         const auto& exportDir = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
  1168.         if (exportDir.VirtualAddress && exportDir.Size) {
  1169.             if (!PEHelpers::IsRvaValid(exportDir.VirtualAddress, fileSize, pNtHeaders)) {
  1170.                 OUTPUT("[-] Invalid export directory RVA!\n");
  1171.                 break;
  1172.             }
  1173.             OUTPUT("\n[+] EXPORT DIRECTORY\n");
  1174.             auto pExportDir = (PIMAGE_EXPORT_DIRECTORY)PEHelpers::GetRvaPtr(
  1175.                 exportDir.VirtualAddress,
  1176.                 IMAGE_FIRST_SECTION(pNtHeaders),
  1177.                 pNtHeaders->FileHeader.NumberOfSections,
  1178.                 lpFileContent);
  1179.             if (pExportDir && !IsBadReadPtr(pExportDir, sizeof(IMAGE_EXPORT_DIRECTORY))) {
  1180.                 OUTPUT("\tCharacteristics: 0x%X\n", pExportDir->Characteristics);
  1181.                 OUTPUT("\tTimeDateStamp: 0x%X\n", pExportDir->TimeDateStamp);
  1182.                 OUTPUT("\tMajorVersion: %d\n", pExportDir->MajorVersion);
  1183.                 OUTPUT("\tMinorVersion: %d\n", pExportDir->MinorVersion);
  1184.                 OUTPUT("\tName: 0x%X\n", pExportDir->Name);
  1185.                 OUTPUT("\tBase: %d\n", pExportDir->Base);
  1186.                 OUTPUT("\tNumberOfFunctions: %d\n", pExportDir->NumberOfFunctions);
  1187.                 OUTPUT("\tNumberOfNames: %d\n", pExportDir->NumberOfNames);
  1188.                 OUTPUT("\tAddressOfFunctions: 0x%X\n", pExportDir->AddressOfFunctions);
  1189.                 OUTPUT("\tAddressOfNames: 0x%X\n", pExportDir->AddressOfNames);
  1190.                 OUTPUT("\tAddressOfNameOrdinals: 0x%X\n\n", pExportDir->AddressOfNameOrdinals);
  1191.  
  1192.                 auto pFunctions = (PDWORD)PEHelpers::GetRvaPtr(
  1193.                     pExportDir->AddressOfFunctions,
  1194.                     IMAGE_FIRST_SECTION(pNtHeaders),
  1195.                     pNtHeaders->FileHeader.NumberOfSections,
  1196.                     lpFileContent);
  1197.                 auto pNames = (PDWORD)PEHelpers::GetRvaPtr(
  1198.                     pExportDir->AddressOfNames,
  1199.                     IMAGE_FIRST_SECTION(pNtHeaders),
  1200.                     pNtHeaders->FileHeader.NumberOfSections,
  1201.                     lpFileContent);
  1202.                 auto pNameOrdinals = (PWORD)PEHelpers::GetRvaPtr(
  1203.                     pExportDir->AddressOfNameOrdinals,
  1204.                     IMAGE_FIRST_SECTION(pNtHeaders),
  1205.                     pNtHeaders->FileHeader.NumberOfSections,
  1206.                     lpFileContent);
  1207.  
  1208.                 if (pNames && pNameOrdinals && pFunctions) {
  1209.                     OUTPUT("\tExported Functions:\n\n");
  1210.                     for (DWORD i = 0; i < pExportDir->NumberOfNames; i++) {
  1211.                         if (IsBadReadPtr(pNames + i, sizeof(DWORD)) ||
  1212.                             IsBadReadPtr(pNameOrdinals + i, sizeof(WORD))) {
  1213.                             break;
  1214.                         }
  1215.  
  1216.                         const char* functionName = (const char*)PEHelpers::GetRvaPtr(
  1217.                             pNames[i],
  1218.                             IMAGE_FIRST_SECTION(pNtHeaders),
  1219.                             pNtHeaders->FileHeader.NumberOfSections,
  1220.                             lpFileContent);
  1221.  
  1222.                         if (functionName && !IsBadReadPtr(functionName, 1)) {
  1223.                             WORD ordinal = pNameOrdinals[i];
  1224.                             if (ordinal < pExportDir->NumberOfFunctions) {
  1225.                                 DWORD functionRva = pFunctions[ordinal];
  1226.                                 if (functionRva >= exportDir.VirtualAddress &&
  1227.                                     functionRva < (exportDir.VirtualAddress + exportDir.Size)) {
  1228.                                     const char* forwardName = (const char*)PEHelpers::GetRvaPtr(
  1229.                                         functionRva,
  1230.                                         IMAGE_FIRST_SECTION(pNtHeaders),
  1231.                                         pNtHeaders->FileHeader.NumberOfSections,
  1232.                                         lpFileContent);
  1233.                                     if (forwardName && !IsBadReadPtr(forwardName, 1)) {
  1234.                                         std::vector<wchar_t> wideForwardName(MAX_PATH);
  1235.                                         MultiByteToWideChar(CP_ACP, 0, forwardName, -1,
  1236.                                             wideForwardName.data(), MAX_PATH);
  1237.                                         OUTPUT("\t\t%s (Ordinal: %d) -> Forward to: %s\n",
  1238.                                             functionName,
  1239.                                             ordinal + pExportDir->Base,
  1240.                                             wideForwardName.data());
  1241.                                     }
  1242.                                 }
  1243.                                 else {
  1244.                                     OUTPUT("\t\t%s (Ordinal: %d, RVA: 0x%08X)\n",
  1245.                                         functionName,
  1246.                                         ordinal + pExportDir->Base,
  1247.                                         functionRva);
  1248.                                 }
  1249.                             }
  1250.                         }
  1251.                     }
  1252.                 }
  1253.             }
  1254.         }
  1255.  
  1256.         ShowProgress(90);
  1257.  
  1258.         const auto& resourceDir = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
  1259.         if (resourceDir.VirtualAddress && resourceDir.Size) {
  1260.             if (!PEHelpers::IsRvaValid(resourceDir.VirtualAddress, fileSize, pNtHeaders)) {
  1261.                 OUTPUT("[-] Invalid resource directory RVA!\n");
  1262.                 break;
  1263.             }
  1264.             OUTPUT("\n[+] RESOURCE DIRECTORY\n");
  1265.             auto pResourceDir = (PIMAGE_RESOURCE_DIRECTORY)PEHelpers::GetRvaPtr(
  1266.                 resourceDir.VirtualAddress,
  1267.                 IMAGE_FIRST_SECTION(pNtHeaders),
  1268.                 pNtHeaders->FileHeader.NumberOfSections,
  1269.                 lpFileContent);
  1270.             if (pResourceDir && !IsBadReadPtr(pResourceDir, sizeof(IMAGE_RESOURCE_DIRECTORY))) {
  1271.                 const wchar_t* resourceTypes[] = {
  1272.                     L"Unknown",     L"Cursor",      L"Bitmap",      L"Icon",
  1273.                     L"Menu",        L"Dialog",      L"String",      L"FontDir",
  1274.                     L"Font",        L"Accelerator", L"RCData",      L"MessageTable",
  1275.                     L"GroupCursor", L"GroupIcon",   L"Version",     L"DlgInclude"
  1276.                 };
  1277.                 ProcessResourceDirectory(pResourceDir, 0, nullptr,
  1278.                     pResourceDir, resourceTypes, pNtHeaders, lpFileContent);
  1279.             }
  1280.             else {
  1281.                 OUTPUT("[-] Invalid or corrupted resource directory\n");
  1282.             }
  1283.         }
  1284.  
  1285.         const auto& debugDir = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
  1286.         if (debugDir.VirtualAddress && debugDir.Size) {
  1287.             if (!PEHelpers::IsRvaValid(debugDir.VirtualAddress, fileSize, pNtHeaders)) {
  1288.                 OUTPUT("[-] Invalid debug directory RVA!\n");
  1289.                 break;
  1290.             }
  1291.             OUTPUT("\n[+] DEBUG DIRECTORY\n");
  1292.             auto pDebugDir = (PIMAGE_DEBUG_DIRECTORY)PEHelpers::GetRvaPtr(
  1293.                 debugDir.VirtualAddress,
  1294.                 IMAGE_FIRST_SECTION(pNtHeaders),
  1295.                 pNtHeaders->FileHeader.NumberOfSections,
  1296.                 lpFileContent);
  1297.             if (pDebugDir && !IsBadReadPtr(pDebugDir, sizeof(IMAGE_DEBUG_DIRECTORY))) {
  1298.                 DWORD numEntries = min(debugDir.Size / sizeof(IMAGE_DEBUG_DIRECTORY), 16);
  1299.                 for (DWORD i = 0; i < numEntries; i++) {
  1300.                     OUTPUT("\tCharacteristics: 0x%X\n", pDebugDir[i].Characteristics);
  1301.                     OUTPUT("\tTimeDateStamp: 0x%X\n", pDebugDir[i].TimeDateStamp);
  1302.                     OUTPUT("\tMajorVersion: %d\n", pDebugDir[i].MajorVersion);
  1303.                     OUTPUT("\tMinorVersion: %d\n", pDebugDir[i].MinorVersion);
  1304.                     OUTPUT("\tType: 0x%X", pDebugDir[i].Type);
  1305.                     switch (pDebugDir[i].Type) {
  1306.                     case IMAGE_DEBUG_TYPE_COFF:
  1307.                         OUTPUT(" (COFF)\n"); break;
  1308.                     case IMAGE_DEBUG_TYPE_CODEVIEW:
  1309.                         OUTPUT(" (CodeView)\n"); break;
  1310.                     case IMAGE_DEBUG_TYPE_FPO:
  1311.                         OUTPUT(" (FPO)\n"); break;
  1312.                     case IMAGE_DEBUG_TYPE_MISC:
  1313.                         OUTPUT(" (Misc)\n"); break;
  1314.                     case IMAGE_DEBUG_TYPE_EXCEPTION:
  1315.                         OUTPUT(" (Exception)\n"); break;
  1316.                     default:
  1317.                         OUTPUT(" (Unknown)\n"); break;
  1318.                     }
  1319.                     OUTPUT("\tSizeOfData: 0x%X\n", pDebugDir[i].SizeOfData);
  1320.                     OUTPUT("\tAddressOfRawData: 0x%X\n", pDebugDir[i].AddressOfRawData);
  1321.                     OUTPUT("\tPointerToRawData: 0x%X\n\n", pDebugDir[i].PointerToRawData);
  1322.  
  1323.                     if (pDebugDir[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW &&
  1324.                         pDebugDir[i].PointerToRawData != 0 &&
  1325.                         pDebugDir[i].SizeOfData >= 24) {
  1326.                         auto pCVHeader = (DWORD*)((BYTE*)lpFileContent + pDebugDir[i].PointerToRawData);
  1327.                         if (!IsBadReadPtr(pCVHeader, sizeof(DWORD)) && *pCVHeader == 0x53445352) {
  1328.                             auto pCVData = (char*)(pCVHeader + 1);
  1329.                             if (!IsBadReadPtr(pCVData + 16, 1)) {
  1330.                                 std::vector<wchar_t> pdbPath(MAX_PATH);
  1331.                                 MultiByteToWideChar(CP_ACP, 0, pCVData + 16, -1,
  1332.                                     pdbPath.data(), MAX_PATH);
  1333.                                 OUTPUT("\tPDB Path: %s\n\n", pdbPath.data());
  1334.                             }
  1335.                         }
  1336.                     }
  1337.                 }
  1338.             }
  1339.         }
  1340.  
  1341.         ShowProgress(100);
  1342.         SetStatusText(L"Analysis complete");
  1343.         ShowWindow(g_hProgressBar, SW_HIDE);
  1344.  
  1345.     } while (false); // End of the do-while loop that replaced goto
  1346.  
  1347.     // Cleanup
  1348.     if (lpFileContent) UnmapViewOfFile(lpFileContent);
  1349.     if (hFileMapping) CloseHandle(hFileMapping);
  1350.     if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
  1351.     UpdateEditControl();
  1352. }
  1353.  
  1354.    
  1355.     /*OUTPUT("[+] Starting PE Analysis for: %s\n\n", filePathW);
  1356.  
  1357.     FileMapper mapper;
  1358.     if (!mapper.Initialize(filePathW)) {
  1359.         SetStatusText(L"Failed to open file!");
  1360.         OUTPUT("[-] Failed to open file! Error: %d\r\n", GetLastError());
  1361.         return;
  1362.     }
  1363.  
  1364.     ShowProgress(20);  // After initial file opening
  1365.  
  1366.  
  1367.     // Open and read file
  1368.     HANDLE hFile = CreateFileW(filePathW, GENERIC_READ, FILE_SHARE_READ, nullptr,
  1369.         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
  1370.     if (hFile == INVALID_HANDLE_VALUE) {
  1371.         OUTPUT("[-] Failed to open file! Error: %d\n", GetLastError());
  1372.         return;
  1373.     }
  1374.  
  1375.     DWORD fileSize = GetFileSize(hFile, nullptr);
  1376.     if (fileSize == INVALID_FILE_SIZE) {
  1377.         CloseHandle(hFile);
  1378.         OUTPUT("[-] Failed to get file size! Error: %d\n", GetLastError());
  1379.         return;
  1380.     }
  1381.  
  1382.     HANDLE hFileMapping = CreateFileMappingW(hFile, nullptr, PAGE_READONLY, 0, 0, nullptr);
  1383.     if (!hFileMapping) {
  1384.         CloseHandle(hFile);
  1385.         OUTPUT("[-] Failed to create file mapping! Error: %d\n", GetLastError());
  1386.         return;
  1387.     }
  1388.  
  1389.     LPVOID lpFileContent = MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0);
  1390.     if (!lpFileContent) {
  1391.         CloseHandle(hFileMapping);
  1392.         CloseHandle(hFile);
  1393.         OUTPUT("[-] Failed to map view of file! Error: %d\n", GetLastError());
  1394.         return;
  1395.     }
  1396.  
  1397.     const auto pImageDosHeader = static_cast<PIMAGE_DOS_HEADER>(mapper.GetView());
  1398.     if (pImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE) {
  1399.         OUTPUT("[-] Invalid DOS signature!\r\n");
  1400.         return;
  1401.     }
  1402.  
  1403.     ShowProgress(30);
  1404.  
  1405.     const auto pImageNtHeaders = reinterpret_cast<PIMAGE_NT_HEADERS>(
  1406.         static_cast<BYTE*>(mapper.GetView()) + pImageDosHeader->e_lfanew);
  1407.     if (pImageNtHeaders->Signature != IMAGE_NT_SIGNATURE) {
  1408.         OUTPUT("[-] Invalid NT signature!\r\n");
  1409.         return;
  1410.     }
  1411.  
  1412.     // Add right after this line:
  1413. // OUTPUT("[+] Starting PE Analysis for: %s\n\n", filePathW);
  1414.  
  1415. // Add PE Image Information and Architecture
  1416.     OUTPUT("[+] PE IMAGE INFORMATION\n\n");
  1417.     // Replace the Architecture output line with this:
  1418.     if (pImageNtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_I386) {
  1419.         OUTPUT("[+] Architecture: x86\n\n");
  1420.     }
  1421.     else if (pImageNtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64) {
  1422.         OUTPUT("[+] Architecture: x64\n\n");
  1423.     }
  1424.     else {
  1425.         OUTPUT("[+] Architecture: Unknown\n\n");
  1426.     }
  1427.  
  1428.     // Add complete DOS Header information
  1429.     OUTPUT("[+] DOS HEADER\n");
  1430.     OUTPUT("\te_magic    : 0x%X\n", pImageDosHeader->e_magic);
  1431.     OUTPUT("\te_cblp     : 0x%X\n", pImageDosHeader->e_cblp);
  1432.     OUTPUT("\te_cp       : 0x%X\n", pImageDosHeader->e_cp);
  1433.     OUTPUT("\te_crlc     : 0x%X\n", pImageDosHeader->e_crlc);
  1434.     OUTPUT("\te_cparhdr  : 0x%X\n", pImageDosHeader->e_cparhdr);
  1435.     OUTPUT("\te_minalloc : 0x%X\n", pImageDosHeader->e_minalloc);
  1436.     OUTPUT("\te_maxalloc : 0x%X\n", pImageDosHeader->e_maxalloc);
  1437.     OUTPUT("\te_ss       : 0x%X\n", pImageDosHeader->e_ss);
  1438.     OUTPUT("\te_sp       : 0x%X\n", pImageDosHeader->e_sp);
  1439.     OUTPUT("\te_csum     : 0x%X\n", pImageDosHeader->e_csum);
  1440.     OUTPUT("\te_ip       : 0x%X\n", pImageDosHeader->e_ip);
  1441.     OUTPUT("\te_cs       : 0x%X\n", pImageDosHeader->e_cs);
  1442.     OUTPUT("\te_lfarlc   : 0x%X\n", pImageDosHeader->e_lfarlc);
  1443.     OUTPUT("\te_ovno     : 0x%X\n", pImageDosHeader->e_ovno);
  1444.     OUTPUT("\te_oemid    : 0x%X\n", pImageDosHeader->e_oemid);
  1445.     OUTPUT("\te_oeminfo  : 0x%X\n", pImageDosHeader->e_oeminfo);
  1446.     OUTPUT("\te_lfanew   : 0x%X\n\n", pImageDosHeader->e_lfanew);
  1447.  
  1448.     // Add NT Header signature before the existing PE FILE HEADER section
  1449.     OUTPUT("[+] NT HEADER\n");
  1450.     OUTPUT("\tSignature  : 0x%X\n\n", pImageNtHeaders->Signature);
  1451.  
  1452.     // The rest of your existing code continues here...
  1453.     // OUTPUT("[+] PE FILE HEADER\n");
  1454.  
  1455.     ShowProgress(40);
  1456.  
  1457.     // Print File Header Information
  1458.     OUTPUT("[+] PE FILE HEADER\n");
  1459.     OUTPUT("\tMachine: 0x%X\n", pImageNtHeaders->FileHeader.Machine);
  1460.     OUTPUT("\tNumberOfSections: 0x%X\n", pImageNtHeaders->FileHeader.NumberOfSections);
  1461.     OUTPUT("\tTimeDateStamp: 0x%X\n", pImageNtHeaders->FileHeader.TimeDateStamp);
  1462.     OUTPUT("\tPointerToSymbolTable: 0x%X\r\n",
  1463.         static_cast<DWORD>(pImageNtHeaders->FileHeader.PointerToSymbolTable));
  1464.     OUTPUT("\tNumberOfSymbols: 0x%X\r\n",
  1465.         static_cast<DWORD>(pImageNtHeaders->FileHeader.NumberOfSymbols));
  1466.     OUTPUT("\tSizeOfOptionalHeader: 0x%X\r\n",
  1467.         static_cast<DWORD>(pImageNtHeaders->FileHeader.SizeOfOptionalHeader));
  1468.     OUTPUT("\tCharacteristics: 0x%X %s\n\n",
  1469.         pImageNtHeaders->FileHeader.Characteristics,
  1470.         PEHelpers::GetImageCharacteristics(pImageNtHeaders->FileHeader.Characteristics).c_str());
  1471.  
  1472.     ShowProgress(50);
  1473.  
  1474.     // Print Optional Header Information
  1475.     OUTPUT("[+] PE OPTIONAL HEADER\n");
  1476.     OUTPUT("\tMagic: 0x%X\n", pImageNtHeaders->OptionalHeader.Magic);
  1477.     OUTPUT("\tAddressOfEntryPoint: 0x%X\n", pImageNtHeaders->OptionalHeader.AddressOfEntryPoint);
  1478.     OUTPUT("\tImageBase: 0x%llX\n", (ULONGLONG)pImageNtHeaders->OptionalHeader.ImageBase);
  1479.     OUTPUT("\tSectionAlignment: 0x%X\n", pImageNtHeaders->OptionalHeader.SectionAlignment);
  1480.     OUTPUT("\tFileAlignment: 0x%X\n", pImageNtHeaders->OptionalHeader.FileAlignment);
  1481.  
  1482.     // Added missing Optional Header fields
  1483.     OUTPUT("\tMajorOperatingSystemVersion: 0x%X\r\n",
  1484.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.MajorOperatingSystemVersion));
  1485.     OUTPUT("\tMinorOperatingSystemVersion: 0x%X\r\n",
  1486.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.MinorOperatingSystemVersion));
  1487.     OUTPUT("\tMajorImageVersion: 0x%X\r\n",
  1488.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.MajorImageVersion));
  1489.     OUTPUT("\tMinorImageVersion: 0x%X\r\n",
  1490.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.MinorImageVersion));
  1491.     OUTPUT("\tMajorSubsystemVersion: 0x%X\r\n",
  1492.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.MajorSubsystemVersion));
  1493.     OUTPUT("\tMinorSubsystemVersion: 0x%X\r\n",
  1494.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.MinorSubsystemVersion));
  1495.     OUTPUT("\tWin32VersionValue: 0x%X\r\n",
  1496.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.Win32VersionValue));
  1497.     OUTPUT("\tSizeOfImage: 0x%X\r\n",
  1498.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.SizeOfImage));
  1499.     OUTPUT("\tSizeOfHeaders: 0x%X\r\n",
  1500.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.SizeOfHeaders));
  1501.     OUTPUT("\tCheckSum: 0x%X\r\n",
  1502.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.CheckSum));
  1503.     OUTPUT("\tSubsystem: 0x%X %s\r\n",
  1504.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.Subsystem),
  1505.         PEHelpers::GetSubsystem(pImageNtHeaders->OptionalHeader.Subsystem).c_str());
  1506.     OUTPUT("\tDllCharacteristics: 0x%X\r\n",
  1507.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.DllCharacteristics));
  1508.     OUTPUT("\tSizeOfStackReserve: 0x%llX\r\n",
  1509.         static_cast<ULONGLONG>(pImageNtHeaders->OptionalHeader.SizeOfStackReserve));
  1510.     OUTPUT("\tSizeOfStackCommit: 0x%llX\r\n",
  1511.         static_cast<ULONGLONG>(pImageNtHeaders->OptionalHeader.SizeOfStackCommit));
  1512.     OUTPUT("\tSizeOfHeapReserve: 0x%llX\r\n",
  1513.         static_cast<ULONGLONG>(pImageNtHeaders->OptionalHeader.SizeOfHeapReserve));
  1514.     OUTPUT("\tSizeOfHeapCommit: 0x%llX\r\n",
  1515.         static_cast<ULONGLONG>(pImageNtHeaders->OptionalHeader.SizeOfHeapCommit));
  1516.     OUTPUT("\tLoaderFlags: 0x%X\r\n",
  1517.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.LoaderFlags));
  1518.     OUTPUT("\tNumberOfRvaAndSizes: 0x%X\r\n\r\n",
  1519.         static_cast<DWORD>(pImageNtHeaders->OptionalHeader.NumberOfRvaAndSizes));
  1520.  
  1521.     OUTPUT("\tSubsystem: 0x%X %s\n\n",
  1522.         pImageNtHeaders->OptionalHeader.Subsystem,
  1523.         PEHelpers::GetSubsystem(pImageNtHeaders->OptionalHeader.Subsystem).c_str());
  1524.  
  1525.     // Print Data Directories
  1526.     OUTPUT("[+] PE DATA DIRECTORIES\n");
  1527.     for (int i = 0; i < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; i++) {
  1528.         const auto& dir = pImageNtHeaders->OptionalHeader.DataDirectory[i];
  1529.         if (dir.VirtualAddress != 0) {
  1530.             OUTPUT("\t%s:\n", PEHelpers::GetDataDirectoryName(i).c_str());
  1531.             OUTPUT("\t\tVirtualAddress: 0x%X\n", dir.VirtualAddress);
  1532.             OUTPUT("\t\tSize: 0x%X\n", dir.Size);
  1533.         }
  1534.     }
  1535.  
  1536.     // Analyze Sections
  1537.     OUTPUT("\n[+] PE IMAGE SECTIONS\r\n");
  1538.     auto pSection = IMAGE_FIRST_SECTION(pImageNtHeaders);
  1539.     for (WORD i = 0; i < pImageNtHeaders->FileHeader.NumberOfSections; i++, pSection++) {
  1540.         // Create a null-terminated string from the section name
  1541.         char sectionName[IMAGE_SIZEOF_SHORT_NAME + 1] = {};
  1542.         memcpy(sectionName, pSection->Name, IMAGE_SIZEOF_SHORT_NAME);
  1543.  
  1544.         // Remove any non-printable characters
  1545.         for (int j = 0; j < IMAGE_SIZEOF_SHORT_NAME; j++) {
  1546.             if (!isprint(static_cast<unsigned char>(sectionName[j]))) {
  1547.                 sectionName[j] = '\0';
  1548.             }
  1549.         }
  1550.  
  1551.         // Convert to wide string
  1552.         wchar_t wideSectionName[IMAGE_SIZEOF_SHORT_NAME + 1] = {};
  1553.         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
  1554.             sectionName, -1,
  1555.             wideSectionName, IMAGE_SIZEOF_SHORT_NAME + 1);
  1556.  
  1557.         OUTPUT("\tSECTION : %s\r\n", wideSectionName);
  1558.         OUTPUT("\t\tMisc (PhysicalAddress) : 0x%X\r\n", pSection->Misc.PhysicalAddress);
  1559.         OUTPUT("\t\tMisc (VirtualSize) : 0x%X\r\n", pSection->Misc.VirtualSize);
  1560.         OUTPUT("\t\tVirtualAddress : 0x%X\r\n", pSection->VirtualAddress);
  1561.         OUTPUT("\t\tSizeOfRawData : 0x%X\r\n", pSection->SizeOfRawData);
  1562.         OUTPUT("\t\tPointerToRawData : 0x%X\r\n", pSection->PointerToRawData);
  1563.         OUTPUT("\t\tPointerToRelocations : 0x%X\r\n", pSection->PointerToRelocations);
  1564.         OUTPUT("\t\tPointerToLinenumbers : 0x%X\r\n", pSection->PointerToLinenumbers);
  1565.         OUTPUT("\t\tNumberOfRelocations : 0x%X\r\n", pSection->NumberOfRelocations);
  1566.         OUTPUT("\t\tNumberOfLinenumbers : 0x%X\r\n", pSection->NumberOfLinenumbers);
  1567.         OUTPUT("\t\tCharacteristics : 0x%X %s\r\n\r\n",
  1568.             pSection->Characteristics,
  1569.             PEHelpers::GetSectionProtection(pSection->Characteristics).c_str());
  1570.     }
  1571.  
  1572.     ShowProgress(60);
  1573.  
  1574.     // Analyze Imports
  1575.     // Then modify the Import section like this:
  1576.     const auto& importDir = pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
  1577.     if (importDir.VirtualAddress && importDir.Size) {
  1578.         OUTPUT("\n[+] IMPORTED DLLS AND FUNCTIONS\r\n");
  1579.         auto pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)PEHelpers::GetRvaPtr(
  1580.             importDir.VirtualAddress,
  1581.             IMAGE_FIRST_SECTION(pImageNtHeaders),
  1582.             pImageNtHeaders->FileHeader.NumberOfSections,
  1583.             lpFileContent);
  1584.  
  1585.         bool is64Bit = Is64BitPE(pImageNtHeaders);
  1586.  
  1587.         while (pImportDesc && pImportDesc->Name != 0) {
  1588.             const char* dllName = (const char*)PEHelpers::GetRvaPtr(
  1589.                 pImportDesc->Name,
  1590.                 IMAGE_FIRST_SECTION(pImageNtHeaders),
  1591.                 pImageNtHeaders->FileHeader.NumberOfSections,
  1592.                 lpFileContent);
  1593.  
  1594.             if (dllName) {
  1595.                 std::vector<wchar_t> wideDllName(MAX_PATH);
  1596.                 MultiByteToWideChar(CP_ACP, 0, dllName, -1, wideDllName.data(), MAX_PATH);
  1597.  
  1598.                 OUTPUT("\n\tDLL NAME : %s\r\n", wideDllName.data());
  1599.                 OUTPUT("\tCharacteristics : 0x%X\r\n", pImportDesc->Characteristics);
  1600.                 OUTPUT("\tOriginalFirstThunk : 0x%X\r\n", pImportDesc->OriginalFirstThunk);
  1601.                 OUTPUT("\tTimeDateStamp : 0x%X\r\n", pImportDesc->TimeDateStamp);
  1602.                 OUTPUT("\tForwarderChain : 0x%X\r\n", pImportDesc->ForwarderChain);
  1603.                 OUTPUT("\tFirstThunk : 0x%X\r\n", pImportDesc->FirstThunk);
  1604.  
  1605.                 OUTPUT("\n\tImported Functions :\r\n\r\n");
  1606.  
  1607.                 ULONGLONG ordinalFlag = is64Bit ? IMAGE_ORDINAL_FLAG64 : IMAGE_ORDINAL_FLAG32;
  1608.  
  1609.                 if (is64Bit) {
  1610.                     auto pThunk = (PIMAGE_THUNK_DATA64)PEHelpers::GetRvaPtr(
  1611.                         pImportDesc->OriginalFirstThunk ? pImportDesc->OriginalFirstThunk : pImportDesc->FirstThunk,
  1612.                         IMAGE_FIRST_SECTION(pImageNtHeaders),
  1613.                         pImageNtHeaders->FileHeader.NumberOfSections,
  1614.                         lpFileContent);
  1615.  
  1616.                     while (pThunk && pThunk->u1.AddressOfData) {
  1617.                         if (!(pThunk->u1.Ordinal & ordinalFlag)) {
  1618.                             auto pImportByName = (PIMAGE_IMPORT_BY_NAME)PEHelpers::GetRvaPtr(
  1619.                                 (DWORD)pThunk->u1.AddressOfData,
  1620.                                 IMAGE_FIRST_SECTION(pImageNtHeaders),
  1621.                                 pImageNtHeaders->FileHeader.NumberOfSections,
  1622.                                 lpFileContent);
  1623.  
  1624.                             if (pImportByName && !IsBadReadPtr(pImportByName, sizeof(IMAGE_IMPORT_BY_NAME))) {
  1625.                                 std::vector<wchar_t> wideFuncName(MAX_PATH);
  1626.                                 MultiByteToWideChar(CP_ACP, 0, (char*)pImportByName->Name, -1,
  1627.                                     wideFuncName.data(), MAX_PATH);
  1628.                                 OUTPUT("\t\t%s\r\n", wideFuncName.data());
  1629.                             }
  1630.                         }
  1631.                         else {
  1632.                             OUTPUT("\t\tOrdinal: %lld\r\n", pThunk->u1.Ordinal & 0xFFFF);
  1633.                         }
  1634.                         pThunk++;
  1635.                     }
  1636.                 }
  1637.                 else {
  1638.                     auto pThunk = (PIMAGE_THUNK_DATA32)PEHelpers::GetRvaPtr(
  1639.                         pImportDesc->OriginalFirstThunk ? pImportDesc->OriginalFirstThunk : pImportDesc->FirstThunk,
  1640.                         IMAGE_FIRST_SECTION(pImageNtHeaders),
  1641.                         pImageNtHeaders->FileHeader.NumberOfSections,
  1642.                         lpFileContent);
  1643.  
  1644.                     while (pThunk && pThunk->u1.AddressOfData) {
  1645.                         if (!(pThunk->u1.Ordinal & ordinalFlag)) {
  1646.                             auto pImportByName = (PIMAGE_IMPORT_BY_NAME)PEHelpers::GetRvaPtr(
  1647.                                 pThunk->u1.AddressOfData,
  1648.                                 IMAGE_FIRST_SECTION(pImageNtHeaders),
  1649.                                 pImageNtHeaders->FileHeader.NumberOfSections,
  1650.                                 lpFileContent);
  1651.  
  1652.                             if (pImportByName && !IsBadReadPtr(pImportByName, sizeof(IMAGE_IMPORT_BY_NAME))) {
  1653.                                 std::vector<wchar_t> wideFuncName(MAX_PATH);
  1654.                                 MultiByteToWideChar(CP_ACP, 0, (char*)pImportByName->Name, -1,
  1655.                                     wideFuncName.data(), MAX_PATH);
  1656.                                 OUTPUT("\t\t%s\r\n", wideFuncName.data());
  1657.                             }
  1658.                         }
  1659.                         else {
  1660.                             OUTPUT("\t\tOrdinal: %d\r\n", pThunk->u1.Ordinal & 0xFFFF);
  1661.                         }
  1662.                         pThunk++;
  1663.                     }
  1664.                 }
  1665.             }
  1666.             pImportDesc++;
  1667.         }
  1668.     }
  1669.  
  1670.         ShowProgress(70);
  1671.  
  1672.         // In your AnalyzePEFile function, add this code after the imports section (before the cleanup label):
  1673.  
  1674.         // Handle Exports
  1675.         const auto& exportDir = pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
  1676.         if (exportDir.VirtualAddress && exportDir.Size) {
  1677.             OUTPUT("\n[+] EXPORTED FUNCTIONS\n");
  1678.             auto pExportDir = (PIMAGE_EXPORT_DIRECTORY)PEHelpers::GetRvaPtr(
  1679.                 exportDir.VirtualAddress,
  1680.                 IMAGE_FIRST_SECTION(pImageNtHeaders),
  1681.                 pImageNtHeaders->FileHeader.NumberOfSections,
  1682.                 lpFileContent);
  1683.  
  1684.             if (pExportDir) {
  1685.                 // ... (existing code)
  1686.  
  1687.                 auto pFunctions = (PDWORD)PEHelpers::GetRvaPtr(
  1688.                     pExportDir->AddressOfFunctions,
  1689.                     IMAGE_FIRST_SECTION(pImageNtHeaders),
  1690.                     pImageNtHeaders->FileHeader.NumberOfSections,
  1691.                     lpFileContent);
  1692.  
  1693.                 auto pNames = (PDWORD)PEHelpers::GetRvaPtr(
  1694.                     pExportDir->AddressOfNames,
  1695.                     IMAGE_FIRST_SECTION(pImageNtHeaders),
  1696.                     pImageNtHeaders->FileHeader.NumberOfSections,
  1697.                     lpFileContent);
  1698.  
  1699.                 auto pNameOrdinals = (PWORD)PEHelpers::GetRvaPtr(
  1700.                     pExportDir->AddressOfNameOrdinals,
  1701.                     IMAGE_FIRST_SECTION(pImageNtHeaders),
  1702.                     pImageNtHeaders->FileHeader.NumberOfSections,
  1703.                     lpFileContent);
  1704.  
  1705.                 if (pNames && pNameOrdinals && pFunctions) {
  1706.                     for (DWORD i = 0; i < pExportDir->NumberOfNames; i++) {
  1707.                         const char* functionName = (const char*)PEHelpers::GetRvaPtr(
  1708.                             pNames[i],
  1709.                             IMAGE_FIRST_SECTION(pImageNtHeaders),
  1710.                             pImageNtHeaders->FileHeader.NumberOfSections,
  1711.                             lpFileContent);
  1712.  
  1713.                         if (functionName) {
  1714.                             WORD ordinal = pNameOrdinals[i];
  1715.                             DWORD functionRva = pFunctions[ordinal];
  1716.  
  1717.                             std::vector<wchar_t> wideFuncName(MAX_PATH);
  1718.                             MultiByteToWideChar(CP_ACP, 0, functionName, -1,
  1719.                                 wideFuncName.data(), MAX_PATH);
  1720.  
  1721.                             // Check if it's a forwarded export
  1722.                             if (functionRva >= exportDir.VirtualAddress &&
  1723.                                 functionRva < (exportDir.VirtualAddress + exportDir.Size)) {
  1724.                                 // This is a forwarded export
  1725.                                 const char* forwardName = (const char*)PEHelpers::GetRvaPtr(
  1726.                                     functionRva,
  1727.                                     IMAGE_FIRST_SECTION(pImageNtHeaders),
  1728.                                     pImageNtHeaders->FileHeader.NumberOfSections,
  1729.                                     lpFileContent);
  1730.  
  1731.                                 if (forwardName) {
  1732.                                     std::vector<wchar_t> wideForwardName(MAX_PATH);
  1733.                                     MultiByteToWideChar(CP_ACP, 0, forwardName, -1,
  1734.                                         wideForwardName.data(), MAX_PATH);
  1735.                                     OUTPUT("\t\t%s (Ordinal: %d) -> Forward to: %s\n",
  1736.                                         wideFuncName.data(),
  1737.                                         ordinal + pExportDir->Base,
  1738.                                         wideForwardName.data());
  1739.                                 }
  1740.                             }
  1741.                             else {
  1742.                                 OUTPUT("\t\t%s (Ordinal: %d, RVA: 0x%08X)\n",
  1743.                                     wideFuncName.data(),
  1744.                                     ordinal + pExportDir->Base,
  1745.                                     functionRva);
  1746.                             }
  1747.                         }
  1748.                     }
  1749.  
  1750.                     // Check for exports by ordinal only (no names)
  1751.                     for (DWORD i = 0; i < pExportDir->NumberOfFunctions; i++) {
  1752.                         if (pFunctions[i] != 0) {
  1753.                             bool hasName = false;
  1754.                             for (DWORD j = 0; j < pExportDir->NumberOfNames; j++) {
  1755.                                 if (pNameOrdinals[j] == i) {
  1756.                                     hasName = true;
  1757.                                     break;
  1758.                                 }
  1759.                             }
  1760.  
  1761.                             if (!hasName) {
  1762.                                 DWORD functionRva = pFunctions[i];
  1763.                                 if (functionRva >= exportDir.VirtualAddress &&
  1764.                                     functionRva < (exportDir.VirtualAddress + exportDir.Size)) {
  1765.                                     // This is a forwarded export
  1766.                                     const char* forwardName = (const char*)PEHelpers::GetRvaPtr(
  1767.                                         functionRva,
  1768.                                         IMAGE_FIRST_SECTION(pImageNtHeaders),
  1769.                                         pImageNtHeaders->FileHeader.NumberOfSections,
  1770.                                         lpFileContent);
  1771.  
  1772.                                     if (forwardName) {
  1773.                                         std::vector<wchar_t> wideForwardName(MAX_PATH);
  1774.                                         MultiByteToWideChar(CP_ACP, 0, forwardName, -1,
  1775.                                             wideForwardName.data(), MAX_PATH);
  1776.                                         OUTPUT("\t\tOrdinal: %d -> Forward to: %s\n",
  1777.                                             i + pExportDir->Base,
  1778.                                             wideForwardName.data());
  1779.                                     }
  1780.                                 }
  1781.                                 else {
  1782.                                     OUTPUT("\t\tOrdinal: %d (RVA: 0x%08X)\n",
  1783.                                         i + pExportDir->Base,
  1784.                                         functionRva);
  1785.                                 }
  1786.                             }
  1787.                         }
  1788.                     }
  1789.                 }
  1790.             }
  1791.         }
  1792.  
  1793.         ShowProgress(80);
  1794.  
  1795.         // Add after export directory analysis and before ShowProgress(100)
  1796.  
  1797.         // Resource Directory Analysis
  1798.         const auto& resourceDir = pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
  1799.         if (resourceDir.VirtualAddress && resourceDir.Size) {
  1800.             OUTPUT("\n[+] RESOURCE DIRECTORY\n");
  1801.             auto pResourceDir = (PIMAGE_RESOURCE_DIRECTORY)PEHelpers::GetRvaPtr(
  1802.                 resourceDir.VirtualAddress,
  1803.                 IMAGE_FIRST_SECTION(pImageNtHeaders),
  1804.                 pImageNtHeaders->FileHeader.NumberOfSections,
  1805.                 lpFileContent);
  1806.  
  1807.             if (pResourceDir && !IsBadReadPtr(pResourceDir, sizeof(IMAGE_RESOURCE_DIRECTORY))) {
  1808.                 OUTPUT("\tCharacteristics: 0x%X\n", pResourceDir->Characteristics);
  1809.                 OUTPUT("\tTimeDateStamp: 0x%X\n", pResourceDir->TimeDateStamp);
  1810.                 OUTPUT("\tMajorVersion: %d\n", pResourceDir->MajorVersion);
  1811.                 OUTPUT("\tMinorVersion: %d\n", pResourceDir->MinorVersion);
  1812.                 OUTPUT("\tNumberOfNamedEntries: %d\n", pResourceDir->NumberOfNamedEntries);
  1813.                 OUTPUT("\tNumberOfIdEntries: %d\n\n", pResourceDir->NumberOfIdEntries);
  1814.  
  1815.                 const wchar_t* resourceTypes[] = {
  1816.                     L"Unknown",     L"Cursor",      L"Bitmap",      L"Icon",
  1817.                     L"Menu",        L"Dialog",      L"String",      L"FontDir",
  1818.                     L"Font",        L"Accelerator", L"RCData",      L"MessageTable",
  1819.                     L"GroupCursor", L"GroupIcon",   L"Version",     L"DlgInclude"
  1820.                 };
  1821.  
  1822.                 auto ProcessResourceDirectory = [&](PIMAGE_RESOURCE_DIRECTORY resDir, int level, const wchar_t* type = nullptr) {
  1823.                     if (IsBadReadPtr(resDir, sizeof(IMAGE_RESOURCE_DIRECTORY))) {
  1824.                         return;
  1825.                     }
  1826.  
  1827.                     auto entry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(resDir + 1);
  1828.                     WORD totalEntries = resDir->NumberOfNamedEntries + resDir->NumberOfIdEntries;
  1829.  
  1830.                     for (WORD i = 0; i < totalEntries; i++) {
  1831.                         if (IsBadReadPtr(entry + i, sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))) {
  1832.                             break;
  1833.                         }
  1834.  
  1835.                         for (int indent = 0; indent < level; indent++) {
  1836.                             OUTPUT("\t");
  1837.                         }
  1838.  
  1839.                         if (entry[i].NameIsString) {
  1840.                             auto nameEntry = (PIMAGE_RESOURCE_DIR_STRING_U)((BYTE*)pResourceDir + entry[i].NameOffset);
  1841.                             if (!IsBadReadPtr(nameEntry, sizeof(IMAGE_RESOURCE_DIR_STRING_U))) {
  1842.                                 std::vector<wchar_t> resourceName(nameEntry->Length + 1);
  1843.                                 wcsncpy_s(resourceName.data(), nameEntry->Length + 1,
  1844.                                     nameEntry->NameString, nameEntry->Length);
  1845.                                 resourceName[nameEntry->Length] = L'\0';
  1846.  
  1847.                                 if (level == 0) {
  1848.                                     OUTPUT("Resource Type: Custom (%s)\n", resourceName.data());
  1849.                                 }
  1850.                                 else {
  1851.                                     OUTPUT("Name: %s\n", resourceName.data());
  1852.                                 }
  1853.                             }
  1854.                         }
  1855.                         else {
  1856.                             if (level == 0) {
  1857.                                 DWORD resourceType = entry[i].Id;
  1858.                                 if (resourceType < 16) {
  1859.                                     OUTPUT("Resource Type: %s (ID: %d)\n", resourceTypes[resourceType], resourceType);
  1860.                                 }
  1861.                                 else {
  1862.                                     OUTPUT("Resource Type: Custom (ID: %d)\n", resourceType);
  1863.                                 }
  1864.                             }
  1865.                             else {
  1866.                                 OUTPUT("ID: %d\n", entry[i].Id);
  1867.                             }
  1868.                         }
  1869.  
  1870.                         if (entry[i].DataIsDirectory) {
  1871.                             auto nextDir = (PIMAGE_RESOURCE_DIRECTORY)((BYTE*)pResourceDir + entry[i].OffsetToDirectory);
  1872.                             if (!IsBadReadPtr(nextDir, sizeof(IMAGE_RESOURCE_DIRECTORY))) {
  1873.                                 ProcessResourceDirectory(nextDir, level + 1,
  1874.                                     level == 0 ? resourceTypes[min(entry[i].Id, 15)] : type);
  1875.                             }
  1876.                         }
  1877.                         else {
  1878.                             auto dataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)((BYTE*)pResourceDir + entry[i].OffsetToData);
  1879.                             if (!IsBadReadPtr(dataEntry, sizeof(IMAGE_RESOURCE_DATA_ENTRY))) {
  1880.                                 for (int indent = 0; indent < level + 1; indent++) {
  1881.                                     OUTPUT("\t");
  1882.                                 }
  1883.                                 OUTPUT("Size: %d bytes, RVA: 0x%X\n",
  1884.                                     dataEntry->Size, dataEntry->OffsetToData);
  1885.  
  1886.                                 // For Version Info resources, we can extract more details
  1887.                                 if (type && wcscmp(type, L"Version") == 0) {
  1888.                                     auto versionData = (BYTE*)PEHelpers::GetRvaPtr(
  1889.                                         dataEntry->OffsetToData,
  1890.                                         IMAGE_FIRST_SECTION(pImageNtHeaders),
  1891.                                         pImageNtHeaders->FileHeader.NumberOfSections,
  1892.                                         lpFileContent);
  1893.  
  1894.                                     if (versionData && !IsBadReadPtr(versionData, sizeof(VS_FIXEDFILEINFO))) {
  1895.                                         auto versionInfo = (VS_FIXEDFILEINFO*)(versionData + 40); // Skip VS_VERSION_INFO header
  1896.                                         if (versionInfo->dwSignature == 0xFEEF04BD) {
  1897.                                             for (int indent = 0; indent < level + 2; indent++) {
  1898.                                                 OUTPUT("\t");
  1899.                                             }
  1900.                                             OUTPUT("File Version: %d.%d.%d.%d\n",
  1901.                                                 HIWORD(versionInfo->dwFileVersionMS),
  1902.                                                 LOWORD(versionInfo->dwFileVersionMS),
  1903.                                                 HIWORD(versionInfo->dwFileVersionLS),
  1904.                                                 LOWORD(versionInfo->dwFileVersionLS));
  1905.                                         }
  1906.                                     }
  1907.                                 }
  1908.                             }
  1909.                         }
  1910.                     }
  1911.                 };
  1912.  
  1913.                 ProcessResourceDirectory(pResourceDir, 0);
  1914.             }
  1915.             else {
  1916.                 OUTPUT("[-] Invalid or corrupted resource directory\n");
  1917.             }
  1918.         }
  1919.  
  1920.         ShowProgress(90);
  1921.  
  1922.         // Debug Directory Analysis
  1923.         const auto& debugDir = pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
  1924.         if (debugDir.VirtualAddress && debugDir.Size) {
  1925.             OUTPUT("\n[+] DEBUG DIRECTORY\n");
  1926.             auto pSection = IMAGE_FIRST_SECTION(pImageNtHeaders);
  1927.             PIMAGE_SECTION_HEADER pDebugSection = nullptr;
  1928.  
  1929.             // Find the section containing the debug directory
  1930.             for (WORD i = 0; i < pImageNtHeaders->FileHeader.NumberOfSections; i++, pSection++) {
  1931.                 if (debugDir.VirtualAddress >= pSection->VirtualAddress &&
  1932.                     debugDir.VirtualAddress < (pSection->VirtualAddress + pSection->Misc.VirtualSize)) {
  1933.                     pDebugSection = pSection;
  1934.                     break;
  1935.                 }
  1936.             }
  1937.  
  1938.             if (!pDebugSection) {
  1939.                 OUTPUT("[-] Could not find debug section\n");
  1940.             }
  1941.             else {
  1942.                 // Calculate the correct offset for both 32-bit and 64-bit PE files
  1943.                 DWORD debugDirOffset = pDebugSection->PointerToRawData +
  1944.                     (debugDir.VirtualAddress - pDebugSection->VirtualAddress);
  1945.  
  1946.                 auto pDebugDirectory = reinterpret_cast<PIMAGE_DEBUG_DIRECTORY>(
  1947.                     (BYTE*)lpFileContent + debugDirOffset);
  1948.  
  1949.                 // Safely process debug entries
  1950.                 DWORD numEntries = min(debugDir.Size / sizeof(IMAGE_DEBUG_DIRECTORY), 16); // Limit entries to prevent overflow
  1951.  
  1952.                 for (DWORD i = 0; i < numEntries; i++) {
  1953.                     if (IsBadReadPtr(pDebugDirectory + i, sizeof(IMAGE_DEBUG_DIRECTORY))) {
  1954.                         OUTPUT("[-] Invalid debug directory entry detected\n");
  1955.                         break;
  1956.                     }
  1957.  
  1958.                     OUTPUT("\tCharacteristics: 0x%X\n", pDebugDirectory[i].Characteristics);
  1959.                     OUTPUT("\tTimeDateStamp: 0x%X\n", pDebugDirectory[i].TimeDateStamp);
  1960.                     OUTPUT("\tMajorVersion: %d\n", pDebugDirectory[i].MajorVersion);
  1961.                     OUTPUT("\tMinorVersion: %d\n", pDebugDirectory[i].MinorVersion);
  1962.                     OUTPUT("\tType: 0x%X", pDebugDirectory[i].Type);
  1963.  
  1964.                     // Process debug type
  1965.                     switch (pDebugDirectory[i].Type) {
  1966.                     case IMAGE_DEBUG_TYPE_COFF:
  1967.                         OUTPUT(" (COFF)\n"); break;
  1968.                     case IMAGE_DEBUG_TYPE_CODEVIEW:
  1969.                         OUTPUT(" (CodeView)\n"); break;
  1970.                     case IMAGE_DEBUG_TYPE_FPO:
  1971.                         OUTPUT(" (FPO)\n"); break;
  1972.                     case IMAGE_DEBUG_TYPE_MISC:
  1973.                         OUTPUT(" (Misc)\n"); break;
  1974.                     case IMAGE_DEBUG_TYPE_EXCEPTION:
  1975.                         OUTPUT(" (Exception)\n"); break;
  1976.                     default:
  1977.                         OUTPUT(" (Unknown)\n"); break;
  1978.                     }
  1979.  
  1980.                     OUTPUT("\tSizeOfData: 0x%X\n", pDebugDirectory[i].SizeOfData);
  1981.                     OUTPUT("\tAddressOfRawData: 0x%X\n", pDebugDirectory[i].AddressOfRawData);
  1982.                     OUTPUT("\tPointerToRawData: 0x%X\n\n", pDebugDirectory[i].PointerToRawData);
  1983.  
  1984.                     // Process CodeView information if available
  1985.                     if (pDebugDirectory[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW &&
  1986.                         pDebugDirectory[i].PointerToRawData != 0 &&
  1987.                         pDebugDirectory[i].SizeOfData >= 24) { // Minimum size for CodeView data
  1988.  
  1989.                         auto pCVHeader = reinterpret_cast<DWORD*>(
  1990.                             (BYTE*)lpFileContent + pDebugDirectory[i].PointerToRawData);
  1991.  
  1992.                         if (!IsBadReadPtr(pCVHeader, sizeof(DWORD)) && *pCVHeader == 0x53445352) {
  1993.                             auto pCVData = reinterpret_cast<char*>(pCVHeader + 1);
  1994.                             if (!IsBadReadPtr(pCVData + 16, 1)) {
  1995.                                 std::vector<wchar_t> pdbPath(MAX_PATH);
  1996.                                 MultiByteToWideChar(CP_ACP, 0, pCVData + 16, -1,
  1997.                                     pdbPath.data(), MAX_PATH);
  1998.                                 OUTPUT("\tPDB Path: %s\n\n", pdbPath.data());
  1999.                             }
  2000.                         }
  2001.                     }
  2002.                 }
  2003.             }
  2004.         }
  2005.  
  2006.         // Continue with ShowProgress(100)...
  2007.  
  2008.         // In your AnalyzePEFile function, at the end:
  2009.         ShowProgress(100);
  2010.         SetStatusText(L"Analysis complete");
  2011.         ShowWindow(g_hProgressBar, SW_HIDE);  // Optional: hide progress bar when done
  2012.  
  2013.     cleanup:
  2014.         if (lpFileContent) {
  2015.             UnmapViewOfFile(lpFileContent);
  2016.         }
  2017.         if (hFileMapping) {
  2018.             CloseHandle(hFileMapping);
  2019.         }
  2020.         if (hFile) {
  2021.             CloseHandle(hFile);
  2022.         }
  2023.  
  2024.         UpdateEditControl();
  2025. }*/
  2026.  
  2027. /*
  2028. //use below vv ALWAYS
  2029. void AnalyzePEFile(const wchar_t* filePathW) {
  2030.     OUTPUT("[+] Starting PE Analysis for: %s\n\n", filePathW);
  2031.  
  2032.     LPVOID lpFileContent = GetFileContent(filePathW);
  2033.     if (!lpFileContent) {
  2034.         OUTPUT("[-] Failed to read file content!\n");
  2035.         return;
  2036.     }
  2037.  
  2038.     const auto pImageDosHeader = static_cast<PIMAGE_DOS_HEADER>(lpFileContent);
  2039.     if (pImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE) {
  2040.         OUTPUT("[-] Invalid DOS signature!\n");
  2041.         HeapFree(GetProcessHeap(), 0, lpFileContent);
  2042.         return;
  2043.     }
  2044.  
  2045.     const auto pImageNtHeaders = reinterpret_cast<PIMAGE_NT_HEADERS>((DWORD_PTR)lpFileContent + pImageDosHeader->e_lfanew);
  2046.     if (pImageNtHeaders->Signature != IMAGE_NT_SIGNATURE) {
  2047.         OUTPUT("[-] Invalid NT signature!\n");
  2048.         HeapFree(GetProcessHeap(), 0, lpFileContent);
  2049.         return;
  2050.     }
  2051.  
  2052.     //UpdateEditControl(); //added just now remove line!
  2053.  
  2054.     OUTPUT("[+] PE FILE HEADER\n");
  2055.     OUTPUT("\tMachine : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.Machine);
  2056.     OUTPUT("\tNumberOfSections : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.NumberOfSections);
  2057.     OUTPUT("\tTimeDateStamp : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.TimeDateStamp);
  2058.     OUTPUT("\tPointerToSymbolTable : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.PointerToSymbolTable);
  2059.     OUTPUT("\tNumberOfSymbols : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.NumberOfSymbols);
  2060.     OUTPUT("\tSizeOfOptionalHeader : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.SizeOfOptionalHeader);
  2061.     OUTPUT("\tCharacteristics : 0x%X %s\n\n", (uintptr_t)pImageNtHeaders->FileHeader.Characteristics, GetImageCharacteristics(pImageNtHeaders->FileHeader.Characteristics));
  2062.  
  2063.     OUTPUT("[+] PE OPTIONAL HEADER\n");
  2064.     OUTPUT("\tMagic : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.Magic);
  2065.     OUTPUT("\tAddressOfEntryPoint : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.AddressOfEntryPoint);
  2066.     OUTPUT("\tImageBase : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.ImageBase);
  2067.     OUTPUT("\tSectionAlignment : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SectionAlignment);
  2068.     OUTPUT("\tFileAlignment : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.FileAlignment);
  2069.     OUTPUT("\tMajorOperatingSystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MajorOperatingSystemVersion);
  2070.     OUTPUT("\tMinorOperatingSystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MinorOperatingSystemVersion);
  2071.     OUTPUT("\tMajorImageVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MajorImageVersion);
  2072.     OUTPUT("\tMinorImageVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MinorImageVersion);
  2073.     OUTPUT("\tMajorSubsystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MajorSubsystemVersion);
  2074.     OUTPUT("\tMinorSubsystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MinorSubsystemVersion);
  2075.     OUTPUT("\tWin32VersionValue : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.Win32VersionValue);
  2076.     OUTPUT("\tSizeOfImage : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfImage);
  2077.     OUTPUT("\tSizeOfHeaders : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfHeaders);
  2078.     OUTPUT("\tCheckSum : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.CheckSum);
  2079.     OUTPUT("\tSubsystem : 0x%X %s\n", (uintptr_t)pImageNtHeaders->OptionalHeader.Subsystem, GetSubsystem(pImageNtHeaders->OptionalHeader.Subsystem));
  2080.     OUTPUT("\tDllCharacteristics : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.DllCharacteristics);
  2081.     OUTPUT("\tSizeOfStackReserve : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfStackReserve);
  2082.     OUTPUT("\tSizeOfStackCommit : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfStackCommit);
  2083.     OUTPUT("\tSizeOfHeapReserve : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfHeapReserve);
  2084.     OUTPUT("\tSizeOfHeapCommit : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfHeapCommit);
  2085.     OUTPUT("\tLoaderFlags : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.LoaderFlags);
  2086.     OUTPUT("\tNumberOfRvaAndSizes : 0x%X\n\n", (uintptr_t)pImageNtHeaders->OptionalHeader.NumberOfRvaAndSizes);
  2087.  
  2088.     //UpdateEditControl(); //added just now remove line!
  2089.  
  2090.     GetDataDirectories(&pImageNtHeaders->OptionalHeader.DataDirectory[0]);
  2091.  
  2092.     const auto pImageSectionHeader = reinterpret_cast<PIMAGE_SECTION_HEADER>((DWORD_PTR)pImageNtHeaders + sizeof(IMAGE_NT_HEADERS));
  2093.     const auto pImageImportSection = GetSections(pImageSectionHeader, pImageNtHeaders->FileHeader.NumberOfSections, pImageNtHeaders->OptionalHeader.DataDirectory[1].VirtualAddress);
  2094.  
  2095.     if (!pImageImportSection) {
  2096.         OUTPUT("[-] Error: Could not find import section!\n");
  2097.         HeapFree(GetProcessHeap(), 0, lpFileContent);
  2098.         return;
  2099.     }
  2100.  
  2101.     const auto pImageImportDescriptor = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>((DWORD_PTR)lpFileContent + pImageImportSection->PointerToRawData);
  2102.     if (pImageNtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_I386) {
  2103.         GetImports32(pImageImportDescriptor, (DWORD)lpFileContent + pImageImportSection->PointerToRawData, pImageImportSection);
  2104.     }
  2105.     else if (pImageNtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64) {
  2106.         GetImports64(pImageImportDescriptor, (DWORD)lpFileContent + pImageImportSection->PointerToRawData, pImageImportSection);
  2107.     }
  2108.     else {
  2109.         OUTPUT("[-] Unsupported architecture!\n");
  2110.     }
  2111.  
  2112.     HeapFree(GetProcessHeap(), 0, lpFileContent);
  2113.     UpdateEditControl();
  2114. }
  2115.  
  2116. void GetDataDirectories(PIMAGE_DATA_DIRECTORY pImageDataDirectory) {
  2117.     OUTPUT("[+] PE DATA DIRECTORIES\n");
  2118.     for (int i = 0; i < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; ++i, ++pImageDataDirectory) {
  2119.         if (pImageDataDirectory->VirtualAddress == 0) continue;
  2120.         OUTPUT("\tDataDirectory (%s) VirtualAddress : 0x%X\n", GetDataDirectoryName(i), (uintptr_t)pImageDataDirectory->VirtualAddress);
  2121.         OUTPUT("\tDataDirectory (%s) Size : 0x%X\n\n", GetDataDirectoryName(i), (uintptr_t)pImageDataDirectory->Size);
  2122.     }
  2123. }
  2124.  
  2125. PIMAGE_SECTION_HEADER GetSections(const PIMAGE_SECTION_HEADER pImageSectionHeader, int NumberOfSections, DWORD dImportAddress) {
  2126.     PIMAGE_SECTION_HEADER pImageImportHeader = nullptr;
  2127.     OUTPUT("\n[+] PE IMAGE SECTIONS\n");
  2128.     for (int i = 0; i < NumberOfSections; ++i) {
  2129.         const auto pCurrentSectionHeader = reinterpret_cast<PIMAGE_SECTION_HEADER>((DWORD_PTR)pImageSectionHeader + i * sizeof(IMAGE_SECTION_HEADER));
  2130.         OUTPUT("\n\tSECTION : %s\n", (wchar_t*)pCurrentSectionHeader->Name);
  2131.         OUTPUT("\t\tMisc (PhysicalAddress) : 0x%X\n", (uintptr_t)pCurrentSectionHeader->Misc.PhysicalAddress);
  2132.         OUTPUT("\t\tMisc (VirtualSize) : 0x%X\n", (uintptr_t)pCurrentSectionHeader->Misc.VirtualSize);
  2133.         OUTPUT("\t\tVirtualAddress : 0x%X\n", (uintptr_t)pCurrentSectionHeader->VirtualAddress);
  2134.         OUTPUT("\t\tSizeOfRawData : 0x%X\n", (uintptr_t)pCurrentSectionHeader->SizeOfRawData);
  2135.         OUTPUT("\t\tPointerToRawData : 0x%X\n", (uintptr_t)pCurrentSectionHeader->PointerToRawData);
  2136.         OUTPUT("\t\tCharacteristics : 0x%X %s\n", (uintptr_t)pCurrentSectionHeader->Characteristics, GetSectionProtection(pCurrentSectionHeader->Characteristics));
  2137.  
  2138.         if (dImportAddress >= pCurrentSectionHeader->VirtualAddress && dImportAddress < pCurrentSectionHeader->VirtualAddress + pCurrentSectionHeader->Misc.VirtualSize) {
  2139.             pImageImportHeader = pCurrentSectionHeader;
  2140.         }
  2141.     }
  2142.     return pImageImportHeader;
  2143. }
  2144.  
  2145. void GetImports32(PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor, DWORD dRawOffset, const PIMAGE_SECTION_HEADER pImageImportSection) {
  2146.     OUTPUT("\n[+] IMPORTED DLL\n");
  2147.     while (pImageImportDescriptor->Name != 0) {
  2148.         OUTPUT("\n\tDLL NAME : %s\n", (wchar_t*)(dRawOffset + (pImageImportDescriptor->Name - pImageImportSection->VirtualAddress)));
  2149.         if (pImageImportDescriptor->OriginalFirstThunk == 0) {
  2150.             ++pImageImportDescriptor;
  2151.             continue;
  2152.         }
  2153.         auto pOriginalFirstThunk = reinterpret_cast<PIMAGE_THUNK_DATA32>(dRawOffset + (pImageImportDescriptor->OriginalFirstThunk - pImageImportSection->VirtualAddress));
  2154.         while (pOriginalFirstThunk->u1.AddressOfData != 0) {
  2155.             const auto pImageImportByName = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(dRawOffset + (pOriginalFirstThunk->u1.AddressOfData - pImageImportSection->VirtualAddress));
  2156.             if (pImageImportByName) {
  2157.                 OUTPUT("\t\tFunction: %s\n", (char*)pImageImportByName->Name);
  2158.             }
  2159.             pOriginalFirstThunk++;
  2160.         }
  2161.         pImageImportDescriptor++;
  2162.     }
  2163. }
  2164.  
  2165. void GetImports64(PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor, DWORD dRawOffset, const PIMAGE_SECTION_HEADER pImageImportSection) {
  2166.     OUTPUT("\n[+] IMPORTED DLL\n");
  2167.     while (pImageImportDescriptor->Name != 0) {
  2168.         OUTPUT("\n\tDLL NAME : %s\n", (wchar_t*)(dRawOffset + (pImageImportDescriptor->Name - pImageImportSection->VirtualAddress)));
  2169.         if (pImageImportDescriptor->OriginalFirstThunk == 0) {
  2170.             ++pImageImportDescriptor;
  2171.             continue;
  2172.         }
  2173.         auto pOriginalFirstThunk = reinterpret_cast<PIMAGE_THUNK_DATA64>(dRawOffset + (pImageImportDescriptor->OriginalFirstThunk - pImageImportSection->VirtualAddress));
  2174.         while (pOriginalFirstThunk->u1.AddressOfData != 0) {
  2175.             const auto pImageImportByName = reinterpret_cast<PIMAGE_IMPORT_BY_NAME>(dRawOffset + (pOriginalFirstThunk->u1.AddressOfData - pImageImportSection->VirtualAddress));
  2176.             if (pImageImportByName) {
  2177.                 OUTPUT("\t\tFunction: %s\n", (char*)pImageImportByName->Name);
  2178.             }
  2179.             pOriginalFirstThunk++;
  2180.         }
  2181.         pImageImportDescriptor++;
  2182.     }
  2183. }
  2184. //use above ^^ ALWAYS
  2185. */
  2186.  
  2187.  
  2188. /*
  2189. // older-orig-deprecated vv
  2190. // Main PE Analysis function
  2191. void AnalyzePEFile(const wchar_t* filePathW)
  2192. {
  2193.     //WCHAR filePathW[MAX_PATH];
  2194.     //MultiByteToWideChar(CP_ACP, 0, filePathA, -1, filePathW, MAX_PATH);
  2195.     OUTPUT("[+] Starting PE Analysis for: %s\n\n", filePathW);
  2196.     //AppendToOutput(L"[+] Starting PE Analysis for: %ls\n\n", filePathW);
  2197.  
  2198.     // Get file content
  2199.     LPVOID lpFileContent = GetFileContent(filePathW);
  2200.     if (!lpFileContent)
  2201.     {
  2202.         OUTPUT("[-] Failed to read file content!\n");
  2203.         return;
  2204.     }
  2205.  
  2206.     // Get DOS header
  2207.     const auto pImageDosHeader = static_cast<PIMAGE_DOS_HEADER>(lpFileContent);
  2208.     if (pImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
  2209.     {
  2210.         OUTPUT("[-] Invalid DOS signature!\n");
  2211.         HeapFree(GetProcessHeap(), 0, lpFileContent);
  2212.         return;
  2213.     }
  2214.  
  2215.     // Get NT headers
  2216.     const auto pImageNtHeaders = reinterpret_cast<PIMAGE_NT_HEADERS>((DWORD_PTR)lpFileContent + pImageDosHeader->e_lfanew);
  2217.     if (pImageNtHeaders->Signature != IMAGE_NT_SIGNATURE)
  2218.     {
  2219.         OUTPUT("[-] Invalid NT signature!\n");
  2220.         HeapFree(GetProcessHeap(), 0, lpFileContent);
  2221.         return;
  2222.     }
  2223.  
  2224.     // Display File Header information
  2225.     OUTPUT("[+] PE FILE HEADER\n");
  2226.     OUTPUT("\tMachine : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.Machine);
  2227.     OUTPUT("\tNumberOfSections : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.NumberOfSections);
  2228.     OUTPUT("\tTimeDateStamp : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.TimeDateStamp);
  2229.     OUTPUT("\tPointerToSymbolTable : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.PointerToSymbolTable);
  2230.     OUTPUT("\tNumberOfSymbols : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.NumberOfSymbols);
  2231.     OUTPUT("\tSizeOfOptionalHeader : 0x%X\n", (uintptr_t)pImageNtHeaders->FileHeader.SizeOfOptionalHeader);
  2232.     OUTPUT("\tCharacteristics : 0x%X %s\n\n",
  2233.         (uintptr_t)pImageNtHeaders->FileHeader.Characteristics,
  2234.         GetImageCharacteristics(pImageNtHeaders->FileHeader.Characteristics));
  2235.  
  2236.     // Display Optional Header information
  2237.     OUTPUT("[+] PE OPTIONAL HEADER\n");
  2238.     OUTPUT("\tMagic : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.Magic);
  2239.     OUTPUT("\tAddressOfEntryPoint : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.AddressOfEntryPoint);
  2240.     OUTPUT("\tImageBase : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.ImageBase);
  2241.     OUTPUT("\tSectionAlignment : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SectionAlignment);
  2242.     OUTPUT("\tFileAlignment : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.FileAlignment);
  2243.     OUTPUT("\tMajorOperatingSystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MajorOperatingSystemVersion);
  2244.     OUTPUT("\tMinorOperatingSystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MinorOperatingSystemVersion);
  2245.     OUTPUT("\tMajorImageVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MajorImageVersion);
  2246.     OUTPUT("\tMinorImageVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MinorImageVersion);
  2247.     OUTPUT("\tMajorSubsystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MajorSubsystemVersion);
  2248.     OUTPUT("\tMinorSubsystemVersion : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.MinorSubsystemVersion);
  2249.     OUTPUT("\tWin32VersionValue : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.Win32VersionValue);
  2250.     OUTPUT("\tSizeOfImage : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfImage);
  2251.     OUTPUT("\tSizeOfHeaders : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfHeaders);
  2252.     OUTPUT("\tCheckSum : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.CheckSum);
  2253.     OUTPUT("\tSubsystem : 0x%X %s\n",
  2254.         (uintptr_t)pImageNtHeaders->OptionalHeader.Subsystem,
  2255.         GetSubsystem(pImageNtHeaders->OptionalHeader.Subsystem));
  2256.     OUTPUT("\tDllCharacteristics : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.DllCharacteristics);
  2257.     OUTPUT("\tSizeOfStackReserve : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfStackReserve);
  2258.     OUTPUT("\tSizeOfStackCommit : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfStackCommit);
  2259.     OUTPUT("\tSizeOfHeapReserve : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfHeapReserve);
  2260.     OUTPUT("\tSizeOfHeapCommit : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.SizeOfHeapCommit);
  2261.     OUTPUT("\tLoaderFlags : 0x%X\n", (uintptr_t)pImageNtHeaders->OptionalHeader.LoaderFlags);
  2262.     OUTPUT("\tNumberOfRvaAndSizes : 0x%X\n\n", (uintptr_t)pImageNtHeaders->OptionalHeader.NumberOfRvaAndSizes);
  2263.  
  2264.     // Get Data Directories
  2265.     GetDataDirectories(&pImageNtHeaders->OptionalHeader.DataDirectory[0]);
  2266.  
  2267.     // Get the import section
  2268.     const auto pImageSectionHeader = reinterpret_cast<PIMAGE_SECTION_HEADER>(
  2269.         (DWORD_PTR)pImageNtHeaders + sizeof(IMAGE_NT_HEADERS));
  2270.  
  2271.     const auto pImageImportSection = GetSections(
  2272.         pImageSectionHeader,
  2273.         pImageNtHeaders->FileHeader.NumberOfSections,
  2274.         pImageNtHeaders->OptionalHeader.DataDirectory[1].VirtualAddress);
  2275.  
  2276.     if (!pImageImportSection)
  2277.     {
  2278.         OUTPUT("[-] Error: Could not find import section!\n");
  2279.         HeapFree(GetProcessHeap(), 0, lpFileContent);
  2280.         return;
  2281.     }
  2282.  
  2283.     // Get imports based on architecture
  2284.     const auto pImageImportDescriptor = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(
  2285.         (DWORD_PTR)lpFileContent + pImageImportSection->PointerToRawData);
  2286.  
  2287.     if (pImageNtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_I386)
  2288.     {
  2289.         GetImports32(
  2290.             pImageImportDescriptor,
  2291.             (DWORD)lpFileContent + pImageImportSection->PointerToRawData,
  2292.             pImageImportSection);
  2293.     }
  2294.     else if (pImageNtHeaders->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
  2295.     {
  2296.         GetImports64(
  2297.             pImageImportDescriptor,
  2298.             (DWORD)lpFileContent + pImageImportSection->PointerToRawData,
  2299.             pImageImportSection);
  2300.     }
  2301.     else
  2302.     {
  2303.         OUTPUT("[-] Unsupported architecture!\n");
  2304.     }
  2305.  
  2306.     // Cleanup
  2307.     HeapFree(GetProcessHeap(), 0, lpFileContent);
  2308.  
  2309.     // Update the GUI with the analysis results
  2310.     UpdateEditControl();
  2311. }
  2312.  
  2313. void GetDataDirectories(PIMAGE_DATA_DIRECTORY pImageDataDirectory)
  2314. {
  2315.     OUTPUT("[+] PE DATA DIRECTORIES\n");
  2316.     for (int i = 0; i < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; ++i, ++pImageDataDirectory)
  2317.     {
  2318.         if (pImageDataDirectory->VirtualAddress == 0)
  2319.             continue;
  2320.  
  2321.         OUTPUT("\tDataDirectory (%s) VirtualAddress : 0x%X\n",
  2322.             GetDataDirectoryName(i),
  2323.             (uintptr_t)pImageDataDirectory->VirtualAddress);
  2324.         OUTPUT("\tDataDirectory (%s) Size : 0x%X\n\n",
  2325.             GetDataDirectoryName(i),
  2326.             (uintptr_t)pImageDataDirectory->Size);
  2327.     }
  2328. }
  2329.  
  2330. PIMAGE_SECTION_HEADER GetSections(const PIMAGE_SECTION_HEADER pImageSectionHeader,
  2331.     int NumberOfSections, DWORD dImportAddress)
  2332. {
  2333.     PIMAGE_SECTION_HEADER pImageImportHeader = nullptr;
  2334.  
  2335.     OUTPUT("\n[+] PE IMAGE SECTIONS\n");
  2336.  
  2337.     for (int i = 0; i < NumberOfSections; ++i)
  2338.     {
  2339.         const auto pCurrentSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD_PTR)pImageSectionHeader +
  2340.             i * sizeof(IMAGE_SECTION_HEADER));
  2341.  
  2342.         OUTPUT("\n\tSECTION : %s\n", (wchar_t*)pCurrentSectionHeader->Name);
  2343.         OUTPUT("\t\tMisc (PhysicalAddress) : 0x%X\n",
  2344.             (uintptr_t)pCurrentSectionHeader->Misc.PhysicalAddress);
  2345.         OUTPUT("\t\tMisc (VirtualSize) : 0x%X\n",
  2346.             (uintptr_t)pCurrentSectionHeader->Misc.VirtualSize);
  2347.         OUTPUT("\t\tVirtualAddress : 0x%X\n",
  2348.             (uintptr_t)pCurrentSectionHeader->VirtualAddress);
  2349.         OUTPUT("\t\tSizeOfRawData : 0x%X\n",
  2350.             (uintptr_t)pCurrentSectionHeader->SizeOfRawData);
  2351.         OUTPUT("\t\tPointerToRawData : 0x%X\n",
  2352.             (uintptr_t)pCurrentSectionHeader->PointerToRawData);
  2353.         OUTPUT("\t\tPointerToRelocations : 0x%X\n",
  2354.             (uintptr_t)pCurrentSectionHeader->PointerToRelocations);
  2355.         OUTPUT("\t\tPointerToLinenumbers : 0x%X\n",
  2356.             (uintptr_t)pCurrentSectionHeader->PointerToLinenumbers);
  2357.         OUTPUT("\t\tNumberOfRelocations : 0x%X\n",
  2358.             (uintptr_t)pCurrentSectionHeader->NumberOfRelocations);
  2359.         OUTPUT("\t\tNumberOfLinenumbers : 0x%X\n",
  2360.             (uintptr_t)pCurrentSectionHeader->NumberOfLinenumbers);
  2361.         OUTPUT("\t\tCharacteristics : 0x%X %s\n",
  2362.             (uintptr_t)pCurrentSectionHeader->Characteristics,
  2363.             GetSectionProtection(pCurrentSectionHeader->Characteristics));
  2364.  
  2365.         if (dImportAddress >= pCurrentSectionHeader->VirtualAddress &&
  2366.             dImportAddress < pCurrentSectionHeader->VirtualAddress +
  2367.             pCurrentSectionHeader->Misc.VirtualSize)
  2368.         {
  2369.             pImageImportHeader = pCurrentSectionHeader;
  2370.         }
  2371.     }
  2372.  
  2373.     return pImageImportHeader;
  2374. }
  2375. void GetImports32(PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor,
  2376.     DWORD dRawOffset, const PIMAGE_SECTION_HEADER pImageImportSection)
  2377. {
  2378.     OUTPUT("\n[+] IMPORTED DLL\n");
  2379.  
  2380.     while (pImageImportDescriptor->Name != 0)
  2381.     {
  2382.         OUTPUT("\n\tDLL NAME : %s\n",
  2383.             (wchar_t*)(dRawOffset + (pImageImportDescriptor->Name - pImageImportSection->VirtualAddress)));
  2384.         OUTPUT("\tCharacteristics : 0x%X\n",
  2385.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->Characteristics - pImageImportSection->VirtualAddress)));
  2386.         OUTPUT("\tOriginalFirstThunk : 0x%X\n",
  2387.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->OriginalFirstThunk - pImageImportSection->VirtualAddress)));
  2388.         OUTPUT("\tTimeDateStamp : 0x%X\n",
  2389.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->TimeDateStamp - pImageImportSection->VirtualAddress)));
  2390.         OUTPUT("\tForwarderChain : 0x%X\n",
  2391.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->ForwarderChain - pImageImportSection->VirtualAddress)));
  2392.         OUTPUT("\tFirstThunk : 0x%X\n",
  2393.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->FirstThunk - pImageImportSection->VirtualAddress)));
  2394.  
  2395.         if (pImageImportDescriptor->OriginalFirstThunk == 0)
  2396.         {
  2397.             ++pImageImportDescriptor;
  2398.             continue;
  2399.         }
  2400.  
  2401.         auto pOriginalFirstThrunk = (PIMAGE_THUNK_DATA32)(dRawOffset +
  2402.             (pImageImportDescriptor->OriginalFirstThunk - pImageImportSection->VirtualAddress));
  2403.  
  2404.         OUTPUT("\n\tImported Functions : \n\n");
  2405.  
  2406.         while (pOriginalFirstThrunk->u1.AddressOfData != 0)
  2407.         {
  2408.             if (pOriginalFirstThrunk->u1.AddressOfData >= IMAGE_ORDINAL_FLAG32)
  2409.             {
  2410.                 ++pOriginalFirstThrunk;
  2411.                 continue;
  2412.             }
  2413.  
  2414.             const auto pImageImportByName = (PIMAGE_IMPORT_BY_NAME)(dRawOffset +
  2415.                 (pOriginalFirstThrunk->u1.AddressOfData - pImageImportSection->VirtualAddress));
  2416.  
  2417.             if (pImageImportByName == nullptr)
  2418.             {
  2419.                 ++pOriginalFirstThrunk;
  2420.                 continue;
  2421.             }
  2422.  
  2423.             if (pOriginalFirstThrunk->u1.Ordinal & IMAGE_ORDINAL_FLAG32)
  2424.             {
  2425.                 OUTPUT("\t\t0x%X (Ordinal) : %s\n",
  2426.                     (uintptr_t)pOriginalFirstThrunk->u1.AddressOfData,
  2427.                     (wchar_t*)((DWORD_PTR)dRawOffset + (pImageImportByName->Name - pImageImportSection->VirtualAddress)));
  2428.             }
  2429.             else
  2430.             {
  2431.                 OUTPUT("\t\t%s\n",
  2432.                     (wchar_t*)((DWORD_PTR)dRawOffset + (pImageImportByName->Name - pImageImportSection->VirtualAddress)));
  2433.             }
  2434.  
  2435.             ++pOriginalFirstThrunk;
  2436.         }
  2437.  
  2438.         ++pImageImportDescriptor;
  2439.     }
  2440. }
  2441.  
  2442. void GetImports64(PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor,
  2443.     DWORD dRawOffset, const PIMAGE_SECTION_HEADER pImageImportSection)
  2444. {
  2445.     OUTPUT("\n[+] IMPORTED DLL\n");
  2446.  
  2447.     while (pImageImportDescriptor->Name != 0)
  2448.     {
  2449.         OUTPUT("\n\tDLL NAME : %s\n",
  2450.             (wchar_t*)(dRawOffset + (pImageImportDescriptor->Name - pImageImportSection->VirtualAddress)));
  2451.         OUTPUT("\tCharacteristics : 0x%X\n",
  2452.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->Characteristics - pImageImportSection->VirtualAddress)));
  2453.         OUTPUT("\tOriginalFirstThunk : 0x%X\n",
  2454.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->OriginalFirstThunk - pImageImportSection->VirtualAddress)));
  2455.         OUTPUT("\tTimeDateStamp : 0x%X\n",
  2456.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->TimeDateStamp - pImageImportSection->VirtualAddress)));
  2457.         OUTPUT("\tForwarderChain : 0x%X\n",
  2458.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->ForwarderChain - pImageImportSection->VirtualAddress)));
  2459.         OUTPUT("\tFirstThunk : 0x%X\n",
  2460.             (uintptr_t)(dRawOffset + (pImageImportDescriptor->FirstThunk - pImageImportSection->VirtualAddress)));
  2461.  
  2462.         if (pImageImportDescriptor->OriginalFirstThunk == 0)
  2463.         {
  2464.             ++pImageImportDescriptor;
  2465.             continue;
  2466.         }
  2467.  
  2468.         auto pOriginalFirstThrunk = (PIMAGE_THUNK_DATA64)(dRawOffset +
  2469.             (pImageImportDescriptor->OriginalFirstThunk - pImageImportSection->VirtualAddress));
  2470.  
  2471.         OUTPUT("\n\tImported Functions : \n\n");
  2472.  
  2473.         while (pOriginalFirstThrunk->u1.AddressOfData != 0)
  2474.         {
  2475.             if (pOriginalFirstThrunk->u1.AddressOfData >= IMAGE_ORDINAL_FLAG64)
  2476.             {
  2477.                 ++pOriginalFirstThrunk;
  2478.                 continue;
  2479.             }
  2480.  
  2481.             const auto pImageImportByName = (PIMAGE_IMPORT_BY_NAME)((DWORD_PTR)dRawOffset +
  2482.                 (pOriginalFirstThrunk->u1.AddressOfData - pImageImportSection->VirtualAddress));
  2483.  
  2484.             if (pImageImportByName == nullptr)
  2485.             {
  2486.                 ++pOriginalFirstThrunk;
  2487.                 continue;
  2488.             }
  2489.  
  2490.             if (pOriginalFirstThrunk->u1.Ordinal & IMAGE_ORDINAL_FLAG64)
  2491.             {
  2492.                 OUTPUT("\t\t0x%llX (Ordinal) : %s\n",
  2493.                     pOriginalFirstThrunk->u1.AddressOfData,
  2494.                     (wchar_t*)((DWORD_PTR)dRawOffset + (pImageImportByName->Name - pImageImportSection->VirtualAddress)));
  2495.             }
  2496.             else
  2497.             {
  2498.                 OUTPUT("\t\t%s\n",
  2499.                     (wchar_t*)((DWORD_PTR)dRawOffset + (pImageImportByName->Name - pImageImportSection->VirtualAddress)));
  2500.             }
  2501.  
  2502.             ++pOriginalFirstThrunk;
  2503.         }
  2504.  
  2505.         ++pImageImportDescriptor;
  2506.     }
  2507. }
  2508. // older-orig-deprecated ^^
  2509. */
  2510.  
  2511. //filePathW
  2512. //lpFilePath
  2513. HANDLE GetFileContent(const wchar_t* lpFilePath) {
  2514.     HANDLE hFile = CreateFileW(lpFilePath, GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr);
  2515.     if (hFile == INVALID_HANDLE_VALUE) return nullptr;
  2516.     DWORD fileSize = GetFileSize(hFile, nullptr);
  2517.     auto lpFileContent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, fileSize);
  2518.     DWORD bytesRead;
  2519.     ReadFile(hFile, lpFileContent, fileSize, &bytesRead, nullptr);
  2520.     CloseHandle(hFile);
  2521.     return lpFileContent;
  2522. }
  2523.  
  2524. void UpdateEditControl() {
  2525.     SetWindowTextW(g_hEditControl, g_OutputText.str().c_str());
  2526.     SendMessage(g_hEditControl, EM_SETSEL, -1, -1);
  2527.     SendMessage(g_hEditControl, EM_SCROLLCARET, 0, 0);
  2528. }
Tags: #needs-twin-func-charfix
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!