green-tunnel 2.0.1 → 3.0.2

package/src/dns/tls.js

@@ -1,15 +0,0 @@
-import dnstls from 'dns-over-tls';
-import BaseDNS from './base.js';
-
-export default class DNSOverTLS extends BaseDNS {
-	async _lookup(hostname) {
-		const {answers} = await dnstls.query(hostname);
-
-		const answer = answers.find(answer => answer.type === 'A' && answer.class === 'IN');
-
-		if (answer) {
-			return answer.data;
-		}
-	}
-}
-

package/src/dns/unencrypted.js

@@ -1,25 +0,0 @@
-import dnsSocket from 'dns-socket';
-import BaseDNS from './base.js';
-
-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);
-      });
-    });
-  }
-}

package/src/handlers/http.js

@@ -1,65 +0,0 @@
-import {URL} from 'url';
-import {isStartOfHTTPRequest} from '../http/utils.js';
-import {createConnection, closeSocket, tryWrite} from '../utils/socket.js';
-import HTTPRequest from '../http/request.js';
-import getLogger from '../logger.js';
-
-const logger = getLogger('https-handler');
-
-export default async function handleHTTP(clientSocket, firstChunk, proxy) {
-	const firstLine = firstChunk.toString().split('\r\n')[0];
-	const url = new URL(firstLine.split(/\s+/)[1]);
-
-	const host = url.hostname;
-	const port = url.port || 80;
-
-	logger.debug(`[HTTP REQUEST] ${url.host}`);
-
-	// -- ServerSocket --
-
-	const serverSocket = await createConnection({host, port}, proxy.dns);
-
-	const close = () => {
-		closeSocket(clientSocket);
-		closeSocket(serverSocket);
-	};
-
-	tryWrite(serverSocket, interceptRequest(firstChunk), close);
-
-	serverSocket.on('data', data => {
-		tryWrite(clientSocket, data, close);
-	});
-
-	serverSocket.on('error', error => {
-		close(error);
-	});
-
-	serverSocket.on('end', () => {
-		close();
-	});
-
-	// -- clientSocket --
-
-	clientSocket.on('data', data => {
-		tryWrite(serverSocket, interceptRequest(data), close);
-	});
-
-	clientSocket.on('end', () => {
-		close();
-	});
-
-	clientSocket.resume();
-}
-
-function interceptRequest(data) {
-	const strData = data.toString();
-
-	if (isStartOfHTTPRequest(strData)) {
-		const request = new HTTPRequest(strData);
-		request.path = new URL(request.path).pathname;
-		delete request.headers['Proxy-Connection'];
-		return request.toString();
-	}
-
-	return data;
-}

package/src/handlers/https.js

@@ -1,78 +0,0 @@
-import {URL} from 'url';
-import {bufferToChunks} from '../utils/buffer.js';
-import {createConnection, closeSocket, tryWrite} from '../utils/socket.js';
-import HTTPResponse from '../http/response.js';
-import getLogger from '../logger.js';
-
-const logger = getLogger('https-handler');
-
-export default async function handleHTTPS(clientSocket, firstChunk, proxy) {
-	const firstLine = firstChunk.toString().split('\r\n')[0];
-	const requestUrl = `https://${firstLine.split(/\s+/)[1]}`;
-	const url = new URL(requestUrl);
-
-	const host = url.hostname;
-	const port = url.port || 443;
-
-	logger.debug(`[HTTPS REQUEST] ${url.host}`);
-
-	// -- ServerSocket --
-
-	const serverSocket = await createConnection({host, port}, proxy.dns);
-
-	const close = () => {
-		closeSocket(clientSocket);
-		closeSocket(serverSocket);
-	};
-
-	serverSocket.on('data', data => {
-		logger.debug(`[HTTPS] receive from ${url.host} (length: ${data.length})`);
-		tryWrite(clientSocket, data, close);
-	});
-
-	serverSocket.on('end', () => {
-		logger.debug(`[HTTPS END] server ended ${url.host}`);
-		close();
-	});
-
-	serverSocket.on('error', error => {
-		logger.debug(`[HTTPS ERROR] server error ${error}`);
-		close(error);
-	});
-
-	// -- clientSocket --
-
-	clientSocket.once('data', clientHello => {
-		const chunks = bufferToChunks(clientHello, proxy.config.clientHelloMTU, proxy.config.tlsRecordFragmentation);
-		for (const chunk of chunks) {
-			logger.debug(`[HTTPS HELLO] ${url.host} (length: ${chunk.length})`);
-			tryWrite(serverSocket, chunk, close);
-		}
-
-		clientSocket.on('data', data => {
-			logger.debug(`[HTTPS] send to ${url.host} (length: ${data.length})`);
-			tryWrite(serverSocket, data, close);
-		});
-	});
-
-	clientSocket.on('end', () => {
-		logger.debug(`[HTTPS END] client ended ${url.host}`);
-		close();
-	});
-
-	clientSocket.on('error', error => {
-		logger.debug(`[HTTPS ERROR] client error ${error}`);
-		close(error);
-	});
-
-	tryWrite(clientSocket, getConnectionEstablishedPacket(), close);
-	clientSocket.resume();
-}
-
-function getConnectionEstablishedPacket() {
-	const packet = new HTTPResponse();
-	packet.statusCode = 200;
-	packet.statusMessgae = 'Connection Established';
-	return packet.toString();
-}
-

