Cobalt Strike Sleep Python Bridge

Questo progetto è un 'ponte' tra il linguaggio Sleep e Python. Consente il controllo di un teamserver di Cobalt Strike tramite Python senza la necessità del client GUI standard.

NOTA: questo progetto è molto in BETA. L'obiettivo è fornire un parco giochi per i test e non è in alcun modo una funzionalità supportata ufficialmente. Forse potrebbe essere qualcosa da aggiungere in futuro al prodotto principale.

Il progetto è stato ispirato dal lavoro svolto da @BinaryFaultline e @Mcgigglez16 nel progetto https://github.com/emcghee/PayloadAutomation. Voglio offrire un ringraziamento speciale a entrambi !!

Il cuore di questo ponte è un'implementazione Python di un client Cobalt Strike headless. Questo è ottenuto usando come motore l'Aggressor Script Console fornita da agscript. Agscript consente l'interazione headless con Cobalt Strike (https://www.cobaltstrike.com/aggressor-script/index.html). Il 'ponte' funziona usando funzioni helper Python in sleepy.py per generare i comandi Sleep necessari attesi dalla console agscript. Invece di scrivere le funzioni Sleep, striker.py fornisce funzioni helper che astraggono Sleep e consentono l'uso di Python.

Changes of note from the original project

Poiché il progetto PayloadAutomation ha ispirato questo, si è partiti con gran parte dello stesso codice, ma ho voluto ridurlo per usare solo i componenti necessari a fungere da wrapper agscript.

• Rinominato da Payload_Automation a sleep_python_bridge. Questo progetto è più della semplice generazione di payload.
• Passato da una libreria PyPI a moduli locali. Questo è stato fatto per i test e potrebbe essere un buon candidato per una libreria Python dopo test approfonditi
• Aggiornati e aggiunti helper per corrispondere alle versioni di aggressor
• Aggiunta la possibilità di caricare script esterni.

Included Libraries

• Striker: una serie di funzioni per interagire con Cobalt Strike ed eseguire funzionalità tipicamente accessibili solo tramite Sleep/GUI.
• Sleepy: una serie di funzioni per facilitare un ponte tra oggetti Sleep e oggetti Python.
• Compyler: una serie di funzioni per compilare vari payload per piattaforma o cross-platform.
• Artifactor: una serie di funzioni per ispezionare e rivedere gli artifact e raccogliere e tracciare gli IoC.

Files and Directories

TODO

• Documentare le funzioni esposte
• spostare le funzioni di compilazione da striker.py a compyler.py
• Aggiungere ulteriori controlli degli errori, in particolare per le dipendenze dell'applicazione
• Espandere compyler per includere build remote e mingw
• Aggiungere il tracciamento degli IoC ai payload generati tramite artifactor.py
• gestire l'errore: "User is already connected."
• Valutare la conversione in una libreria Python formale

How to use

Gli esempi in questo progetto potrebbero essere il modo più semplice per capire, ma c'è lo script example.py

#!/usr/local/bin/python3

## Import the bridge
from sleep_python_bridge.striker import CSConnector
from argparse import ArgumentParser
from pprint import pp, pprint

###################
## Argparse
def parseArguments():
    parser = ArgumentParser()
    parser.add_argument('host', help='The teamserver host.')
    parser.add_argument('port', help='The teamserver port.')
    parser.add_argument('username', help='The desired username.')
    parser.add_argument('password', help='The teamserver password.')
    parser.add_argument('path', help="Directory to CobaltStrike")
    
    args = parser.parse_args()
    return args

## Let's go
def main(args):

    cs_host = args.host
    cs_port = args.port
    cs_user = args.username
    cs_pass = args.password
    cs_directory = args.path

    ## Connect to server
    print(f"[*] Connecting to teamserver: {cs_host}")
    with CSConnector(
        cs_host=cs_host, 
        cs_port=cs_port, 
        cs_user=cs_user, 
        cs_pass=cs_pass,
        cs_directory=cs_directory) as cs:

        # Perform some actions
        # 
        # Get beacon metadata - i.e., x beacons() from the script console
        beacons = cs.get_beacons()
        print("BEACONS")
        pprint(beacons)

        # Get list of listners - i.e., x listeners_stageless() from the script console
        listeners = cs.get_listeners_stageless()
        print("LISTENERS")
        pprint(listeners)

if __name__ == "__main__":
    args = parseArguments()
    main(args)

Esegui lo script

python3 example.py 127.0.0.1 50050 example password /path/to/cobaltstrike

Practical Examples

Log Tracker

