dignity.js 0.6.0 → 0.7.1

package/src/core/dignity-p2p.js

@@ -1,7 +1,17 @@
 const nacl = require('tweetnacl');
 const naclUtil = require('tweetnacl-util');
 const EventEmitter = require('../utils/event-emitter');
-const { MessageSecurityService, stableStringify } = require('../security/message-security-service');
+const {
+  MessageSecurityService,
+  stableStringify,
+  DEFAULT_APP_PASSWORD
+} = require('../security/message-security-service');
+const {
+  revokeAndRotateIdentity,
+  rotateIdentityPassword,
+  enrollColdRecoveryPassword
+} = require('../security/identity-rotation');
+const { deriveKeyPairFromCredentials } = require('../security/derive-key-pair');
 const {
   DEFAULT_PEER_GROUP_OPTIONS,
   peerGroupScope,
@@ -91,6 +101,13 @@ class DignityP2P extends EventEmitter {
     this.gossipIdTtlMs = security && typeof security.gossipIdTtlMs === 'number'
       ? security.gossipIdTtlMs
       : 5 * 60 * 1000;
+    this.maxSeenGossipIds = security && typeof security.maxSeenGossipIds === 'number'
+      ? security.maxSeenGossipIds
+      : 100000;
+    this.gossipPublishMinIntervalMs = security && typeof security.gossipPublishMinIntervalMs === 'number'
+      ? security.gossipPublishMinIntervalMs
+      : 0;
+    this.lastGossipPublishAt = new Map(); // groupId -> timestamp
     this.maxAppliedOperations = security && typeof security.maxAppliedOperations === 'number'
       ? security.maxAppliedOperations
       : 50000;
@@ -103,6 +120,14 @@ class DignityP2P extends EventEmitter {
   async start() {
     this.networkAdapter.onMessage(this.boundMessageHandler);
     await this.networkAdapter.start(this.nodeId);
+
+    const appPassword = this.securityService.options.appPassword;
+    if (!appPassword || appPassword === DEFAULT_APP_PASSWORD) {
+      this.emit('warning', {
+        type: 'default-app-password',
+        message: 'Using the default appPassword is insecure; set a strong shared secret in production.'
+      });
+    }
   }
 
   async stop() {
@@ -461,8 +486,154 @@ class DignityP2P extends EventEmitter {
     });
   }
 
-  registerPeerPublicKey(peerId, publicKey) {
-    this.securityService.registerPeerPublicKey(peerId, publicKey);
+  registerPeerPublicKey(peerId, publicKey, options = {}) {
+    this.securityService.registerPeerPublicKey(peerId, publicKey, options);
+  }
+
+  getPeerIdentityGeneration(peerId) {
+    return this.securityService.getPeerIdentityGeneration(peerId);
+  }
+
+  getPeerIdentityState(peerId) {
+    return this.securityService.getPeerIdentityState(peerId);
+  }
+
+  applyPeerIdentityRotation(peerId, rotation) {
+    const result = this.securityService.applyIdentityRotation(peerId, rotation);
+    if (result.applied) {
+      this.emit('identityrotated', {
+        peerId,
+        username: rotation.username,
+        fromGeneration: result.fromGeneration,
+        toGeneration: result.toGeneration,
+        rotationKind: result.rotationKind
+      });
+    }
+    return result;
+  }
+
+  async broadcastIdentityRotation(rotation, options = {}) {
+    return this.broadcastMessage('identity:rotate', rotation, options);
+  }
+
+  async broadcastColdRecoveryEnrollment(enrollment, options = {}) {
+    return this.broadcastMessage('identity:cold-enroll', enrollment, options);
+  }
+
+  applyPeerColdRecoveryEnrollment(peerId, enrollment) {
+    const result = this.securityService.applyColdRecoveryEnrollment(peerId, enrollment);
+    if (result.applied) {
+      this.emit('coldrecoveryenrolled', {
+        peerId,
+        username: enrollment.username,
+        recoveryPublicKey: enrollment.recoveryPublicKey
+      });
+    }
+    return result;
+  }
+
+  async enrollAndBroadcastColdRecovery({
+    username,
+    coldPassword,
+    pepper = '',
+    kdfIterations,
+    broadcastOptions = {}
+  } = {}) {
+    const result = await enrollColdRecoveryPassword({
+      username,
+      coldPassword,
+      pepper,
+      kdfIterations
+    });
+    await this.broadcastColdRecoveryEnrollment(result.enrollment, broadcastOptions);
+    return result;
+  }
+
+  async revokeAndRotateDerivedIdentity({
+    username,
+    password,
+    coldPassword,
+    currentGeneration = 1,
+    reason = 'compromise-recovery',
+    pepper = '',
+    kdfIterations,
+    broadcast = false,
+    broadcastOptions = {}
+  } = {}) {
+    const result = await revokeAndRotateIdentity({
+      username,
+      password,
+      coldPassword,
+      currentGeneration,
+      reason,
+      pepper,
+      kdfIterations
+    });
+
+    if (broadcast) {
+      await this.broadcastIdentityRotation(result.rotation, broadcastOptions);
+    }
+
+    return result;
+  }
+
+  async rotateDerivedIdentityPassword({
+    username,
+    currentPassword,
+    newPassword,
+    coldPassword,
+    currentGeneration = 1,
+    reason = 'password-change',
+    pepper = '',
+    kdfIterations,
+    broadcast = false,
+    broadcastOptions = {}
+  } = {}) {
+    const result = await rotateIdentityPassword({
+      username,
+      currentPassword,
+      newPassword,
+      coldPassword,
+      currentGeneration,
+      reason,
+      pepper,
+      kdfIterations
+    });
+
+    if (broadcast) {
+      await this.broadcastIdentityRotation(result.rotation, broadcastOptions);
+    }
+
+    return result;
+  }
+
+  async adoptDerivedIdentityKeyPair(keyPair, { generation = 1 } = {}) {
+    if (!keyPair || !keyPair.signing || !keyPair.encryption) {
+      throw new Error('adoptDerivedIdentityKeyPair requires a derived keyPair');
+    }
+
+    this.securityService.signingSecretKey = keyPair.signing.secretKey;
+    this.securityService.signingPublicKey = keyPair.signing.publicKey;
+    this.securityService.encryptionSecretKey = keyPair.encryption.secretKey;
+    this.securityService.encryptionPublicKey = keyPair.encryption.publicKey;
+    this.securityService.publicKeyBundle = {
+      signingPublicKey: naclUtil.encodeBase64(keyPair.signing.publicKey),
+      encryptionPublicKey: naclUtil.encodeBase64(keyPair.encryption.publicKey)
+    };
+    this.securityService.options.keyPair = keyPair;
+    this.securityService.options.identityGeneration = generation;
+  }
+
+  async deriveAndAdoptIdentity({ username, password, generation = 1, pepper = '', kdfIterations } = {}) {
+    const keyPair = await deriveKeyPairFromCredentials({
+      username,
+      password,
+      generation,
+      pepper,
+      kdfIterations
+    });
+    await this.adoptDerivedIdentityKeyPair(keyPair, { generation });
+    return keyPair;
   }
 
   trustPeerPublicKey(peerId, publicKey) {
@@ -624,6 +795,14 @@ class DignityP2P extends EventEmitter {
         this.seenGossipIds.delete(gossipId);
       }
     }
+
+    while (this.seenGossipIds.size > this.maxSeenGossipIds) {
+      const oldestGossipId = this.seenGossipIds.keys().next().value;
+      if (!oldestGossipId) {
+        break;
+      }
+      this.seenGossipIds.delete(oldestGossipId);
+    }
   }
 
   hasSeenGossip(gossipId) {
@@ -641,6 +820,7 @@ class DignityP2P extends EventEmitter {
     }
 
     this.seenGossipIds.set(gossipId, this.now() + this.gossipIdTtlMs);
+    this.pruneSeenGossip();
   }
 
   listConnectedPeerIds() {
@@ -734,6 +914,16 @@ class DignityP2P extends EventEmitter {
       throw new Error(`PeerGroup ${groupId} has not been joined`);
     }
 
+    if (this.gossipPublishMinIntervalMs > 0) {
+      const lastPublishAt = this.lastGossipPublishAt.get(groupId) || 0;
+      const elapsed = this.now() - lastPublishAt;
+      if (elapsed < this.gossipPublishMinIntervalMs) {
+        const error = new Error(`Gossip publish rate limit exceeded for group ${groupId}`);
+        error.code = 'GOSSIP_RATE_LIMIT';
+        throw error;
+      }
+    }
+
     const fanout = typeof options.fanout === 'number'
       ? options.fanout
       : (group ? group.fanout : this.defaultPeerGroupFanout);
@@ -750,6 +940,7 @@ class DignityP2P extends EventEmitter {
 
     const gossipId = options.gossipId || this.idGenerator();
     this.markSeenGossip(gossipId);
+    this.lastGossipPublishAt.set(groupId, this.now());
 
     await this.broadcastMessage('peer-group:gossip', {
       groupId,
@@ -1117,6 +1308,37 @@ class DignityP2P extends EventEmitter {
       return;
     }
 
+    if (decrypted.messageType === 'identity:rotate') {
+      const peerId = decrypted.senderId || decrypted.payload?.username;
+      if (peerId && decrypted.payload) {
+        const result = this.applyPeerIdentityRotation(peerId, decrypted.payload);
+        if (!result.applied) {
+          this.emit('warning', {
+            type: 'identity-rotation-ignored',
+            peerId,
+            reason: result.reason
+          });
+        }
+      }
+      return;
+    }
+
+    if (decrypted.messageType === 'identity:cold-enroll') {
+      const peerId = decrypted.senderId || decrypted.payload?.username;
+      if (peerId && decrypted.payload) {
+        try {
+          this.applyPeerColdRecoveryEnrollment(peerId, decrypted.payload);
+        } catch (error) {
+          this.emit('warning', {
+            type: 'cold-recovery-enrollment-rejected',
+            peerId,
+            error
+          });
+        }
+      }
+      return;
+    }
+
     if (message && message.senderId && message.senderPublicKey) {
       this.trustPeerPublicKey(message.senderId, message.senderPublicKey);
     }
@@ -1131,7 +1353,10 @@ class DignityP2P extends EventEmitter {
       const { collectionName, record } = payload;
 
       if (collectionName && record) {
-        const applied = this.restoreRecord(collectionName, record);
+        const applied = this.restoreRecord(collectionName, record, {
+          rejectOnHashMismatch: true,
+          via: 'direct-mesh'
+        });
         if (applied) {
           this.emit('change', {
             kind: 'snapshot',

package/src/index.js

@@ -28,8 +28,20 @@ const VDF = require('./security/vdf');
 const SlothPermutation = require('./security/sloth-vdf');
 const {
   MessageSecurityService,
-  DEFAULT_SECURITY_OPTIONS
+  DEFAULT_SECURITY_OPTIONS,
+  DEFAULT_APP_PASSWORD
 } = require('./security/message-security-service');
+const { deriveKeyPairFromCredentials, keyPairToPublicBundle, deriveColdRecoverySigningKey } = require('./security/derive-key-pair');
+const {
+  createIdentityRotation,
+  verifyIdentityRotation,
+  revokeAndRotateIdentity,
+  rotateIdentityPassword,
+  enrollColdRecoveryPassword,
+  verifyColdRecoveryEnrollment,
+  shouldApplyIdentityRotation
+} = require('./security/identity-rotation');
+const parsePeerJsServerUrl = require('./signaling/parse-peerjs-url');
 const {
   PEER_GROUP_SCOPE_PREFIX,
   DEFAULT_PEER_GROUP_OPTIONS,
@@ -55,6 +67,18 @@ module.exports = {
   SlothPermutation,
   MessageSecurityService,
   DEFAULT_SECURITY_OPTIONS,
+  DEFAULT_APP_PASSWORD,
+  deriveKeyPairFromCredentials,
+  deriveColdRecoverySigningKey,
+  keyPairToPublicBundle,
+  createIdentityRotation,
+  verifyIdentityRotation,
+  revokeAndRotateIdentity,
+  rotateIdentityPassword,
+  enrollColdRecoveryPassword,
+  verifyColdRecoveryEnrollment,
+  shouldApplyIdentityRotation,
+  parsePeerJsServerUrl,
   PEER_GROUP_SCOPE_PREFIX,
   DEFAULT_PEER_GROUP_OPTIONS,
   peerGroupScope,

package/src/security/derive-key-pair.js

@@ -0,0 +1,147 @@
+const nacl = require('tweetnacl');
+const naclUtil = require('tweetnacl-util');
+const { deriveBroadcastKey, DEFAULT_SECURITY_OPTIONS } = require('./message-security-service');
+
+const SIGNING_INFO = 'dignity-signing-v1';
+const ENCRYPTION_INFO = 'dignity-encryption-v1';
+const COLD_RECOVERY_INFO = 'dignity-cold-recovery-v1';
+
+function utf8ToBytes(value) {
+  return naclUtil.decodeUTF8(value);
+}
+
+function concatBytes(...parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+
+function buildColdRecoverySalt(username, pepper = '') {
+  if (!username || typeof username !== 'string') {
+    throw new Error('deriveColdRecoverySigningKey requires username');
+  }
+
+  const segments = ['dignity-cold-recovery-v1'];
+  if (pepper) {
+    segments.push(pepper);
+  }
+  segments.push(username, COLD_RECOVERY_INFO);
+  return utf8ToBytes(segments.join('\0'));
+}
+
+async function deriveColdRecoverySigningKey({
+  username,
+  coldPassword,
+  pepper = '',
+  kdfIterations
+} = {}) {
+  if (!coldPassword || typeof coldPassword !== 'string') {
+    throw new Error('deriveColdRecoverySigningKey requires coldPassword');
+  }
+
+  const salt = buildColdRecoverySalt(username, pepper);
+  const iterations = typeof kdfIterations === 'number'
+    ? kdfIterations
+    : DEFAULT_SECURITY_OPTIONS.kdfIterations;
+  const seed = await deriveBroadcastKey(coldPassword, salt, iterations);
+  const signing = nacl.sign.keyPair.fromSeed(seed);
+
+  return {
+    signing,
+    recoveryPublicKey: naclUtil.encodeBase64(signing.publicKey)
+  };
+}
+
+function buildIdentitySalt(username, info, pepper = '', generation = 1) {
+  if (!username || typeof username !== 'string') {
+    throw new Error('deriveKeyPairFromCredentials requires username');
+  }
+  if (!info || typeof info !== 'string') {
+    throw new Error('deriveKeyPairFromCredentials requires info label');
+  }
+  const normalizedGeneration = Number(generation);
+  if (!Number.isInteger(normalizedGeneration) || normalizedGeneration < 1) {
+    throw new Error('deriveKeyPairFromCredentials requires generation >= 1');
+  }
+
+  const segments = ['dignity-identity-v1'];
+  if (pepper) {
+    segments.push(pepper);
+  }
+  segments.push(username, `gen:${normalizedGeneration}`, info);
+  return utf8ToBytes(segments.join('\0'));
+}
+
+async function deriveIdentitySeed({ password, username, info, pepper, generation, kdfIterations }) {
+  if (!password || typeof password !== 'string') {
+    throw new Error('deriveKeyPairFromCredentials requires password');
+  }
+
+  const salt = buildIdentitySalt(username, info, pepper, generation);
+  const iterations = typeof kdfIterations === 'number'
+    ? kdfIterations
+    : DEFAULT_SECURITY_OPTIONS.kdfIterations;
+
+  return deriveBroadcastKey(password, salt, iterations);
+}
+
+/**
+ * Derive deterministic Ed25519 signing and Curve25519 box key pairs from
+ * public username + private password. Same inputs yield the same keys across
+ * runs and environments. Bump `generation` (2, 3, …) after compromise recovery;
+ * see `identity-rotation.js` for signed revocation / password-change flows.
+ */
+async function deriveKeyPairFromCredentials({
+  username,
+  password,
+  pepper = '',
+  generation = 1,
+  kdfIterations
+} = {}) {
+  const signingSeed = await deriveIdentitySeed({
+    password,
+    username,
+    info: SIGNING_INFO,
+    pepper,
+    generation,
+    kdfIterations
+  });
+  const encryptionSecret = await deriveIdentitySeed({
+    password,
+    username,
+    info: ENCRYPTION_INFO,
+    pepper,
+    generation,
+    kdfIterations
+  });
+
+  return {
+    signing: nacl.sign.keyPair.fromSeed(signingSeed),
+    encryption: nacl.box.keyPair.fromSecretKey(encryptionSecret),
+    generation
+  };
+}
+
+function keyPairToPublicBundle(keyPair) {
+  return {
+    signingPublicKey: naclUtil.encodeBase64(keyPair.signing.publicKey),
+    encryptionPublicKey: naclUtil.encodeBase64(keyPair.encryption.publicKey)
+  };
+}
+
+module.exports = {
+  deriveKeyPairFromCredentials,
+  deriveColdRecoverySigningKey,
+  keyPairToPublicBundle,
+  buildIdentitySalt,
+  buildColdRecoverySalt,
+  SIGNING_INFO,
+  ENCRYPTION_INFO,
+  COLD_RECOVERY_INFO,
+  concatBytes
+};