iosignal 1.6.1 → 1.7.1

package/src/server/Metric.js

@@ -1,154 +1,155 @@
-import { memoryUsage } from 'process';
-import { ENC_MODE } from '../common/constants.js'
-
-const MAX = 10
-let period = 10000
-
-export class Metric{
-  constructor(manager){
-    this.manager = manager;
-
-    this.metricsPack= {
-      remotes:[0],
-      channels:[0],
-      txBytes:[0],
-      rxBytes:[0],
-      unixTime: [Math.floor( Date.now() /1000)],
-      period: 0
-    }
-
-    this.tickId = setInterval( e=>{
-
-      this.metricsPack.remotes.push( this.manager.remotes.size )
-      if(this.metricsPack.remotes.length > MAX ) this.metricsPack.remotes.shift()
-
-      this.metricsPack.channels.push( this.manager.channel_map.size )
-      if(this.metricsPack.channels.length > MAX ) this.metricsPack.channels.shift()
-
-      
-      this.metricsPack.txBytes.push( this.manager.txBytes )
-      if(this.metricsPack.txBytes.length > MAX ) this.metricsPack.txBytes.shift()
-
-      this.metricsPack.rxBytes.push( this.manager.rxBytes )
-      if(this.metricsPack.rxBytes.length > MAX ) this.metricsPack.rxBytes.shift()
-
-      this.metricsPack.unixTime = Math.floor( Date.now() /1000)
-      this.metricsPack.period = period;
-      this.manager.txBytes = 0
-      this.manager.rxBytes = 0
-    
-
-    },10000)
-  }
-
-
-
-  oneline(prn){
-    let memoryUse = memoryUsage();
-    let memoryInfo = [{
-      ...memoryUse
-    }]
-
-    if ( prn ) console.table(memoryInfo, [ 'rss','heapTotal','heapUsed', 'external','arrayBuffers' ]);
-
-    let metric = [{
-      lastSSID: this.manager.lastSSID,
-      remotes: this.manager.remotes.size,
-      channels: this.manager.channel_map.size,
-      txBytes: this.manager.txBytes,
-      rxBytes: this.manager.rxBytes,
-    }]
-
-    if ( prn ) console.table(metric, [ 'lastSSID', 'remotes', 'channels','txBytes','rxBytes' ]);
-
-    return metric[0]
-  }
-
-  getRemotes( prn ){
-    let remoteList =  Array.from(this.manager.remotes.values())
-    let remoteStates = remoteList.map(v=>{
-      return  "#"+v.ssid+":"+ v.cid +"("+v.state+")"
-    })
-    if (prn ) console.table(remoteStates)
-    return remoteStates
-  }
-  getCIdList( prn ){
-    let CIdList =  Array.from(this.manager.cid2remote.keys())
-    if (prn ) console.table(CIdList)
-    return CIdList
-  }
-
-  getChannelList(prn){
-    let chList =  Array.from(this.manager.channel_map.keys())
-    if (prn ) console.table(chList)
-    return chList
-  }
-
-  getSubscribers(ch){
-    let list = [];
-    if( this.manager.channel_map.has(ch)){
-      let subscribers = this.manager.channel_map.get(ch) //set
-      subscribers.forEach( c =>{
-        list.push(c.cid)
-      })
-    }
-    // console.log(list)
-    return list
-  }
-
-  getRemoteByCId( cid , mode = 1){
-
-    if( this.manager.cid2remote.has(cid)){
-      let remote = this.manager.cid2remote.get(cid)
-      if(mode == 1){
-        return {
-          ip: remote.ip,
-          id: remote.cid,
-          ssid: remote.ssid,
-          cid: remote.cid,
-          uptime:  Math.trunc( ( Date.now() - remote.socket.openTime ) / 1000),
-          tx: remote.socket.txCounter,
-          rx: remote.socket.rxCounter,
-          txBytes: remote.socket.bytesWritten || remote.socket._socket?.bytesWritten,
-          rxBytes: remote.socket.bytesRead || remote.socket._socket?.bytesRead
-        }
-      }else if( mode == 2){
-        return {
-          ip: remote.ip,
-          uptime:  Math.trunc( ( Date.now() - remote.socket.openTime ) / 1000),
-          nick: remote.nick,
-          ssid: remote.ssid,
-          echo: remote.lastEchoMessage
-        }
-      }else if( mode == 3){
-        return {
-          ip: remote.ip,
-          uptime:  Math.trunc( ( Date.now() - remote.socket.openTime ) / 1000),
-          nick: remote.nick,
-          ssid: remote.ssid,
-          isSecure: remote.TLS,
-          isAuth: remote.boho.isAuthorized,
-          encMode:  ENC_MODE[remote.encMode]
-        }
-      }else if( mode == 4){
-        let channels = Array.from( remote.channels.keys() )
-        let set_memory = Array.from( remote.memory.keys() )
-        let retain_signal = Array.from( remote.retain_signal.keys() )
-        return {
-          ip: remote.ip,
-          uptime:  Math.trunc( ( Date.now() - remote.socket.openTime ) / 1000),
-          channels: channels,
-          set: set_memory,
-          retain: retain_signal
-        }
-      }
-
-    }else{
-      return { result: "nop" }
-    }
-
-  }
-
-
-}
-
+import { memoryUsage } from 'process';
+import { ENC_MODE } from '../common/constants.js'
+
+const MAX = 10
+let period = 10000
+
+export class Metric {
+  constructor(manager) {
+    this.manager = manager;
+
+    this.metricsPack = {
+      remotes: [0],
+      channels: [0],
+      txBytes: [0],
+      rxBytes: [0],
+      unixTime: [Math.floor(Date.now() / 1000)],
+      period: 0
+    }
+
+    this.tickId = setInterval(e => {
+
+      this.metricsPack.remotes.push(this.manager.remotes.size)
+      if (this.metricsPack.remotes.length > MAX) this.metricsPack.remotes.shift()
+
+      this.metricsPack.channels.push(this.manager.channel_map.size)
+      if (this.metricsPack.channels.length > MAX) this.metricsPack.channels.shift()
+
+
+      this.metricsPack.txBytes.push(this.manager.txBytes)
+      if (this.metricsPack.txBytes.length > MAX) this.metricsPack.txBytes.shift()
+
+      this.metricsPack.rxBytes.push(this.manager.rxBytes)
+      if (this.metricsPack.rxBytes.length > MAX) this.metricsPack.rxBytes.shift()
+
+      this.metricsPack.unixTime = Math.floor(Date.now() / 1000)
+      this.metricsPack.period = period;
+      this.manager.txBytes = 0
+      this.manager.rxBytes = 0
+
+
+    }, 10000)
+  }
+
+
+
+  oneline(prn) {
+    let memoryUse = memoryUsage();
+    let memoryInfo = [{
+      ...memoryUse
+    }]
+
+    if (prn) console.table(memoryInfo, ['rss', 'heapTotal', 'heapUsed', 'external', 'arrayBuffers']);
+
+    let metric = [{
+      lastSSID: this.manager.lastSSID,
+      remotes: this.manager.remotes.size,
+      channels: this.manager.channel_map.size,
+      txBytes: this.manager.txBytes,
+      rxBytes: this.manager.rxBytes,
+    }]
+
+    if (prn) console.table(metric, ['lastSSID', 'remotes', 'channels', 'txBytes', 'rxBytes']);
+
+    return metric[0]
+  }
+
+  getRemotes(prn) {
+    let remoteList = Array.from(this.manager.remotes.values())
+    let remoteStates = remoteList.map(v => {
+      return "#" + v.ssid + ":" + v.cid + "(" + v.state + ")"
+    })
+    if (prn) console.table(remoteStates)
+    return remoteStates
+  }
+
+  getCIdList(prn) {
+    let CIdList = Array.from(this.manager.cid2remote.keys())
+    if (prn) console.table(CIdList)
+    return CIdList
+  }
+
+  getChannelList(prn) {
+    let chList = Array.from(this.manager.channel_map.keys())
+    if (prn) console.table(chList)
+    return chList
+  }
+
+  getSubscribers(ch) {
+    let list = [];
+    if (this.manager.channel_map.has(ch)) {
+      let subscribers = this.manager.channel_map.get(ch) //set
+      subscribers.forEach(c => {
+        list.push(c.cid)
+      })
+    }
+    // console.log(list)
+    return list
+  }
+
+  getRemoteByCId(cid, mode = 1) {
+
+    if (this.manager.cid2remote.has(cid)) {
+      let remote = this.manager.cid2remote.get(cid)
+      if (mode == 1) {
+        return {
+          ip: remote.ip,
+          id: remote.cid,
+          ssid: remote.ssid,
+          cid: remote.cid,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          tx: remote.socket.txCounter,
+          rx: remote.socket.rxCounter,
+          txBytes: remote.socket.bytesWritten || remote.socket._socket?.bytesWritten,
+          rxBytes: remote.socket.bytesRead || remote.socket._socket?.bytesRead
+        }
+      } else if (mode == 2) {
+        return {
+          ip: remote.ip,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          nick: remote.nick,
+          ssid: remote.ssid,
+          echo: remote.lastEchoMessage
+        }
+      } else if (mode == 3) {
+        return {
+          ip: remote.ip,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          nick: remote.nick,
+          ssid: remote.ssid,
+          isSecure: remote.TLS,
+          isAuth: remote.boho.isAuthorized,
+          encMode: ENC_MODE[remote.encMode]
+        }
+      } else if (mode == 4) {
+        let channels = Array.from(remote.channels.keys())
+        let set_memory = Array.from(remote.memory.keys())
+        let retain_signal = Array.from(remote.retain_signal.keys())
+        return {
+          ip: remote.ip,
+          uptime: Math.trunc((Date.now() - remote.socket.openTime) / 1000),
+          channels: channels,
+          set: set_memory,
+          retain: retain_signal
+        }
+      }
+
+    } else {
+      return { result: "nop" }
+    }
+
+  }
+
+
+}
+

