lazy importer

Eine einfache und benutzerfreundliche Header-Only-Bibliothek, die das Leben eines Reverse Engineers erheblich erschwert.

kleines Beispiel

LI_FN(OutputDebugStringA)("hello world");
LI_FN(VirtualProtect).in(LI_MODULE("kernel32.dll").cached());

IDA-Ausgabe beim Kompilieren der ersten Zeile

Funktionen

• Hinterlässt keine Strings im Speicher.
• Allokiert keinen Speicher.
• Kann einfach inlined werden.
• Hinterlässt keine Imports in der ausführbaren Datei.
• Erzeugt extrem kleinen Assembly-Code.
• Nicht-cachende Funktionen hinterlassen nichts in Datensektionen.
• Hashes werden für jede Kompilierung randomisiert, um einfache Hash-Datenbank-Angriffe zu vereiteln.

Dokumentation

• LI_FN(function_pointer) -> lazy_function
• LI_FN_DEF(function_type) -> lazy_function
• LI_MODULE(module_name) -> lazy_module

---

• safe gibt an, dass bei erfolgloser Ausführung der Aufgabe 0 zurückgegeben wird, anstatt dass undefiniertes Verhalten auftritt.
• cached gibt an, dass das Ergebnis nur beim ersten Aufruf berechnet und später wiederverwendet wird.
• forwarded gibt an, dass Export-Forwarding korrekt aufgelöst wird.

lazy_module

function	safe	cached
Versucht, das angegebene Modul zu finden und gibt dessen Adresse zurück
get<T = void*>() -> T	:x:	:x:
safe<T = void*>() -> T	:white_check_mark:	:x:
cached<T = void*>() -> T	:x:	:white_check_mark:
safe_cached<T = void*>() -> T	:white_check_mark:	:white_check_mark:
Versucht, das angegebene Modul unter Verwendung des angegebenen LDR_DATA_TABLE_ENTRY-Zeigers zu finden
in<T = void*, Ldr>(Ldr ldr_entry) -> T	:white_check_mark:	:x:
in_cached<T = void*, Ldr>(Ldr ldr_entry) -> T	:white_check_mark:	:white_check_mark:

lazy_function<F>

function	safe	cached	forwarded
ruft den aufgelösten Export mit den angegebenen Argumenten auf
operator()(...) -> result_of<F, ...>	:x:	:x:	:x:
versucht, einen Export in allen geladenen Modulen aufzulösen und gibt die Funktionsadresse zurück
get<T = F>() -> T	:x:	:x:	:x:
safe<T = F>() -> T	:white_check_mark:	:x:	:x:
cached<T = F>() -> T	:x:	:white_check_mark:	:x:
safe_cached<T = F>() -> T	:white_check_mark:	:white_check_mark:	:x:
forwarded<T = F>() -> T	:x:	:x:	:white_check_mark:
forwarded_safe<T = F>() -> T	:white_check_mark:	:x:	:white_check_mark:
forwarded_cached<T = F>() -> T	:x:	:white_check_mark:	:white_check_mark:
forwarded_safe_cached<T = F>() -> T	:white_check_mark:	:white_check_mark:	:white_check_mark:
versucht, einen Export im angegebenen Modul aufzulösen und gibt die Funktionsadresse zurück
in<T = F, A>(A module_address) -> T	:x:	:x:	:x:
in_safe<T = F, A>(A module_address) -> T	:white_check_mark:	:x:	:x:
in_cached<T = F, A>(A module_address) -> T	:x:	:white_check_mark:	:x:
in_safe_cached<T = F, A>(A module_address) -> T	:white_check_mark:	:white_check_mark:	:x:
versucht, einen Export in ntdll aufzulösen und gibt die Funktionsadresse zurück
nt<T = F>() -> T	:x:	:x:	:x:
nt_safe<T = F>() -> T	:white_check_mark:	:x:	:x:
nt_cached<T = F>() -> T	:x:	:white_check_mark:	:x:
nt_safe_cached<T = F>() -> T	:white_check_mark:	:white_check_mark:	:x:

zusätzliche Konfiguration

#define	Auswirkungen
LAZY_IMPORTER_NO_FORCEINLINE	deaktiviert Force-Inlining
LAZY_IMPORTER_CASE_INSENSITIVE	aktiviert Groß-/Kleinschreibungs-unabhängigen Vergleich. Möglicherweise erforderlich für die Auflösung weitergeleiteter Exporte.
LAZY_IMPORTER_CACHE_OPERATOR_PARENS	verwendet cached() anstelle von get() im operator() von lazy_function
LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS	verwendet forwarded() in get(). WARNUNG gilt nicht für nt() und in().
LAZY_IMPORTER_HARDENED_MODULE_CHECKS	fügt zusätzliche Plausibilitätsprüfungen zur Modul-Enumeration hinzu.
LAZY_IMPORTER_NO_CPP_FORWARD	Entfernt die Abhängigkeit vom <utility>-C++-Header.

Beispielausgabe