iosignal 0.0.1 → 1.1.0

package/src/auth/BohoAuth.js

@@ -0,0 +1,168 @@
+/**
+ * BohoAuth
+ */
+
+import { MBP } from 'meta-buffer-pack'
+import { BohoMsg , Meta } from 'boho'
+import { quotaTable } from '../common/quotaTable.js'
+import { serverOption } from '../server/serverOption.js'
+import { IOMsg ,CLIENT_STATE } from '../common/constants.js'
+import { FileLogger } from '../server/FileLogger.js'
+
+const decoder = new TextDecoder()
+export class BohoAuth{
+  constructor(){ 
+    this.authLogger;
+    if( serverOption.fileLogger.auth.use ){
+      this.authLogger = new FileLogger( serverOption.fileLogger.auth.path)
+      console.log('Auth: begin file logger.[auth]')
+    }
+  }
+
+  send_auth_fail( peer , reason){
+    if( this.authLogger ){
+      let peerInfo = `FAIL #${peer.ssid} reason:${reason} `
+      this.authLogger.log( peerInfo )
+    } 
+
+    console.log('## AUTH_FAIL reason:', reason )
+    // peer.send( Buffer.from( [BohoMsg.AUTH_FAIL] ))
+    peer.setState( CLIENT_STATE.AUTH_FAIL )
+    setTimeout(e=>{
+      peer.send( Buffer.from( [BohoMsg.AUTH_FAIL] ))
+    }, serverOption.auth.delay_auth_fail )
+  }
+
+  async verify_auth_hmac( auth_hmac , peer ){
+    try {
+      //1. unpack 
+      let infoPack = MBP.unpack( auth_hmac , Meta.AUTH_HMAC )
+      if(!infoPack){
+        this.send_auth_fail( peer ,'unpack auth_pack fail');
+        return
+      }
+
+      let id = ""
+      if( infoPack.id8.includes(0)){
+        id = decoder.decode( infoPack.id8.subarray( 0, infoPack.id8.indexOf(0) ) );
+      }else{
+        id = decoder.decode( infoPack.id8 );
+      }
+
+      //2. get key of id from DB
+      let authInfo = await this.getAuth( id )
+
+      // console.log('##### authInfo',authInfo )
+      if(serverOption.debug.showAuthInfo ){
+      }
+      
+      if( !authInfo ){
+        this.send_auth_fail( peer , 'NO ID:'+ id);
+        return
+      }
+
+      // console.log('db authInfo.key: ', authInfo.key)
+      peer.boho.copy_id8( infoPack.id8 )
+      // type of key
+      let authKey ;
+      const SHA256_HASH_BASE64_LEN = 44
+      if( authInfo.key.length == SHA256_HASH_BASE64_LEN){
+        // hashed key
+        authKey =  Buffer.from( authInfo.key, 'base64')
+        peer.boho.copy_key( authKey )
+      }else{
+        // plain key
+        peer.boho.set_key( authInfo.key )
+      }
+      
+      //3. check hmac
+      // console.log('-- found: authKey of id: ', id, authKey.toString('hex'))
+      let auth_ack = peer.boho.check_auth_hmac( infoPack )
+
+      // console.log('auth_ack',  auth_ack )
+      if( !auth_ack ){
+        this.send_auth_fail( peer, 'hmac dismatched' );
+        return
+      }
+
+      //4. get info
+        // console.log('#### auth success' )
+
+      //5. check duplicate login.
+      // current policy. Deny duplicate login
+
+      // duplicate login policy.  
+      // 1. send clear_auth signal to the old connection. 
+      // 2. close old connection.
+      // 3. close new connection. retry from begining.
+      if( peer.manager.cid2remote.has( authInfo.cid  ) ){
+        let old = peer.manager.cid2remote.get(authInfo.cid )
+        if( old == peer ){
+          console.log('## trying RELOGIN with SAME ID. ignored.')
+          return
+        }
+        console.log('### clear_auth and close old connection:', old.cid )
+        old.send( Buffer.from( [ IOMsg.SERVER_CLEAR_AUTH ]))
+        old.close() 
+        peer.close()  // auto relogin
+        return
+      }
+
+
+      //6. delete current (temp rand)cid if exist.
+      if( peer.cid ){
+        peer.manager.cid2remote.delete( peer.cid ) 
+      }
+
+      //7. setting info.
+      peer.did = id
+      peer.cid = authInfo.cid
+      peer.nick =  authInfo.cid // temporary: nick as cid
+
+      //8. setting quota level. 
+      let quotaLevel = serverOption.defaultQuotaIndex;
+      if(authInfo.level) quotaLevel = authInfo.level; 
+      quotaLevel = parseInt( quotaLevel )
+      let newQuota = quotaTable[ quotaLevel ];
+      if(!newQuota){
+        let err = 'no index quotaTable for auth.level: ' + quotaLevel
+        console.log('##AUTH:DATA ERROR##', err)
+        this.send_auth_fail( peer, err );
+        return
+      }else{
+        peer.level = quotaLevel;
+        peer.quota = newQuota;
+      }
+
+      if( peer.level === serverOption.adminLevel){
+        console.log('## LOGIN ADMIN CID:',  peer.cid )
+        peer.isAdmin = true;
+      }
+      // console.log('auth: peer.quota', peer.quota )
+      // send quota.level
+      peer.send( Buffer.from( [IOMsg.QUOTA_LEVEL, quotaLevel] ))
+
+      //9. set cid2remote
+      peer.manager.cid2remote.set( peer.cid , peer )
+      // console.log( 'done: cid2remote:', peer.manager.cid2remote.keys()  )
+      // console.log("LOGIN: ", `id: ${ peer.did}(${peer.cid})` )
+      //10. send ack.
+      peer.send( auth_ack )
+      peer.setState( CLIENT_STATE.AUTH_READY )
+      if( this.authLogger ){
+        let peerInfo = `OK #${peer.ssid} cid: ${peer.cid} did:${ peer.did }`
+        if( peer.isAdmin ) peerInfo = "#ADMIN# "+ peerInfo
+        this.authLogger.log( peerInfo )
+      } 
+      return authInfo
+    } catch (error) {
+      this.send_auth_fail( peer , 'caught: unknown error' + error );
+    }
+
+  }
+
+
+
+  
+}
+

