@neelegirl/baileys 2.1.4 → 2.1.6

package/lib/Signal/libsignal.js

@@ -1,123 +1,331 @@
 "use strict"
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
-    }
-    Object.defineProperty(o, k2, desc)
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    o[k2] = m[k]
-}))
-
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v })
-}) : function(o, v) {
-    o["default"] = v
-})
-
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod
-    var result = {}
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
-    __setModuleDefault(result, mod)
-    return result
-}
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const libsignal = __importStar(require("@neelegirl/libsignal"))
+const libsignal = require("@neelegirl/libsignal")
+const { PreKeyWhisperMessage } = require("@neelegirl/libsignal/src/protobufs")
+const { LRUCache } = require("lru-cache")
 const WASignalGroup_1 = require("./WASignalGroup")
+const lid_mapping_1 = require("./lid-mapping")
 const Utils_1 = require("../Utils")
 const WABinary_1 = require("../WABinary")
 
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth)
-    return {
+function extractIdentityFromPkmsg(ciphertext) {
+    try {
+        if (!ciphertext || ciphertext.length < 2) {
+            return undefined
+        }
+        const version = ciphertext[0]
+        if ((version & 0xf) !== 3) {
+            return undefined
+        }
+        const preKeyProto = PreKeyWhisperMessage.decode(ciphertext.slice(1))
+        if (preKeyProto.identityKey?.length === 33) {
+            return new Uint8Array(preKeyProto.identityKey)
+        }
+    }
+    catch (_error) { }
+}
+
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const parsedKeys = auth.keys
+    const lidMapping = new lid_mapping_1.LIDMappingStore(parsedKeys, logger, pnToLIDFunc)
+    const storage = signalStorage(auth, lidMapping)
+    const migratedSessionCache = new LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    })
+    const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid)
             const cipher = new WASignalGroup_1.GroupCipher(storage, senderName)
-            return cipher.decrypt(msg)
+            return parsedKeys.transaction(async () => {
+                return cipher.decrypt(msg)
+            }, group)
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
+            if (!item.groupId) {
+                throw new Error('group ID is required for sender key distribution message')
+            }
             const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
-            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
-            }
-            await builder.process(senderName, senderMsg)
+            const senderNameStr = senderName.toString()
+            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(
+                null,
+                null,
+                null,
+                null,
+                item.axolotlSenderKeyDistributionMessage
+            )
+            return parsedKeys.transaction(async () => {
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
+                }
+                await builder.process(senderName, senderMsg)
+            }, item.groupId)
         },
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid)
             const session = new libsignal.SessionCipher(storage, addr)
-            let result
-            switch (type) {
-                case 'pkmsg':
-                    result = await session.decryptPreKeyWhisperMessage(ciphertext)
-                    break
-                case 'msg':
-                    result = await session.decryptWhisperMessage(ciphertext)
-                    break
+            if (type === 'pkmsg') {
+                const identityKey = extractIdentityFromPkmsg(ciphertext)
+                if (identityKey) {
+                    const addrStr = addr.toString()
+                    const identityChanged = await storage.saveIdentity(addrStr, identityKey)
+                    if (identityChanged) {
+                        logger?.info?.({ jid, addr: addrStr }, 'identity key changed or contact was first seen')
+                    }
+                }
             }
-            return result
+            return parsedKeys.transaction(async () => {
+                switch (type) {
+                    case 'pkmsg':
+                        return session.decryptPreKeyWhisperMessage(ciphertext)
+                    case 'msg':
+                    default:
+                        return session.decryptWhisperMessage(ciphertext)
+                }
+            }, jid)
         },
         async encryptMessage({ jid, data }) {
             const addr = jidToSignalProtocolAddress(jid)
             const cipher = new libsignal.SessionCipher(storage, addr)
-            const { type: sigType, body } = await cipher.encrypt(data)
-            const type = sigType === 3 ? 'pkmsg' : 'msg'
-            return { type, ciphertext: Buffer.from(body, 'binary') }
+            return parsedKeys.transaction(async () => {
+                const { type: sigType, body } = await cipher.encrypt(data)
+                const type = sigType === 3 ? 'pkmsg' : 'msg'
+                return {
+                    type,
+                    ciphertext: Buffer.from(body, 'binary')
+                }
+            }, jid)
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId)
             const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
