@ethora/chat-component-rn 26.8.6 → 26.8.7

package/src/e2ee/send.ts

@@ -0,0 +1,70 @@
+import type { Client } from '@xmpp/client';
+import type { Element } from 'ltx';
+import {
+  accountDomain,
+  isE2eeEnabled,
+  isE2eeRoom,
+  omemoReady,
+  resolveRecipients,
+} from './index';
+
+export function shouldEncrypt(roomJID: string): boolean {
+  return isE2eeEnabled() && isE2eeRoom(roomJID);
+}
+
+let queue: Promise<void> = Promise.resolve();
+
+export function sendEncrypted(
+  client: Client,
+  roomJID: string,
+  id: string,
+  data: Element,
+  body: Element,
+  plain: Element
+): void {
+  queue = queue.then(async () => {
+    let stanza = plain;
+    try {
+      const crypto = await omemoReady();
+      if (!crypto) {throw new Error('omemo_not_ready');}
+      const recipients = await resolveRecipients(roomJID, accountDomain(client));
+      stanza = await crypto.encryptGroupMessage(roomJID, recipients, [body], id, [data]);
+    } catch (error) {
+      const reason = String((error as Error)?.message || error);
+      if (reason.startsWith('omemo_members_unknown')) {
+        console.warn(`OMEMO: not sending to ${roomJID} - ${reason}`);
+        return;
+      }
+      console.warn(`OMEMO: sending to ${roomJID} in clear - ${reason}`);
+    }
+    try {
+      await client.send(stanza);
+    } catch (error) {
+      console.error('An error occurred while sending message:', error);
+    }
+  });
+}
+
+export function sendSealedMedia(
+  client: Client,
+  roomJID: string,
+  id: string,
+  body: Element,
+  cleartext: Element[]
+): void {
+  queue = queue.then(async () => {
+    try {
+      const crypto = await omemoReady();
+      if (!crypto) {throw new Error('omemo_not_ready');}
+      const recipients = await resolveRecipients(roomJID, accountDomain(client));
+      const stanza = await crypto.encryptGroupMessage(roomJID, recipients, [body], id, cleartext);
+      await client.send(stanza);
+    } catch (error) {
+      console.error(
+        `OMEMO: refusing to send sealed attachment to ${roomJID} - ${String(
+          (error as Error)?.message || error
+        )}`
+      );
+    }
+  });
+}

package/src/e2ee/stanza.ts

