@hansaka02/baileys 1.0.0 → 7.3.2

package/lib/Utils/process-message.js

@@ -103,7 +103,111 @@ function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pol
     const decKey = crypto_1.hmacSign(sign, key0, 'sha256')
     const aad = toBinary(`${pollMsgId}\u0000${voterJid}`)
     const decrypted = crypto_1.aesDecryptGCM(encPayload, decKey, encIv, aad)
+    
     return WAProto_1.proto.Message.PollVoteMessage.decode(decrypted)
+    
+    function toBinary(txt) {
+        return Buffer.from(txt)
+    }
+}
+
+/**
+ * Decrypt an event edit
+ * @param edit encrypted event edit
+ * @returns message
+ */
+function decryptEventEdit({ encPayload, encIv }, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }) {
+    const sign = Buffer.concat([
+        toBinary(eventMsgId),
+        toBinary(eventCreatorJid),
+        toBinary(responderJid),
+        toBinary('Event Edit'),
+        new Uint8Array([1])
+    ])
+    
+    const key0 = crypto_1.hmacSign(eventEncKey, new Uint8Array(32), 'sha256')
+    const decKey = crypto_1.hmacSign(sign, key0, 'sha256')
+    const decrypted = crypto_1.aesDecryptGCM(encPayload, decKey, encIv, null)
+    
+    return WAProto_1.proto.Message.decode(decrypted)
+    
+    function toBinary(txt) {
+        return Buffer.from(txt)
+    }
+}
+
+/**
+ * Decrypt an event response
+ * @param response encrypted event response
+ * @param ctx additional info about the event required for decryption
+ * @returns event response message
+ */
+function decryptEventResponse({ encPayload, encIv }, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }) {
+    const sign = Buffer.concat([
+        toBinary(eventMsgId),
+        toBinary(eventCreatorJid),
+        toBinary(responderJid),
+        toBinary('Event Response'),
+        new Uint8Array([1])
+    ])
+    
+    const key0 = crypto_1.hmacSign(eventEncKey, new Uint8Array(32), 'sha256')
+    const decKey = crypto_1.hmacSign(sign, key0, 'sha256')
+    const aad = toBinary(`${eventMsgId}\u0000${responderJid}`)
+    const decrypted = crypto_1.aesDecryptGCM(encPayload, decKey, encIv, aad)
+    
+    return WAProto_1.proto.Message.EventResponseMessage.decode(decrypted)
+    
+    function toBinary(txt) {
+        return Buffer.from(txt)
+    }
+}
+
+/**
+ * Decrypt an comment message 
+ * @param comment encrypted comment message
+ * @returns message
+ */
+function decryptComment({ encPayload, encIv }, { commentCreatorJid, commentMsgId, commentEncKey, commentJid }) {
+    const sign = Buffer.concat([
+        toBinary(commentMsgId),
+        toBinary(commentCreatorJid),
+        toBinary(commentJid),
+        toBinary('Enc Comment'),
+        new Uint8Array([1])
+    ])
+    
+    const key0 = crypto_1.hmacSign(commentEncKey, new Uint8Array(32), 'sha256')
+    const decKey = crypto_1.hmacSign(sign, key0, 'sha256')
+    const decrypted = crypto_1.aesDecryptGCM(encPayload, decKey, encIv, null)
+    
+    return WAProto_1.proto.Message.decode(decrypted)
+    
+    function toBinary(txt) {
+        return Buffer.from(txt)
+    }
+}
+
+/**
+ * Decrypt an reaction 
+ * @param reaction encrypted reaction
+ * @returns reaction message
+ */
+function decryptReaction({ encPayload, encIv }, { reactionCreatorJid, reactionMsgId, reactionEncKey, reactionJid }) {
+    const sign = Buffer.concat([
+        toBinary(reactionMsgId),
+        toBinary(reactionCreatorJid),
+        toBinary(reactionJid),
+        toBinary('Enc Reaction'),
+        new Uint8Array([1])
+    ])
+    
+    const key0 = crypto_1.hmacSign(reactionEncKey, new Uint8Array(32), 'sha256')
+    const decKey = crypto_1.hmacSign(sign, key0, 'sha256')
+    const decrypted = crypto_1.aesDecryptGCM(encPayload, decKey, encIv, null)
+    
+    return WAProto_1.proto.Message.ReactionMessage.decode(decrypted)
+    
     function toBinary(txt) {
         return Buffer.from(txt)
     }
@@ -111,6 +215,7 @@ function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pol
 
 const processMessage = async (message, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, signalRepository, keyStore, logger, options, getMessage }) => {
     const meId = creds.me.id
+    const meLid = creds.me.lid
     const { accountSettings } = creds
     const chat = { id: WABinary_1.jidNormalizedUser(getChatId(message.key)) }
     const isRealMsg = isRealMessage(message, meId)
@@ -373,35 +478,50 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         }
     }
     else if (content?.pollUpdateMessage) {
-        const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey
+        const pollUpdate = content.pollUpdateMessage
+        const creationMsgKey = pollUpdate.pollCreationMessageKey
+
         // we need to fetch the poll creation message to get the poll enc key
         const pollMsg = await getMessage(creationMsgKey)
         if (pollMsg) {
-            const meIdNormalised = WABinary_1.jidNormalizedUser(meId)
-            const pollCreatorJid = generics_1.getKeyAuthor(creationMsgKey, meIdNormalised)
-            const voterJid = generics_1.getKeyAuthor(message.key, meIdNormalised)
-            const pollEncKey = pollMsg.messageContextInfo?.messageSecret
             try {
-                const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
-                    pollEncKey,
-                    pollCreatorJid,
-                    pollMsgId: creationMsgKey.id,
-                    voterJid,
-                })
-                ev.emit('messages.update', [
-                    {
-                        key: creationMsgKey,
-                        update: {
-                            pollUpdates: [
-                                {
-                                    pollUpdateMessageKey: message.key,
-                                    vote: voteMsg,
-                                    senderTimestampMs: content.pollUpdateMessage.senderTimestampMs.toNumber(),
-                                }
-                            ]
+                const meLidNormalised = WABinary_1.jidNormalizedUser(meLid)
+                const getDevice = messages_1.getDevice(creationMsgKey.id) 
+                const pollCreationFromMe = getDevice === 'baileys' ? true : false
+                const pollEncKey = pollMsg.messageContextInfo?.messageSecret
+                const voterJid = generics_1.getKeyAuthor(message.key, meLidNormalised)
+
+                let pollCreatorJid = generics_1.getKeyAuthor(creationMsgKey, meLidNormalised)
+
+                if (pollCreationFromMe) {
+                    pollCreatorJid = meLidNormalised
+                }
+
+                if (!pollEncKey) {
+                    logger?.warn({ vote: pollUpdate.vote, creationMsgKey }, 'poll creation: missing messageSecret for decryption') 
+                } else {
+                    const voteMsg = decryptPollVote(pollUpdate.vote, {
+                        pollEncKey,
+                        pollCreatorJid,
+                        pollMsgId: creationMsgKey.id,
+                        voterJid
+                    })
+
+                    ev.emit('messages.update', [
+                        {
+                            key: creationMsgKey,
+                            update: {
+                                pollUpdates: [
+                                    {
+                                        pollUpdateMessageKey: message.key,
+                                        vote: voteMsg,
+                                        senderTimestampMs: content.pollUpdateMessage.senderTimestampMs.toNumber()
+                                    }
+                                ]
+                            }
                         }
-                    }
-                ])
+                    ])
+                }
             }
             catch (err) {
                 logger?.warn({ err, creationMsgKey }, 'failed to decrypt poll vote')
@@ -411,6 +531,194 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             logger?.warn({ creationMsgKey }, 'poll creation message not found, cannot decrypt update')
         }
     }
