farrokhi/dnsdiagDNS-Messung, Fehlerbehebung und Sicherheits-Audit-Toolset
[](https://pypi.python.org/pypi/dnsdiag/) []() [](https://pepy.tech/project/dnsdiag) [](https://pepy.tech/project/dnsdiag) []() [](https://hub.docker.com/r/farrokhi/dnsdiag) [](https://github.com/farrokhi/dnsdiag/stargazers)
DNS-Mess-, Fehlerbehebungs- und Sicherheitsaudit-Toolset
===============================================================
Haben Sie sich jemals gefragt, ob Ihr ISP [Ihren DNS-Datenverkehr
abfängt](https://medium.com/decentralize-today/is-your-isp-hijacking-your-dns-traffic-f3eb7ccb0ee7)?
Haben Sie ungewöhnliches Verhalten in Ihren DNS-Antworten bemerkt oder wurden Sie
auf die falsche Adresse umgeleitet und vermuteten, dass mit Ihrem DNS etwas nicht
stimmt? Wir bieten eine Suite von Tools an, um grundlegende Audits Ihrer DNS-Anfragen
und -Antworten durchzuführen und Ihnen zu helfen sicherzustellen, dass Ihr DNS wie
erwartet funktioniert.
Mit `dnsping` können Sie die Antwortzeit eines beliebigen DNS-Servers für
beliebige Abfragen messen. Ähnlich wie das reguläre Ping-Dienstprogramm bietet
dnsping eine vergleichbare Funktionalität für DNS-Anfragen und hilft Ihnen, die
Reaktionsfähigkeit des Servers zu überwachen.
Sie können auch die Route Ihrer DNS-Anfrage zu ihrem Ziel mit
`dnstraceroute` verfolgen und überprüfen, ob sie nicht umgeleitet oder abgefangen
wird. Durch den Vergleich von DNS-Anfragen, die an denselben Server gesendet
werden, ermöglicht es `dnstraceroute`, Unterschiede in den genommenen Pfaden zu
beobachten und Sie auf mögliche Probleme aufmerksam zu machen.
`dnseval` bewertet mehrere DNS-Resolver, um Ihnen zu helfen, den besten
DNS-Resolver für Ihr Netzwerk auszuwählen. Während die Verwendung Ihres eigenen
DNS-Resolvers empfohlen wird, um die Abhängigkeit von DNS-Resolvern Dritter zu
vermeiden, kann `dnseval` bei Bedarf bei der Auswahl des optimalen DNS-Resolvers
unterstützen. Es ermöglicht Ihnen, DNS-Server anhand von Leistung (Latenz) und
Zuverlässigkeit (Paketverlust) zu vergleichen und bietet Ihnen einen umfassenden
Überblick für eine fundierte Entscheidungsfindung.
# Installation
Es gibt mehrere Möglichkeiten, dieses Toolset zu verwenden, wobei wir empfehlen,
es direkt aus dem Quellcode auszuführen, um optimale Flexibilität und Kontrolle
zu erhalten. Das Ausführen aus dem Quellcode oder die Installation mit pip
erfordert Python 3.11 oder neuer.
## Quellcode
1. Klonen Sie das Git-Repository und installieren Sie die Abhängigkeiten:
```
git clone https://github.com/farrokhi/dnsdiag.git
cd dnsdiag
pip3 install -r requirements.txt
```
2. Alternativ können Sie das Paket mit pip installieren:
```
pip3 install dnsdiag
```
## Verwendung von uv (Empfohlen)
[uv](https://docs.astral.sh/uv/) ist ein schneller Python-Paketmanager, der Tools direkt ohne Installation ausführen kann:
```bash
# dnsping direkt ohne Installation ausführen
uvx --from dnsdiag dnsping google.com
# Mit spezifischen Optionen ausführen
uvx --from dnsdiag dnsping -c 5 --tls -s 8.8.8.8 example.com
# dnstraceroute ausführen
uvx --from dnsdiag dnstraceroute cloudflare.com
# dnseval ausführen
uvx --from dnsdiag dnseval -f public-servers.txt github.com
```
Um dnsdiag dauerhaft zu installieren:
```bash
# dnsdiag-Tools installieren
uv tool install dnsdiag
# Auf die neueste Version aktualisieren
uv tool upgrade dnsdiag
```
## Binärpaket
Von Zeit zu Zeit werden Binärpakete für Windows, Mac OS X und Linux
veröffentlicht. Die neueste Version können Sie von der [Releases-Seite](https://github.com/farrokhi/dnsdiag/releases) herunterladen.
### Unterstützte Plattformen
Vorgefertigte Binärdateien sind verfügbar für:
- Linux (x86_64, ARM64)
- macOS (Intel, Apple Silicon)
- Windows (x86_64)
Windows ARM64 wird derzeit nicht unterstützt, da die Build-Abhängigkeiten native
Kompilierungs-Toolchains erfordern, die nicht ohne Weiteres verfügbar sind. Wenn
Sie Windows auf ARM verwenden, können Sie dnsdiag mit dem Windows Subsystem for
Linux (WSL2) ausführen oder direkt aus dem Quellcode installieren.
## Docker
Wenn Sie `dnsdiag` nicht auf Ihrem lokalen Rechner installieren möchten, können
Sie das Docker-Image verwenden, um die Tools in einer containerisierten Umgebung
auszuführen. Zum Beispiel:
```
docker run --network host -it --rm farrokhi/dnsdiag dnsping.py
```
# dnsping
`dnsping` ermöglicht es Ihnen, einen DNS-Resolver zu "pingen", indem Sie eine
beliebige DNS-Anfrage mehrmals senden. Eine vollständige Liste der unterstützten
Kommandozeilenoptionen erhalten Sie mit `--help`. Hier sind einige wichtige Flags:
- Verwenden Sie `--tcp`, `--tls`, `--doh`, `--quic` oder `--http3`, um das
Transportprotokoll auszuwählen (Standard ist UDP). Diese Optionen schließen sich
gegenseitig aus; pro Befehl kann nur ein Protokoll angegeben werden.
- Verwenden Sie `--flags`, um Antwort-Flags, einschließlich EDNS-Flags, für jede
Antwort anzuzeigen.
- Verwenden Sie `--dnssec`, um DNSSEC-Validierung anzufordern, falls verfügbar.
- Extended DNS Error-Nachrichten ([RFC 8914](https://www.rfc-editor.org/rfc/rfc8914)) werden automatisch angezeigt, wenn sie vorhanden sind.
- Verwenden Sie `--nsid`, um den Name Server Identifier (NSID) anzuzeigen, falls verfügbar ([RFC 5001](https://www.rfc-editor.org/rfc/rfc5001)).
- Verwenden Sie `--ecs`, um EDNS Client Subnet-Informationen für geografische Routing-Optimierung einzubeziehen.
- Verwenden Sie `--cookie`, um DNS-Cookies ([RFC 7873](https://www.rfc-editor.org/rfc/rfc7873)) anzuzeigen, wenn sie in Antworten vorhanden sind.
```shell
./dnsping.py -c 5 --dnssec --flags --tls -t AAAA -s 8.8.8.8 brokendnssec.net
```
```
dnsping.py DNS: 8.8.8.8:853, hostname: brokendnssec.net, proto: TLS, class: IN, type: AAAA, flags: [RD]
75 bytes from 8.8.8.8: seq=1 time=73.703 ms SERVFAIL [QR RD RA -- DO] [EDE:10("For brokendnssec.net/soa")]
75 bytes from 8.8.8.8: seq=2 time=69.523 ms SERVFAIL [QR RD RA -- DO] [EDE:10("For brokendnssec.net/soa")]
75 bytes from 8.8.8.8: seq=3 time=58.058 ms SERVFAIL [QR RD RA -- DO] [EDE:10("For brokendnssec.net/soa")]
75 bytes from 8.8.8.8: seq=4 time=54.235 ms SERVFAIL [QR RD RA -- DO] [EDE:10("For brokendnssec.net/soa")]
75 bytes from 8.8.8.8: seq=5 time=57.806 ms SERVFAIL [QR RD RA -- DO] [EDE:10("For brokendnssec.net/soa")]
--- 8.8.8.8 dnsping statistics ---
5 requests transmitted, 5 responses received, 0% lost
min=54.235 ms, avg=22.665 ms, max=69.523 ms, stddev=38.202 ms
```
`dnsping` bietet auch Statistiken wie minimale, maximale und durchschnittliche
Antwortzeiten sowie Jitter (Standardabweichung) und Paketverlust.
Hier sind einige interessante Anwendungsfälle für `dnsping`:
- Vergleich der Antwortzeiten über verschiedene Transportprotokolle (z. B. UDP vs. DoH).
- Bewertung der Zuverlässigkeit Ihres DNS-Servers durch Messung von Jitter und Paketverlust.
- Messung der Antwortzeiten mit aktiviertem DNSSEC unter Verwendung des `--dnssec`-Flags.
- Testen des EDNS Client Subnet-Verhaltens für geolokalisierungsbewusste Antworten:
```shell
./dnsping.py -c 3 --ecs 203.0.113.0/24 -s 94.140.14.14 google.com
```
```
dnsping.py DNS: 94.140.14.14:53, hostname: google.com, proto: UDP, class: IN, type: A, flags: [RD]
66 bytes from 94.140.14.14: seq=1 time=31.407 ms NOERROR [ECS:203.0.113.0/24/24]
66 bytes from 94.140.14.14: seq=2 time=29.156 ms NOERROR [ECS:203.0.113.0/24/24]
66 bytes from 94.140.14.14: seq=3 time=30.892 ms NOERROR [ECS:203.0.113.0/24/24]
--- 94.140.14.14 dnsping statistics ---
3 requests transmitted, 3 responses received, 0% lost
min=29.156 ms, avg=30.485 ms, max=31.407 ms, stddev=1.176 ms
```
- Identifizierung von DNS-Servern mithilfe der NSID-Option:
```shell
./dnsping.py -c 2 --nsid -s 8.8.8.8 google.com
```
```
dnsping.py DNS: 8.8.8.8:53, hostname: google.com, proto: UDP, class: IN, type: A, flags: [RD]
68 bytes from 8.8.8.8: seq=1 time=36.399 ms NOERROR [NSID:gpdns-ams]
68 bytes from 8.8.8.8: seq=2 time=32.156 ms NOERROR [NSID:gpdns-ams]
--- 8.8.8.8 dnsping statistics ---
2 requests transmitted, 2 responses received, 0% lost
min=32.156 ms, avg=34.278 ms, max=36.399 ms, stddev=2.122 ms
```
- Testen von DNS-Cookies für erhöhte Sicherheit und Cache-Optimierung:
```shell
./dnsping.py -c 2 --cookie -s anyns.pch.net quad9.net
```
```
dnsping.py DNS: anyns.pch.net:53, hostname: quad9.net, proto: UDP, class: IN, type: A, flags: [RD]
82 bytes from anyns.pch.net: seq=1 time=30.552 ms NOERROR [COOKIE:27f609c017bb2ec4ea70de5c68eec3fc39f6a53ee49c55f8]
82 bytes from anyns.pch.net: seq=2 time=24.794 ms NOERROR [COOKIE:719631dd9fcce722d3ac859b68eec3fd2e5430b5c8a7f8cf]
--- anyns.pch.net dnsping statistics ---
2 requests transmitted, 2 responses received, 0% lost
min=24.794 ms, avg=27.673 ms, max=30.552 ms, stddev=4.072 ms
```
## Interpretation von DNSSEC- und sicherheitsrelevanten Flags
Bei Verwendung von `--dnssec` und `--flags` legt `dnsping` DNS-Protokollfelder
offen, die direkt für die DNS-Sicherheitsvalidierung relevant sind. Diese Werte
geben an, ob ein Resolver zur Validierung von DNSSEC fähig ist und ob eine Antwort
erfolgreich verifiziert wurde.
Häufige Flags:
- **DO (DNSSEC OK)**
Gibt an, dass der Client DNSSEC-bezogene Records anfordert. Sein Vorhandensein
zeigt, dass der Resolver DNSSEC-Anfragen unterstützt.
- **AD (Authenticated Data)**
Wird von validierenden Resolvern gesetzt, wenn die Antwort kryptografisch
mittels DNSSEC validiert wurde. Dies ist ein starkes Signal dafür, dass die
DNSSEC-Validierung aktiv und erfolgreich ist.
Typische Muster:
| Ergebnis | Bedeutung |
|-------|--------|
| `NOERROR` mit `AD`-Flag | DNSSEC-Validierung erfolgreich |
| `SERVFAIL` mit `DO`-Flag | DNSSEC-Validierung fehlgeschlagen (oft aufgrund defekter Signaturen oder Fehlkonfiguration) |
| Kein `AD`-Flag vorhanden | Resolver führt keine DNSSEC-Validierung durch |
Extended DNS Errors (EDE, RFC 8914) liefern zusätzliche diagnostische
Informationen, wenn die DNSSEC-Validierung fehlschlägt. Zum Beispiel:
- **EDE:10** – *DNSSEC Bogus* (ungültige oder defekte DNSSEC-Daten)
- **EDE:6** – *DNSSEC Signature Expired*
- **EDE:7** – *DNSSEC Signature Not Yet Valid*
Diese Indikatoren machen `dnsping` nicht nur für Leistungstests nützlich, sondern
auch für die Validierung, ob Resolver DNSSEC korrekt durchsetzen, und für die
Diagnose von DNSSEC-Bereitstellungsproblemen.
# dnstraceroute
`dnstraceroute` ist ein Dienstprogramm, das den Pfad Ihrer DNS-Anfragen zu ihrem
Ziel verfolgt. Sie möchten dies möglicherweise mit Ihrem tatsächlichen
Netzwerk-Traceroute vergleichen, um sicherzustellen, dass Ihr DNS-Datenverkehr
nicht über unerwünschte Pfade geleitet wird.
`dnstraceroute` unterstützt mehrere Transportprotokolle (sich gegenseitig ausschließend):
- UDP (Standard) - Traditionelle DNS-Anfragen
- TCP (`--tcp`) - DNS über TCP
- DoQ (`--quic`) - DNS über QUIC (unterstützt von AdGuard DNS)
- DoH3 (`--http3`) - DNS über HTTP/3 (unterstützt von Google DNS und Cloudflare)
```shell
./dnstraceroute.py --expert --asn -C -t A -s 8.8.4.4 facebook.com
```
Sie können auch moderne DNS-Protokolle testen:
```shell
# DNS über QUIC mit AdGuard DNS testen
./dnstraceroute.py --quic -s 94.140.14.14 -c 3 google.com
# DNS über HTTP/3 mit Google DNS testen
./dnstraceroute.py --http3 -s 8.8.8.8 -c 3 google.com
```
```
dnstraceroute.py DNS: 8.8.4.4:53, hostname: facebook.com, rdatatype: A
1 192.168.0.1 (192.168.0.1) 1 ms
2 192.168.28.177 (192.168.28.177) 4 ms
3 192.168.0.1 (192.168.0.1) 693 ms
4 172.19.4.17 (172.19.4.17) 3 ms
5 dns.google (8.8.4.4) [AS15169 GOOGLE, US] 8 ms
=== Expert Hints ===
[*] public DNS server is next to a private IP address (possible hijacking)
```
Die Verwendung des `--expert`-Flags mit `dnstraceroute` aktiviert die Anzeige von
Expertenhinweisen, einschließlich Warnungen vor möglichem DNS-Datenverkehr-Hijacking.
# dnseval
`dnseval` ist ein Bulk-Ping-Dienstprogramm, das beliebige DNS-Anfragen an eine
angegebene Liste von DNS-Servern sendet und es Ihnen ermöglicht, deren
Antwortzeiten gleichzeitig zu vergleichen.
Sie können `dnseval` verwenden, um Antwortzeiten über verschiedene
Transportprotokolle zu bewerten, einschließlich UDP (Standard), TCP, DoT (DNS über
TLS), DoH (DNS über HTTPS), DoQ (DNS über QUIC) und DoH3 (DNS über HTTP/3), indem
Sie die Flags `--tcp`, `--tls`, `--doh`, `--quic` bzw. `--http3` verwenden. Diese
Protokolloptionen schließen sich gegenseitig aus; pro Befehl kann nur eine
angegeben werden.
## Zusammenfassung der Protokollunterstützung
| Tool | UDP | TCP | TLS (DoT) | DoH | DoQ | DoH3 |
|------|-----|-----|-----------|-----|-----|------|
| `dnsping` | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| `dnstraceroute` | ✓ | ✓ | - | - | ✓ | ✓ |
| `dnseval` | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
*DoQ: DNS über QUIC, DoH3: DNS über HTTP/3*
```shell
./dnseval.py --skip-warmup --dnssec -c10 -f public-servers.txt ripe.net
```
```
server avg(ms) min(ms) max(ms) stddev(ms) lost(%) ttl flags response
---------------------------------------------------------------------------------------------------------------------
1.0.0.1 29.01 14.15 45.36 8.60 %0 300 QR -- -- RD RA AD -- DO NOERROR
1.1.1.1 23.90 18.14 42.07 7.83 %0 300 QR -- -- RD RA AD -- DO NOERROR
1.0.0.2 25.90 21.36 31.58 4.26 %0 300 QR -- -- RD RA AD -- DO NOERROR
1.1.1.2 22.68 18.36 32.15 3.96 %0 300 QR -- -- RD RA AD -- DO NOERROR
1.0.0.3 22.53 18.98 32.52 3.94 %0 300 QR -- -- RD RA AD -- DO NOERROR
1.1.1.3 21.70 20.25 22.97 0.77 %0 299 QR -- -- RD RA AD -- DO NOERROR
2606:4700:4700::1001 21.70 19.13 27.50 2.28 %0 299 QR -- -- RD RA AD -- DO NOERROR
2606:4700:4700::1111 22.63 20.42 30.18 3.13 %0 299 QR -- -- RD RA AD -- DO NOERROR
2606:4700:4700::1002 24.97 20.89 44.63 7.16 %0 299 QR -- -- RD RA AD -- DO NOERROR
2606:4700:4700::1112 23.24 21.37 25.87 1.48 %0 298 QR -- -- RD RA AD -- DO NOERROR
2606:4700:4700::1003 21.68 19.28 24.88 1.65 %0 298 QR -- -- RD RA AD -- DO NOERROR
2606:4700:4700::1113 22.61 19.86 26.09 1.73 %0 299 QR -- -- RD RA AD -- DO NOERROR
195.46.39.39 25.56 16.42 55.37 15.37 %0 300 QR -- -- RD RA -- -- -- NOERROR
195.46.39.40 19.08 16.51 23.86 2.24 %0 300 QR -- -- RD RA -- -- -- NOERROR
2a05:d014:939:3300::39 0.00 0.00 0.00 0.00 %100 N/A -- -- -- -- -- -- -- -- No Response
2a05:d014:939:3300::40 0.00 0.00 0.00 0.00 %100 N/A -- -- -- -- -- -- -- -- No Response
208.67.220.220 30.60 14.54 120.64 31.88 %0 300 QR -- -- RD RA AD -- DO NOERROR
208.67.222.222 21.78 17.42 36.45 6.06 %0 50 QR -- -- RD RA AD -- DO NOERROR
2620:0:ccc::2 29.48 19.23 98.29 24.22 %0 299 QR -- -- RD RA AD -- DO NOERROR
2620:0:ccd::2 22.36 17.90 30.18 3.98 %0 299 QR -- -- RD RA AD -- DO NOERROR
216.146.35.35 172.53 114.46 360.87 71.47 %0 299 QR -- -- RD RA AD -- DO NOERROR
216.146.36.36 187.36 118.21 324.32 59.08 %0 110 QR -- -- RD RA AD -- DO NOERROR
209.244.0.3 46.49 25.23 115.86 28.19 %0 300 QR -- -- RD RA -- -- DO NOERROR
209.244.0.4 58.33 28.09 109.18 29.20 %0 299 QR -- -- RD RA -- -- DO NOERROR
4.2.2.1 64.58 30.21 86.79 30.19 %25 299 QR -- -- RD RA -- -- DO NOERROR
4.2.2.2 40.54 22.69 74.80 20.76 %0 70 QR -- -- RD RA -- -- DO NOERROR
4.2.2.3 90.62 90.62 90.62 0.00 %50 70 QR -- -- RD RA -- -- DO NOERROR
4.2.2.4 31.53 23.80 70.93 14.51 %0 294 QR -- -- RD RA -- -- DO NOERROR
4.2.2.5 24.11 24.05 24.18 0.09 %33 294 QR -- -- RD RA -- -- DO NOERROR
80.80.80.80 0.00 0.00 0.00 0.00 %100 N/A -- -- -- -- -- -- -- -- No Response
80.80.81.81 0.00 0.00 0.00 0.00 %100 N/A -- -- -- -- -- -- -- -- No Response
8.8.4.4 28.35 20.85 39.14 7.24 %0 300 QR -- -- RD RA AD -- DO NOERROR
8.8.8.8 21.22 16.22 24.93 2.39 %0 299 QR -- -- RD RA AD -- DO NOERROR
```
Sie können die Ergebnisse auch im JSONL-Format für die weitere Verarbeitung
speichern. Jede Zeile in der Ausgabedatei ist ein gültiges JSON-Objekt, das die
vollständigen Messergebnisse für einen DNS-Server enthält.
```shell
./dnseval.py -c 5 -j results.jsonl -f public-servers.txt example.com
```
Die Ausgabe kann Zeile für Zeile mit Standard-JSON-Tools wie `jq` geparst werden.
```shell
cat results.jsonl | jq -r 'select(.data.r_lost_percent == 0) | .data.resolver'
```
### Autor
Babak Farrokhi
- github: [github.com/farrokhi](https://github.com/farrokhi/)
- website: [farrokhi.net](https://farrokhi.net/)
- mastodon: [@[email protected]](https://unix.family/@farrokhi)
- twitter: [@farrokhi](https://twitter.com/farrokhi)
### Lizenz
dnsdiag wird unter einer 2-Klausel-BSD-Lizenz veröffentlicht.