Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
PolarDNS — PolarDNS ist ein spezialisierter autoritativer DNS-Server, der sich für Penetrationstests und Sicherheitsforschung eignet. | Kitploit
Tools/GitHubGitHub/oryxlabs/polardns
SchwachstellenscannerSchwachstellenanalyseFuzzingNetzwerksicherheitPenetrationstestsDNS-Analyse
GitHuboryxlabs/polardns

PolarDNS

PolarDNS ist ein spezialisierter autoritativer DNS-Server, der sich für Penetrationstests und Sicherheitsforschung eignet.

Repository anzeigen
249193vor 1 JahrVon Kitploit geprüft
Webseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen
PolarDNS logo PolarDNS ist ein spezialisierter autoritativer DNS-Server, geschrieben in Python 3.x, ursprünglich entwickelt als Werkzeug für Sicherheitstests von rekursiven DNS-Resolvern von der Serverseite aus.

Es ermöglicht dem Betreiber, benutzerdefinierte DNS-Antworten zu erzeugen, was es für eingehende DNS-Protokolltests geeignet macht.

_

PolarDNS kann getestet werden für:

  • DNS-Resolver (Serverseite)
  • DNS-Clients
  • DNS-Bibliotheken
  • DNS-Parser und -Dissectoren
  • jede Software, die DNS-Informationen verarbeitet

Es unterstützt sowohl UDP- als auch TCP-Protokolle und gibt dem Betreiber die vollständige Kontrolle über die DNS-Protokollebene.

Der PolarDNS-Server kann eine Vielzahl von nicht standardmäßigen und nicht konformen DNS-Antworten erzeugen, DNS-Antworten, die gegen die RFC-Spezifikationen verstoßen, einschließlich stark abnormaler und fehlerhafter DNS-Antworten.

Dies kann nützlich sein für:

  • Funktionstests
  • RFC-Konformität
  • Schwachstellenforschung

Installation

Es gibt drei verfügbare Methoden, um PolarDNS zu installieren.

PolarDNS benötigt Python 3.11 oder neuer und hat keine zusätzlichen Abhängigkeiten.

Methode 1: Installation via Pip

Dies ist der einfachste Weg, PolarDNS zu installieren und auszuführen:

root@kitploit:~
pip install polardns
polardns

Methode 2: Traditionelle Installation

Sie können auch das Repository klonen und PolarDNS direkt ausführen:

root@kitploit:~
git clone https://github.com/oryxlabs/PolarDNS.git
cd PolarDNS
python polardns.py

Diese Methode wird empfohlen, wenn Sie vorhaben, den Code zu debuggen oder zu modifizieren oder neue Funktionen hinzuzufügen.

Methode 3: PolarDNS in Docker ausführen

Sie können PolarDNS auch in einem Docker-Container ausführen:

root@kitploit:~
docker run -p 53:53/tcp -p 53:53/udp oryxlabs/polardns

PolarDNS ausführen

Der PolarDNS-Server ist über die Konfigurationsdatei polardns/polardns.toml konfigurierbar.

  • Für Testzwecke sollte die Standardkonfiguration für den lokalen Betrieb in Ordnung sein.
  • Möglicherweise möchten Sie die Konfiguration jedoch anpassen, indem Sie Ihre Domain und Nameserver-IP-Adressen hinzufügen.

Nach dem Start von PolarDNS sollten Sie eine Ausgabe ähnlich der folgenden sehen:

root@kitploit:~
python polardns.py
1741599804.9039893 | PolarDNS v1.6.1 server starting up
1741599804.9039893 | Using '/path/to/your/polardns/polardns.toml' config file
1741599804.9039893 | Starting listener at tcp://0.0.0.0:53
1741599804.9039893 | Starting listener at udp://0.0.0.0:53

Dies zeigt an, dass der Server läuft und bereit ist.

Arbeiten mit PolarDNS

Standardmäßig beginnt der Server auf allen Schnittstellen auf UDP- und TCP-Port 53 (0.0.0.0:53) zu lauschen und ist bereit, DNS-Anfragen zu beantworten.

Sie können ihn lokal testen, indem Sie die folgende Beispielabfrage stellen, die immer etwas auflösen sollte.

Abfrage im UDP-Modus:

root@kitploit:~
dig always.yourdomain.com @127.0.0.1

Abfrage im TCP-Modus:

root@kitploit:~
dig always.yourdomain.com @127.0.0.1 +tcp

Sie sollten einen A-Eintrag mit der IP-Adresse 2.3.4.5 erhalten, ähnlich wie in diesem Screenshot:

PolarDNS Beispielverwendung

Dies zeigt an, dass der Server ordnungsgemäß funktioniert.

Hauptkonzept