+    else if (content?.secretEncryptedMessage) {
+        const encEventEdit = content.secretEncryptedMessage
+        const creationMsgKey = encEventEdit.targetMessageKey
+        
+        if (WAProto_1.proto.Message.SecretEncryptedMessage.SecretEncType[encEventEdit.secretEncType] !== 'EVENT_EDIT') return
+
+        // we need to fetch the event creation message to get the event enc key
+        const eventMsg = await getMessage(creationMsgKey)
+        if (eventMsg) {
+            try {
+                const meLidNormalised = WABinary_1.jidNormalizedUser(meLid)
+                const eventCreatorJid = generics_1.getKeyAuthor(message.key, meLidNormalised)
+                const responderJid = generics_1.getKeyAuthor(message.key, meLidNormalised)
+                const eventEncKey = eventMsg.messageContextInfo?.messageSecret
+
+                if (!eventEncKey) {
+                    logger?.warn({ encEventEdit, creationMsgKey }, 'event edit: missing messageSecret for decryption') 
+                } else {
+                    const responseMsg = decryptEventEdit(encEventEdit, {
+                        eventEncKey,
+                        eventCreatorJid,
+                        eventMsgId: creationMsgKey.id,
+                        responderJid
+                    })
+                    const content = messages_1.normalizeMessageContent(responseMsg)
+                    const protocolMsg = content?.protocolMessage
+
+                    ev.emit('messages.update', [
+                        {
+                            key: { ...message.key, id: protocolMsg.key?.id },
+                            update: {
+                                message: {
+                                	messageContextInfo: responseMsg.messageContextInfo, 
+                                	editedMessage: { 
+                                		message: protocolMsg.editedMessage
+                                	}
+                                }, 
+                                messageTimestamp: protocolMsg.timestampMs
+                             	   ? Math.floor(generics_1.toNumber(protocolMsg.timestampMs) / 1000)
+                          	      : message.messageTimestamp
+                            }
+                        }
+                    ])
+                }
+            }
+            catch (err) {
+                logger?.warn({ err, creationMsgKey, encEventEdit }, 'failed to decrypt event edit')
+            }
+        }
+        else {
+            logger?.warn({ encEventEdit, creationMsgKey }, 'event creation message not found, cannot decrypt update')
+        }
+    }
+    else if (content?.encEventResponseMessage) {
+        const encEventResponse = content.encEventResponseMessage
+        const creationMsgKey = encEventResponse.eventCreationMessageKey
+
+        // we need to fetch the event creation message to get the event enc key
+        const eventMsg = await getMessage(creationMsgKey)
+        if (eventMsg) {
+            try {
+                const meLidNormalised = WABinary_1.jidNormalizedUser(meLid)
+                const eventCreatorJid = generics_1.getKeyAuthor(creationMsgKey, meLidNormalised)
+                const responderJid = generics_1.getKeyAuthor(message.key, meLidNormalised)
+                const eventEncKey = eventMsg.messageContextInfo?.messageSecret
+
+                if (!eventEncKey) {
+                    logger?.warn({ encEventResponse, creationMsgKey }, 'event response: missing messageSecret for decryption') 
+                } else {
+                    const responseMsg = decryptEventResponse(encEventResponse, {
+                        eventEncKey,
+                        eventCreatorJid,
+                        eventMsgId: creationMsgKey.id,
+                        responderJid
+                    })
+
+                    const eventResponse = {
+                        eventResponseMessageKey: message.key, 
+                        senderTimestampMs: responseMsg.timestampMs, 
+                        response: responseMsg
+                    }
+
+                    ev.emit('messages.update', [
+                        {
+                            key: creationMsgKey,
+                            update: {
+                                eventResponses: [eventResponse]
+                            }
+                        }
+                    ])
+                }
+            }
+            catch (err) {
+                logger?.warn({ err, creationMsgKey, encEventResponse }, 'failed to decrypt event response')
+            }
+        }
+        else {
+            logger?.warn({ encEventResponse, creationMsgKey }, 'event creation message not found, cannot decrypt update')
+        }
+    }
+    else if (content?.encCommentMessage) {
+        const encComment = content.encCommentMessage
+        const creationMsgKey = encComment.targetMessageKey
+
+        // we need to fetch the message to get the reaction enc key
+        const commentMsg = await getMessage(creationMsgKey)
+        if (commentMsg) {
+            try {
+                const meLidNormalised = WABinary_1.jidNormalizedUser(meLid)
+                const commentCreatorJid = creationMsgKey.participant ? creationMsgKey.participant : message.key?.participant ? message.key.participant : meLidNormalised
+                const commentJid = message.key?.participant ? message.key.participant : creationMsgKey.participant ? creationMsgKey.participant : meLidNormalised
+                const commentEncKey = commentMsg.messageContextInfo?.messageSecret
+
+                if (!commentEncKey) {
+                    logger?.warn({ encComment, creationMsgKey }, 'comment message: missing messageSecret for decryption') 
+                } else {
+                    const responseMsg = decryptComment(encComment, {
+                        commentEncKey,
+                        commentCreatorJid,
+                        commentMsgId: creationMsgKey.id,
+                        commentJid
+                    }) 
+
+                    ev.emit('messages.upsert', {
+                        messages: [{
+                        	key: message.key, 
+                        	message: responseMsg
+                        }], 
+                        type: 'append'
+                    }) 
+                }
+            }
+            catch (err) {
+                logger?.warn({ err, creationMsgKey, encComment }, 'failed to decrypt comment message')
+            }
+        }
+        else {
+            logger?.warn({ encComment, creationMsgKey }, 'creation message not found, cannot decrypt')
+        }
+    }
+    else if (content?.encReactionMessage) {
+        const encReaction = content.encReactionMessage
+        const creationMsgKey = encReaction.targetMessageKey
+
+        // we need to fetch the message to get the reaction enc key
+        const reactMsg = await getMessage(creationMsgKey)
+        if (reactMsg) {
+            try {
+                const meLidNormalised = WABinary_1.jidNormalizedUser(meLid)
+                const reactionCreatorJid = creationMsgKey.participant ? creationMsgKey.participant : message.key?.participant ? message.key.participant : meLidNormalised
+                const reactionJid = message.key?.participant ? message.key.participant : creationMsgKey.participant ? creationMsgKey.participant : meLidNormalised
+                const reactionEncKey = reactMsg.messageContextInfo?.messageSecret
+
+                if (!reactionEncKey) {
+                    logger?.warn({ encReaction, creationMsgKey }, 'reaction: missing messageSecret for decryption') 
+                } else {
+                    const responseMsg = decryptReaction(encReaction, {
+                        reactionEncKey,
+                        reactionCreatorJid,
+                        reactionMsgId: creationMsgKey.id,
+                        reactionJid
+                    })
+                    
+                    const Reaction = {
+                        key: message.key, 
+                        message: {
+                            reactionMessage: {
+                                key: creationMsgKey, 
+                                text: responseMsg.text, 
+                                senderTimestampMs: responseMsg.senderTimestampMs
+                            }
+                        }
+                    }
+
+                    ev.emit('messages.upsert', {
+                        messages: [Reaction], 
+                        type: 'append'
+                    }) 
+                }
+            }
+            catch (err) {
+                logger?.warn({ err, creationMsgKey, encReaction }, 'failed to decrypt reaction')
+            }
+        }
+        else {
+            logger?.warn({ encReaction, creationMsgKey }, 'creation message not found, cannot decrypt')
+        }
+    }
     if (Object.keys(chat).length > 1) {
         ev.emit('chats.update', [chat])
     }
