bdy 1.7.46-dev

package/src/tunnel/http/stream.js

@@ -0,0 +1,46 @@
+const { Transform } = require('stream');
+
+class TunnelHttpStream extends Transform {
+  constructor(maxSize) {
+    super();
+    this.maxSize = maxSize;
+    this.data = Buffer.alloc(0);
+    this.realLength = 0;
+    this.tooLarge = false;
+    this.backPressure = [];
+  }
+
+  _transform(chunk, encoding, callback) {
+    if (!this.tooLarge) {
+      if (this.data.length + chunk.length > this.maxSize) {
+        this.tooLarge = true;
+        this.data = Buffer.alloc(0);
+      } else {
+        this.data = Buffer.concat([this.data, chunk]);
+      }
+    }
+    this.realLength += chunk.length;
+    this.backPressure.push(chunk);
+    this._pushBackPressure();
+    callback();
+  }
+
+  _pushBackPressure() {
+    while(this.backPressure.length > 0) {
+      const chunk = this.backPressure.shift();
+      if (!this.push(chunk)) {
+        this.once('drain', () => {
+          this._pushBackPressure();
+        });
+        break;
+      }
+    }
+  }
+
+  pipeToNothing(done) {
+    this.once('end', done);
+    this.resume();
+  }
+}
+
+module.exports = TunnelHttpStream;

package/src/tunnel/http.js

