Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
dnschef — DNSChef - Proxy DNS para Probadores de Penetración y Analistas de Malware | Kitploit
Herramientas/GitHubGitHub/iphelix/dnschef
Recopilación de InformaciónSeguridad de RedesAnálisis de MalwarePruebas de PenetraciónAnálisis de DNS
GitHubiphelix/dnschef

dnschef

DNSChef - Proxy DNS para Probadores de Penetración y Analistas de Malware

Ver Repositorio
1.1k2253hace 7 añosRevisado por Kitploit

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

root@kitploit:~
 | | versión 0.4  | |        / _|

| | __ ___ | | __| | / ` | ' / |/ | ' \ / _ \ | | (| | | | _ \ (| | | | __/ |
_
,
|| ||/_|| ||___||

root@kitploit:~
   D O C U M E N T A C I Ó N

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

Existen varios proxies DNS en el mercado. La mayoría simplemente redirigirá todas las consultas DNS a una única dirección IP o implementará 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 falsificar respuestas basándose 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 características. A continuación encontrará una explicación detallada de cada una de las funciones y usos sugeridos.

Se recomienda el uso de un proxy DNS en situaciones en las que no sea posible forzar a una aplicación a utilizar directamente 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 redirija las conexiones al destino deseado.

Configuración de un proxy DNS

Antes de comenzar a usar DNSChef, debe configurar su máquina para que utilice un servidor de nombres DNS con la herramienta ejecutándose. Tiene varias opciones según el sistema operativo que vaya a utilizar:

Descargar herramienta
  • Linux - Edite /etc/resolv.conf para incluir una línea al principio con su 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 usando herramientas como Network Manager. Dentro de Network Manager, abra Configuración IPv4, seleccione Solo direcciones automáticas (DHCP) o Manual en el cuadro desplegable Método y edite el cuadro de texto Servidores DNS para incluir una dirección IP donde se esté ejecutando DNSChef.

  • Windows - Seleccione Conexiones de red desde el Panel de control. Luego 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 ingrese la dirección IP donde se esté ejecutando DNSChef. Por ejemplo, si se ejecuta localmente, ingrese 127.0.0.1.

  • OS X - Abra Preferencias del Sistema y haga clic en el ícono Red. Seleccione la interfaz activa y complete el campo Servidor DNS. Si está usando Airport, deberá 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 al principio (por ejemplo, "nameserver 127.0.0.1").

  • iOS - Abra Ajustes y seleccione General. Luego 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 donde se está ejecutando DNSChef. Asegúrese de haber desactivado la interfaz Celular (si está disponible).

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

Si no tiene la capacidad de modificar manualmente la configuración de DNS del dispositivo, aún tiene varias opciones que involucran técnicas como ARP Spoofing, Rogue DHCP y otros métodos creativos.

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

Ejecución de DNSChef

DNSChef es una aplicación multiplataforma desarrollada en Python que debería ejecutarse en la mayoría de las plataformas que tengan un intérprete de Python. Puede usar el ejecutable dnschef.exe proporcionado para ejecutarlo en hosts Windows sin instalar un intérprete de Python. Esta guía se centrará en entornos Unix; sin embargo, todos los ejemplos siguientes también se han probado y funcionan 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):

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

[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[*] No se especificaron parámetros. Ejecutando en modo proxy completo

Sin parámetros, 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 solicitante. Por ejemplo, consultemos un registro "A" para un dominio y observemos los resultados:

root@kitploit:~
$ host -t A thesprawl.org
thesprawl.org tiene dirección 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ó:

root@kitploit:~
[23:54:03] 127.0.0.1: proxy de respuesta de tipo 'A' para thesprawl.org

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

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

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

[*] Usando modo IPv6.
[*] DNSChef iniciado en la interfaz: ::1
[*] Usando los siguientes servidores de nombres: 2001:4860:4860::8888
[*] No se especificaron parámetros. Ejecutando en modo proxy completo
[00:35:44] ::1: proxy de respuesta de tipo 'A' para thesprawl.org
[00:35:44] ::1: proxy de respuesta de tipo 'AAAA' para thesprawl.org
[00:35:44] ::1: proxy de respuesta de tipo 'MX' para thesprawl.org

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

Interceptar todas las respuestas

Ahora que sabe cómo iniciar DNSChef, configurémoslo para falsificar todas las respuestas apuntando a 127.0.0.1 usando el parámetro --fakeip:

root@kitploit:~
# ./dnschef.py --fakeip 127.0.0.1 -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[*] Cocinando todas las respuestas A para que apunten a 127.0.0.1
[23:55:57] 127.0.0.1: cocinando la respuesta de tipo 'A' para google.com a 127.0.0.1
[23:55:57] 127.0.0.1: proxy de respuesta de tipo 'AAAA' para google.com
[23:55:57] 127.0.0.1: proxy de respuesta de tipo 'MX' para google.com

En la salida anterior, puede ver que DNSChef fue configurado para proxy de todas las solicitudes a 127.0.0.1. La primera línea de registro a las 08:11:23 muestra que hemos "cocinado" la respuesta del registro "A" para que apunte a 127.0.0.1. Sin embargo, las solicitudes posteriores para los registros 'AAAA' y 'MX' simplemente se hacen proxy desde un servidor DNS real. Veamos la salida del programa solicitante:

root@kitploit:~
$ host google.com localhost
google.com tiene dirección 127.0.0.1
google.com tiene dirección IPv6 2001:4860:4001:803::1001
google.com mail es manejado por 10 aspmx.l.google.com.
google.com mail es manejado por 40 alt3.aspmx.l.google.com.
google.com mail es manejado por 30 alt2.aspmx.l.google.com.
google.com mail es manejado por 20 alt1.aspmx.l.google.com.
google.com mail es manejado por 50 alt4.aspmx.l.google.com.

Como puede ver, el programa fue engañado para usar 127.0.0.1 para la dirección IPv4. Sin embargo, la información obtenida de los registros IPv6 (AAAA) y de correo (MX) parece completamente legítima. El objetivo de DNSChef es tener el menor impacto posible en el funcionamiento correcto del programa, por lo que si una aplicación depende de un servidor de correo específico, obtendrá uno correctamente a través de esta solicitud proxy.

Falsifiquemos una solicitud más para ilustrar cómo apuntar a múltiples registros al mismo tiempo:

root@kitploit:~
# ./dnschef.py --fakeip 127.0.0.1 --fakeipv6 ::1 -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[*] Cocinando todas las respuestas A para que apunten a 127.0.0.1
[*] Cocinando todas las respuestas AAAA para que apunten a ::1
[00:02:14] 127.0.0.1: cocinando la respuesta de tipo 'A' para google.com a 127.0.0.1
[00:02:14] 127.0.0.1: cocinando la respuesta de tipo 'AAAA' para google.com a ::1
[00:02:14] 127.0.0.1: proxy de respuesta de tipo 'MX' para google.com

Además del indicador --fakeip, he especificado ahora --fakeipv6 diseñado para falsificar consultas de registro 'AAAA'. Aquí está la salida actualizada del programa:

root@kitploit:~
$ host google.com localhost
google.com tiene dirección 127.0.0.1
google.com tiene dirección IPv6 ::1
google.com mail es manejado por 10 aspmx.l.google.com.
google.com mail es manejado por 40 alt3.aspmx.l.google.com.
google.com mail es manejado por 30 alt2.aspmx.l.google.com.
google.com mail es manejado por 20 alt1.aspmx.l.google.com.
google.com mail es manejado por 50 alt4.aspmx.l.google.com.

Una vez más, todos los registros no sobrescritos explícitamente por la aplicación fueron proxy y devueltos desde el servidor DNS real. Sin embargo, tanto IPv4 (A) como IPv6 (AAAA) fueron falsificados para apuntar a una máquina local.

DNSChef es compatible con múltiples tipos de registros:

root@kitploit:~
+--------+--------------+-----------+--------------------------+
| Registro| Descripción  |Argumento  | Ejemplo                  |
+--------+--------------+-----------+--------------------------+
|  A     | Dirección IPv4|--fakeip   | --fakeip 192.0.2.1       |
|  AAAA  | Dirección IPv6|--fakeipv6 | --fakeipv6 2001:db8::1   |
|  MX    | Servidor de correo|--fakemail| --fakemail mail.fake.com |
|  CNAME | Registro CNAME|--fakealias| --fakealias www.fake.com |
|  NS    | Servidor de nombres|--fakens| --fakens ns.fake.com     |
+--------+--------------+-----------+--------------------------+

NOTA: Por usabilidad, no todos los tipos de registros DNS están expuestos en la línea de comandos. Se pueden especificar registros adicionales como PTR, TXT, SOA, etc. usando el indicador --file y un encabezado de registro apropiado. Consulte la sección archivo de definiciones externas a continuación para obtener más detalles.

Por último, observemos cómo la aplicación maneja las consultas de tipo ANY:

root@kitploit:~
# ./dnschef.py --fakeip 127.0.0.1 --fakeipv6 ::1 --fakemail mail.fake.com --fakealias www.fake.com --fakens ns.fake.com -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[*] Cocinando todas las respuestas A para que apunten a 127.0.0.1
[*] Cocinando todas las respuestas AAAA para que apunten a ::1
[*] Cocinando todas las respuestas MX para que apunten a mail.fake.com
[*] Cocinando todas las respuestas CNAME para que apunten a www.fake.com
[*] Cocinando todas las respuestas NS para que apunten a ns.fake.com
[00:17:29] 127.0.0.1: cocinando la respuesta de tipo 'ANY' para google.com con todos los registros falsos conocidos.

Las consultas de registro ANY de DNS resultan en que DNSChef devuelva todos los registros falsos que conoce para un dominio aplicable. Aquí está la salida que verá el programa:

root@kitploit:~
$ host -t ANY google.com localhost
google.com tiene dirección 127.0.0.1
google.com tiene dirección IPv6 ::1
google.com mail es manejado por 10 mail.fake.com.
google.com es un alias de www.fake.com.
google.com name server ns.fake.com.

Filtrado de dominios

Usando el ejemplo anterior, considere que solo desea interceptar solicitudes para thesprawl.org y dejar las consultas a todos los demás dominios como webfaction.com sin modificación. Puede usar el parámetro --fakedomains como se ilustra a continuación:

root@kitploit:~
# ./dnschef.py --fakeip 127.0.0.1 --fakedomains thesprawl.org -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1
[*] Usando los siguientes servidores de nombres: 8.8.8.8  
[*] Cocinando respuestas para que apunten a 127.0.0.1 coincidiendo con: thesprawl.org
[00:23:37] 127.0.0.1: cocinando la respuesta de tipo 'A' para thesprawl.org a 127.0.0.1
[00:23:52] 127.0.0.1: proxy de respuesta de tipo 'A' para mx9.webfaction.com

En el ejemplo anterior, la solicitud para thesprawl.org fue falsificada; sin embargo, la solicitud para mx9.webfaction.com se dejó intacta. Filtrar dominios es muy útil cuando intenta aislar una sola aplicación sin afectar al resto.

NOTA: DNSChef no verificará si el dominio existe o no antes de falsificar la respuesta. Si ha especificado un dominio, siempre se resolverá a un valor falso, exista o no realmente.

Filtrado inverso

En otra situación, puede necesitar falsificar respuestas para todas las solicitudes excepto una lista definida de dominios. Puede lograr esta tarea usando el parámetro --truedomains de la siguiente manera:

root@kitploit:~
# ./dnschef.py --fakeip 127.0.0.1 --truedomains thesprawl.org,*.webfaction.com -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1
[*] Usando los siguientes servidores de nombres: 8.8.8.8  
[*] Cocinando respuestas para que apunten a 127.0.0.1 que no coinciden con: *.webfaction.com, thesprawl.org
[00:27:57] 127.0.0.1: proxy de respuesta de tipo 'A' para mx9.webfaction.com
[00:28:05] 127.0.0.1: cocinando la respuesta de tipo 'A' para google.com a 127.0.0.1

Hay varias cosas sucediendo en el ejemplo anterior. Primero, note el uso de un comodín (*). Todos los dominios que coincidan con *.webfaction.com serán emparejados inversamente y resueltos a sus valores reales. La solicitud para 'google.com' devolvió 127.0.0.1 porque no estaba en la lista de dominios excluidos.

NOTA: Los comodines son específicos de posición. Una máscara de tipo *.thesprawl.org coincidirá con www.thesprawl.org pero no con www.test.thesprawl.org. Sin embargo, una máscara de tipo ..thesprawl.org coincidirá con thesprawl.org, www.thesprawl.org y www.test.thesprawl.org.

Archivo de definiciones externas

Puede haber situaciones en las que definir un único registro DNS falso para todos los dominios coincidentes no sea suficiente. Puede usar un archivo externo con una colección de pares DOMINIO=REGISTRO que definan exactamente dónde desea que vaya la solicitud.

Por ejemplo, creemos el siguiente archivo de definiciones y llamémoslo dnschef.ini:

root@kitploit:~
[A]
*.google.com=192.0.2.1
thesprawl.org=192.0.2.2
*.wordpress.*=192.0.2.3

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

root@kitploit:~
# ./dnschef.py --file dnschef.ini -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[+] Cocinando respuestas A para el dominio *.google.com con '192.0.2.1'
[+] Cocinando respuestas A para el dominio thesprawl.org con '192.0.2.2'
[+] Cocinando respuestas A para el dominio *.wordpress.* con '192.0.2.3'
[00:43:54] 127.0.0.1: cocinando la respuesta de tipo 'A' para google.com a 192.0.2.1
[00:44:05] 127.0.0.1: cocinando la respuesta de tipo 'A' para www.google.com a 192.0.2.1
[00:44:19] 127.0.0.1: cocinando la respuesta de tipo 'A' para thesprawl.org a 192.0.2.2
[00:44:29] 127.0.0.1: proxy de respuesta de tipo 'A' para www.thesprawl.org
[00:44:40] 127.0.0.1: cocinando la respuesta de tipo 'A' para www.wordpress.org a 192.0.2.3
[00:44:51] 127.0.0.1: cocinando la respuesta de tipo 'A' para wordpress.com a 192.0.2.3
[00:45:02] 127.0.0.1: proxy de respuesta de tipo 'A' para 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 hizo proxy en lugar de modificarse. Por último, 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. Finalmente, una consulta no definida de slashdot.org simplemente se hizo proxy con una respuesta real.

Puede especificar encabezados de sección para todos los demás tipos de registros DNS compatibles, incluidos aquellos no expuestos 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.ini':

root@kitploit:~
[PTR]
*.2.0.192.in-addr.arpa=fake.com

Observemos el comportamiento de DNSChef con este nuevo tipo de registro:

root@kitploit:~
 ./dnschef.py --file dnschef.ini -q
[sudo] password for iphelix: 
[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[+] Cocinando respuestas PTR para el dominio *.2.0.192.in-addr.arpa con 'fake.com'
[00:11:34] 127.0.0.1: cocinando la respuesta de tipo 'PTR' para 1.2.0.192.in-addr.arpa a fake.com

Y aquí está lo que un cliente podría ver al realizar consultas DNS inversas:

root@kitploit:~
$ host 192.0.2.1 localhost
1.2.0.192.in-addr.arpa domain name pointer fake.com.

Algunos registros requieren un formato exacto. Buenos ejemplos son SOA y NAPTR:

root@kitploit:~
[SOA]
*.thesprawl.org=ns.fake.com. hostmaster.fake.com. 1 10800 3600 604800 3600

[NAPTR]
*.thesprawl.org=100 10 U E2U+sip !^.*$!sip:[email protected]! .

Consulte el archivo dnschef.ini de muestra para más ejemplos.

Filtrado avanzado

Puede combinar entradas de un archivo y de la línea de comandos. Por ejemplo, el siguiente comando utiliza ambos parámetros --file y --fakedomains:

root@kitploit:~
# ./dnschef.py --file dnschef.ini --fakeip 6.6.6.6 --fakedomains=thesprawl.org,slashdot.org -q
[*] DNSChef iniciado en la interfaz: 127.0.0.1 
[*] Usando los siguientes servidores de nombres: 8.8.8.8
[+] Cocinando respuestas A para el dominio *.google.com con '192.0.2.1'
[+] Cocinando respuestas A para el dominio thesprawl.org con '192.0.2.2'
[+] Cocinando respuestas A para el dominio *.wordpress.* con '192.0.2.3'
[*] Cocinando respuestas A para que apunten a 6.6.6.6 coincidiendo con: *.wordpress.*, *.google.com, thesprawl.org
[*] Cocinando respuestas A para que apunten a 6.6.6.6 coincidiendo con: slashdot.org, *.wordpress.*, *.google.com, thesprawl.org
[00:49:05] 127.0.0.1: cocinando la respuesta de tipo 'A' para google.com a 192.0.2.1
[00:49:15] 127.0.0.1: cocinando la respuesta de tipo 'A' para slashdot.org a 6.6.6.6
[00:49:31] 127.0.0.1: cocinando la respuesta de tipo 'A' para thesprawl.org a 6.6.6.6
[00:50:08] 127.0.0.1: proxy de respuesta de tipo 'A' para tor.com

Observe que la definición para thesprawl.org en el parámetro de línea de comandos tuvo prioridad sobre dnschef.ini. Esto puede ser útil si desea sobrescribir valores en el archivo de configuración. slashdot.org aún se resuelve a la dirección IP falsa porque fue especificado en el parámetro --fakedomains. La solicitud de tor.com simplemente se hace proxy ya que no fue especificada ni en la línea de comandos ni en el archivo de configuración.

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

root@kitploit:~
# ./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:

root@kitploit:~
# ./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 utiliza el servidor DNS público de Google para hacer solicitudes proxy. Sin embargo, puede definir una lista personalizada de servidores de nombres usando el parámetro --nameservers:

root@kitploit:~
# ./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#PUERTO:

root@kitploit:~
# ./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 puerto#:

root@kitploit:~
# ./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 puede activarse con la bandera --tcp.

Arquitectura interna

Aquí hay información sobre los detalles internos por si necesita adaptar la herramienta a sus necesidades. DNSChef está construido sobre el módulo SocketServer y utiliza hilos para ayudar a procesar múltiples solicitudes simultáneamente. La herramienta está diseñada para escuchar en puertos TCP o UDP (por defecto el puerto 53) para recibir solicitudes entrantes y reenviarlas cuando sea necesario a un servidor DNS real a través de UDP.

La excelente librería dnslib se utiliza para desglosar y reensamblar paquetes DNS. Es particularmente útil al generar paquetes de respuesta basados en consultas.

DNSChef es capaz de modificar consultas para registros de tipo "A", "AAAA", "MX", "CNAME", "NS", "TXT", "PTR", "NAPTR", "SOA", "ANY". Es muy fácil expandir o modificar el comportamiento para cualquier registro. Simplemente agregue otra entrada if qtype == "TIPO DE REGISTRO") e indique qué responder.

¡Disfrute la herramienta y envíe todas las solicitudes y comentarios a iphelix [at] thesprawl.org.

¡Feliz hacking! -Peter