@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Utils/noise-handler.js

@@ -2,11 +2,20 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const boom_1 = require("@hapi/boom")
-const WAProto_1 = require("../../WAProto")
-const Defaults_1 = require("../Defaults")
-const WABinary_1 = require("../WABinary")
-const crypto_1 = require("./crypto")
+const { Boom } = require("@hapi/boom")
+const { proto } = require("../../WAProto")
+const {
+  NOISE_MODE, 
+  WA_CERT_DETAILS
+} = require("../Defaults/constants")
+const { decodeBinaryNode } = require("../WABinary")
+const { 
+  aesDecryptGCM, 
+  aesEncryptGCM,
+  Curve, 
+  hkdf, 
+  sha256 
+} = require("./crypto")
 
 const generateIV = (counter) => {
     const iv = new ArrayBuffer(12)
@@ -16,35 +25,44 @@ const generateIV = (counter) => {
 
 const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }) => {
     logger = logger.child({ class: 'ns' })
+    
     const authenticate = (data) => {
         if (!isFinished) {
-            hash = crypto_1.sha256(Buffer.concat([hash, data]))
+            hash = sha256(Buffer.concat([hash, data]))
         }
     }
+    
     const encrypt = (plaintext) => {
-        const result = crypto_1.aesEncryptGCM(plaintext, encKey, generateIV(writeCounter), hash)
+        const result = aesEncryptGCM(plaintext, encKey, generateIV(writeCounter), hash)
         writeCounter += 1
         authenticate(result)
         return result
     }
+    
     const decrypt = (ciphertext) => {
         // before the handshake is finished, we use the same counter
         // after handshake, the counters are different
         const iv = generateIV(isFinished ? readCounter : writeCounter)
-        const result = crypto_1.aesDecryptGCM(ciphertext, decKey, iv, hash)
+        const result = aesDecryptGCM(ciphertext, decKey, iv, hash)
+        
         if (isFinished) {
             readCounter += 1
         }
+        
         else {
             writeCounter += 1
         }
+        
         authenticate(ciphertext)
+        
         return result
     }
+    
     const localHKDF = async (data) => {
-        const key = await crypto_1.hkdf(Buffer.from(data), 64, { salt, info: '' })
+        const key = await hkdf(Buffer.from(data), 64, { salt, info: '' })
         return [key.slice(0, 32), key.slice(32)]
     }
+    
     const mixIntoKey = async (data) => {
         const [write, read] = await localHKDF(data)
         salt = write
@@ -53,6 +71,7 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         readCounter = 0
         writeCounter = 0
     }
+    
     const finishInit = async () => {
         const [write, read] = await localHKDF(new Uint8Array(0))
         encKey = write
@@ -62,8 +81,10 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         writeCounter = 0
         isFinished = true
     }
-    const data = Buffer.from(Defaults_1.NOISE_MODE)
-    let hash = data.byteLength === 32 ? data : crypto_1.sha256(data)
+    
+    const data = Buffer.from(NOISE_MODE)
+    
+    let hash = data.byteLength === 32 ? data : sha256(data)
     let salt = hash
     let encKey = hash
     let decKey = hash
@@ -72,8 +93,10 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
     let isFinished = false
     let sentIntro = false
     let inBytes = Buffer.alloc(0)
+    
     authenticate(NOISE_HEADER)
     authenticate(publicKey)
+    
     return {
         encrypt,
         decrypt,
@@ -82,24 +105,31 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         finishInit,
         processHandshake: async ({ serverHello }, noiseKey) => {
             authenticate(serverHello.ephemeral)
-            await mixIntoKey(crypto_1.Curve.sharedKey(privateKey, serverHello.ephemeral))
+            await mixIntoKey(Curve.sharedKey(privateKey, serverHello.ephemeral))
             const decStaticContent = decrypt(serverHello.static)
-            await mixIntoKey(crypto_1.Curve.sharedKey(privateKey, decStaticContent))
+            await mixIntoKey(Curve.sharedKey(privateKey, decStaticContent))
             const certDecoded = decrypt(serverHello.payload)
-            const { intermediate: certIntermediate } = WAProto_1.proto.CertChain.decode(certDecoded)
-            const { issuerSerial } = WAProto_1.proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details)
-            if (issuerSerial !== Defaults_1.WA_CERT_DETAILS.SERIAL) {
-                throw new boom_1.Boom('certification match failed', { statusCode: 400 })
+            const { intermediate: certIntermediate /*leaf*/ } = proto.CertChain.decode(certDecoded)
+            // TODO: handle this leaf stuff
+            const { issuerSerial } = proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details)
+            
+            if (issuerSerial !== WA_CERT_DETAILS.SERIAL) {
+                throw new Boom('certification match failed', { statusCode: 400 })
             }
+            
             const keyEnc = encrypt(noiseKey.public)
-            await mixIntoKey(crypto_1.Curve.sharedKey(noiseKey.private, serverHello.ephemeral))
+            
+            await mixIntoKey(Curve.sharedKey(noiseKey.private, serverHello.ephemeral))
+            
             return keyEnc
         },
         encodeFrame: (data) => {
             if (isFinished) {
                 data = encrypt(data)
             }
+            
             let header
+            
             if (routingInfo) {
                 header = Buffer.alloc(7)
                 header.write('ED', 0, 'utf8')
@@ -112,12 +142,15 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
             else {
                 header = Buffer.from(NOISE_HEADER)
             }
+            
             const introSize = sentIntro ? 0 : header.length
             const frame = Buffer.alloc(introSize + 3 + data.byteLength)
+            
             if (!sentIntro) {
                 frame.set(header)
                 sentIntro = true
             }
+            
             frame.writeUInt8(data.byteLength >> 16, introSize)
             frame.writeUInt16BE(65535 & data.byteLength, introSize + 1)
             frame.set(data, introSize + 3)
@@ -132,18 +165,25 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
                     return (inBytes.readUInt8() << 16) | inBytes.readUInt16BE(1)
                 }
             }
+            
             inBytes = Buffer.concat([inBytes, newData])
             logger.trace(`recv ${newData.length} bytes, total recv ${inBytes.length} bytes`)
+            
             let size = getBytesSize()
             while (size && inBytes.length >= size + 3) {
                 let frame = inBytes.slice(3, size + 3)
-                inBytes = inBytes.slice(size + 3)
+                
+                inBytes = inBytes.slice(size + 3) 
+                
                 if (isFinished) {
                     const result = decrypt(frame)
-                    frame = await WABinary_1.decodeBinaryNode(result)
+                    frame = await decodeBinaryNode(result)
                 }
+                
                 logger.trace({ msg: frame?.attrs?.id }, 'recv frame')
+                
                 onFrame(frame)
+                
                 size = getBytesSize()
             }
         }

