@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Signal/Group/sender-message-key.js

@@ -0,0 +1,33 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.SenderMessageKey = void 0
+const crypto_1 = require('libsignal/src/crypto')
+class SenderMessageKey {
+    constructor(iteration, seed) {
+        const derivative = (0, crypto_1.deriveSecrets)(
+            seed,
+            Buffer.alloc(32),
+            Buffer.from('WhisperGroup')
+        )
+        const keys = new Uint8Array(32)
+        keys.set(new Uint8Array(derivative[0].slice(16)))
+        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16)
+        this.iv = Buffer.from(derivative[0].slice(0, 16))
+        this.cipherKey = Buffer.from(keys.buffer)
+        this.iteration = iteration
+        this.seed = seed
+    }
+    getIteration() {
+        return this.iteration
+    }
+    getIv() {
+        return this.iv
+    }
+    getCipherKey() {
+        return this.cipherKey
+    }
+    getSeed() {
+        return this.seed
+    }
+}
+exports.SenderMessageKey = SenderMessageKey

package/lib/Signal/libsignal.js

@@ -0,0 +1,204 @@
+'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 () {
+        var ownKeys = function (o) {
+            ownKeys =
+                Object.getOwnPropertyNames ||
+                function (o) {
+                    var ar = []
+                    for (var k in o)
+                        if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
+                    return ar
+                }
+            return ownKeys(o)
+        }
+        return function (mod) {
+            if (mod && mod.__esModule) return mod
+            var result = {}
+            if (mod != null)
+                for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                    if (k[i] !== 'default') __createBinding(result, mod, k[i])
+            __setModuleDefault(result, mod)
+            return result
+        }
+    })()
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeLibSignalRepository = makeLibSignalRepository
+const libsignal = __importStar(require('libsignal'))
+const Utils_1 = require('../Utils')
+const WABinary_1 = require('../WABinary')
+const sender_key_name_1 = require('./Group/sender-key-name')
+const sender_key_record_1 = require('./Group/sender-key-record')
+const Group_1 = require('./Group')
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth)
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid)
+            const cipher = new Group_1.GroupCipher(storage, senderName)
+            return cipher.decrypt(msg)
+        },
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new Group_1.GroupSessionBuilder(storage)
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message')
+            }
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
+            const senderMsg = new Group_1.SenderKeyDistributionMessage(
+                null,
+                null,
+                null,
+                null,
+                item.axolotlSenderKeyDistributionMessage
+            )
+            const senderNameStr = senderName.toString()
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [
+                senderNameStr
+            ])
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+            }
+            await builder.process(senderName, senderMsg)
+        },
+        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
+                default:
+                    throw new Error(`Unknown message type: ${type}`)
+            }
+            return result
+        },
+        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') }
+        },
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId)
+            const builder = new Group_1.GroupSessionBuilder(storage)
+            const senderNameStr = senderName.toString()
+            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [
+                senderNameStr
+            ])
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName)
+            const session = new Group_1.GroupCipher(storage, senderName)
+            const ciphertext = await session.encrypt(data)
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+            }
+        },
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
+            await cipher.initOutgoing(session)
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString()
+        }
+    }
+}
+const jidToSignalProtocolAddress = (jid) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(jid)
+    return new libsignal.ProtocolAddress(user, device || 0)
+}
+const jidToSignalSenderKeyName = (group, user) => {
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
+}
+function signalStorage({ creds, keys }) {
+    return {
+        loadSession: async (id) => {
+            const { [id]: sess } = await keys.get('session', [id])
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess)
+            }
+        },
+        storeSession: async (id, session) => {
+            await keys.set({ session: { [id]: session.serialize() } })
+        },
+        isTrustedIdentity: () => {
+            return true
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString()
+            const { [keyId]: key } = await keys.get('pre-key', [keyId])
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                }
+            }
+        },
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            }
+        },
+        loadSenderKey: async (senderKeyName) => {
+            const keyId = senderKeyName.toString()
+            const { [keyId]: key } = await keys.get('sender-key', [keyId])
+            if (key) {
+                return sender_key_record_1.SenderKeyRecord.deserialize(key)
+            }
+            return new sender_key_record_1.SenderKeyRecord()
+        },
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString()
+            const serialized = JSON.stringify(key.serialize())
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } })
+        },
+        getOurRegistrationId: () => creds.registrationId,
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+            }
+        }
+    }
+}

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,267 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.LIDMappingStore = void 0
+
+const WABinary_1 = require('../WABinary/jid-utils')
+
+const CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000
+const CACHE_MAX_ENTRIES = 5000
+
+const isPnJid = (jid) => typeof jid === 'string' && jid.endsWith('@s.whatsapp.net')
+const isLidJid = (jid) => typeof jid === 'string' && jid.endsWith('@lid')
+
+/**
+ * Small TTL + size capped cache (keeps this module free of extra dependencies)
+ */
+class TtlCache {
+    constructor(ttl, max) {
+        this.ttl = ttl
+        this.max = max
+        this.map = new Map()
+    }
+    get(key) {
+        const hit = this.map.get(key)
+        if (!hit) return undefined
+        if (hit.exp < Date.now()) {
+            this.map.delete(key)
+            return undefined
+        }
+        hit.exp = Date.now() + this.ttl
+        return hit.value
+    }
+    set(key, value) {
+        if (this.map.size >= this.max) {
+            const oldest = this.map.keys().next().value
+            this.map.delete(oldest)
+        }
+        this.map.set(key, { value, exp: Date.now() + this.ttl })
+    }
+    clear() {
+        this.map.clear()
+    }
+}
+
+/**
+ * Stores PN <-> LID user mappings in the auth key store ('lid-mapping').
+ * Purely additive: nothing in the decode / send / session path depends on it.
+ */
+class LIDMappingStore {
+    /**
+     * @param keys SignalKeyStore (with transaction capability)
+     * @param logger pino logger
+     * @param pnToLIDFunc optional (jids: string[]) => Promise<{ pn, lid }[]> used when a mapping is unknown
+     */
+    constructor(keys, logger, pnToLIDFunc) {
+        this.keys = keys
+        this.logger = logger
+        this.pnToLIDFunc = pnToLIDFunc
+        this.cache = new TtlCache(CACHE_TTL_MS, CACHE_MAX_ENTRIES)
+        this.inflightLID = new Map()
+        this.inflightPN = new Map()
+    }
+
+    /** Store one or more { lid, pn } pairs. Invalid pairs are skipped, never thrown. */
+    async storeLIDPNMappings(pairs) {
+        if (!Array.isArray(pairs) || pairs.length === 0) return
+
+        const valid = []
+        for (const { lid, pn } of pairs) {
+            if (!((isLidJid(lid) && isPnJid(pn)) || (isPnJid(lid) && isLidJid(pn)))) {
+                this.logger?.warn?.(`Invalid LID-PN mapping: ${lid}, ${pn}`)
+                continue
+            }
+            const lidDecoded = (0, WABinary_1.jidDecode)(isLidJid(lid) ? lid : pn)
+            const pnDecoded = (0, WABinary_1.jidDecode)(isPnJid(pn) ? pn : lid)
+            if (!lidDecoded || !pnDecoded) continue
+            valid.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user })
+        }
+        if (valid.length === 0) return
+
+        const missing = []
+        const known = new Map()
+        for (const { pnUser } of valid) {
+            const cached = this.cache.get(`pn:${pnUser}`)
+            if (cached) known.set(pnUser, cached)
+            else missing.push(pnUser)
+        }
+        if (missing.length) {
+            const stored = await this.keys.get('lid-mapping', [...new Set(missing)])
+            for (const pnUser of new Set(missing)) {
+                const lidUser = stored?.[pnUser]
+                if (lidUser) {
+                    known.set(pnUser, lidUser)
+                    this.cache.set(`pn:${pnUser}`, lidUser)
+                    this.cache.set(`lid:${lidUser}`, pnUser)
+                }
+            }
+        }
+
+        const batch = {}
+        const toCache = []
+        for (const { pnUser, lidUser } of valid) {
+            if (known.get(pnUser) === lidUser) continue
+            batch[pnUser] = lidUser
+            batch[`${lidUser}_reverse`] = pnUser
+            toCache.push([pnUser, lidUser])
+        }
+        if (Object.keys(batch).length === 0) return
+
+        await this.keys.transaction(async () => {
+            await this.keys.set({ 'lid-mapping': batch })
+        }, 'lid-mapping')
+
+        for (const [pnUser, lidUser] of toCache) {
+            this.cache.set(`pn:${pnUser}`, lidUser)
+            this.cache.set(`lid:${lidUser}`, pnUser)
+        }
+    }
+
+    async getLIDForPN(pn) {
+        const res = await this.getLIDsForPNs([pn])
+        return (res && res[0] && res[0].lid) || null
+    }
+
+    async getLIDsForPNs(pns) {
+        if (!Array.isArray(pns) || pns.length === 0) return null
+        const cacheKey = [...new Set(pns)].sort().join(',')
+        const inflight = this.inflightLID.get(cacheKey)
+        if (inflight) return inflight
+        const promise = this._getLIDsForPNs(pns)
+        this.inflightLID.set(cacheKey, promise)
+        try {
+            return await promise
+        } finally {
+            this.inflightLID.delete(cacheKey)
+        }
+    }
+
+    async _getLIDsForPNs(pns) {
+        const out = {}
+        const pending = []
+        const usyncFetch = new Map()
+
+        const resolve = (pn, decoded, lidUser) => {
+            if (!lidUser) return false
+            const device = decoded.device ? `:${decoded.device}` : ''
+            out[pn] = { lid: `${lidUser}${device}@lid`, pn }
+            return true
+        }
+
+        for (const pn of pns) {
+            if (!isPnJid(pn)) continue
+            const decoded = (0, WABinary_1.jidDecode)(pn)
+            if (!decoded) continue
+            const cached = this.cache.get(`pn:${decoded.user}`)
+            if (cached) resolve(pn, decoded, cached)
+            else pending.push({ pn, decoded })
+        }
+
+        if (pending.length) {
+            const users = [...new Set(pending.map((p) => p.decoded.user))]
+            const stored = await this.keys.get('lid-mapping', users)
+            for (const user of users) {
+                const lidUser = stored?.[user]
+                if (lidUser && typeof lidUser === 'string') {
+                    this.cache.set(`pn:${user}`, lidUser)
+                    this.cache.set(`lid:${lidUser}`, user)
+                }
+            }
+            for (const { pn, decoded } of pending) {
+                const cached = this.cache.get(`pn:${decoded.user}`)
+                if (cached) {
+                    resolve(pn, decoded, cached)
+                } else {
+                    const normalized = (0, WABinary_1.jidNormalizedUser)(pn)
+                    if (!usyncFetch.has(normalized)) usyncFetch.set(normalized, [])
+                    usyncFetch.get(normalized).push(decoded.device || 0)
+                }
+            }
+        }
+
+        if (usyncFetch.size > 0 && this.pnToLIDFunc) {
+            try {
+                const result = await this.pnToLIDFunc([...usyncFetch.keys()])
+                if (result && result.length) {
+                    await this.storeLIDPNMappings(result)
+                    for (const pair of result) {
+                        const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn)
+                        const lidDecoded = (0, WABinary_1.jidDecode)(pair.lid)
+                        if (!pnDecoded || !lidDecoded) continue
+                        for (const device of usyncFetch.get(pair.pn) || [0]) {
+                            const suffix = device ? `:${device}` : ''
+                            const pnJid = `${pnDecoded.user}${suffix}@s.whatsapp.net`
+                            out[pnJid] = { lid: `${lidDecoded.user}${suffix}@lid`, pn: pnJid }
+                        }
+                    }
+                }
+            } catch (err) {
+                // lookup is best effort, never break the caller
+                this.logger?.warn?.({ err }, 'LID lookup via usync failed')
+            }
+        }
+
+        const values = Object.values(out)
+        return values.length ? values : null
+    }
+
+    async getPNForLID(lid) {
+        const res = await this.getPNsForLIDs([lid])
+        return (res && res[0] && res[0].pn) || null
+    }
+
+    async getPNsForLIDs(lids) {
+        if (!Array.isArray(lids) || lids.length === 0) return null
+        const cacheKey = [...new Set(lids)].sort().join(',')
+        const inflight = this.inflightPN.get(cacheKey)
+        if (inflight) return inflight
+        const promise = this._getPNsForLIDs(lids)
+        this.inflightPN.set(cacheKey, promise)
+        try {
+            return await promise
+        } finally {
+            this.inflightPN.delete(cacheKey)
+        }
+    }
+
+    async _getPNsForLIDs(lids) {
+        const out = {}
+        const pending = []
+
+        const resolve = (lid, decoded, pnUser) => {
+            if (!pnUser || typeof pnUser !== 'string') return false
+            const device = decoded.device ? `:${decoded.device}` : ''
+            out[lid] = { lid, pn: `${pnUser}${device}@s.whatsapp.net` }
+            return true
+        }
+
+        for (const lid of lids) {
+            if (!isLidJid(lid)) continue
+            const decoded = (0, WABinary_1.jidDecode)(lid)
+            if (!decoded) continue
+            const cached = this.cache.get(`lid:${decoded.user}`)
+            if (cached) resolve(lid, decoded, cached)
+            else pending.push({ lid, decoded })
+        }
+
+        if (pending.length) {
+            const reverseKeys = [...new Set(pending.map((p) => `${p.decoded.user}_reverse`))]
+            const stored = await this.keys.get('lid-mapping', reverseKeys)
+            for (const { lid, decoded } of pending) {
+                const pnUser = stored?.[`${decoded.user}_reverse`]
+                if (pnUser && typeof pnUser === 'string') {
+                    this.cache.set(`lid:${decoded.user}`, pnUser)
+                    this.cache.set(`pn:${pnUser}`, decoded.user)
+                    resolve(lid, decoded, pnUser)
+                }
+            }
+        }
+
+        const values = Object.values(out)
+        return values.length ? values : null
+    }
+
+    close() {
+        this.cache.clear()
+    }
+}
+exports.LIDMappingStore = LIDMappingStore

