lordceaser-baileys 2.0.38 → 2.0.39

package/WASignalGroup/ciphertext_message.js

@@ -0,0 +1,16 @@
+class CiphertextMessage {
+    UNSUPPORTED_VERSION = 1;
+
+    CURRENT_VERSION = 3;
+
+    WHISPER_TYPE = 2;
+
+    PREKEY_TYPE = 3;
+
+    SENDERKEY_TYPE = 4;
+
+    SENDERKEY_DISTRIBUTION_TYPE = 5;
+
+    ENCRYPTED_MESSAGE_OVERHEAD = 53;
+}
+module.exports = CiphertextMessage;

package/WASignalGroup/group_cipher.js

@@ -0,0 +1,120 @@
+const queue_job = require('./queue_job');
+const SenderKeyMessage = require('./sender_key_message');
+const crypto = require('libsignal/src/crypto');
+
+class GroupCipher {
+  constructor(senderKeyStore, senderKeyName) {
+    this.senderKeyStore = senderKeyStore;
+    this.senderKeyName = senderKeyName;
+  }
+
+  queueJob(awaitable) {
+    return queue_job(this.senderKeyName.toString(), awaitable)
+  }
+
+  async encrypt(paddedPlaintext) {
+    return await this.queueJob(async () => {
+      const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+      if (!record) {
+        throw new Error("No SenderKeyRecord found for encryption")
+      }
+      const senderKeyState = record.getSenderKeyState();
+      if (!senderKeyState) {
+        throw new Error("No session to encrypt message");
+      }
+      const iteration = senderKeyState.getSenderChainKey().getIteration()
+      const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1)
+
+      const ciphertext = await this.getCipherText(
+        senderKey.getIv(),
+        senderKey.getCipherKey(),
+        paddedPlaintext
+      );
+
+      const senderKeyMessage = new SenderKeyMessage(
+        senderKeyState.getKeyId(),
+        senderKey.getIteration(),
+        ciphertext,
+        senderKeyState.getSigningKeyPrivate()
+      );
+      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+      return senderKeyMessage.serialize()
+    })
+  }
+
+  async decrypt(senderKeyMessageBytes) {
+    return await this.queueJob(async () => {
+      const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+      if (!record) {
+        throw new Error("No SenderKeyRecord found for decryption")
+      }
+      const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+      const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+      if (!senderKeyState) {
+        throw new Error("No session found to decrypt message")
+      }
+
+      senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+      const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+      // senderKeyState.senderKeyStateStructure.senderSigningKey.private =
+
+      const plaintext = await this.getPlainText(
+        senderKey.getIv(),
+        senderKey.getCipherKey(),
+        senderKeyMessage.getCipherText()
+      );
+
+      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+
+      return plaintext;
+    })
+  }
+
+  getSenderKey(senderKeyState, iteration) {
+    let senderChainKey = senderKeyState.getSenderChainKey();
+    if (senderChainKey.getIteration() > iteration) {
+      if (senderKeyState.hasSenderMessageKey(iteration)) {
+        return senderKeyState.removeSenderMessageKey(iteration);
+      }
+      throw new Error(
+        `Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`
+      );
+    }
+
+    if (iteration - senderChainKey.getIteration() > 2000) {
+      throw new Error('Over 2000 messages into the future!');
+    }
+
+    while (senderChainKey.getIteration() < iteration) {
+      senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+      senderChainKey = senderChainKey.getNext();
+    }
+
+    senderKeyState.setSenderChainKey(senderChainKey.getNext());
+    return senderChainKey.getSenderMessageKey();
+  }
+
+  getPlainText(iv, key, ciphertext) {
+    try {
+      const plaintext = crypto.decrypt(key, ciphertext, iv);
+      return plaintext;
+    } catch (e) {
+      //console.log(e.stack);
+      throw new Error('InvalidMessageException');
+    }
+  }
+
+  getCipherText(iv, key, plaintext) {
+    try {
+      iv = typeof iv === 'string' ? Buffer.from(iv, 'base64') : iv;
+      key = typeof key === 'string' ? Buffer.from(key, 'base64') : key;
+      const crypted = crypto.encrypt(key, Buffer.from(plaintext), iv);
+      return crypted;
+    } catch (e) {
+      //console.log(e.stack);
+      throw new Error('InvalidMessageException');
+    }
+  }
+}
+
+module.exports = GroupCipher;

package/WASignalGroup/group_session_builder.js