-            }
-            const senderKeyDistributionMessage = await builder.create(senderName)
-            const session = new WASignalGroup_1.GroupCipher(storage, senderName)
-            const ciphertext = await session.encrypt(data)
-            return {
-                ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
-            }
+            return parsedKeys.transaction(async () => {
+                const senderKeyDistributionMessage = await builder.create(senderName)
+                const session = new WASignalGroup_1.GroupCipher(storage, senderName)
+                const ciphertext = await session.encrypt(data)
+                return {
+                    ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                }
+            }, group)
         },
         async injectE2ESession({ jid, session }) {
+            logger?.trace?.({ jid }, 'injecting E2EE session')
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
-            await cipher.initOutgoing(session)
+            return parsedKeys.transaction(async () => {
+                await cipher.initOutgoing(session)
+            }, jid)
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString()
         },
+        lidMapping,
+        async validateSession(jid) {
+            try {
+                const addr = jidToSignalProtocolAddress(jid)
+                const session = await storage.loadSession(addr.toString())
+                if (!session) {
+                    return { exists: false, reason: 'no session' }
+                }
+                if (!session.haveOpenSession()) {
+                    return { exists: false, reason: 'no open session' }
+                }
+                return { exists: true }
+            }
+            catch (_error) {
+                return { exists: false, reason: 'validation error' }
+            }
+        },
+        async deleteSession(jids) {
+            if (!jids?.length) {
+                return
+            }
+            const sessionUpdates = {}
+            for (const jid of jids) {
+                const addr = jidToSignalProtocolAddress(jid)
+                sessionUpdates[addr.toString()] = null
+            }
+            await parsedKeys.transaction(async () => {
+                await auth.keys.set({ session: sessionUpdates })
+            }, `delete-${jids.length}-sessions`)
+        },
+        async migrateSession(fromJid, toJid) {
+            if (!fromJid || (!(0, WABinary_1.isLidUser)(toJid) && !(0, WABinary_1.isHostedLidUser)(toJid))) {
+                return { migrated: 0, skipped: 0, total: 0 }
+            }
+            if (!(0, WABinary_1.isPnUser)(fromJid) && !(0, WABinary_1.isHostedPnUser)(fromJid)) {
+                return { migrated: 0, skipped: 0, total: 1 }
+            }
+            const fromDecoded = (0, WABinary_1.jidDecode)(fromJid)
+            const user = fromDecoded?.user
+            if (!user) {
+                return { migrated: 0, skipped: 0, total: 0 }
+            }
+            const { [user]: userDevices } = await parsedKeys.get('device-list', [user])
+            if (!userDevices?.length) {
+                return { migrated: 0, skipped: 0, total: 0 }
+            }
+            const fromDeviceStr = (fromDecoded?.device || 0).toString()
+            if (!userDevices.includes(fromDeviceStr)) {
+                userDevices.push(fromDeviceStr)
+            }
+            const uncachedDevices = userDevices.filter(device => !migratedSessionCache.has(`${user}.${device}`))
+            const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`)
+            const existingSessions = deviceSessionKeys.length
+                ? await parsedKeys.get('session', deviceSessionKeys)
+                : {}
+            const deviceJids = []
+            for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
+                if (!sessionData) {
+                    continue
+                }
+                const deviceStr = sessionKey.split('.')[1]
+                if (!deviceStr) {
+                    continue
+                }
+                const deviceNum = parseInt(deviceStr, 10)
+                let jid = `${user}${deviceNum ? `:${deviceNum}` : ''}@s.whatsapp.net`
+                if (deviceNum === 99) {
+                    jid = `${user}:99@hosted`
+                }
+                deviceJids.push(jid)
+            }
+            return parsedKeys.transaction(async () => {
+                const migrationOps = deviceJids.map(jid => {
+                    const lidWithDevice = (0, WABinary_1.transferDevice)(jid, toJid)
+                    const fromDecoded = (0, WABinary_1.jidDecode)(jid)
+                    return {
+                        fromJid: jid,
+                        toJid: lidWithDevice,
+                        pnUser: fromDecoded?.user,
+                        deviceId: fromDecoded?.device || 0,
+                        fromAddr: jidToSignalProtocolAddress(jid),
+                        toAddr: jidToSignalProtocolAddress(lidWithDevice)
+                    }
+                })
+                const totalOps = migrationOps.length
+                let migratedCount = 0
+                const pnAddrStrings = [...new Set(migrationOps.map(op => op.fromAddr.toString()))]
+                const pnSessions = pnAddrStrings.length
+                    ? await parsedKeys.get('session', pnAddrStrings)
+                    : {}
+                const sessionUpdates = {}
+                for (const op of migrationOps) {
+                    const pnAddrStr = op.fromAddr.toString()
+                    const lidAddrStr = op.toAddr.toString()
+                    const pnSession = pnSessions[pnAddrStr]
+                    if (!pnSession) {
+                        continue
+                    }
+                    const fromSession = libsignal.SessionRecord.deserialize(pnSession)
+                    if (!fromSession.haveOpenSession()) {
+                        continue
+                    }
+                    sessionUpdates[lidAddrStr] = fromSession.serialize()
+                    sessionUpdates[pnAddrStr] = null
+                    migratedCount += 1
+                }
+                if (Object.keys(sessionUpdates).length) {
+                    await parsedKeys.set({ session: sessionUpdates })
+                    for (const op of migrationOps) {
+                        if (sessionUpdates[op.toAddr.toString()] && op.pnUser) {
+                            migratedSessionCache.set(`${op.pnUser}.${op.deviceId}`, true)
+                        }
+                    }
+                }
+                return {
+                    migrated: migratedCount,
+                    skipped: totalOps - migratedCount,
+                    total: totalOps
+                }
+            }, `migrate-${deviceJids.length}-sessions-${(0, WABinary_1.jidDecode)(toJid)?.user || 'unknown'}`)
+        }
     }
+    return repository
 }
 
 const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = WABinary_1.jidDecode(jid)
-    return new libsignal.ProtocolAddress(user, device || 0)
+    const decoded = (0, WABinary_1.jidDecode)(jid)
+    const { user, device, server, domainType } = decoded || {}
+    if (!user) {
+        throw new Error(`JID decoded but user is empty: ${jid}`)
+    }
+    const signalUser = domainType !== WABinary_1.WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user
+    const finalDevice = device || 0
+    if (device === 99 && server !== 'hosted' && server !== 'hosted.lid') {
+        throw new Error(`unexpected non-hosted device 99 JID: ${jid}`)
+    }
+    return new libsignal.ProtocolAddress(signalUser, finalDevice)
 }
 
 const jidToSignalSenderKeyName = (group, user) => {
-    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString()
+    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
 }
 
-function signalStorage({ creds, keys }) {
+function signalStorage({ creds, keys }, lidMapping) {
+    const resolveLIDSignalAddress = async (id) => {
+        if (id.includes('.')) {
+            const [deviceId, device] = id.split('.')
+            const [user, domainType_] = deviceId.split('_')
+            const domainType = parseInt(domainType_ || '0', 10)
+            if (domainType === WABinary_1.WAJIDDomains.LID || domainType === WABinary_1.WAJIDDomains.HOSTED_LID) {
+                return id
+            }
+            const pnJid = `${user}${device !== '0' ? `:${device}` : ''}@${domainType === WABinary_1.WAJIDDomains.HOSTED ? 'hosted' : 's.whatsapp.net'}`
+            const lidForPN = await lidMapping.getLIDForPN(pnJid)
+            if (lidForPN) {
+                return jidToSignalProtocolAddress(lidForPN).toString()
+            }
+        }
+        return id
+    }
     return {
         loadSession: async (id) => {
-            const { [id]: sess } = await keys.get('session', [id])
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess)
+            try {
+                const wireJid = await resolveLIDSignalAddress(id)
+                const { [wireJid]: sess } = await keys.get('session', [wireJid])
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess)
+                }
             }
+            catch (_error) {
+                return null
+            }
+            return null
         },
         storeSession: async (id, session) => {
-            await keys.set({ 'session': { [id]: session.serialize() } })
+            const wireJid = await resolveLIDSignalAddress(id)
+            await keys.set({ session: { [wireJid]: session.serialize() } })
+        },
+        isTrustedIdentity: () => true,
+        loadIdentityKey: async (id) => {
+            const wireJid = await resolveLIDSignalAddress(id)
+            const { [wireJid]: key } = await keys.get('identity-key', [wireJid])
+            return key || undefined
         },
-        isTrustedIdentity: () => {
-            return true
+        saveIdentity: async (id, identityKey) => {
+            const wireJid = await resolveLIDSignalAddress(id)
+            const { [wireJid]: existingKey } = await keys.get('identity-key', [wireJid])
+            const keysMatch = existingKey
+                && existingKey.length === identityKey.length
+                && existingKey.every((byte, i) => byte === identityKey[i])
+            if (existingKey && !keysMatch) {
+                await keys.set({
+                    session: { [wireJid]: null },
+                    'identity-key': { [wireJid]: identityKey }
+                })
+                return true
+            }
+            if (!existingKey) {
+                await keys.set({ 'identity-key': { [wireJid]: identityKey } })
+                return true
+            }
+            return false
         },
         loadPreKey: async (id) => {
             const keyId = id.toString()
@@ -137,26 +345,26 @@ function signalStorage({ creds, keys }) {
                 pubKey: Buffer.from(key.keyPair.public)
             }
         },
-        loadSenderKey: async (keyId) => {
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString()
             const { [keyId]: key } = await keys.get('sender-key', [keyId])
-            if (key) {
-                return new WASignalGroup_1.SenderKeyRecord(key)
-            }
+            return key ? new WASignalGroup_1.SenderKeyRecord(key) : new WASignalGroup_1.SenderKeyRecord()
         },
-        storeSenderKey: async (keyId, key) => {
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString()
             await keys.set({ 'sender-key': { [keyId]: key.serialize() } })
         },
-        getOurRegistrationId: () => (creds.registrationId),
+        getOurRegistrationId: () => creds.registrationId,
         getOurIdentity: () => {
             const { signedIdentityKey } = creds
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Utils_1.generateSignalPubKey(signedIdentityKey.public),
+                pubKey: Buffer.from((0, Utils_1.generateSignalPubKey)(signedIdentityKey.public))
             }
         }
     }
 }
 
 module.exports = {
-  makeLibSignalRepository
-}
+    makeLibSignalRepository
+}

package/lib/Signal/lid-mapping.d.ts

@@ -0,0 +1,23 @@
+import type { LIDMapping, SignalKeyStoreWithTransaction } from '../Types'
+import type { ILogger } from '../Utils/logger'
+
+export declare class LIDMappingStore {
+    private readonly mappingCache
+    private readonly keys
+    private readonly logger
+    private readonly inflightLIDLookups
+    private readonly inflightPNLookups
+    private pnToLIDFunc?
+    constructor(
+        keys: SignalKeyStoreWithTransaction,
+        logger: ILogger,
+        pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>
+    )
+    storeLIDPNMappings(pairs: LIDMapping[]): Promise<void>
+    getLIDForPN(pn: string): Promise<string | null>
+    getLIDsForPNs(pns: string[]): Promise<LIDMapping[] | null>
+    getPNForLID(lid: string): Promise<string | null>
+    getPNsForLIDs(lids: string[]): Promise<LIDMapping[] | null>
+    private _getLIDsForPNsImpl
+    private _getPNsForLIDsImpl
+}