ในบทความนี้

DNS privacy paths between a browser, HTTPS resolver, proxy, and authoritative DNS infrastructure

ในบทความนี้

DNS over HTTPS เข้ารหัสคำถามและคำตอบของ DNS ระหว่างไคลเอนต์กับ DNS resolver โดยใช้ HTTPS การเข้ารหัสนี้ปกป้องการเชื่อมต่อดังกล่าว แต่ไม่ได้ทำให้การท่องเว็บเป็นแบบนิรนาม และไม่ได้ซ่อนคำถามจาก resolver

สิ่งที่ต้องตัดสินใจจริง ๆ คือการแปลงชื่อเกิดขึ้นที่ใด ใครสังเกตเห็นได้บ้าง และจะเกิดอะไรขึ้นเมื่อการเข้ารหัสล้มเหลว ผลทดสอบบน Linux ขนาดเล็กของเราช่วยเพิ่มหลักฐานเกี่ยวกับพฤติกรรมของ endpoint และความเข้ากันได้กับ proxy


ข้อมูลสำคัญ

  • DoH เข้ารหัสการแลกเปลี่ยนข้อมูล DNS ระหว่างไคลเอนต์กับ HTTPS resolver ของไคลเอนต์
  • resolver ที่เลือกยังคงอ่านคำถาม DNS ที่ตนตอบได้
  • DNSSEC ยืนยันความถูกต้องของข้อมูล DNS แต่ไม่ได้เข้ารหัสคำถาม
  • การเชื่อมต่อ HTTPS ของเว็บไซต์ไม่ได้พิสูจน์ว่าการค้นหา DNS ถูกเข้ารหัส
  • การทดสอบด้วย curl จำนวน 10 คำขอของเราได้รับคำตอบครบทั้ง 10 คำถาม
  • คำถาม DoH ผ่าน proxy ทั้ง 48 รายการในการทดสอบด้วย Python ได้รับคำตอบทั้งหมด

DNS over HTTPS คืออะไร และทำงานอย่างไร

DoH ส่งข้อความ DNS ภายในการแลกเปลี่ยนข้อมูลแบบ HTTPS โดย RFC 8484 กำหนดโปรโตคอลระหว่างไคลเอนต์ DNS กับ HTTPS resolver

เส้นทางคือเบราว์เซอร์หรือไคลเอนต์ ไปยัง HTTPS resolver แล้วต่อไปยังโครงสร้างพื้นฐาน DNS ตามที่จำเป็น การเชื่อมต่อที่เข้ารหัสสิ้นสุดที่ resolver และไม่ได้เข้ารหัสการแลกเปลี่ยน DNS ที่เกิดขึ้นหลังจากนั้นทั้งหมดโดยอัตโนมัติ

รูปแบบมาตรฐานคือข้อความ DNS แบบไบนารี คำขอ GET จะเข้ารหัสไว้ในพารามิเตอร์ dns ส่วนคำขอ POST จะส่งไว้ในเนื้อหาของคำขอ ส่วนอินเทอร์เฟซ JSON เฉพาะของผู้ให้บริการสะดวกสำหรับการทดสอบ แต่ใช้แทน DoH template ของเบราว์เซอร์ไม่ได้

resolver ทำหน้าที่ตอบการค้นหาชื่อ ส่วน proxy server ทำหน้าที่ส่งต่อทราฟฟิก ควรแยกสองหน้าที่นี้ออกจากกันเมื่อตั้งค่าอย่างใดอย่างหนึ่ง


DNS over HTTPS ซ่อนการท่องเว็บจาก ISP ได้หรือไม่

DoH ซ่อนเนื้อหาของการเชื่อมต่อ DNS นั้นจากผู้สังเกตการณ์แบบเฉื่อยชาบนเส้นทางเครือข่าย แต่ไม่สามารถซ่อนกิจกรรมการท่องเว็บทั้งหมดได้

resolver ของไคลเอนต์มองเห็นคำถามและที่อยู่ต้นทางที่เชื่อมต่อเข้ามา ISP ยังสังเกตเห็นที่อยู่ IP ปลายทางและรูปแบบทราฟฟิกได้ เมื่อการเชื่อมต่อไปยังเว็บไซต์ผ่านโดยตรง ข้อพิจารณาด้านความเป็นส่วนตัว ของ RFC 8484 อธิบายว่าเหตุใดการเข้ารหัสการส่งข้อมูลจึงไม่ได้ขจัดความจำเป็นที่ต้องไว้วางใจ resolver