package/src/client/CongPacket.js

@@ -0,0 +1,150 @@
+import { Transform } from 'stream'
+import { MBP } from 'meta-buffer-pack'
+
+export const CongType = {
+  TYPE_LEN1: 1,
+  TYPE_LEN2: 2,
+  TYPE_LEN3: 3,
+  TYPE_LEN4: 4
+}
+
+// support LittleEndian system.
+export function pack(payload) {
+
+  if (payload.byteLength < 256) { //one byte len
+    return MBP.pack(
+      MBP.MB('#type', '8', CongType.TYPE_LEN1),
+      MBP.MB('#payloadLen1', '8', payload.byteLength),
+      MBP.MB('#payload', payload)
+    )
+
+  } else if (payload.byteLength < 65536) {  // 2bytes len
+    return MBP.pack(
+      MBP.MB('#type', '8', CongType.TYPE_LEN2),
+      MBP.MB('#payloadLen2', '16L', payload.byteLength),
+      MBP.MB('#payload', payload)
+    )
+
+  } else if (payload.byteLength < 2 ** 24) {  // 3bytes len
+    let len4Buffer = Buffer.alloc(4)
+    len4Buffer.writeUint32LE( payload.byteLength ) 
+    let cropLen3 = len4Buffer.subarray(0,3)
+    return MBP.pack(
+      MBP.MB('#type', '8', CongType.TYPE_LEN3),
+      MBP.MB('#payloadLen3', cropLen3),
+      MBP.MB('#payload', payload)
+    )
+
+  } else { //use 4 bytes.
+    return MBP.pack(
+      MBP.MB('#type', '8', CongType.TYPE_LEN4),
+      MBP.MB('#payloadLen4', '32L', payload.byteLength),
+      MBP.MB('#payload', payload)
+    )
+  }
+
+}
+
+// let totalCong = 0;
+
+export class CongRx extends Transform {
+  constructor(options) {
+    super(options)
+    // console.log('new congRx. totalCong:', ++totalCong )
+    this.buffer = Buffer.alloc(0)
+    this.frames = []
+    this.rxi = 0;
+    this.rxi_zero = 0;
+  }
+
+
+
+  _transform(chunk, encoding, callback) {
+    this.addData(chunk)
+    if (this.frames.length > 0) {
+      this.frames.forEach(frame => {
+        // console.log('emit frame:', frame)
+        this.push(frame)
+      })
+      this.frames = []
+    }
+    callback()
+  }
+
+
+  addData(chunk) {
+    // console.log('congpack chunk:', chunk )
+    let c = chunk.byteLength;
+    let i = 0;
+    while( c-- ){
+      this.rxi++
+      if( chunk[ i++ ] == 0 ){
+        this.rxi_zero++
+      }
+    }
+
+    if (this.buffer.byteLength > 0) {
+      this.buffer = Buffer.concat([this.buffer, chunk])
+    } else {
+      this.buffer = chunk
+    }
+    // console.log('buffer before parse', this.buffer )
+    this.parse()
+  }
+
+
+  parse() {
+    let head = this.buffer[0]
+    let headerLen;
+    let payloadSize;
+    // find header
+    // console.log('>> parser head, buffer:', head , this.buffer )
+
+    if (head == CongType.TYPE_LEN1) {
+       headerLen = 2;
+      if (this.buffer.byteLength < headerLen) return;
+       payloadSize = this.buffer.readUint8(1)
+
+    } else if (head == CongType.TYPE_LEN2) {
+       headerLen = 3;
+      if (this.buffer.byteLength < headerLen) return;
+       payloadSize = this.buffer.readUint16LE(1)
+
+    } else if (head == CongType.TYPE_LEN3) {
+       headerLen = 4;
+      if (this.buffer.byteLength < headerLen) return;
+       payloadSize = this.buffer.readUint16LE(1) + this.buffer.readUint8(3) * 65536
+
+    } else if (head == CongType.TYPE_LEN4) {
+       headerLen = 5;
+      if (this.buffer.byteLength < headerLen) return;
+       payloadSize = this.buffer.readUint32LE(1)
+
+    } else {
+      // console.log('CongPacket: UNKNOWN_HEAD drop', this.buffer)
+      this.emit('wrong',this.buffer)
+      this.buffer = Buffer.alloc(0)
+    }
+
+
+    if (payloadSize == this.buffer.byteLength - headerLen) {
+      this.frames.push(this.buffer.subarray(headerLen))
+      this.buffer = Buffer.alloc(0)
+      return
+    } else if (payloadSize < this.buffer.byteLength - headerLen) {
+      this.frames.push(this.buffer.subarray(headerLen, headerLen + payloadSize))
+      this.buffer = this.buffer.subarray(headerLen + payloadSize)
+      this.parse()
+    } else { 
+      //not ready
+      // console.log('+')
+      return
+    }
+
+
+  }
+
+
+}
+
+