Indem Sie den PolarDNS-Server bitten, etwas aufzulösen, geben Sie ihm im Wesentlichen Anweisungen, wie er auf Sie antworten soll. Das bedeutet, dass Sie (der Client) dem PolarDNS-Server vorgeben, welche Art von Antwort er für Sie erzeugen soll.

Betrachten Sie zum Beispiel die folgende Abfrage:

root@kitploit:~
dig always.ttl2000000000.slp1500.yourdomain.com @127.0.0.1

Sie sollten wieder einen A-Eintrag mit der IP-Adresse 2.3.4.5 erhalten, aber diesmal mit einem TTL-Wert von 2.000.000.000 (63,4 Jahre) und nach einer Verzögerung von 1,5 Sekunden:

PolarDNS benutzerdefinierte TTL und Latenz

Im obigen Beispiel haben wir das grundlegende Feature always verwendet (das immer etwas auflöst) und es mit dem Modifikator ttl kombiniert, um den TTL-Wert anzupassen, sowie mit dem Modifikator slp, um vor dem Senden der Antwort zu warten.

PolarDNS-Funktionalitäten

PolarDNS hat die folgenden Hauptfunktionalitäten:

  1. Features: Diese können verschiedene DNS-Antworten erzeugen. Die meisten Features haben Parameter, sodass es möglich ist, ihr Verhalten anzupassen, um eine Vielzahl verschiedener DNS-Antworten zu erzeugen.
  2. Antwortmodifikatoren: Diese können die vom PolarDNS-Server ausgehenden DNS-Antworten weiter modifizieren. Modifikatoren sind unabhängig vom ausgewählten Feature und können frei kombiniert werden.

Es gibt derzeit über 70 verschiedene Features und 19 Antwortmodifikatoren. Durch die Verwendung verschiedener Features und deren Kombination mit verschiedenen Antwortmodifikatoren ist es möglich, unzählige Varianten einer bestimmten Antwort zu erzeugen.

Siehe den beigefügten Katalog aller implementierten Features und Antwortmodifikatoren.

Dies gibt PolarDNS die Fähigkeit, hochgradig ungewöhnliche, abnormale und sogar fehlerhafte DNS-Antworten zu erzeugen, sodass der Betreiber sehen kann, wie die empfangende Seite mit solchen Situationen umgeht und ob die empfangende Seite technisch robust und ausgereift ist.

Einige Beispiele für DNS-Antworten, die PolarDNS erzeugen kann, umfassen:

  • Alias (CNAME)-Ketten und Alias-Schleifen
  • DNS-Header-Fehlbildungen (ID, Flags, Anzahl der Sektionen)
  • Injektion von unaufgeforderten Einträgen (Cache-Poisoning)
  • Injektion von beliebigen Bytes beliebiger Länge
  • Unvollständige / leere / NULL-Byte-Antworten
  • Kompressionsprobleme (Schleifen, ungültige Zeiger)
  • Langsam übertragene Chunked-Responses
  • Ungültige Labels oder Domainnamenlängen
  • Beliebige Anzahl von TXT-Einträgen beliebiger Größe
  • Paketlängenmanipulationen (TCP)
  • usw.

Diese können zur Entdeckung verschiedener Schwachstellen führen, wie:

  • Sloth-Domain-Angriffe
  • Phantom-Domain-Angriffe
  • Domain-Lock-Up-Angriffe
  • Cache-Poisoning
  • Ressourcenerschöpfung
  • Abstürze, DoS

Siehe die BlackHat MEA 2023-Präsentationen (einschließlich BONUS-Folien) für weitere Details, viele weitere Beispiele und Anwendungsfälle.

Testen von rekursiven DNS-Resolvern

Hier ist ein Überblick auf hoher Ebene, was Sie benötigen, um mit dem Testen rekursiver DNS-Server zu beginnen.

  1. Kaufen Sie eine Domain für Ihre Tests, z. B. example123.com, über Ihren bevorzugten Domain-Registrar.
  2. Besorgen Sie sich 2 Linux-VPS-Instanzen mit öffentlichen und statischen IP-Adressen – dies werden Ihre Nameserver.
  3. Installieren Sie den PolarDNS-Server auf beiden Instanzen.
  4. Bearbeiten Sie die Konfigurationsdatei polardns/polardns.toml auf jeder Instanz und ändern Sie Ihren Domainnamen und Ihre Nameserver-IP-Adressen entsprechend – gleiche Konfiguration auf beiden.
  5. Wählen Sie im Domain-Registrar aus, die Domain mit Ihren eigenen Nameservern zu verwalten. Sie müssen die primären und sekundären NS angeben – geben Sie die IP-Adressen Ihrer Instanzen an.

Jetzt sollte Ihre Infrastruktur bereit sein, um jeden rekursiven DNS-Resolver Ihrer Wahl zu testen.

