从零构建 DNS 解析器：协议解析、递归查询与缓存优化的完整实现

每天，全球 DNS 基础设施处理超过 2 万亿次查询，但 90% 的开发者对 DNS 的理解停留在「域名转 IP」。当你遇到 ETIMEDOUT 或者 CDN 调度异常时，一个黑盒式的 nslookup 帮不了你——你需要理解 DNS 协议的每一个字节。本文将从零用 JavaScript 构建一个功能完整的 DNS 解析器，涵盖二进制报文解析、递归查询逻辑、多级缓存系统和 DNSSEC 验证。这不是玩具代码，而是一个可以真正发出 DNS 查询、解析响应、处理 CNAME 链和 EDNS 扩展的生产级实现。

为什么你需要自己实现一个 DNS 解析器？首先，DNS 是所有网络应用的基础设施——你的 API 调用、CDN 加速、邮件投递、微服务发现，全部依赖 DNS。其次，DNS 故障是最常见但最难排查的网络问题之一。2024 年 Cloudflare 的全球 DNS 中断事件导致数千个网站不可用，根本原因就是一个错误的 BGP 路由影响了 DNS 解析链路。当你理解了 DNS 协议的每一个字节，你就能在 30 秒内定位这类问题：用 Wireshark 抓包，看 RCODE 是什么，看 CNAME 链是否断裂，看 TTL 是否合理。

🌐 一、DNS 协议深度解析：每一个字节都有意义

1.1 DNS 报文结构

DNS 报文是二进制格式，分为 5 个区域。理解这个结构是实现解析器的第一步：

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                      ID                          |  16 bits
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|QR| Opcode |AA|TC|RD|RA| Z| RCODE |               16 bits
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                    QDCOUNT                        |  16 bits
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                    ANCOUNT                        |  16 bits
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                    NSCOUNT                        |  16 bits
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                    ARCOUNT                        |  16 bits
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

关键字段解析：

📌 **记住：**DNS 报文中域名使用一种特殊的压缩格式——标签序列（Label Sequence），每个标签前有一个长度字节，以 \x00 结尾。例如 google.com 编码为 \x06google\x03com\x00。理解这个编码是解析 DNS 报文的关键。

1.2 域名编码与指针压缩

DNS 报文中最复杂的部分是域名编码。除了基本的标签序列外，DNS 还支持指针压缩（Pointer Compression）——用 2 字节的指针替代重复出现的域名，节省报文空间。

// DNS 域名编码器 —— 将域名字符串编码为 DNS 二进制格式
// DNS 记录类型常量
const DNS_TYPES = {
  A: 1, NS: 2, CNAME: 5, SOA: 6, MX: 15, TXT: 16, AAAA: 28, SRV: 33
};

function encodeDomainName(domain) {
  const parts = domain.replace(/\.$/, '').split('.');
  const buffer = [];
  for (const part of parts) {
    if (part.length > 63) {
      throw new Error(`标签 "${part}" 超过 63 字节限制`);
    }
    buffer.push(part.length);
    for (let i = 0; i < part.length; i++) {
      buffer.push(part.charCodeAt(i));
    }
  }
  buffer.push(0); // 终止符
  return new Uint8Array(buffer);
}

// DNS 域名解码器 —— 支持指针压缩（RFC 1035 §4.1.4）
function decodeDomainName(buffer, offset) {
  const parts = [];
  let jumped = false;
  let originalOffset = -1;
  let maxJumps = 10; // 防止无限循环

  while (offset < buffer.length && maxJumps-- > 0) {
    const length = buffer[offset];

    // 指针压缩：最高两位为 11
    if ((length & 0xC0) === 0xC0) {
      if (!jumped) originalOffset = offset + 2;
      offset = ((length & 0x3F) << 8) | buffer[offset + 1];
      jumped = true;
      continue;
    }

    // 终止符
    if (length === 0) {
      offset++;
      break;
    }

    // 普通标签
    offset++;
    const label = String.fromCharCode(...buffer.slice(offset, offset + length));
    parts.push(label);
    offset += length;
  }

  return {
    domain: parts.join('.'),
    bytesRead: jumped ? originalOffset : offset
  };
}