@@ -0,0 +1,133 @@
+import { Element, parse } from 'ltx';
+import { store } from '../roomStore';
+import { translateKey } from '../i18n/strings';
+import { NS_OMEMO } from './ns';
+import { omemoReady, senderJidFromMuc } from './index';
+
+export type DecryptOutcome =
+  | 'not-encrypted'
+  | 'decrypted'
+  | 'undecryptable'
+  | 'drop';
+
+export type E2eeError =
+  | 'unsupported'
+  | 'other-device'
+  | 'failed';
+
+const READY_TIMEOUT_MS = 8000;
+
+export function encryptedCarrier(
+  stanza: Element,
+  depth = 0
+): Element | undefined {
+  if (depth > 4 || !stanza?.getChild) {return undefined;}
+  if (stanza.name === 'message' && stanza.getChild('encrypted', NS_OMEMO)) {
+    return stanza;
+  }
+  for (const child of stanza.children ?? []) {
+    if (typeof child === 'string') {continue;}
+    const found = encryptedCarrier(child as Element, depth + 1);
+    if (found) {return found;}
+  }
+  return undefined;
+}
+
+const PLACEHOLDER_KEY: Record<E2eeError, string> = {
+  unsupported: 'e2ee.unsupportedMessage',
+  'other-device': 'e2ee.otherDevice',
+  failed: 'e2ee.undecryptable',
+};
+
+export function placeholderKey(error?: string): string {
+  return PLACEHOLDER_KEY[error as E2eeError] ?? PLACEHOLDER_KEY.failed;
+}
+
+function placeholder(error: E2eeError): Element {
+  const settings = store.getState()?.chatSettingStore;
+  return new Element('body', {}).t(
+    translateKey(
+      placeholderKey(error),
+      settings?.config?.i18n?.locale || settings?.langSource,
+      settings?.config?.i18n?.strings
+    )
+  );
+}
+
+function mark(carrier: Element, error?: E2eeError): void {
+  let data = carrier.getChild('data');
+  if (!data) {
+    data = new Element('data', {});
+    carrier.append(data);
+  }
+  data.attrs.omemoEncrypted = 'true';
+  if (error) {
+    data.attrs.undecryptable = 'true';
+    data.attrs.e2eeError = error;
+  }
+}
+
+function strip(carrier: Element): void {
+  carrier.remove('encrypted', NS_OMEMO);
+  carrier.remove('encryption', 'urn:xmpp:eme:0');
+  carrier.remove('body');
+}
+
+function close(carrier: Element, error: E2eeError): DecryptOutcome {
+  strip(carrier);
+  carrier.append(placeholder(error));
+  mark(carrier, error);
+  return 'undecryptable';
+}
+
+export function rewriteEncryptedStanza(stanza: Element): DecryptOutcome {
+  const carrier = encryptedCarrier(stanza);
+  if (!carrier) {return 'not-encrypted';}
+  const encrypted = carrier.getChild('encrypted', NS_OMEMO);
+  if (!encrypted?.getChild('payload')) {return 'drop';}
+  return close(carrier, 'unsupported');
+}
+
+const waitForDevice = () => {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<undefined>((resolve) => {
+    timer = setTimeout(() => resolve(undefined), READY_TIMEOUT_MS);
+  });
+  return Promise.race([omemoReady(), timeout]).finally(() => {
+    if (timer) {clearTimeout(timer);}
+  });
+};
+
+export async function decryptStanzaInPlace(
+  stanza: Element,
+  domain: string
+): Promise<DecryptOutcome> {
+  const carrier = encryptedCarrier(stanza);
+  if (!carrier) {return 'not-encrypted';}
+
+  const encrypted = carrier.getChild('encrypted', NS_OMEMO);
+  if (!encrypted?.getChild('payload')) {return 'drop';}
+
+  const from = String(carrier.attrs?.from || '');
+  const roomJid = from.split('/')[0]!;
+  const sender = senderJidFromMuc(from, domain);
+  const crypto = await waitForDevice();
+  const decrypted = sender
+    ? await crypto?.decrypt(carrier, sender, roomJid)
+    : undefined;
+
+  if (!decrypted?.content) {
+    return close(
+      carrier,
+      decrypted?.error === 'omemo_not_encrypted_for_this_device'
+        ? 'other-device'
+        : 'failed'
+    );
+  }
+
+  strip(carrier);
+  const wrapper = parse(`<omemo-content>${decrypted.content}</omemo-content>`);
+  carrier.append(...wrapper.children);
+  mark(carrier);
+  return 'decrypted';
+}

package/src/e2ee/store.ts

