dnschef-ng

DNSChef est un proxy DNS hautement configurable pour les testeurs d'intrusion et les analystes de malwares. Un proxy DNS (aussi appelé "Fake DNS") est un outil utilisé pour l'analyse du trafic réseau d'applications, entre autres usages. Par exemple, un proxy DNS peut être utilisé pour falsifier les requêtes vers "badguy.com" afin qu'elles pointent vers une machine locale pour y être terminées ou interceptées au lieu d'un hôte réel sur Internet.

Il existe plusieurs proxys DNS. La plupart se contentent de pointer toutes les requêtes DNS vers une seule adresse IP ou n'implémentent qu'un filtrage rudimentaire. DNSChef a été développé dans le cadre d'un test d'intrusion où un système plus configurable était nécessaire. En conséquence, DNSChef est une application multiplateforme capable de forger des réponses basées sur des listes de domaines inclusives et exclusives, de prendre en charge plusieurs types d'enregistrements DNS, de faire correspondre des domaines avec des jokers, de relayer les vraies réponses pour les domaines non correspondants, de définir des fichiers de configuration externes, l'IPv6 et bien d'autres fonctionnalités. Vous trouverez ci-dessous une explication détaillée de chacune des fonctionnalités et des utilisations suggérées.

L'utilisation d'un proxy DNS est recommandée dans les situations où il n'est pas possible de forcer une application à utiliser directement un autre serveur proxy. Par exemple, certaines applications mobiles ignorent complètement les paramètres de proxy HTTP du système d'exploitation. Dans ces cas, l'utilisation d'un serveur proxy DNS tel que DNSChef vous permettra d'amener cette application à rediriger les connexions vers la destination souhaitée.

## Nouvelles fonctionnalités

