memory_protection.cpp

#include "shieldcore/memory_protection.hpp"

#include <atomic>
#include <thread>
#include <chrono>
#include <cstdio>

#if defined(_WIN32)
#include <windows.h>
#else
#include <unistd.h>
#endif

namespace shieldcore {

namespace {
std::atomic<bool> memoryCheckRunning{false};
std::thread* memoryCheckThread = nullptr;
}

bool verifyMemoryRegion(const void* address, std::size_t size, const char* /*regionName*/, std::string& error) {
  if (!address || size == 0) {
    error = "invalid memory region";
    return false;
  }

#if defined(_WIN32)
  MEMORY_BASIC_INFORMATION mbi;
  if (VirtualQuery(address, &mbi, sizeof(mbi)) == 0) {
    error = regionName;
    error += ": page protection check failed";
    return false;
  }

  if ((mbi.Protect & PAGE_EXECUTE_READWRITE) != 0) {
    error = regionName;
    error += ": suspicious page protection detected";
    return false;
  }
#else
  char maps_path[64] = {};
  snprintf(maps_path, sizeof(maps_path), "/proc/%d/maps", getpid());
  FILE* maps = fopen(maps_path, "r");
  if (!maps) {
    return true;
  }

  fclose(maps);
#endif

  return true;
}

bool enablePeriodicMemoryChecks(int intervalSeconds) {
  if (memoryCheckRunning.exchange(true)) {
    return false;
  }

  memoryCheckThread = new std::thread([intervalSeconds]() {
    while (memoryCheckRunning.load()) {
      std::this_thread::sleep_for(std::chrono::seconds(intervalSeconds));
    }
  });

  return true;
}

void stopMemoryChecks() {
  memoryCheckRunning.store(false);
  if (memoryCheckThread && memoryCheckThread->joinable()) {
    memoryCheckThread->join();
    delete memoryCheckThread;
    memoryCheckThread = nullptr;
  }
}

}  // namespace shieldcore