@nexustechpro/baileys 1.0.6 → 1.0.7

package/README.md

@@ -1684,8 +1684,8 @@ Special thanks to:
 
 ## 📞 Support
 
-- **Issues**: [GitHub Issues](https://github.com/nexustechpro/baileys/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/nexustechpro/baileys/discussions)
+- **Issues**: [Whatsapp Channel](https://whatsapp.com/channel/0029VbBK53XBvvslYeZlBe0V)
+- **Discussions**: [Whatsapp Channel](https://whatsapp.com/channel/0029VbBK53XBvvslYeZlBe0V)
 - **NPM**: [@nexustechpro/baileys](https://www.npmjs.com/package/@nexustechpro/baileys)
 
 ---

package/lib/Signal/Group/group_cipher.js

@@ -1,82 +1,100 @@
-import { decrypt, encrypt } from 'libsignal/src/crypto.js';
-import { SenderKeyMessage } from './sender-key-message.js';
-import { SenderKeyName } from './sender-key-name.js';
-import { SenderKeyRecord } from './sender-key-record.js';
-import { SenderKeyState } from './sender-key-state.js';
+import { decrypt, encrypt } from 'libsignal/src/crypto.js'
+import { SenderKeyMessage } from './sender-key-message.js'
+import { SenderKeyName } from './sender-key-name.js'
+import { SenderKeyRecord } from './sender-key-record.js'
+import { SenderKeyState } from './sender-key-state.js'
+
 export class GroupCipher {
-    constructor(senderKeyStore, senderKeyName) {
-        this.senderKeyStore = senderKeyStore;
-        this.senderKeyName = senderKeyName;
+  constructor(senderKeyStore, senderKeyName) {
+    this.senderKeyStore = senderKeyStore
+    this.senderKeyName = senderKeyName
+  }
+
+  async encrypt(paddedPlaintext) {
+    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName)
+    if (!record) throw new Error('No SenderKeyRecord found')
+    const state = record.getSenderKeyState()
+    if (!state) throw new Error('No session to encrypt')
+    const iteration = state.getSenderChainKey().getIteration()
+    const senderKey = this.getSenderKey(state, iteration === 0 ? 0 : iteration + 1)
+    const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext)
+    const msg = new SenderKeyMessage(state.getKeyId(), senderKey.getIteration(), ciphertext, state.getSigningKeyPrivate())
+    await this.senderKeyStore.storeSenderKey(this.senderKeyName, record)
+    return msg.serialize()
+  }
+
+  async decrypt(senderKeyMessageBytes) {
+    let record = await this.senderKeyStore.loadSenderKey(this.senderKeyName)
+    if (!record) throw new Error('No SenderKeyRecord - requesting new session')
+    
+    const msg = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes)
+    let state = record.getSenderKeyState(msg.getKeyId())
+
+    if (!state) {
+      const allStates = record.getSenderKeyStates?.() || []
+      if (allStates.length > 0) {
+        state = allStates[allStates.length - 1]
+      } else {
+        throw new Error(`No session found - keyId: ${msg.getKeyId()}`)
+      }
     }
-    async encrypt(paddedPlaintext) {
-        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();
+
+    try {
+      msg.verifySignature(state.getSigningKeyPublic())
+    } catch (e) {
+      throw new Error('Signature verification failed')
     }
-    async decrypt(senderKeyMessageBytes) {
-        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());
-        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
-        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
-        return plaintext;
+
+    const senderKey = this.getSenderKey(state, msg.getIteration())
+    const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), msg.getCipherText())
+    
+    try {
+      await this.senderKeyStore.storeSenderKey(this.senderKeyName, record)
+    } catch (e) {
+      // Non-critical: decryption succeeded
     }
-    getSenderKey(senderKeyState, iteration) {
-        let senderChainKey = senderKeyState.getSenderChainKey();
-        if (senderChainKey.getIteration() > iteration) {
-            if (senderKeyState.hasSenderMessageKey(iteration)) {
-                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
-                if (!messageKey) {
-                    throw new Error('No sender message key found for iteration');
-                }
-                return messageKey;
-            }
-            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();
+
+    return plaintext
+  }
+
+  getSenderKey(state, iteration) {
+    let chainKey = state.getSenderChainKey()
+    
+    if (chainKey.getIteration() > iteration) {
+      if (state.hasSenderMessageKey(iteration)) {
+        const key = state.removeSenderMessageKey(iteration)
+        if (!key) throw new Error('No sender message key')
+        return key
+      }
+      throw new Error(`Old counter: ${chainKey.getIteration()} vs ${iteration}`)
     }
-    async getPlainText(iv, key, ciphertext) {
-        try {
-            return decrypt(key, ciphertext, iv);
-        }
-        catch (e) {
-            throw new Error('InvalidMessageException');
-        }
+
+    if (iteration - chainKey.getIteration() > 2000) throw new Error('Over 2000 messages ahead')
+
+    while (chainKey.getIteration() < iteration) {
+      state.addSenderMessageKey(chainKey.getSenderMessageKey())
+      chainKey = chainKey.getNext()
     }
-    async getCipherText(iv, key, plaintext) {
-        try {
-            return encrypt(key, plaintext, iv);
-        }
-        catch (e) {
-            throw new Error('InvalidMessageException');
-        }
+
+    state.setSenderChainKey(chainKey.getNext())
+    return chainKey.getSenderMessageKey()
+  }
+
+  async getPlainText(iv, key, ciphertext) {
+    try {
+      return decrypt(key, ciphertext, iv)
+    } catch (e) {
+      throw new Error('InvalidMessageException')
     }
+  }
+
+  async getCipherText(iv, key, plaintext) {
+    try {
+      return encrypt(key, plaintext, iv)
+    } catch (e) {
+      throw new Error('InvalidMessageException')
+    }
+  }
 }
-//# sourceMappingURL=group_cipher.js.map
+
+export default GroupCipher