@badzz88/baileys 8.5.6 → 8.5.8

package/src/Utils/meta-ai-msmsg.js

@@ -1,222 +0,0 @@
-'use strict';
-const Crypto_1 = require('./crypto');
-const { proto } = require('../../WAProto');
-const BOT_MESSAGE_INFO = 'Bot Message';
-const KEY_LENGTH = 32;
-const AUTH_TAG_LENGTH = 16;
-const MSG_ID_HEX_RE = /^[0-9A-Fa-f]{32}$/;
-const unpadRandomMax16 = value => {
-    const bytes = new Uint8Array(value);
-    if (!bytes.length) {
-        throw new Error('unpadPkcs7 given empty bytes');
-    }
-    const padLength = bytes[bytes.length - 1];
-    if (padLength > bytes.length) {
-        throw new Error(`unpad given ${bytes.length} bytes, but pad is ${padLength}`);
-    }
-    return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.length - padLength);
-};
-const toBuffer = value => {
-    if (Buffer.isBuffer(value)) {
-        return value;
-    }
-    if (value instanceof Uint8Array) {
-        return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-    }
-    return Buffer.from(value);
-};
-const normalizeLidJid = jid => {
-    if (!jid || !jid.endsWith('@lid') || !jid.includes(':')) {
-        return jid;
-    }
-    return `${jid.split(':')[0]}@lid`;
-};
-const buildMessageIdRepresentations = messageId => {
-    const ascii = Buffer.from(messageId);
-    const binary = MSG_ID_HEX_RE.test(messageId) ? Buffer.from(messageId, 'hex') : ascii;
-    return [
-        { label: 'msgIdAscii', value: ascii },
-        ...(binary.equals(ascii) ? [] : [{ label: 'msgIdBinary', value: binary }])
-    ];
-};
-const pushUnique = (items, seen, item) => {
-    const key = JSON.stringify([
-        item.messageId,
-        item.idSource,
-        item.idSources,
-        item.infoSource,
-        item.aadSource,
-        item.info.toString('hex'),
-        item.aad.toString('hex')
-    ]);
-    if (!seen.has(key)) {
-        seen.add(key);
-        items.push(item);
-    }
-};
-const getCandidateIds = messageKey => {
-    const orderedCandidates = [
-        messageKey?.botType === 'full'
-            ? { source: 'stanzaId', messageId: messageKey?.stanzaId }
-            : { source: 'botEditTargetId', messageId: messageKey?.botEditTargetId },
-        { source: 'targetId', messageId: messageKey?.targetId },
-        { source: 'metaTargetId', messageId: messageKey?.metaTargetId },
-        { source: 'stanzaId', messageId: messageKey?.stanzaId }
-    ];
-    const targetIdCandidates = Array.isArray(messageKey?.targetIdCandidates) ? messageKey.targetIdCandidates : [];
-    for (let index = 0; index < targetIdCandidates.length; index += 1) {
-        orderedCandidates.push({
-            source: `targetIdCandidates[${index}]`,
-            messageId: targetIdCandidates[index]
-        });
-    }
-    const grouped = new Map();
-    for (const candidate of orderedCandidates) {
-        if (!candidate.messageId) {
-            continue;
-        }
-        const messageId = String(candidate.messageId);
-        const existing = grouped.get(messageId);
-        if (existing) {
-            if (!existing.idSources.includes(candidate.source)) {
-                existing.idSources.push(candidate.source);
-            }
-        }
-        else {
-            grouped.set(messageId, {
-                messageId,
-                idSource: candidate.source,
-                idSources: [candidate.source]
-            });
-        }
-    }
-    return Array.from(grouped.values());
-};
-const getJidCandidates = messageKey => {
-    const ordered = [
-        { source: 'meId', jid: messageKey?.meId },
-        { source: 'conversationJid', jid: messageKey?.conversationJid },
-        { source: 'senderJid', jid: messageKey?.senderJid },
-        { source: 'meLidNormalized', jid: normalizeLidJid(messageKey?.meLid) }
-    ];
-    const seen = new Set();
-    const candidates = [];
-    for (const candidate of ordered) {
-        if (!candidate.jid) {
-            continue;
-        }
-        const jid = String(candidate.jid);
-        if (!seen.has(jid)) {
-            seen.add(jid);
-            candidates.push({ source: candidate.source, jid, value: Buffer.from(jid) });
-        }
-    }
-    return candidates;
-};
-const buildMsmsgDecryptionStrategies = messageKey => {
-    const botJid = String(messageKey?.participant || '');
-    const botJidBuffer = Buffer.from(botJid);
-    const targetIds = getCandidateIds(messageKey);
-    const jidCandidates = getJidCandidates(messageKey);
-    const primaryJid = jidCandidates[0];
-    const alternateJid = jidCandidates.find(candidate => candidate.source !== primaryJid?.source && candidate.jid !== botJid);
-    const strategies = [];
-    const seen = new Set();
-    for (const idCandidate of targetIds) {
-        const idForms = buildMessageIdRepresentations(idCandidate.messageId);
-        for (const idForm of idForms) {
-            pushUnique(strategies, seen, {
-                mode: '2step',
-                idSource: idCandidate.idSource,
-                idSources: idCandidate.idSources,
-                infoSource: `${idForm.label}+meId+botJid`,
-                aadSource: `${idForm.label}+0+botJid`,
-                authTagLayout: 'trailing',
-                messageId: idCandidate.messageId,
-                info: Buffer.concat([idForm.value, primaryJid.value, botJidBuffer, Buffer.alloc(0)]),
-                aad: Buffer.concat([idForm.value, Buffer.from([0]), botJidBuffer]),
-                attemptLabel: `${idCandidate.idSource}:${idForm.label}:primary`
-            });
-            if (alternateJid) {
-                pushUnique(strategies, seen, {
-                    mode: '2step',
-                    idSource: idCandidate.idSource,
-                    idSources: idCandidate.idSources,
-                    infoSource: `${idForm.label}+${alternateJid.source}+botJid`,
-                    aadSource: `${idForm.label}+0+${alternateJid.source}`,
-                    authTagLayout: 'trailing',
-                    messageId: idCandidate.messageId,
-                    info: Buffer.concat([idForm.value, alternateJid.value, botJidBuffer, Buffer.alloc(0)]),
-                    aad: Buffer.concat([idForm.value, Buffer.from([0]), alternateJid.value]),
-                    attemptLabel: `${idCandidate.idSource}:${idForm.label}:${alternateJid.source}`
-                });
-            }
-        }
-    }
-    return strategies.slice(0, 12);
-};
-const assertRequired = (value, label) => {
-    if (!value ||
-        (Buffer.isBuffer(value) && value.length === 0) ||
-        (value instanceof Uint8Array && value.byteLength === 0)) {
-        throw new Error(`Missing required ${label} for msmsg decryption`);
-    }
-};
-const decryptWithStrategy = (messageSecret, msMsg, strategy) => {
-    const baseSecret = Buffer.from(Crypto_1.hkdf(toBuffer(messageSecret), KEY_LENGTH, { info: BOT_MESSAGE_INFO }));
-    const key = Buffer.from(Crypto_1.hkdf(baseSecret, KEY_LENGTH, { info: strategy.info }));
-    const payload = toBuffer(msMsg.encPayload);
-    const ciphertextWithTag = Buffer.concat([payload.slice(0, -AUTH_TAG_LENGTH), payload.slice(-AUTH_TAG_LENGTH)]);
-    return Buffer.from(Crypto_1.aesDecryptGCM(ciphertextWithTag, key, toBuffer(msMsg.encIv), strategy.aad));
-};
-const decodeDecryptedMsmsgMessage = decrypted => {
-    const messageBuffer = toBuffer(decrypted);
-    try {
-        const unpadded = Buffer.from(unpadRandomMax16(messageBuffer));
-        const decoded = proto.Message.decode(unpadded);
-        const hasContent = Object.keys(decoded).some(key => key !== 'messageContextInfo' && decoded[key] != null);
-        if (hasContent) {
-            return decoded;
-        }
-    }
-    catch { }
-    return proto.Message.decode(messageBuffer);
-};
-const decryptMsmsgBotMessage = async (messageSecret, messageKey, msMsg) => {
-    assertRequired(messageSecret, 'messageSecret');
-    assertRequired(messageKey?.participant, 'participant');
-    assertRequired(messageKey?.meId, 'meId');
-    assertRequired(msMsg?.encIv, 'encIv');
-    assertRequired(msMsg?.encPayload, 'encPayload');
-    if (getCandidateIds(messageKey).length === 0) {
-        throw new Error('Missing required target message id for msmsg decryption');
-    }
-    const strategies = buildMsmsgDecryptionStrategies(messageKey);
-    const attemptedStrategies = [];
-    let lastError;
-    for (const strategy of strategies) {
-        const attempt = {
-            idSource: strategy.idSource,
-            idSources: strategy.idSources,
-            infoSource: strategy.infoSource,
-            aadSource: strategy.aadSource,
-            messageId: strategy.messageId
-        };
-        try {
-            return await decryptWithStrategy(messageSecret, msMsg, strategy);
-        }
-        catch (error) {
-            attemptedStrategies.push(attempt);
-            lastError = error;
-        }
-    }
-    const error = new Error('Failed to decrypt msmsg with bounded deterministic strategies');
-    error.attemptedStrategies = attemptedStrategies;
-    error.cause = lastError;
-    throw error;
-};
-module.exports = {
-    buildMsmsgDecryptionStrategies,
-    decodeDecryptedMsmsgMessage,
-    decryptMsmsgBotMessage
-};

