Cobalt Strike Sleep Python Bridge

Este proyecto es un 'puente' entre el lenguaje sleep y python. Permite el control de un teamserver de Cobalt Strike a través de python sin necesidad del cliente GUI estándar.

NOTA: Este proyecto está muy en BETA. El objetivo es proporcionar un campo de pruebas para testing y de ninguna manera es una característica con soporte oficial. Quizás esto podría ser algo añadido en el futuro al producto principal.

El proyecto fue inspirado por el trabajo realizado por @BinaryFaultline y @Mcgigglez16 en el proyecto https://github.com/emcghee/PayloadAutomation. ¡¡Quiero ofrecer un agradecimiento especial a ambos!!

El corazón de este puente es una implementación en python de un cliente headless de Cobalt Strike. Esto se logra utilizando la Aggressor Script Console proporcionada por agscript como motor. Agscript permite la interacción headless con Cobalt Strike (https://www.cobaltstrike.com/aggressor-script/index.html). El 'bridge' funciona mediante funciones auxiliares de python en sleepy.py para generar los comandos sleep necesarios que espera la consola agscript. En lugar de escribir las funciones sleep, striker.py proporciona funciones auxiliares que abstraen sleep y permiten el uso de python.

Cambios destacados del proyecto original

Debido a que el proyecto PayloadAutomation inspiró esto, comenzó con gran parte del mismo código, pero quería reducirlo para usar los componentes necesarios para actuar como un wrapper de agscript.

• Renombrado de Payload_Automation a sleep_python_bridge. Este proyecto es más que generación de payloads.
• Cambiado de una biblioteca PyPI a módulos locales. Esto se hizo para pruebas y puede ser un buen candidato para una biblioteca python después de pruebas exhaustivas.
• Actualizados y añadidos helpers para coincidir con las versiones de aggressor.
• Añadida la capacidad de cargar scripts externos.

Bibliotecas incluidas

• Striker: Un conjunto de funciones para interactuar con Cobalt Strike y ejecutar funcionalidades normalmente solo accesibles vía Sleep/GUI.
• Sleepy: Un conjunto de funciones para facilitar un puente entre objetos Sleep y objetos Python.
• Compyler: Un conjunto de funciones para compilar varios payloads desde plataforma o multiplataforma.
• Artifactor: Un conjunto de funciones para inspeccionar y revisar artefactos y recopilar y rastrear IoCs.

Archivos y Directorios

Pendientes

• Documentar las funciones expuestas
• Mover las funciones basadas en compilación de striker.py a compyler.py
• Añadir comprobaciones de errores adicionales, específicamente para dependencias de la aplicación
• Ampliar compyler para incluir builds remotas y mingw
• Añadir seguimiento de IOC a los payloads generados mediante artifactor.py
• Manejar el error: "User is already connected."
• Considerar convertir esto en una biblioteca python formal

Cómo usar

Puede que la forma más fácil de entender este proyecto sean los ejemplos, pero el script es 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)

Ejecuta el script

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

Ejemplos Prácticos

Rastreador de logs

Los logs de beacon están disponibles en tiempo de ejecución en un teamserver o a través de los archivos de log de beacon guardados en el teamserver. Los datos siempre están ahí, pero puede que no se presenten de la forma que te gustaría. Este es un ejemplo de rastreador de logs que utiliza un data grid HTML para ver rápidamente los logs de beacon.

