Pacu en Kali Linux: Guía Rápida

https://www.onlinetis.com/es/

Pacu en Kali Linux: Guía Rápida

Parece que estás interesado en utilizar Pacu dentro de Kali Linux, probablemente para realizar auditorías de seguridad en entornos de AWS.

Pacu es un framework de explotación de código abierto diseñado específicamente para evaluar la seguridad de las infraestructuras en la nube. Si ya tienes Kali listo, aquí tienes una guía rápida para configurarlo y entender cómo funciona.

¿Qué es Pacu?

Desarrollado por Rhino Security Labs, Pacu es a AWS lo que Metasploit es a los sistemas operativos tradicionales. Permite a los profesionales de seguridad:

Enumerar usuarios, roles y servicios.
Escalar privilegios mediante configuraciones erróneas.
Exfiltrar datos de S3 o bases de datos.
Mantener persistencia en el entorno de la nube.

Instalación en Kali Linux

Kali no suele traer Pacu preinstalado, pero la instalación es sencilla usando pip. Se recomienda usar un entorno virtual para evitar conflictos.

Actualiza tu sistema:
Bash
```
sudo apt update && sudo apt upgrade
```
Instala las dependencias y Pacu:
Bash
```
pip3 install pacu
```
Nota: Si prefieres el código fuente, puedes clonarlo desde GitHub: git clone https://github.com/RhinoSecurityLabs/pacu.

Flujo de Trabajo Básico

Una vez instalado, simplemente ejecutas pacu en tu terminal. El flujo suele ser el siguiente:

1. Configuración de Sesión

Pacu guarda tu progreso en bases de datos locales. Al iniciar, te pedirá un nombre para la sesión.

2. Configuración de Credenciales

Necesitas las llaves de acceso (Access Key ID y Secret Access Key) de la cuenta de AWS que vas a auditar.

Comando: set_keys

3. Ejecución de Módulos

Pacu funciona por módulos. Puedes listarlos todos con list.

Enumeración: run iam__enum_users_roles_policies (para ver qué permisos tienes).
Escalada de Privilegios: run iam__privesc_scan (analiza automáticamente si puedes obtener más poder).

Recomendaciones de Seguridad

Importante: Nunca uses Pacu en entornos de producción o cuentas de terceros sin una autorización explícita (Pentesting legal). AWS detecta rápidamente actividades sospechosas a través de GuardDuty y CloudTrail.

Ventajas de usarlo en Kali:

Centralización: Tienes tus herramientas de red y nube en un solo lugar.
Reportes: Pacu permite exportar los datos recolectados, facilitando la creación de informes de auditoría.

Aquí tienes un pequeño script en Bash que puedes copiar y pegar. Este script automatiza la creación de un entorno virtual (para mantener tu Kali limpio), instala Pacu y configura los requisitos necesarios.

Script de instalación automatizada

Bash
#!/bin/bash

# Actualizar repositorios
echo "[+] Actualizando repositorios..."
sudo apt update -y

# Instalar pip y venv si no están presentes
echo "[+] Instalando dependencias de Python..."
sudo apt install -y python3-pip python3-venv git

# Crear un directorio para Pacu y entrar en él
mkdir -p ~/tools/pacu
cd ~/tools/pacu

# Crear entorno virtual
echo "[+] Creando entorno virtual..."
python3 -m venv venv
source venv/bin/activate

# Instalar Pacu vía pip
echo "[+] Instalando Pacu..."
pip install pacu

echo "--------------------------------------------------"
echo "[!] Instalación completada."
echo "[!] Para usarlo: cd ~/tools/pacu && source venv/bin/activate && pacu"
echo "--------------------------------------------------"

Cómo usar este script:

Abre tu terminal en Kali.
Crea el archivo: nano instalar_pacu.sh.
Pega el código de arriba.
Dale permisos de ejecución: chmod +x instalar_pacu.sh.
Ejecútalo: ./instalar_pacu.sh.

Un par de tips "pro" para Kali:

AWS CLI: Te recomiendo instalar también la herramienta oficial de AWS (sudo apt install awscli). A veces Pacu necesita interactuar con perfiles configurados mediante aws configure.
Proxy/VPN: Si estás haciendo un pentest externo, recuerda que muchas empresas bloquean IPs conocidas de centros de datos o rangos de VPN. Ejecutar Pacu desde tu Kali local con una IP residencial suele ser más sigiloso que desde una instancia de AWS (EC2).

Una vez que ya tienes configurado el entorno y tus credenciales de AWS en Pacu (mediante set_keys), lo ideal es no lanzar ataques a ciegas. En AWS, el reconocimiento (Recon) es vital para saber qué servicios están activos y qué tan lejos puedes llegar.

Aquí tienes los módulos más comunes para empezar, divididos por su función:

1. Reconocimiento de Identidad (IAM)

Antes de tocar cualquier servidor, necesitas saber "quién eres" y qué permisos tienes asignados.

run iam__get_confirm_permissions: Es el primer paso obligado. Intenta determinar qué permisos tiene tu llave actual.
run iam__enum_users_roles_policies: Lista todos los usuarios, roles y políticas del entorno. Te ayuda a mapear la superficie de ataque.
run iam__privesc_scan: El más importante. Analiza automáticamente si alguna de tus políticas te permite escalar privilegios (por ejemplo, si puedes crear un nuevo usuario con permisos de administrador).

2. Enumeración de Recursos (Infraestructura)

Ahora que sabes quién eres, toca ver qué hay "encendido" en la cuenta.

run ec2__enum: Busca instancias (servidores virtuales), grupos de seguridad y redes (VPC). Muy útil para encontrar servidores olvidados.
run s3__list_buckets: Lista todos los buckets de S3. Los buckets mal configurados son la fuente número uno de filtración de datos en AWS.
run lambda__enum: Busca funciones Lambda. A veces estas funciones contienen variables de entorno con contraseñas o llaves de otras bases de datos.

3. Comandos de Utilidad en la Consola

Dentro de la terminal de Pacu, estos comandos te ayudarán a moverte rápido:

Comando	Descripción
`list`	Muestra todos los módulos disponibles (más de 50).
`search <término>`	Busca módulos específicos (ej: `search s3`).
`help <módulo>`	Explica qué hace un módulo antes de que lo ejecutes.
`whoami`	Te muestra los detalles de la llave que estás usando actualmente.

Un ejemplo práctico de flujo:

set_keys (pones tus llaves).
run iam__get_confirm_permissions (¿qué puedo hacer?).
run iam__privesc_scan (¿puedo ser administrador?).
run ec2__enum (¿qué servidores puedo atacar?).

Consejo de Seguridad (Blue Team)

Recuerda que casi todas estas acciones dejan rastro en AWS CloudTrail. Si estás en una auditoría real, el equipo de defensa verá ráfagas de llamadas a la API (especialmente con los módulos de enumeración).

Configurar las llaves de acceso (Access Keys) es el paso más crítico. Si las manejas mal, podrías exponer tu propia máquina o, peor aún, dejar rastro de las llaves en el historial de comandos de Kali.

Aquí te explico la forma profesional y segura de hacerlo dentro de Pacu.

1. Obtención Segura de Credenciales

Antes de entrar a Kali, asegúrate de que en la consola de AWS el usuario IAM tenga habilitado el MFA y que las llaves que generes sean temporales si es posible.

Regla de oro: Nunca uses las llaves de la "Cuenta Raíz" (Root). Crea un usuario IAM con permisos limitados para la auditoría.

2. Configuración dentro de Pacu

En lugar de configurar variables de entorno en Linux (que pueden quedar grabadas en .bash_history), lo ideal es hacerlo dentro de la sesión interactiva de Pacu.

Inicia Pacu:
Bash
```
pacu
```
Crea o selecciona una sesión: (Ejemplo: auditoria_marzo)
Ejecuta el comando de llaves:
Bash
```
set_keys
```
Sigue los pasos:
- Alias: Un nombre para identificar la llave (ej: admin_test).
- Access Key ID: Pégalo aquí.
- Secret Access Key: Pégalo aquí (no se mostrará en pantalla por seguridad).
- Session Token: Solo si estás usando credenciales temporales o MFA.

