@ethora/chat-component-rn 26.8.6 → 26.8.8

package/src/e2ee/deviceStore.ts

@@ -0,0 +1,80 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { secureGetOrCreate } from '../helpers/secureKeyValue';
+import {
+  decryptFromPersist,
+  encryptForPersist,
+  isPersistKeyKept,
+} from '../helpers/persistCrypto';
+import { randomBytes, toHex } from './crypto';
+import { createStore, type OmemoStore, type StringBackend } from './store';
+
+const MMKV_INSTANCE_ID = 'ethora-omemo';
+const MMKV_KEY_STORE_KEY = 'ethora_omemo_store_key';
+const ASYNC_STORAGE_PREFIX = '@ethora/omemo:';
+
+const createMmkvBackend = async (): Promise<StringBackend | null> => {
+  let MMKV: any;
+  try {
+    MMKV = require('react-native-mmkv').MMKV;
+  } catch {
+    return null;
+  }
+  if (typeof MMKV !== 'function') {return null;}
+  const key = await secureGetOrCreate(MMKV_KEY_STORE_KEY, () =>
+    toHex(randomBytes(8))
+  );
+  if (!key) {throw new Error('e2ee: the device store key was not kept');}
+  try {
+    const storage = new MMKV({ id: MMKV_INSTANCE_ID, encryptionKey: key.value });
+    if (key.created) {storage.clearAll();}
+    return {
+      getItem: async (key) => storage.getString(key) ?? null,
+      setItem: async (key, value) => void storage.set(key, value),
+      removeItem: async (key) => void storage.delete(key),
+    };
+  } catch (e) {
+    console.warn('[e2ee] react-native-mmkv present but unusable, falling back', e);
+    return null;
+  }
+};
+
+const asyncStorageBackend: StringBackend = {
+  getItem: async (key) => {
+    const raw = await AsyncStorage.getItem(ASYNC_STORAGE_PREFIX + key);
+    return raw ? decryptFromPersist(raw) : null;
+  },
+  setItem: async (key, value) =>
+    AsyncStorage.setItem(ASYNC_STORAGE_PREFIX + key, await encryptForPersist(value)),
+  removeItem: (key) => AsyncStorage.removeItem(ASYNC_STORAGE_PREFIX + key),
+};
+
+const createAsyncStorageBackend = async (): Promise<StringBackend> => {
+  if (!(await isPersistKeyKept())) {
+    throw new Error('e2ee: the storage cipher key was not kept');
+  }
+  return asyncStorageBackend;
+};
+
+let backendPromise: Promise<StringBackend> | null = null;
+
+const getBackend = (): Promise<StringBackend> => {
+  if (!backendPromise) {
+    const opening = createMmkvBackend().then(
+      (mmkv) => mmkv ?? createAsyncStorageBackend()
+    );
+    backendPromise = opening;
+    // A refusal is not cached: the next start may find the store usable.
+    opening.catch(() => {
+      if (backendPromise === opening) {backendPromise = null;}
+    });
+  }
+  return backendPromise;
+};
+
+export async function openDeviceStore(jid: string): Promise<OmemoStore> {
+  return createStore(await getBackend(), jid);
+}
+
+export const __resetDeviceStoreForTests = (): void => {
+  backendPromise = null;
+};

package/src/e2ee/fileCipher.ts