@@ -0,0 +1,406 @@
+const EventEmitter = require('events');
+const { v4 } = require('uuid');
+const http = require('http');
+const {
+  DEFAULT_TIMEOUT,
+  getRealTargetHost
+} = require('../utils.js');
+const TunnelAgent = require('./agent.js');
+const url = require('url');
+const TunnelHtml = require('./html.js');
+const TunnelCompression = require('./compression.js');
+const https = require('https');
+const TunnelHttpServe = require('./http/serve.js');
+const logger = require('../logger.js');
+const { LOG_ERROR } = require('../texts.js');
+const stream = require('stream');
+const {
+  TUNNEL_IDENTIFIED_HTTP1,
+  TUNNEL_IDENTIFIED_HTTP2,
+  TUNNEL_COMPRESSION_METHOD_IDENTITY
+} = require('../utils');
+
+class TunnelHttp extends EventEmitter {
+  constructor({
+    req,
+    res,
+    proto,
+    host,
+    port,
+    hostHeader,
+    serve,
+    timeout,
+    httpIdentify,
+    verify,
+    httpLog,
+    compression,
+    headers,
+    responseHeaders,
+    auth = null,
+  }) {
+    super();
+    this.id = v4();
+    this.host = host;
+    this.port = port;
+    this.proto = proto;
+    this.auth = auth;
+    this.req = req;
+    this.res = res;
+    this.hostHeader = hostHeader;
+    this.timeout = timeout || DEFAULT_TIMEOUT;
+    this.httpIdentify = httpIdentify;
+    this.verify = verify;
+    this.compression = compression;
+    this.headers = {};
+    this.responseHeaders = {};
+    this.serve = serve;
+    if (responseHeaders) {
+      responseHeaders.forEach((header) => {
+        this.responseHeaders[header.name.toLowerCase()] = header.value;
+      });
+    }
+    if (headers) {
+      headers.forEach((header) => {
+        this.headers[header.name.toLowerCase()] = header.value;
+      });
+    }
+    this.httpLog = httpLog;
+    this.logRequest = null;
+  }
+
+  outputEnd(code, html) {
+    try {
+      if (this.logRequest) {
+        const s = new stream.Readable();
+        s.push(html);
+        s.push(null);
+        s.pipe(this.logRequest.responseBody);
+      }
+      this.httpLog.newResponse(this.req, code, {}, this.logRequest);
+      this.res.statusCode = code;
+      this.res.end(html);
+    } catch (err) {
+      // do nothing
+    }
+    this.clear();
+  }
+
+  getDisplayTarget() {
+    let t = `${this.proto}://${this.host}`;
+    if (this.proto === 'http' && this.port !== 80) t += `:${this.port}`;
+    else if (this.proto === 'https' && this.port !== 443) t += `:${this.port}`;
+    return t;
+  }
+
+  output503() {
+    this.outputEnd(503, TunnelHtml.get503(this.getDisplayTarget()));
+  }
+
+  outputHeaders(statusCode, headers) {
+    this.res.statusCode = statusCode;
+    Object.keys(headers).forEach((name) => {
+      this.res.setHeader(name.toLowerCase(), headers[name]);
+    });
+    Object.keys(this.responseHeaders).forEach((name) => {
+      this.res.setHeader(name.toLowerCase(), this.responseHeaders[name]);
+    });
+  }
+
+  getHostHeader() {
+    if (this.hostHeader) return this.hostHeader;
+    let h = this.host;
+    if (this.proto === 'http' && this.port !== 80) h += `:${this.port}`;
+    else if (this.proto === 'https' && this.port !== 443) h += `:${this.port}`;
+    return h;
+  }
+
+  getRequestHeaders(http2) {
+    const h = {};
+    let ip;
+    if (this.req.httpVersion === '2.0') {
+      ip = this.req.socket.stream ? this.req.socket.stream.remoteAddress : '::1';
+    } else {
+      ip = this.req.socket.remoteAddress;
+    }
+    if (http2) {
+      h[':scheme'] = this.proto;
+      h[':authority'] = this.getHostHeader();
+      h[':method'] = this.getMethod();
+      h[':path'] = this.getPath();
+    } else {
+      h.host = this.getHostHeader();
+    }
+    h['x-forwarded-for'] = ip || '0.0.0.0';
+    h['x-forwarded-proto'] = 'https';
+    if (this.auth) {
+      h['authorization'] = `Basic ${Buffer.from(this.auth).toString('base64')}`;
+    }
+    return h;
+  }
+
+  getClearedHeaders(headers = {}, compressionMethod) {
+    const hop = [
+      ':method',
+      ':path',
+      ':scheme',
+      ':authority',
+      ':status',
+      'keep-alive',
+      'host',
+      'connection',
+      'proxy-authenticate',
+      'proxy-connection',
+      'Proxy-authorization',
+      'trailer',
+      'upgrade',
+      'transfer-encoding',
+      'strict-transport-security',
+      'te'
+    ];
+    const tmp = {};
+    if (compressionMethod && compressionMethod !== TUNNEL_COMPRESSION_METHOD_IDENTITY) {
+      tmp['content-encoding'] = compressionMethod;
+      hop.push('content-length');
+      hop.push('content-encoding');
+    }
+    Object.keys(headers).forEach((name) => {
+      if (!hop.includes(name)) {
+        tmp[name] = headers[name];
+      }
+    });
+    return tmp;
+  }
+
+  getPath() {
+    const {
+      pathname,
+      search,
+    } = url.parse(this.req.url);
+    let path = pathname;
+    if (search) path += search;
+    return path;
+  }
+
+  getMethod() {
+    return this.req.method;
+  }
+
+  createRequestHttp1() {
+    const reqHeaders = this.req.headers;
+    const method = this.getMethod();
+    const path = this.getPath();
+    const headers = {
+      ...this.getClearedHeaders(reqHeaders),
+      ...this.headers,
+      ...this.getRequestHeaders(false)
+    };
+    const r = http.request({
+      agent: TunnelAgent.getHttp1(),
+      host: getRealTargetHost(this.host),
+      port: this.port,
+      method,
+      protocol: 'http:',
+      setHost: false,
+      path,
+      headers
+    });
+    this.logRequest = this.httpLog.newRequest(method, headers, path, TUNNEL_IDENTIFIED_HTTP1, this.req);
+    r.on('response', (proxyRes) => {
+      this.proxyRes = proxyRes;
+      const statusCode = this.proxyRes.statusCode;
+      const resHeaders = this.proxyRes.headers;
+      const compressionMethod = TunnelCompression.detect(this.compression, reqHeaders, resHeaders);
+      this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
+      if (this.logRequest) {
+        this.proxyRes.pipe(this.logRequest.responseBody).pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+      } else {
+        this.proxyRes.pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+      }
+      this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+    });
+    return r;
+  }
+
+  createRequestHttps1() {
+    const reqHeaders = this.req.headers;
+    const method = this.getMethod();
+    const headers = {
+      ...this.getClearedHeaders(reqHeaders),
+      ...this.headers,
+      ...this.getRequestHeaders(false)
+    };
+    const path = this.getPath();
+    const r = https.request({
+      agent: TunnelAgent.getHttps1(),
+      host: getRealTargetHost(this.host),
+      port: this.port,
+      method,
+      protocol: 'https:',
+      setHost: false,
+      path,
+      rejectUnauthorized: this.verify,
+      headers
+    });
+    this.logRequest = this.httpLog.newRequest(method, headers, path, TUNNEL_IDENTIFIED_HTTP1, this.req);
+    r.on('response', (proxyRes) => {
+      this.proxyRes = proxyRes;
+      const statusCode = this.proxyRes.statusCode;
+      const resHeaders = this.proxyRes.headers;
+      const compressionMethod = TunnelCompression.detect(this.compression, reqHeaders, resHeaders);
+      this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
+      if (this.logRequest) {
+        this.proxyRes.pipe(this.logRequest.responseBody).pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+      } else {
+        this.proxyRes.pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+      }
+      this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+    });
+    return r;
+  }
+
+  createServe() {
+    const reqHeaders = this.req.headers;
+    const r = new TunnelHttpServe(this.serve);
+    const method = this.getMethod();
+    const path = this.getPath();
+    this.logRequest = this.httpLog.newRequest(method, reqHeaders, path, TUNNEL_IDENTIFIED_HTTP1, this.req);
+    r.on('response', (statusCode, resHeaders, stream) => {
+      if (!stream) {
+        this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders));
+        this.res.end();
+      } else {
+        const compressionMethod = TunnelCompression.detect(this.compression, reqHeaders, resHeaders);
+        this.outputHeaders(statusCode, this.getClearedHeaders(resHeaders, compressionMethod));
+        if (this.logRequest) {
+          stream.pipe(this.logRequest.responseBody).pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+        } else {
+          stream.pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+        }
+      }
+      this.httpLog.newResponse(this.req, statusCode, resHeaders, this.logRequest);
+    });
+    return r;
+  }
+
+  async createRequestHttps2() {
+    const reqHeaders = this.req.headers;
+    const authority = `${this.proto}://${getRealTargetHost(this.host)}:${this.port}`;
+    const client = await TunnelAgent.getHttp2Client(authority, this.host, this.verify);
+    const method = this.getMethod();
+    const path = this.getPath();
+    const headers = {
+      ...this.getClearedHeaders(reqHeaders),
+      ...this.headers,
+      ...this.getRequestHeaders(true)
+    };
+    const r = client.request(headers);
+    this.logRequest = this.httpLog.newRequest(method, headers, path, TUNNEL_IDENTIFIED_HTTP2, this.req);
+    r.on('response', (resHeaders) => {
+      const status = resHeaders[':status'] || 200;
+      const compressionMethod = TunnelCompression.detect(this.compression, reqHeaders, resHeaders);
+      this.outputHeaders(status, this.getClearedHeaders(resHeaders, compressionMethod));
+      if (this.logRequest) {
+        r.pipe(this.logRequest.responseBody).pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+      } else {
+        r.pipe(TunnelCompression.compress(compressionMethod)).pipe(this.res);
+      }
+      this.httpLog.newResponse(this.req, status, resHeaders, this.logRequest);
+    });
+    return r;
+  }
+
+  async createRequest() {
+    if (this.httpIdentify === TUNNEL_IDENTIFIED_HTTP1) {
+      if (this.proto === 'http') return this.createRequestHttp1();
+      return this.createRequestHttps1();
+    }
+    return this.createRequestHttps2();
+  }
+
+  clear() {
+    if (this.req) {
+      this.req.removeAllListeners();
+      this.req = null;
+    }
+    if (this.res) {
+      this.res.removeAllListeners();
+      this.res = null;
+    }
+    if (this.proxyReq) {
+      this.proxyReq.removeAllListeners();
+      this.proxyReq = null;
+    }
+    if (this.proxyRes) {
+      this.proxyRes.removeAllListeners();
+      this.proxyRes = null;
+    }
+    if (this.httpLog) {
+      this.httpLog = null;
+    }
+    if (this.logRequest) {
+      this.logRequest.removeAllListeners();
+      this.logRequest = null;
+    }
+  }
+
+  async pipe() {
+    if (this.serve) {
+      try {
+        this.proxyReq = this.createServe();
+      } catch (err) {
+        logger.debug(LOG_ERROR);
+        logger.debug(err);
+        this.output503();
+        return;
+      }
+      this.proxyReq.on('error', () => {
+        this.output503();
+      });
+      this.proxyReq.on('close', () => {
+        setTimeout(() => {
+          this.clear();
+        }, 5000);
+      });
+      this.proxyReq.process(this.req);
+    } else {
+      try {
+        this.proxyReq = await this.createRequest();
+      } catch (err) {
+        logger.debug(LOG_ERROR);
+        logger.debug(err);
+        if (this.logRequest) {
+          this.req.pipe(this.logRequest.requestBody);
+          // no real request waiting for this data -> push it into the void
+          this.logRequest.requestBody.pipeToNothing(() => {
+            // wait for piping request
+            this.output503();
+          });
+          return;
+        }
+        this.output503();
+        return;
+      }
+      this.proxyReq.setTimeout(this.timeout * 1000);
+      this.proxyReq.on('timeout', () => {
+        this.output503();
+      });
+      this.proxyReq.on('error', (err) => {
+        logger.debug(LOG_ERROR);
+        logger.debug(err);
+        this.output503();
+      });
+      this.proxyReq.on('close', () => {
+        setTimeout(() => {
+          this.clear();
+        }, 5000);
+      });
+      if (this.logRequest) {
+        this.req.pipe(this.logRequest.requestBody).pipe(this.proxyReq);
+      } else {
+        this.req.pipe(this.proxyReq);
+      }
+    }
+  }
+}
+
+module.exports = TunnelHttp;

