Full Toolkit for Next-Level Domain Analysis
Detect DNS referral loops and count shared requests once πͺπ (#123)
Felix Wotschofsky2b09e3b47ebd
diff --git a/lib/resolvers/authoritative-walk.test.ts b/lib/resolvers/authoritative-walk.test.tsnew file mode 100644index 0000000..6970a33--- /dev/null+++ b/lib/resolvers/authoritative-walk.test.ts@@ -0,0 +1,473 @@+// @vitest-environment node+import type { Answer, DecodedPacket } from 'dns-packet';+import { describe, expect, it, vi } from 'vitest';++import { UserFacingError } from '../user-facing-error';+import {+ AuthoritativeResolver,+ type AuthoritativeUdpTransport,+} from './authoritative';+import type { RecordType } from './base';++const reply = (+ name: string,+ type: RecordType,+ answers: Answer[] = [],+): DecodedPacket =>+ ({+ type: 'response',+ id: 1,+ questions: [{ name, type }],+ answers,+ authorities: [],+ additionals: [],+ rcode: 'NOERROR',+ flag_aa: true,+ }) as unknown as DecodedPacket;+// Authoritative NODATA carrying the zone's SOA and NS (RFC 2308 type 1).+const nodata = (name: string, type: RecordType, zone: string, host: string) =>+ ({+ ...reply(name, type),+ authorities: [+ {+ name: zone,+ type: 'SOA',+ ttl: 300,+ data: {+ mname: host,+ rname: `hostmaster.${zone}`,+ serial: 1,+ refresh: 300,+ retry: 300,+ expire: 300,+ minimum: 300,+ },+ },+ { name: zone, type: 'NS', ttl: 300, data: host },+ ],+ }) as DecodedPacket;+const address = (name: string, data = '203.0.113.10'): Answer => ({+ name,+ type: 'A',+ ttl: 300,+ data,+});+const referral = (+ name: string,+ type: RecordType,+ zone: string,+ hosts: string[],+ ips: string[] = [],+): DecodedPacket => ({+ ...reply(name, type),+ flag_aa: false,+ authorities: hosts.map((host) => ({+ name: zone,+ type: 'NS',+ ttl: 300,+ data: host,+ })),+ additionals: ips.map((ip, i) => address(hosts[i], ip)),+});++describe('AuthoritativeResolver walk bounds', () => {+ it('can retry a transient transport failure in a new top-level walk', async () => {+ let available = false;+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType }) => {+ if (!available) throw new Error('temporary transport failure');+ return reply(domain, recordType, [address(domain)]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveRecordType('example.com', 'A'),+ ).rejects.toBeInstanceOf(UserFacingError);+ available = true;+ await expect(+ resolver.resolveRecordType('example.com', 'A'),+ ).resolves.toMatchObject({+ records: [expect.objectContaining({ data: '203.0.113.10' })],+ });+ expect(udpTransport).toHaveBeenCalledTimes(5);+ });++ it('stops self-referrals and still tries the healthy sibling', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver === '192.0.2.1')+ return referral(+ domain,+ recordType,+ 'example.com',+ ['ns1.example.net', 'ns2.example.net'],+ ['8.8.8.8', '9.9.9.9'],+ );+ if (nameserver === '8.8.8.8')+ return referral(+ domain,+ recordType,+ 'example.com',+ ['ns1.example.net'],+ ['8.8.8.8'],+ );+ return reply(domain, recordType, [address(domain)]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ const result = await resolver.resolveRecordType('www.example.com', 'A');+ expect(result.records[0].data).toBe('203.0.113.10');+ expect(result.trace.join('\n')).toMatch(/referral loop/i);+ expect(udpTransport).toHaveBeenCalledTimes(3);+ });++ it('stops a circular glueless dependency before it starves a slower sibling', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ await new Promise((resolve) => setTimeout(resolve, 20));+ if (nameserver === '192.0.2.1') {+ if (domain.endsWith('.c.test'))+ return referral(+ domain,+ recordType,+ 'c.test',+ ['ns.c.test'],+ ['8.8.4.1'],+ );+ // a.test and b.test name each other's servers, without glue.+ if (domain.endsWith('.b.test'))+ return referral(domain, recordType, 'b.test', [+ 'ns1.a.test',+ 'ns2.a.test',+ ]);+ return referral(domain, recordType, 'a.test', [+ 'ns1.b.test',+ 'ns2.b.test',+ 'h.deep.c.test',+ ]);+ }+ // The healthy NS needs more round trips than the cycle takes to warm.+ if (nameserver === '8.8.4.1')+ return referral(+ domain,+ recordType,+ 'deep.c.test',+ ['ns.deep.c.test'],+ ['8.8.4.2'],+ );+ if (nameserver === '8.8.4.2')+ return reply(domain, recordType, [address(domain, '8.8.8.8')]);+ if (nameserver === '9.9.9.9')+ return reply(domain, recordType, [address(domain, '8.8.8.8')]);+ return reply(domain, recordType, [+ address(+ domain,+ domain.startsWith('www.') ? '203.0.113.10' : '9.9.9.9',+ ),+ ]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveRecordType('www.a.test', 'A'),+ ).resolves.toMatchObject({+ records: [expect.objectContaining({ data: '203.0.113.10' })],+ });+ });++ it('treats authoritative negative answers with SOA and NS as terminal', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver === '192.0.2.1')+ return referral(+ domain,+ recordType,+ 'example.com',+ ['ns1.example.net'],+ ['8.8.8.8'],+ );+ return nodata(domain, recordType, 'example.com', 'ns1.example.net');+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveRecordType('www.example.com', 'AAAA'),+ ).resolves.toMatchObject({ records: [] });+ expect(udpTransport).toHaveBeenCalledTimes(2);+ });++ it('tries a sibling when a lame server answers from a zone above the cut', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver === '192.0.2.1')+ return referral(+ domain,+ recordType,+ 'sub.example.com',+ ['c.example.net', 'd.example.net'],+ ['8.8.8.8', '9.9.9.9'],+ );+ // Lame for sub.example.com, authoritative only for its parent.+ if (nameserver === '8.8.8.8')+ return nodata(domain, recordType, 'example.com', 'c.example.net');+ return reply(domain, recordType, [address(domain)]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveRecordType('www.sub.example.com', 'A'),+ ).resolves.toMatchObject({ records: [{ data: '203.0.113.10' }] });+ });++ it('asks a sibling parent for DS when another refers it to the child apex', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver === '192.0.2.1')+ return referral(+ domain,+ recordType,+ 'example.com',+ ['p1.example.net', 'p2.example.net'],+ ['8.8.8.8', '9.9.9.9'],+ );+ // A DS-unaware parent server refers the query to the child.+ if (nameserver === '8.8.8.8')+ return referral(+ domain,+ recordType,+ 'sub.example.com',+ ['ns1.example.org'],+ ['1.1.1.1'],+ );+ if (nameserver === '9.9.9.9')+ return reply(domain, recordType, [+ {+ name: domain,+ type: 'DS',+ ttl: 300,+ data: {+ keyTag: 1,+ algorithm: 13,+ digestType: 2,+ digest: Buffer.from('ab', 'hex'),+ },+ },+ ]);+ // The child apex answers its own DS with NODATA.+ return nodata(domain, recordType, 'sub.example.com', 'ns1.example.org');+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveAnswers('sub.example.com', 'DS'),+ ).resolves.toMatchObject({+ answers: [expect.objectContaining({ type: 'DS' })],+ zone: 'example.com',+ });+ });++ it('asks a sibling parent for DS when another answers it from the child zone', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver === '192.0.2.1')+ return referral(+ domain,+ recordType,+ 'example.com',+ ['p1.example.net', 'p2.example.net'],+ ['8.8.8.8', '9.9.9.9'],+ );+ // A DS-unaware parent server also hosting the child answers from it.+ if (nameserver === '8.8.8.8')+ return nodata(+ domain,+ recordType,+ 'sub.example.com',+ 'p1.example.net',+ );+ return reply(domain, recordType, [+ {+ name: domain,+ type: 'DS',+ ttl: 300,+ data: {+ keyTag: 1,+ algorithm: 13,+ digestType: 2,+ digest: Buffer.from('ab', 'hex'),+ },+ },+ ]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveAnswers('sub.example.com', 'DS'),+ ).resolves.toMatchObject({+ answers: [expect.objectContaining({ type: 'DS' })],+ zone: 'example.com',+ });+ });++ it('keeps a spent step budget user-facing after a cached delegation fails', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ const layer = Number(domain.match(/layer(\d+)/)?.[1] ?? 0);+ if (nameserver === '192.0.2.1' && !layer)+ return referral(+ domain,+ recordType,+ 'evil.test',+ ['ns1.evil.test', 'ns2.evil.test'],+ ['8.8.8.8', '9.9.9.9'],+ );+ if (nameserver === '8.8.8.8' && recordType === 'A')+ return reply(domain, recordType, [address(domain)]);+ // A non-authoritative answer from the stale cached delegation must+ // not win just because the step budget ran out.+ if (nameserver === '9.9.9.9')+ return {+ ...reply(domain, recordType, [address(domain, '198.51.100.66')]),+ flag_aa: false,+ } as DecodedPacket;+ // Every further hop forks into four glueless NS names.+ return referral(+ domain,+ recordType,+ domain,+ [1, 2, 3, 4].map((n) => `ns${n}.layer${layer + 1}.test`),+ );+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await resolver.resolveRecordType('www.evil.test', 'A');+ await expect(+ resolver.resolveRecordType('www.evil.test', 'TXT'),+ ).rejects.toBeInstanceOf(UserFacingError);+ });++ it('bounds processing when a small shared request graph forks exponentially', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType }) => {+ const layer = Number(domain.match(/layer(\d+)/)?.[1] ?? 0);+ if (layer === 10)+ return reply(domain, recordType, [address(domain, '8.8.8.8')]);+ return referral(+ domain,+ recordType,+ domain,+ [1, 2, 3, 4].map((n) => `ns${n}.layer${layer + 1}.test`),+ );+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveRecordType('www.layer0.test', 'A'),+ ).rejects.toBeInstanceOf(Error);+ // Fewer than 50 distinct requests are needed; the separate traversal+ // guard must stop this graph even when the wire budget is not exhausted.+ expect(udpTransport.mock.calls.length).toBeLessThan(50);+ });++ it('counts a request once whatever the case of its name', async () => {+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver !== '192.0.2.1')+ return reply(domain, recordType, [address(domain)]);+ if (/\.example\.net\.?$/i.test(domain))+ return reply(domain, recordType, [address(domain, '8.8.8.8')]);+ return referral(domain, recordType, 'example.com', [+ 'ns1.example.net',+ 'NS1.Example.Net.',+ ]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await resolver.resolveRecordType('www.example.com', 'A');+ // Root referral, one shared NS lookup, then the answer.+ expect(udpTransport).toHaveBeenCalledTimes(3);+ });++ it('counts shared glueless requests once without raising the 50-candidate budget', async () => {+ const hosts = (suffix: string) =>+ [1, 2, 3, 4].map((n) => `ns${n}.${suffix}`);+ const udpTransport = vi.fn<AuthoritativeUdpTransport>(+ async ({ domain, recordType, nameserver }) => {+ if (nameserver === '192.0.2.1') {+ if (domain.endsWith('.registry.test'))+ return reply(domain, recordType, [address(domain, '8.8.8.8')]);+ if (domain.endsWith('.shared.test'))+ return referral(+ domain,+ recordType,+ 'shared.test',+ hosts('registry.test'),+ );+ if (domain.endsWith('.provider.test'))+ return referral(+ domain,+ recordType,+ 'provider.test',+ hosts('shared.test'),+ );+ return referral(+ domain,+ recordType,+ 'example.test',+ hosts('provider.test'),+ );+ }+ return reply(domain, recordType, [+ address(+ domain,+ nameserver === '8.8.8.8'+ ? '9.9.9.9'+ : nameserver === '9.9.9.9'+ ? '1.1.1.1'+ : '203.0.113.10',+ ),+ ]);+ },+ );+ const resolver = new AuthoritativeResolver({+ udpTransport,+ rootServers: async () => ['192.0.2.1'],+ });+ await expect(+ resolver.resolveRecordType('www.example.test', 'A'),+ ).resolves.toMatchObject({+ records: [expect.objectContaining({ data: '203.0.113.10' })],+ });+ expect(udpTransport.mock.calls.length).toBeLessThanOrEqual(22);+ });+});diff --git a/lib/resolvers/authoritative.ts b/lib/resolvers/authoritative.tsindex e2a7be9..384e3f3 100644--- a/lib/resolvers/authoritative.ts+++ b/lib/resolvers/authoritative.ts@@ -151,6 +151,17 @@ type WalkResult = {coveringRrsigs?: RrsigData[];};+// Shared by all glueless branches of one top-level query. Reusing a cached+// request (including a rejection) consumes neither another slot nor packets.+// A new top-level query gets a fresh budget and can retry requests that+// rejected (transport failures); resolved responses, rcode failures+// included, stay cached for the resolver instance.+type WalkBudget = {+ remaining: number;+ requests: Map<string, Promise<DnsResponse>>;+ remainingSteps: number;+};+type FetchRecordsParams = {domain: string;recordType: RecordType;@@ -160,7 +171,8 @@ type FetchRecordsParams = {trace?: string[];depth?: number;deadlineAt?: number;- budget?: { remaining: number };+ budget?: WalkBudget;+ ancestors?: ReadonlySet<string>;};const FALLBACK_LOOKUP_ERROR: UserFacingErrorPayload = {@@ -172,7 +184,8 @@ const FALLBACK_LOOKUP_ERROR: UserFacingErrorPayload = {export class AuthoritativeResolver extends DnsResolver {private static readonly MAX_RECURSION_DEPTH = 20;- // Caps candidate nameserver attempts for one walk, like BIND's+ // Caps distinct requests (name, type, nameserver) for one walk -- reusing+ // one is free and bounded by the walk's step budget instead -- like BIND's// max-recursion-queries: the depth cap alone still lets a crafted zone// answer every glueless delegation with 4 fresh NS names and fork// 4^depth sub-walks. One attempt costs up to 4 UDP tries plus a TCP@@ -516,8 +529,23 @@ export class AuthoritativeResolver extends DnsResolver {deadlineAt = Date.now() +(this.options.fallbackDeadlineMs ??AuthoritativeResolver.FALLBACK_DEADLINE_MS),- budget = { remaining: AuthoritativeResolver.MAX_CANDIDATES_PER_WALK },+ budget = {+ remaining: AuthoritativeResolver.MAX_CANDIDATES_PER_WALK,+ requests: new Map(),+ remainingSteps:+ AuthoritativeResolver.MAX_CANDIDATES_PER_WALK *+ AuthoritativeResolver.MAX_RECURSION_DEPTH,+ },+ ancestors = new Set<string>(),}: FetchRecordsParams): Promise<WalkResult> {+ // Cached responses cost no packets, but a crafted or misconfigured graph+ // can still fork exponentially through shared requests. Bound that+ // processing separately.+ if (budget.remainingSteps-- <= 0) {+ throw new Error(+ `DNS traversal budget exhausted while resolving ${domain}`,+ );+ }if (depth > AuthoritativeResolver.MAX_RECURSION_DEPTH) {throw new Error(`Max recursion depth exceeded while resolving ${domain} (type ${recordType})`,@@ -558,37 +586,57 @@ export class AuthoritativeResolver extends DnsResolver {// A blackholed network makes every candidate burn its full retry budget// (4 attempts x 3s); serializing that across 4 fallback servers would// take ~48s. The first candidate always gets its full budget -- a step- // reached with the deadline spent still makes progress -- and further- // ones only start while the deadline allows, so fast failures (REFUSED,- // quick rejects) still reach every server.+ // reached with the deadline spent still makes progress -- unless it is+ // skipped as a loop or an already-failed request, which counts as a+ // failure. Further ones only start while the deadline allows, so fast+ // failures (REFUSED, quick rejects) still reach every server.// ponytail: past the deadline the ceiling is depth x one retry budget;// the platform request timeout is the backstop for adversarial chains.for (const candidate of candidateNameservers) {- if (budget.remaining <= 0) {- failedNameservers.push(- `${candidate}: skipped, candidate budget exhausted`,- );- break;- }if (failedNameservers.length > 0 && Date.now() >= deadlineAt) {failedNameservers.push(`${candidate}: skipped, fallback deadline exceeded`,);break;}- budget.remaining--;const loaderKey = {domain,recordType,nameserver: candidate,dnssecOk: this.options.dnssecOk ?? false,};+ // Name case and a trailing dot don't make a request distinct.+ const key = `${canonicalDnsName(domain)} ${recordType} ${candidate}`;+ // Branch-local ancestry stops a circular glueless dependency, whose+ // replies are cached after a round trip or two and then recurse in+ // microtasks, before it spends the step budget a slower sibling needs.+ // ponytail: keyed per server, so a cycle reachable through several+ // servers (four roots, or a cached delegation's addresses) still forks+ // through their orders and can starve a sibling only a few round trips+ // slower; tracking the glueless NS names each branch is resolving would+ // close that.+ if (ancestors.has(key)) {+ failedNameservers.push(`${candidate}: DNS referral loop detected`);+ continue;+ }+ let pending = budget.requests.get(key);+ if (!pending) {+ if (budget.remaining <= 0) {+ failedNameservers.push(+ `${candidate}: skipped, candidate budget exhausted`,+ );+ break;+ }+ budget.remaining--;+ pending = this.requestLoader.load(loaderKey);+ budget.requests.set(key, pending);+ }let result: DnsResponse;try {- result = await this.requestLoader.load(loaderKey);+ result = await pending;} catch (error) {// DataLoader caches rejections; clear the key so a transient failure- // doesn't poison every later identical query in this walk.+ // doesn't poison every later walk. This walk keeps the rejection.this.requestLoader.clear(loaderKey);failedNameservers.push(`${candidate}: ${error instanceof Error ? error.message : 'request failed'}`,@@ -636,6 +684,7 @@ export class AuthoritativeResolver extends DnsResolver {depth,deadlineAt,budget,+ ancestors: new Set([...ancestors, key]),});} catch (error) {failedNameservers.push(@@ -648,26 +697,29 @@ export class AuthoritativeResolver extends DnsResolver {// No candidate produced a terminal answer or a followable referral.if (cached) {// The cached delegation was the only candidate set and may simply be- // stale (e.g. rate-limited or replaced mid-request); drop it and- // re-walk from the root once instead of failing the lookup. This takes- // priority over any non-authoritative lastResort answer -- adopting a- // deferred answer from the stale cached server would mask the healthy- // authoritative server the fresh root walk finds.+ // stale (e.g. replaced mid-request); drop it and re-walk from the root+ // once instead of failing the lookup. Requests that already failed in+ // this walk are not re-sent: a server that failed here stays failed.+ // This takes priority over any non-authoritative lastResort answer --+ // adopting a deferred answer from the stale cached server would mask+ // the healthy authoritative server the fresh root walk finds. With the+ // step budget spent there is no re-walk; the walk ends below, still+ // without adopting lastResort.this.delegationCache.delete(cached.zone);- return this.fetchRecordsRaw({- domain,- recordType,- trace: [- ...trace,- `${recordType} ${domain} -> cached delegation ${cached.zone} failed (${failedNameservers.join('; ')}), re-walking from root`,- ],- depth: depth + 1,- deadlineAt,- budget,- });- }-- if (lastResort) {+ if (budget.remainingSteps > 0)+ return this.fetchRecordsRaw({+ domain,+ recordType,+ trace: [+ ...trace,+ `${recordType} ${domain} -> cached delegation ${cached.zone} failed (${failedNameservers.join('; ')}), re-walking from root`,+ ],+ depth: depth + 1,+ deadlineAt,+ budget,+ ancestors,+ });+ } else if (lastResort) {// No candidate answered authoritatively; the deferred answer is better// than failing the lookup. It carries an owned answer, so// resolveAcceptedResponse returns it as a terminal answer.@@ -690,6 +742,7 @@ export class AuthoritativeResolver extends DnsResolver {depth,deadlineAt,budget,+ ancestors,});}@@ -741,6 +794,7 @@ export class AuthoritativeResolver extends DnsResolver {depth,deadlineAt,budget,+ ancestors,}: {packet: Packet;protocol: DnsResponse['protocol'];@@ -752,7 +806,8 @@ export class AuthoritativeResolver extends DnsResolver {trace: string[];depth: number;deadlineAt: number;- budget: { remaining: number };+ budget: WalkBudget;+ ancestors: ReadonlySet<string>;}): Promise<WalkResult> {// Only records owned by the queried name (any type, e.g. a CNAME alias)// make this a terminal answer. An answer section carrying nothing but@@ -796,6 +851,27 @@ export class AuthoritativeResolver extends DnsResolver {};}+ // Authoritative NXDOMAIN/NODATA is final when its SOA shows it came from+ // the zone at this cut or below; an NXDOMAIN without SOA is final too.+ // Other denials skip this: a NODATA without SOA, a lame server's denial+ // from a zone outside the cut, and a DS denial from the child zone itself+ // (SOA owned by the queried name; DS lives in the parent), even from a+ // parent server that also hosts the child. Below, NS they carry are+ // followed, or rejected as a loop so that a sibling is tried; without NS+ // the walk ends empty all the same.+ const soa = packet.authorities?.find((answer) => answer.type === 'SOA');+ const soaZone = soa && canonicalDnsName(soa.name);+ const cut = canonicalDnsName(zone);+ if (+ (packet as DecodedPacket).flag_aa &&+ (soaZone === undefined+ ? packet.rcode === 'NXDOMAIN'+ : (!cut || isInBailiwick(soaZone, cut)) &&+ !(recordType === 'DS' && soaZone === wantName))+ ) {+ return { answers: [], trace, rcode: packet.rcode, zone };+ }+// We must validate referrals before following them: an attacker controlling// a delegated zone can otherwise point our recursive query at loopback or// RFC1918 addresses and turn this resolver into an SSRF primitive. Only@@ -813,6 +889,13 @@ export class AuthoritativeResolver extends DnsResolver {);if (nsRedirects.length) {+ const currentZone = canonicalDnsName(zone);+ const nextZone = canonicalDnsName(nsRedirects[0].name);+ // A referral must advance down the tree. Repeating a zone cut (even+ // with different servers) or walking upward cannot resolve the query.+ if (currentZone && !nextZone.endsWith(`.${currentZone}`)) {+ throw new Error(`DNS referral loop detected: ${zone} -> ${nextZone}`);+ }// Trust a glue A record only if it names one of this referral's// delegated NS hostnames and points at a publicly routable IP.// We deliberately accept out-of-bailiwick glue (an NS host not under@@ -853,6 +936,7 @@ export class AuthoritativeResolver extends DnsResolver {depth: depth + 1,deadlineAt,budget,+ ancestors,});}@@ -867,6 +951,7 @@ export class AuthoritativeResolver extends DnsResolver {depth,deadlineAt,budget,+ ancestors,});}@@ -886,6 +971,7 @@ export class AuthoritativeResolver extends DnsResolver {depth,deadlineAt,budget,+ ancestors,}: {nsRedirects: StringAnswer[];domain: string;@@ -895,7 +981,8 @@ export class AuthoritativeResolver extends DnsResolver {trace: string[];depth: number;deadlineAt: number;- budget: { remaining: number };+ budget: WalkBudget;+ ancestors: ReadonlySet<string>;}): Promise<WalkResult> {const zone = canonicalDnsName(nsRedirects[0].name);const subTrace: string[] = [];@@ -917,6 +1004,7 @@ export class AuthoritativeResolver extends DnsResolver {depth: depth + 1,deadlineAt,budget,+ ancestors,});subTrace.push(...resolved.trace);// resolved.answers are all A records (filtered by type), so@@ -961,6 +1049,7 @@ export class AuthoritativeResolver extends DnsResolver {depth: depth + 1,deadlineAt,budget,+ ancestors,});} catch (error) {// Sibling NS lookups are still usable failover: the race above only@@ -987,6 +1076,7 @@ export class AuthoritativeResolver extends DnsResolver {depth: depth + 1,deadlineAt,budget,+ ancestors,});}}