3. Verificación de Seguridad (Whoami)

Una vez añadidas, no asumas que funcionan. Usa el comando interno para verificar qué identidad estás proyectando hacia la nube de AWS:

Bash

whoami

Esto te devolverá el ARN (Amazon Resource Name) del usuario, la cuenta y si las llaves están activas. Si recibes un error de "403 Forbidden", es que las llaves son correctas pero no tienes permisos ni siquiera para consultar quién eres.

4. Buenas Prácticas de "Higiene" en Kali

Para evitar filtraciones accidentales mientras trabajas:

No uses export AWS_ACCESS_KEY_ID=... directamente en la terminal de Kali. Si lo haces, cualquier persona con acceso a tu máquina (o un malware) podría leer tu archivo ~/.bash_history.
Usa el comando history -c al terminar tu sesión si sospechas que escribiste algo sensible.
Base de datos de Pacu: Pacu guarda las llaves en una base de datos SQLite local (~/.pacu/sessions.db). Asegúrate de que tu usuario de Kali tenga permisos restrictivos:
Bash
```
chmod 600 ~/.pacu/sessions.db
```

¿Qué pasa si pierdes el acceso?

Si sospechas que tus llaves han sido detectadas por el equipo azul (Blue Team) o comprometidas, el siguiente paso lógico es saber cómo rotar o desactivar llaves desde la línea de comandos.

Escalar privilegios en AWS con Pacu es como buscar una "grieta" en la configuración de los permisos (IAM). En lugar de explotar un fallo de software, explotamos una mala configuración de permisos.

Aquí te explico cómo funciona el proceso de escalada de privilegios de forma profesional.

1. El Escaneo Automático

La joya de la corona de Pacu es el módulo iam__privesc_scan. Este módulo no intenta romper nada de inmediato; simplemente analiza las políticas asociadas a tus llaves y las compara con una base de datos de más de 20 métodos conocidos de escalada.

Ejecución:

Bash

run iam__privesc_scan

¿Qué busca el módulo?

El script revisará si tienes permisos como:

iam:CreateLoginProfile: Permite crear una contraseña para un usuario que no la tiene.
iam:UpdateAssumeRolePolicy: Permite modificar quién puede asumir un rol (puedes darte permiso a ti mismo).
iam:PutUserPolicy: Permite añadirte a ti mismo una política de "Administrador".

2. Ejemplo Práctico: El método `CreateNewPolicyVersion`

Imagina que el escaneo te dice que tienes el permiso iam:CreatePolicyVersion. Este es uno de los errores más comunes.

El concepto: AWS permite tener varias versiones de una política. Si tienes este permiso, puedes crear una "Versión 2" de tu propia política que diga "Permitir todo (*)" y marcarla como la versión predeterminada.

Cómo lo hace Pacu por ti:

Si el escaneo detecta esto, puedes ejecutar el módulo específico:

Bash

run iam__privesc_scan --unsupported

(O seleccionar el módulo de explotación directa si ya sabes cuál es):

Bash

run iam__set_default_policy_version --policy-arn <tu_arn> --version-id v2

3. Post-Escalación: ¿Qué hacer ahora?

Una vez que Pacu te confirma que has escalado a AdministratorAccess, tu objetivo cambia. Ya no eres un usuario limitado; ahora eres el dueño de la infraestructura.

Enumeración Total: Ahora que eres admin, vuelve a correr ec2__enum o s3__list_buckets. Verás muchas más cosas que antes estaban ocultas.
Persistencia: Puedes usar el módulo iam__backdoor_users_keys para añadir una segunda llave de acceso a otro usuario, por si el equipo de seguridad borra tu llave principal.

4. Cómo evitar que te detecten (Sigilo)

Si el Blue Team tiene configurado AWS GuardDuty, recibirán una alerta llamada PrivilegeEscalation:IAM/User.

