fca-riyad 37.0.0

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

@@ -0,0 +1,66 @@
+syntax = "proto2";
+package WACommon;
+
+enum FutureProofBehavior {
+	PLACEHOLDER = 0;
+	NO_PLACEHOLDER = 1;
+	IGNORE = 2;
+}
+
+message MessageKey {
+	optional string remoteJID = 1;
+	optional bool fromMe = 2;
+	optional string ID = 3;
+	optional string participant = 4;
+}
+
+message Command {
+	enum CommandType {
+		EVERYONE = 1;
+		SILENT = 2;
+		AI = 3;
+		AI_IMAGINE = 4;
+	}
+
+	optional CommandType commandType = 1;
+	optional uint32 offset = 2;
+	optional uint32 length = 3;
+	optional string validationToken = 4;
+}
+
+message Mention {
+	enum MentionType {
+		PROFILE = 0;
+	}
+
+	optional MentionType mentionType = 1;
+	optional string mentionedJID = 2;
+	optional uint32 offset = 3;
+	optional uint32 length = 4;
+}
+
+message MessageText {
+	optional string text = 1;
+	repeated string mentionedJID = 2;
+	repeated Command commands = 3;
+	repeated Mention mentions = 4;
+}
+
+message SubProtocol {
+	optional bytes payload = 1;
+	optional int32 version = 2;
+}
+
+message LimitSharing {
+	enum Trigger {
+		UNKNOWN = 0;
+		CHAT_SETTING = 1;
+		BIZ_SUPPORTS_FB_HOSTING = 2;
+		UNKNOWN_GROUP = 3;
+	}
+
+	optional bool sharingLimited = 1;
+	optional Trigger trigger = 2;
+	optional int64 limitSharingSettingTimestamp = 3;
+	optional bool initiatedByMe = 4;
+}

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