- Nécessite Python 3.11+
- Prend en charge le transfert de fichiers via DNS (uniquement via `A`,`AAAA`,`TXT` pour l'instant...)
- Le fichier de configuration est désormais en TOML
- API HTTP optionnelle (permet de consulter les journaux et de mettre à jour la configuration à distance)
- Entièrement asynchrone pour des performances accrues (utilise AsyncIO)
- Journalisation structurée et un certain nombre d'améliorations de la qualité de vie
- Est désormais un package Python
- Dockerisé
- Inclut un certain nombre de PR et de correctifs du dépôt d'origine

## Installation

Pour installer la dernière version, vous devriez utiliser [pipx](https://pypa.github.io/pipx/) (sauf si vous êtes une espèce de merde qui aime les steaks bâclés) :

    pipx install dnschef-ng

Si vous voulez l'API HTTP (nécessite des dépendances supplémentaires) :
    
    pipx install dnschef-ng[api]

Installez la dernière version depuis Git avec pipx :

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

Installez la dernière version depuis Git avec pipx et les dépendances pour l'API HTTP :

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


## Configuration d'un proxy DNS

Avant de pouvoir commencer à utiliser DNSChef, vous devez configurer votre machine pour utiliser un serveur de noms DNS avec l'outil en cours d'exécution. Vous avez plusieurs options selon le système d'exploitation que vous allez utiliser :

- **Linux** - Modifiez */etc/resolv.conf* pour inclure une ligne tout en haut avec votre hôte d'analyse du trafic (par exemple, ajoutez "nameserver 127.0.0.1"  si vous exécutez localement). Vous pouvez également ajouter une adresse de serveur DNS à l'aide d'outils tels que Network Manager. Dans Network Manager, ouvrez les paramètres IPv4, sélectionnez *Adresses automatiques (DHCP) uniquement* ou *Manuel* dans la liste déroulante *Méthode* et modifiez le champ *Serveurs DNS* pour inclure une adresse IP avec DNSChef en cours d'exécution.

- **Windows** - Sélectionnez *Connexions réseau* dans le *Panneau de configuration*. Sélectionnez ensuite l'une des connexions (par exemple, "Connexion au réseau local"), faites un clic droit dessus et choisissez Propriétés. Dans la boîte de dialogue qui apparaît, sélectionnez *Protocole Internet (TCP/IP)* et cliquez sur Propriétés. Enfin, sélectionnez l'option *Utiliser les adresses de serveur DNS suivantes* et saisissez l'adresse IP avec DNSChef en cours d'exécution. Par exemple, si vous exécutez localement, saisissez 127.0.0.1.

- **OS X** - Ouvrez *Préférences Système* et cliquez sur l'icône *Réseau*. Sélectionnez l'interface active et renseignez le champ *Serveur DNS*. Si vous utilisez Airport, vous devrez cliquer sur le bouton *Avancé...* et modifier les serveurs DNS à partir de là. Vous pouvez également modifier */etc/resolv.conf* et y ajouter un faux serveur de noms tout en haut (par exemple "nameserver 127.0.0.1").

- **iOS** - Ouvrez *Réglages* et sélectionnez *Général*. Sélectionnez ensuite *Wi-Fi* et cliquez sur la flèche bleue à droite d'un point d'accès actif dans la liste. Modifiez l'entrée DNS pour pointer vers l'hôte où DNSChef est en cours d'exécution. Assurez-vous d'avoir désactivé l'interface cellulaire (si disponible).

- **Android** - Ouvrez *Paramètres* et sélectionnez *Sans fil et réseaux*.  Touchez *Paramètres Wi-Fi* et sélectionnez *Avancé* après avoir appuyé sur le bouton *Options* du téléphone. Activez la case *Utiliser une adresse IP statique* et configurez un serveur DNS personnalisé.

Si vous n'avez pas la possibilité de modifier manuellement les paramètres DNS de l'appareil, vous disposez encore de plusieurs options faisant appel à des techniques telles que l'[usurpation ARP](http://en.wikipedia.org/wiki/ARP_spoofing), le [DHCP pirate](http://www.yersinia.net/doc.htm) et d'autres méthodes créatives.

Enfin, vous devez configurer un faux service vers lequel DNSChef pointera toutes les requêtes. Par exemple, si vous essayez d'intercepter le trafic web, vous devez démarrer soit un serveur web séparé sur le port 80, soit configurer un proxy web (par exemple Burp) pour intercepter le trafic. DNSChef pointera les requêtes vers votre hôte proxy/serveur avec des services correctement configurés.

## Exécution de DNSChef

DNSChef est une application multiplateforme développée en Python qui devrait fonctionner sur la plupart des plateformes disposant d'un interpréteur Python. Ce guide se concentrera sur les environnements Unix ; cependant, tous les exemples ci-dessous ont été testés et fonctionnent également sous Windows.

Essayons DNSChef avec sa fonctionnalité de surveillance la plus basique. Exécutez la commande suivante en tant que root (requis pour démarrer un serveur sur le port 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

Sans aucun paramètre, DNSChef fonctionne en mode proxy complet. Cela signifie que toutes les requêtes seront simplement transmises à un serveur DNS en amont (8.8.8.8 par défaut) et renvoyées à l'hôte demandeur. Par exemple, interrogeons un enregistrement "A" pour un domaine et observons les résultats :

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

DNSChef affichera la ligne de journal suivante indiquant l'heure, l'adresse IP source, le type d'enregistrement demandé et, surtout, le nom interrogé :

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

Ce mode est utile pour la surveillance simple d'applications lorsque vous avez besoin de savoir quels domaines elles utilisent pour leurs communications.

DNSChef prend entièrement en charge IPv6, qui peut être activé à l'aide des options *-6* ou *--ipv6**. Il fonctionne exactement comme le mode IPv4, à l'exception que l'interface d'écoute par défaut est remplacée par ::1 et que le serveur DNS par défaut est remplacé par 2001:4860:4860::8888. Voici un exemple de sortie :

    # ./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

REMARQUE : Par défaut, DNSChef crée un écouteur UDP. Vous pouvez utiliser TCP à la place avec l'argument *--tcp* décrit plus loin.

## Exécution de l'API HTTP de DNSChef

> [!WARNING]
> L'API n'a pas d'authentification. Autorisez/refusez l'accès au niveau du réseau via les groupes de sécurité, iptables, le pare-feu, etc..

`uvicorn dnschef.api:app`

Vous pouvez ensuite consulter la documentation OpenAPI à l'adresse `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

Remarquez l'en-tête de section `[A]` : il définit le type d'enregistrement pour DNSChef. Observons maintenant attentivement la sortie de plusieurs requêtes :

    # ./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

*google.com* et *www.google.com* correspondent tous deux à l'entrée *\*.google.com* et ont été correctement résolus vers *192.0.2.1*. En revanche, la requête *www.thesprawl.org* a simplement été proxifiée au lieu d'être modifiée. Enfin, toutes les variantes de *wordpress.com*, *www.wordpress.org*, etc. correspondent au masque *\*.wordpress.\** et ont été correctement résolues vers *192.0.2.3*. Enfin, une requête *slashdot.org* non définie a simplement été proxifiée avec une réponse réelle.

Vous pouvez spécifier des en-têtes de section pour tous les autres types d'enregistrement DNS pris en charge, y compris ceux qui ne sont pas explicitement exposés en ligne de commande : [A], [AAAA], [MX], [NS], [CNAME], [PTR], [NAPTR] et [SOA]. Par exemple, définissons une nouvelle section [PTR] dans le fichier `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.

Voir le fichier d'exemple `dnschef.toml` pour des exemples supplémentaires.

## Staging de fichiers

DNSChef peut « stager » n'importe quel fichier via le DNS. Actuellement, le staging de fichiers n'est pris en charge qu'avec les enregistrements `A`, `AAAA` et `TXT` (d'autres seront ajoutés). Pour demander à DNSChef de stager un fichier, ajoutez la section suivante à votre `dnschef.toml` :```toml
[A]
"*.wat.org" = { file = "/home/payload.exe", chunk_size = 4 }

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

Avec cette configuration, toute requête `TXT` vers `ns*.dungbeetle.org` renverra un fragment de notre fichier situé localement sur le système de fichiers à `~/payload.exe`.

Les paramètres `response_format` et `response_prefix_pool` sont facultatifs mais vous permettent de personnaliser davantage la réponse DNS `TXT`.

Le paramètre `response_format` définit le format de la réponse `TXT` :

- La variable `{prefix}` sera remplacée aléatoirement par l'une des valeurs définies dans le tableau `response_prefix_pool`.

- La variable `{chunk}` sera remplacée par le fragment du fichier.

Avec la configuration ci-dessus, une requête `TXT` vers `ns1.dungbeetle.org` renverra la réponse suivante :```
docusign=test-<BASE64_ENCODED_FILE_CHUNK_N1>

## Filtrage avancé

Vous pouvez mélanger et combiner les entrées provenant d'un fichier et de la ligne de commande. Par exemple, la commande suivante utilise à la fois les paramètres `--file` et `--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

Remarquez que la définition de *thesprawl.org* dans le paramètre de ligne de commande a pris le pas sur *dnschef.toml*. Cela peut être utile si vous souhaitez remplacer des valeurs du fichier de configuration. slashdot.org continue de résoudre vers l'adresse IP factice car il a été spécifié dans le paramètre *--fakedomains*. La requête tor.com est simplement relayée par proxy car elle n'a été spécifiée ni dans la ligne de commande ni dans le fichier de configuration.

## Autres configurations

Pour des raisons de sécurité, DNSChef écoute par défaut sur l'interface locale 127.0.0.1 (ou ::1 pour IPv6). Vous pouvez faire écouter DNSChef sur une autre interface en utilisant le paramètre *--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

ou pour 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

Par défaut, DNSChef utilise le serveur DNS public de Google pour effectuer les requêtes proxy. Toutefois, vous pouvez définir une liste personnalisée de serveurs de noms à l'aide du paramètre *--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

Il est possible de spécifier un port de serveur de noms non standard en utilisant la notation 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

Il est également possible de démarrer DNSChef lui-même sur un port alternatif en utilisant le paramètre `-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

Le protocole DNS peut être utilisé via UDP (par défaut) ou TCP. DNSChef implémente un mode TCP qui peut être activé avec l'option `--tcp`.