@@ -0,0 +1,54 @@
+import { fromBase64, toBase64 } from './crypto';
+
+export interface OmemoStore {
+  get<T>(key: string): Promise<T | undefined>;
+  set(key: string, value: unknown): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+
+const BYTES_TAG = '$bytes';
+
+export function encodeValue(value: unknown): string {
+  return JSON.stringify(value, (_key, item) =>
+    item instanceof Uint8Array ? { [BYTES_TAG]: toBase64(item) } : item
+  );
+}
+
+export function decodeValue<T>(text: string): T {
+  return JSON.parse(text, (_key, item) =>
+    item && typeof item === 'object' && typeof item[BYTES_TAG] === 'string'
+      ? fromBase64(item[BYTES_TAG])
+      : item
+  ) as T;
+}
+
+export interface StringBackend {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+}
+
+export function createStore(backend: StringBackend, jid: string): OmemoStore {
+  const prefix = `${jid.toLowerCase()}|`;
+  return {
+    get: async <T>(key: string) => {
+      const raw = await backend.getItem(prefix + key);
+      return raw === null ? undefined : decodeValue<T>(raw);
+    },
+    set: (key, value) => backend.setItem(prefix + key, encodeValue(value)),
+    delete: (key) => backend.removeItem(prefix + key),
+  };
+}
+
+export function createMemoryBackend(): StringBackend {
+  const data = new Map<string, string>();
+  return {
+    getItem: async (key) => data.get(key) ?? null,
+    setItem: async (key, value) => void data.set(key, value),
+    removeItem: async (key) => void data.delete(key),
+  };
+}
+
+export function createMemoryStore(jid = 'memory'): OmemoStore {
+  return createStore(createMemoryBackend(), jid);
+}

package/src/helpers/accountName.ts

@@ -0,0 +1,15 @@
+export const accountNameOf = (
+  user:
+    | { xmppUsername?: string; userJID?: string; id?: string; _id?: string }
+    | null
+    | undefined,
+  appId: string
+): string => {
+  for (const raw of [user?.xmppUsername, user?.userJID, user?.id, user?._id]) {
+    const value = String(raw || '').split('@')[0]!.trim();
+    if (!value) {continue;}
+    if (value.includes('_')) {return value;}
+    if (appId) {return `${appId}_${value}`;}
+  }
+  return '';
+};

package/src/helpers/createMessageFromXml.ts

@@ -1,4 +1,7 @@
 import { IMessage } from '../types/types';
+import { isE2eeRoom } from '../e2ee';
+import { composeName } from './displayName';
+import { parseSealedMediaBody } from '../e2ee/sealedBody';
 
 interface IMessageWithNewData extends IMessage {
   [x: string]: any;
@@ -86,13 +89,25 @@ export const createMessageFromXml = async (
   // Synthesize user.name from sender attrs (web reads usersSet from
   // redux in <Message>; we fix it once at the source so Avatar /
   // MessageHeader render the actual sender instead of "??").
-  const firstName = (merged.senderFirstName || '').toString().trim();
-  const lastName = (merged.senderLastName || '').toString().trim();
+  const firstName = (merged.senderFirstName || merged.firstName || '')
+    .toString()
+    .trim();
+  const lastName = (merged.senderLastName || merged.lastName || '')
+    .toString()
+    .trim();
   const fullName = (merged.fullName || '').toString().trim();
   const senderJID = (merged.senderJID || '').toString();
-  const senderLocal = senderJID.includes('@')
-    ? senderJID.split('@')[0]
-    : senderJID;
+  const senderBare = senderJID.split('/')[0] || '';
+  const senderResource = senderJID.includes('/') ? senderJID.split('/')[1] || '' : '';
+  const senderIsOccupant =
+    !!senderResource &&
+    (senderBare === String(merged.roomJid || '') ||
+      /@conference\./i.test(senderBare));
+  const senderLocal = senderIsOccupant
+    ? senderResource
+    : senderBare.includes('@')
+      ? senderBare.split('@')[0]
+      : senderBare;
 
   // Bug #41 root cause: the resource of the MUC `from` (room@conference/
   // occupant-id) is the SAME field getDataFromXml uses to derive
@@ -112,7 +127,7 @@ export const createMessageFromXml = async (
   const xmppFrom = (merged.xmppFrom || '').toString();
   const fromResource = xmppFrom.includes('/') ? xmppFrom.split('/')[1] : '';
 
-  const composed = [firstName, lastName].filter(Boolean).join(' ').trim();
+  const composed = composeName(firstName, lastName);
   const existingName = String(merged?.user?.name || '').trim();
   const resolvedName =
     existingName ||
@@ -122,8 +137,18 @@ export const createMessageFromXml = async (
     merged?.user?.id ||
     '';
 
+  const unencrypted =
+    merged.omemoEncrypted !== 'true' && isE2eeRoom(String(merged.roomJid || ''));
+
+  const sealedKeys =
+    merged.clientEncrypted === 'true'
+      ? parseSealedMediaBody(merged.body)
+      : undefined;
+
   const message: IMessage = {
     ...merged,
+    ...(unencrypted ? { unencrypted: true } : {}),
+    ...(sealedKeys ? { e2eeKeys: sealedKeys, body: 'media' } : {}),
     user: {
       ...(merged.user || {}),
       id: merged?.user?.id || fromResource || senderLocal,

package/src/helpers/createUserNameFromSetUser.ts

@@ -1,4 +1,5 @@
 import { IMessage, RoomMember } from '../types/types';
+import { composeName } from './displayName';
 
 /**
  * Cache-only lookup. Returns the literal "Deleted User" as a MISS sentinel
@@ -21,7 +22,7 @@ export const createUserNameFromSetUser = (
   // fall back to that before giving up and returning the raw id.
   const bareName = user.name?.trim() || '';
 
-  return `${firstName} ${lastName}`.trim() || bareName || userId;
+  return composeName(firstName, lastName) || bareName || userId;
 };
 
 /**

package/src/helpers/displayName.ts

@@ -0,0 +1,9 @@
+export const composeName = (
+  first?: string | null,
+  last?: string | null
+): string => {
+  const f = String(first ?? '').trim();
+  const l = String(last ?? '').trim();
+  if (f && f.includes('@') && f.toLowerCase() === l.toLowerCase()) {return f;}
+  return `${f} ${l}`.trim();
+};

package/src/helpers/persistCrypto.ts

@@ -69,6 +69,11 @@ const loadOrCreateKey = (): Promise<CryptoJS.lib.WordArray> => {
   return cachedKeyPromise;
 };
 
+export async function isPersistKeyKept(): Promise<boolean> {
+  const key = await loadOrCreateKey();
+  return (await secureGet(CIPHER_KEY_STORE_KEY)) === CryptoJS.enc.Base64.stringify(key);
+}
+
 /** Encrypt a JSON-serialisable payload for storage. Returns the string to persist. */
 export async function encryptForPersist(plaintext: string): Promise<string> {
   const key = await loadOrCreateKey();

package/src/helpers/secureKeyValue.ts

@@ -74,6 +74,21 @@ export async function secureRemove(key: string): Promise<void> {
   await AsyncStorage.removeItem(FALLBACK_PREFIX + key).catch(() => undefined);
 }
 
+export async function secureGetOrCreate(
+  key: string,
+  create: () => string
+): Promise<{ value: string; created: boolean } | null> {
+  const existing = await secureGet(key);
+  if (existing) {return { value: existing, created: false };}
+  const value = create();
+  await secureSet(key, value);
+  if ((await secureGet(key)) !== value) {
+    pushLog('warn', `secureStore: ${key} was not kept`);
+    return null;
+  }
+  return { value, created: true };
+}
+
 /** Test seam only. */
 export const __resetSecureKeyValueWarningForTests = (): void => {
   warnedFallback = false;

package/src/helpers/videoCache.ts

@@ -0,0 +1,138 @@
+import * as FileSystem from 'expo-file-system/legacy';
+import { filenameFromUrl, getExtensionForMime } from './mimeToExtension';
+
+// Containers the native players open from a local file by extension.
+const VIDEO_EXT_RE = /\.(mp4|mov|m4v|webm|3gp|mkv|mpeg)$/i;
+
+const hashString = (value: string) => {
+  let hash = 5381;
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash * 33) ^ value.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+};
+
+export const isRemoteUrl = (url?: string | null): boolean =>
+  /^https?:\/\//i.test(url || '');
+
+const hostOf = (url: string): string =>
+  (/^https?:\/\/(?:[^@/]+@)?([^:/?#]+)/i.exec(url)?.[1] || '').toLowerCase();
+
+// The query carries the short-lived file token; the file is the same.
+const withoutQuery = (url: string): string => url.split('#')[0]!.split('?')[0]!;
+
+/**
+ * Where a remote video is kept once downloaded. The extension matters:
+ * AVFoundation picks the demuxer of a local file by it.
+ */
+export const getVideoCacheUri = (
+  url: string,
+  mimetype: string | undefined | null,
+  cacheDirectory: string
+): string => {
+  const fromUrl = VIDEO_EXT_RE.exec(filenameFromUrl(url))?.[0];
+  const fromMime = getExtensionForMime(mimetype);
+  const ext = (
+    fromUrl || (VIDEO_EXT_RE.test(fromMime) ? fromMime : '.mp4')
+  ).toLowerCase();
+  return `${cacheDirectory}ethora-video-${hashString(withoutQuery(url))}${ext}`;
+};
+
+/**
+ * Hosts that answered a streaming attempt with an error. AVPlayer refuses a
+ * server that replies 200 to a byte-range request ("server is not correctly
+ * configured"), so for those the next video skips the doomed stream and
+ * downloads straight away.
+ */
+const hostsWithoutStreaming = new Set<string>();
+
+export const markStreamingUnsupported = (url: string): void => {
+  const host = hostOf(url);
+  if (host) {hostsWithoutStreaming.add(host);}
+};
+
+export const isStreamingUnsupported = (url: string): boolean =>
+  hostsWithoutStreaming.has(hostOf(url));
+
+export const findCachedVideo = async (
+  url: string,
+  mimetype?: string | null
+): Promise<string | null> => {
+  const cacheDirectory = FileSystem.cacheDirectory;
+  if (!cacheDirectory || !isRemoteUrl(url)) {return null;}
+  try {
+    const uri = getVideoCacheUri(url, mimetype, cacheDirectory);
+    const info = await FileSystem.getInfoAsync(uri);
+    return info.exists ? uri : null;
+  } catch {
+    return null;
+  }
+};
+
+type ProgressListener = (fraction: number) => void;
+
+const inFlight = new Map<
+  string,
+  { promise: Promise<string>; listeners: Set<ProgressListener> }
+>();
+
+/**
+ * Downloads the video next to the app's other caches and resolves with the
+ * local uri. One download per file however many callers ask; `onProgress`
+ * gets 0..1 when the server reports a length.
+ */
+export const downloadVideoToCache = (
+  url: string,
+  mimetype?: string | null,
+  onProgress?: ProgressListener
+): Promise<string> => {
+  const cacheDirectory = FileSystem.cacheDirectory;
+  if (!cacheDirectory) {
+    return Promise.reject(new Error('video_cache_unavailable'));
+  }
+  const finalUri = getVideoCacheUri(url, mimetype, cacheDirectory);
+
+  const running = inFlight.get(finalUri);
+  if (running) {
+    if (onProgress) {running.listeners.add(onProgress);}
+    return running.promise;
+  }
+
+  const listeners = new Set<ProgressListener>();
+  if (onProgress) {listeners.add(onProgress);}
+
+  const run = async (): Promise<string> => {
+    // Download under another name: an interrupted download must not be
+    // mistaken for the cached file next time.
+    const part = `${finalUri}.part`;
+    await FileSystem.deleteAsync(part, { idempotent: true }).catch(() => {});
+    const task = FileSystem.createDownloadResumable(url, part, {}, (p) => {
+      if (p.totalBytesExpectedToWrite > 0) {
+        const fraction = Math.min(
+          1,
+          p.totalBytesWritten / p.totalBytesExpectedToWrite
+        );
+        listeners.forEach((listener) => listener(fraction));
+      }
+    });
+    const result = await task.downloadAsync();
+    if (!result || result.status < 200 || result.status >= 300) {
+      await FileSystem.deleteAsync(part, { idempotent: true }).catch(() => {});
+      throw new Error(`video_download_status_${result?.status ?? 'cancelled'}`);
+    }
+    await FileSystem.deleteAsync(finalUri, { idempotent: true }).catch(() => {});
+    await FileSystem.moveAsync({ from: part, to: finalUri });
+    return finalUri;
+  };
+
+  const promise = run().finally(() => {
+    inFlight.delete(finalUri);
+  });
+  inFlight.set(finalUri, { promise, listeners });
+  return promise;
+};
+
+export const __resetVideoCacheForTests = (): void => {
+  hostsWithoutStreaming.clear();
+  inFlight.clear();
+};

package/src/hooks/useLogout.tsx

@@ -12,6 +12,7 @@ import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
 import { secureUserStorage } from '../helpers/secureUserStorage';
 import { getFlushBoundaryTs } from '../helpers/getServerReadTimestamp';
+import { stopOmemo } from '../e2ee';
 
 // AsyncStorage keys the library writes but that aren't cleared by any
 // slice reducer. Listed here so a single logout call wipes the full
@@ -109,6 +110,14 @@ const logoutService = {
       console.warn('logoutService: push reset failed', e);
     }
 
+    stopOmemo();
+    try {
+      const { clearOpenedFiles } =
+        require('../e2ee/sealedFiles') as typeof import('../e2ee/sealedFiles');
+      clearOpenedFiles();
+    } catch {
+    }
+
     // 3. REST: nuke the in-memory `/chats/my` cache so the next login
     //    doesn't read user A's rooms while user B is bootstrapping.
     try {