package/src/Utils/native-bridge.js

@@ -1,68 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.loadRustBridge = void 0;
-const fs = require('fs');
-const path = require('path');
-const BRIDGE_NAME = 'whatsapp-rust-bridge';
-let cached;
-let attempted = false;
-const findPackageDir = pkgName => {
-    let searchPaths;
-    try {
-        searchPaths = require.resolve.paths(pkgName) || [];
-    }
-    catch {
-        searchPaths = [];
-    }
-    for (const dir of searchPaths) {
-        const candidate = path.join(dir, pkgName);
-        if (fs.existsSync(path.join(candidate, 'package.json'))) {
-            return candidate;
-        }
-    }
-    return null;
-};
-const loadRustBridge = () => {
-    if (attempted)
-        return cached;
-    attempted = true;
-    try {
-        cached = require(BRIDGE_NAME);
-        return cached;
-    }
-    catch (error) {
-        const recoverableCodes = new Set(['ERR_PACKAGE_PATH_NOT_EXPORTED', 'ERR_PACKAGE_IMPORT_NOT_DEFINED']);
-        if (!recoverableCodes.has(error?.code)) {
-            cached = null;
-            return null;
-        }
-        try {
-            const dir = findPackageDir(BRIDGE_NAME);
-            if (!dir) {
-                cached = null;
-                return null;
-            }
-            const pkgJson = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
-            const candidates = [
-                pkgJson.main,
-                'index.js',
-                'index.node',
-                'dist/index.js',
-                'lib/index.js',
-                'build/index.js'
-            ].filter(Boolean);
-            for (const rel of candidates) {
-                const fullPath = path.join(dir, rel);
-                if (fs.existsSync(fullPath)) {
-                    cached = require(fullPath);
-                    return cached;
-                }
-            }
-        }
-        catch {
-        }
-        cached = null;
-        return null;
-    }
-};
-exports.loadRustBridge = loadRustBridge;

