dns2 1.5.0 → 2.0.2

package/server/dns.js

@@ -0,0 +1,94 @@
+const EventEmitter = require('events');
+const DOHServer = require('./doh');
+const TCPServer = require('./tcp');
+const UDPServer = require('./udp');
+
+class DNSServer extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.servers = {};
+    if (options.doh) {
+      this.servers.doh = (new DOHServer(options.doh))
+        .on('error', error => this.emit('error', error, 'doh'));
+    }
+    if (options.tcp) {
+      this.servers.tcp = (new TCPServer())
+        .on('error', error => this.emit('error', error, 'tcp'));
+    }
+    if (options.udp) {
+      this.servers.udp = (new UDPServer(typeof options.udp === 'object' ? options.udp : undefined))
+        .on('error', error => this.emit('error', error, 'udp'));
+    }
+    const servers = Object.values(this.servers);
+    this.closed = Promise.all(
+      servers.map(server => new Promise(resolve => server.once('close', resolve))),
+    ).then(() => {
+      this.emit('close');
+    });
+
+    this.listening = Promise.all(
+      servers.map(server => new Promise(resolve => server.once('listening', resolve))),
+    ).then(() => {
+      const addresses = this.addresses();
+      this.emit('listening', addresses);
+      return addresses;
+    });
+
+    const emitRequest = (request, send, client) => this.emit('request', request, send, client);
+    const emitRequestError = (error) => this.emit('requestError', error);
+    for (const server of servers) {
+      server.on('request', emitRequest);
+      server.on('requestError', emitRequestError);
+    }
+
+    if (options.handle) {
+      this.on('request', options.handle.bind(options));
+    }
+  }
+
+  addresses() {
+    const addresses = {};
+    const { udp, tcp, doh } = this.servers;
+    if (udp) {
+      addresses.udp = udp.address();
+    }
+    if (tcp) {
+      addresses.tcp = tcp.address();
+    }
+    if (doh) {
+      addresses.doh = doh.address();
+    }
+    return addresses;
+  }
+
+  listen(options = {}) {
+    for (const serverType of Object.keys(this.servers)) {
+      const server = this.servers[serverType];
+      const serverOptions = options[serverType]; // Port or { port, address }
+
+      if (serverOptions && serverOptions.port) {
+        server.listen(serverOptions.port, serverOptions.address);
+      } else {
+        server.listen(serverOptions);
+      }
+    }
+
+    return this.listening;
+  }
+
+  close() {
+    const { doh, udp, tcp } = this.servers;
+    if (udp) {
+      udp.close();
+    }
+    if (tcp) {
+      tcp.close();
+    }
+    if (doh) {
+      doh.close();
+    }
+    return this.closed;
+  }
+}
+
+module.exports = DNSServer;

package/server/doh.js

@@ -1,143 +1,146 @@
 const http = require('http');
 const https = require('https');
-const fs = require('fs');
-const url = require('url');
-const EventEmitter = require("events");
+const { URL } = require('url');
 const Packet = require('../packet');