package/src/client/IOCongSocket.js

@@ -0,0 +1,88 @@
+import { IOCore } from "./IOCore.js"
+import { pack, CongRx } from './CongPacket.js'
+import net from'net'
+
+
+export class IOCongSocket extends IOCore{
+  constructor( url  ) {
+    super( url );
+    if(url) this.open();
+  }
+
+  close() {
+    this.socket?.end();
+    this.socket = null;
+  }
+
+  stop() {
+    this.close()
+    clearInterval(this.connectionCheckerIntervalID);
+    this.connectionCheckerIntervalID = null
+  }
+  
+  keepAlive() {
+    let state = this.socket?.readyState;
+    if ( !this.socket || !(state === 'open' || state === 'opening')  ) {
+      this.open();
+    } 
+  }
+
+
+  createConnection(url){
+    // TCP Socket
+    let urlObj = new URL( url )
+    // console.log(urlObj)
+    if( urlObj.protocol != "cong:"){ 
+      urlObj = new URL( 'cong://'+ url )
+    }
+    // console.log('congSocket url:', urlObj )
+    this.socket = net.createConnection( urlObj.port,  urlObj.hostname )
+    this.stateChange('opening')
+
+    this.socket.on('connect' , ()=>{
+      // console.log('cong connected' )
+      this.congRx = new CongRx();
+      this.socket.pipe( this.congRx )
+      this.congRx.on("data", this.onTCPSocketMessage.bind(this));
+      this.emit('open') 
+    })
+
+    this.socket.on('error', e=>{ 
+      this.emit('error', e)
+    })
+
+    this.socket.on('close', ()=>{ 
+      this.emit('close');
+    })
+
+  }
+
+  onTCPSocketMessage( data ) {
+    this.rxCounter++;
+    this.rxBytes += data.byteLength
+    this.lastTxRxTime = Date.now();
+    // console.log('>> congRx data.len:', data.byteLength )
+    // console.log('>> cong.rxi, rxi_zero:', this.congRx.rxi, this.congRx.rxi_zero )
+    this.emit('socket_data', data  );
+    
+  }
+
+  socket_send(data) {  
+    if( this.socket?.readyState === 'open'){
+      // console.log('tcp send raw payload:', data)
+      let packData = pack(data);
+      // console.log('tcp send cong packed:', packData)
+      this.socket.write( packData )
+      this.txCounter++;
+      this.txBytes += packData.byteLength;
+      this.lastTxRxTime = Date.now();
+    }else{
+      console.log('.')
+    }
+  }
+ 
+}
+
+
+
+