Updates PE header structure for x64

INSTALL.md

@@ -59,7 +59,7 @@ target("...")
    cmake --preset windows-release -S .
    cmake --build cmake-build/build/windows-release --target omath -j 6
    ```
-   Use **\<platform\>-\<build configuration\>** preset to build siutable version for yourself. Like **windows-release** or **linux-release**.
+   Use **\<platform\>-\<build configuration\>** preset to build suitable version for yourself. Like **windows-release** or **linux-release**.
 
     | Platform Name | Build Config  |
     |---------------|---------------|

docs/index.md

@@ -0,0 +1,17 @@
+# Welcome to MkDocs
+
+For full documentation visit [mkdocs.org](https://www.mkdocs.org).
+
+## Commands
+
+* `mkdocs new [dir-name]` - Create a new project.
+* `mkdocs serve` - Start the live-reloading docs server.
+* `mkdocs build` - Build the documentation site.
+* `mkdocs -h` - Print help message and exit.
+
+## Project layout
+
+    mkdocs.yml    # The configuration file.
+    docs/
+        index.md  # The documentation homepage.
+        ...       # Other markdown pages, images and other files.

include/omath/rev_eng/internal_rev_object.hpp

@@ -26,7 +26,11 @@ namespace omath::rev_eng
         template<std::size_t id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list)
         {
+#ifdef _MSC_VER
             using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+#else
+            using VirtualMethodType = ReturnType(__fastcall*)(void*, decltype(arg_list)...);
+#endif
             return (*reinterpret_cast<VirtualMethodType**>(this))[id](this, arg_list...);
         }
     };

include/omath/system/pe/data_directory.hpp

@@ -0,0 +1,5 @@
+//
+// Created by Vlad on 10/8/2025.
+//
+
+#pragma once

include/omath/system/pe/dos_header.hpp

@@ -0,0 +1,32 @@
+//
+// Created by Vlad on 10/7/2025.
+//
+
+#pragma once
+#include <cstdint>
+
+namespace omath::system::pe
+{
+    struct DosHeader final
+    {
+        std::uint16_t e_magic;
+        std::uint16_t e_cblp;
+        std::uint16_t e_cp;
+        std::uint16_t e_crlc;
+        std::uint16_t e_cparhdr;
+        std::uint16_t e_minalloc;
+        std::uint16_t e_maxalloc;
+        std::uint16_t e_ss;
+        std::uint16_t e_sp;
+        std::uint16_t e_csum;
+        std::uint16_t e_ip;
+        std::uint16_t e_cs;
+        std::uint16_t e_lfarlc;
+        std::uint16_t e_ovno;
+        std::uint16_t e_res[4];
+        std::uint16_t e_oemid;
+        std::uint16_t e_oeminfo;
+        std::uint16_t e_res2[10];
+        std::uint32_t e_lfanew;
+    };
+}

include/omath/system/pe/file_header.hpp

@@ -0,0 +1,56 @@
+//
+// Created by Vlad on 10/7/2025.
+//
+
+#pragma once
+#include <cstdint>
+
+namespace omath::system::pe
+{
+    enum class MachineId : std::uint16_t
+    {
+        UNKNOWN = 0x0000,
+        TARGET_HOST = 0x0001, // Useful for indicating we want to interact with the host and not a WoW guest.
+        I386 = 0x014C, // Intel 386.
+        R3000 = 0x0162, // MIPS little-endian, 0x160 big-endian
+        R4000 = 0x0166, // MIPS little-endian
+        R10000 = 0x0168, // MIPS little-endian
+        WCEMIPSV2 = 0x0169, // MIPS little-endian WCE v2
+        ALPHA = 0x0184, // Alpha_AXP
+        SH3 = 0x01A2, // SH3 little-endian
+        SH3DSP = 0x01A3,
+        SH3E = 0x01A4, // SH3E little-endian
+        SH4 = 0x01A6, // SH4 little-endian
+        SH5 = 0x01A8, // SH5
+        ARM = 0x01C0, // ARM Little-Endian
+        THUMB = 0x01C2, // ARM Thumb/Thumb-2 Little-Endian
+        ARMNT = 0x01C4, // ARM Thumb-2 Little-Endian
+        AM33 = 0x01D3,
+        POWERPC = 0x01F0, // IBM PowerPC Little-Endian
+        POWERPCP = 0x01F1,
+        IA64 = 0x0200, // Intel 64
+        MIPS16 = 0x0266, // MIPS
+        ALPHA64 = 0x0284, // ALPHA64
+        MIPSFPU = 0x0366, // MIPS
+        MIPSFPU16 = 0x0466, // MIPS
+        AXP64 = 0x0284,
+        TRICORE = 0x0520, // Infineon
+        CEF = 0x0CEF,
+        EBC = 0x0EBC, // EFI Byte Code
+        AMD64 = 0x8664, // AMD64 (K8)
+        M32R = 0x9041, // M32R little-endian
+        ARM64 = 0xAA64, // ARM64 Little-Endian
+        CEE = 0xC0EE,
+    };
+
+    struct FileHeader final
+    {
+        MachineId machine;
+        uint16_t num_sections;
+        uint32_t timedate_stamp;
+        uint32_t ptr_symbols;
+        uint32_t num_symbols;
+        uint16_t size_optional_header;
+        std::uint16_t characteristics;
+    };
+}

include/omath/system/pe/image_nt_headers.hpp

@@ -0,0 +1,23 @@
+//
+// Created by Vlad on 10/9/2025.
+//
+
+#pragma once
+#include "file_header.hpp"
+#include "optional_header.hpp"
+
+namespace omath::system::pe
+{
+    enum class NtArchitecture
+    {
+        x32_bit,
+        x64_bit,
+    };
+    template<NtArchitecture architecture>
+    struct ImageNtHeaders final
+    {
+        std::uint32_t signature;
+        FileHeader file_header;
+        OptionalHeader<architecture == NtArchitecture::x64_bit> optional_header;
+    };
+} // namespace omath::system::pe

include/omath/system/pe/optional_header.hpp

@@ -0,0 +1,118 @@
+//
+// Created by Vlad on 10/8/2025.
+//
+#pragma once
+#include <cstdint>
+
+namespace omath::system::pe
+{
+    static constexpr std::uint16_t opt_hdr32_magic = 0x010B;
+    static constexpr std::uint16_t opt_hdr64_magic = 0x020B;
+    enum class SubsystemId : std::uint16_t
+    {
+        unknown = 0x0000,
+        native = 0x0001,
+        windows_gui = 0x0002,
+        windows_cui = 0x0003,
+        os2_cui = 0x0005,
+        posix_cui = 0x0007,
+        native_windows = 0x0008,
+        windows_ce_gui = 0x0009,
+        efi_application = 0x000A,
+        efi_boot_service_driver = 0x000B,
+        efi_runtime_driver = 0x000C,
+        efi_rom = 0x000D,
+        xbox = 0x000E,
+        windows_boot_application = 0x0010,
+        xbox_code_catalog = 0x0011,
+    };
+
+    struct DataDirectory final
+    {
+        std::uint32_t rva;
+        std::uint32_t size;
+    };
+    struct OptionalHeaderX64 final
+    {
+        // Standard fields.
+        std::uint16_t magic;
+        std::uint16_t linker_version;
+
+        std::uint32_t size_code;
+        std::uint32_t size_init_data;
+        std::uint32_t size_uninit_data;
+
+        std::uint32_t entry_point;
+        std::uint32_t base_of_code;
+
+        // NT additional fields.
+        std::uint64_t image_base;
+        std::uint32_t section_alignment;
+        std::uint32_t file_alignment;
+
+        std::uint32_t os_version;
+        std::uint32_t img_version;
+        std::uint32_t subsystem_version;
+        std::uint32_t win32_version_value;
+
+        std::uint32_t size_image;
+        std::uint32_t size_headers;
+
+        std::uint32_t checksum;
+        SubsystemId subsystem;
+        std::uint16_t characteristics;
+
+        std::uint64_t size_stack_reserve;
+        std::uint64_t size_stack_commit;
+        std::uint64_t size_heap_reserve;
+        std::uint64_t size_heap_commit;
+
+        std::uint32_t ldr_flags;
+
+        std::uint32_t num_data_directories;
+        DataDirectory data_directories[16];
+    };
+    struct OptionalHeaderX86 final
+    {
+        // Standard fields.
+        uint16_t magic;
+        uint16_t linker_version;
+
+        uint32_t size_code;
+        uint32_t size_init_data;
+        uint32_t size_uninit_data;
+
+        uint32_t entry_point;
+        uint32_t base_of_code;
+        uint32_t base_of_data;
+
+        // NT additional fields.
+        uint32_t image_base;
+        uint32_t section_alignment;
+        uint32_t file_alignment;
+
+        std::uint32_t os_version;
+        std::uint32_t img_version;
+        std::uint32_t subsystem_version;
+        uint32_t win32_version_value;
+
+        uint32_t size_image;
+        uint32_t size_headers;
+
+        uint32_t checksum;
+        SubsystemId subsystem;
+        std::uint16_t characteristics;
+
+        uint32_t size_stack_reserve;
+        uint32_t size_stack_commit;
+        uint32_t size_heap_reserve;
+        uint32_t size_heap_commit;
+
+        uint32_t ldr_flags;
+
+        uint32_t num_data_directories;
+        DataDirectory data_directories[16];
+    };
+    template<bool x64 = true>
+    using OptionalHeader = std::conditional_t<x64, OptionalHeaderX64, OptionalHeaderX86>;
+} // namespace omath::system::pe

include/omath/system/pe/section_header.hpp

@@ -0,0 +1,32 @@
+//
+// Created by Vlad on 10/8/2025.
+//
+
+#pragma once
+#include <cstdint>
+
+// Section header
+//
+namespace omath::system::pe
+{
+    struct SectionHeader final
+    {
+        char name[8];
+        union
+        {
+            std::uint32_t physical_address;
+            std::uint32_t virtual_size;
+        };
+        std::uint32_t virtual_address;
+
+        std::uint32_t size_raw_data;
+        std::uint32_t ptr_raw_data;
+
+        std::uint32_t ptr_relocs;
+        std::uint32_t ptr_line_numbers;
+        std::uint32_t  num_relocs;
+        std::uint32_t  num_line_numbers;
+
+        std::uint32_t characteristics;
+    };
+}

include/omath/utility/pattern_scan.hpp

@@ -26,7 +26,7 @@ namespace omath
     {
         INVALID_PATTERN_STRING
     };
-    class PatternScanner
+    class PatternScanner final
     {
         friend unit_test_pattern_scan_read_test_Test;
         friend unit_test_pattern_scan_corner_case_1_Test;
@@ -36,11 +36,11 @@ namespace omath
 
     public:
         [[nodiscard]]
-        static std::span<std::byte>::const_iterator scan_for_pattern(const std::span<std::byte>& range,
+        static std::span<std::byte>::iterator scan_for_pattern(const std::span<std::byte>& range,
                                                                      const std::string_view& pattern);
 
         [[nodiscard]]
-        static std::span<std::byte>::const_iterator scan_for_pattern(std::span<std::byte>&& range,
+        static std::span<std::byte>::iterator scan_for_pattern(std::span<std::byte>&& range,
                                                                      const std::string_view& pattern) = delete;
 
         template<class IteratorType>

include/omath/utility/pe_pattern_scan.hpp

@@ -0,0 +1,43 @@
+//
+// Created by Vlad on 10/7/2025.
+//
+
+#pragma once
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <string_view>
+#include <vector>
+namespace omath
+{
+    struct PeSectionScanResult
+    {
+        std::uint64_t virtual_base_addr;
+        std::uint64_t raw_base_addr;
+        std::ptrdiff_t target_offset;
+    };
+    class PePatternScanner final
+    {
+    private:
+        struct Section
+        {
+            std::uint64_t virtual_base_addr;
+            std::uint64_t raw_base_addr;
+            std::vector<std::byte> data;
+        };
+
+    public:
+        [[nodiscard]]
+        static std::optional<std::uintptr_t> scan_for_pattern_in_loaded_module(const std::string_view& module_name,
+                                                                               const std::string_view& pattern);
+
+        [[nodiscard]]
+        static std::optional<PeSectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
+                                 const std::string_view& target_section_name = ".text");
+
+        [[nodiscard]]
+        static std::optional<Section> extract_section_from_pe_file(const std::filesystem::path& path_to_file,
+                                                                   const std::string_view& section_name);
+    };
+} // namespace omath

mkdocs.yml

@@ -0,0 +1 @@
+site_name: My Docs