@@ -0,0 +1,46 @@
+//const utils = require('../../common/utils');
+const SenderKeyDistributionMessage = require('./sender_key_distribution_message');
+
+const keyhelper = require("./keyhelper");
+class GroupSessionBuilder {
+  constructor(senderKeyStore) {
+    this.senderKeyStore = senderKeyStore;
+  }
+
+  async process(senderKeyName, senderKeyDistributionMessage) {
+    //console.log('GroupSessionBuilder process', senderKeyName, senderKeyDistributionMessage);
+    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+    senderKeyRecord.addSenderKeyState(
+      senderKeyDistributionMessage.getId(),
+      senderKeyDistributionMessage.getIteration(),
+      senderKeyDistributionMessage.getChainKey(),
+      senderKeyDistributionMessage.getSignatureKey()
+    );
+    await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+  }
+
+  // [{"senderKeyId":1742199468,"senderChainKey":{"iteration":0,"seed":"yxMY9VFQcXEP34olRAcGCtsgx1XoKsHfDIh+1ea4HAQ="},"senderSigningKey":{"public":""}}]
+  async create(senderKeyName) {
+    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+    //console.log('GroupSessionBuilder create session', senderKeyName, senderKeyRecord);
+
+    if (senderKeyRecord.isEmpty()) {
+      const keyId = keyhelper.generateSenderKeyId();
+      const senderKey = keyhelper.generateSenderKey();
+      const signingKey = keyhelper.generateSenderSigningKey();
+
+      senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+      await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+
+    const state = senderKeyRecord.getSenderKeyState();
+
+    return new SenderKeyDistributionMessage(
+      state.getKeyId(),
+      state.getSenderChainKey().getIteration(),
+      state.getSenderChainKey().getSeed(),
+      state.getSigningKeyPublic()
+    );
+  }
+}
+module.exports = GroupSessionBuilder;

package/WASignalGroup/index.js

@@ -0,0 +1,5 @@
+module.exports.GroupSessionBuilder = require('./group_session_builder')
+module.exports.SenderKeyDistributionMessage = require('./sender_key_distribution_message')
+module.exports.SenderKeyRecord = require('./sender_key_record')
+module.exports.SenderKeyName = require('./sender_key_name')
+module.exports.GroupCipher = require('./group_cipher')

package/WASignalGroup/keyhelper.js

@@ -0,0 +1,21 @@
+const curve = require('libsignal/src/curve');
+const nodeCrypto = require('crypto');
+
+exports.generateSenderKey = function() {
+    return nodeCrypto.randomBytes(32);
+}
+
+exports.generateSenderKeyId = function() {
+    return nodeCrypto.randomInt(2147483647);
+}
+
+exports.generateSenderSigningKey = function(key) {
+    if (!key) {
+        key = curve.generateKeyPair();
+    }
+
+    return {
+        public: key.pubKey,
+        private: key.privKey,
+    };
+} 

package/WASignalGroup/protobufs.js

@@ -0,0 +1,3 @@
+const { groupproto } = require('./GroupProtocol')
+
+module.exports = groupproto

package/WASignalGroup/queue_job.js

@@ -0,0 +1,69 @@
+// vim: ts=4:sw=4:expandtab
+
+/*
+ * jobQueue manages multiple queues indexed by device to serialize
+ * session io ops on the database.
+ */
+'use strict';
+
+
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    while (true) {
+        let limit = Math.min(queue.length, _gcLimit); // Break up thundering hurds for GC duty.
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            } catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            /* Perform lazy GC of queue for faster iteration. */
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            } else {
+                offt = limit;
+            }
+        } else {
+            break;
+        }
+    }
+    cleanup();
+}
+
+module.exports = function (bucket, awaitable) {
+    /* Run the async awaitable only when all other async calls registered
+     * here have completed (or thrown).  The bucket argument is a hashable
+     * key representing the task queue to use. */
+    if (!awaitable.name) {
+        // Make debuging easier by adding a name to this function.
+        Object.defineProperty(awaitable, 'name', { writable: true });
+        if (typeof bucket === 'string') {
+            awaitable.name = bucket;
+        } else {
+            console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
+        }
+    }
+    let inactive;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => queue.push({
+        awaitable,
+        resolve,
+        reject
+    }));
+    if (inactive) {
+        /* An executor is not currently active; Start one now. */
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+};

package/WASignalGroup/sender_chain_key.js