package/src/tunnel/identification.js

@@ -0,0 +1,95 @@
+const EventEmitter = require('events');
+const tls = require('tls');
+const net = require('net');
+const { getRealTargetHost } = require('../utils.js');
+const {
+  EVENT_TUNNEL_IDENTIFIED,
+  TUNNEL_IDENTIFIED_HTTP1,
+  TUNNEL_IDENTIFIED_HTTP2
+} = require('../utils');
+
+const CHECK_INTERVAL = 300000;
+const CHECK_TIMEOUT = 5000;
+
+class TunnelIdentification extends EventEmitter {
+  constructor(proto, host, port, forceHttp2) {
+    super();
+    this.proto = proto;
+    this.host = getRealTargetHost(host);
+    this.port = port;
+    this.forceHttp2 = forceHttp2;
+    this.type = TUNNEL_IDENTIFIED_HTTP1;
+    this.identify();
+    this.ts = setInterval(() => this.identify(), CHECK_INTERVAL);
+  }
+
+  stop() {
+    if (this.ts) {
+      clearInterval(this.ts);
+      this.ts = null;
+    }
+  }
+
+  identify() {
+    if (this.forceHttp2) {
+      this.type = TUNNEL_IDENTIFIED_HTTP2;
+      this.emit(EVENT_TUNNEL_IDENTIFIED, TUNNEL_IDENTIFIED_HTTP2);
+      return;
+    }
+    let socket;
+    const close = () => {
+      try {
+        socket.removeAllListeners();
+        socket.close();
+      } catch (err) {
+        // do nothing
+      }
+    };
+    const connected = () => {
+      if (socket.alpnProtocol) {
+        if (socket.alpnProtocol === 'h2') {
+          this.type = TUNNEL_IDENTIFIED_HTTP2;
+          this.emit(EVENT_TUNNEL_IDENTIFIED, TUNNEL_IDENTIFIED_HTTP2);
+        } else {
+          this.type = TUNNEL_IDENTIFIED_HTTP1;
+          this.emit(EVENT_TUNNEL_IDENTIFIED, TUNNEL_IDENTIFIED_HTTP1);
+        }
+        close();
+      } else {
+        socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
+        socket.on('data', (d) => {
+          if (/HTTP\/1\.1/.test(d.toString('utf8'))) {
+            this.type = TUNNEL_IDENTIFIED_HTTP1;
+            this.emit(EVENT_TUNNEL_IDENTIFIED, TUNNEL_IDENTIFIED_HTTP1);
+          } else {
+            this.type = TUNNEL_IDENTIFIED_HTTP2;
+            this.emit(EVENT_TUNNEL_IDENTIFIED, TUNNEL_IDENTIFIED_HTTP2);
+          }
+          close();
+        });
+      }
+    };
+    if (this.proto === 'http') {
+      socket = net.connect({
+        host: this.host,
+        port: this.port,
+      });
+      socket.on('connect', connected);
+    } else {
+      socket = tls.connect({
+        host: this.host,
+        port: this.port,
+        rejectUnauthorized: true,
+        ALPNProtocols: ['h2', 'http/1.1'],
+        servername: this.host
+      });
+      socket.on('secureConnect', connected);
+    }
+    socket.setTimeout(CHECK_TIMEOUT);
+    socket.on('timeout', close);
+    socket.on('error', close);
+    socket.on('close', close);
+  }
+}
+
+module.exports = TunnelIdentification;

