Support for unencrypted DNS

README.md

@@ -43,6 +43,8 @@ Options:
   --port          port address to bind proxy server     [number] [default: 8000]
   --dns-type               [string] [choices: "https", "tls"] [default: "https"]
   --dns-server        [string] [default: "https://cloudflare-dns.com/dns-query"]
+  --dns-ip        IP address for unencrypted DNS  [string][default: "127.0.0.1"]
+  --dns-port      Port for unencrypted DNS                [number] [default: 53]
   --silent, -s    run in silent mode                  [boolean] [default: false]
   --verbose, -v   debug mode                              [string] [default: ""]
   --system-proxy  automatic set system-proxy           [boolean] [default: true]

bin/gt.js

@@ -7,11 +7,11 @@ const ora = require('ora');
 const debug = require('debug');
 const yargs = require('yargs');
 const pkg = require('../package.json');
-const {Proxy, config, getLogger} = require('../src/index.cjs');
+const { Proxy, config, getLogger } = require('../src/index.cjs');
 
 const logger = getLogger('cli');
 
-const {argv} = yargs
+const { argv } = yargs
 	.usage('Usage: green-tunnel [options]')
 	.usage('Usage: gt [options]')
 	.alias('help', 'h')
@@ -37,7 +37,7 @@ const {argv} = yargs
 
 	.option('dns-type', {
 		type: 'string',
-		choices: ['https', 'tls'],
+		choices: ['https', 'tls', 'unencrypted'],
 		default: config.dns.type,
 	})
 
@@ -46,6 +46,16 @@ const {argv} = yargs
 		default: config.dns.server,
 	})
 
+	.option('dns-ip', {
+		type: 'string',
+		default: config.dns.ip,
+	})
+
+	.option('dns-port', {
+		type: 'number',
+		default: config.dns.port,
+	})
+
 	.option('silent', {
 		alias: 's',
 		type: 'boolean',
@@ -113,7 +123,9 @@ async function main() {
 		httpsOnly: argv['https-only'],
 		dns: {
 			type: argv['dns-type'],
-			server: argv['dns-server']
+			server: argv['dns-server'],
+			ip: argv['dns-ip'],
+			port: argv['dns-port']
 		},
 		source: 'CLI',
 	});
@@ -138,12 +150,12 @@ async function main() {
 	process.on('unhandledRejection', errorTrap);
 	process.on('uncaughtException', errorTrap);
 
-	await proxy.start({setProxy: argv['system-proxy']});
+	await proxy.start({ setProxy: argv['system-proxy'] });
 
 	if (!argv['silent'] && !argv['verbose']) {
 		clear();
 		printBanner();
-		updateNotifier({pkg}).notify();
+		updateNotifier({ pkg }).notify();
 		printAlert(proxy);
 		showSpinner();
 	}

package.json

@@ -38,6 +38,7 @@
     "debug": "^4.1.1",
     "dns-over-http": "^0.1.2",
     "dns-over-tls": "0.0.6",
+    "dns-socket": "^4.2.2",
     "esm": "^3.2.22",
     "is-docker": "^2.0.0",
     "lru-cache": "^5.1.1",

src/config.js

@@ -4,8 +4,10 @@ const config = {
 	httpsOnly: false,
 	clientHelloMTU: 100,
 	dns: {
-		type: 'https', // 'tls' or 'https'
+		type: 'https', // 'tls' or 'https' or 'unencrypted'
 		server: 'https://cloudflare-dns.com/dns-query',
+		ip: '127.0.0.1',
+		port: 53,
 		cacheSize: 1000,
 	}
 };

src/dns/base.js

@@ -1,5 +1,5 @@
 import LRU from 'lru-cache';
-import {isIP} from 'validator';
+import { isIP } from 'validator';
 import getLogger from '../logger';
 import config from '../config';
 

src/dns/unencrypted.js

@@ -0,0 +1,25 @@
+import dnsSocket from 'dns-socket';
+import BaseDNS from './base';
+
+const socket = dnsSocket()
+
+export default class DNSUnencrypted extends BaseDNS {
+  constructor(dnsIp, dnsPort) {
+    super();
+    this.dnsIp = dnsIp;
+    this.dnsPort = dnsPort;
+  }
+
+  _lookup(hostname) {
+    return new Promise((resolve, reject) => {
+      socket.query({
+        questions: [{
+          type: 'A',
+          name: hostname
+        }]
+      }, this.dnsPort, this.dnsIp, (err, res, query) => {
+        resolve(res.answers[0].data);
+      });
+    });
+  }
+}

src/proxy.js

@@ -1,33 +1,38 @@
 import net from 'net';
-import {setProxy, unsetProxy} from './utils/system-proxy';
+import { setProxy, unsetProxy } from './utils/system-proxy';
 import handleRequest from './handlers/request';
 import DNSOverTLS from './dns/tls';
 import DNSOverHTTPS from './dns/https';
+import DNSUnencrypted from './dns/unencrypted';
 import config from './config';
 import getLogger from './logger';
-import {appInit} from './utils/analytics';
+import { appInit } from './utils/analytics';
 
 const logger = getLogger('proxy');
 
 export default class Proxy {
 	constructor(customConfig) {
-		this.config = {...config, ...customConfig};
+		this.config = { ...config, ...customConfig };
 		this.server = undefined;
 		this.isSystemProxySet = false;
 		this.initDNS();
 		appInit(customConfig.source);
 	}
 
 	initDNS() {
-		this.dns = this.config.dns.type === 'https' ?
-			new DNSOverHTTPS(this.config.dns.server) :
-			new DNSOverTLS(this.config.dns.server);
+		if (this.config.dns.type === 'https') {
+			this.dns = new DNSOverHTTPS(this.config.dns.server);
+		} else if (this.config.dns.type === 'tls') {
+			this.dns = new DNSOverTLS(this.config.dns.server);
+		} else {
+			this.dns = new DNSUnencrypted(this.config.dns.ip, this.config.dns.port);
+		}
 	}
 
 	async start(options = {}) {
 		options.setProxy = options.setProxy === undefined ? false : options.setProxy;
 
-		this.server = net.createServer({pauseOnConnect: true}, clientSocket => {
+		this.server = net.createServer({ pauseOnConnect: true }, clientSocket => {
 			handleRequest(clientSocket, this).catch(err => {
 				logger.debug(String(err));
 			});
@@ -45,7 +50,7 @@ export default class Proxy {
 			this.server.listen(this.config.port, this.config.ip, () => resolve());
 		});
 
-		const {address, port} = this.server.address();
+		const { address, port } = this.server.address();
 		logger.debug(`server listen on ${address} port ${port}`);
 
 		if (options.setProxy) {