@periskope/baileys 6.7.18-alpha.2 → 6.7.18-alpha.21

package/WASignalGroup/ciphertext_message.js

@@ -1,16 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,46 +0,0 @@
-//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

@@ -1,5 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

package/WASignalGroup/queue_job.js

@@ -1,69 +0,0 @@
-// 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

@@ -1,50 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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;