avoid saving files on disk

tests/general/mem_fd_helper.hpp

@@ -0,0 +1,116 @@
+#pragma once
+// Linux-only helper: creates an anonymous in-memory file via memfd_create.
+// Usage:
+//   MemFdFile f = MemFdFile::create(data.data(), data.size());
+//   // use f.path() as a std::filesystem::path
+//   // fd is automatically closed on destruction
+#include <cstdint>
+#include <cstring>
+#include <filesystem>
+#include <format>
+#include <string>
+#include <vector>
+#include <unistd.h>
+#include <sys/mman.h>
+
+class MemFdFile
+{
+public:
+    MemFdFile() = default;
+
+    ~MemFdFile()
+    {
+        if (m_fd >= 0)
+            ::close(m_fd);
+    }
+
+    MemFdFile(const MemFdFile&) = delete;
+    MemFdFile& operator=(const MemFdFile&) = delete;
+
+    MemFdFile(MemFdFile&& o) noexcept : m_fd(o.m_fd), m_path(std::move(o.m_path))
+    {
+        o.m_fd = -1;
+    }
+
+    [[nodiscard]] bool valid() const { return m_fd >= 0; }
+
+    [[nodiscard]] std::filesystem::path path() const { return m_path; }
+
+    static MemFdFile create(const std::uint8_t* data, std::size_t size)
+    {
+        MemFdFile f;
+        f.m_fd = static_cast<int>(::memfd_create("test_bin", 0));
+        if (f.m_fd < 0)
+            return f;
+
+        f.m_path = std::format("/proc/self/fd/{}", f.m_fd);
+
+        const auto* ptr = reinterpret_cast<const char*>(data);
+        std::size_t written = 0;
+        while (written < size)
+        {
+            const auto n = ::write(f.m_fd, ptr + written, size - written);
+            if (n <= 0)
+            {
+                ::close(f.m_fd);
+                f.m_fd = -1;
+                return f;
+            }
+            written += static_cast<std::size_t>(n);
+        }
+        return f;
+    }
+
+    static MemFdFile create(const std::vector<std::uint8_t>& data)
+    {
+        return create(data.data(), data.size());
+    }
+
+private:
+    int m_fd = -1;
+    std::string m_path;
+};
+
+// Build a minimal PE binary in-memory with a single .text section.
+// Layout (all offsets compile-time):
+//   0x00: DOS header (64 B)   0x40: pad   0x80: NT sig   0x84: FileHeader (20 B)
+//   0x98: OptionalHeader (0xF0 B)   0x188: SectionHeader (44 B)   0x1B4: section data
+inline std::vector<std::uint8_t> build_minimal_pe(const std::vector<std::uint8_t>& section_bytes)
+{
+    constexpr std::uint32_t e_lfanew  = 0x80u;
+    constexpr std::uint16_t size_opt  = 0xF0u;
+    constexpr std::size_t   nt_off    = e_lfanew;
+    constexpr std::size_t   fh_off    = nt_off + 4;
+    constexpr std::size_t   oh_off    = fh_off + 20;
+    constexpr std::size_t   sh_off    = oh_off + size_opt;
+    constexpr std::size_t   data_off  = sh_off + 44;
+
+    std::vector<std::uint8_t> buf(data_off + section_bytes.size(), 0u);
+
+    buf[0] = 'M'; buf[1] = 'Z';
+    std::memcpy(buf.data() + 0x3Cu, &e_lfanew, 4);
+
+    buf[nt_off] = 'P'; buf[nt_off + 1] = 'E';
+
+    const std::uint16_t machine = 0x8664u, num_sections = 1u;
+    std::memcpy(buf.data() + fh_off,      &machine,      2);
+    std::memcpy(buf.data() + fh_off + 2,  &num_sections, 2);
+    std::memcpy(buf.data() + fh_off + 16, &size_opt,     2);
+
+    const std::uint16_t magic = 0x20Bu;
+    std::memcpy(buf.data() + oh_off, &magic, 2);
+
+    const char name[8] = {'.','t','e','x','t',0,0,0};
+    std::memcpy(buf.data() + sh_off, name, 8);
+
+    const auto vsize = static_cast<std::uint32_t>(section_bytes.size());
+    const std::uint32_t vaddr = 0x1000u;
+    const auto ptr_raw = static_cast<std::uint32_t>(data_off);
+    std::memcpy(buf.data() + sh_off + 8,  &vsize,   4);
+    std::memcpy(buf.data() + sh_off + 12, &vaddr,   4);
+    std::memcpy(buf.data() + sh_off + 16, &vsize,   4);
+    std::memcpy(buf.data() + sh_off + 20, &ptr_raw, 4);
+
+    std::memcpy(buf.data() + data_off, section_bytes.data(), section_bytes.size());
+    return buf;
+}