@@ -0,0 +1,86 @@
+import { cbc } from '@noble/ciphers/aes.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesEqual, concatBytes, hkdfSha256, randomBytes } from './crypto';
+
+const SLICE = 32 * 1024;
+const BLOCK = 16;
+
+export type Progress = (fraction: number) => void;
+
+const yieldToUi = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+function payloadKeys(key: Uint8Array) {
+  const km = hkdfSha256(key, undefined, 'OMEMO Payload', 80);
+  return { enc: km.slice(0, 32), auth: km.slice(32, 64), iv: km.slice(64) };
+}
+
+export async function encryptLargePayload(
+  plaintext: Uint8Array,
+  onProgress?: Progress
+): Promise<{ keyMaterial: Uint8Array; payload: Uint8Array }> {
+  const key = randomBytes(32);
+  const { enc, auth, iv } = payloadKeys(key);
+  const payload = new Uint8Array((Math.floor(plaintext.length / BLOCK) + 1) * BLOCK);
+  const mac = hmac.create(sha256, auth);
+
+  let offset = 0;
+  let chain = iv;
+  while (plaintext.length - offset > SLICE) {
+    const out = payload.subarray(offset, offset + SLICE);
+    out.set(
+      cbc(enc, chain, { disablePadding: true }).encrypt(
+        plaintext.subarray(offset, offset + SLICE)
+      )
+    );
+    mac.update(out);
+    chain = out.slice(SLICE - BLOCK);
+    offset += SLICE;
+    onProgress?.(offset / plaintext.length);
+    await yieldToUi();
+  }
+  const last = cbc(enc, chain).encrypt(plaintext.subarray(offset));
+  payload.set(last, offset);
+  mac.update(last);
+  onProgress?.(1);
+
+  return { keyMaterial: concatBytes(key, mac.digest().slice(0, 16)), payload };
+}
+
+export async function decryptLargePayload(
+  keyMaterial: Uint8Array,
+  payload: Uint8Array,
+  onProgress?: Progress
+): Promise<Uint8Array> {
+  if (keyMaterial.length !== 48) {throw new Error('Invalid key material');}
+  if (payload.length === 0 || payload.length % BLOCK !== 0) {
+    throw new Error('Payload authentication failed');
+  }
+  const { enc, auth, iv } = payloadKeys(keyMaterial.slice(0, 32));
+
+  const mac = hmac.create(sha256, auth);
+  for (let offset = 0; offset < payload.length; offset += SLICE) {
+    mac.update(payload.subarray(offset, offset + SLICE));
+    onProgress?.((Math.min(offset + SLICE, payload.length) / payload.length) * 0.65);
+    if (offset + SLICE < payload.length) {await yieldToUi();}
+  }
+  if (!bytesEqual(mac.digest().slice(0, 16), keyMaterial.slice(32))) {
+    throw new Error('Payload authentication failed');
+  }
+
+  const plaintext = new Uint8Array(payload.length);
+  let offset = 0;
+  let chain = iv;
+  while (payload.length - offset > SLICE) {
+    const part = payload.subarray(offset, offset + SLICE);
+    plaintext.set(cbc(enc, chain, { disablePadding: true }).decrypt(part), offset);
+    chain = part.slice(SLICE - BLOCK);
+    offset += SLICE;
+    onProgress?.(0.65 + (offset / payload.length) * 0.35);
+    await yieldToUi();
+  }
+  const last = cbc(enc, chain).decrypt(payload.subarray(offset));
+  plaintext.set(last, offset);
+  onProgress?.(1);
+  return plaintext.subarray(0, offset + last.length);
+}

package/src/e2ee/fileEnvelope.ts

@@ -0,0 +1,115 @@
+import {
+  bytesToUtf8,
+  fromBase64,
+  randomBytes,
+  toBase64,
+  toHex,
+  utf8ToBytes,
+} from './crypto';
+import {
+  decryptLargePayload,
+  encryptLargePayload,
+  type Progress,
+} from './fileCipher';
+
+export { parseSealedMediaBody } from './sealedBody';
+
+const MAGIC = Uint8Array.from([0x45, 0x54, 0x48, 0x4f, 0x46, 0x49, 0x4c, 0x45]);
+const VERSION = 1;
+const HEADER_OFFSET = MAGIC.length + 1 + 4;
+
+export interface FileEnvelopeMeta {
+  mimetype: string;
+  originalname: string;
+  size: number;
+}
+
+export interface SealedFile {
+  ciphertext: Uint8Array;
+  keyMaterial: string;
+  filename: string;
+}
+
+export function encodeFileEnvelope(
+  meta: FileEnvelopeMeta,
+  bytes: Uint8Array
+): Uint8Array {
+  const header = utf8ToBytes(
+    JSON.stringify({
+      mimetype: meta.mimetype,
+      originalname: meta.originalname,
+      size: meta.size,
+    })
+  );
+
+  const out = new Uint8Array(HEADER_OFFSET + header.length + bytes.length);
+  out.set(MAGIC, 0);
+  out[MAGIC.length] = VERSION;
+  new DataView(out.buffer).setUint32(MAGIC.length + 1, header.length, false);
+  out.set(header, HEADER_OFFSET);
+  out.set(bytes, HEADER_OFFSET + header.length);
+  return out;
+}
+
+export function decodeFileEnvelope(envelope: Uint8Array): {
+  meta: FileEnvelopeMeta;
+  bytes: Uint8Array;
+} {
+  if (envelope.length < HEADER_OFFSET) {
+    throw new Error('file_envelope_truncated');
+  }
+  for (let i = 0; i < MAGIC.length; i++) {
+    if (envelope[i] !== MAGIC[i]) {throw new Error('file_envelope_bad_magic');}
+  }
+  const version = envelope[MAGIC.length];
+  if (version !== VERSION) {
+    throw new Error(`file_envelope_unsupported_version_${version}`);
+  }
+
+  const headerLen = new DataView(
+    envelope.buffer,
+    envelope.byteOffset,
+    envelope.byteLength
+  ).getUint32(MAGIC.length + 1, false);
+
+  const bodyStart = HEADER_OFFSET + headerLen;
+  if (bodyStart > envelope.length) {throw new Error('file_envelope_truncated');}
+
+  const meta = JSON.parse(
+    bytesToUtf8(envelope.subarray(HEADER_OFFSET, bodyStart))
+  ) as FileEnvelopeMeta;
+
+  return { meta, bytes: envelope.subarray(bodyStart) };
+}
+
+export async function sealFileForUpload(
+  file: { bytes: Uint8Array; name?: string; type?: string },
+  onProgress?: Progress
+): Promise<SealedFile> {
+  const envelope = encodeFileEnvelope(
+    {
+      mimetype: file.type || 'application/octet-stream',
+      originalname: file.name || 'blob',
+      size: file.bytes.length,
+    },
+    file.bytes
+  );
+
+  const { keyMaterial, payload } = await encryptLargePayload(envelope, onProgress);
+
+  return {
+    ciphertext: payload,
+    keyMaterial: toBase64(keyMaterial),
+    filename: toHex(randomBytes(16)),
+  };
+}
+
+export async function openSealedFile(
+  ciphertext: Uint8Array,
+  keyMaterial: string,
+  onProgress?: Progress
+): Promise<{ meta: FileEnvelopeMeta; bytes: Uint8Array }> {
+  return decodeFileEnvelope(
+    await decryptLargePayload(fromBase64(keyMaterial), ciphertext, onProgress)
+  );
+}

