Desplegar un honeypot en Cowrie

Introducción

En este laboratorio, aprenderá cómo desplegar Cowrie, un honeypot (trampa virtual) SSH de interacción media que captura y analiza el comportamiento de los atacantes. Configurará Cowrie en un entorno virtual de Python y lo configurará para imitar un servicio SSH real mientras habilita un registro exhaustivo.

A través de este ejercicio práctico, probará el honeypot simulando ataques y analizando los registros generados. Esta experiencia práctica le ayudará a comprender cómo funcionan los honeypots como herramientas de ciberseguridad para la detección y análisis de amenazas.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL hydra(("Hydra")) -.-> hydra/HydraGroup(["Hydra"]) wireshark(("Wireshark")) -.-> wireshark/WiresharkGroup(["Wireshark"]) wireshark/WiresharkGroup -.-> wireshark/protocol_dissection("Protocol Dissection") wireshark/WiresharkGroup -.-> wireshark/packet_analysis("Packet Analysis") hydra/HydraGroup -.-> hydra/installation("Installation and Setup") subgraph Lab Skills wireshark/protocol_dissection -.-> lab-549933{{"Desplegar un honeypot en Cowrie"}} wireshark/packet_analysis -.-> lab-549933{{"Desplegar un honeypot en Cowrie"}} hydra/installation -.-> lab-549933{{"Desplegar un honeypot en Cowrie"}} end

Instalar Cowrie

En este paso, instalará Cowrie, un honeypot (trampa virtual) SSH de interacción media diseñado para registrar ataques de fuerza bruta y la interacción de shell realizada por los atacantes. Cowrie está implementado en Python y se puede instalar fácilmente utilizando pip. Un honeypot es un mecanismo de seguridad que imita sistemas reales para atraer y estudiar la actividad maliciosa, lo que ayuda a los profesionales de la seguridad a entender los patrones de ataque.

Primero, asegúrese de estar en el directorio de trabajo predeterminado. Aquí es donde mantendremos todos los archivos del proyecto organizados:
```
cd ~/project
```
Instale las dependencias del sistema necesarias para Cowrie. Estos paquetes proporcionan componentes esenciales necesarios para que Cowrie funcione correctamente, incluyendo herramientas de desarrollo de Python y bibliotecas criptográficas:
```
sudo apt-get update && sudo apt-get install -y python3-venv python3-dev libssl-dev libffi-dev build-essential
```
Cree un entorno virtual de Python para Cowrie. Los entornos virtuales mantienen las dependencias del proyecto aisladas de la instalación de Python de su sistema, evitando posibles conflictos:
```
python3 -m venv cowrie-env
```
Active el entorno virtual. Cuando se activa, cualquier paquete de Python que instale irá a este entorno aislado en lugar de a la instalación de Python de todo el sistema:
```
source cowrie-env/bin/activate
```
Instale Cowrie utilizando pip. Pip es el administrador de paquetes de Python que descargará e instalará Cowrie junto con sus dependencias:
```
pip install cowrie
```
Verifique la instalación comprobando la versión de Cowrie. Esto confirma que el paquete se instaló correctamente y muestra la versión que está ejecutando:
```
cowrie --version
```
Debería ver una salida similar a:
```
cowrie 2.1.0
```
Desactive el entorno virtual cuando haya terminado. Esto lo devuelve al entorno de Python predeterminado de su sistema:
```
deactivate
```

Configurar la configuración del honeypot

En este paso, configurará la configuración del honeypot Cowrie para personalizar su comportamiento y capacidades de registro. Los archivos de configuración actúan como el cerebro de su honeypot, determinando cómo interactúa con posibles atacantes y qué datos se registran para su análisis.