beaconlogtracker.py es un script que se conecta a un teamserver, extrae los logs de beacon en ejecución cada 30 segundos, guarda en <code>beaconlogs.json` y los muestra en un data grid HTML buscable y ordenable.

Los logs de beacon siempre se guardan en el directorio de logs, pero esta es una forma alternativa de rastrear los logs en memoria con un visor alternativo. Si el teamserver se reinicia, los logs en memoria se pierden y debes consultar los logs almacenados en el directorio de logs del teamserver. Este script mantiene los logs en memoria sincronizados con el archivo beaconlogs.json. De esta manera tienes una forma rápida y sencilla de visualizar todos los datos sin tener que revisar el directorio de logs incluso si Cobalt Strike se reinicia.

Inicia el script haciendo que se conecte a tu teamserver para sincronizar los logs cada 30 segundos

Uso:

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

Esto mantendrá beaconlogs.json sincronizado con los logs de beacon guardados y en ejecución. Se sincroniza cada 30 segundos

Inicia un servidor web desde el directorio output/html

python3 -m http.server 8000

Conéctate a http://localhost:8000/beaconlogs.html

Generador de Payloads

Una característica que los operadores de red team solicitan a menudo es la capacidad de crear payloads programáticamente sin necesidad de la GUI de Cobalt Strike. El proyecto de referencia hacía esto con un generador de payloads. Era genial, pero hay un desafío único. Aggressor proporciona varios hooks para influir en cómo se construye un payload. Estos hooks son utilizados por los distintos kits (es decir, artifact kit, sleep mask kit o kit UDRL). Normalmente se usan cargando un script de aggressor a través de la GUI. Este proyecto se amplió para permitir la carga de scripts externos. Sin esto, usar estos hooks de payload sería difícil. Este código podría ampliarse fácilmente para pasar los payloads a funciones externas y añadir ofuscación personalizada, incrustarlos en un loader personalizado, o cualquier otra modificación.

El script del generador de payloads se conecta al teamserver, carga los scripts adicionales y crea payloads.

Uso (sin kits externos):

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

Uso (con kit externo)

Este ejemplo enumerará los pasos para añadir el Arsenal kit, que tiene los kits artifact y sleep mask habilitados.

• Actualiza el archivo /path/to/arsenal_kit/arsenal_kit.config para habilitar los kits artifact y sleep mask
• [Opcional] Realiza las modificaciones necesarias en los kits artifact y sleep mask
• Compila el arsenal kit con /path/to/arsenal_kit/build_arsenal_kit.sh
• Copia los archivos de distribución del arsenal kit al directorio payload_scripts.
  cp -r /path/to/arsenal_kit/dist/* /path/to/sleep_python_bridge/payload_scripts
• [Opcional] Consulta la sección de logging para más información sobre modificaciones adicionales
• ejecuta python3 payloadgenerator.py 127.0.0.1 50050 payloads password /path/to/cobaltstrike

Logging

Normalmente, al usar la GUI, los scripts externos pueden usar la función println de aggressor para enviar información a la Script Console, lo cual es útil para retroalimentación o depuración. Al usar payloadgenerator.py, la salida de println se pierde y la única opción disponible es la función elog. Cuando se usa elog, se necesita la GUI para ver la información en el Event Log.

Continuando con el ejemplo de uso 'con kit externo', actualicemos el archivo /path/to/sleep_python_bridge/payload_scripts/arsenal_kit.cna y cambiemos las dos apariciones de println por elog. Con este cambio, todo el registro del arsenal kit estará disponible en el Event Log de la GUI.

Carga de scripts externos

Cargar scripts externos no siempre es necesario, excepto para scripts de modificación de payloads que incluyen hooks de payload (es decir, kits artifact, sleep mask y udrl). Si cargas scripts desde la GUI de Cobalt Strike, los payloads respetarán estos scripts desde la GUI pero no desde el cliente agscript (son clientes diferentes). Debes añadir los scripts y archivos de soporte al directorio payload_scripts.

payloadgenerator.py cargará automáticamente cualquier script .cna que se encuentre en el nivel superior del directorio payload_scripts. Cualquier script .cna ubicado en un subdirectorio no se cargará.

Ejemplo de estructura de directorios con el 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

Uso (opciones adicionales para 4.8)

Gracias a una actualización reciente proporcionada por @mgeeky, el script payloadgenerator.py ahora admite argumentos adicionales para soportar los nuevos parámetros de la función artifact_payload añadidos en 4.8. Con estos argumentos ahora tienes más control sobre qué payloads se generan.

$ 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)

Ejemplos

$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

Graficador de Beacons

Este es un código beta que mostrará los beacons en un grafo dirigido.

El script actualiza el archivo output/data/beacons.json

Inicia un servidor web y abre http://localhost:8000/beacons.html

Uso:

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

Esto creará el archivo beacons.json utilizado por el graficador javascript.

Inicia un servidor web desde el directorio output/html

python3 -m http.server 8000

Conéctate a http://localhost:8000/beacons.html