@@ -422,5 +730,9 @@ module.exports = {
   shouldIncrementChatUnread, 
   getChatId, 
   decryptPollVote, 
+  decryptEventEdit, 
+  decryptEventResponse, 
+  decryptComment, 
+  decryptReaction, 
   processMessage
 }

package/lib/Utils/validate-connection.js

@@ -77,12 +77,37 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
     const appVersionBuf = crypto_1.createHash('md5')
         .update(config.version.join('.')) // join as string
         .digest()
+
     const companion = {
         os: config.browser[0],
         platformType: getPlatformType(config.browser[1]),
         requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: {
+            primary: 10,
+            secondary: 15,
+            tertiary: 7
+        }
     }
+
     const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish()
+
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
@@ -96,8 +121,9 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
             eSkeyId: generics_1.encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
-        },
+        }
     }
+
     return WAProto_1.proto.ClientPayload.fromObject(registerPayload)
 }
 
@@ -115,25 +141,41 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
     const jid = deviceNode.attrs.jid
     const lid = deviceNode.attrs.lid
     const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content)
-    const isHostedAccount = accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED
-    const hmacPrefix = isHostedAccount ? Buffer.from([6, 5]) : Buffer.alloc(0) 
+    
+    let hmacPrefix = Buffer.from([])
+    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = Buffer.from([6, 5])
+    }
+
     const advSign = crypto_2.hmacSign(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'))
     if (Buffer.compare(hmac, advSign) !== 0) {
         throw new boom_1.Boom('Invalid account signature')
     }
+
     const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details)
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account
-    const accountMsg = Buffer.concat([Buffer.from([6, 0]), deviceDetails, signedIdentityKey.public])
+
+    const decodedDeviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails)
+
+    const accountSignaturePrefix =
+        decodedDeviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED
+            ? Buffer.from([6, 5])
+            : Buffer.from([6, 0])
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public])
     if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
         throw new boom_1.Boom('Failed to verify account signature')
     }
