11/16/2026 | Press release | Distributed by Public on 11/16/2026 01:10
The Domain Name System Operations, Analysis, and Research Center (DNS-OARC) held its 47th meeting in Vancouver in early November 2026. For those of us who have fallen deeply into the DNS rabbit hole, two full days of DNS topics is barely enough! These meetings provide a concentrated overview of the current hot topics in today's DNS. Here are a few highlights that I found interesting.
A cuckoo filter
A lot can be learned from analysing DNS traffic. Almost every network transaction starts with a call to the DNS to transform the name of a service into some form of network address. It's a close-to-universal service, and it's used for all kinds of purposes from service delivery in consumer environments through to orchestration of malicious botnet swarms, and everything in between. Little wonder that some see the DNS as a rich vein of information about network activity, while others see it as a control point, and others see it as the first line of defence in a hostile world. In the world of generating threat intelligence, the DNS is an essential input.
The key action here is to be able to gather and analyse the stream of queries - the names being queried, the resource records being sought, who is asking and when and where they are asking, and the answer they received. The larger the dataset being analysed, the better the analytic results that can be obtained, but at some stage the sheer size of the data feed presents a major challenge. The Quad9 open recursive resolver isn't the largest recursive resolver service in today's Internet. The data flows generated by its query streams, however, are still impressively large, and the tools used to store and query this dataset are becoming highly specialized.
Quad9's John Todd reported on their investigation of a 'cuckoo filter'. They aim to:
A cuckoo filter can respond with complete certainty when a queried name is not in the stored set, but cannot say with certainty that the name is in the set. The probability of false positive answers is a function of the selectable bit size of the fingerprint of the object. The larger the fingerprint, the lower the probability of these false positives.
Quad9 is looking at further development of this approach, with functions such as a Least Recently Used (LRU) storage regime with cache entry deletion and insertion, and a Time To Live (TTL) on stored entries. The first reports for this tool are surprisingly efficient:
This tool opens some interesting analytic possibilities, including tracking newly observed domains, changes in name properties, name string similarities, and identification through name properties.
Presentation: Cuckoo Clock
Chasing milliseconds in DNS resolution
There is a classic dilemma in DNS system design in large-scale customer networks. The closer you can provision the resolver to the customer, the lower the latency, but the smaller the cache hit rate as the resolver is serving a smaller population of end clients. A resolver positioned deeper in the network will have a higher query load and a better cache hit rate, but - because it's positioned deeper in common network infrastructure - it's likely to be further away and hence have higher latency.
The result of pushing the caches closer to the edge is a compromise between latency and cache hit rates. Comcast is reporting a very respectable 10ms latency to reach the resolver cache, which is an impressive result in deployment engineering for an extensive network.
Presentation: ISP Customer DNS on Edge Compute
Cat and mouse resolution
DNS configurations lay a trail that resolvers must follow. One such trail is the label sequence in a DNS name. Less well-ordered trails include the alias records in CNAMEs, and the resolution of nameservers into IP addresses when the glue records cannot be trusted or do not exist. These configuration structures cause the resolver to begin a new resolution task, and can be used to cause a processing load on resolvers. The presentation by Cisco's DNS group shows eight examples where resolution causes effort that can never lead to a completed resolution (Figure 2).
Resolvers use a set of controls to defend their integrity. They often keep a record of the CNAMEs that have been encountered in a resolution task and call a halt as soon as a repeated name is encountered. They also keep a count of the number of CNAMEs in a resolution task and stop when an upper limit is reached. There is typically an overall time and work budget for each name resolution task, and resolution is halted when the available budget is consumed. If a resolution task is terminated in this manner, then the original name is also cached for a small number of seconds by the resolver so that repetitions of this name resolution task can be immediately recognized and stopped.
The conclusion from this presentation is that stopping a loop is not the same as stopping the cost imposed on the resolver, and stopping repeated work is more critical to overall resolver performance and capacity than detecting the loop.
Presentation: Beyond Loop Limits
Look, no NS!
It was reported earlier this year in a presentation by ISC's Ondrej Sury that the Bind recursive resolver has switched to a parent-centric delegation model. The nameserver (NS) delegation records in the DNS are part of the delegated (child) zone, but are copied into the parent zone. A cautious resolver would follow one of these copied delegation records in the parent zone, as it has no choice, but would then retrieve the same records from the child zone as the authoritative record of the delegation.
This change to the Bind code did away with these additional queries, as they appeared to offer no benefit. If the parent record was corrupted to mislead the resolver, then the damage was already done when the record was retrieved and used to query the child zone. The query into the fake child record would also give the same misleading records.
So, while it is considered good DNS housekeeping for a child zone to contain resource records, it is of no practical value (with a caveat we'll consider). As Shane Kerr reported in a small experiment using a zone without NS records, none of the open recursive resolvers objected to missing records in the child zone.
There is an ongoing debate about this approach, with two drafts on this practice in the Internet Engineering Task Force (IETF). One draft describes how recursive resolvers should adopt this parent-centric delegation model. The other draft describes delegation checking (termed 'revalidation') using child zone data and proposes that a resolver that fetches these child zone records should also validate that they are DNS Security Extensions (DNSSEC) signed. I suspect that, as with many such debates relating to choices between correctness and expedience, the expedient option will become the default practice.
This highlights a deeper issue in the DNS about the nature of security protection offered by DNSSEC. Correctly configured, DNSSEC validation of a response from a signed zone ensures that the only names that are resolved and locally cached are resolved to a validated value. But that simply means that the answer is authentic.
DNSSEC does not protect how that response was obtained, nor does it constrain the set or parties that may be queried while the resolver discovers the nameservers for the queried zone. The delegation data in parent-centric resolvers is not DNSSEC-signed. It is feasible for an on-the-wire interception attack, and DNSSEC does not require that these delegation referrals or the IP addresses of nameservers be separately validated. DNSSEC validates the answer, not where and how you might have obtained the answer.
For a DNSSEC-signed zone, an interception attack cannot lead to a false answer being accepted (assuming that the keys have not been compromised), as this would not pass validation. It can lead to queries being passed to third parties. The assertion that Wes Hardaker made in his presentation is that if we use child-centric delegation, then the child zone's record is signed and can be directly validated. That way efforts to rewrite intercepted records can be detected.
This is certainly true, but it is a major shift in DNSSEC validation practices. Such an additional measure would impose its own incremental costs in performing this validation of each child-zone signed delegation () record. This also leads to consideration of the proposed signed parent-centric record.
It's certainly possible to take a very cautious view of the DNS to minimize the exposure of an end user when making DNS queries and minimize the risk of misdirection and third-party inspection. Such a cautious approach would use oblivious DNS over HTTPS (RFC 9230), query name minimization (RFC 9196), perform DNSSEC validation of every delegation using the child-centric NS record, and use transport encryption to deflect efforts at on-the-wire interception.
Should a general-use DNS resolver be designed to meet the most stringent of security standards under all circumstances? Or does the incremental cost in terms of additional processing, queries, and delay make such an approach completely impractical in a standard retail ISP context? Can individual users opt out of a standard DNS offering and use a more stringently specified resolution environment?
Even today the answer is 'yes', and users can define a custom DNS resolution environment that both obscures DNS queries from inspection and interception and validates all data before using it. With significant effort.
Presentations: NO NS!, Subverting Resolution
DNS resolution misbehaviour
We might prefer to deploy DNS name resolution systems that are efficient and fast, but we don't always get what we want! This APNIC Labs study looked at the number of queries received for a non-existent name, using our measurement platform to perform 116M tests over a broad sampling of end users drawn from across the global Internet during seven days in August 2026. The methodology included presenting each user with a unique DNS name to resolve, so that DNS resolver caching behaviour was deliberately bypassed. The result of these 116M tests was a total of 513M queries received by the authoritative nameservers, or an average of 4.43 queries per unique name. This is a repetition of a similar experiment undertaken in 2019, when the query multiplication factor was 2.37.
The causes for this increased query load can be traced to a strict limit in DNS to only ask for one resource record type per query. If an application wants to learn the IPv4 and IPv6 address records for the named resource, then that's two queries performed back-to-back. Additionally, we've introduced the HTTPS service records, which can provide the service's preferred application access protocol.
The use of these additional query types still does not explain all the increase in query volume, and in particular the increase in duplicate queries that are received within the first 10ms of the initial query. One plausible explanation is the widespread use of DNS load balancers in the large-scale ISP industry, and some observed preference of these front-end systems to duplicate queries to minimize the delay impact of query/response drop within the backend server set.
What is perhaps less obvious is that among the five different ways to respond negatively to a query, the level of query duplication varies considerably. Returning the code is about as bad as simply refusing to respond at all! The conventional response is more efficient than answering positively. Details are shown in Figure 3.
Presentation: DNS Resolution Behaviour (DNS Measurement)
Quantum computing and DNSSEC
It has been known for many years that quantum computers could break so-called classical encryption algorithms in a fraction of the time needed for conventional computers. Many took comfort in the comforting assessment that the engineering required to create a large-scale quantum computer with millions, or even billions, of qubits that could be held stable for more than a few fractions of a second was decades away. That comforting belief appears to have been undermined. There is an increasing view from quantum pundits that it's time to take the use of post-quantum cryptography in DNS far more seriously than we have in the past.
Where there is a requirement for integrity of the encrypted data for many decades to come, then the time to take post-quantum cryptography seriously has already come. For digital signatures, it's also time to move.
The core cryptography standards, ML-KEM, ML-DSA and SLH-DSA, appear to be settled, and ML-KEM is enabled by default across major browsers, operating system Transport Layer Security (TLS) libraries and other encryption-sensitive applications.
In the world of DNSSEC, there is uncertainty about this potential shift to post-quantum cryptography. A presentation by Cloudflare's Vicky Shrestha made the assertion that "we are hostages in a siege of response size paranoia". Or, to put it another way, from Verisign's Matt Thomas, "The DNS has always been shaped by what fits in a packet."
User Datagram Protocol (UDP) could carry this payload, but IP fragmentation is unreliable. Transmission Control Protocol (TCP) could carry this payload, but there are concerns about unreliability and overhead in maintaining a TCP state on authoritative servers. In another quote from the same Cloudflare presentation : "This is why people joke about replacing the DNS protocol altogether, but they have a haunted look in their eye while they are choking back their tears."
Early measurement efforts to assess the viability of using ML-DSA 44 (algorithm 18) point to widespread evidence of breakage. It's reasonable to expect that the initial steps along the post-quantum path will be somewhat tentative, and the initial models will be likely to be opt-in in some form.
OpenSSL introduced native support for ML-DSA-44 as of version 3.5, but that is just part of the initial steps of a longer journey. Work is needed on standardized DNS specifications, DNS provisioning protocol specifications, and signing and validation tools. We need to review the capability to support TCP everywhere in the DNS, and to accept large payloads in both servers and resolvers. We need to understand the impact of widespread use of stateful TCP sessions in the DNS, particularly in the resolver-to-server connections, and how the DO bit is interpreted in the context of a TCP response.
When considering TCP and scale, we must also consider the proliferation of front-end load balancing systems to spread a large query load across a local farm of recursive resolvers or authoritative servers. If the resolver client keeps the TCP session open - which would be a natural behaviour to reduce the session setup cost against multiple queries - then the front end has limited ability to re-route this session to a different back-end server. TLS and QUIC sessions are potentially harder to switch between back-end servers. This may result in unexpected transient bottlenecks in the server environment. There is also a behaviour difference between TCP and UDP. When a server reaches its TCP limit, no new connections are accepted, while the load under UDP relates to simpler individual packet loss.
It may be tempting to take comfort in the idea that we already know how to support DNS over TCP. The way we manage the DNS query load will not map cleanly into TCP. Supporting TCP when TCP is used for less than 1% of queries is different to using TCP for every query with the bit set that today approaches 60% of queries.
Presentation: Measuring PQ DNSSEC performance
Counting the use of NSEC and NSEC3 in the DNS
I must admit to a significant level of personal bias when reviewing DNS measurement presentations that look at the measured properties of DNS zones, such as this presentation that looks at the use of various forms of negation in DNSSEC. A small number of names and zones are used by billions of Internet users continually (think of the name 'google.com'), while the long tail is used at a significantly lower level of query intensity. Calculating averages across this highly skewed profile can often generate misleading conclusions.
There appear to be two approaches to serving a DNSSEC-signed zone, and some hybrids between them.
One approach is to preprocess a complete zone file and add signature records in this preprocessing phase, and then serve the zone, with its signatures, in a conventional manner. The other basic choice is to attach a signature record as the final processing step of generating a response.
For positive responses, there is little semantic difference between these two approaches, but for negative responses there are some major differences. In a pre-signing mode, the signer does not know in advance the query name that does not exist, so it can only answer in terms of the names that are defined in the zone. The record is used to sign the span between two 'adjacent' names in a zone and thereby claim in a verifiable manner that all names that fall between these two names do not exist. is a minor variation that obscures the order of names in the zone to prevent zone enumeration, but it's otherwise the same. A dynamic signer has access to the query name, and the signer can construct a signed response that specifically asserts that the queried name does not exist.
Recursive resolvers can aggressively cache and records to defend authoritative servers against random name attacks, as the cached records can answer all queries that fall within the defined name span of the record. Dynamic signing using records, or with cannot use the same level of assistance from recursive resolvers, and the random name attacks generate additional passes through the cryptographic signer for every query. It is more straightforward to use multiple providers to serve a pre-signed zone than a dynamically signed zone.
The choice of signing design and negative response technology depends on the specific circumstances of the zone. Accordingly, I find the metrics and averages in this presentation extremely challenging to put into a useful and informative context.
Presentation: Dissecting NSEC and NSEC3 Deployment in the Wild
Recursive-to-authoritative DNS channel encryption
The effort to encrypt all DNS communications appeared to lose interest once the work on stub-to-recursive channel encryption took off. The IETF specified DNS over TLS (RFC 7858, RFC 8310), DNS over HTTPS (RFC 8484) and DNS over QUIC (RFC 9250) in short order. Normally, the overheads of setting up the encrypted channel would be too high for an application that prefers lightweight UDP stateless packet exchange, but in a stub-to-recursive scenario the initial connection overhead can be spread over the subsequent queries. A streaming protocol that does not exhibit Head-of-Line blocking, such as DNS over QUIC and DNS over HTTPS/3 (that uses QUIC), can be as efficient as UDP.
The recursive-to-authoritative channel is different. There is no end user IP address in these DNS queries, so the privacy issues are not as acute. A recursive-to-authoritative data channel would not normally be persistent, so the overheads of channel setup, as compared to the query and response transaction, would be an issue. Also, if the channel capabilities of the server were not known in advance, then the resolver client would need to detect these capabilities by probing, which would take more time.
There are a few ways we can signal the capabilities of the server. One way is by using the proposed DELEG record that contains the capabilities of the server in the parent zone. Another approach is to associate the transport capabilities of the server with the server's name in a service binding transport hint, and use the record as an opportunistic additional inserted record in the Additional section of a response.
I must admit that this opportunistic approach to transport signalling seems a whole lot more sensible to me. It does not need a massive change to one of the fundamental properties of the DNS, delegation, and it can be adopted incrementally. This seems like a precise solution to a precisely bounded problem!
Presentation: OOTS
Stop ANY
The DNS is a one-trick pony - you send a query, and you get a response. That's it. No ping. No control channel. None of that. However, there is one special query type: ANY.
It had been assumed that ANY was analogous to a mythical ALL query type, returning all defined RRsets for a given query name. Indeed, it was sometimes used as a single query replacement for querying for A and AAAA RRsets.
However, the same ANY query has been used in DNS amplification attacks with spoofed source addresses and UDP transport, as the query is generally far smaller than the response. This attack vector has led to some servers returning a minimal response to ANY queries (RFC 8482). RFC 8482 proposed that DNS responders could opt to send a smaller response than the complete collection of RRsets for a name, and suggested three possible responses:
There is an attractive alternative: To simply decline to respond to an ANY query using a NOTIMPL (not implemented) response code, which is what is being proposed in a current Internet draft.
Presentation: Stop ANYthing
DNS OARC47
There were many other presentations and discussions at this workshop. A complete record of the presentations over the two days can be found at the workshop's website.
The views expressed by the authors of this blog are their own and do not necessarily reflect the views of APNIC. Please note a Code of Conduct applies to this blog.