Descargar lazy_importer - Descargar el código fuente de lazy

lazy_importer

C/C++

1.0.0

Descargar

importador perezoso

Una biblioteca de encabezado simple y fácil de usar para que la vida de un ingeniero inverso sea mucho más difícil.

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 la memoria.
No asigna ningún recuerdo.
Se puede inclinar fácilmente.
No deja ninguna importación en el ejecutable.
Produce un ensamblaje extremadamente pequeño.
Las funciones no almacenadas en caché no dejan nada en las secciones de datos.
Los hash se aleatorizan para cada compilación para derrotar los ataques básicos de base de datos hash.

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 que se manifiesta el comportamiento indefinido.
cached indica que el resultado solo se calcula durante la primera llamada y luego se reutiliza.
forwarded indica que el reenvío de exportación se resolverá correctamente.

`lazy_module`

función	seguro	en caché
Intenta encontrar el módulo dado y devuelve su dirección
`get<T = void*>() -> T`
`safe<T = void*>() -> T`	✅
`cached<T = void*>() -> T`		✅
`safe_cached<T = void*>() -> T`	✅	✅
ATMPS para encontrar el módulo dado utilizando el puntero 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>`

función	seguro	en caché	reenviado
llamadas resueltas exportación utilizando argumentos dados
`operator()(...) -> result_of<F, ...>`
intenta resolver una exportación en todos los módulos cargados y devuelve la dirección de función
`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`	✅	✅	✅
intenta resolver una exportación en el módulo dado y devuelve la dirección de función
`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`	✅	✅
intenta resolver una exportación en `ntdll` y devuelve la dirección de la función
`nt<T = F>() -> T`
`nt_safe<T = F>() -> T`	✅
`nt_cached<T = F>() -> T`		✅
`nt_safe_cached<T = F>() -> T`	✅	✅

configuración adicional

`#define`	efectos
`LAZY_IMPORTER_NO_FORCEINLINE`	deshabilita la fuerza en la enjuague
`LAZY_IMPORTER_CASE_INSENSITIVE`	habilita la comparación insensible de casos. Podría ser necesario para la resolución de exportación reenviada.
`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()` . La advertencia no se aplica a `nt()` y `in()` .
`LAZY_IMPORTER_HARDENED_MODULE_CHECKS`	Agrega controles de cordura adicionales a la enumeración del módulo.
`LAZY_IMPORTER_NO_CPP_FORWARD`	Elimina la dependencia del encabezado `<utility>` C ++.

salida de ejemplo

 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" );