The Domain Name System was designed in 1983 as a distributed phonebook for the early internet. It assumed good faith from every participant. Queries travel in cleartext. Responses carry no proof of origin. Any device sitting between a client and a resolver can read every lookup, and any on-path attacker can substitute a forged answer that the client has no way to distinguish from the real one. For the first two decades that hardly mattered because the internet was small and largely cooperative. It matters now because DNS underpins every TLS handshake, every email delivery, every CDN routing decision, and every certificate issuance event on the modern web.
Four decades of patching that original design have produced four distinct protection layers, each targeting a different weakness. DNSSEC adds cryptographic authenticity so resolvers can verify that a response was not tampered with. DNS-over-HTTPS and DNS-over-TLS add encryption so observers cannot read the queries. DANE pins TLS certificates to DNS records so domain owners can bypass the public certificate authority trust model. None of these layers is redundant. None of them alone is sufficient. Understanding what each one does — and what it deliberately leaves unsolved — is the difference between a secure DNS posture and a collection of partially deployed features that create a false sense of coverage.
Quick check: Use the DNS Lookup Tool to query DNSKEY and DS records for any domain and see whether DNSSEC is deployed, then run a Domain Health scan to check validation status.
DNSSEC: Authenticating DNS Responses
DNSSEC solves the authenticity problem. Without it, a recursive resolver has no way to verify that the answer it received for a query actually came from the authoritative server for that zone. A Kaminsky-style cache poisoning attack, a compromised upstream link, or a rogue Wi-Fi access point can all inject forged DNS responses that redirect users to attacker-controlled infrastructure. DNSSEC makes forgery detectable by introducing a chain of cryptographic signatures that extends from the DNS root zone down through each TLD and into individual domain zones.
The mechanism works through four record types acting in concert. The zone owner generates a Zone Signing Key (ZSK) and a Key Signing Key (KSK), both published as DNSKEY records in the zone. The ZSK signs every record set in the zone, producing RRSIG records that accompany the answers. The KSK signs the DNSKEY record set itself, and a hash of that KSK is published as a DS record in the parent zone. When a resolver queries example.com and receives an A record, it also receives the RRSIG for that A record. It fetches the DNSKEY from the example.com zone, verifies the RRSIG against the ZSK, then checks the KSK against the DS record in the .com zone. The .com DS record is itself signed by the .com zone's keys, which are validated against DS records in the root zone. The root zone's keys are distributed out of band as trust anchors.
# Query DNSKEY records for a domain
dig example.com DNSKEY +dnssec +short
# Check the DS record in the parent zone
dig example.com DS +short
# Validate the full DNSSEC chain
dig example.com A +dnssec +sigchase +trusted-key=./root.keys
What DNSSEC prevents is precise: cache poisoning, response forgery, and any form of unsigned record injection. A validating resolver will return SERVFAIL rather than accept a response with a broken or missing signature chain. What DNSSEC does not prevent is equally important. It does not encrypt anything. A passive observer on the network path can still see every domain name being queried, every response being returned, and every TTL value in the exchange. DNSSEC guarantees that the answer is authentic. It says nothing about whether someone was watching.
Adoption has been uneven. The root zone and most TLDs have been signed since 2010. Among second-level domains, adoption varies dramatically: roughly 30 percent of .com domains carry DS records, while ccTLDs like .nl and .se exceed 60 percent. On the resolver side, major public resolvers including Google Public DNS, Cloudflare 1.1.1.1, and Quad9 all perform DNSSEC validation by default. The practical gap is not resolver support. It is zone signing. If a domain owner never publishes DNSKEY and DS records, resolvers have nothing to validate.
DNS-over-HTTPS: Privacy Through Indistinguishability
DNS-over-HTTPS, specified in RFC 8484, addresses the problem that DNSSEC ignores: eavesdropping. DoH wraps DNS queries and responses inside standard HTTPS connections on port 443. From a network perspective, DoH traffic is indistinguishable from any other HTTPS session. An ISP, a corporate firewall, or a government monitoring point cannot selectively identify, block, or inspect DNS queries without blocking all HTTPS traffic to the resolver's IP address. That property — indistinguishability from web traffic — is the defining characteristic that separates DoH from every other encrypted DNS approach.
The protocol supports two content types: the traditional DNS wire format (application/dns-message) sent as an HTTP POST, and a JSON format for easier programmatic consumption. Most browser implementations use the wire format. The resolver endpoint is a standard HTTPS URL, typically something like https://dns.cloudflare.com/dns-query or https://dns.google/dns-query.
# DoH query using curl with wire format
curl -s -H 'accept: application/dns-json' \
'https://cloudflare-dns.com/dns-query?name=example.com&type=A' | jq
# Response
# {
# "Status": 0,
# "TC": false,
# "RD": true,
# "RA": true,
# "AD": true,
# "Answer": [
# { "name": "example.com", "type": 1, "TTL": 86400, "data": "93.184.216.34" }
# ]
# }
The AD flag in that response indicates that the resolver performed DNSSEC validation successfully. That is worth noting because DoH and DNSSEC are complementary, not competing. DoH encrypts the transport. DNSSEC authenticates the content. A DoH response with AD=true means the query was private and the answer is verified.
The controversy around DoH centers on control. When Firefox or Chrome enable DoH by default and route queries to a browser-chosen resolver like Cloudflare or Google, DNS resolution moves out of the operating system's control and away from the network's configured resolver. Enterprise DNS policies, split-horizon DNS, parental controls, and network-level security filtering all depend on being able to see and sometimes intercept DNS queries. DoH undermines every one of those assumptions. This is not a bug in DoH. It is the explicit design goal: make DNS queries as hard to intercept as web traffic. Whether that trade-off is acceptable depends entirely on who is doing the intercepting and why.
Adoption is now broad. Firefox has shipped DoH by default in the United States and several other regions since 2020. Chrome, Edge, and Brave all support DoH and will upgrade to it automatically when the system-configured resolver offers a DoH endpoint. On mobile, iOS 14+ and Android 9+ both support DoH configuration at the OS level.
DNS-over-TLS: Privacy With Network Visibility
DNS-over-TLS, specified in RFC 7858, solves the same eavesdropping problem as DoH but makes a fundamentally different trade-off about visibility. DoT wraps DNS queries in TLS but sends them on a dedicated port: 853. That means a network operator can see that DNS-over-TLS traffic is occurring, can choose to allow or block it, and can enforce policies about which resolvers are permitted. The queries themselves are encrypted — an observer cannot read the domain names being looked up — but the fact that encrypted DNS is happening is not hidden.
This distinction matters enormously in enterprise and service-provider contexts. A corporate network that needs to enforce DNS-based security filtering can block port 853 and force clients back to the local resolver. A government censor can block port 853 to prevent encrypted DNS without collateral damage to HTTPS. Network operators who want to offer encrypted DNS while retaining operational visibility — knowing that DNS traffic is flowing, measuring query volume, detecting resolver failures — find DoT far more compatible with existing network management than DoH.
Android's Private DNS feature, introduced in Android 9, is the most widely deployed DoT implementation. When a user configures a Private DNS hostname in Android settings, the OS establishes a persistent TLS connection to that resolver on port 853 and routes all DNS queries through it. This protects queries from Wi-Fi eavesdropping, ISP monitoring, and any other on-path observer, while still using a dedicated channel that network administrators can identify.
- DoT uses port 853; DoH uses port 443. This is the single most consequential difference between them.
- DoT is easier to block selectively, which enterprise and ISP operators consider a feature, not a limitation.
- DoT does not blend with web traffic, so a network monitor can distinguish DNS from HTTPS at the port level.
- Both DoT and DoH provide identical encryption strength. The privacy of the query content is the same.
- Android Private DNS is DoT. Browser encrypted DNS is usually DoH. The two protocols coexist.
In practice, the DoH-versus-DoT debate is less about which protocol is technically superior and more about where control should reside. DoH shifts control toward the application and the end user. DoT keeps control closer to the network and the operating system. Both are legitimate positions depending on the threat model. A journalist in a country with state censorship benefits from DoH's indistinguishability. An enterprise security team benefits from DoT's dedicated port. The right answer depends on who the adversary is.
DANE and TLSA Records: Certificate Pinning via DNS
DANE — DNS-based Authentication of Named Entities — approaches DNS security from a completely different angle. Instead of protecting the DNS query itself, DANE uses DNS to protect TLS. The problem it solves is this: the public certificate authority model allows any of hundreds of trusted CAs to issue a certificate for any domain. If a single CA is compromised, coerced, or misconfigured, it can issue a fraudulent certificate for your domain and a man-in-the-middle attack becomes trivially possible. DANE lets domain owners publish a TLSA record in DNS that specifies exactly which certificate, public key, or CA should be trusted for a given service.
A TLSA record has four fields. The usage field specifies whether the record constrains the end-entity certificate, the CA certificate, or acts as a trust anchor. The selector field specifies whether the full certificate or just the public key is being matched. The matching type field specifies whether the record contains the raw data, a SHA-256 hash, or a SHA-512 hash. The certificate association data field contains the actual hash or certificate material.
# Query TLSA record for HTTPS on example.com
dig _443._tcp.example.com TLSA +short
# Example output:
# 3 1 1 2BB183AF2B23730D4F28BEF987F5A03C44D60E6A0B125C8F...
#
# Usage 3 = DANE-EE (pin the end-entity certificate directly)
# Selector 1 = match the SubjectPublicKeyInfo (public key only)
# Matching 1 = SHA-256 hash
# Data = SHA-256 hash of the server's public key
DANE has one absolute dependency: DNSSEC. If the TLSA record can be forged, the entire pinning mechanism is worthless — an attacker who can forge DNS responses can forge the TLSA record to match their fraudulent certificate. DANE without DNSSEC is not just weak; it is meaningless. This dependency is the primary reason DANE adoption on the web has remained low. Browsers have not implemented DANE verification for HTTPS, partly because DNSSEC deployment among web-facing domains is still too inconsistent to rely on.
Where DANE has found real traction is in email. SMTP has an even worse CA trust problem than HTTPS because opportunistic TLS between mail servers traditionally performs no certificate validation at all. Postfix, the most widely deployed MTA, has supported DANE for outbound TLS since version 2.11. When a sending Postfix server finds a TLSA record for the receiving MX host's port 25, it validates the receiving server's certificate against that TLSA record. If validation fails, the connection is refused rather than silently downgraded to cleartext. This eliminates both passive eavesdropping and active downgrade attacks on server-to-server email.
Major email providers including Comcast, Deutsche Telekom, and several Scandinavian ISPs have deployed DANE on their inbound MX records. Google published TLSA records for Gmail's MX servers in 2024. The practical effect is that DANE is becoming a meaningful layer of mail transport security for organizations that sign their zones and publish TLSA records alongside their MX configuration.
Practical DNS Security Deployment
Deploying DNS security is not a single event. It is a sequence of layers, each building on the one before it, each with different operational requirements and failure modes. The order matters because later layers depend on earlier ones, and deploying them out of sequence creates either gaps or brittle configurations that break under maintenance.
- Enable DNSSEC validation on your resolvers. If you run your own recursive resolvers, enable validation and monitor for SERVFAIL spikes that indicate broken signature chains. If you use a public resolver, confirm it validates by default.
- Sign your own zones. Work with your DNS provider or registrar to enable DNSSEC signing and publish DS records in the parent zone. Automate key rollovers to avoid expiration-related outages.
- Deploy DoH or DoT for user-facing queries. For end-user devices, configure DoH in browsers or DoT at the OS level. For corporate environments, decide whether queries should route through a local validating resolver or directly to a trusted public resolver.
- Publish TLSA records for mail. If your zones are signed and your MX records are stable, publish DANE TLSA records for port 25 on your MX hosts. Test with tools like the DANE SMTP Validator before going live.
- Monitor continuously. DNSSEC signatures expire. Key rollovers can fail silently. DS record updates in the parent zone can lag. Certificate rotations can invalidate TLSA records. Every layer requires ongoing validation, not just initial deployment.
The most common deployment failure is not a misconfigured record. It is a process gap: a team that signs a zone but never automates key rollover, an admin who publishes a TLSA record but forgets to update it when the certificate rotates, or an organization that enables DoH in browsers but never checks whether the chosen resolver actually validates DNSSEC. DNS security layers interact with each other and with the certificate, mail, and hosting infrastructure. Treating any one of them as a standalone checkbox creates exactly the kind of false confidence that attackers exploit.
Use the Domain Health tool to check whether DNSSEC is configured correctly for your domains, and the DNS Lookup API to programmatically monitor DNSKEY, DS, and TLSA records as part of your deployment pipeline.
DNS Security Threats That Remain
Even a fully deployed stack of DNSSEC, DoH or DoT, and DANE leaves significant attack surface unaddressed. These are not theoretical edge cases. They are active, exploited attack vectors that DNS security protocols were never designed to prevent.
DNS rebinding exploits the gap between DNS resolution and browser same-origin enforcement. An attacker controls a domain that initially resolves to an external IP, then switches the A record to an internal IP address like 192.168.1.1 with a very short TTL. The browser still considers the request same-origin because the domain name has not changed, but the request now reaches an internal device. DNSSEC cannot help because the attacker's zone is legitimately signed — the records are authentic, just malicious. DoH cannot help because the query is encrypted but the response is still a valid internal IP.
Subdomain takeover happens when a DNS record points to a third-party service — a cloud provider, a CDN, a SaaS platform — and the account or resource behind that service is decommissioned without removing the DNS record. An attacker claims the orphaned resource and now controls content served under the victim's subdomain. DNSSEC validates the CNAME record as authentic because it is. The record was never tampered with. It was simply never cleaned up. Regular auditing with DNS History can surface dangling records before they become exploitable.
Registrar-level domain hijacking bypasses DNS security entirely by compromising the domain's administrative control at the registrar. An attacker who gains access to the registrar account can change nameservers, modify DS records, transfer the domain, or disable DNSSEC. Because the attacker now controls the authoritative zone, every subsequent DNS response is technically valid from DNSSEC's perspective. Two-factor authentication on registrar accounts, registrar lock, and registry lock services are the primary defenses, and they have nothing to do with DNS protocols.
BGP hijacking can redirect DNS traffic at the network routing layer. By announcing more-specific IP prefixes for a DNS resolver or authoritative server, an attacker can intercept DNS queries before they reach the legitimate server. DNSSEC validation will detect forged responses in this scenario, which is one of its strongest use cases. But if the attacker also controls a valid certificate for the resolver (or targets unencrypted DNS), the hijack can be invisible to the client. The combination of DNSSEC validation and encrypted transport (DoH or DoT with certificate pinning) provides the strongest defense against BGP-based DNS interception.
Where DomScan Helps
DomScan surfaces the signals that make DNS security operationally visible rather than theoretically deployed. The DNS Lookup Tool queries DNSKEY, DS, RRSIG, and TLSA records alongside standard record types so you can verify DNSSEC chain status and DANE configuration without switching between tools. Domain Health checks whether DNSSEC validation succeeds end-to-end, not just whether the records exist. DNS History tracks changes to security-critical records over time, making it possible to detect key rollover failures, DS record gaps, or unexpected TLSA changes before they cause outages.
The practical value is not replacing the protocols or the operational discipline they require. It is making the current state legible enough that the team responsible for DNS security can tell the difference between a correctly deployed stack and one that looks deployed but has a broken signature chain, an expired key, or a TLSA record that no longer matches the current certificate.
Independent references: Review RFC 7858 for DNS-over-TLS, RFC 8484 for DNS-over-HTTPS, and the Cloudflare DNS encryption guide for practical deployment instructions.
DNS security is not a feature you turn on. It is a set of interlocking protocols, each with its own deployment requirements, failure modes, and maintenance obligations. The domains that are genuinely protected are the ones where someone is watching the chain of trust, verifying that encryption is actually negotiated, and catching the operational gaps before an attacker finds them.