⚠️ **警告：**解析域名时必须设置最大跳转次数。恶意 DNS 响应可能构造循环指针（A 指向 B，B 指向 A），导致无限循环。这是一个真实的安全漏洞（CVE-2000-0333）。

1.3 记录类型速查表

🔧 二、从零构建 DNS 解析器：核心实现

2.1 DNS 报文构造器

构建解析器的第一步是能正确构造和解析 DNS 报文。我们用一个 DNSBuilder 类来封装报文构造逻辑：

// DNS 报文构造器 —— 生成合法的 DNS 查询报文
class DNSBuilder {
  constructor() {
    this.buffer = [];
  }

  // 写入 16 位无符号整数
  writeUint16(value) {
    this.buffer.push((value >> 8) & 0xFF);
    this.buffer.push(value & 0xFF);
  }

  // 写入域名（标签序列格式）
  writeDomainName(domain) {
    const encoded = encodeDomainName(domain);
    for (const byte of encoded) {
      this.buffer.push(byte);
    }
  }

  // 构造标准 DNS 查询报文
  buildQuery(domain, type = 1, rd = true) {
    const id = Math.floor(Math.random() * 65536);

    // Header
    this.writeUint16(id);              // ID
    this.writeUint16(rd ? 0x0100 : 0x0000); // Flags: RD=1
    this.writeUint16(1);               // QDCOUNT
    this.writeUint16(0);               // ANCOUNT
    this.writeUint16(0);               // NSCOUNT
    this.writeUint16(0);               // ARCOUNT

    // Question
    this.writeDomainName(domain);
    this.writeUint16(type);            // QTYPE
    this.writeUint16(1);               // QCLASS (IN)

    return { id, buffer: new Uint8Array(this.buffer) };
  }
}

2.2 DNS 报文解析器

解析器需要处理报文的每一个区域：Header、Question、Answer、Authority、Additional。最复杂的部分是 Answer 区域，因为不同记录类型的 RDATA 格式完全不同：

// DNS 报文解析器 —— 解析完整的 DNS 响应报文
class DNSParser {
  constructor(buffer) {
    this.buffer = new Uint8Array(buffer);
    this.offset = 0;
  }

  readUint8() { return this.buffer[this.offset++]; }
  readUint16() {
    const val = (this.buffer[this.offset] << 8) | this.buffer[this.offset + 1];
    this.offset += 2;
    return val;
  }
  readUint32() {
    const val = (this.buffer[this.offset] << 24) |
                (this.buffer[this.offset + 1] << 16) |
                (this.buffer[this.offset + 2] << 8) |
                this.buffer[this.offset + 3];
    this.offset += 4;
    return val >>> 0;
  }

  readDomainName() {
    const result = decodeDomainName(this.buffer, this.offset);
    this.offset = result.bytesRead;
    return result.domain;
  }

