In diesem Artikel
DNS over HTTPS verschlüsselt DNS-Abfragen und -Antworten zwischen deinem Client und einem DNS-Resolver per HTTPS. Es schützt diese Verbindung, macht das Surfen aber nicht anonym und verbirgt Abfragen nicht vor dem Resolver.
Entscheidend ist in der Praxis, wo die Namensauflösung stattfindet, wer sie beobachten kann und was passiert, wenn die Verschlüsselung fehlschlägt. Unser kleiner Linux-Test liefert zusätzliche Belege zum Verhalten der Endpunkte und zur Proxy-Kompatibilität.
Die wichtigsten Fakten
- DoH verschlüsselt den DNS-Austausch zwischen einem Client und seinem HTTPS-Resolver.
- Der gewählte Resolver kann die DNS-Fragen, die er beantwortet, weiterhin lesen.
- DNSSEC authentifiziert DNS-Daten; es verschlüsselt keine Abfragen.
- Die HTTPS-Verbindung einer Website belegt nicht, dass ihre DNS-Abfrage verschlüsselt war.
- Bei unserem Test mit zehn curl-Anfragen kamen auf alle zehn Abfragen Antworten zurück.
- Alle 48 über einen Proxy gesendeten DoH-Abfragen in unserem Python-Test lieferten Antworten.
Was ist DNS over HTTPS und wie funktioniert es?
DoH überträgt DNS-Nachrichten innerhalb von HTTPS-Verbindungen. RFC 8484 definiert das Protokoll zwischen einem DNS-Client und einem HTTPS-Resolver.
Der Weg führt vom Browser oder Client zum HTTPS-Resolver und von dort bei Bedarf weiter zur DNS-Infrastruktur. Die verschlüsselte Verbindung endet am Resolver; sie verschlüsselt nicht automatisch jeden weiteren DNS-Austausch danach.
Das standardisierte Format ist eine binäre DNS-Nachricht. GET-Anfragen kodieren sie in einem dns-Parameter; POST-Anfragen übertragen sie im Body. Anbieterspezifische JSON-Schnittstellen sind praktisch zum Testen, aber nicht austauschbar mit dem DoH-Template eines Browsers.
Ein Resolver beantwortet Namensabfragen. Ein Proxy-Server leitet Datenverkehr weiter. Halte diese beiden Aufgaben bei der Konfiguration auseinander.
Verbirgt DNS over HTTPS dein Surfverhalten vor deinem ISP?
DoH verbirgt den Inhalt dieser DNS-Verbindung vor passiven Beobachtern auf dem Netzwerkpfad. Es kann nicht jede Surfaktivität verbergen.
Dein Resolver sieht die Fragen und die Quelladresse, die sich mit ihm verbindet. Dein ISP kann weiterhin die Ziel-IP-Adressen und Verkehrsmuster beobachten, wenn Verbindungen zu Websites direkt laufen. Die Datenschutzhinweise in RFC 8484 erklären, warum verschlüsselter Transport das Vertrauen in den Resolver nicht überflüssig macht.
Unverschlüsselte Server Name Indication kann beim TLS-Aufbau außerdem einen Hostnamen preisgeben. ECH schützt die innere ClientHello-Nachricht, einschließlich dieses Hostnamens, wenn es erfolgreich ausgehandelt wird; Ziel-IP-Adressen verbirgt es nicht. Siehe Mozillas Erklärung zu ECH.
Wie schneidet DoH im Vergleich zu DoT, DNSSEC, VPNs und WARP ab?
DoH und DoT schützen den DNS-Transport; DNSSEC authentifiziert DNS-Daten. Ein VPN verändert den Weg des Datenverkehrs, der durch seinen Tunnel läuft.
| Technologie | Zweck | Grenze |
|---|---|---|
| DoH | DNS over HTTPS | Austausch zwischen Client und Resolver |
| DoT | DNS over TLS, normalerweise TCP-Port 853 | DNS-Transport |
| DNSSEC | Signierte DNS-Daten validieren | Echtheit, nicht Vertraulichkeit |
| VPN | Ausgewählten Netzwerkverkehr tunneln | Hängt von Routing und DNS-Konfiguration ab |
Die maßgeblichen Standards sind RFC 7858 für DoT und RFC 4033 für DNSSEC. Weder DNSSEC noch DoH versprechen umfassenden Schutz vor manipulierten Antworten.
Die dokumentierten Modi von WARP unterscheiden zwischen reiner DNS-Verschlüsselung und dem Tunneln von Datenverkehr und DNS. Für die allgemeinen Unterschiede siehe Proxy versus VPN und Smart DNS, Proxys und VPNs.
DoQ ist ein weiterer verschlüsselter DNS-Transport. RFC 9250 bildet DNS direkt auf QUIC ab; das ist etwas anderes als DoH über HTTP/3.
Solltest du DoH ein- oder ausschalten?
Aktiviere DoH, wenn Resolver-Richtlinie und Verhalten im Fehlerfall zu deinem Netzwerk passen. Sorge dafür, dass vorgeschriebenes organisationsinternes DNS, lokale Namen und Filter weiter funktionieren.
Nutze den 3-Schritte-Check für DNS-Datenschutz, bevor du Einstellungen änderst:
- Schritt 1: Auflösung lokalisieren. Finde heraus, ob der Browser, das Betriebssystem oder ein Proxy das Ziel auflöst.
- Schritt 2: Beobachter identifizieren. Verfolge Client, HTTPS-Resolver und DNS-Infrastruktur; beziehe einen Proxy ein, falls vorhanden.
- Schritt 3: Fallback prüfen. Prüfe, ob ein Fehler die Auflösung stoppt oder einen anderen Transport zulässt.

