RFC 4697

Observed DNS Resolution Misbehavior

📅 published October 2006, from ietf

Observed DNS Resolution Misbehavior 🦋

Okay bestie, let's start with the header tea ☕. This one is from the Network Working Group 🌸 and it's RFC 4697, also filed as BCP: 123. The title is "Observed DNS Resolution Misbehavior." The authors are M. Larson and P. Barber, both from VeriSign, Inc. 💅 It's a Best Current Practice, dated October 2006. The title block doesn't list anything it obsoletes or updates, so it's standing on its own 👑.

Status of This Memo ✨

This document specifies an Internet Best Current Practice for the Internet Community, and it's asking for discussion and suggestions for improvements 🫶. Distribution of this memo is unlimited 🌈.

Copyright (C) The Internet Society (2006).

Abstract 💜

So this memo is all about DNS iterative resolvers acting up in a way that floods the root and TLD name servers with queries 😭. We give iterative resolver developers advice on how to cut down on those unnecessary queries. Everything in here came from watching weird query traffic at two of the thirteen root name servers and all thirteen com/net TLD name servers 👀. Main character energy for the data nerds 🤓.

Table of Contents 📜

   1. Introduction ....................................................2
      1.1. A Note about Terminology in this Memo ......................3
      1.2. Key Words ..................................................3
   2. Observed Iterative Resolver Misbehavior .........................3
      2.1. Aggressive Requerying for Delegation Information ...........3
           2.1.1. Recommendation ......................................5
      2.2. Repeated Queries to Lame Servers ...........................6
           2.2.1. Recommendation ......................................6
      2.3. Inability to Follow Multiple Levels of Indirection .........7
           2.3.1. Recommendation ......................................7
      2.4. Aggressive Retransmission when Fetching Glue ...............8
           2.4.1. Recommendation ......................................9
      2.5. Aggressive Retransmission behind Firewalls .................9
           2.5.1. Recommendation .....................................10
      2.6. Misconfigured NS Records ..................................10
           2.6.1. Recommendation .....................................11

      2.7. Name Server Records with Zero TTL .........................11
           2.7.1. Recommendation .....................................12
      2.8. Unnecessary Dynamic Update Messages .......................12
           2.8.1. Recommendation .....................................13
      2.9. Queries for Domain Names Resembling IPv4 Addresses ........13
           2.9.1. Recommendation .....................................14
      2.10. Misdirected Recursive Queries ............................14
           2.10.1. Recommendation ....................................14
      2.11. Suboptimal Name Server Selection Algorithm ...............15
           2.11.1. Recommendation ....................................15
   3. Security Considerations ........................................16
   4. Acknowledgements ...............................................16
   5. Internationalization Considerations ............................16
   6. References .....................................................16
      6.1. Normative References ......................................16
      6.2. Informative References ....................................16

1. Introduction 💖

Okay so, the researchers watched the query traffic hitting two root name servers and the thirteen com/net TLD name servers, and guess what? A huge chunk of it was "requeries" 😭. A requery is the same question (<QNAME, QTYPE, QCLASS>) getting asked over and over at a way-too-high rate. They saw requeries coming from one single IP address, and they also saw them from multiple IP addresses at once (i.e., the exact same query arriving at the same time from several different IP addresses) 🙈.

Here's the drama 🎭. The duplicate traffic is almost always caused by a deficient iterative resolver, stub resolver, or application implementation that's paired with some kind of operational anomaly. The implementation messes they've spotted so far include well-intentioned recovery attempts gone awry 🤦, insufficient caching of failures, giving up early when multiple levels of indirection have to be followed, and aggressive retry by stub resolvers or applications 💀. The anomalies that set off requery events include lame delegations, unusual glue records, and anything that makes all the authoritative name servers for a zone unreachable. That covers Denial of Service (DoS) attacks, crashes, maintenance, routing failures, congestion, etc. 🌪️

The next sections go deep on the behavior they saw and recommend changes that will bring the requery rate down 📉. None of the recommended changes touches the core DNS protocol specification 🙌. Instead, this document is a set of guidelines for implementors of iterative resolvers 🧚.