Tip de Pentester: No intentes escalar privilegios 10 veces seguidas. Lee primero el reporte de iam__privesc_scan y ejecuta solo el método que tenga más probabilidades de éxito.
Limpieza: Pacu tiene un comando llamado cleanup (aunque es manual en muchos casos). Asegúrate de anotar qué políticas cambiaste para revertirlas al finalizar la auditoría.

Ahora que has escalado privilegios y tienes permisos de AdministratorAccess, el mundo de los datos en AWS está a tu disposición. En una auditoría, la exfiltración de un Bucket S3 suele ser el "Trofeo" (Crown Jewel), ya que es donde las empresas guardan backups, bases de datos, archivos de configuración o fotos de usuarios.

Aquí te explico cómo hacerlo usando los módulos de Pacu y herramientas nativas.

1. Localizar los "Objetivos" (Enumeración de S3)

Antes de descargar nada, necesitas saber qué buckets existen y cuáles contienen información sensible.

Comando: run s3__list_buckets
Este comando listará todos los nombres de los buckets en la cuenta.
Inspección de permisos: run s3__download_bucket_policy
Si quieres ver quién más tiene acceso (o si el bucket es público por error), este módulo descarga la política JSON del bucket.

2. Explorar el contenido (Muestreo)

No querrás descargar terabytes de basura. Primero "mira" dentro de los buckets que parezcan interesantes (nombres como backup, prod-data, config, sql-dumps).

Comando: run s3__get_objects --bucket <nombre_del_bucket>
Este comando listará los archivos (objetos) dentro del bucket. Pacu te mostrará el nombre, tamaño y fecha de modificación.

3. Exfiltración: El robo de datos

Tienes dos formas principales de sacar la información hacia tu Kali:

Opción A: Usando Pacu (Directo)

Comando: run s3__download_bucket --bucket <nombre_del_bucket>
Este módulo intentará descargar todo el contenido del bucket a tu máquina local.
- Ubicación: Los archivos se guardarán en la carpeta de tu sesión de Pacu (normalmente en ~/.pacu/sessions/tu_sesion/downloads/s3/).

Opción B: Usando AWS CLI (Más rápido para archivos grandes)

A veces, Pacu puede ser lento con archivos gigantes. Como ya tienes las llaves en tu Kali, puedes usar la herramienta oficial de AWS:

Bash

aws s3 sync s3://nombre-del-bucket-victima ./mi_carpeta_local --profile pacu_profile

El comando sync es muy potente porque si se corta la conexión, puede reanudar la descarga donde se quedó.

4. Técnicas Avanzadas de Exfiltración (Sigilo)

Si el Blue Team está vigilando, descargar gigabytes desde una IP desconocida activará alertas. Aquí es donde entra el ingenio:

Exfiltración vía Ransomware (Simulado): Algunos auditores usan el permiso s3:PutObject para sobreescribir archivos con versiones cifradas (solo en entornos de prueba controlados).
Generar URLs Firmadas (Pre-signed URLs):
- Comando: run s3__generate_presigned_url --bucket <bucket> --key <archivo>
- Esto genera un enlace web temporal. Puedes pasarle ese enlace a otra persona (o a otra máquina) y descargar el archivo desde un navegador sin necesidad de configurar llaves de AWS en ese equipo. Es muy difícil de rastrear si no hay logs detallados.

¿Cómo defenderse? (El lado ético)

Si estás haciendo esto para un cliente, en tu reporte debes recomendar:

Habilitar S3 Block Public Access: A nivel de cuenta.
Maced: Un servicio de AWS que usa IA para detectar datos sensibles (DNI, tarjetas) en S3.
CloudTrail Data Events: Por defecto, CloudTrail no loguea quién descarga un archivo de S3 (es muy caro). Recomienda activarlo solo para buckets críticos.

Esta es una de las partes más críticas en un ejercicio de Red Teaming. En el mundo real, un atacante no solo quiere los datos, quiere que nadie sepa que estuvo allí. En una auditoría ética, esto se llama Fase de Limpieza (Cleanup) y es fundamental para dejar el entorno del cliente tal cual lo encontraste.

