Skip to content

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.ts
new file mode 100644
index 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.ts
index 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,
});
}
}