Skip to content
AdminKit

DNSSEC: what it actually protects — and what it doesn't

DNSSEC adds cryptographic signatures to DNS responses so a validating resolver can confirm an answer wasn't altered or forged in transit, closing the gap that lets attackers forge DNS answers; it does not encrypt your DNS traffic or hide which domains you look up. AdminKit's DNSSEC check shows a domain's DNSSEC status directly.

By AdminKit team, Netbase JSC · Updated

Key takeaways

  • DNSSEC proves that a DNS answer came from the domain’s real zone and wasn’t changed on the way. It does not encrypt queries or hide which names you look up.
  • Protection needs two sides: the domain must be signed, and the resolver you use must validate. A signed domain behind a non-validating resolver gains nothing.
  • A validating resolver puts every answer into one of four states: secure, insecure (unsigned), bogus (signed but broken) or indeterminate.
  • The main risk is operational: a key rollover that leaves the parent’s DS record out of step makes the whole domain fail for validating resolvers.
  • AdminKit’s DNSSEC check gives a live secure / insecure / bogus verdict for any domain.

What problem was DNSSEC built to fix?

Ordinary DNS has no built-in way for a recursive resolver to tell a genuine answer from a forged one. A resolver asks “what’s the IP address for example.com?” and accepts whatever response arrives first that appears to match the query — there’s no signature, no proof the response actually came from the domain’s authoritative nameserver. RFC 4033 (also on the IETF Datatracker) describes the consequence plainly: an attacker who can inject a forged response into the path between a resolver and the real authoritative server (or poison a resolver’s cache with one) can redirect anyone using that resolver to an address of their choosing, with no indication anything went wrong. This is the same structural weakness behind DNS cache-poisoning and some DNS hijacking scenarios described in our DNS hijacking guide.

RFC 9364, published as Best Current Practice 237 in 2023, gathers the DNSSEC specifications in one place and states that “using DNSSEC for origin authentication of DNS data is the best current practice.”

How does the DNSSEC chain of trust work?

DNSSEC fixes this by having each domain cryptographically sign its own DNS records. RFC 4034 defines the record types involved: a DNSKEY record publishes the domain’s public signing key, RRSIG records are the signatures over each set of records, and a chain of DS records at each parent zone (from the root down through the TLD to the domain) lets a resolver verify the whole chain of trust without needing to pre-trust every individual domain’s key out of band. A validating resolver checks this chain and only accepts an answer if the signature verifies — a forged or altered response fails validation and gets dropped instead of silently accepted. Proving a name doesn’t exist needs its own mechanism: an NSEC or NSEC3 record lets a resolver verify a negative answer the same cryptographic way, rather than trusting an unsigned “no such name” response at face value. Each RRSIG’s inception/expiration window is checked against the resolver’s own clock, so a resolver with inaccurate time — NTP is what normally keeps it correct — can reject a genuinely valid signature as expired, or the reverse. See the DS record entry for how that specific parent-zone record lets a resolver cross a delegation boundary without pre-trusting the child zone’s key.

Chain of trust for www.example.com (simplified)

Root zone      DNSKEY (trust anchor configured in the resolver)
   |  DS for "com"          signed by the root's key
com zone       DNSKEY
   |  DS for "example.com"  signed by com's key
example.com    DNSKEY
   |  RRSIG over the A record, made with example.com's key
www.example.com  A  192.0.2.10   <- accepted only if every link verifies
RecordLives inJob
DNSKEYThe signed zonePublishes the zone’s public keys
RRSIGThe signed zone, next to each record setSignature over one record set, with a validity window
DSThe parent zoneFingerprint of the child’s key; links parent to child
NSEC / NSEC3The signed zoneSigned proof that a name or type doesn’t exist
CDS / CDNSKEYThe signed zoneThe child’s request for what its DS record at the parent should be

What does DNSSEC not do?

