Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Stardust — Un modèle d'implant moderne indépendant de la position 32/64 bits | Kitploit
Outils/GitHubGitHub/cracked5pider/stardust
ExploitationShellcodePost-ExploitationRed TeamingGénération de ShellcodeDéveloppement de Charges UtilesExploitation de Binaires
GitHubcracked5pider/stardust

Stardust

Un modèle d'implant moderne indépendant de la position 32/64 bits

Voir le dépôt
1.4k2175il y a 3 moisVérifié par Kitploit
Site web

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Stardust

Un modèle de shellcode moderne et facile à utiliser 32/64 bits.

  • chaînes brutes
  • projet C++20
  • utilise le hachage à la compilation avec fnv1a pour la résolution des fonctions et des modules

Utilisation de base

résolution des modules à partir du PEB en utilisant resolve::module :

root@kitploit:~
if ( ! (( ntdll.handle = resolve::module( expr::hash_string<wchar_t>( L"ntdll.dll" ) ) )) ) {
    return;
}

if ( ! (( kernel32.handle = resolve::module( expr::hash_string<wchar_t>( L"kernel32.dll" ) ) )) ) {
    return;
}

résolution des API de fonctions en utilisant soit la macro RESOLVE_API, soit la fonction resolve::api :

root@kitploit:~
const auto user32 = kernel32.LoadLibraryA( symbol<const char*>( "user32.dll" ) );

decltype( MessageBoxA ) * msgbox = RESOLVE_API( reinterpret_cast<uintptr_t>( user32 ), MessageBoxA );

msgbox( nullptr, symbol<const char*>( "Hello world" ), symbol<const char*>( "caption" ), MB_OK );

RESOLVE_API est un wrapper autour de resolve::api qui hache automatiquement le nom de la fonction et caste le pointeur de fonction vers le type de fonction.

hachage de chaînes pour UTF-8 et UTF-16 en utilisant la fonction expr::hash_string à la compilation :

root@kitploit:~
auto user32_hash      = expr::hash_string<wchar_t>( L"user32.dll" );
auto loadlibrary_hash = expr::hash_string<char>( "LoadLibraryA" );

prise en charge des chaînes brutes pour le 32/64 bits en utilisant la fonction symbol :

root@kitploit:~
auto caption_string = symbol<const char*>( "hello from stardust" );

user32.MessageBoxA( nullptr, caption_string, symbol<const char*>( "message title" ), MB_OK );

facile d'ajouter de nouvelles API et modules à l'instance. Sous include/common.h, l'entrée suivante doit être faite :

root@kitploit:~
class instance {
    ...
    
    struct
    {
        uintptr_t handle; // base address to user32.dll

        struct {
            D_API( MessageBoxA );
            // more entries can be added here
        };
    } user32 = {
        RESOLVE_TYPE( MessageBoxA ),
        // more entries can be added here 
    };
    
    ...

tandis que le src/main.cc doit résoudre l'adresse de base de user32 et résoudre le pointeur de l'API :

root@kitploit:~

declfn instance::instance(
    void
) {
    ...
    //
    // resolve user32.dll from PEB if loaded 
    if ( ! (( user32.handle = resolve::module( expr::hash_string<wchar_t>( L"user32.dll" ) ) )) ) {
        return;
    }

    //
    // automatically resolve every entry imported
    // by user32 from the structure 
    RESOLVE_IMPORT( user32 );
    ...
}

capacités de débogage semi-conviviales via DbgPrint. Le projet doit cependant être compilé en mode debug en spécifiant make debug. Utilisation :

root@kitploit:~
const auto user32 = kernel32.LoadLibraryA( symbol<const char*>( "user32.dll" ) );

if ( user32 ) {
    DBG_PRINTF( "oh wow look we loaded user32.dll -> %p\n", user32 );
} else {
    DBG_PRINTF( "okay something went wrong. failed to load user32 :/\n" );
}

DBG_PRINTF( "running from %ls (Pid: %d)\n",
    NtCurrentPeb()->ProcessParameters->ImagePathName.Buffer,
    NtCurrentTeb()->ClientId.UniqueProcess );

DBG_PRINTF( "shellcode @ %p [%d bytes]\n", base.address, base.length );

Compilation

Compilation en mode release :

root@kitploit:~
$ make                                                                                                                                                                                                                                                                                  20:17:26
-> compiling src/main.cc to main.x64.obj
-> compiling src/resolve.cc to resolve.x64.obj
compiling x64 project
/usr/bin/x86_64-w64-mingw32-ld: bin/stardust.x64.exe:.text: section below image base
-> compiling src/main.cc to main.x86.obj
-> compiling src/resolve.cc to resolve.x86.obj
compiling x86 project
/usr/bin/i686-w64-mingw32-ld: bin/stardust.x86.exe:.text: section below image base
$ ll bin                                                                                                                                                                                                                                                                                20:57:10
drwxr-xr-x spider spider 4.0 KB Thu Mar 13 20:57:10 2025 obj
.rw-r--r-- spider spider 752 B  Thu Mar 13 20:57:10 2025 stardust.x64.bin
.rw-r--r-- spider spider 672 B  Thu Mar 13 20:57:10 2025 stardust.x86.bin

Compilation en mode debug :

root@kitploit:~
$ make debug                                                                                                                                                                                                                                                                            20:57:14
-> compiling src/main.cc to main.x64.obj
-> compiling src/resolve.cc to resolve.x64.obj
compiling x64 project
/usr/bin/x86_64-w64-mingw32-ld: bin/stardust.x64.exe:.text: section below image base
-> compiling src/main.cc to main.x86.obj
-> compiling src/resolve.cc to resolve.x86.obj
compiling x86 project
/usr/bin/i686-w64-mingw32-ld: bin/stardust.x86.exe:.text: section below image base
$ ll bin                                                                                                                                                                                                                                                                                20:58:13
drwxr-xr-x spider spider 4.0 KB Thu Mar 13 20:58:13 2025 obj
.rw-r--r-- spider spider 1.2 KB Thu Mar 13 20:58:13 2025 stardust.x64.bin
.rw-r--r-- spider spider 1.1 KB Thu Mar 13 20:58:13 2025 stardust.x86.bin

Démo

x64: x64

x86: x86

Télécharger l’outil