lazy_importer lazy

lazy_importer

C/C++

1.0.0

Baixar

Importador preguiçoso

Uma biblioteca de cabeçalho simples e fácil de usar 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 da IDA ao compilar a primeira linha

características

Não deixa nenhuma série na memória.
Não aloca nenhuma memória.
Pode ser facilmente inlinado.
Não deixa nenhuma importação no executável.
Produz uma montagem extremamente pequena.
As funções sem cache não deixam nada nas seções de dados.
Os hashes são randomizados para 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 pode concluir sua tarefa com sucesso 0 é retornada em vez de comportamento indefinido se manifestar.
cached indica que o resultado é calculado apenas durante a primeira chamada e posteriormente reutilizado.
forwarded indica que o encaminhamento de exportação será resolvido corretamente.

`lazy_module`

função	seguro	cache
Tentativas de encontrar o módulo fornecido e retorna seu endereço
`get<T = void*>() -> T`
`safe<T = void*>() -> T`	✅
`cached<T = void*>() -> T`		✅
`safe_cached<T = void*>() -> T`	✅	✅
Tenta encontrar o módulo fornecido usando o ponteiro ldr_data_table_entry dado
`in<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅
`in_cached<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅	✅

`lazy_function<F>`

função	seguro	cache	encaminhado
Chamadas resolvidas exportação usando argumentos determinados
`operator()(...) -> result_of<F, ...>`
Tentativas de resolver uma exportação em todos os módulos carregados e retorna o endereço da função
`get<T = F>() -> T`
`safe<T = F>() -> T`	✅
`cached<T = F>() -> T`		✅
`safe_cached<T = F>() -> T`	✅	✅
`forwarded<T = F>() -> T`			✅
`forwarded_safe<T = F>() -> T`	✅		✅
`forwarded_cached<T = F>() -> T`		✅	✅
`forwarded_safe_cached<T = F>() -> T`	✅	✅	✅
Tentativas de resolver uma exportação no módulo fornecido e retorna o endereço da função
`in<T = F, A>(A module_address) -> T`
`in_safe<T = F, A>(A module_address) -> T`	✅
`in_cached<T = F, A>(A module_address) -> T`		✅
`in_safe_cached<T = F, A>(A module_address) -> T`	✅	✅
Tentativas de resolver uma exportação no `ntdll` e retorna o endereço da função
`nt<T = F>() -> T`
`nt_safe<T = F>() -> T`	✅
`nt_cached<T = F>() -> T`		✅
`nt_safe_cached<T = F>() -> T`	✅	✅

Configuração extra

`#define`	efeitos
`LAZY_IMPORTER_NO_FORCEINLINE`	desabilita a força inline
`LAZY_IMPORTER_CASE_INSENSITIVE`	Ativa a comparação insensível ao caso. Pode ser necessário para a resolução de exportação encaminhada.
`LAZY_IMPORTER_CACHE_OPERATOR_PARENS`	usa `cached()` em vez de `get()` em `operator()` de lazy_função
`LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS`	usa `forwarded()` em `get()` . O aviso não se aplica a `nt()` e `in()` .
`LAZY_IMPORTER_HARDENED_MODULE_CHECKS`	Adiciona verificações extras de sanidade à enumeração do módulo.
`LAZY_IMPORTER_NO_CPP_FORWARD`	Remove a dependência do cabeçalho `<utility>` c ++.

Exemplo de saída

 for ( i = * ( _QWORD * * )( * ( _QWORD * )( __readgsqword ( 0x60u ) + 24 ) + 16 i64 ); ; i = ( _QWORD * ) * i )
  {
    v1 = i [ 6 ];
    v2 = * ( unsigned int * )( * ( signed int * )( v1 + 60 ) + v1 + 136 );
    v3 = ( _DWORD * )( v2 + v1 );
    if ( v2 + v1 != v1 )
    {
      LODWORD ( v4 ) = v3 [ 6 ];
      if ( ( _DWORD ) v4 )
        break ;
    }
LABEL_8:
    ;
  }
  while ( 1 )
  {
    v4 = ( unsigned int )( v4 - 1 );
    v5 = -2128831035 ;
    v6 = ( char * )( v1 + * ( unsigned int * )(( unsigned int ) v3 [ 8 ] + 4 * v4 + v1 ));
    v7 = * v6 ;
    v8 = ( signed __int64 )( v6 + 1 );
    if ( v7 )
    {
      do
      {
        ++ v8 ;
        v5 = 16777619 * ( v5 ^ v7 );
        v7 = * ( _BYTE * )( v8 - 1 );
      }
      while ( v7 );
      if ( v5 == -973690651 )
        break ;
    }
    if ( !( _DWORD ) v4 )
      goto LABEL_8;
  }
  (( void (__fastcall * )( const char * ))( v1
                                     + * ( unsigned int * )( v1
                                                       + ( unsigned int ) v3 [ 7 ]
                                                       + 4 i64 * * ( unsigned __int16 * )( v1 + ( unsigned int ) v3 [ 9 ] + 2 * v4 ))))( "hello world" );