dns2 2.0.5 → 2.2.1

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "dns2",
-  "version": "2.0.5",
+  "version": "2.2.1",
   "description": "A DNS Server and Client Implementation in Pure JavaScript with no dependencies.",
   "main": "index.js",
+  "types": "ts/index.d.ts",
+  "files": [
+    "lib",
+    "client",
+    "server",
+    "packet.js",
+    "example",
+    "ts"
+  ],
   "scripts": {
-    "test": "node test",
-    "lint": "eslint .",
+    "test": "node --test",
+    "test:coverage": "node --test --experimental-test-coverage",
+    "test:coverage:lcov": "mkdir -p coverage && node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info",
+    "lint": "npx eslint .",
+    "lint:fix": "npx eslint . --fix",
     "example-server-udp": "node example/server/udp.js",
     "example-server-tcp": "node example/server/tcp.js",
     "example-server-doh": "node example/server/doh.js",
@@ -13,30 +25,32 @@
     "example-client-udp": "node example/client/udp.js",
     "example-client-tcp": "node example/client/tcp.js",
     "example-client-google": "node example/client/google.js",
-    "example-client-udp-subnet": "node example/client/udp-subnet.js"
+    "example-client-udp-subnet": "node example/client/udp-subnet.js",
+    "benchmark": "node benchmark/udp.js"
   },
   "keywords": [
     "dns"
   ],
-  "author": "Liu Song <hi@lsong.org>",
+  "author": "Liu Song <song940@gmail.com>",
   "contributors": [
     "Andris Reinman <andris.reinman@gmail.com>",
     "Eviltik <eviltik@gmail.com>",
-    "Martin Heidegger <martin.heidegger@gmail.com>"
+    "Martin Heidegger <martin.heidegger@gmail.com>",
+    "Matt Simerson <matt@tnpi.net>"
   ],
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/song940/node-dns.git"
+    "url": "git+https://github.com/lsongdev/node-dns.git"
   },
   "bugs": {
-    "url": "https://github.com/song940/node-dns/issues"
+    "url": "https://github.com/lsongdev/node-dns/issues"
   },
-  "homepage": "https://github.com/song940/node-dns#readme",
+  "homepage": "https://github.com/lsongdev/node-dns#readme",
   "devDependencies": {
-    "eslint": "^7.28.0",
-    "eslint-config-semistandard": "^15.0.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^4.2.1"
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "eslint": "^10.4.0",
+    "globals": "^17.6.0"
   }
 }

package/packet.js

@@ -1,4 +1,5 @@
-const { debuglog } = require('util');
+const { debuglog } = require('node:util');
+const { randomInt } = require('node:crypto');
 const BufferReader = require('./lib/reader');
 const BufferWriter = require('./lib/writer');
 
@@ -9,6 +10,34 @@ const toIPv6 = buffer => buffer
   .join(':')
   .replace(/\b(?:0+:){1,}/, ':');
 
