lazy_importer下载lazy_importer源代码下载

lazy_importer

C/C++

1.0.0

下载

懒惰的进口商

一个简单易用的仅使用标头库，以使反向工程的寿命更加困难。

小例子

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

编译第一行时IDA输出

特征

不会在记忆中留下任何字符串。
不分配任何内存。
可以轻松地嵌入。
不会在可执行文件中留下任何进口。
产生非常小的组件。
非缓存功能不会在数据部分中留下任何内容。
每次汇编都是随机分组的，以打败基本哈希数据库攻击。

文档

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

safe表示，当功能无法成功完成任务时，将返回其任务0，而不是未定义的行为表现。
cached表明结果仅在第一个呼叫期间计算，然后再重复使用。
forwarded表示将正确解决出口转发。

`lazy_module`

功能	安全的	缓存
尝试找到给定模块并返回其地址
`get<T = void*>() -> T`
`safe<T = void*>() -> T`	✅
`cached<T = void*>() -> T`		✅
`safe_cached<T = void*>() -> T`	✅	✅
使用给定的ldr_data_table_entry指针来查找给定模块
`in<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅
`in_cached<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅	✅

`lazy_function<F>`

功能	安全的	缓存	转发
使用给定的参数解决了呼叫解决的导出
`operator()(...) -> result_of<F, ...>`
尝试在所有加载模块中解析导出并返回函数地址
`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`	✅	✅	✅
尝试在给定模块中解析导出并返回功能地址
`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`	✅	✅
尝试解决`ntdll`中的导出并返回功能地址
`nt<T = F>() -> T`
`nt_safe<T = F>() -> T`	✅
`nt_cached<T = F>() -> T`		✅
`nt_safe_cached<T = F>() -> T`	✅	✅

额外的配置

`#define`	效果
`LAZY_IMPORTER_NO_FORCEINLINE`	禁用强制内线
`LAZY_IMPORTER_CASE_INSENSITIVE`	启用案例不敏感的比较。转发出口分辨率可能需要。
`LAZY_IMPORTER_CACHE_OPERATOR_PARENS`	在lazy_function的`operator()`中使用`cached()`而不是`get()`
`LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS`	在`get()` `forwarded()` ）。警告不适用于`nt()`和`in()` 。
`LAZY_IMPORTER_HARDENED_MODULE_CHECKS`	在模块枚举中增加了额外的理智检查。
`LAZY_IMPORTER_NO_CPP_FORWARD`	去除对`<utility>` c ++标头的依赖。

示例输出

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