lazy importer

Una libreria header only semplice e facile da usare per rendere la vita di un reverse engineer molto più difficile.

piccolo esempio

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

Output di IDA durante la compilazione della prima riga

funzionalità

• Non lascia alcuna stringa in memoria.
• Non alloca alcuna memoria.
• Può essere facilmente inlined.
• Non lascia alcun import nell'eseguibile.
• Produce assembly estremamente compatto.
• Le funzioni non caching non lasciano nulla nelle sezioni dati.
• Gli hash sono randomizzati per ogni compilazione per sconfiggere attacchi di base basati su database di hash.

documentazione

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

---

• safe indica che quando la funzione non riesce a completare con successo il proprio compito viene restituito 0 invece di manifestare un comportamento indefinito.
• cached indica che il risultato viene calcolato solo durante la prima chiamata e successivamente riutilizzato.
• forwarded indica che l'export forwarding verrà risolto correttamente.

lazy_module

function	safe	cached
Tenta di trovare il modulo specificato e ne restituisce l'indirizzo
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:
Tenta di trovare il modulo specificato usando il puntatore LDR_DATA_TABLE_ENTRY fornito
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
chiama l'export risolto usando gli argomenti forniti
operator()(...) -> result_of<F, ...>	:x:	:x:	:x:
tenta di risolvere un export in tutti i moduli caricati e restituisce l'indirizzo della funzione
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:
tenta di risolvere un export nel modulo specificato e restituisce l'indirizzo della funzione
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:
tenta di risolvere un export in ntdll e restituisce l'indirizzo della funzione
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:

configurazione extra

#define	effetti
LAZY_IMPORTER_NO_FORCEINLINE	disabilita il force inlining
LAZY_IMPORTER_CASE_INSENSITIVE	abilita il confronto case insensitive. Potrebbe essere necessario per la risoluzione degli export forwardati.
LAZY_IMPORTER_CACHE_OPERATOR_PARENS	usa cached() invece di get() nell'operator() di lazy_function
LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS	usa forwarded() in get(). ATTENZIONE non si applica a nt() e in().
LAZY_IMPORTER_HARDENED_MODULE_CHECKS	aggiunge controlli di integrità extra all'enumerazione dei moduli.
LAZY_IMPORTER_NO_CPP_FORWARD	Rimuove la dipendenza dall'header c++ <utility>.

output di esempio