Server Name Indication ที่ไม่ได้เข้ารหัสอาจเผยชื่อโฮสต์ระหว่างการตั้งค่า TLS ได้เช่นกัน ECH ปกป้อง ClientHello ชั้นใน รวมถึงชื่อโฮสต์นั้น เมื่อเจรจาสำเร็จ แต่ไม่ได้ซ่อนที่อยู่ IP ปลายทาง ดู คำอธิบาย ECH ของ Mozilla


DoH เปรียบเทียบกับ DoT, DNSSEC, VPN และ WARP อย่างไร

DoH และ DoT ปกป้องการส่งข้อมูล DNS ส่วน DNSSEC ยืนยันความถูกต้องของข้อมูล DNS ขณะที่ VPN เปลี่ยนเส้นทางของทราฟฟิกที่ผ่านอุโมงค์ของตน

เทคโนโลยี วัตถุประสงค์ ขอบเขต
DoH DNS over HTTPS การแลกเปลี่ยนข้อมูลระหว่างไคลเอนต์กับ resolver
DoT DNS over TLS โดยปกติใช้พอร์ต TCP 853 การส่งข้อมูล DNS
DNSSEC ตรวจสอบข้อมูล DNS ที่ลงนามแล้ว ยืนยันความถูกต้อง ไม่ใช่การรักษาความลับ
VPN ส่งทราฟฟิกเครือข่ายที่เลือกผ่านอุโมงค์ ขึ้นอยู่กับการกำหนดเส้นทางและการตั้งค่า DNS

มาตรฐานที่เกี่ยวข้องคือ RFC 7858 สำหรับ DoT และ RFC 4033 สำหรับ DNSSEC ทั้ง DNSSEC และ DoH ไม่ได้รับประกันการป้องกันคำตอบที่เป็นอันตรายได้ทุกกรณี

โหมดของ WARP ตามเอกสาร แยกการเข้ารหัสเฉพาะ DNS ออกจากการส่งทั้งทราฟฟิกและ DNS ผ่านอุโมงค์ หากต้องการดูความแตกต่างในภาพกว้าง ดู proxy เทียบกับ VPN และ Smart DNS, proxy และ VPN

DoQ เป็นอีกรูปแบบหนึ่งของการส่ง DNS แบบเข้ารหัส RFC 9250 นำ DNS ไปทำงานบน QUIC โดยตรง ซึ่งแตกต่างจาก DoH ที่ส่งผ่าน HTTP/3


ควรเปิดหรือปิด DoH

เปิดใช้ DoH เมื่อนโยบายของ resolver และพฤติกรรมเมื่อเกิดข้อผิดพลาดเหมาะกับเครือข่ายของคุณ และต้องแน่ใจว่า DNS ขององค์กรที่จำเป็น ชื่อภายในเครือข่าย และการกรองยังทำงานได้

ใช้ การตรวจสอบความเป็นส่วนตัวของ DNS 3 ขั้นตอน ก่อนเปลี่ยนการตั้งค่า:

  • ขั้นตอนที่ 1: หาจุดที่แปลงชื่อ ระบุว่าเบราว์เซอร์ ระบบปฏิบัติการ หรือ proxy เป็นผู้แปลงชื่อปลายทาง
  • ขั้นตอนที่ 2: ระบุผู้สังเกตการณ์ ไล่ดูไคลเอนต์ HTTPS resolver และโครงสร้างพื้นฐาน DNS รวมถึง proxy หากมี
  • ขั้นตอนที่ 3: ตรวจสอบการ fallback ตรวจดูว่าเมื่อล้มเหลว การแปลงชื่อจะหยุดหรือเปลี่ยนไปใช้การส่งข้อมูลแบบอื่น

ใครเป็นผู้แปลงชื่อ และใครมองเห็นได้บ้าง

ตัวเลือก ใช้ X เมื่อ… หลีกเลี่ยง X เมื่อ…
DoH ภายนอก ใช้ DoH ภายนอกเมื่อนโยบายของ resolver ตรงกับความต้องการ หลีกเลี่ยง DoH ภายนอกเมื่อชื่อภายในที่จำเป็นหรือการกรองใช้งานไม่ได้
DoH แบบเข้มงวด ใช้ DoH แบบเข้มงวดเมื่อต้องการให้การแปลงชื่อหยุดลงหากการเข้ารหัสล้มเหลว หลีกเลี่ยง DoH แบบเข้มงวดเมื่อข้อกำหนดของเครือข่ายทำให้ใช้งานไม่ได้
fallback อัตโนมัติ ใช้ fallback อัตโนมัติเมื่อให้ความสำคัญกับความพร้อมใช้งาน หลีกเลี่ยง fallback อัตโนมัติเมื่อยอมรับการ fallback ไปใช้ข้อความธรรมดาไม่ได้