-  
-class Server extends EventEmitter {
-    constructor(options) {
-        super();
+const EventEmitter = require('events');
+const { debuglog } = require('util');
 
-        // Set defaults and then check what the cat brought in
-        var port = 80
-        var sslport = 443;
-        var cert = '';
-        var key = '';
-        if (typeof options === 'object') {
-            if (options.http) port = options.port;
-            if (options.sslport) sslport = options.sslport;
-            if (options.cert) cert = options.cert;
-            if (options.key) key = options.key;
-        }
+const debug = debuglog('dns2-server');
 
-        //If no cert or key specified make a futile atempt of reading default names
-        if (cert=='') cert = fs.readFileSync(path.join(__dirname,"server.crt"));
-        if (key=='') key = fs.readFileSync(path.join(__dirname,"secret.key"));
+const decodeBase64URL = str => {
+  let queryData = str
+    .replace(/-/g, '+')
+    .replace(/_/g, '/');
+  const pad = queryData.length % 4;
+  if (pad === 1) return;
+  if (pad) {
+    queryData += new Array(5 - pad).join('=');
+  }
+  return queryData;
+};
 
-        // if http port is specified create http server. However DoH needs SSL so a proxy must be infront.
-        if (port!=0)
-            var httpOptions = {                    
-            };
-            var httpServer = http.createServer(httpOptions).listen(port, function(){
-                this.emit('listening', "http", port);
-            });    
-            httpServer.on("request", this.handleRequest.bind(this)) 
+const readStream = stream => new Promise((resolve, reject) => {
+  let buffer = '';
+  stream
+    .on('error', reject)
+    .on('data', chunk => { buffer += chunk; })
+    .on('end', () => resolve(buffer));
+});
 
-        // if SSL-port, key and cert is specified then create an SSL endpoint
-        if (sslport!=0&&key!=''&&cert!='')
-            var httpsOptions = {
-                key: key,
-                cert: cert
-            };
-            var httpsServer = https.createServer(httpsOptions).listen(sslport, function(){
-                this.emit('listening', "https", sslport);
-            });   
-            httpsServer.on("request", this.handleRequest.bind(this)) 
-    };
+class Server extends EventEmitter {
+  constructor(options) {
+    super();
+    const { ssl } = Object.assign(this, { cors: true }, options);
+    this.server = (ssl ? https.createServer(options) : http.createServer())
+      .on('request', this.handleRequest.bind(this))
+      .on('listening', () => this.emit('listening', this.address()))
+      .on('error', error => this.emit('error', error))
+      .on('close', () => {
+        this.server.removeAllListeners();
+        this.emit('close');
+      });
+    return this;
+  }
 
-    handleRequest(req,res) {
-            
-        // We are only handling get and post as reqired by rfc
-        const method = req.method;            
-        if ((method!="GET" && method!="POST")) {
-            res.writeHead(405, {"Content-Type": "text/plain"});
-            res.write("405 Method not allowed\n");
-            res.end();
-            return;
+  async handleRequest(client, res) {
+    try {
+      const { method, url, headers } = client;
+      const { pathname, searchParams: query } = new URL(url, 'http://unused/');
+      const { cors } = this;
+      if (cors === true) {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+      } else if (typeof cors === 'string') {
+        res.setHeader('Access-Control-Allow-Origin', cors);
+        res.setHeader('Vary', 'Origin');
+      } else if (typeof cors === 'function') {
+        const isAllowed = cors(headers.origin);
+        res.setHeader('Access-Control-Allow-Origin', isAllowed ? headers.origin : 'false');
+        res.setHeader('Vary', 'Origin');
+      }
+      // debug
+      debug('request', method, url);
+      // We are only handling get and post as reqired by rfc
+      if ((method !== 'GET' && method !== 'POST')) {
+        res.writeHead(405, { 'Content-Type': 'text/plain' });
+        res.write('405 Method not allowed\n');
+        res.end();
+        return;
+      }
+      // Check so the uri is correct
+      if (pathname !== '/dns-query') {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.write('404 Not Found\n');
+        res.end();
+        return;
+      }
+      // Make sure the requestee is requesting the correct content type
+      const contentType = headers.accept;
+      if (contentType !== 'application/dns-message') {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        res.write('400 Bad Request: Illegal content type\n');
+        res.end();
+        return;
+      }
+      let queryData;
+      if (method === 'GET') {
+        // Parse query string for the request data
+        const dns = query.get('dns');
+        if (!dns) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.write('400 Bad Request: No query defined\n');
+          res.end();
+          return;
         }
-    
-        // Check so the uri is correct
-        const uri = url.parse(req.url).pathname;
-        if (uri!="/dns-query") {
-            res.writeHead(404, {"Content-Type": "text/plain"});
-            res.write("404 Not Found\n");
-            res.end();
-            return;
+        // Decode from Base64Url Encoding
+        const base64 = decodeBase64URL(dns);
+        if (!base64) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.write('400 Bad Request: Invalid query data\n');
+          res.end();
+          return;
         }
-        
-        // Make sure the requestee is requesting the correct content type
-        const contentType = req.headers['accept'];
-        if (contentType!="application/dns-message") {
-            res.writeHead(400, {"Content-Type": "text/plain"});
-            res.write("400 Bad Request: Illegal content type\n");
-            res.end();
-            return;
-        }
-    
-        var queryData = {};
-    
-        if (method == 'GET') {
-            //Parse query string for the request data
-            const queryObject = url.parse(req.url,true).query;
-            if (!queryObject.dns) {
-                res.writeHead(400, {"Content-Type": "text/plain"});
-                res.write("400 Bad Request: No query defined\n");
-                res.end();
-                return;
-            }
-            
-            //Decode from Base64Url Encoding
-            var queryData = queryObject.dns.replace(/-/g, '+').replace(/_/g, '/');
-            var pad = queryData.length % 4;
-            if(pad) {
-                if(pad === 1) {
-                    res.writeHead(400, {"Content-Type": "text/plain"});
-                    res.write("400 Bad Request: Invalid query data\n");
-                    res.end();
-                    return;
-                }
-                queryData += new Array(5-pad).join('=');
-            }
+        // Decode Base64 to buffer
+        queryData = Buffer.from(base64, 'base64');
+      } else if (method === 'POST') {
+        queryData = await readStream(client);
+      }
+      // Parse DNS query and Raise event.
+      const message = Packet.parse(queryData);
+      this.emit('request', message, this.response.bind(this, res), client);
+    } catch (e) {
+      this.emit('requestError', e);
+      res.destroy();
+    }
+  }
 
-            //Decode Base64 to buffer
-            queryData = Buffer.from(queryData, 'base64');
-            const message = Packet.parse(queryData);
-    
-            //Raise event
-            this.emit('request', message, this.response.bind(this, res), req);
-    
-        } else {
-    
-            // Collect request from client and..
-            collectRequestData.then((request)=>{
-                const message = Packet.parse(request);
-    
-                //then raise the event
-                this.emit('request', message, this.response.bind(this, res), req);    
-            });
-        }
-        
-    }; 
+  /**
+   * Send of the response to the client
+   * @param {*} res
+   * @param {*} message
+   */
+  response(res, message) {
+    debug('response');
+    res.setHeader('Content-Type', 'application/dns-message');
+    res.writeHead(200);
+    res.end(message.toBuffer());
+  }
 
-    // Send of the response to the client
-    response(res, message) {
-        res.setHeader('Content-Type', 'application/dns-message');
-        res.writeHead(200);
-        res.end(message.toBuffer());
-    };
+  /**
+   * listen
+   * @param {*} port
+   * @returns
+   */
+  listen(port, address) {
+    return this.server.listen(port || this.port, address);
+  }
 
-    // Wait for the request body to be received
-    async collectRequestData(request) {
-        let body = '';
-        request.on('data', chunk => {
-            body += chunk;
-        });
-        request.on('end', () => {
-            callback(body);
-        });
-    };
+  address() {
+    return this.server.address();
+  }
 
+  close() {
+    return this.server.close();
+  }
 }
 
-module.exports = Server;
+module.exports = Server;

package/server/index.js

@@ -1,6 +1,7 @@
 const UDPServer = require('./udp');
 const TCPServer = require('./tcp');
 const DOHServer = require('./doh');
+const DNSServer = require('./dns');
 
 const createUDPServer = options => {
   return new UDPServer(options);
@@ -12,13 +13,19 @@ const createTCPServer = options => {
 
 const createDOHServer = options => {
   return new DOHServer(options);
-}
+};
+
+const createServer = options => {
+  return new DNSServer(options);
+};
 
 module.exports = {
   UDPServer,
   TCPServer,
   DOHServer,
+  DNSServer,
   createTCPServer,
   createUDPServer,
-  createDOHServer
-};
+  createDOHServer,
+  createServer,
+};

package/server/tcp.js

@@ -9,18 +9,26 @@ class Server extends tcp.Server {
     }
     this.on('connection', this.handle.bind(this));
   }
