¿Qué es Octopus?

Octopus es un servidor C2 de preoperación de código abierto basado en Python que puede controlar un agente de Octopus PowerShell a través de HTTP/S.

El propósito principal de crear Octopus es usarlo antes de cualquier operación de red team, donde en lugar de comenzar el compromiso con todo tu arsenal operativo e infraestructura, puedes usar Octopus primero para atacar el objetivo y recopilar información antes de iniciar tu operación real de red team.

Octopus funciona de una manera muy simple para ejecutar comandos e intercambiar información con el C2 a través de un canal bien cifrado, lo que lo hace discreto e indetectable para casi todos los antivirus, protecciones de endpoints y soluciones de monitoreo de red.

Una característica interesante de Octopus se llama ESA, que significa "Endpoint Situational Awareness" (Conciencia Situacional del Endpoint), que recopilará información importante sobre el objetivo que te ayudará a comprender mejor los endpoints de la red objetivo que enfrentarás durante tu operación, dándote así la oportunidad de personalizar tu operación real basándote en esta información.

Octopus está diseñado para ser sigiloso y encubierto mientras se comunica con el C2, ya que utiliza AES-256 por defecto para su canal cifrado entre el agente de PowerShell y el servidor C2. También puedes optar por usar SSL/TLS proporcionando un certificado válido para tu dominio y configurando el servidor C2 de Octopus para usarlo.

Características clave de Octopus

Octopus está repleto de varias características que te permiten obtener información sobre tu próxima operación antes de que necesites desplegar todo tu arsenal o herramientas y técnicas, como:

• Controlar agentes a través de HTTP/S.
• Ejecutar comandos del sistema.
• Descargar / Subir archivos.
• Cargar módulos externos de PowerShell.
• Usar canales cifrados (AES-256) entre el C2 y los agentes.
• Usar técnicas discretas para ejecutar comandos y transferir resultados.
• Crear listeners personalizados y múltiples para cada objetivo.
• Generar diferentes tipos de payloads.
• Compatible con todas las versiones de Windows con PowerShell 2.0 y superiores.
• Ejecutar el agente ejecutable de Octopus en Windows sin tocar el proceso powershell.exe.
• Recopilar información automáticamente del endpoint (conciencia situacional del endpoint).

Requisitos

Puedes instalar todos los requisitos de Octopus mediante:

pip install -r requirements.txt

Necesitas instalar nasm para Linux y el compilador 'mingw-w64' para usar la funcionalidad de shellcoding y el agente de argumentos suplantados.

Puedes instalar nasm en distribuciones basadas en Debian usando:

apt install nasm

Y puedes instalar mingw-w64 en distribuciones basadas en Debian usando:

apt install mingw-w64

Octopus ha sido probado en los siguientes sistemas operativos:

• Ubuntu (18.04)
• Ubuntu (16.04)
• Kali Linux (2019.2)

También necesitarás instalar Mono para asegurarte de que puedes compilar el código fuente en C# sin problemas.

Octopus depende del binario mono-csc para compilar el código fuente en C# y puedes instalarlo con el siguiente comando apt install mono-devel, el cual ha sido probado en Kali y Ubuntu 16.04.

Puedes usar Octopus sin instalar Mono pero no podrás usar el comando generate_exe.

También ten en cuenta que compilar C# depende del ensamblado System.Management.Automation.dll con el hash SHA1 a43ed886b68c6ee913da85df9ad2064f1d81c470.

Si encuentras algún problema al usar Octopus, no dudes en informar de un bug.

Instalación

En primer lugar, asegúrate de descargar la última versión de Octopus usando el siguiente comando:

git clone https://github.com/mhaskar/Octopus/

Luego necesitas instalar los requisitos usando el siguiente comando:

pip install -r requirements.txt

Después de eso, puedes iniciar el servidor de Octopus ejecutando lo siguiente:

./octopus.py

Serás recibido con lo siguiente una vez que lo ejecutes:

┌─[askar@hackbook]─[/opt/redteaming/Octopus]
└──╼ $python3 octopus.py



      ___           ___                       ___           ___         ___           ___
     /  /\         /  /\          ___        /  /\         /  /\       /__/\         /  /\
    /  /::\       /  /:/         /  /\      /  /::\       /  /::\      \  \:\       /  /:/_
   /  /:/\:\     /  /:/         /  /:/     /  /:/\:\     /  /:/\:\      \  \:\     /  /:/ /\
  /  /:/  \:\   /  /:/  ___    /  /:/     /  /:/  \:\   /  /:/~/:/  ___  \  \:\   /  /:/ /::\
 /__/:/ \__\:\ /__/:/  /  /\  /  /::\    /__/:/ \__\:\ /__/:/ /:/  /__/\  \__\:\ /__/:/ /:/\:\
 \  \:\ /  /:/ \  \:\ /  /:/ /__/:/\:\   \  \:\ /  /:/ \  \:\/:/   \  \:\ /  /:/ \  \:\/:/~/:/
  \  \:\  /:/   \  \:\  /:/  \__\/  \:\   \  \:\  /:/   \  \::/     \  \:\  /:/   \  \::/ /:/
   \  \:\/:/     \  \:\/:/        \  \:\   \  \:\/:/     \  \:\      \  \:\/:/     \__\/ /:/
    \  \::/       \  \::/          \__\/    \  \::/       \  \:\      \  \::/        /__/:/
     \__\/         \__\/                     \__\/         \__\/       \__\/         \__\/


                    v1.2 estable !


 Octopus C2 | Controla tus shells


Octopus >>

Uso

Usar Octopus es bastante simple, ya que solo necesitas iniciar un listener y generar tu agente basado en la información de ese listener.

Puedes generar tantos listeners como necesites, y luego puedes comenzar a interactuar con tus agentes que se conectan a ellos.

Configuración del perfil

Antes de que puedas empezar a usar Octopus, debes configurar un perfil de manejo de URLs que controlará el comportamiento y las funciones del C2, ya que Octopus es un C2 basado en HTTP, por lo que depende de las URLs para manejar las conexiones y para garantizar que las URLs no sirvan como firmas o IoC en la red que estás atacando; las URLs pueden ser fácilmente personalizadas y renombradas según sea necesario.

La configuración del perfil actualmente solo soporta el manejo de URLs, el valor de auto kill y los encabezados.

Configuración de tu perfil

Para comenzar a configurar tu perfil, necesitas editar el archivo profile.py, que contiene varias variables clave, que son:

• file_receiver_url: maneja la descarga de archivos.
• report_url: maneja los informes de ESA.
• command_send_url: maneja los comandos que se enviarán al objetivo.
• command_receiver_url: maneja los comandos que se ejecutarán en el objetivo.
• first_ping_url: maneja la primera conexión desde el objetivo.
• server_response_header: este encabezado se mostrará en cada respuesta.
• auto_kill: variable para controlar cuándo se eliminará el agente después de N conexiones fallidas con el C2.

Ejemplo:

#!/usr/bin/python3

# this is the web listener profile for Octopus C2
# you can customize your profile to handle a specific URLs to communicate with the agent
# TODO : add the ability to customize the request headers

# handling the file downloading
# Ex : /anything
# Ex : /anything.php
file_receiver_url = "/messages"


# handling the report generation
# Ex : /anything
# Ex : /anything.php
report_url = "/calls"

# command sending to agent (store the command will be executed on a host)
# leave <hostname> as it with the same format
# Ex : /profile/<hostname>
# Ex : /messages/<hostname>
# Ex : /bills/<hostname>
command_send_url = "/view/<hostname>"


# handling the executed command
# Ex : /anything
# Ex : /anything.php
command_receiver_url = "/bills"


# handling the first connection from the agent
# Ex : /anything
# Ex : /anything.php
first_ping_url = "/login"

# will return in every response as Server header
server_response_header = "nginx"

# will return white page that includes HTA script
mshta_url = "/hta"

# auto kill value after n tries

auto_kill = 10