[WIP] memory injector to intercept malloc() calls

Author: Gonzalo Diaz

src/tests/CMakeLists.txt

@@ -1,6 +1,10 @@
 find_package(Catch2 3 REQUIRED)
 find_path(CATCH_INCLUDE_DIR NAMES catch.hpp PATH_SUFFIXES catch2)
 
+# # Create a static library for the memory injector utility
+file(GLOB_RECURSE TOOLS_SOURCES "tools/*.cpp")
+add_library(memory_injector STATIC ${TOOLS_SOURCES})
+
 file(GLOB_RECURSE SOURCES "unit/lib/*.cpp")
 add_executable(unit-tests_combined ${SOURCES})
 
@@ -12,6 +16,14 @@ target_link_libraries(unit-tests_combined PRIVATE Catch2::Catch2WithMain)
 # Functionality to test.
 target_link_libraries(unit-tests_combined PRIVATE exercises)
 
+target_link_libraries(unit-tests_combined PRIVATE memory_injector)
+
+# GNU ld (Linux) needs --wrap=malloc to redirect calls to __wrap_malloc.
+# macOS uses dyld interposition instead, which requires no linker flag.
+if(NOT APPLE)
+  target_link_options(memory_injector INTERFACE "-Wl,--wrap=malloc")
+endif()
+
 list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
 include(CTest)
 include(Catch)

src/tests/tools/memory_injector.cpp

@@ -0,0 +1,91 @@
+#include "memory_injector.hpp"
+#include <cstdlib>
+
+// Hidden state variables local to this translation unit
+static bool force_immediate_error = false;
+static int allocation_counter = 0;
+static int target_fault_allocation = -1;
+
+namespace MemoryInjector {
+// cppcheck-suppress unusedFunction
+void enable_oom_fault() {
+  force_immediate_error = true;
+  target_fault_allocation = -1;
+}
+
+// cppcheck-suppress unusedFunction
+void disable_fault() {
+  force_immediate_error = false;
+  allocation_counter = 0;
+  target_fault_allocation = -1;
+}
+
+// cppcheck-suppress unusedFunction
+void fail_on_allocation_number(int n) {
+  force_immediate_error = false;
+  allocation_counter = 0;
+  target_fault_allocation = n;
+}
+} // namespace MemoryInjector
+
+// ── Platform-specific interception ──────────────────────────────────────────
+
+#if defined(__APPLE__)
+// macOS: use dyld interposition. No extra linker flags are required.
+// The DYLD_INTERPOSE macro creates an entry in the __DATA,__interpose section
+// that dyld uses to redirect calls to `malloc` at load time.
+
+#include <malloc/malloc.h>
+
+static void *my_malloc(size_t size) {
+  // Case 1: Forced immediate out-of-memory error
+  if (force_immediate_error) {
+    return nullptr;
+  }
+
+  // Case 2: Error on the Nth allocation attempt
+  if (target_fault_allocation != -1) {
+    allocation_counter++;
+    if (allocation_counter == target_fault_allocation) {
+      return nullptr;
+    }
+  }
+
+  // Fall through to the real malloc (resolved via the interpose table)
+  return malloc(size);
+}
+
+#define DYLD_INTERPOSE(_replacement, _replacee)                                \
+  __attribute__((used)) static struct {                                        \
+    const void *replacement;                                                   \
+    const void *replacee;                                                      \
+  } _interpose_##_replacee __attribute__((section("__DATA,__interpose"))) = {  \
+      (const void *)(_replacement), (const void *)(_replacee)}
+
+DYLD_INTERPOSE(my_malloc, malloc);
+
+#else
+// Linux / GNU ld: use the --wrap=malloc linker flag.
+// The linker renames every call to `malloc` → `__wrap_malloc` and makes the
+// original symbol available as `__real_malloc`.
+
+extern "C" void *__real_malloc(size_t);
+
+extern "C" void *__wrap_malloc(size_t size) {
+  // Case 1: Forced immediate out-of-memory error
+  if (force_immediate_error) {
+    return nullptr;
+  }
+
+  // Case 2: Error on the Nth allocation attempt
+  if (target_fault_allocation != -1) {
+    allocation_counter++; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
+    if (allocation_counter == target_fault_allocation) {
+      return nullptr;
+    }
+  }
+
+  // If it shouldn't fail, call the real system malloc
+  return __real_malloc(size);
+}
+#endif

src/tests/tools/memory_injector.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include <cstddef>
+
+namespace MemoryInjector {
+// Triggers an immediate malloc failure
+void enable_oom_fault();
+
+// Disables the simulator (malloc goes back to normal behavior)
+void disable_fault();
+
+// Advanced: Makes malloc succeed N times and fail on the next allocation
+void fail_on_allocation_number(int n);
+} // namespace MemoryInjector