+
   async handle(client) {
-    const data = await Packet.readStream(client);
-    const message = Packet.parse(data);
-    this.emit('request', message, this.response.bind(this, client), client);
+    try {
+      const data = await Packet.readStream(client);
+      const message = Packet.parse(data);
+      this.emit('request', message, this.response.bind(this, client), client);
+    } catch (e) {
+      this.emit('requestError', e);
+      client.destroy();
+    }
   }
+
   response(client, message) {
-    if (message instanceof Packet)
+    if (message instanceof Packet) {
       message = message.toBuffer();
+    }
     const len = Buffer.alloc(2);
     len.writeUInt16BE(message.length);
-    client.end(Buffer.concat([len, message]));
+    client.end(Buffer.concat([ len, message ]));
   }
 }
 
-module.exports = Server;
+module.exports = Server;

package/server/udp.js

@@ -18,13 +18,18 @@ class Server extends udp.Socket {
     }
     this.on('message', this.handle.bind(this));
   }
+
   handle(data, rinfo) {
-    const message = Packet.parse(data);
-    this.emit('request', message, this.response.bind(this, rinfo), rinfo);
+    try {
+      const message = Packet.parse(data);
+      this.emit('request', message, this.response.bind(this, rinfo), rinfo);
+    } catch (e) {
+      this.emit('requestError', e);
+    }
   }
+
   response(rinfo, message) {
-    if (message instanceof Packet)
-      message = message.toBuffer();
+    if (message instanceof Packet) { message = message.toBuffer(); }
     return new Promise((resolve, reject) => {
       this.send(message, rinfo.port, rinfo.address, err => {
         if (err) return reject(err);
@@ -32,6 +37,7 @@ class Server extends udp.Socket {
       });
     });
   }
+
   listen(port, address) {
     return new Promise(resolve =>
       this.bind(port, address, resolve));