@@ -0,0 +1,50 @@
+const SenderMessageKey = require('./sender_message_key');
+//const HKDF = require('./hkdf');
+const crypto = require('libsignal/src/crypto');
+
+class SenderChainKey {
+  MESSAGE_KEY_SEED = Buffer.from([0x01]);
+
+  CHAIN_KEY_SEED = Buffer.from([0x02]);
+
+  iteration = 0;
+
+  chainKey = Buffer.alloc(0);
+
+  constructor(iteration, chainKey) {
+    this.iteration = iteration;
+    this.chainKey = chainKey;
+  }
+
+  getIteration() {
+    return this.iteration;
+  }
+
+  getSenderMessageKey() {
+    return new SenderMessageKey(
+      this.iteration,
+      this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey)
+    );
+  }
+
+  getNext() {
+    return new SenderChainKey(
+      this.iteration + 1,
+      this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey)
+    );
+  }
+
+  getSeed() {
+    return typeof this.chainKey === 'string' ? Buffer.from(this.chainKey, 'base64') : this.chainKey;
+  }
+
+  getDerivative(seed, key) {
+    key = typeof key === 'string' ? Buffer.from(key, 'base64') : key;
+    const hash = crypto.calculateMAC(key, seed);
+    //const hash = new Hash().hmac_hash(key, seed, 'sha256', '');
+    
+    return hash;
+  }
+}
+
+module.exports = SenderChainKey;

package/WASignalGroup/sender_key_distribution_message.js

@@ -0,0 +1,78 @@
+const CiphertextMessage = require('./ciphertext_message');
+const protobufs = require('./protobufs');
+
+class SenderKeyDistributionMessage extends CiphertextMessage {
+  constructor(
+    id = null,
+    iteration = null,
+    chainKey = null,
+    signatureKey = null,
+    serialized = null
+  ) {
+    super();
+    if (serialized) {
+      try {
+        const version = serialized[0];
+        const message = serialized.slice(1);
+
+        const distributionMessage = protobufs.SenderKeyDistributionMessage.decode(
+          message
+        ).toJSON();
+        this.serialized = serialized;
+        this.id = distributionMessage.id;
+        this.iteration = distributionMessage.iteration;
+        this.chainKey = distributionMessage.chainKey;
+        this.signatureKey = distributionMessage.signingKey;
+      } catch (e) {
+        throw new Error(e);
+      }
+    } else {
+      const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION);
+      this.id = id;
+      this.iteration = iteration;
+      this.chainKey = chainKey;
+      this.signatureKey = signatureKey;
+      const message = protobufs.SenderKeyDistributionMessage.encode(
+        protobufs.SenderKeyDistributionMessage.create({
+          id,
+          iteration,
+          chainKey,
+          signingKey: this.signatureKey,
+        })
+      ).finish();
+      this.serialized = Buffer.concat([Buffer.from([version]), message]);
+    }
+  }
+
+  intsToByteHighAndLow(highValue, lowValue) {
+    return (((highValue << 4) | lowValue) & 0xff) % 256;
+  }
+
+  serialize() {
+    return this.serialized;
+  }
+
+  getType() {
+    return this.SENDERKEY_DISTRIBUTION_TYPE;
+  }
+
+  getIteration() {
+    return this.iteration;
+  }
+
+  getChainKey() {
+    return typeof this.chainKey === 'string' ? Buffer.from(this.chainKey, 'base64') : this.chainKey;
+  }
+
+  getSignatureKey() {
+    return typeof this.signatureKey === 'string'
+      ? Buffer.from(this.signatureKey, 'base64')
+      : this.signatureKey;
+  }
+
+  getId() {
+    return this.id;
+  }
+}
+
+module.exports = SenderKeyDistributionMessage;

package/WASignalGroup/sender_key_message.js

@@ -0,0 +1,92 @@
+const CiphertextMessage = require('./ciphertext_message');
+const curve = require('libsignal/src/curve');
+const protobufs = require('./protobufs');
+
+class SenderKeyMessage extends CiphertextMessage {
+  SIGNATURE_LENGTH = 64;
+
+  constructor(
+    keyId = null,
+    iteration = null,
+    ciphertext = null,
+    signatureKey = null,
+    serialized = null
+  ) {
+    super();
+    if (serialized) {
+      const version = serialized[0];
+      const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
+      const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
+      const senderKeyMessage = protobufs.SenderKeyMessage.decode(message).toJSON();
+      senderKeyMessage.ciphertext = Buffer.from(senderKeyMessage.ciphertext, 'base64');
+
+      this.serialized = serialized;
+      this.messageVersion = (version & 0xff) >> 4;
+
+      this.keyId = senderKeyMessage.id;
+      this.iteration = senderKeyMessage.iteration;
+      this.ciphertext = senderKeyMessage.ciphertext;
+      this.signature = signature;
+    } else {
+      const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+      ciphertext = Buffer.from(ciphertext); // .toString('base64');
+      const message = protobufs.SenderKeyMessage.encode(
+        protobufs.SenderKeyMessage.create({
+          id: keyId,
+          iteration,
+          ciphertext,
+        })
+      ).finish();
+
+      const signature = this.getSignature(
+        signatureKey,
+        Buffer.concat([Buffer.from([version]), message])
+      );
+      this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
+      this.messageVersion = this.CURRENT_VERSION;
+      this.keyId = keyId;
+      this.iteration = iteration;
+      this.ciphertext = ciphertext;
+      this.signature = signature;
+    }
+  }
+
+  getKeyId() {
+    return this.keyId;
+  }
+
+  getIteration() {
+    return this.iteration;
+  }
+
+  getCipherText() {
+    return this.ciphertext;
+  }
+
+  verifySignature(signatureKey) {
+    const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
+    const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
+    const res = curve.verifySignature(signatureKey, part1, part2);
+    if (!res) throw new Error('Invalid signature!');
+  }
+
+  getSignature(signatureKey, serialized) {
+    const signature = Buffer.from(
+      curve.calculateSignature(
+        signatureKey,
+        serialized
+      )
+    );
+    return signature;
+  }
+
+  serialize() {
+    return this.serialized;
+  }
+
+  getType() {
+    return 4;
+  }
+}
+
+module.exports = SenderKeyMessage;

