bdy 1.7.60-dev → 1.8.3-dev

package/src/tunnel/http/stream.js

@@ -1,47 +0,0 @@
-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.removeAllListeners('drain');
-        this.once('drain', () => {
-          this._pushBackPressure();
-        });
-        break;
-      }
-    }
-  }
-
-  pipeToNothing(done) {
-    this.once('end', done);
-    this.resume();
-  }
-}
-
-module.exports = TunnelHttpStream;

package/src/tunnel/http.js

@@ -1,406 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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);
-      try {
-        socket.removeAllListeners();
-        socket.once('error', () => {
-        });
-        socket.end();
-        socket.destroy();
-      } catch {
-        // do nothing
-      }
-      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

@@ -1,85 +0,0 @@
-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
-    }
-    const s1 = this.stream;
-    try {
-      this.socket.removeAllListeners();
-      this.socket.once('error', () => {});
-      this.socket.end();
-    } catch(err) {
-      // do nothing
-    }
-    const s2 = this.socket;
-    setTimeout(() => {
-      try {
-        s1.destroy();
-      } catch {
-        // do nothing
-      }
-      try {
-        s2.destroy();
-      } catch {
-        // do nothing
-      }
-    }, 1000);
-    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;