| Option | X verwenden, wenn … | X vermeiden, wenn … |
|---|---|---|
| Externes DoH | Verwende externes DoH, wenn die Resolver-Richtlinie zu deinen Anforderungen passt. | Vermeide externes DoH, wenn erforderliche lokale Namen oder Filter nicht mehr funktionieren. |
| Striktes DoH | Verwende striktes DoH, wenn ein Verschlüsselungsfehler die Auflösung stoppen soll. | Vermeide striktes DoH, wenn es durch Netzwerkvorgaben unbrauchbar wird. |
| Automatischer Fallback | Verwende den automatischen Fallback, wenn Verfügbarkeit Priorität hat. | Vermeide den automatischen Fallback, wenn ein Rückfall auf Klartext nicht akzeptabel ist. |
Welchen Anbieter und welche DoH-URL solltest du wählen?
Wähle nach Datenschutzrichtlinie, Filteranforderungen und Client-Kompatibilität, bevor du Antwortzeiten vergleichst. Passe das Endpunktformat an die Anwendung an.
| Anbieter | Endpunkt im Wire-Format | JSON-Testschnittstelle |
|---|---|---|
| Cloudflare | https://cloudflare-dns.com/dns-query | Gleicher Pfad, JSON-Accept-Header |
| https://dns.google/dns-query | https://dns.google/resolve |
Sieh dir die DoH-Dokumentation von Cloudflare und die DoH-Dokumentation von Google an. Ein Template-Feld und ein einfaches Endpunkt-Feld erfordern möglicherweise unterschiedliche Syntax; füge keine JSON-Abfrage-URL in eines von beiden ein, ohne es zu prüfen.
Vergleiche die Datenschutzrichtlinie des Cloudflare-Resolvers mit der DNS-Datenschutzrichtlinie von Google, einschließlich der Ausnahmen bei der Protokollierung. Behandle Malware-Blockierung und Jugendschutzfilter als eigene Anforderungen: Verschlüsselung allein liefert keines von beiden.
Wie aktivierst du DoH in Browsern und Betriebssystemen?
Konfiguriere die Komponente, die deine Abfragen tatsächlich durchführt, und prüfe dann ihren aktiven Status und das Fallback-Verhalten. Browser- und Betriebssystemeinstellungen decken unterschiedliche Pfade ab.
- Chrome: Öffne Einstellungen, Datenschutz und Sicherheit, Sicherheit und dann Sicheres DNS verwenden. Prüfe die Resolver-Auswahl und das Verhalten beim automatischen Fallback in den Hinweisen zu den Sicherheitseinstellungen von Chrome.
- Firefox: Öffne Einstellungen, Datenschutz und Sicherheit, DNS over HTTPS und dann Erweiterte Einstellungen. Wähle eine Schutzstufe und kontrolliere ihren Status. Der Standardschutz kann auf einen Fallback zurückgreifen; der maximale Schutz zeigt eine Warnung an, wenn die sichere Auflösung fehlschlägt, mit der Möglichkeit einer Ausnahme. Folge den Anweisungen von Mozilla zu den Schutzstufen.
- Windows 11: Öffne die aktive Verbindung unter Netzwerk & Internet und bearbeite ihre DNS-Einstellungen. Wähle ein automatisches oder manuelles DoH-Template und lege den Klartext-Fallback bewusst fest. Siehe die Anleitung von Microsoft zu den Netzwerkeinstellungen.
- Android: Gehe nicht davon aus, dass Privates DNS ein DoH-URL-Feld wie im Browser bedeutet. Die Android-Konfigurationshinweise von Google verwenden für Privates DNS einen Anbieter-Hostnamen.
Microsoft dokumentiert in seinen Hinweisen zum Windows-DNS-Client außerdem den Unterschied zwischen verlangter und angeforderter verschlüsselter Auflösung. Prüfe die Funktion erneut, nachdem du das Netzwerk gewechselt oder ein VPN aktiviert hast.
Funktioniert DoH mit Proxys?
DoH kann durch einen Proxy laufen, doch das bestimmt nicht, wer die Hostnamen von Websites auflöst. HTTPS-Anfragen an einen Resolver zu senden und die Auflösung des Ziels zu delegieren, sind zwei getrennte Vorgänge.
Die Proxy-Dokumentation von Chromium beschreibt die proxyseitige Auflösung des Ziels bei HTTP- und SOCKS5-Proxys. Die Heuristiken von Mozilla beschreiben Fälle, in denen die Proxy-Erkennung die automatische DoH-Aktivierung verhindert; die zugehörige DNSOverHTTPS-Richtlinie steuert den Fallback separat. Dieses Verhalten hängt von der Konfiguration ab.
Das curl-Handbuch unterscheidet zwischen lokaler SOCKS5-Auflösung und proxyseitiger Auflösung von Hostnamen und dokumentiert --doh-url. Diese Option zwingt einen entfernten Proxy nicht dazu, deinen gewählten Resolver zu verwenden; selbst die erste Auflösung des DoH-Servers läuft über einen eigenen Bootstrap-Pfad.
In unserem SOCKS-Test wurde bei direkten Anfragen und bei Anfragen über socks5:// der Resolver des Hosting-Anbieters gefunden. Bei socks5h:// meldeten zwei Durchläufe Google-Resolver in den USA oder in Kanada. Beide SOCKS-Routen nutzten Residential-Exit-Adressen. Zum Protokollkontext siehe HTTP versus SOCKS5.
Oblivious DoH ergänzt verschlüsselte DNS-Nachrichten und ein eigenes Relay-Design, um die Identität des Clients von den Abfragen zu trennen. Gewöhnliches Proxying ist nicht automatisch ODoH.
Um herauszufinden, welche Seite hinter einem SOCKS-Proxy das DNS auflöst, haben wir in unserem Test dieses kurze Skript verwendet. Bei socks5:// blieb die Abfrage beim Resolver unseres Servers; bei socks5h:// wanderte sie auf die Proxy-Seite.
"""Who resolves the hostname: socks5:// (your machine) or socks5h:// (the proxy)?
pip install "requests[socks]"
edns.ip-api.com answers with the DNS resolver that looked up its hostname.
"""
import os
import requests
SOCKS = os.environ.get("SOCKS_URL") # e.g. socks5://USER__cr.us:[email protected]:824
host_part = SOCKS.split("://", 1)[1]
routes = {
"direct": None,
"socks5 (local DNS)": "socks5://" + host_part,
"socks5h (proxy DNS)": "socks5h://" + host_part,
}
for label, proxy in routes.items():
proxies = {"http": proxy, "https": proxy} if proxy else None
try:
dns = requests.get("http://edns.ip-api.com/json", proxies=proxies, timeout=20).json()["dns"]
print(f"{label:20} resolver: {dns['geo']}")
except requests.RequestException as exc:
print(f"{label:20} failed: {type(exc).__name__}")
Wie kannst du testen, ob DoH funktioniert?
Prüfe Erreichbarkeit des Endpunkts, DNS-Antworten und Anwendungs-Routing getrennt voneinander. Eine erfolgreiche HTTPS-Anfrage allein kann weder die Browser-Konfiguration noch Anonymität belegen.
Bei unserem kurzen Test am 19. Oktober 2026 nutzte ein Linux-Server in der EU mit Ubuntu 24.04 curl 8.5.0 sowie Python 3.12 mit httpx 0.28 und HTTP/2. Das war eine kleine Stichprobe, kein Benchmark: ungefähr 130 DoH-Anfragen bei drei Anbietern, im Abstand von jeweils einer Sekunde.
Um 12:50 UTC sendete curl pro JSON-Endpunkt fünf aufeinanderfolgende A-Abfragen für example.com und öffnete jedes Mal eine neue Verbindung. Die Anfragen folgten der JSON-Syntax von Google und der JSON-Syntax von Cloudflare.
| Anbieter | Erfolgreiche Abfragen | DNS-Status und Antworten | Median Body | Median gesamt |
|---|---|---|---|---|
| 5/5 | 0, NOERROR; zwei A-Records | 296 B | 48 ms | |
| Cloudflare | 5/5 | 0, NOERROR; zwei A-Records | 249 B | 44 ms |
Die Endpunkte waren https://dns.google/resolve?name=example.com&type=A und https://cloudflare-dns.com/dns-query?name=example.com&type=A, Letzterer mit accept: application/dns-json. Das sind Zeiten für HTTPS-Anfragen einschließlich Verbindungsaufbau, keine isolierte DNS-Latenz.
Die Python-Messung verwendete vier Domains, drei Durchläufe pro Methode und einen wiederverwendbaren HTTP/2-Client pro Ausführung. Die folgenden Ergebnisse sind Mediane der Mediane pro Domain. Quellen: doh_check.py, doh_results_direct.json und doh_results_proxy.json.
| Methode | Direkt | Residential-HTTP-Proxy |
|---|---|---|
| System-Resolver | 1 ms | 1 ms, weiterhin lokal |
| Cloudflare JSON | 14 ms | 271 ms |
| Google JSON | 17 ms | 333 ms |
| Cloudflare Wire | 11 ms | 263 ms |
| Quad9 Wire | 13 ms | 224 ms |
Jede DoH-Methode lieferte pro Route in 12/12 Anfragen Antworten, darunter alle 48 über den Residential-HTTP-Proxy von DataImpulse. Die 1 ms des System-Resolvers spiegeln lokales Caching wider, keine Netzwerkabfrage. Bei einer Domain erreichte der Median für Cloudflare JSON über den Proxy 1,4 Sekunden.
Bei Quad9 JSON gab es Zeitüberschreitungen oder HTTP 400. Ein Versuch im Wire-Format über HTTP/1.1 lieferte HTTP 505; mit HTTP/2 funktionierte es. Das sind beobachtete Ergebnisse, keine allgemeingültigen Protokollanforderungen. Auch die Antworten für Wikipedia unterschieden sich zwischen direkten und über den Proxy gesendeten Anfragen, doch der Test kann nicht klären, ob Standort, Resolver-Routing oder Caching die Ursache sind.
Verwende für eine unabhängige Überprüfung harmlose Testnamen, kontrolliere Anwendungsstatus und Netzwerkdiagnose und teste das Verhalten im Fehlerfall in einem Netzwerk, das du selbst verwaltest. Bewahre die Rohantworten separat auf: Die Python-Ergebnisdateien fassen Durchläufe zusammen und behalten Felder der letzten Antwort, nicht jeden Response-Body. Der Erfolgszähler misst fehlerfreie Aufrufe, prüfe daher auch HTTP-Status, DNS-Status und Antworten.
Das folgende Skript stammt aus unserem kurzen Test am 19. Oktober 2026. Es sendet dieselben Abfragen per DoH (JSON und Wire-Format) an Cloudflare, Google und Quad9 sowie an den System-Resolver, direkt und, wenn PROXY_URL gesetzt ist, über einen HTTP-Proxy, und gibt die Median-Latenz pro Endpunkt aus. Es erfordert pip install httpx[http2]: Quad9 antwortet nur über HTTP/2.
"""Resolve a few domains over DNS-over-HTTPS and over the system resolver.
pip install "httpx[http2]" # Quad9 requires HTTP/2 for DoH (RFC 8484, section 5.2)
Optional: PROXY_URL to send the DoH requests through an HTTP proxy (DoH is plain HTTPS).
"""
import base64, json, os, socket, statistics, struct, time
import httpx
PROXY = os.environ.get("PROXY_URL") # e.g. http://USER__cr.us:[email protected]:823
CLIENT = httpx.Client(http2=True, proxy=PROXY, timeout=10) # one client = warm HTTPS connections
DOMAINS = ["example.com", "wikipedia.org", "github.com", "dataimpulse.com"]
RUNS = 3
JSON_ENDPOINTS = {
"cloudflare-json": ("https://cloudflare-dns.com/dns-query", {"accept": "application/dns-json"}),
"google-json": ("https://dns.google/resolve", {}),
}
WIRE_ENDPOINTS = { # RFC 8484: binary DNS message, base64url in ?dns=
"cloudflare-wire": "https://cloudflare-dns.com/dns-query",
"quad9-wire": "https://dns.quad9.net/dns-query",
}
def json_query(url, headers, name):
r = CLIENT.get(url, params={"name": name, "type": "A"}, headers=headers)
data = r.json()
ips = [a["data"] for a in data.get("Answer", []) if a.get("type") == 1]
return r.status_code, data.get("Status"), ips, len(r.content)
def build_wire_query(name):
header = struct.pack(">HHHHHH", 0, 0x0100, 1, 0, 0, 0) # id 0, recursion desired, 1 question
qname = b"".join(bytes([len(p)]) + p.encode() for p in name.split(".")) + b"\0"
return header + qname + struct.pack(">HH", 1, 1) # type A, class IN
def wire_query(url, name):
q = base64.urlsafe_b64encode(build_wire_query(name)).rstrip(b"=").decode()
r = CLIENT.get(url, params={"dns": q}, headers={"accept": "application/dns-message"})
if r.headers.get("content-type") != "application/dns-message":
raise ValueError(f"HTTP {r.status_code}, not a DNS message")
flags, ancount = struct.unpack(">H", r.content[2:4])[0], struct.unpack(">H", r.content[6:8])[0]
rcode = flags & 0x000F # 0 = NOERROR; ancount includes CNAMEs, enough for a smoke test
return r.status_code, rcode, [f"{ancount} answer records"], len(r.content)
def system_query(name):
infos = socket.getaddrinfo(name, 443, socket.AF_INET, socket.SOCK_STREAM)
return None, 0, sorted({i[4][0] for i in infos}), 0
def timed(fn, *args):
start = time.perf_counter()
try:
status, rcode, answers, size = fn(*args)
error = ""
except Exception as exc:
status, rcode, answers, size, error = None, None, [], 0, type(exc).__name__
return (time.perf_counter() - start) * 1000, status, rcode, answers, size, error
def main():
rows = []
for name in DOMAINS:
methods = {"system": (system_query, name)}
methods.update({k: (json_query, u, h, name) for k, (u, h) in JSON_ENDPOINTS.items()})
methods.update({k: (wire_query, u, name) for k, u in WIRE_ENDPOINTS.items()})
for method, (fn, *args) in methods.items():
results = []
for _ in range(RUNS):
results.append(timed(fn, *args))
time.sleep(1)
ok = [r for r in results if not r[5]]
rows.append({
"domain": name, "method": method, "route": "proxy" if PROXY and method != "system" else "direct",
"ok": f"{len(ok)}/{RUNS}",
"median_ms": round(statistics.median(r[0] for r in ok)) if ok else None,
"http_status": results[-1][1], "dns_rcode": results[-1][2],
"answers": results[-1][3], "bytes": results[-1][4], "error": results[-1][5],
})
print(f"{name:16} {method:16} {rows[-1]['ok']} {rows[-1]['median_ms']} ms {rows[-1]['answers']}")
out = "doh_results_proxy.json" if PROXY else "doh_results_direct.json"
with open(out, "w") as f:
json.dump(rows, f, indent=1)
print("saved", out)
if __name__ == "__main__":
main()
Run: pip install "httpx[http2]"; python3 doh_check.py (through a proxy: PROXY_URL="http://USER__cr.us:[email protected]:823" python3 doh_check.py)
Warum schlägt DoH fehl oder kollidiert mit Netzwerkkontrollen?
Externes DNS kann mit Split-DNS, Jugendschutzfiltern, Captive Portals oder VPN-Routing in Konflikt geraten. Strikte Verschlüsselung kann dazu führen, dass ein nicht erreichbarer Resolver zu fehlgeschlagenen Abfragen führt.
Ermittle zuerst die fehlerhafte Ebene: Endpunkt-Syntax, TLS-Verbindung, HTTP-Antwort, DNS-Antwort oder Anwendungsrichtlinie. Teste sowohl öffentliche als auch erforderliche interne Namen. Mozilla dokumentiert die Kompromisse bei Filtern und Unternehmensrichtlinien.
Bevorzuge für autorisierte Administration explizite Browser-Richtlinien und eine freigegebene Resolver-Konfiguration. Das Blockieren klassischer DNS-Ports allein deckt die HTTPS-basierte Auflösung nicht ab. Vermeide pauschales Blockieren von HTTPS, das nicht betroffene Anwendungen stört, und beschränke Diagnoseprotokolle auf Testverkehr.
Häufig gestellte Fragen
Was ist DNS over HTTPS?
Es ist eine Methode, DNS-Fragen und -Antworten über eine verschlüsselte HTTPS-Verbindung auszutauschen. Der Schutz gilt zwischen dem Client und dem gewählten Resolver.
Sollte ich DNS over HTTPS ein- oder ausschalten?
Schalte es ein, wenn du dem Resolver vertraust und erforderliche Netzwerkdienste weiter funktionieren. Wähle striktes Fehlerverhalten nur, wenn der Verlust der Auflösung besser ist als die Nutzung eines Fallbacks.
Verbirgt DoH mein Surfverhalten vor meinem ISP?
Es verhindert, dass der geschützte DNS-Austausch passiv mitgelesen wird. Direkte Verbindungen zum Ziel und Verkehrsmuster können dennoch Informationen über das Surfverhalten verraten.
Wie unterscheidet sich DoH von DoT und DNSSEC?
DoH und DoT verschlüsseln den DNS-Transport mit unterschiedlichen Protokollvarianten. DNSSEC validiert signierte DNS-Daten und kann beide Transportarten ergänzen.
Funktioniert DoH mit einem Proxy und wer löst den Hostnamen auf?
Es kann funktionieren, aber die Konfiguration von Client und Proxy bestimmt, wer die Auflösung übernimmt. Ein Proxy, der eine DoH-Anfrage weiterleitet, und ein Proxy, der den Hostnamen einer Website auflöst, erfüllen unterschiedliche Aufgaben.
Beweist das Schloss-Symbol im Browser, dass DoH aktiviert ist?
Nein. Website-TLS und DNS-Transport sind getrennte Verbindungen, überprüfe DNS daher über Anwendungsstatus und Diagnose.
Prüfe das DNS-Routing zusammen mit deinem Proxy-Setup
Wenn du DataImpulse nutzt, überprüfe mit einem kleinen Test sowohl den Exit des Datenverkehrs als auch den DNS-Pfad. DataImpulse ist ein Proxy-Anbieter, kein DoH-Resolver, kein VPN, keine Scraping-API und kein verwalteter Unblocker. Beginne mit dem Vergleich von HTTP und SOCKS5, um das passende Verbindungsmodell zu wählen.
Zuletzt aktualisiert: 19. Oktober 2026.
