@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/legitimacy-signal-injector.js

@@ -0,0 +1,180 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.LegitimacySignalInjector = void 0
+
+/**
+ * @file legitimacy-signal-injector.js
+ * @description Injects human imperfection signals into WA messages.
+ *   WA detection looks for TOO perfect accounts: no typos, consistent
+ *   reply speeds, typing duration linearly correlated with message length.
+ *   This module injects realistic imperfections:
+ *     - Typos followed by corrections (2.5% of messages)
+ *     - Read-receipt without immediate reply (read gap)
+ *     - Mid-typing pauses for longer messages
+ *   Ported from baileys-antiban to CJS for bilis.
+ * @author Denzy ZeroDay (port), Kobus Wentzel (original)
+ */
+
+const QWERTY_ADJACENT = {
+    a: ['q', 's', 'w', 'z'],
+    b: ['v', 'g', 'h', 'n'],
+    c: ['x', 'd', 'f', 'v'],
+    d: ['s', 'e', 'r', 'f', 'c', 'x'],
+    e: ['w', 'r', 'd', 's'],
+    f: ['d', 'r', 't', 'g', 'v', 'c'],
+    g: ['f', 't', 'y', 'h', 'b', 'v'],
+    h: ['g', 'y', 'u', 'j', 'n', 'b'],
+    i: ['u', 'o', 'k', 'j'],
+    j: ['h', 'u', 'i', 'k', 'n', 'm'],
+    k: ['j', 'i', 'o', 'l', 'm'],
+    l: ['k', 'o', 'p'],
+    m: ['n', 'j', 'k'],
+    n: ['b', 'h', 'j', 'm'],
+    o: ['i', 'p', 'l', 'k'],
+    p: ['o', 'l'],
+    q: ['w', 'a'],
+    r: ['e', 't', 'f', 'd'],
+    s: ['a', 'w', 'e', 'd', 'x', 'z'],
+    t: ['r', 'y', 'g', 'f'],
+    u: ['y', 'i', 'j', 'h'],
+    v: ['c', 'f', 'g', 'b'],
+    w: ['q', 'e', 's', 'a'],
+    x: ['z', 's', 'd', 'c'],
+    y: ['t', 'u', 'h', 'g'],
+    z: ['a', 's', 'x']
+}
+
+const DEFAULT_CONFIG = {
+    enableTypos: true,
+    typoProbability: 0.025,
+    typoCorrectMinMs: 500,
+    typoCorrectMaxMs: 2000,
+    enableReadGaps: true,
+    readGapProbability: 0.15,
+    readGapMinMs: 300000,
+    readGapMaxMs: 3600000,
+    enableTypingPauses: true,
+    typingPauseLengthThreshold: 50,
+    typingPauseProbability: 0.4,
+    typingPauseMinMs: 1500,
+    typingPauseMaxMs: 6000
+}
+
+class LegitimacySignalInjector {
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config }
+        this.stats = {
+            typosInjected: 0,
+            correctionsGenerated: 0,
+            readGapsInjected: 0,
+            typingPausesInjected: 0
+        }
+    }
+
+    /**
+     * Check if a typo should be injected for this message.
+     * Returns { typoText, correctionDelay, correctionText } or null.
+     */
+    shouldInjectTypo(text) {
+        if (!this.config.enableTypos || text.length <= 10) return null
+        if (Math.random() >= this.config.typoProbability) return null
+        if (/https?:\/\/|www\./i.test(text)) return null
+
+        const words = text.split(/\s+/)
+        const eligible = words.filter(
+            (w) => w.length >= 3 && !w.startsWith('@') && !/^\d+$/.test(w)
+        )
+        if (eligible.length === 0) return null
+
+        const targetWord = eligible[Math.floor(Math.random() * eligible.length)]
+        const typoWord = this._injectTypoInWord(targetWord)
+        if (!typoWord || typoWord === targetWord) return null
+
+        const typoText = text.replace(targetWord, typoWord)
+        const correctionDelay = this._rand(
+            this.config.typoCorrectMinMs,
+            this.config.typoCorrectMaxMs
+        )
+        const correctionText = text.length < 30 ? text : `*${targetWord}`
+
+        this.stats.typosInjected++
+        this.stats.correctionsGenerated++
+
+        return { typoText, correctionDelay, correctionText }
+    }
+
+    /**
+     * Check if a read gap should be injected before replying.
+     * Returns gap duration in ms, or null.
+     */
+    shouldInjectReadGap() {
+        if (!this.config.enableReadGaps) return null
+        if (Math.random() >= this.config.readGapProbability) return null
+        const gapMs = this._rand(this.config.readGapMinMs, this.config.readGapMaxMs)
+        this.stats.readGapsInjected++
+        return gapMs
+    }
+
+    /**
+     * Calculate mid-typing pause positions for long messages.
+     * Returns array of { afterChars, pauseDurationMs }.
+     */
+    getTypingPauses(messageLength) {
+        if (!this.config.enableTypingPauses) return []
+        if (messageLength < this.config.typingPauseLengthThreshold) return []
+        if (Math.random() >= this.config.typingPauseProbability) return []
+
+        const pauses = []
+        const numPauses = Math.random() < 0.6 ? 1 : 2
+
+        for (let i = 0; i < numPauses; i++) {
+            const pct = i === 0 ? 0.35 + Math.random() * 0.15 : 0.65 + Math.random() * 0.15
+            pauses.push({
+                afterChars: Math.floor(messageLength * pct),
+                pauseDurationMs: this._rand(
+                    this.config.typingPauseMinMs,
+                    this.config.typingPauseMaxMs
+                )
+            })
+            this.stats.typingPausesInjected++
+        }
+
+        return pauses.sort((a, b) => a.afterChars - b.afterChars)
+    }
+
+    getStats() {
+        return { ...this.stats }
+    }
+
+    reset() {
+        this.stats = {
+            typosInjected: 0,
+            correctionsGenerated: 0,
+            readGapsInjected: 0,
+            typingPausesInjected: 0
+        }
+    }
+
+    _injectTypoInWord(word) {
+        const chars = word.toLowerCase().split('')
+        const eligible = chars.map((c, i) => ({ c, i })).filter(({ c }) => QWERTY_ADJACENT[c])
+        if (eligible.length === 0) return null
+
+        const target = eligible[Math.floor(Math.random() * eligible.length)]
+        const neighbors = QWERTY_ADJACENT[target.c]
+        const rep = neighbors[Math.floor(Math.random() * neighbors.length)]
+        const orig = word[target.i]
+        const repChar = orig === orig.toUpperCase() ? rep.toUpperCase() : rep
+
+        const typo = word.split('')
+        typo[target.i] = repChar
+        return typo.join('')
+    }
+
+    _rand(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min
+    }
+}
+
+exports.LegitimacySignalInjector = LegitimacySignalInjector
+module.exports = { LegitimacySignalInjector, QWERTY_ADJACENT }

package/lib/Utils/link-preview.js

@@ -0,0 +1,106 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getUrlInfo = void 0
+const messages_1 = require('./messages')
+const messages_media_1 = require('./messages-media')
+const THUMBNAIL_WIDTH_PX = 192
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts)
+    const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth)
+    return result
+}
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+const getUrlInfo = async (
+    text,
+    opts = {
+        thumbnailWidth: THUMBNAIL_WIDTH_PX,
+        fetchOpts: { timeout: 3000 }
+    }
+) => {
+    var _a
+    try {
+        // retries
+        const retries = 0
+        const maxRetry = 5
+        const { getLinkPreview } = await import('link-preview-js')
+        let previewLink = text
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL)
+                const forwardedURLObj = new URL(forwardedURL)
+                if (retries >= maxRetry) {
+                    return false
+                }
+                if (
+                    forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname
+                ) {
+                    retries + 1
+                    return true
+                } else {
+                    return false
+                }
+            },
+            headers: opts.fetchOpts
+        })
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            }
+            if (opts.uploadImage) {
+                const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)(
+                    { image: { url: image } },
+                    {
+                        upload: opts.uploadImage,
+                        mediaTypeOverride: 'thumbnail-link',
+                        options: opts.fetchOpts
+                    }
+                )
+                urlInfo.jpegThumbnail = (
+                    imageMessage === null || imageMessage === void 0
+                        ? void 0
+                        : imageMessage.jpegThumbnail
+                )
+                    ? Buffer.from(imageMessage.jpegThumbnail)
+                    : undefined
+                urlInfo.highQualityThumbnail = imageMessage || undefined
+            } else {
+                try {
+                    urlInfo.jpegThumbnail = image
+                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
+                        : undefined
+                } catch (error) {
+                    ;(_a = opts.logger) === null || _a === void 0
+                        ? void 0
+                        : _a.debug(
+                              { err: error.stack, url: previewLink },
+                              'error in generating thumbnail'
+                          )
+                }
+            }
+            return urlInfo
+        }
+    } catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error
+        }
+    }
+}
+exports.getUrlInfo = getUrlInfo

package/lib/Utils/logger.d.ts

@@ -0,0 +1,13 @@
+export interface ILogger {
+    level: string
+    child(obj: Record<string, unknown>): ILogger
+    trace(obj: unknown, msg?: string): any
+    debug(obj: unknown, msg?: string): any
+    info(obj: unknown, msg?: string): any
+    warn(obj: unknown, msg?: string): any
+    error(obj: unknown, msg?: string): any
+}
+
+declare const _default: import("pino").Logger<never, boolean>
+
+export default _default

package/lib/Utils/logger.js

@@ -0,0 +1,9 @@
+'use strict'
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod }
+    }
+Object.defineProperty(exports, '__esModule', { value: true })
+const pino_1 = __importDefault(require('pino'))
+exports.default = pino_1.default({ timestamp: () => `,"time":"${new Date().toJSON()}"` })

package/lib/Utils/lt-hash.js

@@ -0,0 +1,54 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.LT_HASH_ANTI_TAMPERING = void 0
+const crypto_1 = require('./crypto')
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+const o = 128
+class d {
+    constructor(e) {
+        this.salt = e
+    }
+    add(e, t) {
+        var r = this
+        for (const item of t) {
+            e = r._addSingle(e, item)
+        }
+        return e
+    }
+    subtract(e, t) {
+        var r = this
+        for (const item of t) {
+            e = r._subtractSingle(e, item)
+        }
+        return e
+    }
+    subtractThenAdd(e, t, r) {
+        var n = this
+        return n.add(n.subtract(e, r), t)
+    }
+    _addSingle(e, t) {
+        var r = this
+        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer
+        return r.performPointwiseWithOverflow(e, n, (e, t) => e + t)
+    }
+    _subtractSingle(e, t) {
+        var r = this
+        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer
+        return r.performPointwiseWithOverflow(e, n, (e, t) => e - t)
+    }
+    performPointwiseWithOverflow(e, t, r) {
+        const n = new DataView(e),
+            i = new DataView(t),
+            a = new ArrayBuffer(n.byteLength),
+            s = new DataView(a)
+        for (let e = 0; e < n.byteLength; e += 2) {
+            s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0)
+        }
+        return a
+    }
+}
+exports.LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')

package/lib/Utils/make-mutex.js

@@ -0,0 +1,41 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeKeyedMutex = exports.makeMutex = void 0
+const makeMutex = () => {
+    let task = Promise.resolve()
+    let taskTimeout
+    return {
+        mutex(code) {
+            task = (async () => {
+                // wait for the previous task to complete
+                // if there is an error, we swallow so as to not block the queue
+                try {
+                    await task
+                } catch (_a) {}
+                try {
+                    // execute the current task
+                    const result = await code()
+                    return result
+                } finally {
+                    clearTimeout(taskTimeout)
+                }
+            })()
+            // we replace the existing task, appending the new piece of execution to it
+            // so the next task will have to wait for this one to finish
+            return task
+        }
+    }
+}
+exports.makeMutex = makeMutex
+const makeKeyedMutex = () => {
+    const map = {}
+    return {
+        mutex(key, task) {
+            if (!map[key]) {
+                map[key] = (0, exports.makeMutex)()
+            }
+            return map[key].mutex(task)
+        }
+    }
+}
+exports.makeKeyedMutex = makeKeyedMutex

package/lib/Utils/message-composer.d.ts

@@ -0,0 +1,106 @@
+import { proto } from '../../WAProto'
+
+export declare const JS_KEYWORDS: Set<string>
+export declare const PYTHON_KEYWORDS: Set<string>
+export declare const LANGUAGE_KEYWORDS: { [key: string]: Set<string> }
+
+export declare enum CodeHighlightType {
+    DEFAULT = 0,
+    KEYWORD = 1,
+    STR = 2,
+    NUMBER = 3,
+    METHOD = 4,
+    COMMENT = 5
+}
+
+export declare enum RichSubMessageType {
+    IMAGE = 3,
+    TABLE = 4,
+    CODE_BLOCK = 5,
+    LATEX = 8
+}
+
+export interface CodeBlockToken {
+    highlightType: CodeHighlightType
+    codeContent: string
+}
+
+export interface RichContextInfo {
+    stanzaId: string
+    participant: string
+    quotedMessage: proto.IMessage
+}
+
+export interface LatexExpression {
+    latexExpression: string
+    url?: string
+    width?: number
+    height?: number
+}
+
+export declare const tokenizeCode: (code: string, language?: string) => CodeBlockToken[]
+
+export declare const buildRichContextInfo: (quoted?: any, options?: { botJid?: string, mentions?: string[] }) => proto.IContextInfo | undefined
+
+export declare const buildBotForwardedMessage: (
+    submessages: any[],
+    ctxInfo?: proto.IContextInfo,
+    unifiedResponse?: { data: Buffer }
+) => proto.IMessage
+
+export declare const generateTableContent: (
+    title: string,
+    headers: string[],
+    rows: string[][],
+    quoted?: any,
+    options?: { headerText?: string, footer?: string }
+) => { message: proto.IMessage, messageId: string }
+
+export declare const generateListContent: (
+    title: string,
+    items: string[] | string[][],
+    quoted?: any,
+    options?: { headerText?: string, footer?: string }
+) => { message: proto.IMessage, messageId: string }
+
+export declare const generateCodeBlockContent: (
+    code: string,
+    quoted?: any,
+    options?: { title?: string, footer?: string, language?: string }
+) => { message: proto.IMessage, messageId: string }
+
+export declare const generateLatexContent: (
+    quoted?: any,
+    options?: { text?: string, expressions: LatexExpression[], headerText?: string, footer?: string }
+) => { message: proto.IMessage, messageId: string }
+
+export declare const generateLatexImageContent: (
+    quoted: any,
+    options: { text?: string, expressions: LatexExpression[], headerText?: string, footer?: string },
+    uploadFn: (buffer: Buffer, type: string) => Promise<{ url?: string, directPath?: string }>,
+    renderLatexToPng: (latexExpr: string) => Promise<{ buffer: Buffer, width: number, height: number }>
+) => Promise<{ message: proto.IMessage, messageId: string }>
+
+export declare const generateLatexInlineImageContent: (
+    quoted: any,
+    options: { text?: string, expressions: LatexExpression[], headerText?: string, footer?: string },
+    uploadFn: (buffer: Buffer, type: string) => Promise<{ url?: string, directPath?: string }>,
+    renderLatexToPng: (latexExpr: string) => Promise<{ buffer: Buffer, width: number, height: number }>
+) => Promise<{ message: proto.IMessage, messageId: string }>
+
+export declare const captureUnifiedResponse: (msg: proto.IMessage) => {
+    unifiedResponse: { data: Buffer },
+    submessages: any[],
+    contextInfo: any
+} | null
+
+export declare const generateUnifiedResponseContent: (
+    quoted: any,
+    captured: { submessages: any[], unifiedResponse: { data: Buffer } }
+) => { message: proto.IMessage, messageId: string }
+
+export declare const generateRichMessageContent: (
+    submessages: any[],
+    quoted?: any,
+    options?: { botJid?: string, mentions?: string[] }
+) => { message: proto.IMessage, messageId: string }