package/src/tunnel/latency.js

@@ -0,0 +1,63 @@
+const { Socket } = require('net');
+const EventEmitter = require('events');
+const { getRealTargetHost } = require('../utils.js');
+const { TUNNEL_LATENCY_EVENT_RECONNECTED } = require('../utils');
+
+class TunnelLatency extends EventEmitter {
+  constructor(host, port) {
+    super();
+    this.latency = -1;
+    this.isChecking = false;
+    this.port = port;
+    this.host = getRealTargetHost(host);
+    this.ts = null;
+  }
+
+  check() {
+    if (this.isChecking) return;
+    this.isChecking = true;
+    let socket = new Socket();
+    let ts = null;
+    const clear = () => {
+      clearTimeout(ts);
+      socket.removeAllListeners();
+      socket.once('error', () => {});
+      socket.end();
+      socket = null;
+      this.isChecking = false;
+    };
+    ts = setTimeout(() => {
+      this.latency = -1;
+      clear();
+    }, 30000);
+    const start = process.hrtime();
+    socket.on('error', () => {
+      this.latency = -1;
+      clear();
+    });
+    socket.on('ready', () => {
+      const elapsed = process.hrtime(start);
+      if (this.latency < 0) this.emit(TUNNEL_LATENCY_EVENT_RECONNECTED);
+      this.latency = elapsed[0] * 1000 + elapsed[1] / 1000000; // ms
+      clear();
+    });
+    socket.connect(this.port, this.host);
+  }
+
+  startChecking() {
+    this.check();
+    this.stopChecking();
+    this.ts = setInterval(() => {
+      this.check();
+    }, 3000);
+  }
+
+  stopChecking() {
+    if (this.ts) {
+      clearInterval(this.ts);
+      this.ts = null;
+    }
+  }
+}
+
+module.exports = TunnelLatency;