En AWS, "limpiar huellas" es un reto porque los servicios de logging como CloudTrail están diseñados para ser inmutables. Sin embargo, hay acciones que puedes tomar para reducir tu visibilidad o eliminar los recursos que creaste.

1. Eliminar Recursos Creados (Persistence Cleanup)

Si durante tu escalada de privilegios creaste usuarios, llaves de acceso o roles, debes borrarlos. Pacu tiene una base de datos interna que recuerda qué hiciste.

Comando: run iam__backdoor_users_keys --cleanup
- Si usaste este módulo para crear llaves secundarias, el flag --cleanup intentará eliminarlas automáticamente.
Manual (Recomendado): Revisa siempre tu historial en la sesión de Pacu (history) y elimina manualmente cualquier usuario de prueba:
- run iam__delete_users --user-names <usuario_creado>

2. "Cegar" la Monitorización (Disrupting Logs)

Un atacante avanzado intentará detener la grabación de sus acciones. Nota: Esto es extremadamente ruidoso y disparará alertas de "Critical Severity" en sistemas bien configurados.

Detener CloudTrail:
- run cloudtrail__stop_logging --trail-name <nombre_del_trail>
- Esto detiene el registro de eventos de la API. Es como apagar las cámaras de seguridad.
Eliminar el Trail (Extremo):
- run cloudtrail__delete_trail --trail-name <nombre_del_trail>
- Borra la configuración del log por completo.

3. Modificar Grupos de Seguridad (EC2)

Si abriste puertos (como el 22 para SSH o el 3389 para RDP) para entrar en instancias EC2, debes cerrarlos.

Comando: run ec2__delete_security_group_rule
- Asegúrate de dejar las reglas de firewall exactamente como estaban.

4. El rastro en S3

Si exfiltraste datos, AWS no suele registrar el "evento de lectura" de archivos individuales a menos que tengan activados los S3 Data Events (que son caros). Sin embargo, si borraste archivos:

Versionado: Si el bucket tiene "Versioning" activo, tus borrados no son permanentes. Deberás eliminar las versiones específicas si el contrato de la auditoría así lo exige para no dejar basura.

5. Limpieza Local (En tu Kali)

No olvides que tu propia máquina guarda evidencia de la intrusión.

Base de datos de Pacu: Borra la sesión cuando termines el reporte:
Bash
```
# Dentro de Pacu
rm_session <nombre_de_sesion>
```
Historial de Bash:
Bash
```
history -c && history -w
```

La Realidad del "Antiforense" en la Nube

Advertencia de Colega: En AWS es casi imposible ser 100% invisible si el cliente usa Amazon GuardDuty. GuardDuty detectará comportamientos inusuales (como llamar a StopLogging) y generará una alerta persistente que no puedes borrar, ya que vive en el panel de seguridad de AWS, no en tus logs.

Generar el reporte es el paso final indispensable en cualquier auditoría. En Pacu, esto es genial porque transforma toda la base de datos de hallazgos (permisos escalados, buckets encontrados, usuarios vulnerables) en un formato profesional que puedes entregar a un cliente o a tu equipo de seguridad.

Aquí te explico cómo generar y visualizar ese reporte desde tu Kali Linux.

1. Generación del Reporte en Pacu

Pacu tiene un comando integrado para exportar los datos de la sesión actual. Una vez que hayas terminado tus ataques y exploraciones, ejecuta:

Bash

run core__report

¿Qué opciones verás?

El script te preguntará qué quieres incluir:

Formatos: Suele ofrecer JSON (útil para procesar con otros scripts) y HTML (el que buscamos para lectura humana).
Detalles: Puedes elegir incluir solo los módulos que tuvieron éxito o un resumen completo de la sesión.

2. Localización de los Archivos

Pacu no abre el reporte automáticamente. Debes buscarlo en la carpeta de tu sesión dentro de Kali. Normalmente la ruta es:

~/.pacu/sessions/[nombre_de_tu_sesion]/reports/

Puedes listarlos con:

Bash

