dnschef-ng

DNSChef ist ein hochgradig konfigurierbarer DNS-Proxy für Penetrationstester und Malware-Analysten. Ein DNS-Proxy (auch „Fake DNS“ genannt) ist ein Werkzeug, das unter anderem für die Analyse des Netzwerkverkehrs von Anwendungen verwendet wird. Beispielsweise kann ein DNS-Proxy verwendet werden, um Anfragen für „badguy.com“ so zu fälschen, dass sie auf eine lokale Maschine zur Beendigung oder Abfangung zeigen, anstatt auf einen echten Host irgendwo im Internet.

Es gibt einige DNS-Proxys auf dem Markt. Die meisten leiten einfach alle DNS-Anfragen an eine einzelne IP-Adresse um oder implementieren nur rudimentäre Filter. DNSChef wurde im Rahmen eines Penetrationstests entwickelt, bei dem ein besser konfigurierbares System benötigt wurde. Das Ergebnis ist eine plattformübergreifende Anwendung, die Antworten auf der Grundlage von inklusiven und exklusiven Domainlisten fälschen kann, mehrere DNS-Record-Typen unterstützt, Domains mit Platzhaltern abgleicht, echte Antworten für nicht passende Domains weiterleitet, externe Konfigurationsdateien definiert, IPv6 und viele weitere Funktionen bietet. Eine detaillierte Erläuterung der einzelnen Funktionen und vorgeschlagenen Anwendungen findest du weiter unten.

Der Einsatz eines DNS-Proxys wird in Situationen empfohlen, in denen eine Anwendung nicht dazu gezwungen werden kann, einen anderen Proxy-Server direkt zu verwenden. Beispielsweise ignorieren einige mobile Anwendungen die HTTP-Proxy-Einstellungen des Betriebssystems vollständig. In solchen Fällen ermöglicht dir der Einsatz eines DNS-Proxyservers wie DNSChef, die Anwendung dazu zu bringen, Verbindungen an das gewünschte Ziel weiterzuleiten.

## Neue Funktionen

- Erfordert Python 3.11+
- Unterstützt das Staging von Dateien über DNS (derzeit nur über `A`,`AAAA`,`TXT` ...)
- Konfigurationsdatei ist jetzt TOML
- Optionale HTTP-API (ermöglicht das Abfragen von Logs und das Aktualisieren der Konfiguration aus der Ferne)
- Vollständig asynchron für verbesserte Leistung (nutzt AsyncIO)
- Strukturierte Protokollierung und eine Reihe von QOL-Verbesserungen
- Ist jetzt ein Python-Paket
- Dockerisiert
- Enthält eine Reihe von PRs und Fixes aus dem ursprünglichen Repository

## Installation

Um die neueste Version zu installieren, solltest du [pipx](https://pypa.github.io/pipx/) verwenden (es sei denn, du bist ein Arschloch, das schlampige Steaks mag):

    pipx install dnschef-ng

Wenn du die HTTP-API nutzen möchtest (erfordert einige zusätzliche Abhängigkeiten):

    pipx install dnschef-ng[api]

Neueste Version aus Git mit pipx installieren:

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

Neueste Version aus Git mit pipx inklusive der Abhängigkeiten für die HTTP-API installieren:

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

## Einrichten eines DNS-Proxys

Bevor du DNSChef verwenden kannst, musst du deinen Rechner so konfigurieren, dass er einen DNS-Nameserver verwendet, auf dem das Tool läuft. Je nach Betriebssystem hast du mehrere Möglichkeiten:

- **Linux** – Bearbeite */etc/resolv.conf*, um ganz oben eine Zeile mit deinem Analyse-Host einzufügen (z. B. füge „nameserver 127.0.0.1“ hinzu, wenn du lokal arbeitest). Alternativ kannst du über Tools wie den Network Manager eine DNS-Serveradresse hinzufügen. Öffne im Network Manager die IPv4-Einstellungen, wähle *Nur automatische (DHCP) Adressen* oder *Manuell* aus dem Dropdown-Menü *Methode* und bearbeite das Textfeld *DNS-Server*, um eine IP-Adresse mit laufendem DNSChef einzutragen.

- **Windows** – Wähle im *Systemsteuerung* die *Netzwerkverbindungen* aus. Wähle dann eine der Verbindungen aus (z. B. „LAN-Verbindung“), klicke mit der rechten Maustaste darauf und wähle Eigenschaften. Wähle im neu erscheinenden Dialogfeld *Internetprotokoll (TCP/IP)* aus und klicke auf Eigenschaften. Wähle schließlich das Optionsfeld *Folgende DNS-Serveradressen verwenden* und gib die IP-Adresse ein, auf der DNSChef läuft. Wenn du z. B. lokal arbeitest, gib 127.0.0.1 ein.

- **OS X** – Öffne *Systemeinstellungen* und klicke auf das Symbol *Netzwerk*. Wähle die aktive Schnittstelle aus und fülle das Feld *DNS-Server* aus. Wenn du Airport verwendest, musst du auf die Schaltfläche *Erweitert…* klicken und die DNS-Server dort bearbeiten. Alternativ kannst du */etc/resolv.conf* bearbeiten und ganz oben einen gefälschten Nameserver hinzufügen (z. B. „nameserver 127.0.0.1“).

- **iOS** – Öffne *Einstellungen* und wähle *Allgemein*. Wähle dann *WLAN* und tippe auf den blauen Pfeil rechts neben einem aktiven Zugangspunkt in der Liste. Bearbeite den DNS-Eintrag, sodass er auf den Host mit laufendem DNSChef zeigt. Stelle sicher, dass du die Mobilfunk-Schnittstelle deaktiviert hast (falls verfügbar).

- **Android** – Öffne *Einstellungen* und wähle *Drahtlos und Netzwerke*. Tippe auf *WLAN-Einstellungen* und wähle *Erweitert*, nachdem du die *Optionen*-Taste am Telefon gedrückt hast. Aktiviere das Kontrollkästchen *Statische IP verwenden* und konfiguriere einen benutzerdefinierten DNS-Server.

Wenn du die DNS-Einstellungen des Geräts nicht manuell ändern kannst, gibt es dennoch mehrere Optionen mit Techniken wie [ARP-Spoofing](http://en.wikipedia.org/wiki/ARP_spoofing), [Rogue DHCP](http://www.yersinia.net/doc.htm) und anderen kreativen Methoden.

Schließlich musst du einen gefälschten Dienst konfigurieren, auf den DNSChef alle Anfragen umleiten soll. Wenn du beispielsweise Webverkehr abfangen möchtest, musst du entweder einen separaten Webserver auf Port 80 starten oder einen Web-Proxy (z. B. Burp) einrichten, um den Verkehr abzufangen. DNSChef leitet die Anfragen an deinen Proxy-/Server-Host mit entsprechend konfigurierten Diensten weiter.

## DNSChef ausführen

DNSChef ist eine plattformübergreifende, in Python entwickelte Anwendung, die auf den meisten Plattformen mit einem Python-Interpreter laufen sollte. Diese Anleitung konzentriert sich auf Unix-Umgebungen; alle unten aufgeführten Beispiele wurden jedoch auch unter Windows getestet.

Verschaffen wir uns einen ersten Eindruck von DNSChef mit seiner grundlegenden Überwachungsfunktion. Führe den folgenden Befehl als Root aus (erforderlich, um einen Server auf Port 53 zu starten):

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

Ohne Parameter läuft DNSChef im vollständigen Proxy-Modus. Das bedeutet, dass alle Anfragen einfach an einen vorgelagerten DNS-Server (standardmäßig 8.8.8.8) weitergeleitet und an den anfragenden Host zurückgegeben werden. Fragen wir beispielsweise einen „A“-Datensatz für eine Domain ab und beobachten wir die Ergebnisse:

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

DNSChef gibt die folgende Protokollzeile aus, die Zeit, Quell-IP-Adresse, Typ des angeforderten Datensatzes und – am wichtigsten – den abgefragten Namen anzeigt:

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

Dieser Modus ist nützlich für die einfache Anwendungsüberwachung, wenn du herausfinden möchtest, welche Domains eine Anwendung für ihre Kommunikation verwendet.

DNSChef bietet volle Unterstützung für IPv6, die mit den Flags *-6* oder *--ipv6** aktiviert werden kann. Es funktioniert genau wie der IPv4-Modus, mit der Ausnahme, dass die Standard-Listening-Schnittstelle auf ::1 und der Standard-DNS-Server auf 2001:4860:4860::8888 umgestellt wird. Hier ist eine Beispielausgabe:

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

HINWEIS: Standardmäßig erstellt DNSChef einen UDP-Listener. Du kannst stattdessen TCP verwenden, und zwar mit dem später besprochenen Argument *--tcp*.

## Ausführen der DNSChef-HTTP-API

> [!WARNING]
> Die API verfügt über keine Authentifizierung. Erlaube/verweigere den Zugriff auf Netzwerkebene über Sicherheitsgruppen, iptables, Firewall usw..

`uvicorn dnschef.api:app`

Danach kannst du die OpenAPI-Dokumentation unter `http://127.0.0.1:8000/docs` aufrufen.```
$ 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

Beachte den Abschnittsheader `[A]`, er definiert den Datensatztyp für DNSChef. Betrachten wir nun aufmerksam die Ausgabe mehrerer Abfragen:

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

Sowohl *google.com* als auch *www.google.com* passten auf den Eintrag *\*.google.com* und wurden korrekt auf *192.0.2.1* aufgelöst. Die Anfrage für *www.thesprawl.org* wurde hingegen einfach proxied, anstatt modifiziert zu werden. Schließlich passten alle Varianten wie *wordpress.com*, *www.wordpress.org* usw. auf die Maske *\*.wordpress.\** und wurden korrekt auf *192.0.2.3* aufgelöst. Schließlich wurde eine undefinierte *slashdot.org*-Abfrage einfach mit einer echten Antwort proxied.

Du kannst Abschnittsheader für alle anderen unterstützten DNS-Datensatztypen angeben, einschließlich derer, die nicht direkt über die Befehlszeile verfügbar sind: [A], [AAAA], [MX], [NS], [CNAME], [PTR], [NAPTR] und [SOA]. Definieren wir zum Beispiel einen neuen [PTR]-Abschnitt in der Datei `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.

Siehe Beispieldatei `dnschef.toml` für weitere Beispiele.

## Datei-Staging

DNSChef kann jede Datei über DNS „stagen“. Derzeit wird das Datei-Staging nur mit den Records `A`, `AAAA` und `TXT` unterstützt (weitere werden folgen). Um DNSChef anzuweisen, eine Datei zu stagen, fügen Sie den folgenden Abschnitt zu Ihrer `dnschef.toml` hinzu:```toml
[A]
"*.wat.org" = { file = "/home/payload.exe", chunk_size = 4 }

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

Mit dieser Konfiguration gibt jede `TXT`-Abfrage an `ns*.dungbeetle.org` einen Teil unserer Datei zurück, die sich lokal im Dateisystem unter `~/payload.exe` befindet.

Die Einstellungen `response_format` und `response_prefix_pool` sind optional, ermöglichen es dir aber, die DNS-`TXT`-Antwort weiter anzupassen.

Die Einstellung `response_format` definiert das Format der `TXT`-Antwort: 

- Die Variable `{prefix}` wird zufällig durch einen der in dem Array `response_prefix_pool` definierten Werte ersetzt.

- Die Variable `{chunk}` wird durch den Dateiteil (Chunk) ersetzt.

Mit der obigen Konfiguration gibt eine `TXT`-Abfrage an `ns1.dungbeetle.org` die folgende Antwort zurück:```
docusign=test-<BASE64_ENCODED_FILE_CHUNK_N1>

## Erweiterte Filterung

Sie können Eingaben aus einer Datei und von der Befehlszeile beliebig kombinieren. Der folgende Befehl verwendet beispielsweise sowohl die Parameter `--file` als auch `--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

Beachten Sie, dass die Definition für *thesprawl.org* im Befehlszeilenparameter Vorrang vor *dnschef.toml* hatte. Dies kann nützlich sein, wenn Sie Werte in der Konfigurationsdatei überschreiben möchten. slashdot.org wird weiterhin auf die gefälschte IP-Adresse aufgelöst, da es im Parameter *--fakedomains* angegeben wurde. Die tor.com-Anfrage wird einfach per Proxy weitergeleitet, da sie weder in der Befehlszeile noch in der Konfigurationsdatei angegeben wurde.

## Weitere Konfigurationen

Aus Sicherheitsgründen lauscht DNSChef standardmäßig auf der lokalen Schnittstelle 127.0.0.1 (bzw. ::1 für IPv6). Sie können DNSChef mit dem Parameter *--interface* auf einer anderen Schnittstelle lauschen lassen:

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

oder für 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

Standardmäßig verwendet DNSChef den öffentlichen DNS-Server von Google für Proxy-Anfragen. Sie können jedoch mit dem Parameter *--nameservers* eine eigene Liste von Nameservern festlegen:

    # ./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 ist möglich, einen nicht standardmäßigen Nameserver-Port mithilfe der IP#PORT-Notation anzugeben:

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

Gleichzeitig ist es möglich, DNSChef selbst über den Parameter `-p port#` auf einem alternativen Port zu starten:

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

Das DNS-Protokoll kann über UDP (Standard) oder TCP verwendet werden. DNSChef implementiert einen TCP-Modus, der mit dem Flag `--tcp` aktiviert werden kann.