lazy_importer скачать - lazy_importer исходный код скачать

lazy_importer

С/С++

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`	использует `cached()` вместо `get()` в `operator()` lazy_function
`LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS`	использует `forwarded()` в `get()` . Предупреждение не относится к `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" );