dnschef-ng

DNSChef es un proxy DNS altamente configurable para probadores de penetración y analistas de malware. Un proxy DNS (también conocido como "DNS falso") es una herramienta utilizada para el análisis del tráfico de red de aplicaciones, entre otros usos. Por ejemplo, un proxy DNS se puede utilizar para falsificar solicitudes de "badguy.com" y hacer que apunten a una máquina local para su terminación o interceptación, en lugar de un host real en algún lugar de Internet.

Existen varios proxies DNS. La mayoría simplemente apunta todas las consultas DNS a una única dirección IP o implementa solo un filtrado rudimentario. DNSChef fue desarrollado como parte de una prueba de penetración en la que se necesitaba un sistema más configurable. Como resultado, DNSChef es una aplicación multiplataforma capaz de forjar respuestas basadas en listas de dominios inclusivas y exclusivas, compatible con múltiples tipos de registros DNS, coincidencia de dominios con comodines, proxy de respuestas reales para dominios no coincidentes, definición de archivos de configuración externos, IPv6 y muchas otras funciones. Puede encontrar una explicación detallada de cada una de las funciones y los usos sugeridos a continuación.

Se recomienda el uso de un proxy DNS en situaciones en las que no es posible obligar a una aplicación a utilizar directamente algún otro servidor proxy. Por ejemplo, algunas aplicaciones móviles ignoran por completo la configuración del proxy HTTP del sistema operativo. En estos casos, el uso de un servidor proxy DNS como DNSChef le permitirá engañar a esa aplicación para que reenvíe las conexiones al destino deseado.

## Nuevas características

- Requiere Python 3.11+
- Admite la transferencia de archivos por DNS (solo sobre `A`, `AAAA`, `TXT` por ahora...)
- El archivo de configuración ahora es TOML
- API HTTP opcional (le permite consultar registros y actualizar la configuración de forma remota)
- Totalmente asíncrono para un mayor rendimiento (usa AsyncIO)
- Registro estructurado y una serie de mejoras de calidad de vida (QOL)
- Ahora es un paquete de Python
- Dockerizado
- Incluye varios PRs y correcciones del repositorio original

## Instalación