-    
-    const devicePrefix = isHostedAccount ? Buffer.from([6, 6]) : Buffer.from([6, 1]) 
-    const deviceMsg = Buffer.concat([devicePrefix, deviceDetails, signedIdentityKey.public, accountSignatureKey])
+
+    const deviceMsg = Buffer.concat([
+        Buffer.from([6, 1]),
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ])
     account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
     const identity = signal_1.createSignalIdentity(lid, accountSignatureKey)
     const accountEnc = encodeSignedDeviceIdentity(account, false)
-    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(account.details)
+    const deviceIdentityData = WAProto_1.proto.ADVDeviceIdentity.decode(account.details)
     const reply = {
         tag: 'iq',
         attrs: {
@@ -148,7 +190,7 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
                 content: [
                     {
                         tag: 'device-identity',
-                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        attrs: { 'key-index': deviceIdentityData.keyIndex.toString() },
                         content: accountEnc
                     }
                 ]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hansaka02/baileys",
-  "version": "1.0.0",
-  "description": "WhatsApp API Modification By hansaka",
+  "version": "7.3.2",
+  "description": "WhatsApp API Modification By Itsukiichan",
   "keywords": [
     "whatsapp",
     "js-whatsapp",
@@ -12,11 +12,11 @@
     "automation",
     "multi-device"
   ],
-  "homepage": "https://github.com/hansaka02/baileys",
-"repository": {
-  "type": "git",
-  "url": "git+https://github.com/hansaka02/baileys.git"
-},
+  "homepage": "https://github.com/hansaka02/Baileys",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/hansaka02/Baileys.git"
+  },
   "license": "MIT",
   "author": "hansaka02",
   "main": "lib/index.js",
@@ -42,23 +42,23 @@
     "test": "jest"
   },
   "dependencies": {
-    "@hapi/boom": "^9.1.3",
     "@adiwajshing/keyed-db": "^0.2.4",
-    "@cacheable/node-cache": "1.5.3", 
-    "@itsukichan/eslint-config": "^1.0.0", 
-    "@itsukichan/libsignal-node": "^1.0.1", 
+    "@cacheable/node-cache": "1.5.3",
+    "@hapi/boom": "^9.1.3",
+    "@itsukichan/eslint-config": "^1.0.0",
+    "@itsukichan/libsignal-node": "^1.0.1",
     "async-mutex": "^0.5.0",
+    "audio-decode": "^2.2.2",
     "axios": "^1.12.1",
-    "audio-decode": "^2.2.2", 
-    "cache-manager": "^5.7.6", 
-    "fflate": "^0.8.2", 
+    "cache-manager": "^5.7.6",
+    "fflate": "^0.8.2",
+    "link-preview-js": "^3.0.14",
     "lodash": "^4.17.21",
-    "link-preview-js": "^3.0.14", 
-    "lru-cache": "^11.1.0", 
+    "lru-cache": "^11.1.0",
     "music-metadata": "^7.12.3",
     "pino": "^9.6",
     "protobufjs": "^7.2.4",
-    "qrcode-terminal": "^0.12.0", 
+    "qrcode-terminal": "^0.12.0",
     "ws": "^8.13.0"
   },
   "devDependencies": {
@@ -77,7 +77,7 @@
     "ts-node": "^10.8.1",
     "typedoc": "^0.27.9",
     "typedoc-plugin-markdown": "4.4.2",
-    "typescript": "^5.8.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "jimp": "^0.22.12"
@@ -95,6 +95,6 @@
     "lib": "lib"
   },
   "bugs": {
-    "url": "https://github.com/hansaka02/baileys/issues"
+    "url": "https://github.com/Itsukichann/Baileys/issues"
   }
 }