1.1. A Note about Terminology in This Memo 🎀

To flip an old saying about standards, the nice thing about DNS terms is that there are so many of them to choose from 💅. Talking or writing about DNS can get messy and confusing, since there's no agreed-upon set of terms for all its different parts 😵‍💫. It gets worse when implementations stuff multiple roles into one piece of software, because then it's hard to even name the thing 🫠.

Here's an example. Picture an entity that accepts recursive queries, sends out iterative queries as needed to resolve the original recursive query, caches the responses it gets, and can also answer questions about certain zones authoritatively 👑. That entity is an iterative resolver combined with an authoritative name server. People often call it a "recursive name server" or a "caching name server" 🌸.

This memo is mainly about iterative resolvers, which usually live inside a recursive name server 💜. The memo uses the more precise term "iterative resolver" because that's usually the part everyone's focused on ✨. When the name server side of that entity needs to come up, the memo says "recursive name server" instead 🫶. To see the difference: the name server component receives DNS queries, and the iterative resolver component sends queries 🔥.

IPv6 changed the game a bit 🌈. When you're talking about glue, you have to mention AAAA records as well as A records (AAAA, A). To avoid repeating and qualifying everything all the time, this memo uses the general term "address record" to cover both A and AAAA records whenever a situation applies to both 💖.

1.2. Key Words 🔑

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [1] 🦋.

2. Observed Iterative Resolver Misbehavior ⭐

2.1. Aggressive Requerying for Delegation Information