+const fromIPv6 = (address) => {
+  const digits = address.split(':');
+  // CAVEAT edge case for :: and IPs starting
+  // or ending by ::
+  if (digits[0] === '') {
+    digits.shift();
+  }
+  if (digits[digits.length - 1] === '') {
+    digits.pop();
+  }
+  // node js 10 does not support Array.prototype.flatMap
+  if (!Array.prototype.flatMap) {
+    Array.prototype.flatMap = function(f, ctx) {
+      return this.reduce((r, x, i, a) => r.concat(f.call(ctx, x, i, a)), []);
+    };
+  }
+
+  // CAVEAT we have to take into account
+  // the extra space used by the empty string
+  const missingFields = 8 - digits.length + 1;
+  return digits.flatMap((digit) => {
+    if (digit === '') {
+      return Array(missingFields).fill('0');
+    }
+    return digit.padStart(4, '0');
+  });
+};
+
 /**
  * [Packet description]
  * @param {[type]} data [description]
@@ -55,31 +84,32 @@ function Packet(data) {
  * @docs https://tools.ietf.org/html/rfc1035#section-3.2.2
  */
 Packet.TYPE = {
-  A     : 0x01,
-  NS    : 0x02,
-  MD    : 0x03,
-  MF    : 0x04,
-  CNAME : 0x05,
-  SOA   : 0x06,
-  MB    : 0x07,
-  MG    : 0x08,
-  MR    : 0x09,
-  NULL  : 0x0A,
-  WKS   : 0x0B,
-  PTR   : 0x0C,
-  HINFO : 0x0D,
-  MINFO : 0x0E,
-  MX    : 0x0F,
-  TXT   : 0x10,
-  AAAA  : 0x1C,
-  SRV   : 0x21,
-  EDNS  : 0x29,
-  SPF   : 0x63,
-  AXFR  : 0xFC,
-  MAILB : 0xFD,
-  MAILA : 0xFE,
-  ANY   : 0xFF,
-  CAA   : 0x101,
+  A      : 0x01,
+  NS     : 0x02,
+  MD     : 0x03,
+  MF     : 0x04,
+  CNAME  : 0x05,
+  SOA    : 0x06,
+  MB     : 0x07,
+  MG     : 0x08,
+  MR     : 0x09,
+  NULL   : 0x0A,
+  WKS    : 0x0B,
+  PTR    : 0x0C,
+  HINFO  : 0x0D,
+  MINFO  : 0x0E,
+  MX     : 0x0F,
+  TXT    : 0x10,
+  AAAA   : 0x1C,
+  SRV    : 0x21,
+  EDNS   : 0x29,
+  SPF    : 0x63,
+  AXFR   : 0xFC,
+  MAILB  : 0xFD,
+  MAILA  : 0xFE,
+  ANY    : 0xFF,
+  CAA    : 0x101,
+  DNSKEY : 0x30,
 };
 /**
  * [QUERY_CLASS description]
@@ -93,6 +123,19 @@ Packet.CLASS = {
   HS  : 0x04,
   ANY : 0xFF,
 };
+/**
+ * DNS response codes
+ * @type {Object}
+ * @docs https://tools.ietf.org/html/rfc1035#section-4.1.1
+ */
+Packet.RCODE = {
+  NOERROR  : 0,
+  FORMERR  : 1,
+  SERVFAIL : 2,
+  NXDOMAIN : 3,
+  NOTIMP   : 4,
+  REFUSED  : 5,
+};
 /**
  * [EDNS_OPTION_CODE description]
  * @type {Object}
@@ -103,11 +146,13 @@ Packet.EDNS_OPTION_CODE = {
 };
 
 /**
- * [uuid description]
- * @return {[type]} [description]
+ * Generate a cryptographically random 16-bit DNS transaction ID.
+ * RFC 5452 §3 — the full 16-bit space must be used from a CSPRNG to make
+ * response forgery / cache poisoning impractical.
+ * @return {number} integer in [0, 0xFFFF]
  */
 Packet.uuid = function() {
-  return Math.floor(Math.random() * 1e5);
+  return randomInt(0x10000);
 };
 
 /**
@@ -151,7 +196,6 @@ Object.defineProperty(Packet.prototype, 'recursive', {
   },
   set(yn) {
     this.header.rd = +yn;
-    return this.header.rd;
   },
 });
 
@@ -358,9 +402,18 @@ Packet.Resource.encode = function(resource, writer) {
   })[0];
   if (encoder in Packet.Resource && Packet.Resource[encoder].encode) {
     return Packet.Resource[encoder].encode(resource, writer);
-  } else {
-    debug('node-dns > unknown encoder %s(%j)', encoder, resource.type);
   }
+  debug('node-dns > unknown encoder %s(%j)', encoder, resource.type);
+  // Fallback for unknown / decoder-only types: round-trip the raw RDATA the
+  // decoder preserved as `resource.data`. Without this, RDLENGTH and RDATA
+  // would be omitted entirely, truncating the wire format and corrupting any
+  // records that follow.
+  const data = Buffer.isBuffer(resource.data) ? resource.data : Buffer.alloc(0);
+  writer.write(data.length, 16);
+  for (const byte of data) {
+    writer.write(byte, 8);
+  }
+  return writer.toBuffer();
 };
 /**
  * [parse description]
@@ -524,7 +577,7 @@ Packet.Resource.AAAA = {
   },
   encode: function(record, writer) {
     writer = writer || new Packet.Writer();
-    const parts = record.address.split(':');
+    const parts = fromIPv6(record.address);
     writer.write(parts.length * 2, 16);
     parts.forEach(function(part) {
       writer.write(parseInt(part, 16), 16);
@@ -576,7 +629,7 @@ Packet.Resource.SPF =
 Packet.Resource.TXT = {
   decode: function(reader, length) {
     const parts = [];
-    let bytesRead = 0; let chunkLength = 0;
+    let bytesRead = 0; let chunkLength;
 
     while (bytesRead < length) {
       chunkLength = reader.read(8); // text length
@@ -764,21 +817,30 @@ Packet.Resource.EDNS.ECS.decode = function(reader, length) {
   rdata.scopePrefixLength = reader.read(8);
   length -= 4;
 
-  if (rdata.family !== 1) {
-    debug('node-dns > unimplemented address family');
-    reader.read(length * 8); // Ignore data that doesn't understand
-    return rdata;
+  if (rdata.family === 1) {
+    const ipv4Octets = [];
+    while (length--) {
+      const octet = reader.read(8);
+      ipv4Octets.push(octet);
+    }
+    while (ipv4Octets.length < 4) {
+      ipv4Octets.push(0);
+    }
+    rdata.ip = ipv4Octets.join('.');
   }
 
-  const ipv4Octets = [];
-  while (length--) {
-    const octet = reader.read(8);
-    ipv4Octets.push(octet);
-  }
-  while (ipv4Octets.length < 4) {
-    ipv4Octets.push(0);
+  if (rdata.family === 2) {
+    const ipv6Segments = [];
+    for (; length; length -= 2) {
+      const segment = reader.read(16).toString(16);
+      ipv6Segments.push(segment);
+    }
+    while (ipv6Segments.length < 8) {
+      ipv6Segments.push('0');
+    }
+    rdata.ip = ipv6Segments.join(':');
   }
-  rdata.ip = ipv4Octets.join('.');
+
   return rdata;
 };
 
@@ -807,15 +869,135 @@ Packet.Resource.CAA = {
     });
     return writer.toBuffer();
   },
+  decode: function(reader, length) {
+    this.flags = reader.read(8);
+    const tagLength = reader.read(8);
+    const bytes = [];
+    let remaining = length - 2;
+    while (remaining--) bytes.push(reader.read(8));
+    const buffer = Buffer.from(bytes);
+    this.tag = buffer.slice(0, tagLength).toString('utf8');
+    this.value = buffer.slice(tagLength).toString('utf8');
+    return this;
+  },
+};
+
+/**
+ * @type {{decode: (function(*, *): Packet.Resource.DNSKEY)}}
+ * @link https://tools.ietf.org/html/rfc4034
+ * @link https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml#table-dns-sec-alg-numbers-1
+ */
+Packet.Resource.DNSKEY = {
+  decode: function(reader, length) {
+    const RData = [];
+    while (RData.length < length) {
+      RData.push(reader.read(8));
+    }
+    this.flags = RData[0] << 8 | RData[1];
+    this.protocol = RData[2];
+    this.algorithm = RData[3];
+    // for key tag
+    let ac = 0;
+    for (let i = 0; i < length; ++i) {
+      ac += (i & 1) ? RData[i] : RData[i] << 8;
+    }
+    ac += (ac >> 16) & 0xFFFF;
+    this.keyTag = ac & 0XFFFF;
+
+    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 = 16
+    // convert binary flags
+    let binFlags = this.flags.toString(2);
+    // add left padding until 16 chars
+    while (binFlags.length < 16) {
+      binFlags = '0' + binFlags;
+    }
+    this.zoneKey = binFlags[7] === '1';
+    this.zoneSep = binFlags[15] === '1';
+    this.key = Buffer.from(RData.slice(4)).toString('base64');
+    return this;
+  },
+  encode: function(record, writer) {
+    writer = writer || new Packet.Writer();
+    const buffer = Buffer.from(record.key, 'base64');
+    writer.write(4 + buffer.length, 16);
+    writer.write(record.flags, 16);
+    writer.write(record.protocol, 8);
+    writer.write(record.algorithm, 8);
+    buffer.forEach(function(c) {
+      writer.write(c, 8);
+    });
+    return writer.toBuffer();
+  },
+};
+
+/**
+ * RRSIG just support decode
+ * test with dns.resolveRRSIG('example.com')
+ *
+ * @type {{decode: (function(*, *): Packet.Resource.RRSIG)}}
+ */
+Packet.Resource.RRSIG = {
+  decode: function(reader, length) {
+    function dateForSig(date) {
+      // javascript date is from millisecond
+      date = new Date(date * 1000);
+      const definitions = {
+        month   : (date.getUTCMonth() + 1),
+        date    : date.getUTCDate(),
+        hour    : date.getUTCHours(),
+        minutes : date.getUTCMinutes(),
+        seconds : date.getUTCSeconds(),
+      };
+      let i;
+      for (i in definitions) {
+        // if less than 10 > single
+        if (definitions[i] < 10) {
+          definitions[i] = '0' + '' + definitions[i];
+        }
+      }
+      return date.getFullYear() + '' +
+        definitions.month + '' +
+        definitions.date + '' +
+        definitions.hour + '' +
+        definitions.minutes + '' +
+        definitions.seconds;
+    }
+
+    // calculate max-offset uint8
+    const maxOffset = reader.offset + (length * 8);
+    /*
+     * Stuff sign contains 18 octets
+     */
+    this.sigType = reader.read(16); // 2
+    this.algorithm = reader.read(8); // 1
+    this.labels = reader.read(8); // 1
+    this.originalTtl = reader.read(32); // 4
+    this.expiration = dateForSig(reader.read(32)); // 4
+    this.inception = dateForSig(reader.read(32)); // 4
+    this.keyTag = reader.read(16); // 2
+    this.signer = Packet.Name.decode(reader);
+    const maxLength = (maxOffset - reader.offset) / 8;
+    const signature = [];
+    while (signature.length < maxLength) {
+      signature.push(reader.read(8));
+    }
+    this.signature = Buffer.from(signature).toString('base64');
+    return this;
+  },
 };
 
 Packet.Reader = BufferReader;
 Packet.Writer = BufferWriter;
 
 Packet.createResponseFromRequest = function(request) {
-  const response = new Packet(request);
-  response.header.qr = 1;
-  response.additionals = [];
+  const response = new Packet();
+  response.header = new Packet.Header({
+    id     : request.header.id,
+    opcode : request.header.opcode,
+    rd     : request.header.rd,
+    qr     : 1,
+  });
+  response.questions = request.questions.slice();
   return response;
 };
 
