Download lazy_importer - lazy_importer Quellcode herunterladen

lazy_importer

C/C++

1.0.0

Herunterladen

fauler Importeur

Eine einfache und einfach zu verwendende Header -Bibliothek, um die Lebensdauer eines Reverse -Ingenieurs viel schwieriger zu machen.

Kleines Beispiel

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

IDA -Ausgabe beim Kompilieren der ersten Zeile

Merkmale

Hinterlässt keine Saiten im Speicher.
Weisen keine Erinnerung zu.
Kann leicht eingebaut werden.
Hinterlässt keine Importe in der ausführbaren Datei.
Erzeugt eine extrem kleine Baugruppe.
Nicht -Caching -Funktionen hinterlassen nichts in Datenabschnitten.
Hashes werden für jede Zusammenstellung randomisiert, um grundlegende Hash -Datenbankangriffe zu besiegen.

Dokumentation

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

safe gibt an, dass, wenn die Funktion ihre Aufgabe nicht erfolgreich erledigen kann.
cached weist darauf hin, dass das Ergebnis nur während des ersten Anrufs berechnet und später wiederverwendet wird.
forwarded gibt an, dass die Exportweiterung korrekt aufgelöst wird.

`lazy_module`

Funktion	sicher	zwischengespeichert
Versuche, das angegebene Modul zu finden und seine Adresse zurückzugeben
`get<T = void*>() -> T`
`safe<T = void*>() -> T`	✅
`cached<T = void*>() -> T`		✅
`safe_cached<T = void*>() -> T`	✅	✅
Es wird versucht, das angegebene Modul mit dem angegebenen Zeiger ldr_data_table_entry zu finden
`in<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅
`in_cached<T = void*, Ldr>(Ldr ldr_entry) -> T`	✅	✅

`lazy_function<F>`

Funktion	sicher	zwischengespeichert	weitergeleitet
Anrufe gelöst den Export mit gegebenen Argumenten
`operator()(...) -> result_of<F, ...>`
Versuche, einen Export in allen geladenen Modulen zu lösen und die Funktionsadresse zurückzugeben
`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`	✅	✅	✅
Versuche, einen Export im angegebenen Modul zu lösen und die Funktionsadresse zurückzugeben
`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`	✅	✅
Versuche, einen Export in `ntdll` zu lösen und die Funktionsadresse zurückzugeben
`nt<T = F>() -> T`
`nt_safe<T = F>() -> T`	✅
`nt_cached<T = F>() -> T`		✅
`nt_safe_cached<T = F>() -> T`	✅	✅

zusätzliche Konfiguration

`#define`	Effekte
`LAZY_IMPORTER_NO_FORCEINLINE`	Deaktiviert die Inlines von Kraft
`LAZY_IMPORTER_CASE_INSENSITIVE`	Aktiviert Fall unempfindlicher Vergleich. Kann für die Weiterleitung der Exportauflösung erforderlich sein.
`LAZY_IMPORTER_CACHE_OPERATOR_PARENS`	Verwendet `cached()` anstelle von `get()` in `operator()` von Lazy_function
`LAZY_IMPORTER_RESOLVE_FORWARDED_EXPORTS`	Verwendete `forwarded()` in `get()` . Warnung gilt nicht für `nt()` und `in()` .
`LAZY_IMPORTER_HARDENED_MODULE_CHECKS`	Fügt der Modulaufzählung zusätzliche geistige Gesundheitsprüfungen hinzu.
`LAZY_IMPORTER_NO_CPP_FORWARD`	Entfernt die Abhängigkeit von `<utility>` C ++ Header.

Beispielausgabe

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