lazy importer

Una biblioteca de solo encabezado, simple y fácil de usar, para hacerle la vida mucho más difícil a un ingeniero inverso.

pequeño ejemplo

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

Salida de IDA al compilar la primera línea

características

• No deja ninguna cadena en memoria.
• No asigna ninguna memoria.
• Se puede incorporar fácilmente (inline).
• No deja ninguna importación en el ejecutable.
• Produce un ensamblado extremadamente pequeño.
• Las funciones sin caché no dejan nada en las secciones de datos.
• Los hashes se aleatorizan en cada compilación para derrotar ataques básicos de bases de datos de hashes.

documentación

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

---

• safe indica que cuando la función no puede completar su tarea con éxito se devuelve 0 en lugar de manifestarse un comportamiento indefinido.
• cached indica que el resultado solo se calcula durante la primera llamada y luego se reutiliza.
• forwarded indica que la exportación reenviada se resolverá correctamente.

lazy_module

function	safe	cached
Intenta encontrar el módulo dado y devuelve su dirección
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:
Intenta encontrar el módulo dado usando el puntero LDR_DATA_TABLE_ENTRY dado
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
llama a la exportación resuelta usando los argumentos dados
operator()(...) -> result_of<F, ...>	:x:	:x:	:x:
intenta resolver una exportación en todos los módulos cargados y devuelve la dirección de la función
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:
intenta resolver una exportación en el módulo dado y devuelve la dirección de la función
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:
intenta resolver una exportación en ntdll y devuelve la dirección de la función
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:

configuración extra

#define	efectos
LAZY_IMPORTER_NO_FORCEINLINE	desactiva la incorporación forzada (force inlining)
LAZY_IMPORTER_CASE_INSENSITIVE	habilita la comparación sin distinción de mayúsculas y minúsculas. Puede ser necesario para la resolución de exportaciones reenviadas.
LAZY_IMPORTER_CACHE_OPERATOR_PARENS	usa cached() en lugar de get() en operator() de lazy_function
LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS	usa forwarded() en get(). ADVERTENCIA: no se aplica a nt() ni a in().
LAZY_IMPORTER_HARDENED_MODULE_CHECKS	añade comprobaciones de cordura adicionales a la enumeración de módulos.
LAZY_IMPORTER_NO_CPP_FORWARD	Elimina la dependencia del encabezado de C++ <utility>.

salida de ejemplo