package/src/server/Remote.js

@@ -0,0 +1,207 @@
+import { pack, CongRx } from '../client/CongPacket.js'
+import { RemoteCore } from './RemoteCore.js';
+import { serverOption } from './serverOption.js';
+import { IOMsg } from '../common/constants.js';
+import * as util from '../common/util.js'
+
+const decoder = new TextDecoder()
+
+export class Remote extends RemoteCore {
+  constructor(socket, req, manager) {
+    super(socket, manager);
+    this.socketType = socket.socketType
+
+    if (this.socketType === 'websocket') {
+      this.TLS = req.headers["x-forwarded-proto"] === 'https' ? true : false;
+      this.ip = this.getRemoteIP(req);
+    } else {
+      this.TLS = false;
+      this.ip = this.getRemoteIP(socket.remoteAddress)
+    }
+
+
+    if (util.isPrivateIP(this.ip)) {
+      // connection from local or private network has default private channel.
+      this.HOME_CHANNEL = 'PRIVATE:'
+      this.privateNode = true
+    } else {
+      // The HOME_CHANNEL is defined by the global IP address value.
+      this.HOME_CHANNEL = 'IP:' + util.getIPv4HexString(this.ip)
+    }
+
+
+    if (this.socketType === 'websocket') {
+      if (serverOption.debug.slow) {
+        socket.on("message", this.onTimeDelayMessage.bind(this));
+      } else {
+        socket.on("message", this.onSocketMessage.bind(this));
+      }
+      socket.on("pong", this.receiveMonitor.bind(this));
+      socket.on("ping", this.receiveMonitor.bind(this));
+      socket.on("error", (e) => { console.log('Websocket error', e, e.code) });
+      socket.onclose = (e) => {
+        this.manager.removeRemote(this);
+      };
+    } else { // TCP else
+      this.congRx = new CongRx();
+      socket.on('data', data => { this.congRx.write(data) })
+
+      this.congRx.on('wrong', this.onWrongCongPacketMessage.bind(this))
+      // readable.pipe( destination )
+      // tcpSocket -> congRx(parser) -> onMessage
+      // socket.pipe( this.congRx )
+
+      if (serverOption.debug.slow) {
+        this.congRx.on('data', this.onTimeDelayMessage.bind(this))
+      } else {
+        this.congRx.on('data', this.onSocketMessage.bind(this))
+      }
+
+      socket.on('error', e => { console.log('TCP Socket error', e) })
+      socket.on('close', e => {
+        this.manager.removeRemote(this);
+      })
+
+    }
+  }
+
+  onWrongCongPacketMessage(message) {
+    /*
+      * three category CongSocket connection.
+      1. anonymouse, tcp connection.
+        > no cid_req, no auth_req
+        > It's attacker. close it.
+      2. not authorized but cid ready connnection.
+        > anonymouse remote client.
+        > allowed some wrong(broken) message. small quota.
+      3. authorized remote connection.
+        > allowed some wrong(broken) message. large quota.
+    */
+    if (this.cid) { // category  2 and 3.
+      // temporary broken message.
+      // console.log('wrong congpack from user:', Date(), this.ip, this.ssid, this.cid)
+    } else {
+      // attacker
+      let msg = ""
+      try {
+        msg = decoder.decode(message)
+      } catch (error) {
+        msg += 'Len: ' + message.byteLength
+      }
+
+      // console.log('attacker message:', attackMsg)
+      if (this.manager.attackLogger) {
+        let attackMsg = `> ${this.ssid} ${this.ip} ${msg}`
+        this.manager.attackLogger.log(attackMsg)
+      }
+
+      this.close(true);
+    }
+  }
+
+
+  permissionChecker() {
+    // type1.
+    // accept some traffic before authorize.
+    const limitBytes = 100
+
+    let txBytes = this.socket.bytesWritten || this.socket._socket?.bytesWritten
+    let rxBytes = this.socket.bytesRead || this.socket._socket?.bytesRead
+
+    if (txBytes == undefined) txBytes = 0
+    if (rxBytes == undefined) rxBytes = 0
+
+  }
+
+
+  // any type of received messages:  message, ping, pong
+  receiveMonitor() {
+    this.socket.rxCounter++
+    this.socket.isAlive = true;
+  }
+
+  isConnectionHTTPS(req) {
+    //In case of reverse proxy environment.  i.e. using nginx proxy_pass.
+    return req.headers["x-forwarded-proto"];   //https or undefined
+  }
+
+  getRemoteIP(req) { //req or ip string
+    let ip;
+    if (req && req.headers) {
+      ip = req.headers["x-forwarded-for"];
+      if (ip == undefined) ip = req.socket.remoteAddress;
+    } else {
+      ip = req;
+    }
+
+    if (ip) {
+      if (ip.indexOf("::ffff:") == 0) ip = ip.substring(7);
+      if (ip == "::1") ip = "127.0.0.1";
+    } else {
+      ip = "0.0.0.0";
+    }
+    return ip;
+  }
+
+  ping() {
+    if (this.socketType === 'websocket') {
+      this.socket.ping()
+      this.socket.txCounter++
+    } else {
+      this.send(Buffer.from([IOMsg.PING]))
+    }
+  }
+
+  pong() {
+    if (this.socketType === 'websocket') {
+      this.socket.pong()
+      this.socket.txCounter++
+    } else {
+      this.send(Buffer.from([IOMsg.PONG]))
+    }
+  }
+
+  getTraffic() {
+    let txb = this.socket.bytesWritten || this.socket._socket?.bytesWritten
+    let rxb = this.socket.bytesRead || this.socket._socket?.bytesRead
+    let tx = this.socket.txCounter
+    let rx = this.socket.rxCounter
+    let traffic = { tx, txb, rx, rxb }
+  }
+
+  close(terminateNow = false) {
+    this.getTraffic()
+    if (this.socketType === 'websocket') {
+      if (terminateNow) this.socket.terminate();
+      else this.socket.close();
+    } else {
+      if (terminateNow) this.socket.destroy();
+      else this.socket.end();
+    }
+  }
+
+  send(message, isBinary) {
+    this.manager.txBytes += message.byteLength;
+    this.socket.txCounter++;
+    if (this.socketType === 'websocket') {
+      if (this.socket.readyState === 1) {
+        if (isBinary != undefined) {
+          this.socket.send(message, { binary: isBinary });
+        } else {
+          this.socket.send(message);
+        }
+      } else {
+        this.close(true)
+      }
+
+    } else { //CongSocket
+      if (this.socket.readyState == 'open') {
+        this.socket.write(pack(message))
+      } else {
+        this.close(true)
+      }
+    }
+
+  }
+
+}