Primero, active el entorno virtual de Python creado en el paso anterior. Esto aisla las dependencias de Cowrie de la instalación de Python de su sistema:
```
cd ~/project
source cowrie-env/bin/activate
```
Genere los archivos de configuración predeterminados. Estas plantillas contienen todas las configuraciones disponibles con sus valores predeterminados:
```
cowrie-gen-config
```
Esto creará archivos de configuración en ~/project/cowrie-env/etc/cowrie/
Edite el archivo de configuración principal utilizando nano, un editor de texto amigable para principiantes:
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Modifique estas configuraciones clave (utilice las teclas de flecha para navegar, Ctrl+O para guardar y Ctrl+X para salir):
- Cambie listen_port = 2222 a listen_port = 22 - esto hace que el honeypot parezca un servidor SSH estándar
- Establezca enabled = true en la sección [output_json] - habilita el registro estructurado para un análisis más fácil
- Establezca enabled = true en la sección [output_textlog] - proporciona registros legibles por humanos
Cree un directorio dedicado para los archivos de registro. Mantener los registros separados ayuda con la organización y el análisis:
```
mkdir -p ~/project/cowrie-logs
```
Actualice la ruta de registro en la configuración para que apunte a su nuevo directorio:
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Busque la configuración log_path y cámbiela a:
```
log_path = /home/labex/project/cowrie-logs
```
Verifique los cambios en su configuración comprobando las configuraciones modificadas:
```
grep -E 'listen_port|enabled|log_path' cowrie-env/etc/cowrie/cowrie.cfg
```
Debería ver una salida que refleje sus cambios, lo que confirma que la configuración se guardó correctamente.

Iniciar el servicio SSH

En este paso, iniciará el servicio SSH del honeypot Cowrie que escuchará las conexiones entrantes. Dado que estamos ejecutando en un contenedor Docker sin systemd, utilizaremos la ejecución directa de procesos. Este enfoque es más sencillo que la gestión de servicios tradicional y está mejor adaptado a entornos contenerizados.

Primero, asegúrese de estar en el directorio correcto y active el entorno virtual. El entorno virtual contiene todas las dependencias de Python necesarias aisladas de su sistema:
```
cd ~/project
source cowrie-env/bin/activate
```
Inicie el servicio Cowrie en segundo plano. La bandera -n hace que se ejecute en modo no demonio (mostrando la salida directamente en la terminal), mientras que & coloca el proceso en segundo plano para que pueda seguir utilizando la terminal:
```
cowrie start -n &
```
Verifique que el servicio esté en ejecución comprobando la lista de procesos. Este comando filtra todos los procesos en ejecución para mostrar solo aquellos que contengan "cowrie":
```
ps aux | grep cowrie
```
Debería ver una salida similar a:
```
labex   12345  0.0  0.5  12345  6789 ?        S    12:34   0:00 python cowrie start -n
```
Compruebe si el servicio está escuchando en el puerto 22. Esto es crucial porque las conexiones SSH llegarán a este puerto. El comando muestra todos los servicios de red y sus puertos de escucha:
```
sudo netstat -tulnp | grep 22
```
Debería ver una salida que indique que Python está escuchando en el puerto 22.
Para hacer que el servicio sea persistente a través de sesiones de terminal, cree un sencillo script de mantenimiento. Esto asegura que el honeypot siga en ejecución incluso si cierra la terminal:
```
nano cowrie-keepalive.sh
```
Agregue el siguiente contenido:
```
#!/bin/bash
source ~/project/cowrie-env/bin/activate
cowrie start -n
```
Haga que el script sea ejecutable para que se pueda ejecutar directamente:
```
chmod +x cowrie-keepalive.sh
```
Ahora puede ejecutar el honeypot ejecutando este script. Activará el entorno e iniciará Cowrie en un solo paso:
```
./cowrie-keepalive.sh
```

Simular un ataque

En este paso, simulará un ataque de fuerza bruta SSH contra su honeypot Cowrie para verificar sus capacidades de registro. Esta simulación ayuda a demostrar cómo los atacantes del mundo real podrían intentar obtener acceso no autorizado y cómo el honeypot registra estos intentos para su análisis.