The most consequential misunderstanding about DNSSEC is treating it as encryption. It isn’t. DNSSEC signs answers so their authenticity can be checked; it does nothing to hide the contents of a query or response from anyone observing the network path. Your ISP, a coffee-shop Wi-Fi operator, or anyone else positioned to see your DNS traffic can still see exactly which domains you’re resolving, DNSSEC or not. If your goal is to keep DNS lookups private rather than just tamper-evident, that’s the job of DNS-over-HTTPS (DoH) or DNS-over-TLS (DoT), which encrypt the transport — a genuinely different problem with a genuinely different fix; see our guide on DoH vs DoT for how those compare.

DNSSEC also stops at the DNS answer. It verifies that the IP address you received for a hostname is the one the domain’s owner actually published — it has no opinion on what’s running at that IP address, whether its TLS certificate is valid, or whether the content served there is trustworthy. A domain can have flawless DNSSEC and still serve an expired or mismatched TLS certificate; those are separate checks covered in our guide on reading a TLS/SSL certificate check result.

And critically, DNSSEC only protects the hop between the authoritative server and a validating resolver. If the resolver you’re actually using doesn’t perform validation — many ISP and default router resolvers historically haven’t — a signed answer and a forged one are treated identically once they reach you, because nothing downstream of the resolver re-checks the signature.

ThreatDoes DNSSEC stop it?
A forged answer injected between resolver and authoritative serverYes, if the resolver validates
A poisoned resolver cacheYes, for signed zones on a validating resolver
Someone on your network reading which names you look upNo: use DoH or DoT
An attacker who has taken over your DNS provider account or registrarNo: they can sign or remove signing with your own keys
A malicious or compromised web server at the correct addressNo: that’s a TLS and server-security question
A router that sends your queries to a rogue resolverOnly if your device validates itself; usually no

What do secure, insecure and bogus mean?

RFC 4035 (§4.3) requires a validating resolver to sort every answer into one of four states:

  • Secure: the resolver built a chain of signed DNSKEY and DS records from its trust anchor down to the answer. The resolver marks the answer with the AD (authenticated data) flag.
  • Insecure: the resolver knows there is no chain, because the zone (or a parent) is unsigned. The answer is served normally, without the AD flag. Most domains are in this state.
  • Bogus: the resolver expected a chain but couldn’t verify it, because a signature failed or required DNSSEC data was missing. RFC 4035 notes this “may indicate an attack but may also indicate a configuration error”. A validating resolver returns SERVFAIL. The Google Public DNS FAQ describes this from a large public resolver’s side: it validates every response from a signed zone unless the client sets the CD flag, and returns SERVFAIL when it cannot validate one.
  • Indeterminate: the resolver couldn’t get the DNSSEC records it needed to decide.

Your own resolver shows which state it reached through the AD flag in its response:

Example output (illustrative, abbreviated, documentation address)

$ dig example.com A +dnssec
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
                     ^^ "ad" set: your resolver validated the answer as secure
example.com.   3600  IN  A      192.0.2.10
example.com.   3600  IN  RRSIG  A 13 2 3600 ( ... )

If a domain you know is signed comes back without ad, your resolver isn’t validating. A resolver that supports Extended DNS Errors (RFC 8914) can also explain a bogus result with a code such as 6 (DNSSEC Bogus), 7 (Signature Expired) or 9 (DNSKEY Missing).

How do you check your own exposure?

Two separate questions are worth answering, and conflating them is the most common DNSSEC mistake:

  • Does the domain you’re checking publish signed records at all, and does the chain actually validate? AdminKit’s DNSSEC check tool answers both live in one request, against a real validating resolver: secure (signed and validating), insecure (unsigned — nothing to validate) or bogus (signed, but the chain is currently broken). Use the DNS lookup tool alongside it to confirm the domain’s NS records and SOA, which tell you which DNS provider would need to fix a broken chain.
  • Does the resolver you actually use perform validation? A signed domain provides no protection if nothing downstream checks the signature. AdminKit’s DNS resolver test page shows how to find out which resolver your device actually uses; then consult ICANN’s DNSSEC overview for how validating resolvers like most public DNS providers handle this today. The ad flag test above is a quick way to confirm it from a terminal.

Why is DNSSEC operationally fragile?

