lazy importer

Uma biblioteca simples e fácil de usar, apenas com cabeçalho, para tornar a vida de um engenheiro reverso muito mais difícil.

pequeno exemplo

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

Saída do IDA ao compilar a primeira linha

recursos

• Não deixa nenhuma string na memória.
• Não aloca nenhuma memória.
• Pode ser facilmente embutida (inlined).
• Não deixa nenhuma importação no executável.
• Produz assembly extremamente pequeno.
• Funções sem cache não deixam nada nas seções de dados.
• Os hashes são randomizados a cada compilação para derrotar ataques básicos de banco de dados de hash.

documentação

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

---

• safe indica que, quando a função não consegue completar sua tarefa com sucesso, 0 é retornado em vez de comportamento indefinido se manifestar.
• cached indica que o resultado é calculado apenas durante a primeira chamada e reutilizado depois.
• forwarded indica que o encaminhamento de exportação será resolvido corretamente.

lazy_module

function	safe	cached
Tenta encontrar o módulo fornecido e retorna seu endereço
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 encontrar o módulo fornecido usando o ponteiro LDR_DATA_TABLE_ENTRY fornecido
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
chama a exportação resolvida usando os argumentos fornecidos
operator()(...) -> result_of<F, ...>	:x:	:x:	:x:
tenta resolver uma exportação em todos os módulos carregados e retorna o endereço da função
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 resolver uma exportação no módulo fornecido e retorna o endereço da função
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 resolver uma exportação em ntdll e retorna o endereço da função
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:

configuração extra

#define	efeitos
LAZY_IMPORTER_NO_FORCEINLINE	desativa o force inlining
LAZY_IMPORTER_CASE_INSENSITIVE	ativa a comparação sem distinção entre maiúsculas e minúsculas. Pode ser necessário para a resolução de exportações encaminhadas.
LAZY_IMPORTER_CACHE_OPERATOR_PARENS	usa cached() em vez de get() no operator() de lazy_function
LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS	usa forwarded() em get(). AVISO: não se aplica a nt() e in().
LAZY_IMPORTER_HARDENED_MODULE_CHECKS	adiciona verificações extras de sanidade à enumeração de módulos.
LAZY_IMPORTER_NO_CPP_FORWARD	Remove a dependência do cabeçalho C++ <utility>.

exemplo de saída