cobalt-strike/sleep_python_bridge
Questo progetto è un 'ponte' tra il linguaggio sleep e python. Consente il controllo di un teamserver Cobalt Strike tramite python senza la necessità del client GUI standard. NOTA: Questo progetto è molto in BETA. L'obiettivo è fornire un parco giochi per test e non è in alcun modo una funzionalità supportata ufficialmente. Forse questo potrebbe essere aggiunto in futuro al prodotto principale.
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.
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.
| Elemento | Descrizione |
|---|---|
| sleep_python_bridge | La libreria che consente a Python di interfacciarsi con Cobalt Strike |
| output/html | percorso per i visualizzatori di dati html |
| output/html/data | percorso per i dati json usati dal visualizzatore di dati |
| output/payloads | percorso per i payload salvati (usato dal generatore di payload) |
| payload_scripts | percorso per gli script esterni da caricare tramite payloadgenerator.py |
| beaconlogtracker.py | Implementazione di un tracker dei log dei beacon che usa un datagrid HTML per visualizzare i log dei beacon |
| payloadgenerator.py | Implementazione di un generatore di payload per beacon che crea payload per ogni listener |
| beacongrapher.py | Implementazione di un tracker dei grafi dei beacon che usa un grafo diretto HTML/javascript per i beacon |
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
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
