lazy_importer Téléchargement - lazy_importer Téléchargement du code source

lazy_importer

C/C++

1.0.0

Télécharger

importateur paresseux

Une bibliothèque d'en-tête simple et facile à utiliser uniquement pour rendre la vie d'un ingénieur à la recherche 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

caractéristiques

Ne laisse aucune chaîne en mémoire.
N'attribue aucune mémoire.
Peut être facilement incliné.
Ne laisse aucune importation dans l'exécutable.
Produit un assemblage extrêmement petit.
Les fonctions non de mise en cache ne laissent rien dans les sections de données.
Les hachages sont randomisés pour chaque compilation pour vaincre les attaques de base de données de hachage de base.

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 terminer sa tâche avec succès 0 est renvoyée au lieu de manifester un comportement non défini.
cached indique que le résultat n'est calculé que lors du premier appel et réutilisé plus tard.
forwarded indique que le transfert d'exportation sera correctement résolu.

`lazy_module`

fonction	sûr	mis en cache
Tente de trouver le module donné et renvoie son adresse
`get<T = void*>() -> T`
`safe<T = void*>() -> T`	✅
`cached<T = void*>() -> T`		✅
`safe_cached<T = void*>() -> T`	✅	✅
Attaches pour trouver le module donné en utilisant le pointeur LDR_DATA_TABLE_TABLE donné
`in<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅
`in_cached<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅	✅

`lazy_function<F>`

fonction	sûr	mis en cache	transféré
Appels exportation résolues en utilisant des arguments donnés
`operator()(...) -> result_of<F, ...>`
tente de résoudre une exportation dans tous les modules chargés et renvoie l'adresse de la fonction
`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`	✅	✅	✅
tente de résoudre une exportation dans le module donné et renvoie l'adresse de la fonction
`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`	✅	✅
tente de résoudre une exportation dans `ntdll` et renvoie l'adresse de la fonction
`nt<T = F>() -> T`
`nt_safe<T = F>() -> T`	✅
`nt_cached<T = F>() -> T`		✅
`nt_safe_cached<T = F>() -> T`	✅	✅

configuration supplémentaire

`#define`	effets
`LAZY_IMPORTER_NO_FORCEINLINE`	désactive la force enracinée
`LAZY_IMPORTER_CASE_INSENSITIVE`	Permet la comparaison insensible au cas. Peut être nécessaire pour la résolution d'exportation transmise.
`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()` . L'avertissement ne s'applique pas à `nt()` et `in()` .
`LAZY_IMPORTER_HARDENED_MODULE_CHECKS`	Ajoute des contrôles de santé mentale supplémentaires à l'énumération du module.
`LAZY_IMPORTER_NO_CPP_FORWARD`	Supprime la dépendance à l'en-tête `<utility>` C ++.

Exemple de sortie

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