package/src/e2ee/index.ts

@@ -0,0 +1,192 @@
+import { Platform } from 'react-native';
+import type { Client } from '@xmpp/client';
+import { store } from '../roomStore';
+import type { Omemo } from './omemo';
+
+export { NS_OMEMO } from './ns';
+export type { Decrypted, DeviceInfo, Trust, Omemo } from './omemo';
+
+let enabled = false;
+let instance: Omemo | undefined;
+let starting: Promise<Omemo | undefined> | undefined;
+let live: Client | undefined;
+let generation = 0;
+
+const bareJidOf = (client: Client | undefined): string | undefined =>
+  client?.jid?.bare?.().toString()?.toLowerCase() || undefined;
+
+const deviceLabel = (): string =>
+  Platform.OS === 'ios' ? 'iOS' : Platform.OS === 'android' ? 'Android' : 'Mobile';
+
+export function setE2eeEnabled(value: boolean): void {
+  if (enabled === value) {return;}
+  enabled = value;
+  if (!enabled) {
+    instance = undefined;
+    starting = undefined;
+    generation++;
+  } else {
+    void maybeStart();
+  }
+}
+
+export function isE2eeEnabled(): boolean {
+  return enabled;
+}
+
+export function onOnline(client: Client): void {
+  live = client;
+  if (instance && instance.jid === bareJidOf(client)) {
+    instance.useClient(client);
+    void instance.ensurePublished();
+    return;
+  }
+  void maybeStart();
+}
+
+function maybeStart(): Promise<Omemo | undefined> {
+  const client = live;
+  if (!enabled || !client) {return Promise.resolve(undefined);}
+  const jid = bareJidOf(client);
+  if (!jid) {return Promise.resolve(undefined);}
+  if (instance && instance.jid === jid) {return Promise.resolve(instance);}
+  if (starting) {return starting;}
+
+  const mine = ++generation;
+  starting = (async () => {
+    await Promise.resolve();
+    try {
+      const { Omemo: OmemoClass } = require('./omemo') as typeof import('./omemo');
+      const { openDeviceStore } =
+        require('./deviceStore') as typeof import('./deviceStore');
+      const keyStore = await openDeviceStore(jid);
+      const created = await OmemoClass.open(client, jid, keyStore, {
+        label: deviceLabel(),
+      });
+      if (mine !== generation) {return undefined;}
+      if (live && live !== client) {created.useClient(live);}
+      instance = created;
+      if (__DEV__) {
+        console.log(
+          `[e2ee] device ${created.deviceId} ready for ${jid} (${created.fingerprint})`
+        );
+      }
+      return instance;
+    } catch (err) {
+      console.warn('[e2ee] could not start', err);
+      return undefined;
+    } finally {
+      if (mine === generation) {starting = undefined;}
+    }
+  })();
+  return starting;
+}
+
+export function stopOmemo(): void {
+  instance = undefined;
+  starting = undefined;
+  live = undefined;
+  generation++;
+}
+
+export function omemo(): Omemo | undefined {
+  return enabled ? instance : undefined;
+}
+
+export function omemoReady(): Promise<Omemo | undefined> {
+  if (!enabled) {return Promise.resolve(undefined);}
+  if (instance) {return Promise.resolve(instance);}
+  return starting ?? maybeStart();
+}
+
+export function isE2eeRoom(roomJid?: string | null): boolean {
+  if (!roomJid) {return false;}
+  const jid = roomJid.split('/')[0]!;
+  return Boolean(store.getState()?.rooms?.rooms?.[jid]?.e2ee);
+}
+
+export function canSendToRoom(roomJid?: string | null): boolean {
+  return enabled || !isE2eeRoom(roomJid);
+}
+
+export function canEditMessage(
+  message?: { roomJid?: string; unencrypted?: boolean } | null
+): boolean {
+  if (!message) {return false;}
+  return message.unencrypted === true || !isE2eeRoom(message.roomJid);
+}
+
+export function canSendMediaToRoom(roomJid?: string | null): boolean {
+  return enabled || !isE2eeRoom(roomJid);
+}
+
+export function roomRecipients(roomJid: string, domain: string): string[] {
+  const jid = roomJid.split('/')[0]!;
+  const members = store.getState()?.rooms?.rooms?.[jid]?.members ?? [];
+  return toAccounts(members, domain);
+}
+
+const toAccounts = (members: any[], domain: string): string[] =>
+  members
+    .map((m: any) => String(m?.xmppUsername || '').split('@')[0])
+    .filter(Boolean)
+    .map((local: string) => `${local}@${domain}`.toLowerCase());
+
+const FETCHED_MEMBERS_TTL = 60_000;
+const fetchedMembers = new Map<string, { at: number; accounts: Promise<string[]> }>();
+
+export async function resolveRecipients(
+  roomJid: string,
+  domain: string
+): Promise<string[]> {
+  const jid = roomJid.split('/')[0]!;
+  const known = roomRecipients(roomJid, domain);
+  const expected = Number(store.getState()?.rooms?.rooms?.[jid]?.usersCnt || 0);
+  if (known.length > 0 && known.length >= expected) {return known;}
+
+  const cached = fetchedMembers.get(jid);
+  if (cached && Date.now() - cached.at < FETCHED_MEMBERS_TTL) {return cached.accounts;}
+
+  const accounts = (async () => {
+    const api =
+      require('../networking/api-requests/rooms.api') as typeof import('../networking/api-requests/rooms.api');
+    const response: any = await api.getRoomByName(jid.split('@')[0]!);
+    const room = response?.result ?? response;
+    const appId = api.ownAppId();
+    const found = toAccounts(
+      (room?.members || []).map((m: any) => ({
+        xmppUsername: api.memberAccount(m, appId),
+      })),
+      domain
+    );
+    if (found.length === 0) {throw new Error('no members returned');}
+    if (found.length < known.length) {return known;}
+    return found;
+  })().catch((err) => {
+    fetchedMembers.delete(jid);
+    throw new Error(
+      `omemo_members_unknown: ${String((err as Error)?.message || err)}`
+    );
+  });
+  fetchedMembers.set(jid, { at: Date.now(), accounts });
+  return accounts;
+}
+
+export function senderJidFromMuc(
+  from: string | undefined,
+  domain: string
+): string | undefined {
+  const nick = String(from || '').split('/')[1];
+  if (!nick || !domain) {return undefined;}
+  return `${nick}@${domain}`.toLowerCase();
+}
+
+export function accountDomain(client: Client | undefined): string {
+  return String(client?.jid?.getDomain?.() || '').toLowerCase();
+}
+
+export const __resetE2eeForTests = (): void => {
+  enabled = false;
+  stopOmemo();
+  fetchedMembers.clear();
+};

package/src/e2ee/limits.ts

@@ -0,0 +1,2 @@
+export const MAX_SEAL_BYTES = 20 * 1024 * 1024;
+export const MAX_OPEN_BYTES = 50 * 1024 * 1024;

package/src/e2ee/ns.ts

@@ -0,0 +1 @@
+export const NS_OMEMO = 'urn:xmpp:omemo:2';