@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/signal.js

@@ -0,0 +1,188 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getNextPreKeysNode =
+    exports.getNextPreKeys =
+    exports.extractDeviceJids =
+    exports.parseAndInjectE2ESessions =
+    exports.xmppPreKey =
+    exports.xmppSignedPreKey =
+    exports.generateOrGetPreKeys =
+    exports.getPreKeys =
+    exports.createSignalIdentity =
+        void 0
+const Defaults_1 = require('../Defaults')
+const WABinary_1 = require('../WABinary')
+const crypto_1 = require('./crypto')
+const lodash_1 = require('lodash')
+const generics_1 = require('./generics')
+const createSignalIdentity = (wid, accountSignatureKey) => {
+    return {
+        identifier: { name: wid, deviceId: 0 },
+        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
+    }
+}
+exports.createSignalIdentity = createSignalIdentity
+const getPreKeys = async ({ get }, min, limit) => {
+    const idList = []
+    for (let id = min; id < limit; id++) {
+        idList.push(id.toString())
+    }
+    return get('pre-key', idList)
+}
+exports.getPreKeys = getPreKeys
+const generateOrGetPreKeys = (creds, range) => {
+    const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId
+    const remaining = range - avaliable
+    const lastPreKeyId = creds.nextPreKeyId + remaining - 1
+    const newPreKeys = {}
+    if (remaining > 0) {
+        for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
+            newPreKeys[i] = crypto_1.Curve.generateKeyPair()
+        }
+    }
+    return {
+        newPreKeys,
+        lastPreKeyId,
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+    }
+}
+exports.generateOrGetPreKeys = generateOrGetPreKeys
+const xmppSignedPreKey = (key) => ({
+    tag: 'skey',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
+        { tag: 'value', attrs: {}, content: key.keyPair.public },
+        { tag: 'signature', attrs: {}, content: key.signature }
+    ]
+})
+exports.xmppSignedPreKey = xmppSignedPreKey
+const xmppPreKey = (pair, id) => ({
+    tag: 'key',
+    attrs: {},
+    content: [
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
+        { tag: 'value', attrs: {}, content: pair.public }
+    ]
+})
+exports.xmppPreKey = xmppPreKey
+const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) =>
+        key
+            ? {
+                  keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
+                  publicKey: crypto_1.generateSignalPubKey(
+                      WABinary_1.getBinaryNodeChildBuffer(key, 'value')
+                  ),
+                  signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
+              }
+            : undefined
+    const nodes = WABinary_1.getBinaryNodeChildren(
+        WABinary_1.getBinaryNodeChild(node, 'list'),
+        'user'
+    )
+    for (const node of nodes) {
+        WABinary_1.assertNodeErrorFree(node)
+    }
+    // Most of the work in repository.injectE2ESession is CPU intensive, not IO
+    // So Promise.all doesn't really help here,
+    // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
+    // This way we chunk it in smaller parts and between those parts we can yield to the event loop
+    // It's rare case when you need to E2E sessions for so many users, but it's possible
+    const chunkSize = 100
+    const chunks = lodash_1.chunk(nodes, chunkSize)
+    for (const nodesChunk of chunks) {
+        await Promise.all(
+            nodesChunk.map(async (node) => {
+                const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
+                const key = WABinary_1.getBinaryNodeChild(node, 'key')
+                const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
+                const jid = node.attrs.jid
+                const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
+                await repository.injectE2ESession({
+                    jid,
+                    session: {
+                        registrationId: registrationId,
+                        identityKey: crypto_1.generateSignalPubKey(identity),
+                        signedPreKey: extractKey(signedKey),
+                        preKey: extractKey(key)
+                    }
+                })
+            })
+        )
+    }
+}
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+    const extracted = []
+    for (const userResult of result) {
+        const { devices, id } = userResult
+        const { user } = WABinary_1.jidDecode(id)
+        const deviceList = devices?.deviceList
+        if (Array.isArray(deviceList)) {
+            for (const { id: device, keyIndex } of deviceList) {
+                if (
+                    (!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+                    (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
+                    (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+                ) {
+                    extracted.push({ user, device })
+                }
+            }
+        }
+    }
+    return extracted
+}
+exports.extractDeviceJids = extractDeviceJids
+/**
+ * get the next N keys for upload or processing
+ * @param count number of pre-keys to get or generate
+ */
+const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(
+        creds,
+        count
+    )
+    const update = {
+        nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
+        firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
+    }
+    await keys.set({ 'pre-key': newPreKeys })
+    const preKeys = await (0, exports.getPreKeys)(
+        keys,
+        preKeysRange[0],
+        preKeysRange[0] + preKeysRange[1]
+    )
+    return { update, preKeys }
+}
+exports.getNextPreKeys = getNextPreKeys
+const getNextPreKeysNode = async (state, count) => {
+    const { creds } = state
+    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count)
+    const node = {
+        tag: 'iq',
+        attrs: {
+            xmlns: 'encrypt',
+            type: 'set',
+            to: WABinary_1.S_WHATSAPP_NET
+        },
+        content: [
+            {
+                tag: 'registration',
+                attrs: {},
+                content: (0, generics_1.encodeBigEndian)(creds.registrationId)
+            },
+            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
+            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+            {
+                tag: 'list',
+                attrs: {},
+                content: Object.keys(preKeys).map((k) => (0, exports.xmppPreKey)(preKeys[+k], +k))
+            },
+            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
+        ]
+    }
+    return { update, node }
+}
+exports.getNextPreKeysNode = getNextPreKeysNode

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,38 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    }
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString()
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient
+    }
+    // WA Web always includes type when present: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId
+    }
+    return stanza
+}
+//# sourceMappingURL=stanza-ack.js.map