package/lib/Socket/Client/abstract-socket-client.js

@@ -0,0 +1,13 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.AbstractSocketClient = void 0
+const events_1 = require('events')
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super()
+        this.url = url
+        this.config = config
+        this.setMaxListeners(0)
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient

package/lib/Socket/Client/index.js

@@ -0,0 +1,32 @@
+'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 __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m)
+            if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p))
+                __createBinding(exports, m, p)
+    }
+Object.defineProperty(exports, '__esModule', { value: true })
+__exportStar(require('./abstract-socket-client'), exports)
+__exportStar(require('./mobile-socket-client'), exports)
+__exportStar(require('./web-socket-client'), exports)

package/lib/Socket/Client/mobile-socket-client.js

@@ -0,0 +1,82 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.MobileSocketClient = void 0
+const net_1 = require('net')
+const abstract_socket_client_1 = require('./abstract-socket-client')
+class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments)
+        this.socket = null
+    }
+    get isOpen() {
+        var _a
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open'
+    }
+    get isClosed() {
+        var _a
+        return (
+            this.socket === null ||
+            ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed'
+        )
+    }
+    get isClosing() {
+        var _a
+        return (
+            this.socket === null ||
+            ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed'
+        )
+    }
+    get isConnecting() {
+        var _a
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening'
+    }
+    async connect() {
+        var _a
+        if (this.socket) {
+            return
+        }
+        if (this.config.agent) {
+            throw new Error('There are not support for proxy agent for mobile connection')
+        } else {
+            this.socket = (0, net_1.connect)({
+                host: this.url.hostname,
+                port: Number(this.url.port) || 443
+            })
+        }
+        this.socket.setMaxListeners(0)
+        const events = [
+            'close',
+            'connect',
+            'data',
+            'drain',
+            'end',
+            'error',
+            'lookup',
+            'ready',
+            'timeout'
+        ]
+        for (const event of events) {
+            ;(_a = this.socket) === null || _a === void 0
+                ? void 0
+                : _a.on(event, (...args) => this.emit(event, ...args))
+        }
+        this.socket.on('data', (...args) => this.emit('message', ...args))
+        this.socket.on('ready', (...args) => this.emit('open', ...args))
+    }
+    async close() {
+        if (!this.socket) {
+            return
+        }
+        return new Promise((resolve) => {
+            this.socket.end(resolve)
+            this.socket = null
+        })
+    }
+    send(str, cb) {
+        if (this.socket === null) {
+            return false
+        }
+        return this.socket.write(str, undefined, cb)
+    }
+}
+exports.MobileSocketClient = MobileSocketClient