@push.rocks/smartdns 7.12.0 → 8.0.0

package/dist_ts_server/classes.dnsserver.js

@@ -1,10 +1,15 @@
 import * as plugins from './plugins.js';
-import { RustDnsBridge } from './classes.rustdnsbridge.js';
+import { RustDnsBridge, } from './classes.rustdnsbridge.js';
 export class DnsServer extends plugins.events.EventEmitter {
     constructor(options) {
         super();
         this.options = options;
         this.handlers = [];
+        this.handlerIdCounter = 0;
+        /** Patterns already warned about, so a hot loop cannot flood the log. */
+        this.warnedOutOfZonePatterns = new Set();
+        /** Stable for the lifetime of this server, so the apex SOA does not churn. */
+        this.soaSerial = Math.floor(Date.now() / 1000);
         // Track initialization state
         this.bridgeSpawned = false;
         // Legacy server references (kept for backward-compatible test access)
@@ -16,20 +21,33 @@ export class DnsServer extends plugins.events.EventEmitter {
         this.bridge.on('dnsQuery', async (event) => {
             try {
                 const startTime = Date.now();
-                const answers = this.resolveQuery(event);
+                const resolution = this.resolveQuery(event);
                 const responseTimeMs = Date.now() - startTime;
                 this.emit('query', {
                     questions: event.questions,
-                    answered: answers.answered,
+                    answered: resolution.answers.length > 0,
+                    responseKind: resolution.responseKind,
+                    authorityZone: resolution.authorityZone,
+                    suppressedHandlers: resolution.suppressedHandlers,
                     responseTimeMs,
                     timestamp: startTime,
                 });
-                await this.bridge.sendQueryResult(event.correlationId, answers.answers, answers.answered);
+                if (resolution.responseKind === 'refused' ||
+                    resolution.suppressedHandlers.length > 0) {
+                    this.emit('refused', {
+                        questions: event.questions,
+                        responseKind: resolution.responseKind,
+                        authorityZone: resolution.authorityZone,
+                        suppressedHandlers: resolution.suppressedHandlers,
+                        timestamp: startTime,
+                    });
+                }
+                await this.bridge.sendQueryResult(event.correlationId, resolution.answers, resolution.responseKind, resolution.authorityZone || undefined);
             }
             catch (err) {
                 console.error('Error handling DNS query:', err);
                 try {
-                    await this.bridge.sendQueryResult(event.correlationId, [], false);
+                    await this.bridge.sendQueryResult(event.correlationId, [], 'servfail');
                 }
                 catch (sendErr) {
                     console.error('Error sending empty query result:', sendErr);
@@ -39,21 +57,106 @@ export class DnsServer extends plugins.events.EventEmitter {
     }
     /**
      * Register a DNS handler for a domain pattern and record types.
+     *
+     * Registering a handler is not by itself a claim of authority. Answers only
+     * carry the AA bit when the queried name falls inside a configured
+     * `authoritativeZones` entry. A handler left at the default
+     * `authoritative` mode whose match falls outside every configured zone is
+     * suppressed rather than answered; pass `{ authority: 'non-authoritative' }`
+     * to serve such names deliberately, without claiming authority for them.
+     *
+     * @returns a handle identifying exactly this registration.
      */
-    registerHandler(domainPattern, recordTypes, handler) {
-        this.handlers.push({ domainPattern, recordTypes, handler });
+    registerHandler(domainPattern, recordTypes, handler, options = {}) {
+        const authority = options.authority || 'authoritative';
+        const id = `dnsh_${++this.handlerIdCounter}`;
+        const entry = {
+            id,
+            domainPattern,
+            recordTypes: [...recordTypes],
+            authority,
+            owner: options.owner,
+            handler,
+        };
+        this.handlers.push(entry);
+        if (authority === 'authoritative' &&
+            !this.patternCanMatchAuthoritativeZone(domainPattern) &&
+            !this.warnedOutOfZonePatterns.has(domainPattern.toLowerCase())) {
+            // Loud at the point of the mistake, rather than silently at query time.
+            this.warnedOutOfZonePatterns.add(domainPattern.toLowerCase());
+            console.warn(`smartdns: handler for '${domainPattern}' cannot match any configured authoritative zone ` +
+                `(${this.normalizedAuthoritativeZones().join(', ') || 'none'}). Its answers will be ` +
+                `suppressed. Add the zone to authoritativeZones, or register with ` +
+                `{ authority: 'non-authoritative' } if this is a deliberate overlay.`);
+        }
+        return {
+            id,
+            domainPattern,
+            recordTypes: entry.recordTypes,
+            authority,
+            owner: options.owner,
+            unregister: () => this.unregisterHandlerById(id),
+        };
     }
     /**
-     * Unregister a specific handler.
+     * Unregister every handler registered for this exact pattern whose record
+     * types cover all of `recordTypes`.
+     *
+     * This is deliberately coarse and cannot distinguish between two consumers
+     * that registered the same pattern. Prefer the handle returned by
+     * `registerHandler`, or `unregisterHandlerById` / `unregisterHandlersByOwner`.
      */
     unregisterHandler(domainPattern, recordTypes) {
         const initialLength = this.handlers.length;
+        this.warnedOutOfZonePatterns.delete(domainPattern.toLowerCase());
         const normalizedDomainPattern = domainPattern.toLowerCase();
         const normalizedRecordTypes = recordTypes.map(type => type.toUpperCase());
         this.handlers = this.handlers.filter(handler => !(handler.domainPattern.toLowerCase() === normalizedDomainPattern &&
             normalizedRecordTypes.every(type => handler.recordTypes.map(recordType => recordType.toUpperCase()).includes(type))));
         return this.handlers.length < initialLength;
     }
+    /**
+     * Remove exactly one registration, by the id from `registerHandler`.
+     * Leaves every other handler on the same pattern untouched.
+     */
+    unregisterHandlerById(handlerId) {
+        const initialLength = this.handlers.length;
+        this.handlers = this.handlers.filter((handler) => {
+            if (handler.id !== handlerId) {
+                return true;
+            }
+            // Release the warn-once slot so dynamic patterns cannot accumulate.
+            this.warnedOutOfZonePatterns.delete(handler.domainPattern.toLowerCase());
+            return false;
+        });
+        return this.handlers.length < initialLength;
+    }
+    /**
+     * Remove every registration made with the given `owner`.
+     * @returns the number of handlers removed.
+     */
+    unregisterHandlersByOwner(owner) {
+        const initialLength = this.handlers.length;
+        this.handlers = this.handlers.filter((handler) => {
+            if (handler.owner !== owner) {
+                return true;
+            }
+            // Release the warn-once slot so dynamic patterns cannot accumulate.
+            this.warnedOutOfZonePatterns.delete(handler.domainPattern.toLowerCase());
+            return false;
+        });
+        return initialLength - this.handlers.length;
+    }
+    /** Every currently registered handler, for introspection and leak checks. */
+    listHandlers() {
+        return this.handlers.map((handler) => ({
+            id: handler.id,
+            domainPattern: handler.domainPattern,
+            recordTypes: [...handler.recordTypes],
+            authority: handler.authority,
+            owner: handler.owner,
+        }));
+    }
     /**
      * Start the DNS server.
      */
@@ -93,6 +196,7 @@ export class DnsServer extends plugins.events.EventEmitter {
             dnssecZone: this.options.dnssecZone,
             dnssecAlgorithm: 'ECDSA',
             primaryNameserver: this.options.primaryNameserver || `ns1.${this.options.dnssecZone}`,
+            soaSerial: this.soaSerial,
             enableLocalhostHandling: this.options.enableLocalhostHandling !== false,
             manualUdpMode: this.options.manualUdpMode || false,
             manualTcpMode: this.options.manualTcpMode || false,
@@ -176,8 +280,9 @@ export class DnsServer extends plugins.events.EventEmitter {
      * Handle a UDP message manually.
      */
     handleUdpMessage(msg, rinfo, responseCallback) {
-        // Async processing via Rust bridge
-        this.processRawDnsPacketAsync(msg)
+        // Async processing via Rust bridge. This is a UDP datagram, so the
+        // response must be truncated to the client's advertised payload size.
+        this.processRawDnsPacketAsync(msg, 'udp')
             .then((responseData) => {
             if (responseCallback) {
                 responseCallback(responseData, rinfo);
@@ -189,12 +294,17 @@ export class DnsServer extends plugins.events.EventEmitter {
     }
     /**
      * Process a raw DNS packet asynchronously via Rust bridge.
+     *
+     * Pass `transport: 'udp'` when the response will be sent as a UDP
+     * datagram: the response is then truncated (TC bit set) to the client's
+     * advertised EDNS0 payload size, or 512 bytes without EDNS0. Without it,
+     * no size bound is applied — correct for TCP and DoH framing.
      */
-    async processRawDnsPacketAsync(packet) {
+    async processRawDnsPacketAsync(packet, transport) {
         if (!this.bridgeSpawned) {
             throw new Error('DNS server not started — call start() first');
         }
-        return this.bridge.processPacket(packet);
+        return this.bridge.processPacket(packet, transport);
     }
     /**
      * Retrieve SSL certificate for specified domains using Let's Encrypt
@@ -214,6 +324,9 @@ export class DnsServer extends plugins.events.EventEmitter {
             return { cert: '', key: '', success: false };
         }
         console.log(`Retrieving SSL certificate for domains: ${authorizedDomains.join(', ')}`);
+        // Declared outside the try so a failure part-way through cannot leave
+        // challenge handlers registered.
+        const challengeHandlers = [];
         try {
             // @ts-ignore - acmeClientOverride is added for testing purposes
             const acmeClient = this.acmeClientOverride || await import('acme-client');
@@ -248,7 +361,6 @@ export class DnsServer extends plugins.events.EventEmitter {
                 }))
             });
             const authorizations = await client.getAuthorizations(order);
-            const challengeHandlers = [];
             for (const auth of authorizations) {
                 const domain = auth.identifier.value;
                 const challenge = auth.challenges.find((c) => c.type === 'dns-01');
@@ -259,7 +371,7 @@ export class DnsServer extends plugins.events.EventEmitter {
                 const recordValue = this.getDnsRecordValueForChallenge(keyAuthorization);
                 const challengeDomain = `_acme-challenge.${domain}`;
                 console.log(`Setting up TXT record for ${challengeDomain}: ${recordValue}`);
-                this.registerHandler(challengeDomain, ['TXT'], (question) => {
+                const challengeRegistration = this.registerHandler(challengeDomain, ['TXT'], (question) => {
                     if (question.name === challengeDomain && question.type === 'TXT') {
                         return {
                             name: question.name,
@@ -271,7 +383,7 @@ export class DnsServer extends plugins.events.EventEmitter {
                     }
                     return null;
                 });
-                challengeHandlers.push({ domain, pattern: challengeDomain });
+                challengeHandlers.push({ domain, registration: challengeRegistration });
                 await new Promise(resolve => setTimeout(resolve, 2000));
                 await client.completeChallenge(challenge);
                 await client.waitForValidStatus(challenge);
@@ -303,10 +415,6 @@ export class DnsServer extends plugins.events.EventEmitter {
                     console.error('Error updating certs on Rust bridge:', err);
                 }
             }
-            for (const handler of challengeHandlers) {
-                this.unregisterHandler(handler.pattern, ['TXT']);
-                console.log(`Cleaned up challenge handler for ${handler.domain}`);
-            }
             return {
                 cert: certificate,
                 key: privateKey,
@@ -317,6 +425,15 @@ export class DnsServer extends plugins.events.EventEmitter {
             console.error('Error retrieving SSL certificate:', error);
             return { cert: '', key: '', success: false };
         }
+        finally {
+            for (const handler of challengeHandlers) {
+                // Remove exactly this challenge handler. The coarse
+                // unregisterHandler(pattern, types) would also take out any other
+                // TXT handler a consumer had registered on the same name.
+                handler.registration.unregister();
+                console.log(`Cleaned up challenge handler for ${handler.domain}`);
+            }
+        }
     }
     /**
      * Filter domains to include only those the server is authoritative for.
@@ -339,13 +456,31 @@ export class DnsServer extends plugins.events.EventEmitter {
     // ── Private helpers ───────────────────────────────────────────────
     /**
      * Resolve a DNS query event from Rust using TypeScript handlers.
+     *
+     * Authority is decided by configuration, never by the presence of a
+     * handler. A handler match is only served as an authoritative answer when
+     * the queried name falls inside a configured authoritative zone.
      */
     resolveQuery(event) {
         const answers = [];
-        let answered = false;
+        const suppressedHandlers = [];
+        const authorityZone = this.getAuthorityZone(event);
+        let sawNonAuthoritativeAnswer = false;
+        let nameExists = false;
         for (const q of event.questions) {
-            const normalizedQuestionName = q.name.toLowerCase();
+            const normalizedQuestionName = this.normalizeName(q.name);
             const normalizedQuestionType = q.type.toUpperCase();
+            const questionZone = this.zoneForName(normalizedQuestionName);
+            // RFC 8020: NXDOMAIN asserts that nothing exists at or below the name,
+            // so it is only safe when the name is not the zone apex (which always
+            // exists — it answers its own SOA) and no handler pattern can match at
+            // or below it (an empty non-terminal exists by virtue of the names
+            // beneath it).
+            if (questionZone &&
+                (normalizedQuestionName === questionZone ||
+                    this.nameHasCoveredDescendants(normalizedQuestionName))) {
+                nameExists = true;
+            }
             const question = {
                 name: normalizedQuestionName,
                 type: normalizedQuestionType,
@@ -353,24 +488,150 @@ export class DnsServer extends plugins.events.EventEmitter {
             };
             for (const handlerEntry of this.handlers) {
                 const normalizedDomainPattern = handlerEntry.domainPattern.toLowerCase();
+                if (!plugins.minimatch.minimatch(normalizedQuestionName, normalizedDomainPattern)) {
+                    continue;
+                }
+                // The name is served by *some* handler, which is what separates
+                // NODATA from NXDOMAIN below.
+                nameExists = true;
                 const normalizedRecordTypes = handlerEntry.recordTypes.map(recordType => recordType.toUpperCase());
-                if (plugins.minimatch.minimatch(normalizedQuestionName, normalizedDomainPattern) &&
-                    normalizedRecordTypes.includes(normalizedQuestionType)) {
-                    const answer = handlerEntry.handler(question);
-                    if (answer) {
-                        answers.push({
-                            name: answer.name,
-                            type: answer.type,
-                            class: typeof answer.class === 'number' ? 'IN' : (answer.class || 'IN'),
-                            ttl: answer.ttl || 300,
-                            data: answer.data,
-                        });
-                        answered = true;
+                if (!normalizedRecordTypes.includes(normalizedQuestionType)) {
+                    continue;
+                }
+                if (handlerEntry.authority === 'authoritative' && !questionZone) {
+                    // Answering here would publish a claim of authority over a
+                    // delegation this server does not hold. Withhold it, and make the
+                    // withholding attributable.
+                    suppressedHandlers.push({
+                        questionName: normalizedQuestionName,
+                        questionType: normalizedQuestionType,
+                        domainPattern: handlerEntry.domainPattern,
+                        handlerId: handlerEntry.id,
+                        owner: handlerEntry.owner,
+                    });
+                    continue;
+                }
+                const answer = handlerEntry.handler(question);
+                if (answer) {
+                    answers.push({
+                        name: answer.name,
+                        type: answer.type,
+                        class: typeof answer.class === 'number' ? 'IN' : (answer.class || 'IN'),
+                        ttl: answer.ttl || 300,
+                        data: answer.data,
+                    });
+                    if (handlerEntry.authority === 'non-authoritative' || !questionZone) {
+                        sawNonAuthoritativeAnswer = true;
                     }
                 }
             }
+            // An authoritative server must be able to answer SOA for its own apex.
+            if (answers.length === 0 &&
+                normalizedQuestionType === 'SOA' &&
+                questionZone &&
+                normalizedQuestionName === questionZone) {
+                answers.push(this.buildApexSoaAnswer(questionZone));
+            }
+        }
+        if (answers.length > 0) {
+            // AA is a property of the message, so a single non-authoritative
+            // contribution downgrades the whole response.
+            return {
+                answers,
+                responseKind: authorityZone && !sawNonAuthoritativeAnswer ? 'answer' : 'nonAuthoritativeAnswer',
+                authorityZone,
+                suppressedHandlers,
+            };
         }
-        return { answers, answered };
+        if (authorityZone) {
+            // NXDOMAIN only when the name provably does not exist: no handler
+            // serves it, it is not a zone apex, and nothing can exist below it.
+            // Otherwise the safe answer is NODATA, which never poisons a negative
+            // cache for names or types this server does happen to hold.
+            return {
+                answers,
+                responseKind: nameExists ? 'authoritativeNegative' : 'authoritativeNameError',
+                authorityZone,
+                suppressedHandlers,
+            };
+        }
+        return { answers, responseKind: 'refused', authorityZone: null, suppressedHandlers };
+    }
+    /** Strip the trailing root dot and case, so matching is RFC 4343 correct. */
+    normalizeName(name) {
+        return name.toLowerCase().replace(/\.$/, '');
+    }
+    /** Configured authoritative zones, most specific first. */
+    normalizedAuthoritativeZones() {
+        return (this.options.authoritativeZones?.length
+            ? this.options.authoritativeZones
+            : [this.options.dnssecZone])
+            .map((zone) => this.normalizeName(zone))
+            .filter(Boolean)
+            .sort((a, b) => b.length - a.length);
+    }
+    /** The most specific configured zone containing `name`, if any. */
+    zoneForName(name) {
+        const normalizedName = this.normalizeName(name);
+        return (this.normalizedAuthoritativeZones().find((zone) => normalizedName === zone || normalizedName.endsWith(`.${zone}`)) || null);
+    }
+    /**
+     * Whether a pattern is anchored inside a configured authoritative zone.
+     * Used only to warn at registration time; query-time authority is always
+     * decided from the actual question name, never from this.
+     */
+    patternCanMatchAuthoritativeZone(domainPattern) {
+        return this.zoneForName(domainPattern) !== null;
+    }
+    /**
+     * Whether something this server serves exists strictly below `name`.
+     * Such a name is an empty non-terminal: it holds no records of its own,
+     * but names beneath it exist, so the correct negative answer for it is
+     * NODATA — never NXDOMAIN, which would deny the whole subtree (RFC 8020).
+     *
+     * Descendants exist when a configured authoritative zone sits below the
+     * name (its apex exists by configuration), or when a handler pattern is
+     * anchored below it (literal `.name` suffix, or a wildcard that matches a
+     * probe label). Mid-label wildcard patterns cannot be fully inverted by
+     * this check; see readme.hints.md.
+     */
+    nameHasCoveredDescendants(name) {
+        if (this.normalizedAuthoritativeZones().some((zone) => zone.endsWith(`.${name}`))) {
+            return true;
+        }
+        return this.handlers.some((handlerEntry) => {
+            const pattern = handlerEntry.domainPattern.toLowerCase();
+            return (pattern.endsWith(`.${name}`) ||
+                plugins.minimatch.minimatch(`_ent_probe_.${name}`, pattern));
+        });
+    }
+    /** The SOA this server publishes at the apex of a zone it is authoritative for. */
+    buildApexSoaAnswer(zone) {
+        return {
+            name: zone,
+            type: 'SOA',
+            class: 'IN',
+            ttl: 3600,
+            data: {
+                mname: this.options.primaryNameserver || `ns1.${this.options.dnssecZone}`,
+                rname: `hostmaster.${zone}`,
+                serial: this.soaSerial,
+                refresh: 3600,
+                retry: 600,
+                expire: 604800,
+                minimum: 86400,
+            },
+        };
+    }
+    /** Resolve the most specific configured authority shared by all questions. */
+    getAuthorityZone(event) {
+        if (event.questions.length === 0)
+            return null;
+        const matchedZones = event.questions.map((question) => this.zoneForName(question.name));
+        const matchedZone = matchedZones[0];
+        return matchedZone && matchedZones.every((zone) => zone === matchedZone)
+            ? matchedZone
+            : null;
     }
     getDnsRecordValueForChallenge(keyAuthorization) {
         const digest = plugins.crypto
@@ -388,17 +649,12 @@ export class DnsServer extends plugins.events.EventEmitter {
         return ipv4Pattern.test(ip) || ipv6Pattern.test(ip);
     }
     isAuthorizedForDomain(domain) {
-        const normalizedDomain = domain.toLowerCase();
-        for (const handler of this.handlers) {
-            if (plugins.minimatch.minimatch(normalizedDomain, handler.domainPattern.toLowerCase())) {
-                return true;
-            }
-        }
-        const normalizedZone = this.options.dnssecZone.toLowerCase();
-        if (normalizedDomain === normalizedZone || normalizedDomain.endsWith(`.${normalizedZone}`)) {
-            return true;
-        }
-        return false;
+        // A DNS-01 challenge only completes when the `_acme-challenge.` TXT
+        // handler can answer authoritatively, and authority comes solely from
+        // configured zones — handler registrations play no part. A domain is in
+        // the same configured zone as its challenge name, so the zone lookup on
+        // the domain itself is the whole check.
+        return this.zoneForName(domain) !== null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsserver.js","sourceRoot":"","sources":["../ts_server/classes.dnsserver.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsserver.js","sourceRoot":"","sources":["../ts_server/classes.dnsserver.ts"],"names":[],"mappings":"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"}

package/dist_ts_server/classes.rustdnsbridge.d.ts

@@ -14,7 +14,8 @@ export type TDnsCommands = {
         params: {
             correlationId: string;
             answers: IIpcDnsAnswer[];
-            answered: boolean;
+            responseKind: TDnsQueryResponseKind;
+            authorityZone?: string;
         };
         result: {
             resolved: boolean;
@@ -30,6 +31,7 @@ export type TDnsCommands = {
     processPacket: {
         params: {
             packet: string;
+            transport?: 'udp' | 'tcp';
         };
         result: {
             packet: string;
@@ -42,6 +44,15 @@ export type TDnsCommands = {
         };
     };
 };
+export type TDnsQueryResponseKind = 
+/** Authoritative answer: carries AA, may be DNSSEC-signed. */
+'answer'
+/** Overlay answer for a name outside every authoritative zone: never AA. */
+ | 'nonAuthoritativeAnswer'
+/** Name exists in an authoritative zone, no record of this type (NODATA). */
+ | 'authoritativeNegative'
+/** Name does not exist in an authoritative zone (NXDOMAIN). */
+ | 'authoritativeNameError' | 'refused' | 'servfail';
 export interface IRustDnsConfig {
     udpPort: number;
     tcpPort?: number;
@@ -54,6 +65,8 @@ export interface IRustDnsConfig {
     dnssecZone: string;
     dnssecAlgorithm: string;
     primaryNameserver: string;
+    /** Zone SOA serial, so apex answers and negative authorities agree. */
+    soaSerial: number;
     enableLocalhostHandling: boolean;
     manualUdpMode: boolean;
     manualTcpMode: boolean;
@@ -97,16 +110,18 @@ export declare class RustDnsBridge extends plugins.events.EventEmitter {
     /**
      * Send a DNS query result back to Rust.
      */
-    sendQueryResult(correlationId: string, answers: IIpcDnsAnswer[], answered: boolean): Promise<void>;
+    sendQueryResult(correlationId: string, answers: IIpcDnsAnswer[], responseKind: TDnsQueryResponseKind, authorityZone?: string): Promise<void>;
     /**
      * Update TLS certificates.
      */
     updateCerts(httpsKey: string, httpsCert: string): Promise<void>;
     /**
      * Process a raw DNS packet via IPC (for manual/passthrough mode).
-     * Returns the DNS response as a Buffer.
+     * Returns the DNS response as a Buffer. Pass `transport: 'udp'` when the
+     * response will be sent as a UDP datagram, so it is truncated (TC bit) to
+     * the client's advertised payload size instead of exceeding it.
      */
-    processPacket(packet: Buffer): Promise<Buffer>;
+    processPacket(packet: Buffer, transport?: 'udp' | 'tcp'): Promise<Buffer>;
     /**
      * Ping the Rust binary for health check.
      */