@ethora/chat-component-rn 26.8.6 → 26.8.7

package/src/components/UsersList/UsersList.tsx

@@ -5,6 +5,7 @@ import React, {
   useMemo,
   useEffect,
 } from 'react';
+import { composeName } from '../../helpers/displayName';
 import { ModalTitle, LabelData } from '../Modals/styledModalComponents';
 import {
   ScrollableContainer,
@@ -101,7 +102,7 @@ const UsersList: React.FC<UsersListProps> = ({
               disabled={selectedUsers.length === 20}
             />
             <View>
-              <Label>{`${user.firstName} ${user.lastName}`}</Label>
+              <Label>{composeName(user.firstName, user.lastName)}</Label>
               {/* <LabelData>{user.xmppUsername}</LabelData> */}
             </View>
           </UserItem>

package/src/components/styled/SendInput.tsx

@@ -87,12 +87,14 @@ interface SendInputProps {
   inputHeight?: number;
   showPreview?: boolean;
   previewParser?: (text: string) => (string | JSX.Element)[];
+  maxMediaBytes?: number;
 }
 
 const SendInput: React.FC<SendInputProps> = ({
   sendMessage,
   sendMedia,
   config,
+  maxMediaBytes,
   onFocus,
   onBlur,
   editMessage,
@@ -151,14 +153,15 @@ const SendInput: React.FC<SendInputProps> = ({
     // Enforce the upload size cap before anything reaches the network.
     // The backend rejects oversized bodies with HTTP 413; catching it
     // here gives a clear message instead of a silent failed bubble.
+    const limit = maxMediaBytes ?? MAX_MEDIA_BYTES;
     const oversize = files.find(
-      (f) => typeof f.size === 'number' && f.size > MAX_MEDIA_BYTES
+      (f) => typeof f.size === 'number' && f.size > limit
     );
     if (oversize) {
       Alert.alert(
         'File too large',
         `"${oversize.name}" is ${formatBytes(oversize.size!)}. The maximum allowed size is ${Math.round(
-          MAX_MEDIA_BYTES / (1024 * 1024)
+          limit / (1024 * 1024)
         )} MB.`
       );
       return;

package/src/e2ee/crypto.ts

@@ -0,0 +1,194 @@
+import { cbc } from '@noble/ciphers/aes.js';
+import { ed25519, x25519 } from '@noble/curves/ed25519.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+
+export { concatBytes, randomBytes, utf8ToBytes };
+
+export interface KeyPair {
+  priv: Uint8Array;
+  pub: Uint8Array;
+}
+
+export interface IdentityKey {
+  seed: Uint8Array;
+  pub: Uint8Array;
+}
+
+const ZERO_SALT = new Uint8Array(32);
+
+export function hkdfSha256(
+  ikm: Uint8Array,
+  salt: Uint8Array | undefined,
+  info: string,
+  length: number
+): Uint8Array {
+  return hkdf(sha256, ikm, salt ?? ZERO_SALT, utf8ToBytes(info), length);
+}
+
+export function hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array {
+  return hmac(sha256, key, data);
+}
+
+export function aesEncrypt(
+  key: Uint8Array,
+  iv: Uint8Array,
+  data: Uint8Array
+): Uint8Array {
+  return cbc(key, iv).encrypt(data);
+}
+
+export function aesDecrypt(
+  key: Uint8Array,
+  iv: Uint8Array,
+  data: Uint8Array
+): Uint8Array {
+  return cbc(key, iv).decrypt(data);
+}
+
+export function generateKeyPair(): KeyPair {
+  const { secretKey, publicKey } = x25519.keygen();
+  return { priv: secretKey, pub: publicKey };
+}
+
+export function generateIdentity(): IdentityKey {
+  const { secretKey, publicKey } = ed25519.keygen();
+  return { seed: secretKey, pub: publicKey };
+}
+
+export function dh(priv: Uint8Array, pub: Uint8Array): Uint8Array {
+  return x25519.getSharedSecret(priv, pub);
+}
+
+export function identityDhPrivate(identity: IdentityKey): Uint8Array {
+  return ed25519.utils.toMontgomerySecret(identity.seed);
+}
+
+export function identityDhPublic(identityPub: Uint8Array): Uint8Array {
+  return ed25519.utils.toMontgomery(identityPub);
+}
+
+export function sign(identity: IdentityKey, message: Uint8Array): Uint8Array {
+  return ed25519.sign(message, identity.seed);
+}
+
+export function verify(
+  signature: Uint8Array,
+  message: Uint8Array,
+  identityPub: Uint8Array
+): boolean {
+  try {
+    return ed25519.verify(signature, message, identityPub);
+  } catch {
+    return false;
+  }
+}
+
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) {return false;}
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {diff |= a[i]! ^ b[i]!;}
+  return diff === 0;
+}
+
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const B64_VALUE = new Int16Array(128).fill(-1);
+for (let i = 0; i < B64.length; i++) {B64_VALUE[B64.charCodeAt(i)] = i;}
+
+export function toBase64(bytes: Uint8Array): string {
+  let out = '';
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const n = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!;
+    out += B64[n >> 18]! + B64[(n >> 12) & 63]! + B64[(n >> 6) & 63]! + B64[n & 63]!;
+  }
+  if (i + 1 === bytes.length) {
+    const n = bytes[i]! << 16;
+    out += B64[n >> 18]! + B64[(n >> 12) & 63]! + '==';
+  } else if (i + 2 === bytes.length) {
+    const n = (bytes[i]! << 16) | (bytes[i + 1]! << 8);
+    out += B64[n >> 18]! + B64[(n >> 12) & 63]! + B64[(n >> 6) & 63]! + '=';
+  }
+  return out;
+}
+
+export function fromBase64(text: string): Uint8Array {
+  const clean = text.replace(/\s+/g, '').replace(/=+$/, '');
+  if (clean.length % 4 === 1) {throw new Error('Invalid base64');}
+  const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+  let acc = 0;
+  let bits = 0;
+  let pos = 0;
+  for (let i = 0; i < clean.length; i++) {
+    const code = clean.charCodeAt(i);
+    const value = code < 128 ? B64_VALUE[code]! : -1;
+    if (value < 0) {throw new Error('Invalid base64');}
+    acc = (acc << 6) | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[pos++] = (acc >> bits) & 0xff;
+    }
+  }
+  return out;
+}
+
+export function toHex(bytes: Uint8Array): string {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+export function randomInt(min: number, max: number): number {
+  const bytes = randomBytes(4);
+  const n = new DataView(bytes.buffer, bytes.byteOffset, 4).getUint32(0);
+  return min + (n % (max - min + 1));
+}
+
+export function bytesToUtf8(bytes: Uint8Array): string {
+  const chunks: string[] = [];
+  let units: number[] = [];
+  const push = (unit: number) => {
+    units.push(unit);
+    if (units.length >= 8192) {
+      chunks.push(String.fromCharCode.apply(null, units));
+      units = [];
+    }
+  };
+
+  let i = 0;
+  while (i < bytes.length) {
+    const b = bytes[i++]!;
+    if (b < 0x80) {
+      push(b);
+      continue;
+    }
+    const extra = b >= 0xf0 && b < 0xf8 ? 3 : b >= 0xe0 ? 2 : b >= 0xc2 ? 1 : -1;
+    let code = extra === 3 ? b & 0x07 : extra === 2 ? b & 0x0f : b & 0x1f;
+    let valid = extra > 0 && b < 0xf8 && i + extra <= bytes.length;
+    for (let k = 0; valid && k < extra; k++) {
+      const next = bytes[i + k]!;
+      if ((next & 0xc0) !== 0x80) {valid = false;}
+      code = (code << 6) | (next & 0x3f);
+    }
+    if (
+      !valid ||
+      (extra === 2 && code < 0x800) ||
+      (extra === 3 && (code < 0x10000 || code > 0x10ffff)) ||
+      (code >= 0xd800 && code <= 0xdfff)
+    ) {
+      push(0xfffd);
+      continue;
+    }
+    i += extra;
+    if (code > 0xffff) {
+      code -= 0x10000;
+      push(0xd800 | (code >> 10));
+      push(0xdc00 | (code & 0x3ff));
+    } else {
+      push(code);
+    }
+  }
+  if (units.length) {chunks.push(String.fromCharCode.apply(null, units));}
+  return chunks.join('');
+}

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)
+  );
+}