I log dei beacon sono disponibili in esecuzione in un teamserver o tramite i file di log dei beacon salvati sul teamserver. I dati sono sempre lì, ma potrebbero non essere presentati nel modo desiderato. Questo è un esempio di log tracker che usa una griglia di dati HTML per visualizzare rapidamente i log dei beacon.

beaconlogtracker.py è uno script che si connette a un teamserver, estrae i log dei beacon attivi ogni 30 secondi, li salva in <code>beaconlogs.json` e li visualizza in una griglia di dati HTML ricercabile e ordinabile.

I log dei beacon vengono sempre salvati nella directory dei log, ma questo è un modo alternativo per tracciare i log in memoria con un visualizzatore alternativo. Se il teamserver viene riavviato, i log in memoria vanno persi e bisogna fare riferimento ai log salvati nella directory dei log sul teamserver. Questo script mantiene i log in memoria sincronizzati con il file beaconlogs.json. In questo modo hai un modo rapido e semplice per visualizzare tutti i dati senza scavare nella directory dei log anche se Cobalt Strike viene riavviato.

Avvia lo script facendolo connettere al tuo teamserver per sincronizzare i log ogni 30 secondi

Utilizzo:

python3 beaconlogtracker.py 127.0.0.1 50050 logtracker password /path/to/cobaltstrike

Questo manterrà beaconlogs.json sincronizzato con i log dei beacon salvati e attivi. Si sincronizza ogni 30 secondi

Avvia un webserver dalla directory output/html

python3 -m http.server 8000

Connettiti a http://localhost:8000/beaconlogs.html

Payload Generator

Una funzionalità spesso richiesta dagli operatori red team è la capacità di creare payload programmaticamente senza la necessità della GUI di Cobalt Strike. Il progetto di riferimento lo faceva con un generatore di payload. Era ottimo, ma c'è una sfida unica. Aggressor fornisce diversi hook per influenzare come viene costruito un payload. Questi hook sono usati dai vari kit (ad es., artifact kit, sleep mask kit, o UDRL kit). Normalmente vengono usati caricando uno script aggressor tramite la GUI. Questo progetto è stato esteso per consentire il caricamento di script esterni. Senza questo, usare questi hook per i payload sarebbe difficile. Questo codice potrebbe essere facilmente esteso per passare i payload a funzioni esterne per aggiungere offuscamento personalizzato, incorporarli in un loader personalizzato, o qualsiasi altra modifica.

Lo script del generatore di payload si connette al teamserver, carica gli script aggiuntivi e crea i payload.

Utilizzo (senza kit esterni):

• esegui python3 payloadgenerator.py 127.0.0.1 50050 payloads password /path/to/cobaltstrike

Utilizzo (con kit esterno)

Questo esempio elenca i passaggi per aggiungere l'Arsenal kit che ha i kit artifact e sleep mask abilitati.

• Aggiornare il file /path/to/arsenal_kit/arsenal_kit.config per abilitare i kit artifact e sleep mask
• [Opzionale] Apportare le modifiche necessarie ai kit artifact e sleep mask
• Eseguire la build dell'arsenal kit con /path/to/arsenal_kit/build_arsenal_kit.sh
• Copiare i file di distribuzione dell'arsenal kit nella directory payload_scripts.
  cp -r /path/to/arsenal_kit/dist/* /path/to/sleep_python_bridge/payload_scripts
• [Opzionale] Vedere la sezione logging per maggiori informazioni su modifiche aggiuntive
• esegui python3 payloadgenerator.py 127.0.0.1 50050 payloads password /path/to/cobaltstrike

Logging

Normalmente, quando si usa la GUI, gli script esterni possono usare la funzione aggressor println per inviare informazioni alla Script Console, utile per feedback o debug. Quando si usa payloadgenerator.py, l'output di println viene perso e l'unica opzione disponibile è la funzione elog. Usando elog, è necessaria la GUI per visualizzare le informazioni nell'Event Log.

Continuando dall'esempio di utilizzo 'con kit esterno', aggiorniamo il file /path/to/sleep_python_bridge/payload_scripts/arsenal_kit.cna e cambiamo le due occorrenze di println in elog. Con questa modifica, tutto il logging dell'arsenal kit sarà ora disponibile nell'Event Log della GUI.

Caricamento di script esterni

Il caricamento di script esterni non è sempre necessario, tranne per gli script di modifica dei payload che includono hook per i payload (ad es., kit artifact, sleep mask e udrl). Se carichi script dalla GUI di Cobalt Strike, i payload rispetteranno questi script dalla GUI ma non dal client agscript (sono client diversi). Devi aggiungere gli script e i file di supporto nella directory payload_scripts.

payloadgenerator.py caricherà automaticamente qualsiasi script .cna che si trova nel livello principale della directory payload_scripts. Qualsiasi script .cna che si trova in una sottodirectory non verrà caricato.

Esempio di struttura di directory con l'Arsenal Kit.

$ ls -1R ./payload_scripts
./payload_scripts:
arsenal_kit.cna
artifact
sleepmask

./payload_scripts/artifact:
artifact32big.dll
artifact32big.exe
artifact32.dll
artifact32.exe
artifact32svcbig.exe
artifact32svc.exe
artifact64big.exe
artifact64big.x64.dll
artifact64.exe
artifact64svcbig.exe
artifact64svc.exe
artifact64.x64.dll
artifact.cna

./payload_scripts/sleepmask:
sleepmask.cna
sleepmask_pivot.x64.o
sleepmask_pivot.x86.o
sleepmask.x64.o
sleepmask.x86.o

Utilizzo (opzioni aggiuntive per 4.8)

Grazie a un recente aggiornamento fornito da @mgeeky, lo script payloadgenerator.py ora supporta argomenti aggiuntivi per gestire i nuovi parametri della funzione artifact_payload aggiunti nella 4.8. Con questi argomenti hai ora più controllo sui payload generati.

$ python3 payloadgenerator.py --help
------------------------
Beacon Payload Generator
------------------------
usage: payloadgenerator.py [-h] [-o path] [-l name] [-a arch] [-t types] [-e exit] [-c method] host port username password path

positional arguments:
  host                  The teamserver host.
  port                  The teamserver port.
  username              The desired username.
  password              The teamserver password.
  path                  Directory to CobaltStrike

optional arguments:
  -h, --help            show this help message and exit

optional parameters:
  -o path, --payload-path path
                        Where to save generated payloads. Default: output/payloads/
  -l name, --listener name
                        Specify listener name to get payloads for. Default: payloads for all listeners will be produced
  -a arch, --arch arch  Specify payload architecture. Choices: x86, x64. Default: payloads for both are generated
  -t types, --payload-types types
                        Comma separated list of payload types to generate keyed by file extensions. Choices: exe,dll,svc.exe,bin,ps1,py,vbs or use 'all' to compile all at once.
                        Default: exe,dll,bin
  -e exit, --exit exit  Payload exit method. Choices: thread, process. Default: process
  -c method, --call-method method
                        System call method. Choices: indirect, direct, none. Default: <empty> (backwards compatible with Cobalt pre 4.8)

Esempi

$python3 payloadgenerator.py 127.0.0.1 50050 payloads password /path/to/cobaltstrike -o /share/payloads/ -c indirect -a x64
------------------------
Beacon Payload Generator
------------------------
[*] Connecting to teamserver: 127.0.0.1
Loading cna scripts from ./payload_scripts

Scripts
-------
arsenal_kit.cna
console.cna

[*] Creating stageless payloads for listener: http1
[*] Creating http1.x64.exe
[*] Creating http1.x64.dll
[*] Creating http1.x64.bin

$python3 payloadgenerator.py 127.0.0.1 50050 payloads password /path/to/cobaltstrike -o /share/payloads/ -c indirect -a x64 -t exe
------------------------
Beacon Payload Generator
------------------------
[*] Connecting to teamserver: 127.0.0.1
Loading cna scripts from ./payload_scripts

Scripts
-------
arsenal_kit.cna
console.cna

[*] Creating stageless payloads for listener: http1
[*] Creating http1.x64.exe

$python3 payloadgenerator.py 127.0.0.1 50050 payloads password /path/to/cobaltstrike -o /share/payloads/
------------------------
Beacon Payload Generator
------------------------
[*] Connecting to teamserver: 127.0.0.1
Loading cna scripts from ./payload_scripts

Scripts
-------
arsenal_kit.cna
console.cna

[*] Creating stageless payloads for listener: http1
[*] Creating http1.x86.exe
[*] Creating http1.x86.dll
[*] Creating http1.x86.bin
[*] Creating http1.x64.exe
[*] Creating http1.x64.dll
[*] Creating http1.x64.bin

Beacon Grapher

Questo è un codice beta che visualizzerà i beacon in un grafo diretto.

Lo script aggiorna il file output/data/beacons.json

Avvia un webserver e apri http://localhost:8000/beacons.html

Utilizzo:

python3 beacongrapher.py 127.0.0.1 50050 grapher password /path/to/cobaltstrike

Questo creerà il file beacons.json usato dal grapher javascript.

Avvia un webserver dalla directory output/html

python3 -m http.server 8000

Connettiti a http://localhost:8000/beacons.html