lazy importer

रिवर्स इंजीनियर के जीवन को बहुत कठिन बनाने के लिए एक सरल और उपयोग में आसान हेडर-ओनली लाइब्रेरी।

छोटा उदाहरण

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

function	safe	cached
Attempts to find the given module and returns its address
get<T = void*>() -> T	:x:	:x:
safe<T = void*>() -> T	:white_check_mark:	:x:
cached<T = void*>() -> T	:x:	:white_check_mark:
safe_cached<T = void*>() -> T	:white_check_mark:	:white_check_mark:
Attemps to find the given module using the given LDR_DATA_TABLE_ENTRY pointer
in<T = void*, Ldr>(Ldr ldr_entry) -> T	:white_check_mark:	:x:
in_cached<T = void*, Ldr>(Ldr ldr_entry) -> T	:white_check_mark:	:white_check_mark:

lazy_function<F>

function	safe	cached	forwarded
calls resolved export using given arguments
operator()(...) -> result_of<F, ...>	:x:	:x:	:x:
attempts to resolve an export in all loaded modules and returns the function address
get<T = F>() -> T	:x:	:x:	:x:
safe<T = F>() -> T	:white_check_mark:	:x:	:x:
cached<T = F>() -> T	:x:	:white_check_mark:	:x:
safe_cached<T = F>() -> T	:white_check_mark:	:white_check_mark:	:x:
forwarded<T = F>() -> T	:x:	:x:	:white_check_mark:
forwarded_safe<T = F>() -> T	:white_check_mark:	:x:	:white_check_mark:
forwarded_cached<T = F>() -> T	:x:	:white_check_mark:	:white_check_mark:
forwarded_safe_cached<T = F>() -> T	:white_check_mark:	:white_check_mark:	:white_check_mark:
attempts to resolve an export in the given module and returns the function address
in<T = F, A>(A module_address) -> T	:x:	:x:	:x:
in_safe<T = F, A>(A module_address) -> T	:white_check_mark:	:x:	:x:
in_cached<T = F, A>(A module_address) -> T	:x:	:white_check_mark:	:x:
in_safe_cached<T = F, A>(A module_address) -> T	:white_check_mark:	:white_check_mark:	:x:
attempts to resolve an export in ntdll and returns the function address
nt<T = F>() -> T	:x:	:x:	:x:
nt_safe<T = F>() -> T	:white_check_mark:	:x:	:x:
nt_cached<T = F>() -> T	:x:	:white_check_mark:	:x:
nt_safe_cached<T = F>() -> T	:white_check_mark:	:white_check_mark:	:x:

अतिरिक्त कॉन्फ़िगरेशन

#define	effects
LAZY_IMPORTER_NO_FORCEINLINE	force inlining अक्षम करता है
LAZY_IMPORTER_CASE_INSENSITIVE	केस-असंवेदनशील तुलना सक्षम करता है। फ़ॉरवर्डेड एक्सपोर्ट रिज़ॉल्यूशन के लिए आवश्यक हो सकता है।
LAZY_IMPORTER_CACHE_OPERATOR_PARENS	lazy_function के operator() में get() के बजाय cached() का उपयोग करता है
LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS	get() में forwarded() का उपयोग करता है। चेतावनी: nt() और in() पर लागू नहीं होता।
LAZY_IMPORTER_HARDENED_MODULE_CHECKS	मॉड्यूल एन्यूमरेशन में अतिरिक्त सैनिटी जाँच जोड़ता है।
LAZY_IMPORTER_NO_CPP_FORWARD	<utility> c++ हेडर पर निर्भरता हटाता है।

उदाहरण आउटपुट