iosignal 7.2.0 → 8.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -15,7 +15,7 @@ import fs, { readFileSync } from 'fs';
15
15
  import { memoryUsage } from 'process';
16
16
  import path from 'path';
17
17
 
18
- var version$1 = "7.2.0";
18
+ var version$1 = "8.0.0";
19
19
  var pkg = {
20
20
  version: version$1};
21
21
 
@@ -1049,7 +1049,9 @@ class IOCore extends EventEmitter {
1049
1049
 
1050
1050
  /**
1051
1051
  * Permanently destroys the instance, cleaning up all resources.
1052
- * The instance will not be usable after this.
1052
+ * The instance will not be usable after this. Later signal()/publish()/subscribe()
1053
+ * calls are silently dropped, the same as sends while disconnected, and call()
1054
+ * rejects with code 'CONNECTION_CLOSED'.
1053
1055
  */
1054
1056
  destroy() {
1055
1057
  this.stop();
@@ -1549,7 +1551,7 @@ class IOCore extends EventEmitter {
1549
1551
  getEncryptionMode() {
1550
1552
  if (this.encMode === ENC_MODE.YES ||
1551
1553
  this.encMode === ENC_MODE.AUTO &&
1552
- !this.TLS && this.boho.isAuthorized
1554
+ !this.TLS && this.boho?.isAuthorized
1553
1555
  ) {
1554
1556
  return true;
1555
1557
  } else {
@@ -1559,10 +1561,12 @@ class IOCore extends EventEmitter {
1559
1561
 
1560
1562
  /**
1561
1563
  * Sends data with encryption based on the encryption mode.
1564
+ * Like an unconnected socket, a destroyed instance silently drops the data.
1562
1565
  * @param {Buffer} data - The data buffer to send.
1563
1566
  * @param {boolean} [useEncryption] - Optional. Force encryption or not. If undefined, uses default policy.
1564
1567
  */
1565
1568
  send_enc_mode(data, useEncryption) {
1569
+ if (!this.boho) return; // destroyed
1566
1570
 
1567
1571
  // use default policy.
1568
1572
  if (useEncryption === undefined) {
@@ -1680,7 +1684,7 @@ class IOCore extends EventEmitter {
1680
1684
 
1681
1685
  const tagEncoded = encodeTag(tag);
1682
1686
  if (tag.startsWith('@') && this.cid) encodeTag(this.cid + tag);
1683
- if( !this.boho.isAuthorized ) return;
1687
+ if( !this.boho?.isAuthorized ) return;
1684
1688
  let dataPack = $$1.B8(data);
1685
1689
 
1686
1690
  //encrypt payload area with key
@@ -1737,6 +1741,12 @@ class IOCore extends EventEmitter {
1737
1741
  call(target, topic, ...args) {
1738
1742
  if (!target || !topic)
1739
1743
  return Promise.reject(new Error('request need target and topic)'))
1744
+ if (!this.boho) {
1745
+ // destroyed: reject like close() does for pending calls instead of waiting for a timeout.
1746
+ const error = new Error('Connection closed');
1747
+ error.code = 'CONNECTION_CLOSED';
1748
+ return Promise.reject(error);
1749
+ }
1740
1750
  this.mid = (this.mid + 1) & 0xffff;
1741
1751
  let sigPack;
1742
1752
  if (args.length > 0) {
@@ -1980,7 +1990,7 @@ class IOCore extends EventEmitter {
1980
1990
  return {
1981
1991
  useAuth: this.useAuth,
1982
1992
  isTLS: this.TLS,
1983
- isAuthorized: this.boho.isAuthorized,
1993
+ isAuthorized: this.boho?.isAuthorized ?? false,
1984
1994
  encMode: this.encMode,
1985
1995
  usingEncryption: this.getEncryptionMode()
1986
1996
  }
@@ -2198,6 +2208,8 @@ class IOCongSocket extends IOCore {
2198
2208
  urlObj = new URL('cong://' + url);
2199
2209
  }
2200
2210
  const socket = this.socket = net.createConnection(urlObj.port, urlObj.hostname);
2211
+ // Signals are small frames; send each immediately instead of waiting on Nagle.
2212
+ socket.setNoDelay(true);
2201
2213
  this._closed = false;
2202
2214
 
2203
2215
  this.socket.on('connect', () => {
@@ -2238,8 +2250,6 @@ class IOCongSocket extends IOCore {
2238
2250
  this.txCounter++;
2239
2251
  this.txBytes += packData.byteLength;
2240
2252
  this.lastTxRxTime = Date.now();
2241
- } else {
2242
- console.log('.');
2243
2253
  }
2244
2254
  }
2245
2255
 
@@ -7366,8 +7376,6 @@ class IOWS extends IOCore {
7366
7376
  this.txCounter++;
7367
7377
  this.txBytes += data.byteLength;
7368
7378
  this.lastTxRxTime = Date.now();
7369
- } else {
7370
- console.log('.');
7371
7379
  }
7372
7380
  }
7373
7381
 
@@ -7428,7 +7436,11 @@ let serverOption = {
7428
7436
  },
7429
7437
 
7430
7438
  auth: {
7431
- delay_auth_fail: 600
7439
+ delay_auth_fail: 600,
7440
+ // Same authenticated CID already online:
7441
+ // 'keepNew' (default) replaces the old connection, 'keepOld' rejects the new login.
7442
+ // Override per Server with options.duplicateLogin, or per BohoAuth with its duplicateLogin option.
7443
+ duplicateLogin: 'keepNew'
7432
7444
  },
7433
7445
  membersOnly: false
7434
7446
 
@@ -7687,7 +7699,13 @@ class RemoteCore {
7687
7699
  }
7688
7700
 
7689
7701
  if (!this.cid) {
7690
- this.cid = '?' + globalThis.crypto.getRandomValues(Buffer.alloc(3)).toString('base64url');
7702
+ const cid = this.manager.issueAnonymousCid();
7703
+ if (!cid) {
7704
+ console.log('anonymous CID space exhausted');
7705
+ this.close();
7706
+ return;
7707
+ }
7708
+ this.cid = cid;
7691
7709
  this.manager.cid2remote.set(this.cid, this);
7692
7710
  }
7693
7711
 
@@ -8524,8 +8542,12 @@ class Manager {
8524
8542
 
8525
8543
  let remoteInfo = `- IP:${remote.ip} #${remote.ssid} cid:${remote.cid} ${remote?.socket.socketType === 'websocket' ? "WS" : "CS"} `;
8526
8544
  if (this.connectionLogger) this.connectionLogger.log(remoteInfo);
8527
- this.deligateSignal(remote, '@state', 'close');
8528
- this.deligateSignal(remote, '@$state', 'close');
8545
+ // A replaced duplicate login no longer owns its CID; the new connection is still online.
8546
+ const cidOwner = this.cid2remote.get(remote.cid);
8547
+ if (!remote.cid || !cidOwner || cidOwner === remote) {
8548
+ this.deligateSignal(remote, '@state', 'close');
8549
+ this.deligateSignal(remote, '@$state', 'close');
8550
+ }
8529
8551
 
8530
8552
  // remove subscriber
8531
8553
  for (let ch of remote.channels.keys()) {
@@ -8552,10 +8574,14 @@ class Manager {
8552
8574
  }
8553
8575
 
8554
8576
 
8555
- if (remote.uid && this.server.serviceNames.has('account')) {
8556
- let req = { topic: 'detachUserRemote' };
8557
- req.args = ['caller:manager.removeRemote'];
8558
- this.server.emit('account', remote, req);
8577
+ // Service lifecycle hook. Called directly: RPC permission/command checks do not apply to cleanup.
8578
+ for (const service of new Set(this.server.services?.values() ?? [])) {
8579
+ if (typeof service.onRemoteClose !== 'function') continue
8580
+ try {
8581
+ service.onRemoteClose(remote);
8582
+ } catch (error) {
8583
+ console.error('service onRemoteClose error:', error);
8584
+ }
8559
8585
  }
8560
8586
 
8561
8587
  this.remotes.delete(remote);
@@ -8853,6 +8879,23 @@ class Manager {
8853
8879
  }
8854
8880
 
8855
8881
 
8882
+ anonymousCidRandom(size) {
8883
+ return globalThis.crypto.getRandomValues(Buffer.alloc(size))
8884
+ }
8885
+
8886
+ // '?' + base64url random bytes, never one that is online. Check and set run in the same
8887
+ // synchronous turn (CID_REQ handler), so concurrent requests cannot take the same CID.
8888
+ // 3 bytes (4 chars) normally; 6 bytes (8 chars) if the short space keeps colliding.
8889
+ issueAnonymousCid() {
8890
+ for (const [size, tries] of [[3, 8], [6, 8]]) {
8891
+ for (let i = 0; i < tries; i++) {
8892
+ const cid = '?' + Buffer.from(this.anonymousCidRandom(size)).toString('base64url');
8893
+ if (!this.cid2remote.has(cid)) return cid
8894
+ }
8895
+ }
8896
+ return null
8897
+ }
8898
+
8856
8899
  closeRemoteByCId(cid) {
8857
8900
  if (this.cid2remote.has(cid)) {
8858
8901
  this.cid2remote.get(cid).close();
@@ -8891,6 +8934,265 @@ const STATUS = {
8891
8934
  ERROR: 255
8892
8935
  };
8893
8936
 
8937
+ const decoder = new TextDecoder();
8938
+ const DUPLICATE_LOGIN_POLICIES = ['keepOld', 'keepNew'];
8939
+ // Only WebSocket remotes carry socketType; CongSocket remotes leave it unset.
8940
+ const transportOf = remote => remote.socketType === 'websocket' ? 'websocket' : 'congsocket';
8941
+
8942
+ function validateDuplicateLogin(policy) {
8943
+ if (!DUPLICATE_LOGIN_POLICIES.includes(policy)) {
8944
+ throw new RangeError(`duplicateLogin must be one of: ${DUPLICATE_LOGIN_POLICIES.join(', ')}`)
8945
+ }
8946
+ return policy
8947
+ }
8948
+
8949
+ class BohoAuth {
8950
+ /**
8951
+ * @param {object} keyProvider
8952
+ * @param {{ duplicateLogin?: 'keepOld' | 'keepNew', onAuthEvent?: (event: object) => any }} [options]
8953
+ * duplicateLogin: unset follows serverOption.auth.duplicateLogin (default 'keepNew').
8954
+ * onAuthEvent: called with { type, did, cid, uid, ip, oldIp, socketType, oldSocketType, reason, at }
8955
+ * for 'replaced' (keepNew evicted the old connection) and 'duplicate_rejected' (keepOld).
8956
+ * socketType/oldSocketType are 'websocket' or 'congsocket'.
8957
+ * Errors and rejected promises are logged and never affect authentication.
8958
+ */
8959
+ constructor(keyProvider, options = {}) {
8960
+ if (!keyProvider) {
8961
+ throw new Error('BohoAuth must be initialized with a keyProvider.');
8962
+ }
8963
+ this.keyProvider = keyProvider;
8964
+ this._duplicateLogin = null;
8965
+ if (options.duplicateLogin !== undefined) this.duplicateLogin = options.duplicateLogin;
8966
+ this.onAuthEvent = options.onAuthEvent ?? null;
8967
+ this.authLogger;
8968
+ if (serverOption.fileLogger.auth.use) {
8969
+ this.authLogger = new FileLogger(serverOption.fileLogger.auth.path);
8970
+ console.log('Auth: begin file logger.[auth]');
8971
+ }
8972
+ }
8973
+
8974
+ /** Effective duplicate login policy: this instance's setting, else serverOption.auth.duplicateLogin. */
8975
+ get duplicateLogin() {
8976
+ return this._duplicateLogin ?? serverOption.auth.duplicateLogin;
8977
+ }
8978
+
8979
+ /** @param {'keepOld' | 'keepNew' | null} policy null returns to the serverOption default. */
8980
+ set duplicateLogin(policy) {
8981
+ this._duplicateLogin = policy === null ? null : validateDuplicateLogin(policy);
8982
+ }
8983
+
8984
+ // Backward-compatible boolean form of duplicateLogin.
8985
+ get keepOldConnection() {
8986
+ return this.duplicateLogin === 'keepOld';
8987
+ }
8988
+
8989
+ set keepOldConnection(keepOld) {
8990
+ this.duplicateLogin = keepOld ? 'keepOld' : 'keepNew';
8991
+ }
8992
+
8993
+ emitAuthEvent(event) {
8994
+ if (typeof this.onAuthEvent !== 'function') return;
8995
+ try {
8996
+ Promise.resolve(this.onAuthEvent(event)).catch(error => console.error('onAuthEvent error:', error));
8997
+ } catch (error) {
8998
+ console.error('onAuthEvent error:', error);
8999
+ }
9000
+ }
9001
+
9002
+ send_auth_fail(peer, reason) {
9003
+ if (peer._closing || peer.state === STATE.CLOSED) return;
9004
+ peer.boho.isAuthorized = false;
9005
+ if (this.authLogger) {
9006
+ let peerInfo = `FAIL #${peer.ssid} reason:${reason} `;
9007
+ this.authLogger.log(peerInfo);
9008
+ }
9009
+ // console.log('##### AUTH_FAIL reason: ', reason)
9010
+ peer.setState(STATE.AUTH_FAIL);
9011
+ // add some delay time.
9012
+ setTimeout(e => {
9013
+ if (!peer._closing && peer.state === STATE.AUTH_FAIL) {
9014
+ peer.send(Buffer.from([it.BohoMsg.AUTH_FAIL]));
9015
+ }
9016
+ }, serverOption.auth.delay_auth_fail);
9017
+ }
9018
+
9019
+
9020
+ async verify_auth_req(auth_req, peer) {
9021
+ try {
9022
+ if (!peer.checkAuthChallenge()) return;
9023
+ if (!(auth_req instanceof Uint8Array) || auth_req.length !== it.MetaSize.AUTH_REQ ||
9024
+ auth_req[0] !== it.BohoMsg.AUTH_REQ) {
9025
+ peer.securityMismatch('INVALID_AUTH_PACKET');
9026
+ return;
9027
+ }
9028
+ //1. unpack
9029
+ let infoPack = $$1.unpack(auth_req, it.Meta.AUTH_REQ);
9030
+ if (!infoPack) {
9031
+ this.send_auth_fail(peer, 'unpack auth_pack fail');
9032
+ return
9033
+ }
9034
+
9035
+ let id = "";
9036
+ if (infoPack.id8.includes(0)) {
9037
+ id = decoder.decode(infoPack.id8.subarray(0, infoPack.id8.indexOf(0)));
9038
+ } else {
9039
+ id = decoder.decode(infoPack.id8);
9040
+ }
9041
+
9042
+ //2. get key of id from DB
9043
+ let authInfo = await this.keyProvider.getAuth(id);
9044
+ if (!peer.checkAuthChallenge()) return;
9045
+ if (!authInfo) {
9046
+ this.send_auth_fail(peer, 'NO ID:' + id);
9047
+ return
9048
+ }
9049
+
9050
+ if (serverOption.debug.showAuthInfo) {
9051
+ console.log('[debug]showAuthInfo', authInfo);
9052
+ }
9053
+
9054
+ peer.boho.copy_id8(infoPack.id8);
9055
+ // type of key
9056
+ let authKey;
9057
+ const SHA256_HASH_BASE64_LEN = 44;
9058
+ if (authInfo.key.length == SHA256_HASH_BASE64_LEN) {
9059
+ // hashed key
9060
+ authKey = Buffer.from(authInfo.key, 'base64');
9061
+ peer.boho.copy_key(authKey);
9062
+ } else {
9063
+ // plain key
9064
+ peer.boho.set_key(authInfo.key);
9065
+ }
9066
+
9067
+ //3. check hmac
9068
+ let auth_res = peer.boho.verify_auth_req(infoPack);
9069
+ if (!auth_res) {
9070
+ this.send_auth_fail(peer, 'hmac dismatched');
9071
+ return
9072
+ }
9073
+
9074
+ // A valid proof consumes this challenge even if account policy rejects it.
9075
+ // Reauthentication requires a new connection, never a replay-state reset.
9076
+ peer._challengeUsed = true;
9077
+
9078
+ //4. get info
9079
+
9080
+ //5. check duplicate login.
9081
+ if (peer.manager.cid2remote.has(authInfo.cid) && peer.manager.cid2remote.get(authInfo.cid) !== peer) {
9082
+ let old = peer.manager.cid2remote.get(authInfo.cid);
9083
+ console.log('[WARN]DUPLICATE_LOGIN detected.', old.cid);
9084
+ old.ping(); // check the connection.
9085
+
9086
+ let authClearSignal = $$1.pack(
9087
+ $$1.MB('#MsgType', '8', IOMsg.AUTH_CLEAR),
9088
+ $$1.MB('#reason', 'duplicate login.')
9089
+ );
9090
+ if (this.keepOldConnection) { // duplicateLogin 'keepOld'
9091
+ peer.boho.isAuthorized = false;
9092
+ // keep old connection. reject new connection by sending auth_fail signal.
9093
+ // peer.send(authClearSignal)
9094
+ if( peer.socketType == 'websocket'){
9095
+ this.send_auth_fail(peer, 'duplicate login');
9096
+ }else {
9097
+ peer.setState(STATE.AUTH_FAIL);
9098
+ peer.close(); //arduino
9099
+ }
9100
+ } else {
9101
+ // accept new connection. stop the old connection by sending auth_clear signal.
9102
+ old.send(authClearSignal);
9103
+ old.close();
9104
+ }
9105
+ this.emitAuthEvent({
9106
+ type: this.keepOldConnection ? 'duplicate_rejected' : 'replaced',
9107
+ did: id, cid: authInfo.cid, uid: authInfo.uid || null,
9108
+ ip: peer.ip, oldIp: old.ip,
9109
+ socketType: transportOf(peer), oldSocketType: transportOf(old),
9110
+ reason: 'duplicate login', at: Date.now()
9111
+ });
9112
+ if (this.keepOldConnection) return
9113
+ }
9114
+
9115
+ //6. delete current (or anonymouse)cid if exist.
9116
+ if (peer.cid) {
9117
+ // console.log('if peer has cid', peer.cid)
9118
+ peer.manager.cid2remote.delete(peer.cid);
9119
+ }
9120
+
9121
+ //7. setting info.
9122
+ peer.did = id;
9123
+ peer.cid = authInfo.cid;
9124
+ peer.nick = authInfo.cid; // temporary: nick as cid
9125
+ if (authInfo.uid) peer.uid = authInfo.uid;
9126
+
9127
+ //8. setting quota level.
9128
+ let quotaLevel = serverOption.defaultQuotaIndex;
9129
+ if (authInfo.level) quotaLevel = authInfo.level;
9130
+ quotaLevel = parseInt(quotaLevel);
9131
+ let newQuota = quotaTable[quotaLevel];
9132
+ if (!newQuota) {
9133
+ let err = 'no index quotaTable for auth.level: ' + quotaLevel;
9134
+ this.send_auth_fail(peer, err);
9135
+ return
9136
+ } else {
9137
+ peer.level = quotaLevel;
9138
+ peer.quota = newQuota;
9139
+ }
9140
+
9141
+ if (peer.level === serverOption.adminLevel) {
9142
+ console.log('## LOGIN ADMIN CID:', peer.cid);
9143
+ peer.isAdmin = true;
9144
+ }
9145
+ // send quota.level
9146
+ peer.send(Buffer.from([IOMsg.QUOTA_LEVEL, quotaLevel]));
9147
+
9148
+ //9. set cid2remote
9149
+ peer.manager.cid2remote.set(peer.cid, peer);
9150
+ //10. send ack.
9151
+ peer.send(auth_res);
9152
+ peer.setState(STATE.AUTH_RES);
9153
+ if (this.authLogger) {
9154
+ let peerInfo = `OK #${peer.ssid} cid: ${peer.cid} did:${peer.did}`;
9155
+ if (peer.isAdmin) peerInfo = "#ADMIN# " + peerInfo;
9156
+ this.authLogger.log(peerInfo);
9157
+ }
9158
+ return authInfo
9159
+ } catch (error) {
9160
+ console.log('verify_auth_req error', error);
9161
+ this.send_auth_fail(peer, '[BohoAuth]caught: unknown error:' + error);
9162
+ }
9163
+ }
9164
+
9165
+ async getAuth(id) {
9166
+ return this.keyProvider.getAuth(id);
9167
+ }
9168
+
9169
+ async getAuthIdList() {
9170
+ if (typeof this.keyProvider.getAuthIdList === 'function') {
9171
+ return this.keyProvider.getAuthIdList();
9172
+ }
9173
+ }
9174
+
9175
+ async addAuth(id, keyStr, cid, level = 0) {
9176
+ if (typeof this.keyProvider.addAuth === 'function') {
9177
+ return this.keyProvider.addAuth(id, keyStr, cid, level);
9178
+ }
9179
+ }
9180
+
9181
+ async delAuth(id) {
9182
+ if (typeof this.keyProvider.delAuth === 'function') {
9183
+ return this.keyProvider.delAuth(id);
9184
+ }
9185
+ }
9186
+
9187
+ async save() {
9188
+ if (typeof this.keyProvider.save === 'function') {
9189
+ return this.keyProvider.save();
9190
+ }
9191
+ }
9192
+
9193
+
9194
+ }
9195
+
8894
9196
  class Server extends require$$0$3 {
8895
9197
 
8896
9198
  /**
@@ -8907,6 +9209,7 @@ class Server extends require$$0$3 {
8907
9209
  }
8908
9210
  this.security = Object.freeze(security);
8909
9211
  this.serviceNames = new Set();
9212
+ this.services = new Map(); // name -> service module (for lifecycle hooks)
8910
9213
  this.wss = {};
8911
9214
  this.port = null;
8912
9215
  this.congPort = null;
@@ -8935,6 +9238,16 @@ class Server extends require$$0$3 {
8935
9238
  if (options.membersOnly) {
8936
9239
  serverOption.membersOnly = options.membersOnly;
8937
9240
  }
9241
+ // Applies to this server's auth manager only; without auth there are no duplicate logins.
9242
+ if (options.duplicateLogin !== undefined) {
9243
+ validateDuplicateLogin(options.duplicateLogin);
9244
+ if (authManager) {
9245
+ if (!('duplicateLogin' in authManager)) {
9246
+ throw new TypeError('duplicateLogin: the auth manager does not support this option')
9247
+ }
9248
+ authManager.duplicateLogin = options.duplicateLogin;
9249
+ }
9250
+ }
8938
9251
 
8939
9252
 
8940
9253
  if (options.port || options.port == 0) {
@@ -9014,6 +9327,8 @@ class Server extends require$$0$3 {
9014
9327
 
9015
9328
  startCongServer() {
9016
9329
  this.congServer = net.createServer((socket) => {
9330
+ // Signals are small frames; send each immediately instead of waiting on Nagle.
9331
+ socket.setNoDelay(true);
9017
9332
  this.manager.addRemote(socket);
9018
9333
  })
9019
9334
  .on('error', (err) => {
@@ -9082,6 +9397,7 @@ class Server extends require$$0$3 {
9082
9397
  }
9083
9398
  });
9084
9399
  this.serviceNames.add(service);
9400
+ this.services.set(service, service_module);
9085
9401
  // console.log(`[Service attached: ${service} ] accept commands: ${service_module.commands}`)
9086
9402
  return this
9087
9403
  }
@@ -9097,6 +9413,7 @@ class Server extends require$$0$3 {
9097
9413
 
9098
9414
  this.serviceNames.forEach(v => this.removeAllListeners(v));
9099
9415
  this.serviceNames.clear();
9416
+ // this.services is kept so onRemoteClose cleanup still runs for sockets that close later.
9100
9417
 
9101
9418
  let serverCount = 0;
9102
9419
  if (this.wss) serverCount++;
@@ -9134,208 +9451,6 @@ class Server extends require$$0$3 {
9134
9451
 
9135
9452
  }
9136
9453
 
9137
- const decoder = new TextDecoder();
9138
- class BohoAuth {
9139
- constructor(keyProvider) {
9140
- if (!keyProvider) {
9141
- throw new Error('BohoAuth must be initialized with a keyProvider.');
9142
- }
9143
- this.keyProvider = keyProvider;
9144
- this.keepOldConnection = true;
9145
- this.authLogger;
9146
- if (serverOption.fileLogger.auth.use) {
9147
- this.authLogger = new FileLogger(serverOption.fileLogger.auth.path);
9148
- console.log('Auth: begin file logger.[auth]');
9149
- }
9150
- }
9151
-
9152
- send_auth_fail(peer, reason) {
9153
- if (peer._closing || peer.state === STATE.CLOSED) return;
9154
- peer.boho.isAuthorized = false;
9155
- if (this.authLogger) {
9156
- let peerInfo = `FAIL #${peer.ssid} reason:${reason} `;
9157
- this.authLogger.log(peerInfo);
9158
- }
9159
- // console.log('##### AUTH_FAIL reason: ', reason)
9160
- peer.setState(STATE.AUTH_FAIL);
9161
- // add some delay time.
9162
- setTimeout(e => {
9163
- if (!peer._closing && peer.state === STATE.AUTH_FAIL) {
9164
- peer.send(Buffer.from([it.BohoMsg.AUTH_FAIL]));
9165
- }
9166
- }, serverOption.auth.delay_auth_fail);
9167
- }
9168
-
9169
-
9170
- async verify_auth_req(auth_req, peer) {
9171
- try {
9172
- if (!peer.checkAuthChallenge()) return;
9173
- if (!(auth_req instanceof Uint8Array) || auth_req.length !== it.MetaSize.AUTH_REQ ||
9174
- auth_req[0] !== it.BohoMsg.AUTH_REQ) {
9175
- peer.securityMismatch('INVALID_AUTH_PACKET');
9176
- return;
9177
- }
9178
- //1. unpack
9179
- let infoPack = $$1.unpack(auth_req, it.Meta.AUTH_REQ);
9180
- if (!infoPack) {
9181
- this.send_auth_fail(peer, 'unpack auth_pack fail');
9182
- return
9183
- }
9184
-
9185
- let id = "";
9186
- if (infoPack.id8.includes(0)) {
9187
- id = decoder.decode(infoPack.id8.subarray(0, infoPack.id8.indexOf(0)));
9188
- } else {
9189
- id = decoder.decode(infoPack.id8);
9190
- }
9191
-
9192
- //2. get key of id from DB
9193
- let authInfo = await this.keyProvider.getAuth(id);
9194
- if (!peer.checkAuthChallenge()) return;
9195
- if (!authInfo) {
9196
- this.send_auth_fail(peer, 'NO ID:' + id);
9197
- return
9198
- }
9199
-
9200
- if (serverOption.debug.showAuthInfo) {
9201
- console.log('[debug]showAuthInfo', authInfo);
9202
- }
9203
-
9204
- peer.boho.copy_id8(infoPack.id8);
9205
- // type of key
9206
- let authKey;
9207
- const SHA256_HASH_BASE64_LEN = 44;
9208
- if (authInfo.key.length == SHA256_HASH_BASE64_LEN) {
9209
- // hashed key
9210
- authKey = Buffer.from(authInfo.key, 'base64');
9211
- peer.boho.copy_key(authKey);
9212
- } else {
9213
- // plain key
9214
- peer.boho.set_key(authInfo.key);
9215
- }
9216
-
9217
- //3. check hmac
9218
- let auth_res = peer.boho.verify_auth_req(infoPack);
9219
- if (!auth_res) {
9220
- this.send_auth_fail(peer, 'hmac dismatched');
9221
- return
9222
- }
9223
-
9224
- // A valid proof consumes this challenge even if account policy rejects it.
9225
- // Reauthentication requires a new connection, never a replay-state reset.
9226
- peer._challengeUsed = true;
9227
-
9228
- //4. get info
9229
-
9230
- //5. check duplicate login.
9231
- if (peer.manager.cid2remote.has(authInfo.cid) && peer.manager.cid2remote.get(authInfo.cid) !== peer) {
9232
- let old = peer.manager.cid2remote.get(authInfo.cid);
9233
- console.log('[WARN]DUPLICATE_LOGIN detected.', old.cid);
9234
- old.ping(); // check the connection.
9235
-
9236
- let authClearSignal = $$1.pack(
9237
- $$1.MB('#MsgType', '8', IOMsg.AUTH_CLEAR),
9238
- $$1.MB('#reason', 'duplicate login.')
9239
- );
9240
- if (this.keepOldConnection) { // default true
9241
- peer.boho.isAuthorized = false;
9242
- // keep old connection. reject new connection by sending auth_fail signal.
9243
- // peer.send(authClearSignal)
9244
- if( peer.socketType == 'websocket'){
9245
- this.send_auth_fail(peer, 'duplicate login');
9246
- }else {
9247
- peer.setState(STATE.AUTH_FAIL);
9248
- peer.close(); //arduino
9249
- }
9250
- } else {
9251
- // accept new connection. stop the old connection by sending auth_clear signal.
9252
- old.send(authClearSignal);
9253
- old.close();
9254
- }
9255
- if (this.keepOldConnection) return
9256
- }
9257
-
9258
- //6. delete current (or anonymouse)cid if exist.
9259
- if (peer.cid) {
9260
- // console.log('if peer has cid', peer.cid)
9261
- peer.manager.cid2remote.delete(peer.cid);
9262
- }
9263
-
9264
- //7. setting info.
9265
- peer.did = id;
9266
- peer.cid = authInfo.cid;
9267
- peer.nick = authInfo.cid; // temporary: nick as cid
9268
- if (authInfo.uid) peer.uid = authInfo.uid;
9269
-
9270
- //8. setting quota level.
9271
- let quotaLevel = serverOption.defaultQuotaIndex;
9272
- if (authInfo.level) quotaLevel = authInfo.level;
9273
- quotaLevel = parseInt(quotaLevel);
9274
- let newQuota = quotaTable[quotaLevel];
9275
- if (!newQuota) {
9276
- let err = 'no index quotaTable for auth.level: ' + quotaLevel;
9277
- this.send_auth_fail(peer, err);
9278
- return
9279
- } else {
9280
- peer.level = quotaLevel;
9281
- peer.quota = newQuota;
9282
- }
9283
-
9284
- if (peer.level === serverOption.adminLevel) {
9285
- console.log('## LOGIN ADMIN CID:', peer.cid);
9286
- peer.isAdmin = true;
9287
- }
9288
- // send quota.level
9289
- peer.send(Buffer.from([IOMsg.QUOTA_LEVEL, quotaLevel]));
9290
-
9291
- //9. set cid2remote
9292
- peer.manager.cid2remote.set(peer.cid, peer);
9293
- //10. send ack.
9294
- peer.send(auth_res);
9295
- peer.setState(STATE.AUTH_RES);
9296
- if (this.authLogger) {
9297
- let peerInfo = `OK #${peer.ssid} cid: ${peer.cid} did:${peer.did}`;
9298
- if (peer.isAdmin) peerInfo = "#ADMIN# " + peerInfo;
9299
- this.authLogger.log(peerInfo);
9300
- }
9301
- return authInfo
9302
- } catch (error) {
9303
- console.log('verify_auth_req error', error);
9304
- this.send_auth_fail(peer, '[BohoAuth]caught: unknown error:' + error);
9305
- }
9306
- }
9307
-
9308
- async getAuth(id) {
9309
- return this.keyProvider.getAuth(id);
9310
- }
9311
-
9312
- async getAuthIdList() {
9313
- if (typeof this.keyProvider.getAuthIdList === 'function') {
9314
- return this.keyProvider.getAuthIdList();
9315
- }
9316
- }
9317
-
9318
- async addAuth(id, keyStr, cid, level = 0) {
9319
- if (typeof this.keyProvider.addAuth === 'function') {
9320
- return this.keyProvider.addAuth(id, keyStr, cid, level);
9321
- }
9322
- }
9323
-
9324
- async delAuth(id) {
9325
- if (typeof this.keyProvider.delAuth === 'function') {
9326
- return this.keyProvider.delAuth(id);
9327
- }
9328
- }
9329
-
9330
- async save() {
9331
- if (typeof this.keyProvider.save === 'function') {
9332
- return this.keyProvider.save();
9333
- }
9334
- }
9335
-
9336
-
9337
- }
9338
-
9339
9454
  class FileKeyProvider {
9340
9455
  constructor(_path) {
9341
9456
  this.AUTH = new Map();
@@ -9544,8 +9659,9 @@ const commands = [
9544
9659
  ];
9545
9660
 
9546
9661
  const MIN_LEVEL$1 = 255;
9662
+ // Only a Boho-authenticated device may use sudo; a raised level alone is not authentication.
9547
9663
  function checkPermission(remote) {
9548
- return (remote.level >= MIN_LEVEL$1) ? true : false;
9664
+ return remote.boho?.isAuthorized === true && remote.level >= MIN_LEVEL$1;
9549
9665
  }
9550
9666
 
9551
9667
  async function call(remote, req) {
@@ -9637,21 +9753,30 @@ const MIN_LEVEL = 200;
9637
9753
  const COMMANDS = [
9638
9754
  'GET', 'SET', 'HGETALL', 'HGET', 'HSET', 'SADD', 'SISMEMBER',
9639
9755
  'SMEMBERS', 'EXISTS', 'SREM', 'DEL', 'KEYS', 'SAVE',
9756
+ 'LPUSH', 'LTRIM', 'LRANGE', 'LINDEX', 'LSET', 'EXPIRE',
9640
9757
  'get', 'set', 'hGetAll', 'hGet', 'hSet', 'sAdd', 'sIsMember',
9641
- 'sMembers', 'exists', 'sRem', 'del', 'keys', 'save'
9758
+ 'sMembers', 'exists', 'sRem', 'del', 'keys', 'save',
9759
+ 'lPush', 'lTrim', 'lRange', 'lIndex', 'lSet', 'expire'
9642
9760
  ];
9643
9761
 
9644
9762
  class RedisService {
9645
- constructor(redisClient, _minLevel) {
9763
+ /**
9764
+ * @param {object} redisClient
9765
+ * @param {number} [_minLevel=200]
9766
+ * @param {{ requireAuth?: boolean }} [options] requireAuth (default true): allow Boho-authenticated remotes only.
9767
+ */
9768
+ constructor(redisClient, _minLevel, options = {}) {
9646
9769
  if (!redisClient) {
9647
9770
  throw new Error("RedisService constructor: no redisClient")
9648
9771
  }
9649
9772
  this.redisClient = redisClient;
9650
9773
  this.minLevel = _minLevel ? _minLevel : MIN_LEVEL;
9774
+ this.requireAuth = options.requireAuth !== false;
9651
9775
  this.commands = COMMANDS;
9652
9776
  }
9653
9777
 
9654
9778
  checkPermission(remote, req) {
9779
+ if (this.requireAuth && remote.boho?.isAuthorized !== true) return false;
9655
9780
  return (remote.level >= this.minLevel) ? true : false;
9656
9781
  }
9657
9782