@eryxenx/fca 1.0.0

package/src/api/socket/e2ee/native/nativeMediaBridge.js

@@ -0,0 +1,233 @@
+"use strict";
+
+/**
+ * Native E2EE media bridge — mautrix-go / mautrix-meta (MPL-2.0)
+ * Copyright (c) Tulir Asokan and mautrix-go/mautrix-meta contributors.
+ * Upstream: https://github.com/mautrix/go, https://github.com/mautrix/meta
+ * License:  https://www.mozilla.org/en-US/MPL/2.0/
+ *
+ * fca-eryxenx's own hand-written Signal/Noise media encoder (vendor/fme)
+ * sends E2EE image/video/audio/document messages that Facebook's server
+ * accepts (valid messageId + CDN path returned) but that the real Messenger
+ * client silently fails to render — the reverse-engineered .proto schema
+ * used there doesn't match Messenger's actual wire format closely enough.
+ *
+ * This module instead calls into a precompiled native library built from
+ * mautrix-go/mautrix-meta (a maintained, protocol-accurate Go implementation
+ * of the same E2EE stack) via the `koffi` FFI, exactly like the reference
+ * "stfca" package does. Only MEDIA sending is routed through here — text
+ * messages keep using fca-eryxenx's existing, already-working E2EE path.
+ */
+
+const path = require("path");
+const logger = require("../../../../utils/nexca-logger");
+
+const NATIVE_CALL_TIMEOUT_MS = 15000;
+
+/**
+ * Wraps a native-engine call with a hard timeout. A hung native call (e.g.
+ * a stuck getDeviceList/usync query) was observed blocking the whole
+ * process — including the unrelated MQTT connection — for 80+ seconds,
+ * taking down the entire bot (all threads, not just the one send). This
+ * makes any single native call fail fast instead of hanging indefinitely.
+ */
+function withTimeout(promise, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`native ${label} timed out after ${NATIVE_CALL_TIMEOUT_MS}ms`)), NATIVE_CALL_TIMEOUT_MS);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+let _clientPromise = null;
+
+function _dynamicImport(specifier) {
+    // eslint-disable-next-line no-new-func
+    return new Function("s", "return import(s)")(specifier);
+}
+
+function _cookiesFromAppState(appState) {
+    const out = {};
+    if (!Array.isArray(appState)) return out;
+    appState.forEach((c) => {
+        if (c && c.key) out[c.key] = c.value;
+    });
+    if (!out.c_user && out.i_user) out.c_user = out.i_user;
+    return out;
+}
+
+let _clientInstance = null;
+let _connected = false;
+
+/**
+ * Returns a connected native Client, creating it once and reusing the same
+ * instance across reconnects (same pattern as the reference stfca package).
+ * Creating a brand-new Client (and thus a brand-new native Go-side handle)
+ * on every reconnect was never releasing the old handle fast enough and
+ * leaked native memory over a multi-hour uptime — reusing the instance and
+ * just re-calling .connect() avoids that entirely.
+ * @param {Array} appState fca-eryxenx's appState (from api.getAppState())
+ */
+async function getClient(appState) {
+    if (_connected && _clientInstance) return _clientInstance;
+    if (_clientPromise) return _clientPromise;
+
+    _clientPromise = (async () => {
+        if (!_clientInstance) {
+            const libUrl = require("url").pathToFileURL(
+                path.join(__dirname, "lib", "index.mjs")
+            ).href;
+
+            let mod;
+            try {
+                mod = await _dynamicImport(libUrl);
+            } catch (err) {
+                throw new Error(
+                    "Native E2EE media engine failed to load (" + libUrl + "): " +
+                    (err && err.message ? err.message : String(err)) +
+                    "\nMake sure `koffi` and `yumi-json-bigint` are installed, and that " +
+                    "native/build/messagix.{so,dll} is present for this platform."
+                );
+            }
+
+            const cookies = _cookiesFromAppState(appState);
+            if (!cookies.c_user || !cookies.xs) {
+                throw new Error("Native E2EE media engine: c_user/xs cookies missing from appState");
+            }
+
+            _clientInstance = new mod.Client(cookies, {
+                enableE2EE: true,
+                e2eeMemoryOnly: true,
+                autoReconnect: true,
+                logLevel: "none"
+            });
+
+            _clientInstance.on("error", (err) => {
+                logger.warn("E2EE", "[native-media] " + (err && err.message ? err.message : String(err)));
+            });
+            _clientInstance.on("disconnected", () => {
+                logger.warn("E2EE", "[native-media] native client disconnected, will reconnect on next send");
+                _connected = false;
+                _clientPromise = null;
+                // NOTE: we deliberately do NOT null/dispose _clientInstance
+                // here — it's reused on the next getClient() call via
+                // client.connect() below, avoiding a second native handle.
+            });
+        }
+
+        logger.info("E2EE", "[native-media] Connecting native mautrix-go client for media sends...");
+        await _clientInstance.connect();
+        await _clientInstance.connectE2EE();
+        _connected = true;
+
+        return _clientInstance;
+    })();
+
+    try {
+        return await _clientPromise;
+    } catch (err) {
+        _clientPromise = null;
+        throw err;
+    }
+}
+
+/**
+ * Sends an E2EE media attachment via the native engine.
+ * @param {Array} appState
+ * @param {string} chatJid  numeric thread id (bare, no @suffix needed)
+ * @param {"image"|"video"|"audio"|"document"} mediaType
+ * @param {Buffer} data
+ * @param {string} mimeType
+ * @param {object} opts { caption, width, height, duration, fileName, replyToId, replyToSenderJid }
+ */
+async function sendMedia(appState, chatJid, mediaType, data, mimeType, opts) {
+    const client = await getClient(appState);
+    opts = opts || {};
+
+    // Native client needs a full JID (id@server). fca-eryxenx normalizes
+    // E2EE thread ids down to bare numeric strings for GoatBot's benefit,
+    // so re-attach the domain here if it's missing — groups use "@g.us",
+    // DMs use "@msgr". Using the wrong domain makes native try to look up
+    // device lists for a nonexistent entity, which hangs until it times out.
+    if (typeof chatJid === "string" && chatJid.indexOf("@") === -1) {
+        chatJid = chatJid + (opts.isGroup ? "@g.us" : "@msgr");
+    }
+
+    switch (mediaType) {
+        case "image":
+            return withTimeout(client.sendE2EEImage(chatJid, data, mimeType || "image/jpeg", {
+                caption: opts.caption, width: opts.width, height: opts.height,
+                replyToId: opts.replyToId, replyToSenderJid: opts.replyToSenderJid
+            }), "sendE2EEImage");
+        case "video":
+            return withTimeout(client.sendE2EEVideo(chatJid, data, mimeType || "video/mp4", {
+                caption: opts.caption, width: opts.width, height: opts.height,
+                duration: opts.duration,
+                replyToId: opts.replyToId, replyToSenderJid: opts.replyToSenderJid
+            }), "sendE2EEVideo");
+        case "audio":
+            return withTimeout(client.sendE2EEAudio(chatJid, data, mimeType || "audio/ogg; codecs=opus", {
+                ptt: false, duration: opts.duration,
+                replyToId: opts.replyToId, replyToSenderJid: opts.replyToSenderJid
+            }), "sendE2EEAudio");
+        case "document":
+        default:
+            return withTimeout(client.sendE2EEDocument(
+                chatJid, data, opts.fileName || "file.bin",
+                mimeType || "application/octet-stream",
+                { replyToId: opts.replyToId, replyToSenderJid: opts.replyToSenderJid }
+            ), "sendE2EEDocument");
+    }
+}
+
+/**
+ * Sends/removes an E2EE reaction via the native engine.
+ * Pass emoji="" to remove a reaction.
+ */
+async function sendReaction(appState, chatJid, messageId, senderJid, emoji, isGroup) {
+    const client = await getClient(appState);
+    if (typeof chatJid === "string" && chatJid.indexOf("@") === -1) chatJid = chatJid + (isGroup ? "@g.us" : "@msgr");
+    return withTimeout(client.sendE2EEReaction(chatJid, messageId, senderJid, emoji || ""), "sendE2EEReaction");
+}
+
+/** Unsends/revokes an E2EE message via the native engine. */
+async function unsendMessage(appState, chatJid, messageId, isGroup) {
+    const client = await getClient(appState);
+    if (typeof chatJid === "string" && chatJid.indexOf("@") === -1) chatJid = chatJid + (isGroup ? "@g.us" : "@msgr");
+    return withTimeout(client.unsendE2EEMessage(chatJid, messageId), "unsendE2EEMessage");
+}
+
+/** Edits an E2EE message via the native engine (chat-agnostic — messageId alone). */
+async function editMessage(appState, messageId, newText) {
+    const client = await getClient(appState);
+    return withTimeout(client.editMessage(messageId, newText), "editMessage");
+}
+
+/** Marks an E2EE thread as read via the native engine. */
+async function markRead(appState, chatJid, watermarkTs) {
+    const client = await getClient(appState);
+    // Unlike other native functions, MxMarkRead's threadId field is int64,
+    // not a JID string — strip any "@..." suffix and pass a plain number.
+    const numericId = typeof chatJid === "string" ? Number(chatJid.split("@")[0]) : Number(chatJid);
+    return withTimeout(client.markAsRead(numericId, watermarkTs ? BigInt(watermarkTs) : undefined), "markAsRead");
+}
+
+/**
+ * Registers a listener on the native client for a given event name
+ * (e.g. "e2eeMessage", "e2eeReaction"). Used only for GROUP E2EE receiving —
+ * DM receiving continues to use the existing vendor engine, unchanged.
+ */
+async function onNativeEvent(appState, eventName, handler) {
+    const client = await getClient(appState);
+    client.on(eventName, handler);
+    return client;
+}
+
+/** Sends a text message to an E2EE group via the native engine's E2EE send. */
+async function sendGroupMessage(appState, chatJid, text, replyToId) {
+    const client = await getClient(appState);
+    if (typeof chatJid === "string" && chatJid.indexOf("@") === -1) chatJid = chatJid + "@g.us";
+    return withTimeout(client.sendE2EEMessage(chatJid, text, { replyToId }), "sendE2EEMessage(group)");
+}
+
+module.exports = { getClient, sendMedia, sendReaction, unsendMessage, markRead, onNativeEvent, sendGroupMessage, editMessage };