DNSSEC’s biggest real-world risk isn’t a security weakness — it’s operational fragility. Signing keys need periodic rollover, and a rollover done incorrectly (old signatures expiring before new ones propagate, or a DS record at the parent zone falling out of sync with the domain’s own keys) can make every record in a signed zone fail validation simultaneously, taking the domain offline for anyone using a validating resolver — a worse outcome than not having DNSSEC at all. This operational cost, more than any technical limitation, is why adoption across both domains and resolvers remains uneven years after DNSSEC was standardized. A registrar or registry that supports CDS/CDNSKEY records removes the manual half of that risk: the domain publishes what it wants its DS record to say, and the parent zone updates it automatically instead of waiting on someone to paste a new key fingerprint into a control panel during a rollover. RFC 7344 defines those two record types.

The same applies when you move a signed domain to a new DNS provider. If the old provider’s keys disappear before the parent’s DS record points at the new provider’s keys, the domain turns bogus for every validating resolver. Plan the move so that the DS record changes while the old signatures are still being served, or remove the DS record and wait out its TTL before switching.

Which checks sit alongside DNSSEC?

DNSSEC, TLS certificate validity, and DNS-over-HTTPS/DoT each protect a different link in the chain between typing a domain name and loading a trustworthy page. See reading a TLS/SSL certificate check result for what happens after a DNS answer is accepted, and DNS rebinding explained for a related but distinct DNS-trust problem that DNSSEC does not address.

This guide is general information, not a security audit of your specific network — see our disclaimer for what AdminKit's guidance does and does not commit to.

Frequently asked questions

What problem does DNSSEC actually solve?

DNSSEC solves authenticity, not confidentiality: it lets a resolver cryptographically verify that a DNS answer really came from the domain's authoritative servers and wasn't modified along the way — including by cache-poisoning attacks that inject forged records into a resolver's cache. Without DNSSEC, a resolver has no way to tell a legitimate answer from a convincingly forged one; RFC 4033 sets out this exact threat model.

Does DNSSEC encrypt my DNS queries?

No. This is the single most common misconception about DNSSEC. It signs responses so they can be verified as authentic, but the queries and answers themselves travel in plaintext, exactly as with unsigned DNS — anyone on the network path can still see which domains you're looking up. If you want confidentiality rather than authenticity, that's what DNS-over-HTTPS (DoH) and DNS-over-TLS (DoT) provide, and they solve a different problem than DNSSEC solves.

If a domain has DNSSEC enabled, does that mean my connection to it is secure?

No — DNSSEC only validates the DNS answer, meaning it confirms you received the correct IP address for a hostname. It says nothing about whether the server at that IP address is trustworthy, whether its TLS certificate is valid, or whether the site itself is safe. Those are separate checks: see our guide on reading a TLS/SSL certificate check result for what happens after DNS resolution succeeds.

Why isn't DNSSEC universally deployed if it closes a real gap?

Deployment requires both the domain's authoritative DNS (signing every zone and managing key rollovers correctly) and the resolver doing the lookup (actually performing validation and rejecting unsigned or invalid answers) to support it, and a single misconfigured key rollover can take a signed domain completely offline for every validating resolver. That operational risk, combined with the fact that most resolvers still accept unsigned answers by default, has historically kept adoption uneven across both domains and resolver operators, as ICANN's and APNIC's public deployment tracking documents.

How do I check if DNSSEC is actually working for a domain?

You need to confirm two separate things: that the domain publishes signed records (DS record at the parent zone plus DNSKEY/RRSIG records at the domain itself), and that the resolver you're actually using performs validation and would reject a tampered answer. AdminKit's DNSSEC check answers the first question with a live secure, insecure or bogus verdict; for the second, look for the AD (authenticated data) flag in your own resolver's answers.

Want AdminKit to watch this for you?

Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.

Huy Nguyen (David), Founder and CEO of Netbase JSC

Talk to an expert

Huy Nguyen (David), Founder & CEO, Netbase JSC

Ask whether this fix applies to your setup, or get a second pair of eyes on your DNS and mail records.