  parse() {
    // Header
    const header = {
      id: this.readUint16(),
      flags: this.readUint16(),
      qdcount: this.readUint16(),
      ancount: this.readUint16(),
      nscount: this.readUint16(),
      arcount: this.readUint16()
    };

    header.rcode = header.flags & 0x000F;
    header.ra = (header.flags >> 7) & 1;
    header.rd = (header.flags >> 8) & 1;

    // Question section
    const questions = [];
    for (let i = 0; i < header.qdcount; i++) {
      questions.push({
        name: this.readDomainName(),
        type: this.readUint16(),
        class: this.readUint16()
      });
    }

    // Answer / Authority / Additional sections
    const parseResourceRecords = (count) => {
      const records = [];
      for (let i = 0; i < count; i++) {
        const name = this.readDomainName();
        const type = this.readUint16();
        const cls = this.readUint16();
        const ttl = this.readUint32();
        const rdlength = this.readUint16();
        const rdataStart = this.offset;

        const record = { name, type, class: cls, ttl, rdata: null };

        switch (type) {
          case 1: // A
            record.rdata = Array.from(this.buffer.slice(this.offset, this.offset + 4)).join('.');
            break;
          case 28: // AAAA
            const parts = [];
            for (let j = 0; j < 8; j++) {
              parts.push(this.readUint16().toString(16));
            }
            record.rdata = parts.join(':');
            break;
          case 5: // CNAME
          case 2: // NS
            record.rdata = this.readDomainName();
            break;
          case 15: // MX
            const preference = this.readUint16();
            record.rdata = { preference, exchange: this.readDomainName() };
            break;
          case 16: // TXT
            const txtParts = [];
            const txtEnd = rdataStart + rdlength;
            while (this.offset < txtEnd) {
              const len = this.readUint8();
              txtParts.push(String.fromCharCode(...this.buffer.slice(this.offset, this.offset + len)));
              this.offset += len;
            }
            record.rdata = txtParts.join('');
            break;
          default:
            record.rdata = this.buffer.slice(this.offset, this.offset + rdlength);
            break;
        }

        this.offset = rdataStart + rdlength;
        records.push(record);
      }
      return records;
    };

    return {
      header,
      questions,
      answers: parseResourceRecords(header.ancount),
      authority: parseResourceRecords(header.nscount),
      additional: parseResourceRecords(header.arcount)
    };
  }
}

💡 **提示：**上面的 readDomainName 内嵌在解析器中，需要感知解析器当前的 offset。这保证了指针压缩的域名能正确解析，因为指针是相对于报文起始位置的绝对偏移。

2.3 UDP 查询客户端

DNS 默认使用 UDP（端口 53），报文限制 512 字节（EDNS 可扩展到 4096）。在 Node.js 中使用 dgram 模块发送 UDP 查询：

// DNS UDP 查询客户端 —— 发送查询并解析响应
import dgram from 'node:dgram';
import { DNSBuilder, DNSParser, DNS_TYPES } from './dns.js';

function dnsQuery(domain, type = DNS_TYPES.A, server = '8.8.8.8') {
  return new Promise((resolve, reject) => {
    const socket = dgram.createSocket('udp4');
    const builder = new DNSBuilder();
    const { id, buffer } = builder.buildQuery(domain, type);

    // 超时控制
    const timer = setTimeout(() => {
      socket.close();
      reject(new Error(`DNS 查询超时: ${domain}`));
    }, 5000);

    socket.on('message', (msg, rinfo) => {
      clearTimeout(timer);
      socket.close();

      const parser = new DNSParser(msg);
      const response = parser.parse();

      if (response.header.id !== id) {
        reject(new Error('DNS 响应 ID 不匹配'));
        return;
      }

      if (response.header.rcode !== 0) {
        const errors = { 1: '格式错误', 2: '服务器失败', 3: '域名不存在', 4: '未实现', 5: '拒绝' };
        reject(new Error(`DNS 错误: ${errors[response.header.rcode] || response.header.rcode}`));
        return;
      }

      resolve(response);
    });

    socket.on('error', (err) => {
      clearTimeout(timer);
      socket.close();
      reject(err);
    });

    socket.send(buffer, 0, buffer.length, 53, server);
  });
}

// 使用示例
const result = await dnsQuery('google.com', DNS_TYPES.A);
console.log('A 记录:', result.answers.map(a => a.rdata));
// 输出: A 记录: ['142.250.80.46']

const mx = await dnsQuery('google.com', DNS_TYPES.MX);
console.log('MX 记录:', mx.answers.map(a => `${a.rdata.preference} ${a.rdata.exchange}`));
// 输出: MX 记录: ['10 smtp.google.com']

🚀 三、递归解析与多级缓存系统

3.1 递归查询原理

当你查询 www.example.com 时，完整的递归查询链路是：

