lazy importer

Une bibliothèque header-only simple et facile à utiliser pour rendre la vie d'un reverse engineer beaucoup plus difficile.

petit exemple

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

Sortie IDA lors de la compilation de la première ligne

fonctionnalités

• Ne laisse aucune chaîne de caractères en mémoire.
• N'alloue aucune mémoire.
• Peut être facilement inlinée.
• Ne laisse aucun import dans l'exécutable.
• Produit un assembly extrêmement compact.
• Les fonctions non cachées ne laissent rien dans les sections de données.
• Les hachages sont randomisés à chaque compilation pour contrer les attaques basiques par base de données de hachages.

documentation

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

---

• safe indique que lorsque la fonction ne peut pas accomplir sa tâche avec succès, 0 est retourné au lieu d'un comportement indéfini qui se manifeste.
• cached indique que le résultat n'est calculé que lors du premier appel et réutilisé ensuite.
• forwarded indique que le transfert d'export sera correctement résolu.

lazy_module

fonction	safe	cached
Tente de trouver le module donné et retourne son adresse
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:
Tente de trouver le module donné en utilisant le pointeur LDR_DATA_TABLE_ENTRY donné
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>

fonction	safe	cached	forwarded
appelle l'export résolu en utilisant les arguments donnés
operator()(...) -> result_of<F, ...>	:x:	:x:	:x:
tente de résoudre un export dans tous les modules chargés et retourne l'adresse de la fonction
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:
tente de résoudre un export dans le module donné et retourne l'adresse de la fonction
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:
tente de résoudre un export dans ntdll et retourne l'adresse de la fonction
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:

configuration supplémentaire

#define	effets
LAZY_IMPORTER_NO_FORCEINLINE	désactive le force inlining
LAZY_IMPORTER_CASE_INSENSITIVE	active la comparaison insensible à la casse. Peut être requis pour la résolution des exports transférés.
LAZY_IMPORTER_CACHE_OPERATOR_PARENS	utilise cached() au lieu de get() dans operator() de lazy_function
LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS	utilise forwarded() dans get(). ATTENTION ne s'applique pas à nt() et in().
LAZY_IMPORTER_HARDENED_MODULE_CHECKS	ajoute des vérifications de cohérence supplémentaires à l'énumération des modules.
LAZY_IMPORTER_NO_CPP_FORWARD	Supprime la dépendance à l'en-tête C++ <utility>.

exemple de sortie