package/lib/Utils/state-manager.js

@@ -0,0 +1,91 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+exports.state_manager = void 0
+
+/**
+ * @file state-manager.js
+ * @description Debounced file-based persistence for anti-ban state
+ *   (known chats, warmup progress, health stats, etc). Writes are
+ *   debounced 5s after each send to avoid disk I/O overhead, but can
+ *   be flushed immediately after critical health events (ban/restriction).
+ * @author Denzy ZeroDay
+ */
+
+const fs = require('fs')
+
+const KNOWN_CHATS_MAX = 1000
+const DEBOUNCE_MS = 5000
+
+class state_manager {
+    constructor(file_path) {
+        this.path = file_path
+        this.debounce_timer = null
+    }
+
+    /** Load persisted state from disk. Returns null if missing/corrupt/wrong version. */
+    load() {
+        try {
+            const raw = fs.readFileSync(this.path, 'utf-8')
+            const parsed = JSON.parse(raw)
+            if (parsed.version !== 3) {
+                process.stderr.write('[bilis-antiban] WARN: corrupt state file or version mismatch, starting fresh\n')
+                return null
+            }
+            return parsed
+        } catch {
+            if (fs.existsSync(this.path)) {
+                process.stderr.write('[bilis-antiban] WARN: corrupt state file, starting fresh\n')
+            }
+            return null
+        }
+    }
+
+    /** Debounced save — call after every send (5s delay before actual write) */
+    save_debounced(state) {
+        if (this.debounce_timer) clearTimeout(this.debounce_timer)
+        this.debounce_timer = setTimeout(() => {
+            this.write_file(state)
+            this.debounce_timer = null
+        }, DEBOUNCE_MS)
+    }
+
+    /** Immediate save — call after critical health events (ban/restriction) */
+    save_immediate(state) {
+        if (this.debounce_timer) {
+            clearTimeout(this.debounce_timer)
+            this.debounce_timer = null
+        }
+        this.write_file(state)
+    }
+
+    /** Flush/cancel pending debounced write (for tests and process exit) */
+    flush() {
+        if (this.debounce_timer) {
+            clearTimeout(this.debounce_timer)
+            this.debounce_timer = null
+        }
+    }
+
+    destroy() {
+        this.flush()
+    }
+
+    write_file(state) {
+        const to_save = {
+            ...state,
+            savedAt: Date.now(),
+            // LRU eviction: keep last KNOWN_CHATS_MAX entries
+            knownChats: state.knownChats.length > KNOWN_CHATS_MAX
+                ? state.knownChats.slice(-KNOWN_CHATS_MAX)
+                : state.knownChats
+        }
+        try {
+            fs.writeFileSync(this.path, JSON.stringify(to_save, null, 2), 'utf-8')
+        } catch (err) {
+            process.stderr.write(`[bilis-antiban] WARN: failed to write state to ${this.path}: ${err}\n`)
+        }
+    }
+}
+
+exports.state_manager = state_manager
+module.exports = { state_manager }

package/lib/Utils/status-posting.d.ts