package/src/handlers/request.js

@@ -1,32 +0,0 @@
-import {isStartOfHTTPRequest, isConnectMethod} from '../http/utils.js';
-import handleHTTP from './http.js';
-import handleHTTPS from './https.js';
-
-export default async function handleRequest(clientSocket, proxy) {
-	clientSocket.resume();
-
-	return new Promise((resolve, reject) => {
-		clientSocket.once('data', async data => {
-			try {
-				clientSocket.pause();
-				const strData = data.toString();
-
-				if (isStartOfHTTPRequest(strData)) {
-					if (isConnectMethod(strData)) {
-						await handleHTTPS(clientSocket, data, proxy);
-					} else if (proxy.config.httpsOnly) {
-						throw new Error('Insecure request blocked: ', strData);
-					} else {
-						await handleHTTP(clientSocket, data, proxy);
-					}
-				} else {
-					throw new Error('Unsupported request: ', strData);
-				}
-
-				resolve();
-			} catch (error) {
-				reject(error);
-			}
-		});
-	});
-}

package/src/http/request.js

@@ -1,45 +0,0 @@
-import {parseRequest} from './utils.js';
-
-export default class HTTPRequest {
-	constructor(rawReq) {
-		if (rawReq) {
-			const packet = this._parseRequest(rawReq);
-			this.method = packet.method;
-			this.path = packet.path;
-			this.httpVersion = packet.httpVersion;
-			this.headers = packet.headers;
-			this.payload = packet.payload;
-		} else {
-			this.method = 'GET';
-			this.path = '/';
-			this.httpVersion = 'HTTP/1.1';
-			this.headers = {};
-			this.payload = '';
-		}
-	}
-
-	_parseRequest(rawReq) {
-		const {firstLineParts, ...request} = parseRequest(rawReq);
-
-		request.method = firstLineParts[0];
-		request.path = firstLineParts[1];
-		request.httpVersion = firstLineParts[2];
-
-		return request;
-	}
-
-	toString() {
-		let result = '';
-
-		result += `${this.method} ${this.path} ${this.httpVersion}\r\n`;
-
-		for (const header in this.headers) {
-			result += `${header}: ${this.headers[header]}\r\n`;
-		}
-
-		result += '\r\n';
-		result += this.payload;
-
-		return result;
-	}
-}

package/src/http/response.js

@@ -1,45 +0,0 @@
-import {parseRequest} from './utils.js';
-
-export default class HTTPResponse {
-	constructor(rawReq) {
-		if (rawReq) {
-			const packet = this._parseRequest(rawReq);
-			this.httpVersion = packet.httpVersion;
-			this.statusCode = packet.statusCode;
-			this.statusMessgae = packet.statusMessgae;
-			this.headers = packet.headers;
-			this.payload = packet.payload;
-		} else {
-			this.httpVersion = 'HTTP/1.1';
-			this.statusCode = 200;
-			this.statusMessgae = 'OK';
-			this.headers = {};
-			this.payload = '';
-		}
-	}
-
-	_parseResponse(rawRes) {
-		const {firstLineParts, ...request} = parseRequest(rawRes);
-
-		request.httpVersion = firstLineParts[0];
-		request.statusCode = firstLineParts[1];
-		request.statusMessgae = firstLineParts[2];
-
-		return request;
-	}
-
-	toString() {
-		let result = '';
-
-		result += `${this.httpVersion} ${this.statusCode} ${this.statusMessgae}\r\n`;
-
-		for (const header in this.headers) {
-			result += `${header}: ${this.headers[header]}\r\n`;
-		}
-
-		result += '\r\n';
-		result += this.payload;
-
-		return result;
-	}
-}

package/src/http/utils.js