package/src/Utils/noise-handler.js

@@ -1,169 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.makeNoiseHandler = void 0;
-const boom_1 = require('@hapi/boom');
-const index_js_1 = require('../../WAProto/index.js');
-const Defaults_1 = require('../Defaults');
-const rb = require('./native-bridge').loadRustBridge();
-const rustNodeToJs = node => {
-    if (!node || typeof node !== 'object')
-        return node;
-    const result = { tag: node.tag, attrs: node.attrs || {} };
-    const content = node.content;
-    if (content === undefined || content === null) {
-    }
-    else if (content instanceof Uint8Array) {
-        result.content = Buffer.from(content);
-    }
-    else if (typeof content === 'string') {
-        result.content = content;
-    }
-    else if (Array.isArray(content)) {
-        result.content = content.map(rustNodeToJs);
-    }
-    else {
-        result.content = content;
-    }
-    return result;
-};
-const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }) => {
-    logger = logger.child({ class: 'ns' });
-    if (!rb) {
-        throw new Error('Establishing a WhatsApp connection requires the "whatsapp-rust-bridge" native module ' +
-            '(Noise protocol handshake + session), which failed to load. Make sure it is installed: ' +
-            'npm install whatsapp-rust-bridge@0.5.4');
-    }
-    const session = new rb.NoiseSession(publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey), NOISE_HEADER instanceof Uint8Array ? NOISE_HEADER : new Uint8Array(NOISE_HEADER), routingInfo ? (routingInfo instanceof Uint8Array ? routingInfo : new Uint8Array(routingInfo)) : undefined);
-    let isWaitingForTransport = false;
-    let pendingOnFrame = null;
-    let pendingBytes = null;
-    const processFrames = async (onFrame) => {
-        const frames = session.decodeFrame(new Uint8Array(0));
-        for (let i = 0; i < frames.length; i++) {
-            const item = frames[i];
-            let frame;
-            if (item instanceof Uint8Array) {
-                frame = Buffer.from(item);
-            }
-            else {
-                try {
-                    frame = rustNodeToJs(item.toJSON());
-                }
-                catch (decodeErr) {
-                    logger.debug({ err: decodeErr?.message }, '[noise] decode error');
-                    continue;
-                }
-            }
-            if (logger.level === 'trace') {
-                logger.trace({ msg: frame?.attrs?.id }, 'recv frame');
-            }
-            onFrame(frame);
-        }
-    };
-    const finishInit = async () => {
-        isWaitingForTransport = true;
-        session.finishInit();
-        isWaitingForTransport = false;
-        logger.trace('Noise handler transitioned to Transport state (Rust)');
-        if (pendingOnFrame && pendingBytes) {
-            logger.trace({ length: pendingBytes.length }, 'Flushing buffered frames after transport ready');
-            const frames = session.decodeFrame(pendingBytes);
-            pendingBytes = null;
-            const cb = pendingOnFrame;
-            pendingOnFrame = null;
-            for (let i = 0; i < frames.length; i++) {
-                const item = frames[i];
-                let frame;
-                if (item instanceof Uint8Array) {
-                    frame = Buffer.from(item);
-                }
-                else {
-                    try {
-                        frame = rustNodeToJs(item.toJSON());
-                    }
-                    catch (e) {
-                        continue;
-                    }
-                }
-                cb(frame);
-            }
-        }
-    };
-    return {
-        encrypt: plaintext => {
-            const u8 = plaintext instanceof Uint8Array ? plaintext : new Uint8Array(plaintext);
-            return Buffer.from(session.encrypt(u8));
-        },
-        decrypt: ciphertext => {
-            const u8 = ciphertext instanceof Uint8Array ? ciphertext : new Uint8Array(ciphertext);
-            return Buffer.from(session.decrypt(u8));
-        },
-        authenticate: data => {
-            session.authenticate(data instanceof Uint8Array ? data : new Uint8Array(data));
-        },
-        mixIntoKey: data => {
-            session.mixIntoKey(data instanceof Uint8Array ? data : new Uint8Array(data));
-        },
-        finishInit,
-        processHandshake: ({ serverHello }, noiseKey) => {
-            const certPayload = session.processHandshakeInit(serverHello.ephemeral, serverHello.static, serverHello.payload, privateKey instanceof Uint8Array ? privateKey : new Uint8Array(privateKey));
-            const { intermediate: certIntermediate, leaf } = index_js_1.proto.CertChain.decode(certPayload);
-            if (!leaf?.details || !leaf?.signature) {
-                throw new boom_1.Boom('invalid noise leaf certificate', { statusCode: 400 });
-            }
-            if (!certIntermediate?.details || !certIntermediate?.signature) {
-                throw new boom_1.Boom('invalid noise intermediate certificate', { statusCode: 400 });
-            }
-            const details = index_js_1.proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details);
-            const { issuerSerial } = details;
-            const { Curve } = require('./crypto');
-            if (!Curve.verify(details.key, leaf.details, leaf.signature)) {
-                throw new boom_1.Boom('noise certificate signature invalid', { statusCode: 400 });
-            }
-            if (!Curve.verify(Defaults_1.WA_CERT_DETAILS.PUBLIC_KEY, certIntermediate.details, certIntermediate.signature)) {
-                throw new boom_1.Boom('noise intermediate certificate signature invalid', { statusCode: 400 });
-            }
-            if (issuerSerial !== Defaults_1.WA_CERT_DETAILS.SERIAL) {
-                throw new boom_1.Boom('certification match failed', { statusCode: 400 });
-            }
-            const keyEnc = session.processHandshakeFinish(noiseKey.public instanceof Uint8Array ? noiseKey.public : new Uint8Array(noiseKey.public), noiseKey.private instanceof Uint8Array ? noiseKey.private : new Uint8Array(noiseKey.private), serverHello.ephemeral);
-            return Buffer.from(keyEnc);
-        },
-        encodeFrame: data => {
-            const u8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-            return Buffer.from(session.encodeFrameRaw(u8));
-        },
-        decodeFrame: async (newData, onFrame) => {
-            if (isWaitingForTransport) {
-                pendingBytes = pendingBytes
-                    ? Buffer.concat([pendingBytes, Buffer.from(newData)])
-                    : Buffer.from(newData);
-                pendingOnFrame = onFrame;
-                return;
-            }
-            const u8 = newData instanceof Uint8Array ? newData : new Uint8Array(newData.buffer, newData.byteOffset, newData.byteLength);
-            const frames = session.decodeFrame(u8);
-            for (let i = 0; i < frames.length; i++) {
-                const item = frames[i];
-                let frame;
-                if (item instanceof Uint8Array) {
-                    frame = Buffer.from(item);
-                }
-                else {
-                    try {
-                        frame = rustNodeToJs(item.toJSON());
-                    }
-                    catch (decodeErr) {
-                        logger.debug({ err: decodeErr?.message }, '[noise] decode error');
-                        continue;
-                    }
-                }
-                if (logger.level === 'trace') {
-                    logger.trace({ msg: frame?.attrs?.id }, 'recv frame');
-                }
-                onFrame(frame);
-            }
-        }
-    };
-};
-exports.makeNoiseHandler = makeNoiseHandler;