cobalt-strike/sleep_python_bridge
Este projeto é uma 'ponte' entre o sleep e a linguagem python. Ele permite o controle de um teamserver do Cobalt Strike através do python, sem a necessidade do cliente GUI padrão. NOTA: Este projeto está muito em BETA. O objetivo é fornecer um playground para testes e de forma alguma é um recurso oficialmente suportado. Talvez isso possa ser algo adicionado no futuro ao produto principal.
Este projeto é uma 'ponte' entre as linguagens Sleep e Python. Ele permite o controle de um teamserver do Cobalt Strike por meio de Python, sem a necessidade do cliente GUI padrão.
NOTA: Este projeto está muito em fase BETA. O objetivo é fornecer um playground para testes e não é, de forma alguma, um recurso com suporte oficial. Talvez isso possa ser algo adicionado ao produto principal no futuro.
O projeto foi inspirado pelo trabalho de @BinaryFaultline e @Mcgigglez16 no projeto https://github.com/emcghee/PayloadAutomation. Quero agradecer especialmente a vocês dois!!
O coração desta ponte é uma implementação em Python de um cliente Cobalt Strike headless. Isso é alcançado usando o Aggressor Script Console fornecido pelo agscript como mecanismo. O Agscript permite interação headless com o Cobalt Strike (https://www.cobaltstrike.com/aggressor-script/index.html). A 'ponte' funciona usando funções auxiliares em Python no sleepy.py para gerar os comandos Sleep necessários esperados pelo console do agscript. Em vez de escrever as funções Sleep, o striker.py fornece funções auxiliares que abstraem o Sleep e permitem o uso de Python.
Como o projeto PayloadAutomation inspirou este, ele começou com muito do mesmo código, mas eu queria reduzi-lo para usar os componentes necessários para atuar como um wrapper do agscript.
| Item | Description |
|---|---|
| sleep_python_bridge | A biblioteca que permite ao Python interagir com o Cobalt Strike |
| output/html | caminho para visualizadores de dados html |
| output/html/data | caminho para dados json usados pelo visualizador de dados |
| output/payloads | caminho para payloads salvos (usado pelo gerador de payloads) |
| payload_scripts | caminho para scripts externos a serem carregados pelo payloadgenerator.py |
| beaconlogtracker.py | Implementação de um rastreador de logs de beacon que usa uma grade de dados HTML para exibir logs de beacon |
| payloadgenerator.py | Implementação de um gerador de payloads de beacon que cria payloads para cada listener |
| beacongrapher.py | Implementação de um rastreador de gráfico de beacon que usa um grafo direcionado em HTML/JavaScript para beacons |
Os exemplos neste projeto podem ser a maneira mais fácil de entender, mas há o 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)
Execute o script
python3 example.py 127.0.0.1 50050 example password /path/to/cobaltstrike
Os logs de beacon estão disponíveis em tempo de execução em um teamserver ou por meio dos arquivos de log de beacon salvos no teamserver. Os dados estão sempre lá, mas podem não ser apresentados da maneira que você gostaria. Este é um exemplo de rastreador de logs que usa uma grade de dados HTML para visualizar rapidamente os logs de beacon.
beaconlogtracker.py é um script que se conecta a um teamserver, extrai os logs de beacon em execução a cada 30 segundos, salva em <code>beaconlogs.json` e exibe em uma grade de dados HTML pesquisável e ordenável.
Os logs de beacon são sempre salvos no diretório de logs, mas esta é uma maneira alternativa de rastrear os logs em memória com um visualizador alternativo. Se o teamserver for reiniciado, os logs em memória são perdidos e você deve consultar os logs armazenados no diretório de logs do teamserver. Este script mantém os logs em memória sincronizados com o arquivo beaconlogs.json. Dessa forma, você tem um jeito rápido e fácil de visualizar todos os dados sem vasculhar o diretório de logs, mesmo que o Cobalt Strike seja reiniciado.
Inicie o script fazendo-o conectar ao seu teamserver para sincronizar logs a cada 30 segundos
Uso:
python3 beaconlogtracker.py 127.0.0.1 50050 logtracker password /path/to/cobaltstrike
Isso manterá o beaconlogs.json sincronizado com os logs de beacon salvos e em execução. Ele sincroniza a cada 30 segundos
Inicie um servidor web a partir do diretório output/html
python3 -m http.server 8000
Conecte-se a http://localhost:8000/beaconlogs.html