package/lib/Utils/pre-key-manager.js

@@ -0,0 +1,126 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { default: PQueue } = require("p-queue") 
+
+/**
+ * Manages pre-key operations with proper concurrency control
+ */
+class PreKeyManager {
+    constructor(store, logger) {
+        this.store = store
+        this.logger = logger
+        this.queues = new Map()
+    }
+    
+    /**
+     * Get or create a queue for a specific key type
+     */
+    getQueue(keyType) {
+        if (!this.queues.has(keyType)) {
+            this.queues.set(keyType, new PQueue({ concurrency: 1 }))
+        }
+        return this.queues.get(keyType)
+    }
+    
+    /**
+     * Process pre-key operations (updates and deletions)
+     */
+    async processOperations(data, keyType, transactionCache, mutations, isInTransaction) {
+        const keyData = data[keyType]
+        
+        if (!keyData) return
+        
+        return this.getQueue(keyType).add(async () => {
+            // Ensure structures exist
+            transactionCache[keyType] = transactionCache[keyType] || {}
+            mutations[keyType] = mutations[keyType] || {}
+            
+            // Separate deletions from updates
+            const deletions = []
+            const updates = {}
+            
+            for (const keyId in keyData) {
+                if (keyData[keyId] === null) {
+                    deletions.push(keyId)
+                }
+                else {
+                    updates[keyId] = keyData[keyId]
+                }
+            }
+            
+            // Process updates (no validation needed)
+            if (Object.keys(updates).length > 0) {
+                Object.assign(transactionCache[keyType], updates)
+                Object.assign(mutations[keyType], updates)
+            }
+            
+            // Process deletions with validation
+            if (deletions.length > 0) {
+                await this.processDeletions(keyType, deletions, transactionCache, mutations, isInTransaction)
+            }
+        })
+    }
+    
+    /**
+     * Process deletions with validation
+     */
+    async processDeletions(keyType, ids, transactionCache, mutations, isInTransaction) {
+        if (isInTransaction) {
+            // In transaction, only allow deletion if key exists in cache
+            for (const keyId of ids) {
+                if (transactionCache[keyType]?.[keyId]) {
+                    transactionCache[keyType][keyId] = null
+                    mutations[keyType][keyId] = null
+                }
+                else {
+                    this.logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`)
+                }
+            }
+        }
+        else {
+            // Outside transaction, validate against store
+            const existingKeys = await this.store.get(keyType, ids)
+            for (const keyId of ids) {
+                if (existingKeys[keyId]) {
+                    transactionCache[keyType][keyId] = null
+                    mutations[keyType][keyId] = null
+                }
+                else {
+                    this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+                }
+            }
+        }
+    }
+    
+    /**
+     * Validate and process pre-key deletions outside transactions
+     */
+    async validateDeletions(data, keyType) {
+        const keyData = data[keyType]
+        
+        if (!keyData) return
+        
+        return this.getQueue(keyType).add(async () => {
+            // Find all deletion requests
+            const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null)
+            
+            if (deletionIds.length === 0) return
+            
+            // Validate deletions
+            const existingKeys = await this.store.get(keyType, deletionIds)
+            
+            for (const keyId of deletionIds) {
+                if (!existingKeys[keyId]) {
+                    this.logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+                    delete data[keyType][keyId]
+                }
+            }
+        })
+    }
+}
+
+module.exports = {
+  PreKeyManager
+}