Para instalar la última versión debería usar [pipx](https://pypa.github.io/pipx/) (a menos que seas un pedazo de mierda que disfruta de las cosas chapuceras):

    pipx install dnschef-ng

Si desea la API HTTP (requiere algunas dependencias adicionales):
    
    pipx install dnschef-ng[api]

Instale la última versión desde Git usando pipx:

     pipx install git+https://github.com/byt3bl33d3r/dnschef-ng.git

Instale la última versión desde Git usando pipx con las dependencias para la API HTTP:

     pipx install "git+https://github.com/byt3bl33d3r/dnschef-ng.git#egg=dnschef-ng[api]"


## Configuración de un proxy DNS

Antes de poder empezar a usar DNSChef, debe configurar su máquina para que use un servidor de nombres DNS con la herramienta en ejecución. Tiene varias opciones según el sistema operativo que vaya a usar:

- **Linux** - Edite */etc/resolv.conf* para incluir una línea en la parte superior con el host de análisis de tráfico (por ejemplo, agregue "nameserver 127.0.0.1" si está ejecutando localmente). Alternativamente, puede agregar una dirección de servidor DNS mediante herramientas como Network Manager. Dentro de Network Manager, abra Configuración de IPv4, seleccione *Solo direcciones (DHCP) automáticas* o *Manual* en el cuadro desplegable *Método* y edite el cuadro de texto *Servidores DNS* para incluir una dirección IP con DNSChef en ejecución.

- **Windows** - Seleccione *Conexiones de red* en el *Panel de control*. A continuación, seleccione una de las conexiones (por ejemplo, "Conexión de área local"), haga clic derecho sobre ella y seleccione propiedades. En el cuadro de diálogo que aparece, seleccione *Protocolo de Internet (TCP/IP)* y haga clic en propiedades. Por último, seleccione el botón de opción *Usar las siguientes direcciones de servidor DNS* e introduzca la dirección IP con DNSChef en ejecución. Por ejemplo, si se ejecuta localmente, introduzca 127.0.0.1.

- **OS X** - Abra *Preferencias del Sistema* y haga clic en el icono de *Red*. Seleccione la interfaz activa y rellene el campo *Servidor DNS*. Si está utilizando Airport, tendrá que hacer clic en el botón *Avanzado...* y editar los servidores DNS desde allí. Alternativamente, puede editar */etc/resolv.conf* y agregar un servidor de nombres falso en la parte superior (por ejemplo, "nameserver 127.0.0.1").

- **iOS** - Abra *Configuración* y seleccione *General*. A continuación, seleccione *Wi-Fi* y haga clic en la flecha azul a la derecha de un punto de acceso activo de la lista. Edite la entrada DNS para que apunte al host con DNSChef en ejecución. Asegúrese de haber deshabilitado la interfaz celular (si está disponible).

- **Android** - Abra *Configuración* y seleccione *Inalámbricas y redes*. Haga clic en *Configuración de Wi-Fi* y seleccione *Avanzado* después de presionar el botón *Opciones* en el teléfono. Active la casilla *Usar IP estática* y configure un servidor DNS personalizado.

Si no tiene la capacidad de modificar manualmente la configuración DNS del dispositivo, todavía tiene varias opciones que implican técnicas como [suplantación de ARP](http://en.wikipedia.org/wiki/ARP_spoofing), [DHCP rogue](http://www.yersinia.net/doc.htm) y otros métodos creativos.

Por último, debe configurar un servicio falso al que DNSChef apuntará todas las solicitudes. Por ejemplo, si intenta interceptar tráfico web, debe levantar un servidor web independiente en el puerto 80 o configurar un proxy web (por ejemplo, Burp) para interceptar el tráfico. DNSChef apuntará las consultas a su host de proxy/servidor con los servicios correctamente configurados.

## Ejecutar DNSChef

DNSChef es una aplicación multiplataforma desarrollada en Python que debería funcionar en la mayoría de las plataformas que tengan un intérprete de Python. Esta guía se centrará en entornos Unix; sin embargo, todos los ejemplos siguientes se probaron para funcionar también en Windows.

Probemos DNSChef con su funcionalidad de monitoreo más básica. Ejecute el siguiente comando como root (necesario para iniciar un servidor en el puerto 53):

    # ./dnschef.py
        
              _                _          __  
             | | version 0.2  | |        / _| 
           __| |_ __  ___  ___| |__   ___| |_ 
          / _` | '_ \/ __|/ __| '_ \ / _ \  _|
         | (_| | | | \__ \ (__| | | |  __/ |  
          \__,_|_| |_|___/\___|_| |_|\___|_|  
                       [email protected]  

    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [*] No parameters were specified. Running in full proxy mode

Sin ningún parámetro, DNSChef se ejecutará en modo proxy completo. Esto significa que todas las solicitudes simplemente se reenviarán a un servidor DNS ascendente (8.8.8.8 por defecto) y se devolverán al host consultante. Por ejemplo, consultemos un registro "A" para un dominio y observemos los resultados:

    $ host -t A thesprawl.org
    thesprawl.org has address 108.59.3.64

DNSChef imprimirá la siguiente línea de registro que muestra la hora, la dirección IP de origen, el tipo de registro solicitado y, lo más importante, qué nombre se consultó:

    [23:54:03] 127.0.0.1: proxying the response of type 'A' for thesprawl.org

Este modo es útil para la monitorización simple de aplicaciones cuando necesita averiguar qué dominios utiliza para sus comunicaciones.

DNSChef tiene soporte completo para IPv6 que se puede activar usando las opciones *-6* o *--ipv6**. Funciona exactamente igual que el modo IPv4, con la excepción de que la interfaz de escucha predeterminada se cambia a ::1 y el servidor DNS predeterminado se cambia a 2001:4860:4860::8888. A continuación se muestra un ejemplo de salida:

    # ./dnschef.py -6
              _                _          __
             | | version 0.2  | |        / _|
           __| |_ __  ___  ___| |__   ___| |_
          / _` | '_ \/ __|/ __| '_ \ / _ \  _|
         | (_| | | | \__ \ (__| | | |  __/ |
          \__,_|_| |_|___/\___|_| |_|\___|_|
                       [email protected]

    [*] Using IPv6 mode.
    [*] DNSChef started on interface: ::1
    [*] Using the following nameservers: 2001:4860:4860::8888
    [*] No parameters were specified. Running in full proxy mode
    [00:35:44] ::1: proxying the response of type 'A' for thesprawl.org
    [00:35:44] ::1: proxying the response of type 'AAAA' for thesprawl.org
    [00:35:44] ::1: proxying the response of type 'MX' for thesprawl.org

NOTA: Por defecto, DNSChef crea un listener UDP. Puede usar TCP en su lugar con el argumento *--tcp*, que se analizará más adelante.

## Ejecutar la API HTTP de DNSChef

> [!WARNING]
> La API no tiene autenticación. Permita/deniegue el acceso a nivel de red mediante grupos de seguridad, iptables, firewall, etc..

`uvicorn dnschef.api:app`

A continuación, puede ver la documentación de OpenAPI en `http://127.0.0.1:8000/docs````
$ uvicorn dnschef.api:app
INFO:     Started server process [28327]
INFO:     Waiting for application startup.
          _                _          __  
         | | version 0.6.0  | |        / _| 
       __| |_ __  ___  ___| |__   ___| |_ 
      / _` | '_ \/ __|/ __| '_ \ / _ \  _|
     | (_| | | | \__ \ (__| | | |  __/ |  
      \__,_|_| |_|___/\___|_| |_|\___|_|  
                @iphelix // @byt3bl33d3r  

2023-09-28 11:24:59 cooking replies                domain=*.thesprawl.org record=192.0.2.1 section=A
2023-09-28 11:24:59 cooking replies                domain=*.thesprawl.org record=2001:db8::1 section=AAAA
-- SNIP --
2023-09-28 11:24:59 cooking replies                domain=*.thesprawl.org record=1 . alpn=h2 ipv4hint=127.0.0.1 ipv6hint=::1 section=HTTPS
INFO:     Application startup complete.
2023-09-28 11:24:59 DNSChef is active              interface=127.0.0.1 ipv6=False nameservers=['8.8.8.8'] port=53 tcp=False
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

# ./dnschef.py --fakeip 127.0.0.1 -q
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[23:55:57] 127.0.0.1: cooking the response of type 'A' for google.com to 127.0.0.1
[23:55:57] 127.0.0.1: proxying the response of type 'AAAA' for google.com
[23:55:57] 127.0.0.1: proxying the response of type 'MX' for google.com

$ host google.com localhost
google.com has address 127.0.0.1
google.com has IPv6 address 2001:4860:4001:803::1001
google.com mail is handled by 10 aspmx.l.google.com.
google.com mail is handled by 40 alt3.aspmx.l.google.com.
google.com mail is handled by 30 alt2.aspmx.l.google.com.
google.com mail is handled by 20 alt1.aspmx.l.google.com.
google.com mail is handled by 50 alt4.aspmx.l.google.com.

# ./dnschef.py --fakeip 127.0.0.1 --fakeipv6 ::1 -q
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[*] Cooking all AAAA replies to point to ::1
[00:02:14] 127.0.0.1: cooking the response of type 'A' for google.com to 127.0.0.1
[00:02:14] 127.0.0.1: cooking the response of type 'AAAA' for google.com to ::1
[00:02:14] 127.0.0.1: proxying the response of type 'MX' for google.com

$ host google.com localhost
google.com has address 127.0.0.1
google.com has IPv6 address ::1
google.com mail is handled by 10 aspmx.l.google.com.
google.com mail is handled by 40 alt3.aspmx.l.google.com.
google.com mail is handled by 30 alt2.aspmx.l.google.com.
google.com mail is handled by 20 alt1.aspmx.l.google.com.
google.com mail is handled by 50 alt4.aspmx.l.google.com.

# ./dnschef.py --fakeip 127.0.0.1 --fakeipv6 ::1 --fakemail mail.fake.com --fakealias www.fake.com --fakens ns.fake.com -q
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[*] Cooking all AAAA replies to point to ::1
[*] Cooking all MX replies to point to mail.fake.com
[*] Cooking all CNAME replies to point to www.fake.com
[*] Cooking all NS replies to point to ns.fake.com
[00:17:29] 127.0.0.1: cooking the response of type 'ANY' for google.com with all known fake records.

# host -t ANY google.com localhost
google.com has address 127.0.0.1
google.com has IPv6 address ::1
google.com mail is handled by 10 mail.fake.com.
google.com is an alias for www.fake.com.
google.com name server ns.fake.com.

# ./dnschef.py --fakeip 127.0.0.1 --fakedomains thesprawl.org -q
[*] DNSChef started on interface: 127.0.0.1
[*] Using the following nameservers: 8.8.8.8  
[*] Cooking replies to point to 127.0.0.1 matching: thesprawl.org
[00:23:37] 127.0.0.1: cooking the response of type 'A' for thesprawl.org to 127.0.0.1
[00:23:52] 127.0.0.1: proxying the response of type 'A' for mx9.webfaction.com

# ./dnschef.py --fakeip 127.0.0.1 --truedomains thesprawl.org,*.webfaction.com -q
[*] DNSChef started on interface: 127.0.0.1
[*] Using the following nameservers: 8.8.8.8  
[*] Cooking replies to point to 127.0.0.1 not matching: *.webfaction.com, thesprawl.org
[00:27:57] 127.0.0.1: proxying the response of type 'A' for mx9.webfaction.com
[00:28:05] 127.0.0.1: cooking the response of type 'A' for google.com to 127.0.0.1

Observa el encabezado de sección `[A]`, este define el tipo de registro para DNSChef. Ahora observemos cuidadosamente la salida de múltiples consultas:

    # ./dnschef.py --file dnschef.toml -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [+] Cooking A replies for domain *.google.com with '192.0.2.1'
    [+] Cooking A replies for domain thesprawl.org with '192.0.2.2'
    [+] Cooking A replies for domain *.wordpress.* with '192.0.2.3'
    [00:43:54] 127.0.0.1: cooking the response of type 'A' for google.com to 192.0.2.1
    [00:44:05] 127.0.0.1: cooking the response of type 'A' for www.google.com to 192.0.2.1
    [00:44:19] 127.0.0.1: cooking the response of type 'A' for thesprawl.org to 192.0.2.2
    [00:44:29] 127.0.0.1: proxying the response of type 'A' for www.thesprawl.org
    [00:44:40] 127.0.0.1: cooking the response of type 'A' for www.wordpress.org to 192.0.2.3
    [00:44:51] 127.0.0.1: cooking the response of type 'A' for wordpress.com to 192.0.2.3
    [00:45:02] 127.0.0.1: proxying the response of type 'A' for slashdot.org

Tanto *google.com* como *www.google.com* coincidieron con la entrada *\*.google.com* y se resolvieron correctamente a *192.0.2.1*. Por otro lado, la solicitud de *www.thesprawl.org* simplemente se pasó por proxy en lugar de modificarse. Finalmente, todas las variaciones de *wordpress.com*, *www.wordpress.org*, etc. coincidieron con la máscara *\*.wordpress.\** y se resolvieron correctamente a *192.0.2.3*. Por último, una consulta no definida de *slashdot.org* simplemente se pasó por proxy con una respuesta real.

Puede especificar encabezados de sección para todos los demás tipos de registros DNS compatibles, incluidos los que no se exponen explícitamente en la línea de comandos: [A], [AAAA], [MX], [NS], [CNAME], [PTR], [NAPTR] y [SOA]. Por ejemplo, definamos una nueva sección [PTR] en el archivo `dnschef.toml`:```toml
[PTR]
"*.2.0.192.in-addr.arpa"="fake.com"

 ./dnschef.py --file dnschef.toml -q
[sudo] password for iphelix: 
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[+] Cooking PTR replies for domain *.2.0.192.in-addr.arpa with 'fake.com'
[00:11:34] 127.0.0.1: cooking the response of type 'PTR' for 1.2.0.192.in-addr.arpa to fake.com

$ host 192.0.2.1 localhost
1.2.0.192.in-addr.arpa domain name pointer fake.com.

Consulte el archivo de ejemplo `dnschef.toml` para ver ejemplos adicionales.

## File Staging (Preparación de archivos)

DNSChef puede "stage" (preparar) cualquier archivo a través de DNS. Actualmente, la preparación de archivos solo es compatible con registros `A`, `AAAA` y `TXT` (se añadirán más). Para indicarle a DNSChef que prepare un archivo, agregue la siguiente sección a su `dnschef.toml`:```toml
[A]
"*.wat.org" = { file = "/home/payload.exe", chunk_size = 4 }

[AAAA]
"*.gorgetowngeronimos.org" = { file = "/home/payload.exe", chunk_size = 16 }

Con esta configuración, cualquier consulta `TXT` a `ns*.dungbeetle.org` devolverá un fragmento de nuestro archivo ubicado localmente en el sistema de archivos en `~/payload.exe`.

Los ajustes `response_format` y `response_prefix_pool` son opcionales, pero le permiten personalizar aún más la respuesta `TXT` del DNS.

El ajuste `response_format` define el formato de la respuesta `TXT`: 

- La variable `{prefix}` se sustituirá aleatoriamente por uno de los valores definidos en el array `response_prefix_pool`.

- La variable `{chunk}` se reemplazará con el fragmento del archivo.

Con la configuración anterior, una consulta `TXT` a `ns1.dungbeetle.org` devolverá la siguiente respuesta:```
docusign=test-<BASE64_ENCODED_FILE_CHUNK_N1>

## Filtrado avanzado

Puedes combinar entradas de un archivo y de la línea de comandos. Por ejemplo, el siguiente comando usa tanto el parámetro `--file` como `--fakedomains`:

    # ./dnschef.py --file dnschef.toml --fakeip 6.6.6.6 --fakedomains=thesprawl.org,slashdot.org -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [+] Cooking A replies for domain *.google.com with '192.0.2.1'
    [+] Cooking A replies for domain thesprawl.org with '192.0.2.2'
    [+] Cooking A replies for domain *.wordpress.* with '192.0.2.3'
    [*] Cooking A replies to point to 6.6.6.6 matching: *.wordpress.*, *.google.com, thesprawl.org
    [*] Cooking A replies to point to 6.6.6.6 matching: slashdot.org, *.wordpress.*, *.google.com, thesprawl.org
    [00:49:05] 127.0.0.1: cooking the response of type 'A' for google.com to 192.0.2.1
    [00:49:15] 127.0.0.1: cooking the response of type 'A' for slashdot.org to 6.6.6.6
    [00:49:31] 127.0.0.1: cooking the response of type 'A' for thesprawl.org to 6.6.6.6
    [00:50:08] 127.0.0.1: proxying the response of type 'A' for tor.com

Observa que la definición de *thesprawl.org* en el parámetro de la línea de comandos tuvo prioridad sobre *dnschef.toml*. Esto puede ser útil si quieres sobrescribir valores del archivo de configuración. slashdot.org todavía se resuelve a la dirección IP falsa porque se especificó en el parámetro *--fakedomains*. La solicitud de tor.com simplemente se reenvía a través del proxy, ya que no se especificó ni en la línea de comandos ni en el archivo de configuración.

## Otras configuraciones

Por razones de seguridad, DNSChef escucha en la interfaz local 127.0.0.1 (o ::1 para IPv6) por defecto. Puedes hacer que DNSChef escuche en otra interfaz usando el parámetro *--interface*:

    # ./dnschef.py --interface 0.0.0.0 -q
    [*] DNSChef started on interface: 0.0.0.0
    [*] Using the following nameservers: 8.8.8.8 
    [*] No parameters were specified. Running in full proxy mode
    [00:50:53] 192.0.2.105: proxying the response of type 'A' for thesprawl.org

o para IPv6:

    # ./dnschef.py -6 --interface :: -q
    [*] Using IPv6 mode.
    [*] DNSChef started on interface: ::
    [*] Using the following nameservers: 2001:4860:4860::8888
    [*] No parameters were specified. Running in full proxy mode
    [00:57:46] 2001:db8::105: proxying the response of type 'A' for thesprawl.org

Por defecto, DNSChef usa el servidor DNS público de Google para realizar solicitudes de proxy. Sin embargo, puedes definir una lista personalizada de servidores de nombres usando el parámetro *--nameservers*:

    # ./dnschef.py --nameservers 4.2.2.1,4.2.2.2 -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 4.2.2.1, 4.2.2.2
    [*] No parameters were specified. Running in full proxy mode
    [00:55:08] 127.0.0.1: proxying the response of type 'A' for thesprawl.org

Es posible especificar un puerto de servidor de nombres no estándar usando la notación IP#PORT:

    # ./dnschef.py --nameservers 192.0.2.2#5353 -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 192.0.2.2#5353
    [*] No parameters were specified. Running in full proxy mode
    [02:03:12] 127.0.0.1: proxying the response of type 'A' for thesprawl.org

Al mismo tiempo, es posible iniciar el propio DNSChef en un puerto alternativo usando el parámetro `-p port#`:

    # ./dnschef.py -p 5353 -q
    [*] Listening on an alternative port 5353
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [*] No parameters were specified. Running in full proxy mode

El protocolo DNS puede usarse sobre UDP (por defecto) o TCP. DNSChef implementa un modo TCP que se puede activar con el indicador `--tcp`.