@@ -1,86 +0,0 @@
-export function parseRequest(rawRequest) {
-	const mainParts = rawRequest.split('\r\n\r\n');
-	const headersPart = mainParts[0];
-	const payload = mainParts[1];
-
-	const headerLines = headersPart.split('\r\n');
-	const firsLine = headerLines.shift();
-
-	const firstLineParts = firsLine.split(/\s+/);
-	const headers = parseHeaders(headerLines);
-
-	return {
-		firstLineParts,
-		headers,
-		payload
-	};
-}
-
-export function parseHeaders(headerLines) {
-	const headers = {};
-
-	for (const line of headerLines) {
-		const [name, value] = line.split(/ *: */);
-		headers[name] = value;
-	}
-
-	return headers;
-}
-
-export function isConnectMethod(rawInput) {
-	const firstWord = rawInput.split(/\s+/)[0];
-	return firstWord.toUpperCase() === 'CONNECT';
-}
-
-export function isStartOfHTTPRequest(rawRequest) {
-	// Valid methods (for http request)
-	const firstWord = rawRequest.split(/\s+/)[0];
-	if (validMethods.includes(firstWord.toUpperCase())) {
-		return true;
-	}
-
-	// Like HTTP/1.1 (For http response)
-	const httpWord = firstWord.split('/')[0];
-	if (httpWord.toLowerCase() === 'http') {
-		return true;
-	}
-
-	return false;
-}
-
-const validMethods = [
-	'DELETE',
-	'GET',
-	'HEAD',
-	'POST',
-	'PUT',
-	'CONNECT',
-	'OPTIONS',
-	'TRACE',
-	'COPY',
-	'LOCK',
-	'MKCOL',
-	'MOVE',
-	'PROPFIND',
-	'PROPPATCH',
-	'SEARCH',
-	'UNLOCK',
-	'BIND',
-	'REBIND',
-	'UNBIND',
-	'ACL',
-	'REPORT',
-	'MKACTIVITY',
-	'CHECKOUT',
-	'MERGE',
-	'M-SEARCH',
-	'NOTIFY',
-	'SUBSCRIBE',
-	'UNSUBSCRIBE',
-	'PATCH',
-	'PURGE',
-	'MKCALENDAR',
-	'LINK',
-	'UNLINK'
-];
-

package/src/index.cjs

@@ -1,7 +0,0 @@
-'use strict';
-// CJS interop shim — green-tunnel is now an ES module.
-// CommonJS callers must use dynamic import:
-//   const gt = await import('green-tunnel');
-throw new Error(
-  'green-tunnel is an ES module. Use `import` (or dynamic `await import(\'green-tunnel\')`) instead of `require()`.'
-);

package/src/index.js

@@ -1,4 +0,0 @@
-export {default as Proxy} from './proxy.js';
-export {default as config} from './config.js';
-export {default as handleRequest} from './handlers/request.js';
-export {default as getLogger} from './logger.js';

package/src/logger.js

@@ -1,11 +0,0 @@
-import debug from 'debug';
-
-export default function getLogger(name) {
-	return {
-		debug: debug(`green-tunnel:${name}`),
-		success: debug(`green-tunnel:${name}:success`),
-		error: debug(`green-tunnel:${name}:error`),
-	}
-}
-
-debug.enable('green-tunnel:proxy:error');

package/src/proxy.js

@@ -1,74 +0,0 @@
-import net from 'net';
-import { setProxy, unsetProxy } from './utils/system-proxy.js';
-import handleRequest from './handlers/request.js';
-import DNSOverTLS from './dns/tls.js';
-import DNSOverHTTPS from './dns/https.js';
-import DNSUnencrypted from './dns/unencrypted.js';
-import config from './config.js';
-import getLogger from './logger.js';
-import { appInit } from './utils/analytics.js';
-
-const logger = getLogger('proxy');
-
-export default class Proxy {
-	constructor(customConfig) {
-		this.config = { ...config, ...customConfig };
-		this.server = undefined;
-		this.isSystemProxySet = false;
-		this.initDNS();
-		appInit(customConfig.source);
-	}
-
-	initDNS() {
-		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 => {
-			handleRequest(clientSocket, this).catch(err => {
-				logger.debug(String(err));
-			});
-		});
-
-		this.server.on('error', err => {
-			logger.error(err.toString());
-		});
-
-		this.server.on('close', () => {
-			logger.debug('server closed');
-		});
-
-		await new Promise(resolve => {
-			this.server.listen(this.config.port, this.config.ip, () => resolve());
-		});
-
-		const { address, port } = this.server.address();
-		logger.debug(`server listen on ${address} port ${port}`);
-
-		if (options.setProxy) {
-			await setProxy(address, port);
-			this.isSystemProxySet = true;
-			logger.debug('system proxy set');
-		}
-	}
-
-	async stop() {
-		if (this.server) {
-			this.server.close();
-		}
-
-		if (this.isSystemProxySet) {
-			await unsetProxy();
-			this.isSystemProxySet = false;
-			logger.debug('system proxy unset');
-		}
-	}
-}

