@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Utils/signal.js

@@ -0,0 +1,167 @@
+import { KEY_BUNDLE_TYPE } from '../Defaults/index.js'
+import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js'
+import { Curve, generateSignalPubKey } from './crypto.js'
+import { encodeBigEndian } from './generics.js'
+
+const chunk = (array, size) => {
+    const chunks = []
+    for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size))
+    return chunks
+}
+
+export const createSignalIdentity = (wid, accountSignatureKey) => ({
+    identifier: { name: wid, deviceId: 0 },
+    identifierKey: generateSignalPubKey(accountSignatureKey),
+})
+
+export const getPreKeys = async ({ get }, min, limit) => {
+    const idList = []
+    for (let id = min; id < limit; id++) idList.push(id.toString())
+    return get('pre-key', idList)
+}
+
+export const generateOrGetPreKeys = (creds, range) => {
+    const available = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
+    const remaining = range - available
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1
+    const newPreKeys = {}
+    if (remaining > 0) {
+        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) newPreKeys[i] = Curve.generateKeyPair()
+    }
+    return { newPreKeys, lastPreKeyId, preKeysRange: [creds.firstUnuploadedPreKeyId, range] }
+}
+
+export const xmppSignedPreKey = key => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature },
+    ],
+})
+
+export const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public },
+    ],
+})
+
+const isValidUInt = n => typeof n === 'number' && Number.isInteger(n) && n >= 0
+
+export const extractE2ESessionFromRetryReceipt = receipt => {
+    const keysNode = getBinaryNodeChild(receipt, 'keys')
+    if (!keysNode) return null
+
+    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type')
+    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0]) return null
+
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity')
+    const skey = getBinaryNodeChild(keysNode, 'skey')
+    if (!identity || identity.length !== 32 || !skey) return null
+
+    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4)
+    if (!isValidUInt(registrationId)) return null
+
+    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value')
+    const signedSig = getBinaryNodeChildBuffer(skey, 'signature')
+    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3)
+    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) return null
+
+    const preKeyNode = getBinaryNodeChild(keysNode, 'key')
+    let preKey
+    if (preKeyNode) {
+        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value')
+        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3)
+        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) return null
+        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) }
+    }
+
+    return {
+        registrationId,
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: { keyId: signedKeyId, publicKey: generateSignalPubKey(signedPubKey), signature: signedSig },
+        preKey,
+    }
+}
+
+export const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = key => key ? {
+        keyId: getBinaryNodeChildUInt(key, 'id', 3),
+        publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+        signature: getBinaryNodeChildBuffer(key, 'signature'),
+    } : undefined
+
+    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user').filter(node => {
+        try { assertNodeErrorFree(node); return true } catch { return false }
+    })
+
+    for (const nodesChunk of chunk(nodes, 100)) {
+        await Promise.all(nodesChunk.map(node => repository.injectE2ESession({
+            jid: node.attrs.jid,
+            session: {
+                registrationId: getBinaryNodeChildUInt(node, 'registration', 4),
+                identityKey: generateSignalPubKey(getBinaryNodeChildBuffer(node, 'identity')),
+                signedPreKey: extractKey(getBinaryNodeChild(node, 'skey')),
+                preKey: extractKey(getBinaryNodeChild(node, 'key')),
+            },
+        })))
+        await new Promise(resolve => setImmediate(resolve)) // yield between chunks to avoid blocking on large batches
+    }
+}
+
+export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = jidDecode(myJid)
+    const extracted = []
+    for (const { devices, id } of result) {
+        const decoded = jidDecode(id)
+        const { user, server } = decoded
+        let { domainType } = decoded
+        const deviceList = devices?.deviceList
+        if (!Array.isArray(deviceList)) continue
+        for (const { id: device, keyIndex, isHosted } of deviceList) {
+            if ((!excludeZeroDevices || device !== 0) &&
+                ((myUser !== user && myLid !== user) || myDevice !== device) &&
+                (device === 0 || !!keyIndex)) {
+                if (isHosted) domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED
+                extracted.push({ user, device, domainType, server: getServerFromDomainType(server, domainType) })
+            }
+        }
+    }
+    return extracted
+}
+
+export const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count)
+    await keys.set({ 'pre-key': newPreKeys })
+    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1])
+    return {
+        update: {
+            nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+            firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1),
+        },
+        preKeys,
+    }
+}
+
+export const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state
+    const { update, preKeys } = await getNextPreKeys(state, count)
+    return {
+        update,
+        node: {
+            tag: 'iq',
+            attrs: { xmlns: 'encrypt', type: 'set', to: S_WHATSAPP_NET },
+            content: [
+                { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
+                { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+                { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+                { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
+                xmppSignedPreKey(creds.signedPreKey),
+            ],
+        },
+    }
+}

package/lib/Utils/spam-report-utils.js

@@ -0,0 +1,142 @@
+import { getBinaryNodeChild, getBinaryNodeChildString, isLidUser, isHostedLidUser, S_WHATSAPP_NET } from '../WABinary/index.js'
+import { extractMessageContent } from './messages.js'
+
+export const SPAM_FLOWS = {
+    ACCOUNT_INFO_REPORT: 'account_info_report',
+    ACCOUNT_INFO_BLOCK: 'account_info_block',
+    ONE_TO_ONE_SPAM_BANNER_REPORT: '1_1_spam_banner_report',
+    MESSAGE_MENU: 'message_menu',
+    OVERFLOW_MENU_REPORT: 'overflow_menu_report',
+}
+
+const toBuffer = data => {
+    if (!data) return null
+    if (Buffer.isBuffer(data)) return data
+    if (data instanceof Uint8Array) return Buffer.from(data)
+    if (typeof data === 'string') return Buffer.from(data, 'base64')
+    return null
+}
+
+export const resolveReportJid = async (jid, lidMapping) => {
+    if (!jid) throw new Error('reportSpam: jid required')
+    if (isLidUser(jid) || isHostedLidUser(jid)) return jid
+    if (lidMapping?.getLIDForPN) {
+        const lid = await lidMapping.getLIDForPN(jid)
+        if (lid) return lid
+    }
+    return jid
+}
+
+export const normalizeReportingTag = tag => {
+    const buf = toBuffer(tag)
+    return buf?.length ? buf : null
+}
+
+export const extractMessageText = msg => {
+    if (!msg?.message) return ''
+    const content = extractMessageContent(msg.message)
+    if (!content) return ''
+    if (typeof content.conversation === 'string') return content.conversation
+    if (content.extendedTextMessage?.text) return content.extendedTextMessage.text
+    if (content.imageMessage?.caption) return content.imageMessage.caption
+    if (content.videoMessage?.caption) return content.videoMessage.caption
+    return ''
+}
+
+export const extractReportingInfoFromStanza = stanza => {
+    const reporting = getBinaryNodeChild(stanza, 'reporting')
+    if (!reporting) return null
+
+    let tagNode = getBinaryNodeChild(reporting, 'reporting_tag')
+    if (!tagNode) {
+        const validation = getBinaryNodeChild(reporting, 'reporting_validation')
+        tagNode = validation ? getBinaryNodeChild(validation, 'reporting_tag') : undefined
+    }
+    if (!tagNode) return null
+
+    const raw = tagNode.content
+    const reportingTag = toBuffer(
+        raw instanceof Uint8Array || Buffer.isBuffer(raw) ? raw
+            : typeof raw === 'string' ? raw
+                : null
+    )
+    if (!reportingTag?.length) return null
+
+    const stanzaId = tagNode.attrs?.id || stanza.attrs?.id
+    if (!stanzaId) return null
+
+    const tsRaw = tagNode.attrs?.ts_s || stanza.attrs?.t
+    return { stanzaId, timestamp: tsRaw ? Number(tsRaw) : 0, reportingTag }
+}
+
+export const buildSpamReportMessageNodes = messages => messages.slice(0, 5).map(m => {
+    const reportingTag = normalizeReportingTag(m.reportingTag)
+    if (!reportingTag) throw new Error(`reportSpam: missing reportingTag for ${m.stanzaId}`)
+    return {
+        tag: 'message',
+        attrs: {
+            t: String(m.timestamp),
+            id: m.stanzaId,
+            reported_push_name: m.pushName || '',
+            type: m.messageType || 'text',
+            from: m.fromJid,
+        },
+        content: [
+            {
+                tag: 'raw',
+                attrs: { local_message_type: '0', v: '2' },
+                content: m.text ?? '',
+            },
+            {
+                tag: 'reporting',
+                attrs: {},
+                content: [{
+                    tag: 'reporting_validation',
+                    attrs: {},
+                    content: [{
+                        tag: 'reporting_tag',
+                        attrs: { id: m.stanzaId, ts_s: String(m.timestamp) },
+                        content: reportingTag,
+                    }],
+                }],
+            },
+        ],
+    }
+})
+
+export const buildSpamReportIq = (jid, messages, spamFlow = SPAM_FLOWS.ACCOUNT_INFO_REPORT) => {
+    if (!messages?.length) throw new Error('reportSpam: at least one message with reporting_tag required')
+    return {
+        tag: 'iq',
+        attrs: { type: 'set', xmlns: 'spam', to: S_WHATSAPP_NET },
+        content: [{
+            tag: 'spam_list',
+            attrs: { jid, spam_flow: spamFlow },
+            content: buildSpamReportMessageNodes(messages),
+        }],
+    }
+}
+
+export const parseSpamReportResponse = result => {
+    if (!result) return { success: false, error: 'empty response' }
+    if (result.attrs?.type === 'error') {
+        const errNode = getBinaryNodeChild(result, 'error')
+        const code = errNode?.attrs?.code
+        const text = errNode?.content?.toString?.() || errNode?.attrs?.text
+        return { success: false, error: `spam IQ error${code ? ` ${code}` : ''}${text ? `: ${text}` : ''}` }
+    }
+    const reportNode = getBinaryNodeChild(result, 'report')
+    const reportId = reportNode?.attrs?.id || getBinaryNodeChildString(reportNode, 'id')
+    if (reportId) return { success: true, reportId: String(reportId) }
+    if (result.attrs?.type === 'result') return { success: true }
+    return { success: false, error: 'unexpected spam IQ response' }
+}
+
+export const buildSimpleReportNode = (jid, messageKeys) => ({
+    tag: 'report',
+    attrs: { jid, type: 'spam' },
+    content: (messageKeys || []).map(key => ({
+        tag: 'message',
+        attrs: { id: key.id || key, from: key.fromMe ? undefined : jid },
+    })),
+})

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,33 @@
+import { isLidUser, isPnUser } from '../WABinary/index.js'
+
+export const processContactAction = (action, id, logger) => {
+    const results = []
+    if (!id) {
+        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index')
+        return results
+    }
+    const lidJid = action.lidJid
+    const idIsPn = isPnUser(id)
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined
+    results.push({
+        event: 'contacts.upsert',
+        data: [{
+            id,
+            name: action.fullName || action.firstName || action.username || undefined,
+            username: action.username || undefined,
+            lid: lidJid || undefined,
+            phoneNumber
+        }]
+    })
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
+        results.push({ event: 'lid-mapping.update', data: { lid: lidJid, pn: id } })
+    }
+    return results
+}
+
+export const emitSyncActionResults = (ev, results) => {
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') ev.emit('contacts.upsert', result.data)
+        else ev.emit('lid-mapping.update', result.data)
+    }
+}

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,102 @@
+import { randomBytes } from 'crypto';
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+import { unixTimestampSeconds } from './generics.js';
+import { TC_TOKEN_INDEX_KEY } from './key-store.js';
+
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days in seconds
+const TC_TOKEN_NUM_BUCKETS = 4;      // ~28-day rolling window
+
+const currentBucket = () => Math.floor(Math.floor(Date.now() / 1000) / TC_TOKEN_BUCKET_DURATION);
+const generateTcToken = () => Buffer.concat([Buffer.from([0x04, 0x01, (Math.floor(unixTimestampSeconds() / TC_TOKEN_BUCKET_DURATION) - 2900) & 0xff]), randomBytes(8)]);
+
+export const isRegularUser = jid => {
+    if (!jid) return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0' || BOT_PHONE_REGEX.test(user) || isJidMetaAI(jid)) return false;
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+};
+
+export const isTcTokenExpired = timestamp => {
+    if (timestamp == null) return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    return isNaN(ts) || ts < (currentBucket() - (TC_TOKEN_NUM_BUCKETS - 1)) * TC_TOKEN_BUCKET_DURATION;
+};
+
+export const shouldSendNewTcToken = senderTimestamp => {
+    if (senderTimestamp === undefined) return true;
+    return currentBucket() > Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+};
+
+export const resolveTcTokenJid = async (jid, getLIDForPN) => isLidUser(jid) ? jid : (await getLIDForPN(jid) || null);
+
+export const resolveIssuanceJid = async (jid, issueToLid, getLIDForPN, getPNForLID) => {
+    if (issueToLid) return isLidUser(jid) ? jid : (await getLIDForPN(jid)) ?? jid;
+    if (!isLidUser(jid)) return jid;
+    return getPNForLID ? (await getPNForLID(jid)) ?? jid : jid;
+};
+
+export const readTcTokenIndex = async keys => {
+    for (const key of [TC_TOKEN_INDEX_KEY, 'index']) {
+        const entry = (await keys.get('tctoken', [key]))[key];
+        if (!entry?.token?.length) continue;
+        try {
+            const parsed = JSON.parse(Buffer.from(entry.token).toString());
+            if (!Array.isArray(parsed)) continue;
+            return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY && j !== 'index');
+        } catch { continue; }
+    }
+    return [];
+};
+
+export const buildMergedTcTokenIndexWrite = async (keys, addedJids) => {
+    const merged = new Set(await readTcTokenIndex(keys));
+    for (const jid of addedJids) if (jid && jid !== TC_TOKEN_INDEX_KEY && jid !== 'index') merged.add(jid);
+    return { [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) } };
+};
+
+export const preSeedTcToken = async ({ authState, jid, getLIDForPN, logger }) => {
+    const tcTokenJid = await resolveTcTokenJid(jid, getLIDForPN);
+    const existing = await authState.keys.get('tctoken', [tcTokenJid]);
+    if (existing[tcTokenJid]?.token?.length) return { token: existing[tcTokenJid].token, storageJid: tcTokenJid };
+    const token = generateTcToken();
+    const timestamp = String(unixTimestampSeconds());
+    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid]);
+    await authState.keys.set({ tctoken: { [tcTokenJid]: { ...(existing[tcTokenJid] || {}), token, timestamp }, ...indexWrite } });
+    logger?.debug({ jid, tcTokenJid }, 'pre-seeded locally generated tctoken');
+    return { token, storageJid: tcTokenJid };
+};
+
+export const buildTcTokenFromJid = async ({ authState, jid, baseContent = [], getLIDForPN }) => {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const entry = (await authState.keys.get('tctoken', [storageJid]))?.[storageJid];
+        const { token: tcTokenBuffer, timestamp, senderTimestamp } = entry ?? {};
+        if (!tcTokenBuffer?.length || timestamp === undefined || isTcTokenExpired(timestamp)) {
+            if (tcTokenBuffer) {
+                const cleared = senderTimestamp !== undefined ? { token: Buffer.alloc(0), senderTimestamp } : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({ tag: 'tctoken', attrs: { t: String(timestamp) }, content: tcTokenBuffer });
+        return baseContent;
+    } catch { return baseContent.length > 0 ? baseContent : undefined; }
+};
+
+export const storeTcTokensFromIqResult = async ({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) => {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode) return;
+    for (const tokenNode of getBinaryNodeChildren(tokensNode, 'token')) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) continue;
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid)) continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingEntry = (await keys.get('tctoken', [storageJid]))[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        if (!incomingTs || (existingTs > 0 && existingTs > incomingTs)) continue;
+        await keys.set({ tctoken: { [storageJid]: { ...existingEntry, token: Buffer.from(tokenNode.content), timestamp: tokenNode.attrs.t } } });
+        onNewJidStored?.(storageJid);
+    }
+};