@@ -0,0 +1,176 @@
+syntax = "proto2";
+package WAMediaTransport;
+
+import "WACommon.proto";
+
+message WAMediaTransport {
+  message Ancillary {
+    message Thumbnail {
+      message DownloadableThumbnail {
+        optional bytes fileSHA256 = 1;
+        optional bytes fileEncSHA256 = 2;
+        optional string directPath = 3;
+        optional bytes mediaKey = 4;
+        optional int64 mediaKeyTimestamp = 5;
+        optional string objectID = 6;
+        optional bytes thumbnailScansSidecar = 7;
+        repeated uint32 thumbnailScanLengths = 8;
+      }
+
+      optional bytes JPEGThumbnail = 1;
+      optional DownloadableThumbnail downloadableThumbnail = 2;
+      optional uint32 thumbnailWidth = 3;
+      optional uint32 thumbnailHeight = 4;
+    }
+
+    optional uint64 fileLength = 1;
+    optional string mimetype = 2;
+    optional Thumbnail thumbnail = 3;
+    optional string objectID = 4;
+  }
+
+  message Integral {
+    optional bytes fileSHA256 = 1;
+    optional bytes mediaKey = 2;
+    optional bytes fileEncSHA256 = 3;
+    optional string directPath = 4;
+    optional int64 mediaKeyTimestamp = 5;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message ImageTransport {
+  message Ancillary {
+    enum HdType {
+      NONE = 0;
+      LQ_4K = 1;
+      HQ_4K = 2;
+    }
+
+    optional uint32 height = 1;
+    optional uint32 width = 2;
+    optional bytes scansSidecar = 3;
+    repeated uint32 scanLengths = 4;
+    optional bytes midQualityFileSHA256 = 5;
+    optional HdType hdType = 6;
+    repeated float memoriesConceptScores = 7 [packed=true];
+    repeated uint32 memoriesConceptIDs = 8 [packed=true];
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message VideoTransport {
+  message Ancillary {
+    enum Attribution {
+      NONE = 0;
+      GIPHY = 1;
+      TENOR = 2;
+    }
+
+    optional uint32 seconds = 1;
+    optional WACommon.MessageText caption = 2;
+    optional bool gifPlayback = 3;
+    optional uint32 height = 4;
+    optional uint32 width = 5;
+    optional bytes sidecar = 6;
+    optional Attribution gifAttribution = 7;
+    optional string accessibilityLabel = 8;
+    optional bool isHd = 9;
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message AudioTransport {
+  message Ancillary {
+    message AvatarAudio {
+      enum AnimationsType {
+        TALKING_A = 0;
+        IDLE_A = 1;
+        TALKING_B = 2;
+        IDLE_B = 3;
+        BACKGROUND = 4;
+      }
+
+      message DownloadableAvatarAnimations {
+        optional bytes fileSHA256 = 1;
+        optional bytes fileEncSHA256 = 2;
+        optional string directPath = 3;
+        optional bytes mediaKey = 4;
+        optional int64 mediaKeyTimestamp = 5;
+        optional string objectID = 6;
+        optional AnimationsType animationsType = 7;
+      }
+
+      optional uint32 poseID = 1;
+      repeated DownloadableAvatarAnimations avatarAnimations = 2;
+    }
+
+    optional uint32 seconds = 1;
+    optional AvatarAudio avatarAudio = 2;
+    optional string waveformData = 3;
+    optional bytes waveform = 4;
+  }
+
+  message Integral {
+    enum AudioFormat {
+      UNKNOWN = 0;
+      OPUS = 1;
+    }
+
+    optional WAMediaTransport transport = 1;
+    optional AudioFormat audioFormat = 2;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message DocumentTransport {
+  message Ancillary {
+    optional uint32 pageCount = 1;
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}
+
+message StickerTransport {
+  message Ancillary {
+    optional uint32 pageCount = 1;
+    optional uint32 height = 2;
+    optional uint32 width = 3;
+    optional uint32 firstFrameLength = 4;
+    optional bytes firstFrameSidecar = 5;
+    optional string mustacheText = 6;
+    optional bool isThirdParty = 7;
+    optional string receiverFetchID = 8;
+    optional string accessibilityLabel = 9;
+  }
+
+  message Integral {
+    optional WAMediaTransport transport = 1;
+    optional bool isAnimated = 2;
+    optional string receiverFetchID = 3;
+  }
+
+  optional Integral integral = 1;
+  optional Ancillary ancillary = 2;
+}

package/src/api/socket/e2ee/e2ee/proto/proto-writer.ts

@@ -0,0 +1,76 @@
+/** Minimal protobuf writer - only what we need */
+export class ProtoWriter {
+  private chunks: Buffer[] = [];
+
+  private encodeVarint(value: number): Buffer {
+    const bytes: number[] = [];
+    let v = value >>> 0;
+    while (v > 127) {
+      bytes.push((v & 0x7f) | 0x80);
+      v >>>= 7;
+    }
+    bytes.push(v);
+    return Buffer.from(bytes);
+  }
+
+  private fieldHeader(fieldNum: number, wireType: number): Buffer {
+    return this.encodeVarint((fieldNum << 3) | wireType);
+  }
+
+  /** Wire type 0 (varint) but supports bigint */
+  private encodeVarintBigInt(value: bigint): Buffer {
+    const bytes: number[] = [];
+    let v = value;
+    while (v > 127n) {
+      bytes.push(Number((v & 0x7fn) | 0x80n));
+      v >>= 7n;
+    }
+    bytes.push(Number(v));
+    return Buffer.from(bytes);
+  }
+
+  /** Wire type 0 (varint) for uint64 fields */
+  uint64_varint(fieldNum: number, value: bigint): this {
+    this.chunks.push(this.fieldHeader(fieldNum, 0));
+    this.chunks.push(this.encodeVarintBigInt(value));
+    return this;
+  }
+
+  /** Wire type 2 (length-delimited) - bytes, string, embedded message */
+  bytes(fieldNum: number, data: Uint8Array): this {
+    const d = Buffer.from(data);
+    this.chunks.push(this.fieldHeader(fieldNum, 2));
+    this.chunks.push(this.encodeVarint(d.length));
+    this.chunks.push(d);
+    return this;
+  }
+
+  string(fieldNum: number, value: string): this {
+    return this.bytes(fieldNum, Buffer.from(value, "utf8"));
+  }
+
+  /** Wire type 0 (varint) */
+  varint(fieldNum: number, value: number): this {
+    this.chunks.push(this.fieldHeader(fieldNum, 0));
+    this.chunks.push(this.encodeVarint(value));
+    return this;
+  }
+
+  /** Wire type 0, bool */
+  bool(fieldNum: number, value: boolean): this {
+    return this.varint(fieldNum, value ? 1 : 0);
+  }
+
+  /** Wire type 1 (64-bit fixed) - uint64 */
+  uint64(fieldNum: number, value: bigint): this {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(value);
+    this.chunks.push(this.fieldHeader(fieldNum, 1));
+    this.chunks.push(buf);
+    return this;
+  }
+
+  build(): Buffer {
+    return Buffer.concat(this.chunks);
+  }
+}

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

@@ -0,0 +1,196 @@
+"use strict";
+
+/**
+ * Facebook-specific E2EE wire protocol handling.
+ *
+ * Facebook Secret Conversations use Signal Protocol (X3DH + Double Ratchet)
+ * with their own framing on top. This module handles:
+ *   - Key bundle upload/download to Facebook's graph endpoint
+ *   - Message framing (encode/decode NEXCA_E2EE frame format)
+ *   - Signed pre-key signatures using HMAC-SHA256 (FB uses Ed25519 in practice;
+ *     we sign with HMAC for our own inter-device sessions)
+ *   - E2EE-capable thread detection from message metadata
+ */
+
+const crypto = require("crypto");
+const { hmacSha256, generateKeyPair, randomBytes } = require("./crypto");
+
+// ─── Frame format ──────────────────────────────────────────────────────────────
+// 2  bytes: magic (0x4E58 = "NX")
+// 1  byte:  version (0x01)
+// 1  byte:  type (0=init, 1=message, 2=reaction, 3=receipt, 4=typing)
+// 4  bytes: sender ID length
+// N  bytes: sender ID (utf8)
+// 4  bytes: thread ID length
+// N  bytes: thread ID (utf8)
+// 4  bytes: header length  [only for type 0,1,2]
+// N  bytes: header
+// 4  bytes: payload length
+// N  bytes: payload (encrypted or raw for receipt/typing)
+
+const MAGIC = 0x4E58;
+const VERSION = 0x01;
+const TYPE = { INIT: 0, MESSAGE: 1, REACTION: 2, RECEIPT: 3, TYPING: 4 };
+
+function encodeFrame(type, senderID, threadID, header, payload) {
+    const sidBuf = Buffer.from(String(senderID), "utf8");
+    const tidBuf = Buffer.from(String(threadID), "utf8");
+    const hdrBuf = header || Buffer.alloc(0);
+    const payBuf = Buffer.isBuffer(payload) ? payload : Buffer.from(payload || "");
+
+    const totalSize = 2 + 1 + 1 + 4 + sidBuf.length + 4 + tidBuf.length + 4 + hdrBuf.length + 4 + payBuf.length;
+    const buf = Buffer.allocUnsafe(totalSize);
+    let offset = 0;
+
+    buf.writeUInt16BE(MAGIC, offset); offset += 2;
+    buf.writeUInt8(VERSION, offset); offset += 1;
+    buf.writeUInt8(type, offset); offset += 1;
+
+    buf.writeUInt32BE(sidBuf.length, offset); offset += 4;
+    sidBuf.copy(buf, offset); offset += sidBuf.length;
+
+    buf.writeUInt32BE(tidBuf.length, offset); offset += 4;
+    tidBuf.copy(buf, offset); offset += tidBuf.length;
+
+    buf.writeUInt32BE(hdrBuf.length, offset); offset += 4;
+    hdrBuf.copy(buf, offset); offset += hdrBuf.length;
+
+    buf.writeUInt32BE(payBuf.length, offset); offset += 4;
+    payBuf.copy(buf, offset);
+
+    return buf;
+}
+
+function decodeFrame(buf) {
+    if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
+    if (buf.length < 8) throw new Error("Frame too short");
+    let offset = 0;
+
+    const magic = buf.readUInt16BE(offset); offset += 2;
+    if (magic !== MAGIC) throw new Error("Invalid frame magic: " + magic.toString(16));
+    const version = buf.readUInt8(offset); offset += 1;
+    const type = buf.readUInt8(offset); offset += 1;
+
+    const sidLen = buf.readUInt32BE(offset); offset += 4;
+    const senderID = buf.slice(offset, offset + sidLen).toString("utf8"); offset += sidLen;
+
+    const tidLen = buf.readUInt32BE(offset); offset += 4;
+    const threadID = buf.slice(offset, offset + tidLen).toString("utf8"); offset += tidLen;
+
+    const hdrLen = buf.readUInt32BE(offset); offset += 4;
+    const header = buf.slice(offset, offset + hdrLen); offset += hdrLen;
+
+    const payLen = buf.readUInt32BE(offset); offset += 4;
+    const payload = buf.slice(offset, offset + payLen);
+
+    return { version, type, senderID, threadID, header, payload };
+}
+
+// ─── Key Bundle ────────────────────────────────────────────────────────────────
+
+function buildKeyBundle(identityKey, signedPreKey, oneTimePreKeys) {
+    return {
+        identityKey: identityKey.publicKeyRaw.toString("base64"),
+        signedPreKey: {
+            keyId: signedPreKey.keyId || 1,
+            publicKey: signedPreKey.publicKeyRaw.toString("base64"),
+            signature: signedPreKey.signature ? signedPreKey.signature.toString("base64") : ""
+        },
+        oneTimePreKeys: (oneTimePreKeys || []).map(k => ({
+            keyId: k.keyId,
+            publicKey: k.publicKeyRaw.toString("base64")
+        }))
+    };
+}
+
+function signKey(identityPrivateKey, keyToSign) {
+    return hmacSha256(identityPrivateKey, keyToSign.publicKeyRaw);
+}
+
+// ─── Facebook Graph API: key registration/fetching ───────────────────────────
+
+async function uploadKeyBundle(defaultFuncs, ctx, keyBundle) {
+    try {
+        const res = await defaultFuncs.post(
+            "https://www.facebook.com/api/graphql/",
+            ctx.jar,
+            {
+                fb_api_req_friendly_name: "MessengerE2EERegistrationMutation",
+                fb_api_caller_class: "RelayModern",
+                doc_id: "6325661730877783",
+                variables: JSON.stringify({
+                    input: {
+                        actor_id: ctx.userID,
+                        client_mutation_id: String(ctx.clientMutationId++),
+                        identity_key: keyBundle.identityKey,
+                        signed_pre_key: keyBundle.signedPreKey,
+                        one_time_pre_keys: keyBundle.oneTimePreKeys
+                    }
+                })
+            }
+        );
+        return res;
+    } catch (e) {
+        return null;
+    }
+}
+
+async function fetchRecipientKeyBundle(defaultFuncs, ctx, recipientUserID) {
+    try {
+        const res = await defaultFuncs.post(
+            "https://www.facebook.com/api/graphql/",
+            ctx.jar,
+            {
+                fb_api_req_friendly_name: "MessengerE2EEKeyBundleQuery",
+                fb_api_caller_class: "RelayModern",
+                doc_id: "6325661730877784",
+                variables: JSON.stringify({ user_id: String(recipientUserID) })
+            }
+        );
+        return res;
+    } catch (e) {
+        return null;
+    }
+}
+
+// ─── Message payload builders ─────────────────────────────────────────────────
+
+function buildInitPayload(senderEphemeralPub, senderOneTimeKeyId, recipientOneTimeKeyId) {
+    return JSON.stringify({
+        type: "x3dh_init",
+        ek: senderEphemeralPub.toString("base64"),
+        skid: senderOneTimeKeyId || null,
+        opk_id: recipientOneTimeKeyId || null,
+        ts: Date.now()
+    });
+}
+
+function parseInitPayload(buf) {
+    const str = Buffer.isBuffer(buf) ? buf.toString("utf8") : buf;
+    return JSON.parse(str);
+}
+
+function buildMessagePayload(text, attachments, replyToMessageId) {
+    return JSON.stringify({
+        v: 1,
+        text: text || null,
+        attachments: attachments || [],
+        reply_to: replyToMessageId || null,
+        ts: Date.now(),
+        nonce: randomBytes(8).toString("hex")
+    });
+}
+
+function parseMessagePayload(buf) {
+    const str = Buffer.isBuffer(buf) ? buf.toString("utf8") : buf;
+    return JSON.parse(str);
+}
+
+module.exports = {
+    MAGIC, VERSION, TYPE,
+    encodeFrame, decodeFrame,
+    buildKeyBundle, signKey,
+    uploadKeyBundle, fetchRecipientKeyBundle,
+    buildInitPayload, parseInitPayload,
+    buildMessagePayload, parseMessagePayload
+};