Primero, asegúrese de que su honeypot Cowrie esté en funcionamiento (desde el paso anterior):
```
ps aux | grep cowrie
```
Este comando comprueba si el proceso Cowrie está activo. Debería ver 'cowrie' en la lista de salida.
Instale el cliente SSH si no está disponible:
```
sudo apt-get install -y openssh-client
```
El paquete openssh-client proporciona el comando ssh que usaremos para conectarnos a nuestro honeypot. La bandera '-y' confirma automáticamente cualquier solicitud.
Simule un ataque de fuerza bruta intentando múltiples conexiones SSH con combinaciones comunes de nombre de usuario/contraseña:
```
for i in {1..5}; do
  sshpass -p 'password' ssh -o StrictHostKeyChecking=no -p 22 labex@localhost
  sshpass -p 'admin' ssh -o StrictHostKeyChecking=no -p 22 admin@localhost
  sshpass -p 'root' ssh -o StrictHostKeyChecking=no -p 22 root@localhost
done
```
Este script intenta pares comunes de nombre de usuario/contraseña (como root/password) cinco veces cada uno. La opción '-o StrictHostKeyChecking=no' evita que SSH pregunte sobre hosts desconocidos, lo que facilita la automatización.
Simule un ataque más sofisticado utilizando Hydra (preinstalado en la máquina virtual LabEx):
```
hydra -L /usr/share/wordlists/metasploit/unix_users.txt -P /usr/share/wordlists/metasploit/unix_passwords.txt -t 4 -vV localhost ssh
```
Hydra es una herramienta de fuerza bruta poderosa. Aquí intenta combinaciones de las listas de palabras proporcionadas (-L para nombres de usuario, -P para contraseñas). La opción '-t 4' limita a 4 intentos en paralelo, y '-vV' muestra una salida detallada.
Verifique que los ataques se hayan registrado comprobando los registros de Cowrie:
```
ls -l ~/project/cowrie-logs/
```
Después de ejecutar los ataques, este comando muestra nuevos archivos de registro que contienen detalles de todos los intentos de conexión. Estos registros son los que los analistas de seguridad examinarían en una implementación real.

Revisar los registros de ataques

En este paso, analizará los registros de ataques generados por Cowrie para comprender los ataques simulados del paso anterior. Los registros contienen información de seguridad valiosa sobre los intentos de ataque. Cowrie registra automáticamente todos los intentos de interacción en dos formatos: un registro de texto simple para lectura rápida y un registro JSON estructurado para análisis detallado.

Primero, navegue al directorio de registros donde Cowrie almacena todos sus archivos de registro:
```
cd ~/project/cowrie-logs
```
Vea el archivo de registro basado en texto (el más reciente primero). El comando ls -lt muestra los archivos ordenados por tiempo de modificación, mientras que tail muestra las últimas 20 líneas del registro más reciente:
```
ls -lt cowrie.log*
tail -n 20 cowrie.log
```
Debería ver entradas que muestren intentos de inicio de sesión fallidos con marcas de tiempo, nombres de usuario y direcciones IP.
Examine el archivo de registro JSON para obtener datos estructurados. La herramienta jq ayuda a analizar JSON, y less permite desplazarse por una salida larga:
```
jq '.' cowrie.json | less
```
Busque entradas con "eventid": "cowrie.login.failed" que indiquen intentos de autenticación fallidos.
Busque patrones de ataque específicos que apunten a cuentas de administrador comunes. El comando grep busca patrones de texto en archivos:
```
grep -a "root" cowrie.log
grep -a "admin" cowrie.log
```

Genere un resumen de los intentos de ataque. Estos comandos extraen y cuentan los nombres de usuario y contraseñas más frecuentemente intentados de los registros JSON:

echo "Top usernames attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .username' cowrie.json | sort | uniq -c | sort -nr

echo -e "\nTop passwords attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .password' cowrie.json | sort | uniq -c | sort -nr

Vea la información de la dirección IP de origen (mostrará localhost en esta simulación). Esto extrae las direcciones IP de los clientes que se conectan:
```
jq -r 'select(.eventid=="cowrie.session.connect") | .src_ip' cowrie.json
```

Resumen

En este laboratorio, has aprendido cómo desplegar un honeypot SSH Cowrie para monitorear y analizar ataques cibernéticos. El proceso incluyó configurar un entorno virtual de Python, configurar puertos SSH y habilitar el registro en formato JSON para recopilar datos detallados de los ataques.

También has adquirido experiencia práctica en iniciar el servicio del honeypot, simular ataques y analizar los datos registrados. Este ejercicio práctico demostró cómo las herramientas de seguridad pueden imitar sistemas reales para detectar y estudiar actividades maliciosas de manera efectiva.