ls -lh ~/.pacu/sessions/*/reports/

3. Visualización en Kali

Como estás en Kali, lo más probable es que estés usando la interfaz gráfica o una conexión SSH con X11. Tienes dos formas rápidas de ver ese HTML:

Desde la terminal (usando Firefox):

Bash

firefox ~/.pacu/sessions/tu_sesion/reports/report_XYZ.html &

Servidor Python rápido (si estás por SSH sin GUI):
Si estás administrando el Kali remotamente, levanta un servidor web temporal en la carpeta de reportes:
Bash
```
cd ~/.pacu/sessions/tu_sesion/reports/
python3 -m http.server 8080
```
Luego, desde el navegador de tu computadora personal, entras a: http://[IP_DE_KALI]:8080.

4. Estructura del Reporte (Lo que verás)

El reporte de Pacu es bastante limpio y se divide en secciones clave que te ayudarán a redactar tu informe final:

Sección	Descripción
Session Summary	Nombre de la sesión, fecha y llaves de AWS utilizadas.
Modules Run	Lista de todos los módulos ejecutados y si fallaron o tuvieron éxito.
IAM Data	Usuarios encontrados, políticas peligrosas y el camino exacto de la escalada de privilegios.
S3 / EC2 Data	Listado de buckets vulnerables y servidores con IPs públicas/privadas.

Un consejo para tu informe final:

El reporte de Pacu es una evidencia técnica, pero no es el informe que leería un gerente. Úsalo como base para tu sección de "Anexo Técnico" y redacta un resumen ejecutivo resaltando el riesgo de negocio (por ejemplo: "Se logró acceso a la base de datos de clientes debido a una política de IAM mal configurada").

El mundo de la seguridad en la nube (Cloud Hacking) evoluciona cada semana. Si ya dominas Pacu, el siguiente paso es entender el "porqué" de las vulnerabilidades y cómo detectarlas antes de que un atacante lo haga.

Aquí tienes una hoja de ruta con los mejores recursos actuales, desde laboratorios prácticos hasta certificaciones:

1. Laboratorios Prácticos (Hands-on)
No hay mejor forma de aprender que rompiendo cosas en un entorno controlado.
- CloudGoat: Creado por los mismos desarrolladores de Pacu (Rhino Security Labs). Es una herramienta que despliega escenarios de AWS "vulnerables por diseño". Es el estándar de oro para practicar escalada de privilegios.
- Flaws.cloud: Un reto estilo CTF (Capture The Flag) muy famoso. Te guía a través de varios niveles de errores comunes en S3 y EC2. Es gratuito y excelente para principiantes.
- Sadcloud: Una herramienta para desplegar infraestructuras de AWS plagadas de errores de seguridad de forma rápida (Terraform).
2. Herramientas Complementarias a Pacu
Para ser un experto en Kali para la nube, deberías probar estas también:
- Prowler: Es la herramienta número uno para auditorías de cumplimiento (CIS Benchmark). A diferencia de Pacu (que es ofensiva), Prowler es para auditoría y defensa.
- SkyArk: Especializada en encontrar "Shadow Admins" (usuarios que parecen limitados pero tienen permisos ocultos de administrador).
- CloudSploit: Un escáner de seguridad que busca configuraciones erróneas en segundos.
3. Certificaciones y Rutas de Aprendizaje
Si quieres profesionalizarte y que tu CV destaque:
- AWS Certified Security – Specialty: La certificación oficial de Amazon. Se enfoca 100% en defensa, cifrado y respuesta a incidentes.
- eCIR (eLearnSecurity Cloud Incident Response): Muy práctica para aprender qué rastro dejan herramientas como Pacu en los logs.
- Hacking the Cloud: Es una "enciclopedia" abierta (página web) que recopila técnicas de ataque y defensa en AWS, Azure y GCP. Es lectura obligada.
Un último consejo de "Hacker Ético":
Si vas a practicar en tu propia cuenta de AWS, asegúrate de configurar un Presupuesto (AWS Budget) de 1 USD. AWS es gratuito el primer año (Free Tier), pero si olvidas una instancia encendida después de usar Pacu, la factura podría darte un susto.