package/WASignalGroup/sender_key_name.js

@@ -0,0 +1,70 @@
+function isNull(str) {
+  return str === null || str.value === '';
+}
+
+/**
+ * java String hashCode 的实现
+ * @param strKey
+ * @return intValue
+ */
+function intValue(num) {
+  const MAX_VALUE = 0x7fffffff;
+  const MIN_VALUE = -0x80000000;
+  if (num > MAX_VALUE || num < MIN_VALUE) {
+    // eslint-disable-next-line
+    return (num &= 0xffffffff);
+  }
+  return num;
+}
+
+function hashCode(strKey) {
+  let hash = 0;
+  if (!isNull(strKey)) {
+    for (let i = 0; i < strKey.length; i++) {
+      hash = hash * 31 + strKey.charCodeAt(i);
+      hash = intValue(hash);
+    }
+  }
+  return hash;
+}
+
+/**
+ * 将js页面的number类型转换为java的int类型
+ * @param num
+ * @return intValue
+ */
+
+class SenderKeyName {
+  constructor(groupId, sender) {
+    this.groupId = groupId;
+    this.sender = sender;
+  }
+
+  getGroupId() {
+    return this.groupId;
+  }
+
+  getSender() {
+    return this.sender;
+  }
+
+  serialize() {
+    return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
+  }
+
+  toString() {
+    return this.serialize();
+  }
+
+  equals(other) {
+    if (other === null) return false;
+    if (!(other instanceof SenderKeyName)) return false;
+    return this.groupId === other.groupId && this.sender.toString() === other.sender.toString();
+  }
+
+  hashCode() {
+    return hashCode(this.groupId) ^ hashCode(this.sender.toString());
+  }
+}
+
+module.exports = SenderKeyName;

package/WASignalGroup/sender_key_record.js

@@ -0,0 +1,56 @@
+const SenderKeyState = require('./sender_key_state');
+
+class SenderKeyRecord {
+    MAX_STATES = 5;
+  
+    constructor(serialized) {
+      this.senderKeyStates = [];
+  
+      if (serialized) {
+        const list = serialized;
+        for (let i = 0; i < list.length; i++) {
+          const structure = list[i];
+          this.senderKeyStates.push(
+            new SenderKeyState(null, null, null, null, null, null, structure)
+          );
+        }
+      }
+    }
+  
+    isEmpty() {
+      return this.senderKeyStates.length === 0;
+    }
+  
+    getSenderKeyState(keyId) {
+      if (!keyId && this.senderKeyStates.length) return this.senderKeyStates[this.senderKeyStates.length - 1];
+      for (let i = 0; i < this.senderKeyStates.length; i++) {
+        const state = this.senderKeyStates[i];
+        if (state.getKeyId() === keyId) {
+          return state;
+        }
+      }
+    }
+  
+    addSenderKeyState(id, iteration, chainKey, signatureKey) {
+      this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey));
+      if (this.senderKeyStates.length > 5) {
+        this.senderKeyStates.shift()
+      }
+    }
+  
+    setSenderKeyState(id, iteration, chainKey, keyPair) {
+      this.senderKeyStates.length = 0;
+      this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, keyPair));
+    }
+  
+    serialize() {
+      const recordStructure = [];
+      for (let i = 0; i < this.senderKeyStates.length; i++) {
+        const senderKeyState = this.senderKeyStates[i];
+        recordStructure.push(senderKeyState.getStructure());
+      }
+      return recordStructure;
+    }
+  }
+  
+  module.exports = SenderKeyRecord;