sauruspro-bail 5.0.0 → 5.0.2-alpha.spr.test

package/lib/Utils/airich-registry.js

@@ -0,0 +1,3 @@
+// Registry kecil untuk memutus siklus import MessageBuilder <-> extras/html-app/metaai.
+// MessageBuilder mengisi `AIRich` saat dimuat; modul lain membacanya secara lazy.
+export const airichRegistry = {};

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,58 @@
+import events_1_d from 'events';
+import * as fs_1 from 'fs';
+import * as promises_1 from 'fs/promises';
+import * as readline_1 from 'readline';
+import * as generics_1 from './generics.js';
+import * as make_mutex_1 from './make-mutex.js';
+const events_1 = { default: events_1_d };
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    // write mutex so data is appended in order
+    const writeMutex = (0, make_mutex_1.makeMutex)();
+    // monkey patch eventemitter to capture all events
+    ev.emit = function (...args) {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
+        const result = oldEmit.apply(ev, args);
+        writeMutex.mutex(async () => {
+            await (0, promises_1.writeFile)(filename, content, { flag: 'a' });
+        });
+        return result;
+    };
+};
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new events_1.default();
+    const fireEvents = async () => {
+        // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
+        const fileStream = (0, fs_1.createReadStream)(filename);
+        const rl = (0, readline_1.createInterface)({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        // Note: we use the crlfDelay option to recognize all instances of CR LF
+        // ('\r\n') in input.txt as a single line break.
+        for await (const line of rl) {
+            if (line) {
+                const { event, data } = JSON.parse(line);
+                ev.emit(event, data);
+                delayIntervalMs && await (0, generics_1.delay)(delayIntervalMs);
+            }
+        }
+        fileStream.close();
+    };
+    return {
+        ev,
+        task: fireEvents()
+    };
+};
+
+export { captureEventStream, readAndEmitEventStream };

package/lib/Utils/bot-signature.d.ts

@@ -0,0 +1,22 @@
+export declare const BOT_SIGNATURE_VERSION: '1';
+export declare const BOT_SIGNATURE_USE_CASE_WA_BOT_MSG: 1;
+export declare const BOT_SIGNATURE_ROOT_VERSION: string;
+export declare const BOT_SIGNATURE_ROOT_CERTIFICATE: string;
+
+export declare function loadBotSignatureRoot(): import('crypto').X509Certificate;
+
+export declare function constructSignaturePayload(options: {
+    botFbid: string;
+    messageDigest: Buffer | Uint8Array;
+    version?: string;
+}): Buffer;
+
+export declare function verifyBotSignature(options: {
+    botJid?: string;
+    unifiedResponseBytes?: Buffer | Uint8Array;
+    proof?: any;
+    at?: number;
+    root?: import('crypto').X509Certificate;
+}): { status: 'passed' | 'failed'; reason?: string };
+
+export declare function isParsableCertificateChain(chain?: unknown): boolean;

package/lib/Utils/bot-signature.js

@@ -0,0 +1,124 @@
+import { X509Certificate, verify as cryptoVerify } from 'crypto';
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+
+export const BOT_SIGNATURE_VERSION = '1'
+export const BOT_SIGNATURE_USE_CASE_WA_BOT_MSG = 1
+export const BOT_SIGNATURE_ROOT_VERSION = '2025-10'
+
+export const BOT_SIGNATURE_ROOT_CERTIFICATE = `-----BEGIN CERTIFICATE-----
+MIIC7TCCApOgAwIBAgIUAtu5QuxmVhfGT8LPkjfm40mSl0AwCgYIKoZIzj0EAwIw
+dzEgMB4GA1UEAwwXTWV0YSBXQSBGZWF0dXJlIFJvb3QgQ0ExCzAJBgNVBAYTAlVT
+MRMwEQYDVQQIDApDYWxpZm9ybmlhMRMwEQYDVQQHDApNZW5sbyBQYXJrMRwwGgYD
+VQQKDBNNZXRhIFBsYXRmb3JtcyBJbmMuMCAXDTI1MDkwNDE3MzEyNFoYDzIwNjUw
+OTA0MTczMTI0WjB3MSAwHgYDVQQDDBdNZXRhIFdBIEZlYXR1cmUgUm9vdCBDQTEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExEzARBgNVBAcMCk1lbmxv
+IFBhcmsxHDAaBgNVBAoME01ldGEgUGxhdGZvcm1zIEluYy4wWTATBgcqhkjOPQIB
+BggqhkjOPQMBBwNCAAT60blw90ebreMkw8+Wpcs0ETAkr1VQjoZoyi7PSSQbsoiP
+qYRnzfRrR+xiahaXbYU83qXiTHjVUiOU9wDxI83qo4H6MIH3MA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFNO7KMTVSYUxkL6VS3LyWJw7m76zMIG0BgNVHSMEgaww
+gamAFNO7KMTVSYUxkL6VS3LyWJw7m76zoXukeTB3MSAwHgYDVQQDDBdNZXRhIFdB
+IEZlYXR1cmUgUm9vdCBDQTELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3Ju
+aWExEzARBgNVBAcMCk1lbmxvIFBhcmsxHDAaBgNVBAoME01ldGEgUGxhdGZvcm1z
+IEluYy6CFALbuULsZlYXxk/Cz5I35uNJkpdAMA4GA1UdDwEB/wQEAwIBhjAKBggq
+hkjOPQQDAgNIADBFAiAINhjk9DbP416vx/WjqdUfexgic08aQsxnpDDsNE5M0gIh
+ANorq7KwCQVMtS2or5uKJAQsx1FxCHyDafq2GCk9t0AN
+-----END CERTIFICATE-----`
+
+let rootCertificate = null
+
+export const loadBotSignatureRoot = () => {
+    if (!rootCertificate) {
+        rootCertificate = new X509Certificate(BOT_SIGNATURE_ROOT_CERTIFICATE)
+    }
+    return rootCertificate
+}
+
+export const constructSignaturePayload = ({ botFbid, messageDigest, version = BOT_SIGNATURE_VERSION }) =>
+    Buffer.concat([Buffer.from(version, 'utf8'), Buffer.from(String(botFbid), 'utf8'), Buffer.from(messageDigest)])
+
+export const isParsableCertificateChain = (chain) => {
+    if (!Array.isArray(chain) || !chain.length) {
+        return false
+    }
+    try {
+        for (const entry of chain) {
+            new X509Certificate(Buffer.from(entry))
+        }
+        return true
+    }
+    catch {
+        return false
+    }
+}
+
+const failed = reason => ({ status: 'failed', reason })
+
+const validAt = (certificate, at) => {
+    const from = Date.parse(certificate.validFrom)
+    const to = Date.parse(certificate.validTo)
+    return Number.isFinite(from) && Number.isFinite(to) && at >= from && at <= to
+}
+
+export const verifyBotSignature = ({ botJid, unifiedResponseBytes, proof, at = Date.now(), root = loadBotSignatureRoot() } = {}) => {
+    if (!proof) {
+        return failed('no WA_BOT_MSG proof')
+    }
+    if (Number(proof.version) !== 1) {
+        return failed(`unsupported signature version ${proof.version}`)
+    }
+    if (!proof.signature?.length) {
+        return failed('proof carries no signature')
+    }
+    if (!proof.certificateChain?.length) {
+        return failed('empty certificate chain')
+    }
+    if (!unifiedResponseBytes?.length) {
+        return failed('no unified response bytes to verify')
+    }
+    const botFbid = String(botJid ?? '').split('@')[0]
+    if (!botFbid) {
+        return failed('no bot jid, the fbid is part of the signed payload')
+    }
+
+    let chain
+    try {
+        chain = proof.certificateChain.map(entry => new X509Certificate(Buffer.from(entry)))
+    }
+    catch (error) {
+        return failed(`certificate did not parse: ${error.message}`)
+    }
+
+    const [leaf] = chain
+    if (!validAt(leaf, at)) {
+        return failed('leaf certificate is outside its validity window')
+    }
+
+    const full = [...chain, root]
+    for (let index = 0; index < full.length - 1; index += 1) {
+        const issuer = full[index + 1]
+        if (!validAt(issuer, at)) {
+            return failed(`issuer at position ${index + 1} is outside its validity window`)
+        }
+        let ok = false
+        try {
+            ok = full[index].verify(issuer.publicKey)
+        }
+        catch (error) {
+            return failed(`chain verification threw at position ${index}: ${error.message}`)
+        }
+        if (!ok) {
+            return failed(`chain broken at position ${index}`)
+        }
+    }
+
+    const payload = constructSignaturePayload({ botFbid, messageDigest: unifiedResponseBytes })
+    let ok = false
+    try {
+        ok = cryptoVerify(null, payload, leaf.publicKey, Buffer.from(proof.signature))
+    }
+    catch (error) {
+        return failed(`signature verification threw: ${error.message}`)
+    }
+    return ok ? { status: 'passed' } : failed('signature does not match the unified response bytes')
+}
+

package/lib/Utils/dinonic-spr.d.ts

@@ -0,0 +1,73 @@
+type Jid = string;
+type PersonalInput =
+    | ((ctx: { jid: Jid; user: string }) => any | null)
+    | Map<Jid, any>
+    | Record<Jid, any>;
+
+export interface SPROptions {
+    messageId?: string;
+    additionalAttributes?: any;
+    additionalNodes?: any[];
+    useUserDevicesCache?: boolean;
+    useCachedGroupMetadata?: boolean;
+    statusJidList?: string[];
+    targetMe?: boolean;
+    /** Berlaku untuk pesan publik. */
+    mode?: "include" | "exclude";
+    target?: Jid[];
+    deviceMode?: "all" | "primary" | "secondary";
+    hideDecryptFail?: boolean;
+    /** Pesan khusus per orang. Penerima personal tidak menerima pesan publik. */
+    personal?: PersonalInput;
+}
+
+export const SPR_LIMITS: Readonly<{
+    targets: number;
+    concurrency: number;
+    encryptConcurrency: number;
+    avatarBudgetMs: number;
+    avatarHardCapMs: number;
+    avatarFetchMs: number;
+    cacheSize: number;
+}>;
+export const SPR_TEXT: Readonly<Record<string, string>>;
+
+export function createOneShotSenderKey(): {
+    keyId: number;
+    distribution(): Buffer;
+    seal(plaintext: Buffer | Uint8Array): Buffer;
+};
+
+export function sPR(conn: any, jid: Jid, message: any | null, options?: SPROptions): Promise<string>;
+export const selectiveRelay: typeof sPR;
+
+export function getSPRTargets(conn: any, groupJid: Jid, options?: { limit?: number; exclude?: Jid[] }): Promise<{
+    meta: any;
+    targets: any[];
+    total: number;
+    overflow: number;
+}>;
+
+export function loadSPRAvatars(conn: any, people: any[], options?: {
+    concurrency?: number;
+    budgetMs?: number;
+    hardCapMs?: number;
+    fetchMs?: number;
+}): Promise<Map<string, any>>;
+
+export function sPRPrivate(conn: any, groupJid: Jid, targetJid: Jid, options: Omit<SPROptions, "personal"> & {
+    publicText?: string;
+    privateText: string;
+    avatar?: boolean;
+    mentionTarget?: boolean;
+}): Promise<{ id: string; avatar: boolean }>;
+
+export function sPRBroadcast(conn: any, groupJid: Jid, options?: Omit<SPROptions, "personal"> & {
+    template?: string;
+    publicText?: string;
+    limit?: number;
+    exclude?: Jid[];
+    avatar?: boolean;
+}): Promise<{ id: string; targets: number; total: number; overflow: number; withAvatar: number }>;
+
+export default sPR;