package/src/scripts/windows/wininet-reset-settings.ps1

@@ -1,14 +0,0 @@
-$signature = @'
-[DllImport("wininet.dll", SetLastError = true, CharSet=CharSet.Auto)]
-public static extern bool InternetSetOption(IntPtr hInternet, int
-dwOption, IntPtr lpBuffer, int dwBufferLength);
-'@
-
-$interopHelper = Add-Type -MemberDefinition $signature -Name MyInteropHelper -PassThru
-$INTERNET_OPTION_SETTINGS_CHANGED = 39
-$INTERNET_OPTION_REFRESH = 37
-
-$result1 = $interopHelper::InternetSetOption(0, $INTERNET_OPTION_SETTINGS_CHANGED, 0, 0)
-$result2 = $interopHelper::InternetSetOption(0, $INTERNET_OPTION_REFRESH, 0, 0)
-
-$result1 -and $result2

package/src/utils/analytics.js

@@ -1,59 +0,0 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { randomUUID } from 'crypto';
-import packageJson from '../../package.json' with { type: 'json' };
-
-const MEASUREMENT_ID = 'G-D1R7M2YZ8Q';
-
-// Get this from: GA4 Admin → Data Streams → select stream → Measurement Protocol API secrets → Create
-const API_SECRET = 'Y_lvWjBxSG2-k5UYBJQQ7Q';
-
-const CONFIG_DIR = join(homedir(), '.config', 'greentunnel');
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-
-function getClientId() {
-	try {
-		mkdirSync(CONFIG_DIR, {recursive: true});
-		let config = {};
-		if (existsSync(CONFIG_FILE)) {
-			config = JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
-		}
-
-		if (!config.clientId) {
-			config.clientId = randomUUID();
-			writeFileSync(CONFIG_FILE, JSON.stringify(config));
-		}
-
-		return config.clientId;
-	} catch {
-		return randomUUID();
-	}
-}
-
-async function sendEvent(name, params = {}) {
-	if (!API_SECRET) return;
-
-	try {
-		await fetch(
-			`https://www.google-analytics.com/mp/collect?measurement_id=${MEASUREMENT_ID}&api_secret=${API_SECRET}`,
-			{
-				method: 'POST',
-				body: JSON.stringify({
-					client_id: getClientId(),
-					events: [{name, params}],
-				}),
-			},
-		);
-	} catch {
-		// Analytics failures must never crash the app
-	}
-}
-
-export function appInit(source = 'OTHER') {
-	sendEvent('app_init', {
-		source,
-		version: packageJson.version,
-		platform: process.platform,
-	});
-}

package/src/utils/buffer.js

@@ -1,35 +0,0 @@
-export function bufferToChunks(buffer, chunkSize, recordFragmentation) {
-	if(recordFragmentation) buffer=tlsRecordFragmentation(buffer, chunkSize)
-	const result = [];
-	const len = buffer.length;
-	let i = 0;
-
-	while (i < len) {
-		result.push(buffer.slice(i, i += chunkSize));
-	}
-
-	return result;
-}
-/**
- * @param {Buffer} buffer
- * @param {number} chunkSize
- */
-function tlsRecordFragmentation(buffer, chunkSize) {
-	const list = []
-	const header = buffer.subarray(0,3)
-	const fullRecord = buffer.subarray(5)
-	const len = fullRecord.length
-	let i = 0
-
-	while (i < len) {
-		const record = fullRecord.subarray(i, i+chunkSize)
-		const recordLength = record.length
-		const buf = Buffer.alloc(recordLength+5)
-		header.copy(buf)
-		buf.writeUInt16BE(recordLength,3)
-		record.copy(buf,5)
-		list.push(buf)
-		i+=chunkSize
-	}
-	return Buffer.concat(list)
-}

package/src/utils/socket.js

@@ -1,32 +0,0 @@
-import net from 'net';
-import getLogger from '../logger.js';
-
-const logger = getLogger('socket');
-
-export async function createConnection(opts, dns) {
-	const ip = await dns.lookup(opts.host);
-
-	const t = new Date();
-	return new Promise(resolve => {
-		const socket = net.createConnection({...opts, host: ip}, () => {
-			logger.debug(`[Socket] connected to ${opts.host} (${ip}) (${new Date() - t} ms)`);
-			resolve(socket);
-		});
-	});
-}
-
-export function tryWrite(socket, data, onError) {
-	try {
-		socket.write(data);
-	} catch (error) {
-		if (onError) {
-			onError(error);
-		}
-	}
-}
-
-export function closeSocket(socket) {
-	socket.removeAllListeners('data');
-	socket.removeAllListeners('error');
-	socket.end();
-}