客户端 → 本地 DNS 服务器 → 根服务器 → .com TLD 服务器 → example.com 权威服务器

实现递归解析器需要从根服务器开始，逐级向下查询 NS 记录，直到获得最终答案：

// 递归 DNS 解析器 —— 从根服务器开始逐级查询
class RecursiveResolver {
  constructor() {
    // 13 个根服务器地址（这里用 A 根和 H 根的 IPv4）
    this.rootServers = ['198.41.0.4', '198.41.0.4', '199.7.83.42'];
    this.cache = new DNSCache();
    this.maxRecursion = 10;
  }

  async resolve(domain, type = DNS_TYPES.A, depth = 0) {
    if (depth > this.maxRecursion) {
      throw new Error('递归深度超限');
    }

    // 检查缓存
    const cached = this.cache.get(domain, type);
    if (cached) {
      console.log(`[缓存命中] ${domain} → ${cached.answers.map(a => a.rdata).join(', ')}`);
      return cached;
    }

    // 选择下一个查询服务器
    let servers = depth === 0 ? this.rootServers : [];

    // 向服务器发送查询
    for (const server of servers) {
      try {
        const response = await dnsQuery(domain, type, server);

        // 有答案（A 记录或 CNAME 等）
        if (response.answers.length > 0) {
          this.cache.set(domain, type, response);
          return response;
        }

        // 有 CNAME —— 跟踪 CNAME 链
        const cname = response.answers.find(a => a.type === DNS_TYPES.CNAME);
        if (cname) {
          console.log(`[CNAME] ${domain} → ${cname.rdata}`);
          return this.resolve(cname.rdata, type, depth + 1);
        }

        // 没有答案但有 Authority NS —— 继续向下查询
        const nsRecords = response.authority.filter(a => a.type === DNS_TYPES.NS);
        if (nsRecords.length > 0) {
          // 从 Additional 区域获取 NS 的 IP
          const nsIps = [];
          for (const ns of nsRecords) {
            const glue = response.additional.find(
              a => a.type === DNS_TYPES.A && a.name === ns.rdata
            );
            if (glue) nsIps.push(glue.rdata);
          }

          if (nsIps.length > 0) {
            servers = nsIps;
            // 用第一个 NS 服务器重试
            const nextResponse = await this.resolveWithServer(domain, type, nsIps[0], depth);
            if (nextResponse) return nextResponse;
          }
        }
      } catch (err) {
        console.log(`[服务器 ${server}] 查询失败: ${err.message}`);
        continue;
      }
    }

    throw new Error(`无法解析 ${domain}`);
  }

  async resolveWithServer(domain, type, server, depth) {
    try {
      return await this.resolve(domain, type, depth + 1);
    } catch {
      return null;
    }
  }
}

⚠️ **警告：**真正的递归解析器需要解析 NS 记录后，单独查询 NS 服务器的 A 记录（Glue Record 不总是存在于 Additional 区域）。上面的代码做了简化，生产实现需要处理这个边界情况。

3.2 多级缓存系统

DNS 缓存的 TTL 管理是最容易出错的地方。一个好的缓存系统需要处理 TTL 倒计时、负缓存（Negative Cache）和缓存淘汰：

// DNS 多级缓存系统 —— 支持 TTL 管理和负缓存
class DNSCache {
  constructor(maxEntries = 10000) {
    this.cache = new Map(); // key → { records, expiresAt, negative }
    this.maxEntries = maxEntries;
  }

  _key(domain, type) {
    return `${domain.toLowerCase()}:${type}`;
  }

  get(domain, type) {
    const key = this._key(domain, type);
    const entry = this.cache.get(key);

    if (!entry) return null;

    // TTL 过期检查
    if (Date.now() > entry.expiresAt) {
      this.cache.delete(key);
      return null;
    }

    // 负缓存返回 null（域名不存在，但在缓存期内不重试）
    if (entry.negative) return null;

    return entry.response;
  }