@@ -0,0 +1,81 @@
+import type { AnyMessageContent } from '../Types'
+
+export type StatusType = 'text' | 'image' | 'video' | 'audio'
+
+export interface TextStatusOptions {
+    text: string
+    backgroundColor?: string
+    font?: number
+    textColor?: string
+}
+
+export interface MediaStatusOptions {
+    media: Buffer | string
+    caption?: string
+    viewOnce?: boolean
+}
+
+export interface StatusPostResult {
+    messageId: string
+    timestamp: Date
+    type: StatusType
+}
+
+/** Pre-defined background colors for text status */
+export declare const STATUS_BACKGROUNDS: {
+    solid: {
+        green: string
+        blue: string
+        purple: string
+        red: string
+        orange: string
+        yellow: string
+        pink: string
+        teal: string
+        gray: string
+        black: string
+        white: string
+    }
+    gradient: {
+        sunset: string[]
+        ocean: string[]
+        forest: string[]
+        purple: string[]
+        midnight: string[]
+        aurora: string[]
+    }
+}
+
+/** Font types for text status (0-9) */
+export declare const STATUS_FONTS: {
+    readonly SANS_SERIF: 0
+    readonly SERIF: 1
+    readonly NORICAN: 2
+    readonly BRYNDAN: 3
+    readonly BEBASNEUE: 4
+    readonly OSWALD: 5
+    readonly DAMION: 6
+    readonly DANCING: 7
+    readonly COMFORTAA: 8
+    readonly EXOTWO: 9
+}
+
+export declare const generateStatusMessageId: () => string
+
+export declare const createTextStatus: (options: TextStatusOptions) => AnyMessageContent
+export declare const createImageStatus: (media: Buffer | string, options?: { caption?: string; viewOnce?: boolean }) => AnyMessageContent
+export declare const createVideoStatus: (media: Buffer | string, options?: { caption?: string; viewOnce?: boolean; gifPlayback?: boolean }) => AnyMessageContent
+export declare const createAudioStatus: (media: Buffer | string, options?: { ptt?: boolean }) => AnyMessageContent
+
+export declare const STATUS_BROADCAST_JID = "status@broadcast"
+export declare const getStatusJid: () => string
+
+export declare const StatusHelper: {
+    text: (text: string, backgroundColor?: string) => AnyMessageContent
+    image: (buffer: Buffer, caption?: string) => AnyMessageContent
+    imageUrl: (url: string, caption?: string) => AnyMessageContent
+    video: (buffer: Buffer, caption?: string) => AnyMessageContent
+    videoUrl: (url: string, caption?: string) => AnyMessageContent
+    gif: (buffer: Buffer, caption?: string) => AnyMessageContent
+    voiceNote: (buffer: Buffer) => AnyMessageContent
+}

package/lib/Utils/status-posting.js

@@ -0,0 +1,187 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.StatusHelper =
+    exports.getStatusJid =
+    exports.STATUS_BROADCAST_JID =
+    exports.createAudioStatus =
+    exports.createVideoStatus =
+    exports.createImageStatus =
+    exports.createTextStatus =
+    exports.generateStatusMessageId =
+    exports.STATUS_FONTS =
+    exports.STATUS_BACKGROUNDS =
+        void 0
+
+const crypto_1 = require('crypto')
+
+/**
+ * Pre-defined background colors for text status
+ */
+exports.STATUS_BACKGROUNDS = {
+    solid: {
+        green: '#25D366',
+        blue: '#34B7F1',
+        purple: '#8B5CF6',
+        red: '#EF4444',
+        orange: '#F97316',
+        yellow: '#EAB308',
+        pink: '#EC4899',
+        teal: '#14B8A6',
+        gray: '#6B7280',
+        black: '#000000',
+        white: '#FFFFFF'
+    },
+    gradient: {
+        sunset: ['#F97316', '#EF4444'],
+        ocean: ['#3B82F6', '#06B6D4'],
+        forest: ['#22C55E', '#10B981'],
+        purple: ['#8B5CF6', '#EC4899'],
+        midnight: ['#1E3A8A', '#4C1D95'],
+        aurora: ['#06B6D4', '#8B5CF6', '#EC4899']
+    }
+}
+
+/**
+ * Font types for text status (0-9)
+ */
+exports.STATUS_FONTS = {
+    SANS_SERIF: 0,
+    SERIF: 1,
+    NORICAN: 2,
+    BRYNDAN: 3,
+    BEBASNEUE: 4,
+    OSWALD: 5,
+    DAMION: 6,
+    DANCING: 7,
+    COMFORTAA: 8,
+    EXOTWO: 9
+}
+
+/**
+ * Generate a typical WhatsApp status message ID starting with 3EB0
+ */
+const generateStatusMessageId = () => {
+    return `3EB0${(0, crypto_1.randomBytes)(16).toString('hex').toUpperCase()}`
+}
+exports.generateStatusMessageId = generateStatusMessageId
+
+/** Create text status content */
+const createTextStatus = (options) => {
+    const backgroundColor = options.backgroundColor || exports.STATUS_BACKGROUNDS.solid.green
+    const font = options.font ?? exports.STATUS_FONTS.SANS_SERIF
+    const textColor = options.textColor || '#FFFFFF'
+
+    return {
+        text: options.text,
+        backgroundColor,
+        font,
+        textColor,
+        contextInfo: {
+            mentionedJid: options.mentions || [],
+            isForwarded: false
+        }
+    }
+}
+exports.createTextStatus = createTextStatus
+
+/** Create image status content */
+const createImageStatus = (media, options) => {
+    return {
+        image: typeof media === 'string' ? { url: media } : media,
+        caption: options?.caption || ''
+    }
+}
+exports.createImageStatus = createImageStatus
+
+/** Create video status content */
+const createVideoStatus = (media, options) => {
+    return {
+        video: typeof media === 'string' ? { url: media } : media,
+        caption: options?.caption || '',
+        gifPlayback: options?.gifPlayback || false
+    }
+}
+exports.createVideoStatus = createVideoStatus
+
+/** Create audio/PTT status content */
+const createAudioStatus = (media, options) => {
+    return {
+        audio: typeof media === 'string' ? { url: media } : media,
+        ptt: true, // Status audio is always PTT style
+        mimetype: 'audio/ogg; codecs=opus',
+        waveform: options?.waveform
+    }
+}
+exports.createAudioStatus = createAudioStatus
+
+/** Status target JID */
+exports.STATUS_BROADCAST_JID = 'status@broadcast'
+
+/** Helper to return the broadcast JID */
+const getStatusJid = () => exports.STATUS_BROADCAST_JID
+exports.getStatusJid = getStatusJid
+
+/**
+ * High-level builder to create and send status messages
+ */
+exports.StatusHelper = {
+    text: (text, backgroundColor, font) =>
+        (0, exports.createTextStatus)({ text, backgroundColor, font }),
+    image: (buffer, caption) => (0, exports.createImageStatus)(buffer, { caption }),
+    imageUrl: (url, caption) => (0, exports.createImageStatus)(url, { caption }),
+    video: (buffer, caption) => (0, exports.createVideoStatus)(buffer, { caption }),
+    videoUrl: (url, caption) => (0, exports.createVideoStatus)(url, { caption }),
+    gif: (buffer, caption) =>
+        (0, exports.createVideoStatus)(buffer, { caption, gifPlayback: true }),
+    voiceNote: (buffer) => (0, exports.createAudioStatus)(buffer),
+
+    /**
+     * Helper to send status to all contacts, specific groups, or individuals.
+     * @param {import('../Socket').Socket} sock
+     * @param {AnyMessageContent} content
+     * @param {string[]} jidList List of JIDs (individuals or groups) who should see this status
+     */
+    send: async (sock, content, jidList = []) => {
+        if (!jidList || jidList.length === 0) {
+            console.warn(
+                'StatusHelper: jidList is empty. Status will potentially be visible to all contacts.'
+            )
+        }
+
+        const groups = jidList.filter((jid) => jid && jid.endsWith('@g.us'))
+        const individuals = jidList.filter(
+            (jid) => jid && (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@lid'))
+        )
+
+        let lastResult
+
+        // Handle Group Status
+        // Note: In WhatsApp, a group status is a message sent to the group JID with isGroupStatus: true.
+        // It appears as a message in the chat but also as a status update for members.
+        if (groups.length > 0) {
+            const groupContent = {
+                ...content,
+                groupStatus: true
+            }
+
+            for (const groupJid of groups) {
+                lastResult = await sock.sendMessage(groupJid, groupContent, {
+                    messageId: (0, exports.generateStatusMessageId)()
+                })
+            }
+        }
+
+        // Handle Personal status@broadcast
+        // Send to broadcast only if individuals are specified or if targeting all contacts (empty jidList)
+        if (individuals.length > 0 || jidList.length === 0) {
+            const result = await sock.sendMessage(exports.STATUS_BROADCAST_JID, content, {
+                statusJidList: individuals.length > 0 ? individuals : undefined,
+                messageId: (0, exports.generateStatusMessageId)()
+            })
+            if (!lastResult) lastResult = result
+        }
+
+        return lastResult
+    }
+}