Initial commit

2026-07-21 22:30:10 +02:00
parent 21d2dd0460
commit 0380705e76
67 changed files with 7356 additions and 0 deletions
@@ -0,0 +1,57 @@
+## ADDED Requirements
+
+### Requirement: Three-tier execution model
+
+WhiteMagic SHALL provide three execution strategies selected by payload safety: `RemoteThreadExecutor` (via `CreateRemoteThread`), `MainThreadPump` (work marshalled onto the target's own thread), and `InProcessInvoker` (direct native-delegate calls when injected in-process).
+
+#### Scenario: strategies are distinct and selectable
+- **WHEN** a caller chooses an execution strategy
+- **THEN** each of remote-thread, main-thread-pump, and in-process MUST be individually invokable
+
+#### Scenario: main-thread pump is the documented default for state-sensitive calls
+- **WHEN** documentation or API guidance describes calling functions that touch single-thread-affinity process state
+- **THEN** it MUST direct callers to the main-thread pump, not `CreateRemoteThread`
+
+### Requirement: Remote-thread execution for thread-agnostic payloads
+
+`RemoteThreadExecutor` SHALL create a remote thread at a target address using a calling-convention-aware stub, wait for completion, and return the typed exit value. Its documentation MUST state that it is safe only for thread-agnostic payloads.
+
+#### Scenario: execute with parameters and convention
+- **WHEN** `Execute<int>(addr, CallConvention.Cdecl, arg1, arg2)` is called on a safe self-contained function
+- **THEN** the target MUST be called with the arguments laid out per cdecl and the typed return value returned
+
+#### Scenario: parameters marshalled and freed
+- **WHEN** a `string` or struct parameter is passed to `Execute`
+- **THEN** it MUST be allocated in the remote process, passed by pointer, and freed after the call completes
+
+#### Scenario: no process open
+- **WHEN** `Execute` is called with no process open
+- **THEN** it MUST fail deterministically rather than crash
+
+### Requirement: Crash-safe main-thread pump
+
+`MainThreadPump` SHALL install a hook on a per-frame function in the target and, each time that function runs, drain a thread-safe queue of work items, executing each on the target's own thread and returning its result or exception to the requesting caller.
+
+#### Scenario: work runs on the hooked thread
+- **WHEN** a work item is queued and the hooked per-frame function next executes
+- **THEN** the work item MUST run in the context of the thread that calls the per-frame function
+
+#### Scenario: result returned to caller
+- **WHEN** a caller queues a function returning a value and awaits its completion
+- **THEN** the caller MUST receive the returned value
+
+#### Scenario: exception propagated, pump survives
+- **WHEN** a queued work item throws
+- **THEN** the exception MUST be surfaced to the requesting caller AND subsequent queued items MUST still be processed
+
+#### Scenario: uninstall restores the frame function
+- **WHEN** the pump is disposed
+- **THEN** the hooked per-frame function MUST be restored to its original bytes
+
+### Requirement: In-process delegate invocation
+
+`InProcessInvoker` SHALL convert a function address to a typed managed delegate and call it directly, without creating a thread or crossing a thread boundary.
+
+#### Scenario: call as delegate
+- **WHEN** `CreateFunction<TDelegate>(addr)` is called in-process and the returned delegate is invoked
+- **THEN** the native function at `addr` MUST be called directly on the current thread with the delegate's marshalled arguments