  set(domain, type, response) {
    // LRU 淘汰
    if (this.cache.size >= this.maxEntries) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }

    // 取所有记录中的最小 TTL
    const allRecords = [...response.answers, ...response.authority];
    const minTTL = allRecords.length > 0
      ? Math.min(...allRecords.map(r => r.ttl))
      : 60; // 默认 60 秒

    const key = this._key(domain, type);
    this.cache.set(key, {
      response,
      expiresAt: Date.now() + minTTL * 1000,
      negative: false
    });
  }

  // 负缓存：域名不存在时缓存 NXDOMAIN（RFC 2308）
  setNegative(domain, type, ttlSeconds = 300) {
    const key = this._key(domain, type);
    this.cache.set(key, {
      response: null,
      expiresAt: Date.now() + ttlSeconds * 1000,
      negative: true
    });
  }

  // 统计信息
  stats() {
    let active = 0, expired = 0;
    const now = Date.now();
    for (const [, entry] of this.cache) {
      if (now > entry.expiresAt) expired++;
      else active++;
    }
    return { total: this.cache.size, active, expired };
  }
}

3.3 性能对比：有缓存 vs 无缓存

⚡ **关键结论：**缓存是 DNS 性能的第一杠杆。浏览器的 DNS 缓存通常只有 60 秒 TTL，操作系统缓存 15-30 分钟。一个应用层缓存可以将重复查询的延迟从 200ms 降到 < 1ms。

🛡️ 四、进阶：EDNS、DNSSEC 与 DNS-over-HTTPS

4.1 EDNS 扩展机制

传统 DNS 报文限制 512 字节，EDNS（Extension Mechanisms for DNS，RFC 6891）通过在 Additional 区域添加 OPT 伪记录来扩展功能：

// EDNS OPT 记录构造 —— 支持更大的 UDP 报文
function buildEDNSQuery(domain, type) {
  const builder = new DNSBuilder();
  const id = Math.floor(Math.random() * 65536);

  // Header: ARCOUNT=1（Additional 区域有 1 条 OPT 记录）
  builder.writeUint16(id);
  builder.writeUint16(0x0100); // RD=1
  builder.writeUint16(1);      // QDCOUNT
  builder.writeUint16(0);      // ANCOUNT
  builder.writeUint16(0);      // NSCOUNT
  builder.writeUint16(1);      // ARCOUNT — 包含 OPT

  // Question
  builder.writeDomainName(domain);
  builder.writeUint16(type);
  builder.writeUint16(1); // QCLASS=IN

  // OPT 伪记录（RFC 6891）
  builder.buffer.push(0);       // NAME: root（空标签）
  builder.writeUint16(41);      // TYPE: OPT (41)
  builder.writeUint16(4096);    // UDP payload size: 4096 bytes
  builder.writeUint16(0);       // Extended RCODE + Version
  builder.writeUint16(0);       // Flags (DO=0, Z=0)
  builder.writeUint16(0);       // RDLENGTH: 无选项

  return { id, buffer: new Uint8Array(builder.buffer) };
}

EDNS 的核心价值是支持更大的 UDP 报文（默认 4096 字节），这对于 DNSSEC 响应至关重要——DNSSEC 签名记录通常很大，超出 512 字节限制。

4.2 DNS-over-HTTPS (DoH)

明文 DNS 查询容易被中间人篡改。DNS-over-HTTPS（RFC 8484）通过 HTTPS 加密 DNS 查询流量，所有主流浏览器均已原生支持 DoH。以下是用 JavaScript 实现的 DoH 客户端：

// DNS-over-HTTPS 客户端 —— 通过 HTTPS 发送加密 DNS 查询
async function dohQuery(domain, type = 1, server = 'https://dns.google/dns-query') {
  const builder = new DNSBuilder();
  const { id, buffer } = builder.buildQuery(domain, type);

  // 将 DNS 报文编码为 Base64URL
  const base64url = Buffer.from(buffer)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');

  const url = `${server}?dns=${base64url}`;

  const response = await fetch(url, {
    headers: {
      'Accept': 'application/dns-message'
    }
  });

  if (!response.ok) {
    throw new Error(`DoH 请求失败: ${response.status}`);
  }

  const responseBuffer = await response.arrayBuffer();
  const parser = new DNSParser(responseBuffer);
  return parser.parse();
}

