Dhaedalida marker SDK
=====================

Tag a function for protection in source: bracket the code you want
protected with RabbitStart() / RabbitEnd(), and the Dhaedalida GUI auto-selects the
enclosing function and hands its address to the CLI. Detection works with or
without a PDB because the markers are found by an embedded byte signature, not
by symbol name.

    #include "dhae_sdk.h"
    int validate_license(const char* key) {
        RabbitStart();
        /* ... sensitive code ... */
        RabbitEnd();
        return ok;
    }

Whole-method granularity: the markers tag the enclosing function; Dhaedalida
protects the ENTIRE function, not just the span between the two calls.

TWO MARKER PAIRS, one per protection mode - pick per function:
  RabbitStart() / RabbitEnd()        Rabbit, the default VM (--rabbit)   - the faster VM
  BearStart() / BearEnd()            Bear, the strongest VM (--bear)     - approx 5x slower

A function may carry only ONE pair. Two pairs on one function is ambiguous about
how to protect it, and Dhaedalida refuses the job rather than choosing for you.
Bear is 64-bit only in this version; on a 32-bit target a Bear-marked function
is virtualized instead. Bear needs a Basic or Pro licence; the Demo edition
protects with Rabbit, and a Bear-marked function is virtualized instead.

Core files
----------
  dhae_marker_sig.h   The marker magic constants (shared with the GUI scanner).
  dhae_sdk.h          The marker prototypes (C / C++).
  dhae_sdk.c          The MSVC C/C++ marker definitions.

Language bindings (bindings\)
-----------------------------
Every binding emits the same 8 magic bytes at a call-reachable site, so the one
GUI scanner detects them all, and every binding supplies all four markers.

  C / C++ (MSVC)              dhae_sdk.c + dhae_sdk.h
  C (GCC / Clang / MinGW)     bindings\c-gnu\dhae_sdk_gnu.c
  Rust                        bindings\rust\dhae_marker.rs
  Delphi / Object Pascal/FPC  bindings\pascal\DhaeMarker.pas
  Go                          bindings\go\
  Assembly - MASM             bindings\masm\dhae_marker.asm     (ml64, 64-bit)
                              bindings\masm\dhae_marker32.asm   (ml,   32-bit)
  Assembly - FASM             bindings\fasm\dhae_marker.asm     (64-bit)
                              bindings\fasm\dhae_marker32.asm   (32-bit)
  Assembly - NASM / YASM      bindings\nasm\dhae_marker.asm     (64-bit)
                              bindings\nasm\dhae_marker32.asm   (32-bit)
  D                           bindings\d\dhae_marker.d
  Zig                         bindings\zig\dhae_marker.zig
  Nim                         bindings\nim\dhaemarker.nim

Every binding covers both 64-bit and 32-bit x86. For C/C++ that means the build
line never changes - cl /O2 yourapp.c dhae_sdk.c works in either dev prompt.

Any other language with a C FFI can link dhae_sdk.c and declare the four externs.
Visual Basic / C# / F# and other .NET languages are not supported (they emit
managed IL, not native machine code).

Requirements
------------
Native x86 - 64-bit or 32-bit; markers statically linked into the image, reached
by a direct call. Dhaedalida protects both, EXE and DLL. On a 32-bit target,
ship the .pdb beside it if you can: a 32-bit image carries no unwind table, so
without symbols the enclosing function has to be worked out from the marker
call, and a worked-out address is flagged as such so you can check it.