@@ -874,3 +1056,4 @@ Packet.prototype.toBase64URL = function() {
 
 module.exports = Packet;
 module.exports.toIPv6 = toIPv6;
+module.exports.fromIPv6 = fromIPv6;

package/server/dns.js

@@ -1,4 +1,5 @@
-const EventEmitter = require('events');
+const EventEmitter = require('node:events');
+const Packet = require('../packet');
 const DOHServer = require('./doh');
 const TCPServer = require('./tcp');
 const UDPServer = require('./udp');
@@ -34,7 +35,23 @@ class DNSServer extends EventEmitter {
       return addresses;
     });
 
-    const emitRequest = (request, send, client) => this.emit('request', request, send, client);
+    const maxConcurrent = options.maxConcurrent > 0 ? options.maxConcurrent : 0;
+    let active = 0;
+
+    const emitRequest = (request, send, client) => {
+      if (maxConcurrent && active >= maxConcurrent) {
+        const response = Packet.createResponseFromRequest(request);
+        response.header.rcode = Packet.RCODE.SERVFAIL;
+        send(response);
+        return;
+      }
+      active++;
+      const wrappedSend = (...args) => {
+        active--;
+        return send(...args);
+      };
+      this.emit('request', request, wrappedSend, client);
+    };
     const emitRequestError = (error) => this.emit('requestError', error);
     for (const server of servers) {
       server.on('request', emitRequest);

package/server/doh.js

@@ -1,9 +1,9 @@
-const http = require('http');
-const https = require('https');
-const { URL } = require('url');
+const http = require('node:http');
+const https = require('node:https');
+const { URL } = require('node:url');
 const Packet = require('../packet');
-const EventEmitter = require('events');
-const { debuglog } = require('util');
+const EventEmitter = require('node:events');
+const { debuglog } = require('node:util');
 
 const debug = debuglog('dns2-server');
 
@@ -20,11 +20,11 @@ const decodeBase64URL = str => {
 };
 
 const readStream = stream => new Promise((resolve, reject) => {
-  let buffer = '';
+  const chunks = [];
   stream
     .on('error', reject)
-    .on('data', chunk => { buffer += chunk; })
-    .on('end', () => resolve(buffer));
+    .on('data', chunk => chunks.push(chunk))
+    .on('end', () => resolve(Buffer.concat(chunks)));
 });
 
 class Server extends EventEmitter {
@@ -139,6 +139,7 @@ class Server extends EventEmitter {
   }
 
   close() {
+    this.server.closeIdleConnections();
     return this.server.close();
   }
 }

package/server/tcp.js

@@ -1,4 +1,4 @@
-const tcp = require('net');
+const tcp = require('node:net');
 const Packet = require('../packet');
 
 class Server extends tcp.Server {

package/server/udp.js

@@ -1,4 +1,4 @@
-const udp = require('dgram');
+const udp = require('node:dgram');
 const Packet = require('../packet');
 
 /**
@@ -10,7 +10,7 @@ class Server extends udp.Socket {
   constructor(options) {
     let type = 'udp4';
     if (typeof options === 'object') {
-      type = options.type;
+      type = options.type ?? type;
     }
     super(type);
     if (typeof options === 'function') {