ควรเลือกผู้ให้บริการและ URL ของ DoH แบบใด

เลือกโดยพิจารณานโยบายความเป็นส่วนตัว ข้อกำหนดด้านการกรอง และความเข้ากันได้ของไคลเอนต์ ก่อนเปรียบเทียบเวลาตอบสนอง และเลือกรูปแบบ endpoint ให้ตรงกับแอปพลิเคชัน

ผู้ให้บริการ endpoint แบบ wire format อินเทอร์เฟซ JSON สำหรับทดสอบ
Cloudflare https://cloudflare-dns.com/dns-query พาธเดียวกัน ใช้ header Accept แบบ JSON
Google https://dns.google/dns-query https://dns.google/resolve

ตรวจสอบ เอกสาร DoH ของ Cloudflare และ เอกสาร DoH ของ Google ช่องกรอก template และช่องกรอก endpoint ธรรมดาอาจต้องใช้รูปแบบที่ต่างกัน จึงไม่ควรวาง URL คำถามแบบ JSON ลงในช่องใดช่องหนึ่งโดยไม่ตรวจสอบก่อน

เปรียบเทียบ นโยบายความเป็นส่วนตัวของ resolver จาก Cloudflare กับ นโยบายความเป็นส่วนตัวของ DNS จาก Google รวมถึงข้อยกเว้นด้านการบันทึกข้อมูล และควรมองการบล็อกมัลแวร์และการกรองสำหรับเด็กเป็นข้อกำหนดแยกต่างหาก เพราะการเข้ารหัสเพียงอย่างเดียวไม่ได้ให้ทั้งสองอย่าง


เปิดใช้ DoH ในเบราว์เซอร์และระบบปฏิบัติการได้อย่างไร

ตั้งค่าที่องค์ประกอบซึ่งทำหน้าที่ค้นหา DNS จริง จากนั้นตรวจสอบสถานะการทำงานและพฤติกรรม fallback การตั้งค่าของเบราว์เซอร์และของระบบปฏิบัติการครอบคลุมเส้นทางที่ต่างกัน

  • Chrome: เปิด Settings, Privacy and security, Security แล้วเลือก Use secure DNS ตรวจสอบตัวเลือก resolver และพฤติกรรม fallback อัตโนมัติใน คำแนะนำการตั้งค่าความปลอดภัยของ Chrome
  • Firefox: เปิด Settings, Privacy and security, DNS over HTTPS แล้วเลือก Advanced settings เลือกระดับการป้องกันและตรวจสอบสถานะ การป้องกันระดับเริ่มต้นอาจ fallback ได้ ส่วน Max Protection จะแสดงคำเตือนเมื่อการแปลงชื่อแบบปลอดภัยล้มเหลว พร้อมตัวเลือกยกเว้น ทำตาม คำแนะนำเรื่องระดับการป้องกันของ Mozilla
  • Windows 11: เปิดการเชื่อมต่อที่ใช้งานอยู่ใต้ Network & internet แล้วแก้ไขการตั้งค่า DNS เลือก DoH template แบบอัตโนมัติหรือกำหนดเอง และตั้งค่า fallback แบบข้อความธรรมดาอย่างตั้งใจ ดู คำแนะนำการตั้งค่าเครือข่ายของ Microsoft
  • Android: อย่าสรุปว่า Private DNS คือช่องกรอก URL ของ DoH แบบเดียวกับในเบราว์เซอร์ คำแนะนำการตั้งค่า Android ของ Google ใช้ชื่อโฮสต์ของผู้ให้บริการสำหรับ Private DNS

Microsoft ยังระบุไว้ใน คำแนะนำเกี่ยวกับไคลเอนต์ DNS ของ Windows ถึงความแตกต่างระหว่างการบังคับและการร้องขอการแปลงชื่อแบบเข้ารหัส ควรตรวจสอบการทำงานอีกครั้งหลังเปลี่ยนเครือข่ายหรือเปิดใช้ VPN


DoH ใช้งานร่วมกับ proxy ได้หรือไม่