package/src/api/socket/e2ee/proto/ArmadilloApplication.proto

@@ -0,0 +1,281 @@
+syntax = "proto2";
+package waArmadilloApplication;
+
+import "WACommon.proto";
+
+message Armadillo {
+    message Metadata {
+    }
+
+    message Payload {
+        oneof payload {
+            Content content = 1;
+            ApplicationData applicationData = 2;
+            Signal signal = 3;
+            SubProtocolPayload subProtocol = 4;
+        }
+    }
+
+    message SubProtocolPayload {
+        optional WACommon.FutureProofBehavior futureProof = 1;
+    }
+
+    message Signal {
+        message EncryptedBackupsSecrets {
+            message Epoch {
+                enum EpochStatus {
+                    ES_OPEN = 1;
+                    ES_CLOSE = 2;
+                }
+
+                optional uint64 ID = 1;
+                optional bytes anonID = 2;
+                optional bytes rootKey = 3;
+                optional EpochStatus status = 4;
+            }
+
+            optional uint64 backupID = 1;
+            optional uint64 serverDataID = 2;
+            repeated Epoch epoch = 3;
+            optional bytes tempOcmfClientState = 4;
+            optional bytes mailboxRootKey = 5;
+            optional bytes obliviousValidationToken = 6;
+        }
+
+        oneof signal {
+            EncryptedBackupsSecrets encryptedBackupsSecrets = 1;
+        }
+    }
+
+    message ApplicationData {
+        message MessageHistoryDocumentMessage {
+            optional WACommon.SubProtocol document = 1;
+        }
+
+        message AIBotResponseMessage {
+            optional string summonToken = 1;
+            optional string messageText = 2;
+            optional string serializedExtras = 3;
+        }
+
+        message MetadataSyncAction {
+            message SyncAttachmentInterventionAction {
+                enum InterventionType {
+                    UNKNOWN = 0;
+                    NUDE = 1;
+                    NOT_NUDE = 2;
+                }
+
+                optional WACommon.MessageKey messageKey = 1;
+                optional InterventionType interventionType = 2;
+            }
+
+            message SyncSpectraAction {
+                enum SpectraActionType {
+                    TAKEDOWN = 0;
+                    RESTORE = 1;
+                }
+
+                optional WACommon.MessageKey key = 1;
+                optional SpectraActionType actionType = 2;
+                optional int64 takedownActionID = 3;
+                optional string config = 4;
+            }
+
+            message SyncMessageAction {
+                message ActionMessageDelete {
+                }
+
+                oneof action {
+                    ActionMessageDelete messageDelete = 101;
+                }
+
+                optional WACommon.MessageKey key = 1;
+            }
+
+            message SyncChatAction {
+                message ActionChatRead {
+                    optional SyncActionMessageRange messageRange = 1;
+                    optional bool read = 2;
+                }
+
+                message ActionChatDelete {
+                    optional SyncActionMessageRange messageRange = 1;
+                }
+
+                message ActionChatArchive {
+                    optional SyncActionMessageRange messageRange = 1;
+                    optional bool archived = 2;
+                }
+
+                oneof action {
+                    ActionChatArchive chatArchive = 101;
+                    ActionChatDelete chatDelete = 102;
+                    ActionChatRead chatRead = 103;
+                }
+
+                optional string chatID = 1;
+            }
+
+            message SyncActionMessage {
+                optional WACommon.MessageKey key = 1;
+                optional int64 timestamp = 2;
+            }
+
+            message SyncActionMessageRange {
+                optional int64 lastMessageTimestamp = 1;
+                optional int64 lastSystemMessageTimestamp = 2;
+                repeated SyncActionMessage messages = 3;
+            }
+
+            oneof actionType {
+                SyncChatAction chatAction = 101;
+                SyncMessageAction messageAction = 102;
+                SyncSpectraAction spectraAction = 103;
+                SyncAttachmentInterventionAction attachmentInterventionAction = 104;
+            }
+
+            optional int64 actionTimestamp = 1;
+        }
+
+        message MetadataSyncNotification {
+            repeated MetadataSyncAction actions = 2;
+        }
+
+        oneof applicationData {
+            MetadataSyncNotification metadataSync = 1;
+            AIBotResponseMessage aiBotResponse = 2;
+            MessageHistoryDocumentMessage messageHistoryDocumentMessage = 3;
+        }
+    }
+
+    message Content {
+        message PaymentsTransactionMessage {
+            enum PaymentStatus {
+                PAYMENT_UNKNOWN = 0;
+                REQUEST_INITED = 4;
+                REQUEST_DECLINED = 5;
+                REQUEST_TRANSFER_INITED = 6;
+                REQUEST_TRANSFER_COMPLETED = 7;
+                REQUEST_TRANSFER_FAILED = 8;
+                REQUEST_CANCELED = 9;
+                REQUEST_EXPIRED = 10;
+                TRANSFER_INITED = 11;
+                TRANSFER_PENDING = 12;
+                TRANSFER_PENDING_RECIPIENT_VERIFICATION = 13;
+                TRANSFER_CANCELED = 14;
+                TRANSFER_COMPLETED = 15;
+                TRANSFER_NO_RECEIVER_CREDENTIAL_NO_RTS_PENDING_CANCELED = 16;
+                TRANSFER_NO_RECEIVER_CREDENTIAL_NO_RTS_PENDING_OTHER = 17;
+                TRANSFER_REFUNDED = 18;
+                TRANSFER_PARTIAL_REFUND = 19;
+                TRANSFER_CHARGED_BACK = 20;
+                TRANSFER_EXPIRED = 21;
+                TRANSFER_DECLINED = 22;
+                TRANSFER_UNAVAILABLE = 23;
+            }
+
+            optional uint64 transactionID = 1;
+            optional string amount = 2;
+            optional string currency = 3;
+            optional PaymentStatus paymentStatus = 4;
+            // optional waArmadilloXMA.ExtendedContentMessage extendedContentMessage = 5;
+        }
+
+        message NetworkVerificationMessage {
+            optional string codeText = 1;
+        }
+
+        message NoteReplyMessage {
+            oneof noteReplyContent {
+                WACommon.MessageText textContent = 4;
+                WACommon.SubProtocol stickerContent = 5;
+                WACommon.SubProtocol videoContent = 6;
+            }
+
+            optional string noteID = 1;
+            optional WACommon.MessageText noteText = 2;
+            optional int64 noteTimestampMS = 3;
+        }
+
+        message BumpExistingMessage {
+            optional WACommon.MessageKey key = 1;
+        }
+
+        message ImageGalleryMessage {
+            repeated WACommon.SubProtocol images = 1;
+        }
+
+        message ScreenshotAction {
+            enum ScreenshotType {
+                SCREENSHOT_IMAGE = 1;
+                SCREEN_RECORDING = 2;
+            }
+
+            optional ScreenshotType screenshotType = 1;
+        }
+
+        message ExtendedContentMessageWithSear {
+            optional string searID = 1;
+            optional bytes payload = 2;
+            optional string nativeURL = 3;
+            optional WACommon.SubProtocol searAssociatedMessage = 4;
+            optional string searSentWithMessageID = 5;
+        }
+
+        message RavenActionNotifMessage {
+            enum ActionType {
+                PLAYED = 0;
+                SCREENSHOT = 1;
+                FORCE_DISABLE = 2;
+            }
+
+            optional WACommon.MessageKey key = 1;
+            optional int64 actionTimestamp = 2;
+            optional ActionType actionType = 3;
+        }
+
+        message RavenMessage {
+            enum EphemeralType {
+                VIEW_ONCE = 0;
+                ALLOW_REPLAY = 1;
+                KEEP_IN_CHAT = 2;
+            }
+
+            oneof mediaContent {
+                WACommon.SubProtocol imageMessage = 2;
+                WACommon.SubProtocol videoMessage = 3;
+            }
+
+            optional EphemeralType ephemeralType = 1;
+        }
+
+        message CommonSticker {
+            enum StickerType {
+                SMALL_LIKE = 1;
+                MEDIUM_LIKE = 2;
+                LARGE_LIKE = 3;
+            }
+
+            optional StickerType stickerType = 1;
+        }
+
+        oneof content {
+            CommonSticker commonSticker = 1;
+            ScreenshotAction screenshotAction = 3;
+            // waArmadilloXMA.ExtendedContentMessage extendedContentMessage = 4;
+            RavenMessage ravenMessage = 5;
+            RavenActionNotifMessage ravenActionNotifMessage = 6;
+            ExtendedContentMessageWithSear extendedMessageContentWithSear = 7;
+            ImageGalleryMessage imageGalleryMessage = 8;
+            PaymentsTransactionMessage paymentsTransactionMessage = 10;
+            BumpExistingMessage bumpExistingMessage = 11;
+            NoteReplyMessage noteReplyMessage = 13;
+            RavenMessage ravenMessageMsgr = 14;
+            NetworkVerificationMessage networkVerificationMessage = 15;
+        }
+    }
+
+    optional Payload payload = 1;
+    optional Metadata metadata = 2;
+}

package/src/api/socket/e2ee/proto/ArmadilloICDC.proto

@@ -0,0 +1,14 @@
+syntax = "proto2";
+package waArmadilloICDC;
+
+message ICDCIdentityList {
+  optional int32 seq = 1;
+  optional int64 timestamp = 2;
+  repeated bytes devices = 3;
+  optional int32 signingDeviceIndex = 4;
+}
+
+message SignedICDCIdentityList {
+  optional bytes details = 1;
+  optional bytes signature = 2;
+}