تنزيل lazy_importer - تنزيل رمز المصدر lazy

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