@eryxenx/fca 1.0.0

package/src/api/socket/e2ee/localMediaServer.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const http = require("http");
+const crypto = require("crypto");
+
+let _server = null;
+let _port = 0;
+const _cache = new Map(); // token -> { buffer, mimeType, expiresAt }
+
+const TTL_MS = 15 * 60 * 1000; // 15 min is plenty for a command to fetch it
+
+function _cleanup() {
+    const now = Date.now();
+    for (const [token, entry] of _cache) {
+        if (entry.expiresAt < now) _cache.delete(token);
+    }
+}
+
+function ensureServer() {
+    if (_server) return Promise.resolve(_port);
+    return new Promise((resolve, reject) => {
+        _server = http.createServer((req, res) => {
+            const token = (req.url || "").replace(/^\/+/, "").split("?")[0];
+            const entry = _cache.get(token);
+            if (!entry) {
+                res.writeHead(404);
+                res.end("not found");
+                return;
+            }
+            res.writeHead(200, {
+                "Content-Type": entry.mimeType || "application/octet-stream",
+                "Content-Length": entry.buffer.length
+            });
+            res.end(entry.buffer);
+        });
+        _server.on("error", reject);
+        // 127.0.0.1 only — never expose this outside the container
+        _server.listen(0, "127.0.0.1", () => {
+            _port = _server.address().port;
+            setInterval(_cleanup, 60 * 1000).unref();
+            resolve(_port);
+        });
+    });
+}
+
+/**
+ * Stores a decrypted media buffer and returns a short-lived local URL for it.
+ * @param {Buffer} buffer
+ * @param {string} mimeType
+ * @returns {Promise<string>} e.g. http://127.0.0.1:53211/ab12cd34
+ */
+async function serveBuffer(buffer, mimeType) {
+    const port = await ensureServer();
+    const token = crypto.randomBytes(12).toString("hex");
+    _cache.set(token, { buffer, mimeType, expiresAt: Date.now() + TTL_MS });
+    return `http://127.0.0.1:${port}/${token}`;
+}
+
+module.exports = { serveBuffer, getCacheSize: () => _cache.size };

package/src/api/socket/e2ee/mediaDecode.js