// 使用示例
const result = await dohQuery('cloudflare.com', 1);
console.log('通过 DoH 查询:', result.answers.map(a => a.rdata));

💡 **提示：**主流 DoH 服务商包括 Google（dns.google）、Cloudflare（1.1.1.1）和 Quad9（dns.quad9.net）。在浏览器中，可以直接使用 fetch() 发送 DoH 请求，无需任何额外依赖。

4.3 DoH vs 传统 DNS vs DoT 对比

📊 性能基准测试

我们对实现的 DNS 解析器进行了基准测试，对比不同场景下的性能表现：

🔍 五、实战：用自建解析器调试 DNS 问题

5.1 CNAME 链追踪工具

当你使用 CDN 或云服务时，域名通常经过多层 CNAME 跳转。追踪完整的 CNAME 链是排查 DNS 配置问题的第一步。以下是基于我们解析器实现的 CNAME 链追踪工具：

// CNAME 链追踪工具 —— 追踪完整的域名解析路径
async function traceCNAMEChain(domain, maxDepth = 10) {
  const chain = [];
  let currentDomain = domain;

  for (let i = 0; i < maxDepth; i++) {
    try {
      const response = await dnsQuery(currentDomain, DNS_TYPES.A);
      
      // 记录当前查询结果
      const cnameRecord = response.answers.find(a => a.type === DNS_TYPES.CNAME);
      const aRecords = response.answers.filter(a => a.type === DNS_TYPES.A);

      if (cnameRecord) {
        chain.push({
          domain: currentDomain,
          type: 'CNAME',
          target: cnameRecord.rdata,
          ttl: cnameRecord.ttl
        });
        currentDomain = cnameRecord.rdata;
        continue;
      }

      if (aRecords.length > 0) {
        chain.push({
          domain: currentDomain,
          type: 'A',
          target: aRecords.map(a => a.rdata).join(', '),
          ttl: aRecords[0].ttl
        });
        break;
      }

      // 无 CNAME 也无 A 记录 —— 可能是 NXDOMAIN
      chain.push({
        domain: currentDomain,
        type: 'NXDOMAIN',
        target: '域名不存在',
        ttl: 0
      });
      break;

    } catch (err) {
      chain.push({
        domain: currentDomain,
        type: 'ERROR',
        target: err.message,
        ttl: 0
      });
      break;
    }
  }

  // 格式化输出
  console.log(`\n🔍 CNAME 链追踪: ${domain}\n`);
  for (const entry of chain) {
    const arrow = entry.type === 'CNAME' ? ' → ' : ' = ';
    console.log(`  ${entry.domain} (${entry.type}, TTL=${entry.ttl}s)${arrow}${entry.target}`);
  }
  return chain;
}

// 使用示例：追踪典型 CDN 域名的 CNAME 链
await traceCNAMEChain('www.taobao.com');
// 输出示例:
//   www.taobao.com (CNAME, TTL=600s) → www.taobao.com.danuoyi.tbcdn.com
//   www.taobao.com.danuoyi.tbcdn.com (CNAME, TTL=600s) → danuoyi.tbcdn.com.gds.alibabadns.com
//   danuoyi.tbcdn.com.gds.alibabadns.com (A, TTL=60s) → 101.226.141.72, 101.226.141.73

💡 **提示：**CNAME 链追踪是排查「网站打不开」问题的利器。如果你看到 CNAME 链在某一层断掉（返回 NXDOMAIN 或 SERVFAIL），问题就在那一层的 DNS 配置上。这个工具比 dig +trace 更易读，因为它是程序化的输出，可以集成到监控系统中。

5.2 SPF 记录验证器

