finalize multi-device

WASignalGroup/group_cipher.js

@@ -0,0 +1,106 @@
+const SenderKeyMessage = require('./sender_key_message');
+const crypto = require('libsignal/src/crypto');
+
+class GroupCipher {
+  constructor(senderKeyStore, senderKeyName) {
+    this.senderKeyStore = senderKeyStore;
+    this.senderKeyName = senderKeyName;
+  }
+
+  async encrypt(paddedPlaintext) {
+    try {
+      const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+      const senderKeyState = record.getSenderKeyState();
+      const senderKey = senderKeyState.getSenderChainKey().getSenderMessageKey();
+
+      const ciphertext = await this.getCipherText(
+        senderKey.getIv(),
+        senderKey.getCipherKey(),
+        paddedPlaintext
+      );
+
+      const senderKeyMessage = new SenderKeyMessage(
+        senderKeyState.getKeyId(),
+        senderKey.getIteration(),
+        ciphertext,
+        senderKeyState.getSigningKeyPrivate()
+      );
+      senderKeyState.setSenderChainKey(senderKeyState.getSenderChainKey().getNext());
+      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+      return senderKeyMessage.serialize();
+    } catch (e) {
+      //console.log(e.stack);
+      throw new Error('NoSessionException');
+    }
+  }
+
+  async decrypt(senderKeyMessageBytes) {
+    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+    if (!record) throw new Error(`No sender key for: ${this.senderKeyName}`);
+
+    const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+
+    const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+    //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 (senderChainKey.getIteration() - iteration > 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;