@@ -0,0 +1,155 @@
+"use strict";
+
+// Generic protobuf wire-format field reader (varint / length-delimited /
+// fixed32 / fixed64). Returns { fieldNumber: [values...] }.
+function readVarint(buf, offset) {
+    let result = 0n, shift = 0n, b;
+    do {
+        b = buf[offset++];
+        result |= BigInt(b & 0x7f) << shift;
+        shift += 7n;
+    } while (b & 0x80);
+    return [result, offset];
+}
+
+function decodeFields(buf) {
+    const fields = {};
+    let offset = 0;
+    while (offset < buf.length) {
+        let tag;
+        try {
+            [tag, offset] = readVarint(buf, offset);
+        } catch (_) { break; }
+        const fieldNum = Number(tag >> 3n);
+        const wireType = Number(tag & 7n);
+        let value;
+        if (wireType === 0) {
+            [value, offset] = readVarint(buf, offset);
+        } else if (wireType === 2) {
+            let len;
+            [len, offset] = readVarint(buf, offset);
+            len = Number(len);
+            value = buf.slice(offset, offset + len);
+            offset += len;
+        } else if (wireType === 1) {
+            value = buf.readBigUInt64LE(offset); offset += 8;
+        } else if (wireType === 5) {
+            value = buf.readUInt32LE(offset); offset += 4;
+        } else {
+            break;
+        }
+        if (!fields[fieldNum]) fields[fieldNum] = [];
+        fields[fieldNum].push(value);
+    }
+    return fields;
+}
+
+function bytesField(fields, n) { return fields[n] ? fields[n][0] : undefined; }
+function strField(fields, n) {
+    const b = bytesField(fields, n);
+    return b !== undefined ? Buffer.from(b).toString("utf8") : undefined;
+}
+function numField(fields, n) {
+    const v = fields[n] ? fields[n][0] : undefined;
+    return v !== undefined ? Number(v) : undefined;
+}
+
+// WACommon.SubProtocol { bytes payload = 1; int32 version = 2; }
+function decodeSubProtocol(buf) {
+    const f = decodeFields(buf);
+    return { payload: bytesField(f, 1), version: numField(f, 2) };
+}
+
+// WAMediaTransport {
+//   Integral  { bytes fileSHA256=1; bytes mediaKey=2; bytes fileEncSHA256=3; string directPath=4; int64 mediaKeyTimestamp=5; }
+//   Ancillary { uint64 fileLength=1; string mimetype=2; Thumbnail thumbnail=3; string objectID=4; }
+//   Integral integral = 1; Ancillary ancillary = 2;
+// }
+function decodeWAMediaTransport(buf) {
+    const top = decodeFields(buf);
+    const integralBuf = bytesField(top, 1);
+    const ancillaryBuf = bytesField(top, 2);
+    const integral = integralBuf ? decodeFields(integralBuf) : {};
+    const ancillary = ancillaryBuf ? decodeFields(ancillaryBuf) : {};
+    return {
+        fileSHA256: bytesField(integral, 1),
+        mediaKey: bytesField(integral, 2),
+        fileEncSHA256: bytesField(integral, 3),
+        directPath: strField(integral, 4),
+        mediaKeyTimestamp: numField(integral, 5),
+        fileLength: numField(ancillary, 1),
+        mimeType: strField(ancillary, 2),
+        objectId: strField(ancillary, 4)
+    };
+}
+
+// {Image,Video,Audio,Document}Transport {
+//   Integral  { WAMediaTransport transport = 1; }
+//   Ancillary { uint32 height=1; uint32 width=2; ... }  (varies per type, only
+//               height/width are common to image/video and are all we need)
+//   Integral integral = 1; Ancillary ancillary = 2;
+// }
+function decodeMediaTransportPayload(buf) {
+    const top = decodeFields(buf);
+    const integralWrapBuf = bytesField(top, 1);
+    const ancillaryBuf = bytesField(top, 2);
+
+    let transport = {};
+    if (integralWrapBuf) {
+        const integralWrap = decodeFields(integralWrapBuf);
+        const transportBuf = bytesField(integralWrap, 1);
+        if (transportBuf) transport = decodeWAMediaTransport(transportBuf);
+    }
+    let width, height;
+    if (ancillaryBuf) {
+        const anc = decodeFields(ancillaryBuf);
+        height = numField(anc, 1);
+        width = numField(anc, 2);
+    }
+    return { ...transport, width, height };
+}
+
+/**
+ * Decodes a Content.{image,video,audio,document}Message object (as produced
+ * by the vendor engine's normalizeE2EEMessage) into flat transport fields
+ * usable by client.downloadMedia({directPath, mediaKey, mediaSha256, ...}).
+ * @param {"image"|"video"|"audio"|"document"} kind
+ * @param {object} mediaMessage e.g. content.imageMessage
+ */
+function decodeIncomingMedia(kind, mediaMessage) {
+    if (!mediaMessage) return null;
+    const sub = kind === "image" ? mediaMessage.image
+        : kind === "video" ? mediaMessage.video
+        : kind === "audio" ? mediaMessage.audio
+        : mediaMessage.document;
+    if (!sub) return null;
+
+    const subBuf = Buffer.isBuffer(sub) ? sub
+        : (sub.payload && Buffer.isBuffer(sub.payload)) ? sub.payload
+        : null;
+    if (!subBuf) return null;
+
+    let payload;
+    try {
+        const proto = decodeSubProtocol(subBuf);
+        payload = proto.payload ? decodeMediaTransportPayload(Buffer.from(proto.payload)) : decodeMediaTransportPayload(subBuf);
+    } catch (_) {
+        try { payload = decodeMediaTransportPayload(subBuf); } catch (__) { return null; }
+    }
+    if (!payload || !payload.directPath || !payload.mediaKey) return null;
+
+    return {
+        kind,
+        directPath: payload.directPath,
+        mediaKey: payload.mediaKey,
+        fileSHA256: payload.fileSHA256,
+        fileEncSHA256: payload.fileEncSHA256,
+        mimeType: payload.mimeType || (kind === "image" ? "image/jpeg" : kind === "video" ? "video/mp4" : kind === "audio" ? "audio/ogg" : "application/octet-stream"),
+        fileLength: payload.fileLength,
+        width: payload.width,
+        height: payload.height,
+        fileName: mediaMessage.fileName || undefined
+    };
+}
+
+module.exports = { decodeIncomingMedia, decodeFields, decodeSubProtocol, decodeWAMediaTransport };

package/src/api/socket/e2ee/native/NOTICE.md

@@ -0,0 +1,29 @@
+# Third-Party Notice
+
+The files in `native/build/messagix.so` and `native/build/messagix.dll`
+are precompiled native binaries built from:
+
+- **mautrix-go** — https://github.com/mautrix/go
+- **mautrix-meta** — https://github.com/mautrix/meta
+
+Copyright (c) Tulir Asokan and the mautrix-go / mautrix-meta contributors.
+
+Both projects are licensed under the **Mozilla Public License 2.0 (MPL-2.0)**.
+A copy of the license is available at:
+https://www.mozilla.org/en-US/MPL/2.0/
+
+`native/lib/index.mjs` is the Node.js FFI bridge (via `koffi`) used to call
+into the compiled binary, adapted from the same upstream project's Node
+bindings.
+
+fca-eryxenx uses this native engine only for sending E2EE media attachments
+(images/video/audio/documents) in end-to-end encrypted Messenger threads,
+because the project's own hand-written Signal Protocol media encoder
+(`../vendor/fme`) produces payloads that Facebook's servers accept but that
+Messenger clients fail to render. Text messages and all non-media E2EE
+functionality continue to use fca-eryxenx's original implementation.
+
+In accordance with MPL-2.0 §3.3, this NOTICE file must be preserved and
+distributed alongside these files, and any modifications to the covered
+source files (if the original `.mjs`/Go source is later vendored here)
+must remain under MPL-2.0 and have their source made available.