okay so picture this 😭 sometimes every single name server in a zone's NS RRSet is unreachable (hello, network outage 💀), unavailable (the name server process isn't even running on the host 🙈), or misconfigured (not authoritative for the zone, aka "lame" 🥀). Say an iterative resolver tries to answer a query for a name in that zone and finds that none of the zone's name servers can help. We've seen a recursive name server implementation where its iterative resolver then checks the zone's NS RRSet in its cache by asking for the zone's delegation info. It sends a query for the zone's NS RRSet to one of the parent zone's name servers. (ngl, queries with QTYPE=NS aren't required by the standard resolution algorithm in Section 4.3.2 of RFC 1034 [2]. They're this implementation's own add-on to that algorithm 🙄)

let's use an example 🎀 suppose "example.com" has this NS RRSet:

example.com.   IN   NS   ns1.example.com.
example.com.   IN   NS   ns2.example.com.

now, when a query for "www.example.com" comes in and neither "ns1.example.com" nor "ns2.example.com" can answer, this implementation immediately queries a "com" zone name server for the "example.com" NS RRSet to "verify" that it has the proper delegation information. this implementation does that query to a zone's parent zone for every recursive query that fails because the target zone's name servers are completely unresponsive. 😤 now imagine a popular zone has a catastrophic failure of all its name servers. Every recursive query for names in that zone sent to this implementation turns into a query to the failed zone's parent name servers. one time, when several dozen popular zones went unreachable, the query load on the com/net name servers jumped by 50%. that's not a vibe 💀

we really don't think this verification query is reasonable 🙅‍♀️ think about the circumstances. when an iterative resolver is resolving a query for a name in a zone it hasn't searched before, it uses the list of name servers from the referral from the target zone's parent. If none of the name servers in that referral are reachable on the first try, a verification query to the parent would be pointless. It would come so quickly after the referral that it would almost certainly contain the same list of name servers. The chance of finding any new info is slim 😮‍💨

the other possibility is that the iterative resolver successfully contacts one of the target zone's name servers and then caches the NS RRSet from the authority section of a response. that's the proper behavior according to Section 5.4.1 of RFC 2181 [3], because the NS RRSet from the target zone is more trustworthy than delegation information from the parent zone 💅 Now, if a later recursive query finds that none of the name servers in the cached NS RRSet is available or authoritative, querying the parent would be wrong. An NS RRSet from the parent zone would now be less trustworthy than the data already in the cache 🚫

For that query to the parent to be useful, the target zone's entire set of name servers would have to change AND the old set would have to be deconfigured or decommissioned AND the delegation info in the parent zone would have to be updated with the new set, all within the Time to Live (TTL) of the target zone's NS RRSet. (that's a LOT of ifs 😩) We think this scenario is uncommon. Admin best practices say changes to a zone's name servers should happen gradually when at all possible, with servers removed from the NS RRSet staying authoritative for the zone for as long as possible 🫶 The scenarios we can picture that would benefit from the parent requery behavior just don't outweigh its damaging effects.

and no, this section does NOT claim that every query to a zone's parent is bad 🙈 some are not only reasonable but required. Imagine the address of a name server (the address record matching the RDATA of an NS record) has timed out of an iterative resolver's cache before the corresponding NS record did. If the name server's name is below the apex of the zone, then its address record is only available as glue in the parent zone. For example, take this NS record:

example.com.        IN   NS   ns.example.com.

if a cache has this NS record but not the address record for "ns.example.com", it can't contact the "example.com" zone directly, so it has to query the "com" zone to get that address record. Just note that such a query would not have QTYPE=NS under the standard resolution algorithm ✨

2.1.1. Recommendation

An iterative resolver MUST NOT send a query for the NS RRSet of a non-responsive zone to any of the name servers for that zone's parent zone. For the purposes of this rule, a non-responsive zone is a zone for which every name server listed in the zone's NS RRSet:

  1. is not authoritative for the zone (i.e., lame), or
  2. returns a server failure response (RCODE=2), or
  3. is dead or unreachable according to Section 7.2 of RFC 2308 [4].

2.2. Repeated Queries to Lame Servers

Section 2.1 covers a catastrophic failure: every name server for a zone can't provide an answer for one reason or another. A more common situation is when only some of a zone's name servers are unavailable or misconfigured 🌸 Different failure modes last for different amounts of time. Some symptoms point to problems that might be transient, like various kinds of ICMP unreachable messages (because a name server process isn't running, or a host or network is unreachable), or a total lack of response to a query. These can happen when a host reboots or there's a temporary outage. They don't necessarily need any human intervention and can reasonably be expected to be temporary 🧚

other symptoms clearly point to something that needs a human to step in, like lame server. If a name server is misconfigured and not authoritative for a zone delegated to it, it's reasonable to assume this problem could last way longer than unreachability or unresponsiveness 😤 So repeatedly querying known lame servers isn't useful. For a condition that could persist for a long time, a better practice is to keep a list of known lame servers and avoid querying them over and over in a short interval 🍓

it's also worth noting that some authoritative name server implementations only look lame for queries of certain types, as described in RFC 4074 [5]. In that case, it makes sense to retry the "lame" servers for other types of queries, especially when all known authoritative name servers look "lame" 👀

2.2.1. Recommendation

Iterative resolvers SHOULD cache name servers that they discover are not authoritative for zones delegated to them (i.e., lame servers). If this caching is done, lame servers MUST be cached against the specific query tuple <zone name, class, server IP address>. The zone name can be derived from the owner name of the NS record that was referenced to query the name server that was found to be lame 💖

Implementations that do lame server caching MUST refrain from sending queries to known lame servers for a configurable time interval after the server is discovered to be lame. A minimum interval of thirty minutes is RECOMMENDED ⏰

there's an exception to this. If all name servers for a zone are marked lame, the iterative resolver SHOULD temporarily ignore the servers' lameness status and query one or more of them. This behavior is a workaround for the type-specific lameness issue from the previous section 🩹

implementors, take care not to make lame server avoidance logic overly broad 🙏 A name server could be lame for a parent zone but not for a child zone. For example, it could be lame for "example.com" but properly authoritative for "sub.example.com". So a name server should not be automatically considered lame for subzones. In the example above, even if a name server is known to be lame for "example.com", it should be queried for QNAMEs at or below "sub.example.com" if an NS record says it should be authoritative for that zone 🫧

2.3. Inability to Follow Multiple Levels of Indirection

some iterative resolver implementations just can't follow enough levels of indirection 😵‍💫 For example, consider these delegations:

foo.example.        IN   NS   ns1.example.com.
foo.example.        IN   NS   ns2.example.com.

example.com.        IN   NS   ns1.test.example.net.
example.com.        IN   NS   ns2.test.example.net.

test.example.net.   IN   NS   ns1.test.example.net.
test.example.net.   IN   NS   ns2.test.example.net.

an iterative resolver resolving the name "www.foo.example" has to follow two levels of indirection. First it gets address records for "ns1.test.example.net" or "ns2.test.example.net", so it can get address records for "ns1.example.com" or "ns2.example.com", and then it can finally query those name servers for the address records of "www.foo.example" 🌀 I know, it looks contrived. But we've seen multiple similar cases, and we expect more as new generic top-level domains (gTLDs) go live. We also expect many zones in new gTLDs to use name servers in existing gTLDs, which will increase the number of delegations using out-of-zone name servers 🚀

2.3.1. Recommendation

building a delegation that relies on multiple levels of indirection is not a good admin practice 🙅‍♀️ However, it's common enough that iterative resolvers need to be able to cope with it. Iterative resolvers SHOULD be able to handle arbitrary levels of indirection resulting from out-of-zone name servers. Iterative resolvers SHOULD implement a level-of-effort counter to avoid loops or otherwise doing too much work on pathological cases 🧠

the best practice that avoids this whole indirection mess is to name one or more of a zone's name servers in the zone itself. For example, if the zone is named "example.com", consider naming some of the name servers "ns{1,2,...}.example.com" (or something similar) 👑

2.4. Aggressive Retransmission when Fetching Glue ✨

okay so when an authoritative name server gives back a referral, it stuffs NS records into the authority section of the response. Section 4.3.2 of RFC 1034 [2] says the name server should also "put whatever addresses are available into the additional section, using glue RRs if the addresses are not available from authoritative data or the cache." 💅 Some name server implementations take that address inclusion a step further with a feature called "glue fetching". A name server that does glue fetching tries to include address records for every NS record in the authority section. If it needs to, it sends out multiple queries of its own to grab any missing address records. 🧚

this is where it gets messy 🙈 Problems with glue fetching can pop up with "authoritative-only" name servers, which only serve authoritative data and ignore requests for recursion. Normally, an entity like that won't generate any queries of its own. It just answers non-recursive queries from iterative resolvers that are looking for info in the zones it serves. With glue fetching turned on, though, an authoritative server calls on an iterative resolver to look up an unknown address record so it can finish filling out the additional section of a response. 😭

we've seen situations where the iterative resolver of a glue-fetching name server can send queries that reach other name servers, but it's apparently blocked from receiving the responses. For example, the name server might be authoritative-only, so its admins expect it to receive only queries and never responses. Maybe they don't know about glue fetching and figure the iterative resolver won't send any queries, so they put the name server behind a network device that stops it from receiving responses. If that's the case, every glue-fetching query goes unanswered. 💀

we've also seen name server implementations whose iterative resolvers retry excessively when their glue-fetching queries go unanswered. A single com/net name server got hundreds of queries per second from one of these sources, literally hundreds 😭🔥 Based on the specific queries it received and some additional analysis, we believe these queries come from overly aggressive glue fetching. 👑

2.4.1. Recommendation

implementers whose name servers support glue fetching SHOULD take care to avoid sending queries at excessive rates. 🫶 Implementations SHOULD support throttling logic to detect when queries are sent but no responses are received. 🌸

2.5. Aggressive Retransmission behind Firewalls 🦋

this one is a real main character moment for the wrong reasons. A common occurrence, and one of the biggest sources of repeated queries at the com/net and root name servers, seems to come from resolvers sitting behind misconfigured firewalls. In this situation, an iterative resolver is apparently allowed to send queries through a firewall to other name servers, but it can't receive the responses. The result is more queries than necessary because of retransmission, and all of them are useless because the responses never arrive. Just like the glue-fetching scenario in Section 2.4, the queries are sometimes sent at excessive rates. 😩 It gets worse: sometimes the responses, which are sent in reply to legitimate queries, set off an alarm on the originator's intrusion detection system. We get contacted a lot by admins responding to those alarms, and they genuinely think our name servers are attacking their systems. 🙈

and it's not just a quick blip. Some resolvers in this situation retransmit queries at an excessive rate, and they keep doing it for days or even weeks. 💀 This could happen with an organization that has multiple recursive name servers, where only some of their iterative resolvers' traffic is improperly filtered like this. Stub resolvers in that organization could be configured to query multiple recursive name servers. Picture this: a stub resolver queries a filtered recursive name server first. That recursive name server's iterative resolver sends one or more queries whose replies get filtered out, so it can't respond to the stub resolver, which times out. Then the stub resolver retransmits to a recursive name server that can actually answer. Since resolution ultimately succeeds, the underlying problem might never get recognized or fixed. 🍓 A popular stub resolver implementation has a very aggressive retransmission schedule, including simultaneous queries to multiple recursive name servers, and that could explain how a situation like this can persist without anyone noticing. ✨

2.5.1. Recommendation

the most obvious recommendation is that administrators SHOULD take care not to place iterative resolvers behind a firewall that lets queries through but not the resulting replies. 🛡️

Iterative resolvers SHOULD take care to avoid sending queries at excessive rates. 💖 Implementations SHOULD support throttling logic to detect when queries are sent but no responses are received. 🎀

2.6. Misconfigured NS Records 🙃

sometimes a zone admin forgets the trailing dot on the domain names in the RDATA of a zone's NS records. 🤭 Here's a fragment of the zone file for "example.com" with the bug:

$ORIGIN example.com.
example.com.      3600   IN   NS   ns1.example.com  ; Note missing
example.com.      3600   IN   NS   ns2.example.com  ; trailing dots

the zone's authoritative servers will parse the NS RDATA as "ns1.example.com.example.com" and "ns2.example.com.example.com", and they'll return NS records with this incorrect RDATA in responses. That typically includes the authority section of every response with records from the "example.com" zone. 😬

now let's walk through a typical sequence of queries. An iterative resolver is trying to resolve address records for "www.example.com" and has no cached info for this zone, so it queries a "com" authoritative server. The "com" server responds with a referral to the "example.com" zone, made up of NS records with valid RDATA plus associated glue records. (This example assumes the "example.com" zone delegation info is correct in the "com" zone.) The iterative resolver caches the NS RRSet from the "com" server and follows the referral by querying one of the "example.com" authoritative servers. That server answers with the "www.example.com" address record in the answer section. Typically it also includes the "example.com" NS records in the authority section and, if there's still room in the message, glue address records in the additional section. 🌈 According to Section 5.4.1 of RFC 2181 [3], NS records in the authority section of an authoritative answer are more trustworthy than NS records from the authority section of a non-authoritative answer. So the "example.com" NS RRSet that just came from the "example.com" authoritative server overrides the "example.com" NS RRSet received moments ago from the "com" authoritative server. 🔄

but here's the plot twist: the "example.com" zone actually contains the erroneous NS RRSet shown in the example above. 😱 Later queries for names in "example.com" make the iterative resolver try to use those incorrect NS records, so it attempts to resolve the nonexistent names "ns1.example.com.example.com" and "ns2.example.com.example.com". In this example, all of the zone's name servers are named inside the zone itself (both "ns1.example.com.example.com" and "ns2.example.com.example.com" end in "example.com"), and they're all bogus. So the iterative resolver can't reach any "example.com" name servers. As a result, attempts to resolve these names turn into address record queries sent to the "com" authoritative servers. Queries for these obviously bogus glue address records happen frequently at the com/net name servers. 🥲

2.6.1. Recommendation

an authoritative server can detect this situation. 🔍 A trailing dot missing from an NS record's RDATA always results, by definition, in a name server name that exists somewhere under the apex of the zone the NS record appears in. Further levels of delegation are possible, though, so a missing trailing dot could accidentally create a name server name that actually exists in a subzone. 🧐

An authoritative name server SHOULD issue a warning when one of a zone's NS records references a name server below the zone's apex when a corresponding address record does not exist in the zone AND there are no delegated subzones where the address record could exist. ⚠️

2.7. Name Server Records with Zero TTL 🍼

sometimes a popular com/net subdomain's zone is set up with a TTL of zero on the zone's NS records. That stops these records from being cached, and it means way more query volume hitting the zone's authoritative servers. 📈 The zone's admin should understand the consequences of a setup like this and provision resources accordingly. 🧠 A zero TTL on the zone's NS RRSet also has consequences beyond the zone itself: if an iterative resolver can't cache a zone's NS records because of a zero TTL, it has to query that zone's parent's name servers every single time it resolves a name in the zone. 😵‍💫 The com/net authoritative servers really do see increased query load when a popular com/net subdomain's zone has a TTL of zero on its NS records. 💅

a zero TTL on an RRSet that's expected to change a lot is extreme, but it's allowed. 🤷‍♀️ A zone's NS RRSet is a special case, though, because changes to it have to be coordinated with the zone's parent. In most parent/child zone relationships we know about, there's usually some delay before changes take effect. Plus, changes to the set of a zone's authoritative name servers (and therefore to the zone's NS RRSet) are usually pretty rare, since reliable authoritative service needs a fairly stable set of servers. 🪨 So an extremely low or zero TTL on a zone's NS RRSet rarely makes sense, except when a change is coming up. In that case, if the zone's admin has planned a change and doesn't want iterative resolvers all over the Internet caching the NS RRSet for a long time, a low TTL is reasonable. 🦋

2.7.1. Recommendation

because a zero TTL on a zone's NS RRSet puts extra load on the zone's parent's authoritative servers, authoritative name servers SHOULD issue a warning when loading a zone under those circumstances. 🚨 and that's the tea for this section 💖

2.8. Unnecessary Dynamic Update Messages 💌

The UPDATE message specified in RFC 2136 [6] lets an authorized agent update a zone's data on an authoritative name server by sending a DNS message over the network. Picture an agent that wants to add a particular resource record. Because of zone cuts, the agent doesn't necessarily know which zone the record belongs in. The dynamic update process needs the agent to work out the appropriate zone so the UPDATE message can go to one of that zone's authoritative servers (typically the primary master, as listed in the MNAME field of the zone's Start of Authority (SOA) record). 🧭

The appropriate zone is the closest enclosing zone, and you can't figure that out just by looking at the domain name of the record, since zone cuts can pop up anywhere 🙃. One way to find it is to walk up the name space tree, sending repeated UPDATE messages until one succeeds. Say an agent is trying to add an address record named "foo.bar.example.com". It could first try the "foo.bar.example.com" zone. If that fails, it could aim at "bar.example.com", then "example.com", then "com", and finally the root zone.

A popular dynamic agent does exactly this, and the result is a flood of UPDATE messages landing on the root name servers, the com/net authoritative servers, and presumably other TLD authoritative servers 😭. Why does the algorithm keep going all the way up to the TLD and root servers? Honestly, that's not totally unreasonable: in enterprise DNS setups with an "internal root" design, there could be private, non-public TLD or root zones that are the right target for a dynamic update 🏢.

The big flaw is that learning one UPDATE message failed doesn't help the agent point future UPDATE messages at the right servers. A better move is to find the closest enclosing zone by walking up the name space with queries for SOA or NS, instead of "probing" with UPDATE messages ✨. Once the right zone is found, send the UPDATE. You can also cache the results of those queries to help find closest enclosing zones for future updates. And once the closest enclosing zone is found this way, the update will either succeed or fail, so there's no reason to keep sending updates to higher-level zones. The key point: walking up the tree with queries gives you cacheable info, but walking up with UPDATE messages does not. 💅

2.8.1. Recommendation 🎀

Dynamic update agents SHOULD send SOA or NS queries to progressively higher-level names to find the closest enclosing zone for a given name to update. Only after the appropriate zone is found should the client send an UPDATE message to one of the zone's authoritative servers. Update clients SHOULD NOT "probe" using UPDATE messages by walking up the tree to progressively higher-level zones.

2.9. Queries for Domain Names Resembling IPv4 Addresses 🔢

The root name servers get a LOT of A record queries where the QNAME looks like an IPv4 address. Nobody's totally sure where they come from 🤷‍♀️. One theory: a user thinks an app will accept either a domain name or an IP address in some configuration option, types in an IP address, and the app assumes everything is a domain name and tries to resolve it, which produces an A record lookup. Other apps might send these queries while misguidedly trying to reverse map IP addresses.

These queries get Name Error (RCODE=3) responses. An iterative resolver can negatively cache those responses, but each one needs its own cache entry. A negative cache entry for the domain name "192.0.2.1" does not stop a later query for the domain name "192.0.2.2" 🙄.

2.9.1. Recommendation 🌸

It would be desirable for the root name servers not to have to answer these queries, since they're burning CPU and bandwidth for nothing 🥲. One possible fix is to delegate these numeric TLDs from the root zone to a separate set of servers that soak up the traffic. The "black hole servers" used by the AS 112 Project (http://www.as112.net), which are currently delegated the in-addr.arpa zones corresponding to RFC 1918 [7] private use address space, would be a possible choice to receive these delegations. Of course, the proper and usual root zone change procedures would have to be followed to make such a change to the root zone.

2.10. Misdirected Recursive Queries 🧭

The root name servers receive a significant number of recursive queries (i.e., queries with the Recursion Desired (RD) bit set in the header). None of the root servers offers recursion, so they ignore the request for recursion, and the response probably doesn't contain the data the querier was hoping for. Some of these queries come from users configuring stub resolvers to query a root server. (This isn't hypothetical: we've gotten complaints from users when this setup doesn't work the way they hoped 📩.) Users obviously shouldn't point stub resolvers at name servers that don't offer recursion, but we're not aware of any stub resolver implementation that gives feedback to the user when configured that way, aside from just "not working" 😩.

2.10.1. Recommendation 💜

When the IP address of a name server that supposedly offers recursion is configured in a stub resolver using an interactive user interface, the resolver could send a test query to verify that the server actually supports recursion (i.e., verify that the response has the RA bit set in the header). The user could be notified right away if the server is non-recursive.

The stub resolver could also report an error, either through a user interface or in a log file, if the queried server doesn't support recursion. Error reporting SHOULD be throttled to avoid a notification or log message for every response from a non-recursive server.

2.11. Suboptimal Name Server Selection Algorithm 🎯

An entire document could be devoted to problems with different implementations of the recursive resolution algorithm. Recursion is woefully under-specified, so every implementor has to design their own algorithm 😤. Implementors sometimes make poor design choices that could have been avoided if a suggested algorithm and best practices were documented, but that's a topic for another document.

Some deficiencies cause significant operational impact and are worth mentioning here. One of these is name server selection by an iterative resolver. When an iterative resolver wants to contact one of a zone's authoritative name servers, how does it choose from the NS records listed in the zone's NS RRSet? If the selection mechanism is suboptimal, queries aren't spread evenly among a zone's authoritative servers 📉. The details of the selection mechanism are up to the implementor, but we've got some suggestions.

2.11.1. Recommendation ⭐

This list isn't conclusive, but it reflects the changes that would produce the most impact in terms of reducing disproportionate query load among a zone's authoritative servers. In other words, these changes would help spread the query load evenly.

  • Do not make assumptions based on NS RRSet order: all NS RRs SHOULD be treated equally. (In the case of the "com" zone, for example, most of the root servers return the NS record for "a.gtld-servers.net" first in the authority section of referrals. Apparently as a result, this server receives disproportionately more traffic than the other twelve authoritative servers for "com".)
  • Use all NS records in an RRSet. (For example, we are aware of implementations that hard-coded information for a subset of the root servers.)
  • Maintain state and favor the best-performing of a zone's authoritative servers. A good definition of performance is response time. Non-responsive servers can be penalized with an extremely high response time.
  • Do not lock onto the best-performing of a zone's name servers. An iterative resolver SHOULD periodically check the performance of all of a zone's name servers to adjust its determination of the best-performing one.

3. Security Considerations 🔐

The iterative resolver misbehavior discussed in this document exposes the root and TLD name servers to increased risk of both intentional and unintentional Denial of Service attacks. 🚨 Bestie, this one is serious: bad resolver behavior can knock over root and TLD servers, whether someone does it on purpose or it happens by accident.

We believe that implementation of the recommendations offered in this document will reduce the amount of unnecessary traffic seen at root and TLD name servers, thus reducing the opportunity for an attacker to use such queries to their advantage. Less junk traffic means fewer openings for attackers 🛡️.

4. Acknowledgements 🫶

The authors would like to thank the following people for their comments that improved this document: Andras Salamon, Dave Meyer, Doug Barton, Jaap Akkerhuis, Jinmei Tatuya, John Brady, Kevin Darcy, Olafur Gudmundsson, Pekka Savola, Peter Koch, and Rob Austein. We apologize if we have omitted anyone; any oversight was unintentional. 💖

5. Internationalization Considerations 🌍

There are no new internationalization considerations introduced by this memo.

6. References 📚

6.1. Normative References

  • [1] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
  • [2] Mockapetris, P., "Domain names - concepts and facilities", STD 13, RFC 1034, November 1987.

6.2. Informative References

  • [3] Elz, R. and R. Bush, "Clarifications to the DNS Specification", RFC 2181, July 1997.
  • [4] Andrews, M., "Negative Caching of DNS Queries (DNS NCACHE)", RFC 2308, March 1998.
  • [5] Morishita, Y. and T. Jinmei, "Common Misbehavior Against DNS Queries for IPv6 Addresses", RFC 4074, May 2005.
  • [6] Vixie, P., Thomson, S., Rekhter, Y., and J. Bound, "Dynamic Updates in the Domain Name System (DNS UPDATE)", RFC 2136, April 1997.
  • [7] Rekhter, Y., Moskowitz, B., Karrenberg, D., de Groot, G., and E. Lear, "Address Allocation for Private Internets", BCP 5, RFC 1918, February 1996.

Authors' Addresses 📮

Matt Larson
VeriSign, Inc.
21345 Ridgetop Circle
Dulles, VA  20166-6503
USA

EMail: mlarson@verisign.com


Piet Barber
VeriSign, Inc.
21345 Ridgetop Circle
Dulles, VA  20166-6503
USA

EMail: pbarber@verisign.com

Copyright (C) The Internet Society (2006).

This document is subject to the rights, licenses and restrictions contained in BCP 78, and except as set forth therein, the authors retain all their rights.

This document and the information contained herein are provided on an "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Intellectual Property ✨

okay so this section is the legal-ish bit, but it's giving very honest energy 💅 The IETF is NOT picking a side on whether any Intellectual Property Rights or other rights that someone might claim over the tech in this document are valid or how far they reach 🙈 It also doesn't claim it went looking for every single one of those rights, so no promises there. And whether any license under those rights is available, or isn't, is also not something they're deciding here. If you want the rules about rights in RFC documents, check out BCP 78 and BCP 79 📚🫶

Next, if you want to see IPR disclosures that were sent to the IETF Secretariat, or any licenses people promised to make available, or what happened when someone tried to get a general license or permission to use those proprietary rights as an implementer or user of this spec, you can look at the IETF online IPR repository at http://www.ietf.org/ipr 🦋 Total main character energy for anyone doing their homework 🎀

And the IETF is literally inviting anyone who's interested to speak up 📣 If you know about any copyrights, patents, patent applications, or other proprietary rights that might cover technology you'd need to implement this standard, tell them! Send it to ietf-ipr@ietf.org 💌 The whole point is that everyone can see what's out there before they build stuff 🌈

Acknowledgement

okay quick shoutout 🫶 The RFC Editor function gets its funding from the IETF Administrative Support Activity (IASA) 💖 Without that support, the people keeping these documents tidy and published wouldn't have the resources to do it, so this one's a thank you to IASA ✨

📦 where this page comes from