DoH สามารถส่งผ่าน proxy ได้ แต่ไม่ได้กำหนดว่าใครเป็นผู้แปลงชื่อโฮสต์ของเว็บไซต์ การส่งคำขอ HTTPS ไปยัง resolver กับการมอบหมายให้ผู้อื่นแปลงชื่อปลายทางเป็นสองการดำเนินการที่แยกจากกัน

เอกสาร proxy ของ Chromium อธิบายการแปลงชื่อปลายทางที่ฝั่ง proxy สำหรับ HTTP และ SOCKS5 proxy heuristics ของ Mozilla อธิบายกรณีที่การตรวจพบ proxy ทำให้ DoH ไม่เปิดใช้อัตโนมัติ ส่วน นโยบาย DNSOverHTTPS ควบคุม fallback แยกต่างหาก พฤติกรรมเหล่านี้ขึ้นอยู่กับการตั้งค่า

คู่มือ curl แยกการแปลงชื่อ SOCKS5 บนเครื่องออกจากการแปลงชื่อโฮสต์ที่ฝั่ง proxy และระบุตัวเลือก --doh-url ไว้ ตัวเลือกนี้ไม่ได้บังคับให้ proxy ระยะไกลใช้ resolver ที่คุณเลือก และแม้แต่การแปลงชื่อเริ่มต้นของเซิร์ฟเวอร์ DoH ก็ใช้เส้นทาง bootstrap แยกต่างหาก

การทดสอบ SOCKS ของเราพบ resolver ของผู้ให้บริการโฮสติ้งเมื่อส่งคำขอโดยตรงและผ่าน socks5:// ส่วนเมื่อใช้ socks5h:// การรันสองครั้งรายงานว่าเป็น resolver ของ Google ในสหรัฐอเมริกาหรือแคนาดา เส้นทาง SOCKS ทั้งสองใช้ที่อยู่ขาออกแบบ residential ดู HTTP เทียบกับ SOCKS5 เพื่อทำความเข้าใจบริบทของโปรโตคอล

Oblivious DoH เพิ่มข้อความ DNS ที่เข้ารหัสและการออกแบบ relay แบบเฉพาะ เพื่อแยกตัวตนของไคลเอนต์ออกจากคำถาม การใช้ proxy ทั่วไปไม่ใช่ ODoH โดยอัตโนมัติ

เพื่อดูว่าฝั่งใดแปลงชื่อ DNS หลัง SOCKS proxy เราใช้สคริปต์สั้น ๆ ต่อไปนี้ เมื่อใช้ socks5:// การค้นหายังอยู่ที่ resolver ของเซิร์ฟเวอร์เรา ส่วนเมื่อใช้ socks5h:// การค้นหาย้ายไปอยู่ฝั่ง proxy