Aufschlüsselung des Testprozesses

Um mit dem Testen eines Ziel-DNS-rekursiven Resolvers zu beginnen, müssen Sie Ihre Abfragen an den Ziel-DNS-Resolver richten, z. B.

root@kitploit:~
dig always.example123.com @<TARGET-RESOLVER-IP>

Zum Beispiel, um den öffentlichen DNS von CloudFlare zu testen:

root@kitploit:~
dig always.example123.com @1.1.1.1

Während der Auflösung kontaktiert der Ziel-DNS-Resolver Ihre autoritativen PolarDNS-Nameserver (die Ihre example123.com-Testdomain verwalten), um die Abfrage aufzulösen.

Einer Ihrer PolarDNS-Server wird dem Ziel-DNS-Resolver antworten. Der Resolver erhält, parst und verarbeitet die Antwort von PolarDNS. Anschließend gibt er die endgültige Antwort an Sie (den Client) zurück.

Hier ist eine visuelle Übersicht des Testprozesses: Verwendung von PolarDNS zum Testen eines DNS-Resolvers

Indem Sie den DNS-Resolver anweisen, verschiedene Subdomains unter Ihrer example123.com-Domain aufzulösen, können Sie effektiv das Verhalten des DNS-Resolvers testen und sehen, wie er mit verschiedenen unerwarteten Situationen (Antworten) umgeht.

Zum Beispiel: Wie geht er mit einer Situation um, wenn er eine fehlerhafte DNS-Antwort, eine Antwort mit einem injizierten Eintrag oder einen Eintrag mit illegalen Zeichen erhält, und welche Art von Antwort sendet er letztendlich an Sie, den Client?

Automatisierte E2E-Tests mit GitHub Actions

PolarDNS kann mit einer Vielzahl von DNS-Resolvern integriert werden, um eine umfassende End-to-End (E2E) DNS-Server-Testsuite auszuführen.

Diese Integration wird durch GitHub Actions ermöglicht, mit Referenzvorlagen (Workflows), die derzeit für die folgenden sechs DNS-Resolver verfügbar sind:

  • BIND9 (e2e-bind9.yaml)
  • CoreDNS (e2e-coredns.yaml)
  • Dnsmasq (e2e-dnsmasq.yaml)
  • Knot Resolver (e2e-knot-v5.yaml, e2e-knot-v6.yaml)
  • PowerDNS (e2e-powerdns.yaml)
  • Unbound (e2e-unbound.yaml)

Wenn eine GitHub Action ausgelöst wird (z. B. bei einem Commit oder manuell), führen die Workflows die folgenden Schritte aus:

  1. Starten des ausgewählten DNS-Resolvers in einem Docker-Container
  2. Starten von PolarDNS in einem separaten Docker-Container
  3. Verbinden des ausgewählten Resolvers mit PolarDNS
  4. Ausführen der E2E-Testsuite gegen den ausgewählten DNS-Resolver

Um Ihre eigenen E2E-Tests hinzuzufügen, platzieren Sie sie einfach im Verzeichnis test-e2e/.

Auf der Suche nach einer vollständigen E2E-Testsuite für DNS-Server? Kontaktieren Sie [email protected].

Hinzufügen neuer Features

Das Hinzufügen neuer Features zu PolarDNS ist entscheidend, um wirklich neuartige DNS-Probleme zu entdecken. Und mit PolarDNS können Sie das relativ einfach tun.

PolarDNS ermöglicht es Ihnen, schnell ein neues Feature hinzuzufügen, Ihre Ideen auszuprobieren oder einen PoC zu entwickeln, ohne Ihren eigenen DNS-Server bauen zu müssen. Alles, was Sie brauchen, ist die Fähigkeit, Python-Code zu verstehen, und die Neugier, mit dem DNS-Protokoll zu experimentieren.

Es gibt eine detaillierte, Schritt-für-Schritt-Beitragsrichtlinie, um Ihnen den Einstieg zu erleichtern. Dort finden Sie nicht nur, wie Sie neue Features hinzufügen, sondern auch, wie Sie PolarDNS debuggen, Probleme melden, Ideen teilen und mehr.

Links

Hier sind einige hervorragende Ressourcen, die nützlich sind, wenn Sie mit PolarDNS spielen.

DNS-Protokollbezogene Links:

  • https://en.wikipedia.org/wiki/List_of_DNS_record_types
  • https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml

DNS-Server:

  • https://en.wikipedia.org/wiki/Comparison_of_DNS_server_software
  • https://www.lifewire.com/free-and-public-dns-servers-2626062

Danksagungen

Vielen Dank an alle, die zu PolarDNS beigetragen haben! ❤️

Tool herunterladen