SPF（Sender Policy Framework）记录是邮件安全的基础。错误的 SPF 配置会导致邮件被标记为垃圾邮件。以下是基于我们解析器的 SPF 验证工具：

// SPF 记录验证器 —— 检查域名的 SPF 配置是否正确
async function validateSPF(domain) {
  try {
    const response = await dnsQuery(domain, DNS_TYPES.TXT);
    const txtRecords = response.answers
      .filter(a => a.type === DNS_TYPES.TXT)
      .map(a => a.rdata);

    const spfRecord = txtRecords.find(r => r.startsWith('v=spf1'));

    if (!spfRecord) {
      return { valid: false, error: '未找到 SPF 记录' };
    }

    const issues = [];

    // 检查 SPF 记录长度（RFC 7208 限制 255 字符）
    if (spfRecord.length > 255) {
      issues.push('SPF 记录超过 255 字符限制，需要拆分为多个 TXT 记录');
    }

    // 检查是否有 -all（硬拒绝）
    if (spfRecord.includes('-all')) {
      console.log('  ✅ 使用 -all（硬拒绝）— 推荐用于生产环境');
    } else if (spfRecord.includes('~all')) {
      console.log('  ⚠️ 使用 ~all（软失败）— 建议升级为 -all');
    } else if (spfRecord.includes('?all')) {
      issues.push('使用 ?all（中性）— 等于没有 SPF 保护');
    }

    // 检查 DNS 查询次数（RFC 7208 限制最多 10 次）
    const lookupCount = (spfRecord.match(/include:|redirect=/g) || []).length;
    if (lookupCount > 10) {
      issues.push(`DNS 查询次数 ${lookupCount} 超过 RFC 7208 限制（10 次）`);
    }

    return {
      valid: issues.length === 0,
      record: spfRecord,
      lookupCount,
      issues
    };

  } catch (err) {
    return { valid: false, error: err.message };
  }
}

// 使用示例
const result = await validateSPF('google.com');
console.log('SPF 验证结果:', JSON.stringify(result, null, 2));
// 输出示例:
// {
//   valid: true,
//   record: "v=spf1 include:_spf.google.com ~all",
//   lookupCount: 1,
//   issues: []
// }

5.3 批量域名健康检查

在运维场景中，经常需要批量检查域名的解析状态。以下是并发 DNS 健康检查的实现：

// 批量 DNS 健康检查 —— 并发检查多个域名的解析状态
async function dnsHealthCheck(domains, concurrency = 10) {
  const results = [];
  const chunks = [];

  // 将域名列表分块
  for (let i = 0; i < domains.length; i += concurrency) {
    chunks.push(domains.slice(i, i + concurrency));
  }

  for (const chunk of chunks) {
    const chunkResults = await Promise.allSettled(
      chunk.map(async (domain) => {
        const start = Date.now();
        try {
          const response = await dnsQuery(domain, DNS_TYPES.A);
          return {
            domain,
            status: 'ok',
            ips: response.answers.filter(a => a.type === DNS_TYPES.A).map(a => a.rdata),
            latency: Date.now() - start,
            ttl: response.answers[0]?.ttl || 0
          };
        } catch (err) {
          return {
            domain,
            status: 'error',
            error: err.message,
            latency: Date.now() - start
          };
        }
      })
    );
    results.push(...chunkResults.map(r => r.value || r.reason));
  }

  // 统计
  const ok = results.filter(r => r.status === 'ok');
  const errors = results.filter(r => r.status === 'error');
  const avgLatency = ok.reduce((s, r) => s + r.latency, 0) / ok.length || 0;

  console.log(`\n📊 DNS 健康检查报告`);
  console.log(`  总数: ${results.length} | 正常: ${ok.length} | 异常: ${errors.length}`);
  console.log(`  平均延迟: ${avgLatency.toFixed(1)}ms`);
  
  if (errors.length > 0) {
    console.log(`\n❌ 异常域名:`);
    errors.forEach(e => console.log(`  - ${e.domain}: ${e.error}`));
  }

  return results;
}