"""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__}")

ทดสอบอย่างไรว่า DoH ทำงานได้

ตรวจสอบการเข้าถึง endpoint คำตอบของ DNS และการกำหนดเส้นทางของแอปพลิเคชันแยกกัน คำขอ HTTPS ที่สำเร็จเพียงอย่างเดียวไม่สามารถยืนยันการตั้งค่าเบราว์เซอร์หรือความเป็นนิรนามได้

ใน การทดสอบอย่างรวดเร็วของเราเมื่อวันที่ 19 ตุลาคม 2026 เซิร์ฟเวอร์ Linux ในสหภาพยุโรปที่ใช้ Ubuntu 24.04 ใช้ curl 8.5.0 และ Python 3.12 กับ httpx 0.28 และ HTTP/2 นี่เป็นการเก็บตัวอย่างขนาดเล็ก ไม่ใช่ benchmark โดยมีคำขอ DoH ประมาณ 130 รายการจากผู้ให้บริการสามราย เว้นช่วงห่างกันรายการละหนึ่งวินาที

เวลา 12:50 UTC curl ส่งคำถาม A ของ example.com ต่อเนื่องกัน 5 ครั้งต่อ JSON endpoint โดยเปิดการเชื่อมต่อใหม่ทุกครั้ง คำขอเหล่านี้เป็นไปตาม ไวยากรณ์ JSON ของ Google และ ไวยากรณ์ JSON ของ Cloudflare

ผู้ให้บริการ คำถามที่สำเร็จ สถานะ DNS และคำตอบ ขนาดเนื้อหาเฉลี่ยกลาง เวลารวมเฉลี่ยกลาง
Google 5/5 0, NOERROR; A record สองรายการ 296 B 48 ms
Cloudflare 5/5 0, NOERROR; A record สองรายการ 249 B 44 ms

endpoint ที่ใช้คือ https://dns.google/resolve?name=example.com&type=A และ https://cloudflare-dns.com/dns-query?name=example.com&type=A โดยอย่างหลังใช้ accept: application/dns-json ค่าเหล่านี้เป็นเวลาของคำขอ HTTPS รวมการตั้งค่าการเชื่อมต่อ ไม่ใช่ latency ของ DNS ล้วน ๆ

การวัดด้วย Python ใช้ 4 โดเมน รัน 3 รอบต่อวิธี และใช้ไคลเอนต์ HTTP/2 ที่นำกลับมาใช้ซ้ำได้หนึ่งตัวต่อการรันหนึ่งครั้ง ผลด้านล่างเป็นค่ามัธยฐานของค่ามัธยฐานรายโดเมน แหล่งข้อมูลคือ doh_check.py, doh_results_direct.json และ doh_results_proxy.json

วิธี โดยตรง Residential HTTP proxy
System resolver 1 ms 1 ms ยังคงเป็นการแปลงชื่อบนเครื่อง
Cloudflare JSON 14 ms 271 ms
Google JSON 17 ms 333 ms
Cloudflare wire 11 ms 263 ms
Quad9 wire 13 ms 224 ms

แต่ละวิธีของ DoH ได้รับคำตอบใน 12/12 คำขอต่อเส้นทาง รวมถึงทั้ง 48 คำขอที่ผ่าน DataImpulse residential HTTP proxy ค่า 1 ms ของ system resolver เกิดจากแคชบนเครื่อง ไม่ใช่การค้นหาผ่านเครือข่าย ค่ามัธยฐานของโดเมนหนึ่งในชุด Cloudflare JSON ที่ผ่าน proxy สูงถึง 1.4 วินาที

ความพยายามของ Quad9 JSON หมดเวลาหรือได้รับ HTTP 400 ส่วนความพยายามแบบ wire บน HTTP/1.1 ได้รับ HTTP 505 ขณะที่ HTTP/2 ใช้งานได้ ผลเหล่านี้เป็นผลที่สังเกตได้ ไม่ใช่ข้อกำหนดของโปรโตคอลที่ใช้ได้ทุกกรณี คำตอบของ Wikipedia ยังเปลี่ยนไประหว่างคำขอโดยตรงกับคำขอผ่าน proxy แต่การทดสอบนี้ไม่สามารถแยกได้ว่าสาเหตุมาจากตำแหน่งที่ตั้ง การกำหนดเส้นทางของ resolver หรือแคช

หากต้องการตรวจสอบอย่างอิสระ ให้ใช้ชื่อทดสอบที่ไม่เป็นอันตราย ตรวจสถานะของแอปพลิเคชันและเครื่องมือวินิจฉัยเครือข่าย และทดสอบพฤติกรรมเมื่อเกิดข้อผิดพลาดบนเครือข่ายที่คุณดูแลเอง ควรเก็บ response ดิบแยกไว้ต่างหาก เพราะไฟล์ผลลัพธ์ของ Python สรุปการรันและเก็บเฉพาะฟิลด์ของ response สุดท้าย ไม่ได้เก็บเนื้อหา response ทุกรายการ ตัวนับความสำเร็จวัดเฉพาะการเรียกที่ไม่เกิดข้อยกเว้น จึงควรตรวจสถานะ HTTP สถานะ DNS และคำตอบควบคู่กันด้วย

สคริปต์ด้านล่างคือสคริปต์จากการทดสอบอย่างรวดเร็วของเราเมื่อวันที่ 19 ตุลาคม 2026 สคริปต์ส่งการค้นหาชุดเดียวกันไปยัง Cloudflare, Google และ Quad9 ผ่าน DoH (ทั้งรูปแบบ JSON และ wire) และไปยัง system resolver ทั้งแบบโดยตรง และผ่าน HTTP proxy หากตั้งค่า PROXY_URL ไว้ จากนั้นพิมพ์ค่า latency มัธยฐานของแต่ละ endpoint ต้องติดตั้งด้วย pip install httpx[http2] เพราะ Quad9 ตอบเฉพาะบน 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)

เหตุใด DoH จึงล้มเหลวหรือขัดแย้งกับระบบควบคุมเครือข่าย

DNS ภายนอกอาจขัดแย้งกับ split DNS การกรองสำหรับเด็ก captive portal หรือการกำหนดเส้นทางของ VPN การเข้ารหัสแบบเข้มงวดอาจทำให้การที่ resolver ใช้งานไม่ได้กลายเป็นการค้นหาที่ล้มเหลว

ขั้นแรกให้ระบุชั้นที่ล้มเหลว ได้แก่ ไวยากรณ์ของ endpoint การเชื่อมต่อ TLS การตอบกลับของ HTTP การตอบกลับของ DNS หรือนโยบายของแอปพลิเคชัน และทดสอบทั้งชื่อสาธารณะและชื่อภายในที่จำเป็น Mozilla อธิบายข้อแลกเปลี่ยนด้านการกรองและนโยบายระดับองค์กรไว้

สำหรับการดูแลระบบที่ได้รับอนุญาต ควรเลือกใช้นโยบายของเบราว์เซอร์ที่กำหนดไว้ชัดเจนและการตั้งค่า resolver ที่ได้รับอนุมัติ การบล็อกพอร์ต DNS แบบดั้งเดิมเพียงอย่างเดียวไม่ครอบคลุมการแปลงชื่อที่ใช้ HTTPS ควรหลีกเลี่ยงการบล็อก HTTPS ในวงกว้างที่รบกวนแอปพลิเคชันอื่นที่ไม่เกี่ยวข้อง และเก็บบันทึกการวินิจฉัยไว้เฉพาะทราฟฟิกทดสอบ


คำถามที่พบบ่อย

DNS over HTTPS คืออะไร

เป็นวิธีแลกเปลี่ยนคำถามและคำตอบของ DNS ผ่านการเชื่อมต่อ HTTPS ที่เข้ารหัส การป้องกันนี้ใช้กับช่วงระหว่างไคลเอนต์กับ resolver ที่เลือก

ควรเปิดหรือปิด DNS over HTTPS

เปิดเมื่อไว้วางใจ resolver และบริการเครือข่ายที่จำเป็นยังใช้งานได้ เลือกพฤติกรรมแบบเข้มงวดเมื่อเกิดข้อผิดพลาดก็ต่อเมื่อการสูญเสียการแปลงชื่อดีกว่าการใช้ fallback

DoH ซ่อนการท่องเว็บจาก ISP ได้หรือไม่

DoH ป้องกันไม่ให้ผู้อื่นอ่านการแลกเปลี่ยน DNS ที่ได้รับการปกป้องแบบเฉื่อยชา แต่การเชื่อมต่อไปยังปลายทางโดยตรงและรูปแบบทราฟฟิกยังอาจเผยข้อมูลเกี่ยวกับการท่องเว็บได้

DoH ต่างจาก DoT และ DNSSEC อย่างไร

DoH และ DoT เข้ารหัสการส่งข้อมูล DNS ด้วยรูปแบบโปรโตคอลที่ต่างกัน ส่วน DNSSEC ตรวจสอบข้อมูล DNS ที่ลงนามแล้วและสามารถใช้เสริมการส่งข้อมูลได้ทั้งสองแบบ

DoH ใช้งานกับ proxy ได้หรือไม่ และใครเป็นผู้แปลงชื่อโฮสต์

ใช้งานได้ แต่การตั้งค่าของไคลเอนต์และ proxy เป็นตัวกำหนดว่าใครเป็นผู้แปลงชื่อ proxy ที่ส่งคำขอ DoH กับ proxy ที่แปลงชื่อโฮสต์ของเว็บไซต์ทำหน้าที่ต่างกัน

ไอคอนแม่กุญแจของเบราว์เซอร์พิสูจน์ได้หรือไม่ว่าเปิดใช้ DoH แล้ว

ไม่ได้ TLS ของเว็บไซต์กับการส่งข้อมูล DNS เป็นการเชื่อมต่อที่แยกจากกัน จึงควรตรวจสอบ DNS ผ่านสถานะของแอปพลิเคชันและเครื่องมือวินิจฉัย


ตรวจสอบเส้นทาง DNS ควบคู่กับการตั้งค่า proxy

หากใช้ DataImpulse ควรตรวจสอบทั้งทางออกของทราฟฟิกและเส้นทาง DNS ด้วยการทดสอบเล็ก ๆ DataImpulse เป็นผู้ให้บริการ proxy ไม่ใช่ DoH resolver, VPN, scraping API หรือบริการ unblocker แบบจัดการให้ เริ่มต้นด้วย การเปรียบเทียบ HTTP และ SOCKS5 เพื่อเลือกรูปแบบการเชื่อมต่อที่เหมาะสม

อัปเดตล่าสุด: 19 ตุลาคม 2026


Share article: