@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/vCard.d.ts

@@ -0,0 +1,71 @@
+export interface VCardContact {
+    /** Full name */
+    fullName: string
+    /** Display name (optional) */
+    displayName?: string
+    /** Organization/Company */
+    organization?: string
+    /** Title/Position */
+    title?: string
+    /** Phone numbers */
+    phones?: Array<{
+        number: string
+        type?: 'CELL' | 'WORK' | 'HOME' | 'MAIN' | 'FAX' | 'PAGER'
+        label?: string
+    }>
+    /** Email addresses */
+    emails?: Array<{
+        email: string
+        type?: 'WORK' | 'HOME' | 'OTHER'
+    }>
+    /** Website URLs */
+    urls?: Array<{
+        url: string
+        type?: 'WORK' | 'HOME' | 'OTHER'
+    }>
+    /** Physical addresses */
+    addresses?: Array<{
+        street?: string
+        city?: string
+        state?: string
+        postalCode?: string
+        country?: string
+        type?: 'WORK' | 'HOME' | 'OTHER'
+    }>
+    /** Birthday (YYYY-MM-DD format) */
+    birthday?: string
+    /** Notes */
+    note?: string
+}
+
+/** Generate vCard string from contact data */
+export declare const generateVCard: (contact: VCardContact) => string
+
+/** Generate multiple vCards (for contact array) */
+export declare const generateVCards: (contacts: VCardContact[]) => string
+
+/** Parse vCard string to contact data (basic parser) */
+export declare const parseVCard: (vcard: string) => Partial<VCardContact>
+
+/** Create a simple contact card message content */
+export declare const createContactCard: (contact: VCardContact) => {
+    contacts: {
+        displayName: string
+        contacts: Array<{ vcard: string }>
+    }
+}
+
+/** Create an array of contact cards message content */
+export declare const createContactCards: (contacts: VCardContact[]) => {
+    contacts: {
+        displayName: string
+        contacts: Array<{ vcard: string }>
+    }
+}
+
+/** Quick helper to create contact from phone number */
+export declare const quickContact: (
+    name: string,
+    phone: string,
+    options?: { organization?: string; email?: string }
+) => VCardContact

package/lib/Utils/vCard.js

@@ -0,0 +1,196 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.quickContact =
+    exports.createContactCards =
+    exports.createContactCard =
+    exports.parseVCard =
+    exports.generateVCards =
+    exports.generateVCard =
+        void 0
+
+/**
+ * Baileys-Joss: vCard / Contact Card Generator
+ * Ported to provide simple, robust vCard generation.
+ */
+
+const escapeVCard = (str) => {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/;/g, '\\;')
+        .replace(/,/g, '\\,')
+        .replace(/\n/g, '\\n')
+}
+
+const formatPhone = (phone) => {
+    return phone.replace(/[^\d+]/g, '')
+}
+
+/** Generate vCard string from contact data */
+const generateVCard = (contact) => {
+    const lines = []
+
+    // vCard header
+    lines.push('BEGIN:VCARD')
+    lines.push('VERSION:3.0')
+
+    // Full name
+    const escapedName = escapeVCard(contact.fullName)
+    lines.push(`FN:${escapedName}`)
+
+    // Structured name
+    const nameParts = contact.fullName.split(' ')
+    if (nameParts.length >= 2) {
+        const lastName = nameParts[nameParts.length - 1] || ''
+        const firstName = nameParts.slice(0, -1).join(' ')
+        lines.push(`N:${escapeVCard(lastName)};${escapeVCard(firstName)};;;`)
+    } else {
+        lines.push(`N:${escapedName};;;;`)
+    }
+
+    if (contact.organization) {
+        lines.push(`ORG:${escapeVCard(contact.organization)}`)
+    }
+
+    if (contact.title) {
+        lines.push(`TITLE:${escapeVCard(contact.title)}`)
+    }
+
+    if (contact.phones && contact.phones.length > 0) {
+        for (const phone of contact.phones) {
+            const type = phone.type || 'CELL'
+            const formattedPhone = formatPhone(phone.number)
+            if (phone.label) {
+                lines.push(
+                    `TEL;type=${type};type=VOICE;X-ABLabel=${escapeVCard(phone.label)}:${formattedPhone}`
+                )
+            } else {
+                lines.push(`TEL;type=${type};type=VOICE:${formattedPhone}`)
+            }
+        }
+    }
+
+    if (contact.emails && contact.emails.length > 0) {
+        for (const email of contact.emails) {
+            const type = email.type || 'OTHER'
+            lines.push(`EMAIL;type=${type}:${email.email}`)
+        }
+    }
+
+    if (contact.urls && contact.urls.length > 0) {
+        for (const url of contact.urls) {
+            const type = url.type || 'OTHER'
+            lines.push(`URL;type=${type}:${url.url}`)
+        }
+    }
+
+    if (contact.addresses && contact.addresses.length > 0) {
+        for (const addr of contact.addresses) {
+            const type = addr.type || 'OTHER'
+            const parts = [
+                '', // PO Box
+                '', // Extended address
+                addr.street || '',
+                addr.city || '',
+                addr.state || '',
+                addr.postalCode || '',
+                addr.country || ''
+            ].map((p) => escapeVCard(p))
+            lines.push(`ADR;type=${type}:${parts.join(';')}`)
+        }
+    }
+
+    if (contact.birthday) {
+        lines.push(`BDAY:${contact.birthday}`)
+    }
+
+    if (contact.note) {
+        lines.push(`NOTE:${escapeVCard(contact.note)}`)
+    }
+
+    lines.push('END:VCARD')
+    return lines.join('\r\n')
+}
+exports.generateVCard = generateVCard
+
+/** Generate multiple vCards (for contact array) */
+const generateVCards = (contacts) => {
+    return contacts.map(exports.generateVCard).join('\r\n')
+}
+exports.generateVCards = generateVCards
+
+/** Parse vCard string to contact data (basic parser) */
+const parseVCard = (vcard) => {
+    const contact = {}
+    const lines = vcard.split(/\r?\n/)
+
+    for (const line of lines) {
+        const [key, ...valueParts] = line.split(':')
+        if (!key) continue
+        const value = valueParts.join(':')
+
+        if (key.startsWith('FN')) {
+            contact.fullName = value.replace(/\\([;,n\\])/g, '$1').replace(/\\n/g, '\n')
+        } else if (key.startsWith('ORG')) {
+            contact.organization = value.replace(/\\([;,n\\])/g, '$1')
+        } else if (key.startsWith('TITLE')) {
+            contact.title = value.replace(/\\([;,n\\])/g, '$1')
+        } else if (key.startsWith('TEL')) {
+            contact.phones = contact.phones || []
+            const typeMatch = key.match(/type=(\w+)/i)
+            const phoneType = typeMatch?.[1]?.toUpperCase() || 'CELL'
+            contact.phones.push({ number: value, type: phoneType })
+        } else if (key.startsWith('EMAIL')) {
+            contact.emails = contact.emails || []
+            const typeMatch = key.match(/type=(\w+)/i)
+            contact.emails.push({
+                email: value,
+                type: typeMatch?.[1]?.toUpperCase() || 'OTHER'
+            })
+        } else if (key.startsWith('BDAY')) {
+            contact.birthday = value
+        } else if (key.startsWith('NOTE')) {
+            contact.note = value.replace(/\\n/g, '\n')
+        }
+    }
+
+    return contact
+}
+exports.parseVCard = parseVCard
+
+/** Create a simple contact card message content */
+const createContactCard = (contact) => {
+    return {
+        contacts: {
+            displayName: contact.displayName || contact.fullName,
+            contacts: [{ vcard: (0, exports.generateVCard)(contact) }]
+        }
+    }
+}
+exports.createContactCard = createContactCard
+
+/** Create an array of contact cards message content */
+const createContactCards = (contacts) => {
+    const firstContact = contacts[0]
+    return {
+        contacts: {
+            displayName:
+                contacts.length === 1 && firstContact
+                    ? firstContact.displayName || firstContact.fullName
+                    : `${contacts.length} Contacts`,
+            contacts: contacts.map((c) => ({ vcard: (0, exports.generateVCard)(c) }))
+        }
+    }
+}
+exports.createContactCards = createContactCards
+
+/** Quick helper to create contact from phone number */
+const quickContact = (name, phone, options) => {
+    return {
+        fullName: name,
+        phones: [{ number: phone, type: 'CELL' }],
+        organization: options?.organization,
+        emails: options?.email ? [{ email: options.email, type: 'WORK' }] : undefined
+    }
+}
+exports.quickContact = quickContact

package/lib/Utils/validate-connection.js

@@ -0,0 +1,253 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.encodeSignedDeviceIdentity =
+    exports.configureSuccessfulPairing =
+    exports.generateRegistrationNode =
+    exports.generateLoginNode =
+        void 0
+const boom_1 = require('@hapi/boom')
+const crypto_1 = require('crypto')
+const WAProto_1 = require('../../WAProto')
+const Defaults_1 = require('../Defaults')
+const WABinary_1 = require('../WABinary')
+const crypto_2 = require('./crypto')
+const generics_1 = require('./generics')
+const signal_1 = require('./signal')
+
+const getUserAgent = (config) => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        // WA started rejecting Platform.WEB on fresh pairing (405 frc/rva) in
+        // Feb 2026 — MACOS still gets through registration.
+        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.MACOS,
+        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode || 'US'
+    }
+}
+
+const PLATFORM_MAP = {
+    'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+}
+
+const getWebInfo = (config) => {
+    let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
+    if (
+        config.syncFullHistory &&
+        PLATFORM_MAP[config.browser[0]] &&
+        config.browser[1] === 'Desktop'
+    ) {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]]
+    }
+    return { webSubPlatform }
+}
+
+const getClientPayload = (config) => {
+    const payload = {
+        connectType: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    }
+    payload.webInfo = getWebInfo(config)
+    return payload
+}
+
+const generateLoginNode = (userJid, config) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(userJid)
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        lidDbMigrated: false
+    }
+    return WAProto_1.proto.ClientPayload.fromObject(payload)
+}
+exports.generateLoginNode = generateLoginNode
+
+const getPlatformType = (platform) => {
+    const platformType = platform.toUpperCase()
+    return (
+        WAProto_1.proto.DeviceProps.PlatformType[platformType] ||
+        WAProto_1.proto.DeviceProps.PlatformType.CHROME
+    )
+}
+
+const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    const appVersionBuf = (0, crypto_1.createHash)('md5').update(config.version.join('.')).digest()
+
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: {
+            primary: 10,
+            secondary: 15,
+            tertiary: 7
+        }
+    }
+
+    const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish()
+
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
+            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    }
+    return WAProto_1.proto.ClientPayload.fromObject(registerPayload)
+}
+exports.generateRegistrationNode = generateRegistrationNode
+
+const configureSuccessfulPairing = (
+    stanza,
+    { advSecretKey, signedIdentityKey, signalIdentities }
+) => {
+    const msgId = stanza.attrs.id
+    const pairSuccessNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-success')
+    const deviceIdentityNode = (0, WABinary_1.getBinaryNodeChild)(
+        pairSuccessNode,
+        'device-identity'
+    )
+    const platformNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'platform')
+    const deviceNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device')
+    const businessNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'biz')
+
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new boom_1.Boom('Missing device-identity or device in pair success node', {
+            data: stanza
+        })
+    }
+
+    const bizName = businessNode?.attrs.name
+    const jid = deviceNode.attrs.jid
+    const lid = deviceNode.attrs.lid
+
+    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(
+        deviceIdentityNode.content
+    )
+
+    let hmacPrefix = Buffer.from([])
+    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = Buffer.from([0x06, 0x05])
+    }
+
+    const advSign = (0, crypto_2.hmacSign)(
+        Buffer.concat([hmacPrefix, details]),
+        Buffer.from(advSecretKey, 'base64')
+    )
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new boom_1.Boom('Invalid account signature')
+    }
+
+    const account = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details)
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account
+
+    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails)
+
+    const accountSignaturePrefix =
+        deviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED
+            ? Buffer.from([0x06, 0x05])
+            : Buffer.from([0x06, 0x00])
+    const accountMsg = Buffer.concat([
+        accountSignaturePrefix,
+        deviceDetails,
+        signedIdentityKey.public
+    ])
+
+    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new boom_1.Boom('Failed to verify account signature')
+    }
+
+    const deviceMsg = Buffer.concat([
+        Buffer.from([0x06, 0x01]),
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ])
+    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg)
+
+    const identity = (0, signal_1.createSignalIdentity)(jid, accountSignatureKey)
+    const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false)
+
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: WABinary_1.S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    }
+
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    }
+
+    return {
+        creds: authUpdate,
+        reply
+    }
+}
+exports.configureSuccessfulPairing = configureSuccessfulPairing
+
+const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account }
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null
+    }
+    return WAProto_1.proto.ADVSignedDeviceIdentity.encode(account).finish()
+}
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity

package/lib/Utils/warmup.js

@@ -0,0 +1,154 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.WarmUp = void 0
+
+/**
+ * @file warmup.js
+ * @description Gradual activity increase for new/reconnected WA numbers.
+ *   Prevents ban by enforcing a 7-day ramp-up of messaging activity.
+ *   Ported from baileys-antiban to CJS for bilis.
+ * @author Denzy ZeroDay (port), original by baileys-antiban contributors
+ */
+
+const MS_PER_DAY = 86400000
+
+/** Random growth factor in [1.5, 2.2] — avoids cross-account fingerprinting */
+const randomGrowthFactor = () => Math.round((1.5 + Math.random() * 0.7) * 100) / 100
+
+const DEFAULT_CONFIG = {
+    warmUpDays: 7,
+    day1Limit: 20,
+    growthFactor: null, // null = randomized per instance
+    inactivityThresholdHours: 72
+}
+
+class WarmUp {
+    /**
+     * @param {object} config - Optional config overrides
+     * @param {object} existingState - Optional restored state from persistence
+     */
+    constructor(config = {}, existingState = null) {
+        this.config = { ...DEFAULT_CONFIG, ...config }
+        if (!this.config.growthFactor) {
+            this.config.growthFactor = randomGrowthFactor()
+        }
+        this.state = existingState || this._freshState()
+    }
+
+    /**
+     * Get current daily message limit based on warm-up phase.
+     * Returns Infinity if graduated.
+     */
+    getDailyLimit() {
+        if (this.state.graduated) return Infinity
+        const day = this._getCurrentDay()
+        if (day >= this.config.warmUpDays) {
+            this.state.graduated = true
+            return Infinity
+        }
+        return Math.round(this.config.day1Limit * Math.pow(this.config.growthFactor, day))
+    }
+
+    /**
+     * Check if a message can be sent within warm-up limits.
+     */
+    canSend() {
+        this._checkInactivity()
+        if (this.state.graduated) return true
+        const day = this._getCurrentDay()
+        const todayCount = this.state.dailyCounts[day] || 0
+        return todayCount < this.getDailyLimit()
+    }
+
+    /**
+     * Record a sent message.
+     */
+    record() {
+        const now = Date.now()
+        const day = this._getCurrentDay()
+        while (this.state.dailyCounts.length <= day) {
+            this.state.dailyCounts.push(0)
+        }
+        this.state.dailyCounts[day]++
+        this.state.lastActiveAt = now
+    }
+
+    /**
+     * Get current warm-up status.
+     */
+    getStatus() {
+        const day = this._getCurrentDay()
+        const todaySent = this.state.dailyCounts[day] || 0
+        const limit = this.getDailyLimit()
+        return {
+            phase: this.state.graduated ? 'graduated' : 'warming',
+            day: Math.min(day + 1, this.config.warmUpDays),
+            totalDays: this.config.warmUpDays,
+            todayLimit: limit === Infinity ? -1 : limit,
+            todaySent,
+            progress: this.state.graduated ? 100 : Math.round((day / this.config.warmUpDays) * 100)
+        }
+    }
+
+    /**
+     * Export state for persistence (save to DB/file).
+     */
+    exportState() {
+        const day = this._getCurrentDay()
+        const todaySent = this.state.dailyCounts[day] || 0
+        const todayDate = new Date().toISOString().split('T')[0]
+        return { ...this.state, todaySentCount: todaySent, todayDate }
+    }
+
+    /**
+     * Import state from persistence (restore from DB/file).
+     */
+    importState(state) {
+        this.state = { ...state }
+        if (state.todayDate && state.todaySentCount !== undefined) {
+            const todayDate = new Date().toISOString().split('T')[0]
+            if (state.todayDate === todayDate) {
+                const day = this._getCurrentDay()
+                while (this.state.dailyCounts.length <= day) {
+                    this.state.dailyCounts.push(0)
+                }
+                this.state.dailyCounts[day] = Math.max(
+                    this.state.dailyCounts[day] || 0,
+                    state.todaySentCount
+                )
+            }
+        }
+    }
+
+    /**
+     * Reset warm-up (e.g. after detected ban risk).
+     */
+    reset() {
+        this.state = this._freshState()
+    }
+
+    _getCurrentDay() {
+        return Math.floor((Date.now() - this.state.startedAt) / MS_PER_DAY)
+    }
+
+    _checkInactivity() {
+        const hoursSinceActive = (Date.now() - this.state.lastActiveAt) / 3600000
+        if (hoursSinceActive > this.config.inactivityThresholdHours && this.state.graduated) {
+            this.state = this._freshState()
+            this.state.graduated = false
+        }
+    }
+
+    _freshState() {
+        const now = Date.now()
+        return {
+            startedAt: now,
+            lastActiveAt: now,
+            dailyCounts: [],
+            graduated: false
+        }
+    }
+}
+
+exports.WarmUp = WarmUp
+module.exports = { WarmUp }