finalize multi-device

src/Utils/decode-wa-message.ts

@@ -1,63 +1,103 @@
 import { Boom } from '@hapi/boom'
-import BinaryNode from "../BinaryNode"
-import { aesDecrypt, hmacSign } from "./generics"
-import { DisconnectReason, WATag } from "../Types"
+import { unpadRandomMax16 } from "./generics"
+import { AuthenticationState } from "../Types"
+import { areJidsSameUser, BinaryNode as BinaryNodeM, encodeBinaryNode, isJidBroadcast, isJidGroup, isJidStatusBroadcast, isJidUser } from '../WABinary'
+import { decryptGroupSignalProto, decryptSignalProto, processSenderKeyMessage } from './signal'
+import { proto } from '../../WAProto'
 
-export const decodeWAMessage = (
-    message: string | Buffer, 
-    auth: { macKey: Buffer, encKey: Buffer }, 
-    fromMe: boolean=false
-) => {
+type MessageType = 'chat' | 'peer_broadcast' | 'other_broadcast' | 'group' | 'direct_peer_status' | 'other_status'
 
-    let commaIndex = message.indexOf(',') // all whatsapp messages have a tag and a comma, followed by the actual message
-    if (commaIndex < 0) throw new Boom('invalid message', { data: message }) // if there was no comma, then this message must be not be valid
-    
-    if (message[commaIndex+1] === ',') commaIndex += 1
-    let data = message.slice(commaIndex+1, message.length)
-    
-    // get the message tag.
-    // If a query was done, the server will respond with the same message tag we sent the query with
-    const messageTag: string = message.slice(0, commaIndex).toString()
-    let json: any
-    let tags: WATag
-    if (data.length > 0) {
-        if (typeof data === 'string') {
-            json = JSON.parse(data) // parse the JSON
+export const decodeMessageStanza = async(stanza: BinaryNodeM, auth: AuthenticationState) => {
+    const deviceIdentity = (stanza.content as BinaryNodeM[])?.find(m => m.tag === 'device-identity')
+    const deviceIdentityBytes = deviceIdentity ? deviceIdentity.content as Buffer : undefined
+
+    let msgType: MessageType
+    let chatId: string
+    let author: string
+
+    const msgId: string = stanza.attrs.id
+    const from: string = stanza.attrs.from
+    const participant: string | undefined = stanza.attrs.participant
+    const recipient: string | undefined = stanza.attrs.recipient
+
+    const isMe = (jid: string) => areJidsSameUser(jid, auth.creds.me!.id)
+
+    if(isJidUser(from)) {
+        if(recipient) {
+            if(!isMe(from)) {
+                throw new Boom('')
+            }
+            chatId = recipient
         } else {
-            const { macKey, encKey } = auth || {}
-            if (!macKey || !encKey) {
-                throw new Boom('recieved encrypted buffer when auth creds unavailable', { data: message, statusCode: DisconnectReason.badSession })
-            }
-            /* 
-                If the data recieved was not a JSON, then it must be an encrypted message.
-                Such a message can only be decrypted if we're connected successfully to the servers & have encryption keys
-            */
-            if (fromMe) {
-                tags = [data[0], data[1]]
-                data = data.slice(2, data.length)
-            }
-            
-            const checksum = data.slice(0, 32) // the first 32 bytes of the buffer are the HMAC sign of the message
-            data = data.slice(32, data.length) // the actual message
-            const computedChecksum = hmacSign(data, macKey) // compute the sign of the message we recieved using our macKey
-            
-            if (checksum.equals(computedChecksum)) {
-                // the checksum the server sent, must match the one we computed for the message to be valid
-                const decrypted = aesDecrypt(data, encKey) // decrypt using AES
-                json = BinaryNode.from(decrypted) // decode the binary message into a JSON array
-            } else {
-                throw new Boom('Bad checksum', {
-                    data: {
-                        received: checksum.toString('hex'),
-                        computed: computedChecksum.toString('hex'),
-                        data: data.slice(0, 80).toString(),
-                        tag: messageTag,
-                        message: message.slice(0, 80).toString()
-                    },
-                    statusCode: DisconnectReason.badSession
-                })
-            }
-        }   
+            chatId = from
+        }
+        msgType = 'chat'
+        author = from
+    } else if(isJidGroup(from)) {
+        if(!participant) {
+            throw new Boom('No participant in group message')
+        }
+        msgType = 'group'
+        author = participant
+        chatId = from
+    } else if(isJidBroadcast(from)) {
+        if(!participant) {
+            throw new Boom('No participant in group message')
+        }
+        const isParticipantMe = isMe(participant)
+        if(isJidStatusBroadcast(from)) {
+            msgType = isParticipantMe ? 'direct_peer_status' : 'other_status'
+        } else {
+            msgType = isParticipantMe ? 'peer_broadcast' : 'other_broadcast'
+        }
+        chatId = from
+        author = participant
+    }
+    const sender = msgType === 'chat' ? author : chatId
+
+    const successes: proto.Message[] = []
+    const failures: { error: Boom }[] = []
+    if(Array.isArray(stanza.content)) {
+        for(const { tag, attrs, content } of stanza.content as BinaryNodeM[]) {
+            if(tag !== 'enc') continue
+            if(!Buffer.isBuffer(content) && !(content instanceof Uint8Array)) continue 
+
+            try {
+                let msgBuffer: Buffer
+
+                const e2eType = attrs.type
+                switch(e2eType) {
+                    case 'skmsg':
+                        msgBuffer = await decryptGroupSignalProto(sender, author, content, auth)
+                    break
+                    case 'pkmsg':
+                    case 'msg':
+                        const user = isJidUser(sender) ? sender : author
+                        msgBuffer = await decryptSignalProto(user, e2eType, content as Buffer, auth)
+                    break
+                }
+                const msg = proto.Message.decode(unpadRandomMax16(msgBuffer))
+                if(msg.senderKeyDistributionMessage) {
+                    await processSenderKeyMessage(author, msg.senderKeyDistributionMessage, auth)
+                }
+
+                successes.push(msg)
+            } catch(error) {
+                failures.push({ error: new Boom(error, { data: Buffer.from(encodeBinaryNode(stanza)).toString('base64') }) })
+            }
+        }
+    }
+
+    return {
+        msgId,
+        chatId,
+        author,
+        from,
+        timestamp: +stanza.attrs.t,
+        participant,
+        recipient,
+        pushname: stanza.attrs.notify,
+        successes,
+        failures
     }
-    return [messageTag, json, tags] as const
 }