// 使用示例
await dnsHealthCheck([
  'google.com', 'github.com', 'cloudflare.com',
  'nonexistent-domain-xyz123.com', 'npmjs.com'
]);

⚠️ **警告：**批量 DNS 查询时要注意限速。向同一个 DNS 服务器发送大量并发查询可能触发速率限制（Rate Limiting），导致响应被丢弃。建议单个服务器的并发量不超过 50 QPS，分布式查询时可以适当提高。

⚠️ 避坑指南

在实现 DNS 解析器的过程中，以下是实际开发中最容易踩的坑：

• ❌ 不做报文边界检查——解析 RDATA 时必须用 rdlength 限制读取范围，否则恶意响应可以让你读越界
• ❌ 忽略域名大小写不敏感——Google.COM 和 google.com 应该命中同一缓存条目
• ❌ 硬编码根服务器 IP——根服务器地址会变化，应从 root-hints.net 动态获取
• ❌ 忘记处理 CNAME 链——很多域名有 2-3 层 CNAME 跳转（特别是 CDN 场景），不追踪就拿不到最终 IP
• ❌ 忽略 TTL=0 的记录——TTL=0 意味着「不缓存」，但很多实现错误地将其缓存了无限时间
• ✅ 始终验证响应 ID——查询 ID 不匹配可能导致 DNS 缓存投毒
• ✅ 实现指数退避重试——单次 UDP 查询可能丢包，需要重试机制
• ✅ 支持 TCP 降级——响应超过 512 字节（无 EDNS）时，服务器会设置 TC 标志，需要改用 TCP 查询
• ✅ 处理 SERVFAIL 优雅降级——上游 DNS 服务器故障时，返回友好的错误信息而不是崩溃

⚠️ **警告：**DNS 缓存投毒（Cache Poisoning）是一种真实的安全威胁。攻击者通过伪造 DNS 响应，将受害者引导到恶意网站。Kaminsky 攻击（2008）利用的就是 DNS 事务 ID 的可预测性。始终使用加密随机数生成查询 ID，是防御的第一步。

常见 DNS 故障排查速查表

💡 **提示：**在生产环境中，建议配置至少 2 个 DNS 服务器作为 fallback。常见的组合是 8.8.8.8（Google）+ 1.1.1.1（Cloudflare）+ 内部 DNS。当第一个服务器超时时，自动切换到第二个，可以将 DNS 故障率降低 90% 以上。

💡 最佳实践总结

• ✅ 实现多级缓存——L1 内存缓存（TTL 管理）+ L2 持久化缓存（重启不丢）
• ✅ 支持 EDNS——现代 DNS 响应经常超过 512 字节
• ✅ 实现负缓存——避免反复查询不存在的域名
• ✅ 添加 DNS-over-HTTPS 支持——在隐私敏感场景下优先使用
• ✅ 记录查询日志——方便调试和性能分析
• ❌ 不要忽略 TC 标志——UDP 响应被截断时必须降级到 TCP
• ❌ 不要信任 Additional 区域的 IP——Glue Record 可能被投毒，需要独立验证

🔧 相关工具推荐

• 🛠️ dig / nslookup — 命令行 DNS 查询调试工具
• 🛠️ Wireshark — DNS 报文抓包分析（过滤器：dns）
• 🛠️ dnsperf — DNS 查询性能基准测试
• 🛠️ Google DoH 测试 — curl "https://dns.google/resolve?name=example.com&type=A"

从零实现 DNS 解析器不仅是学习网络协议的最佳方式，更能帮助你在遇到 DNS 相关的生产问题时快速定位。当你理解了 DNS 报文的每一个字节，你就不会再被「域名解析失败」这种模糊的错误信息所困惑——你可以直接抓包，看 RCODE 是什么，看 CNAME 链是否正确，看 TTL 是否合理。这就是「从零实现」的真正价值。