package/src/tunnel/tcp.js

@@ -0,0 +1,71 @@
+const { Socket } = require('net');
+const { v4 } = require('uuid');
+const EventEmitter = require('events');
+const { getRealTargetHost } = require('../utils.js');
+const { TCP_EVENT_CLOSED } = require('../utils');
+
+class TunnelTcp extends EventEmitter {
+  constructor(host, port, stream) {
+    super();
+    this.id = v4();
+    this.host = host;
+    this.port = port;
+    this.stream = stream;
+    this.socket = new Socket();
+  }
+
+  end() {
+    try {
+      this.stream.unpipe();
+      this.socket.unpipe();
+    } catch (err) {
+      // do nothing
+    }
+    try {
+      this.stream.removeAllListeners();
+      this.stream.on('error', () => {});
+      this.stream.end();
+    } catch (err) {
+      // do nothing
+    }
+    try {
+      this.socket.removeAllListeners();
+      this.socket.once('error', () => {});
+      this.socket.end();
+    } catch(err) {
+      // do nothing
+    }
+    this.socket = null;
+    this.stream = null;
+    this.host = null;
+    this.port = null;
+    this.emit(TCP_EVENT_CLOSED);
+  }
+
+  pipe() {
+    this.socket.on('error', () => {
+      this.end();
+    });
+    this.socket.on('close', () => {
+      this.end();
+    });
+    this.stream.on('error', () => {
+      this.end();
+    });
+    this.stream.on('close', () => {
+      this.end();
+    });
+    try {
+      this.socket.connect({
+        host: getRealTargetHost(this.host),
+        port: this.port
+      }, () => {
+        this.socket.pipe(this.stream).pipe(this.socket);
+      });
+    } catch (err) {
+      this.end();
+    }
+  }
+}
+
+module.exports = TunnelTcp;