@ethora/chat-component-rn 26.10.6 → 26.10.7

package/lib/module/push/pushKeyStore.js

@@ -0,0 +1,159 @@
+"use strict";
+
+import { fromBase64, toBase64 } from '../e2ee/crypto';
+import { loadSecureStore } from '../helpers/secureStoreRuntime';
+import { pushLog } from '../utils/devLogger';
+import { SEALED_BOX_PUBLIC_KEY_BYTES, SEALED_BOX_SECRET_KEY_BYTES, generateSealedBoxKeyPair, sealedBoxKeyId, sealedBoxPublicKeyOf } from './sealedBox';
+// The device key for encrypted pushes: one X25519 pair per install, in the
+// platform keychain / keystore through expo-secure-store. The public half
+// goes to the push service with the token (`pushKey`); the secret half
+// never leaves the device and is read by whoever renders a sealed push —
+// the Android background task (`sealedPushTask.ts`, same process, same
+// store) and the iOS notification service extension, which reads the
+// keychain item directly (plugins/notification-service), so the item's
+// attributes below are a contract with the Swift side:
+//   service   `ethora.push` (expo-secure-store stores it as `ethora.push:no-auth`)
+//   account   `ethora_push_secret_key`, UTF-8
+//   value     base64 of the 32-byte secret key, UTF-8
+//   group     the app's first keychain access group, which the config
+//             plugin shares with the extension
+// Readable after the first unlock so a push that arrives while the phone
+// is locked still decrypts; this device only, so an iCloud keychain copy
+// on another device is never a key for pushes that go to this one.
+
+export const PUSH_KEY_KEYCHAIN_SERVICE = 'ethora.push';
+export const PUSH_SECRET_KEY_ITEM = 'ethora_push_secret_key';
+export const PUSH_PUBLIC_KEY_ITEM = 'ethora_push_public_key';
+let warnedMissingStore = false;
+const warnMissingStoreOnce = () => {
+  if (warnedMissingStore) {
+    return;
+  }
+  warnedMissingStore = true;
+  pushLog('warn', 'push: expo-secure-store is not installed, so no device key for encrypted ' + 'pushes can be kept; pushes stay in the clear.');
+};
+const storeOptions = () => {
+  const store = loadSecureStore();
+  if (!store) {
+    return null;
+  }
+  const accessible = store.accessible.afterFirstUnlockThisDeviceOnly;
+  return {
+    keychainService: PUSH_KEY_KEYCHAIN_SERVICE,
+    ...(accessible !== undefined ? {
+      keychainAccessible: accessible
+    } : {})
+  };
+};
+const readItem = async item => {
+  const store = loadSecureStore();
+  const options = storeOptions();
+  if (!store || !options) {
+    return null;
+  }
+  try {
+    return await store.getItemAsync(item, options);
+  } catch (e) {
+    pushLog('warn', `push: reading ${item} failed`, e);
+    return null;
+  }
+};
+const decodeKey = (raw, length) => {
+  if (!raw) {
+    return null;
+  }
+  try {
+    const bytes = fromBase64(raw);
+    return bytes.length === length ? bytes : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The stored pair, or null when there is none (or it is unreadable).
+ * The public key is re-derived from the secret, so the pair is consistent
+ * even if only the secret item survived.
+ */
+export async function loadPushSecretKey() {
+  const secretKey = decodeKey(await readItem(PUSH_SECRET_KEY_ITEM), SEALED_BOX_SECRET_KEY_BYTES);
+  if (!secretKey) {
+    return null;
+  }
+  const stored = decodeKey(await readItem(PUSH_PUBLIC_KEY_ITEM), SEALED_BOX_PUBLIC_KEY_BYTES);
+  return {
+    publicKey: stored ?? sealedBoxPublicKeyOf(secretKey),
+    secretKey
+  };
+}
+const describe = publicKey => ({
+  publicKey: toBase64(publicKey),
+  keyId: sealedBoxKeyId(publicKey)
+});
+
+/** The public half of the stored pair, null when the device has no key. */
+export async function getPushKeyPair() {
+  const key = await loadPushSecretKey();
+  return key ? describe(key.publicKey) : null;
+}
+
+/**
+ * Generate and store a new pair, replacing any existing one. Pushes sealed
+ * for the old key stop opening at once, so re-register the token with the
+ * new `publicKey` right after. Null when expo-secure-store is missing or
+ * the keychain refused the write.
+ */
+export async function resetPushKeyPair() {
+  const store = loadSecureStore();
+  const options = storeOptions();
+  if (!store || !options) {
+    warnMissingStoreOnce();
+    return null;
+  }
+  const pair = generateSealedBoxKeyPair();
+  try {
+    await store.setItemAsync(PUSH_SECRET_KEY_ITEM, toBase64(pair.secretKey), options);
+    await store.setItemAsync(PUSH_PUBLIC_KEY_ITEM, toBase64(pair.publicKey), options);
+  } catch (e) {
+    pushLog('warn', 'push: storing the device key failed', e);
+    return null;
+  }
+  const check = await loadPushSecretKey();
+  if (!check || toBase64(check.publicKey) !== toBase64(pair.publicKey)) {
+    pushLog('warn', 'push: the device key was not kept');
+    return null;
+  }
+  pushLog('rn', `push: new device key ${sealedBoxKeyId(pair.publicKey)}`);
+  return describe(pair.publicKey);
+}
+
+/**
+ * The device key for encrypted pushes, created on first call. Hand
+ * `publicKey` to `registerPushToken` (or send it as `pushKey` yourself).
+ */
+export async function ensurePushKeyPair() {
+  const existing = await getPushKeyPair();
+  return existing ?? resetPushKeyPair();
+}
+
+/** Remove the pair; the next `ensurePushKeyPair` creates a new one. */
+export async function clearPushKeyPair() {
+  const store = loadSecureStore();
+  const options = storeOptions();
+  if (!store || !options) {
+    return;
+  }
+  for (const item of [PUSH_SECRET_KEY_ITEM, PUSH_PUBLIC_KEY_ITEM]) {
+    try {
+      await store.deleteItemAsync(item, options);
+    } catch {
+      // Not there — nothing to remove.
+    }
+  }
+}
+
+/** Test seam only. */
+export const __resetPushKeyStoreForTests = () => {
+  warnedMissingStore = false;
+};
+//# sourceMappingURL=pushKeyStore.js.map

package/lib/module/push/pushKeyStore.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fromBase64","toBase64","loadSecureStore","pushLog","SEALED_BOX_PUBLIC_KEY_BYTES","SEALED_BOX_SECRET_KEY_BYTES","generateSealedBoxKeyPair","sealedBoxKeyId","sealedBoxPublicKeyOf","PUSH_KEY_KEYCHAIN_SERVICE","PUSH_SECRET_KEY_ITEM","PUSH_PUBLIC_KEY_ITEM","warnedMissingStore","warnMissingStoreOnce","storeOptions","store","accessible","afterFirstUnlockThisDeviceOnly","keychainService","undefined","keychainAccessible","readItem","item","options","getItemAsync","e","decodeKey","raw","length","bytes","loadPushSecretKey","secretKey","stored","publicKey","describe","keyId","getPushKeyPair","key","resetPushKeyPair","pair","setItemAsync","check","ensurePushKeyPair","existing","clearPushKeyPair","deleteItemAsync","__resetPushKeyStoreForTests"],"sourceRoot":"../../../src","sources":["push/pushKeyStore.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/push/sealedBox.js

@@ -0,0 +1,97 @@
+"use strict";
+
+import { hsalsa, xsalsa20poly1305 } from '@noble/ciphers/salsa.js';
+import { clean, concatBytes, u32, u8, utf8ToBytes } from '@noble/ciphers/utils.js';
+import { x25519 } from '@noble/curves/ed25519.js';
+import { blake2b } from '@noble/hashes/blake2.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+
+// libsodium's sealed box (`crypto_box_seal` / `crypto_box_seal_open`) on
+// the noble primitives the e2ee code already ships, so the JS side needs
+// no native libsodium. The push service seals every chat push for a
+// device that registered an X25519 public key (ethora-backend,
+// services/push/README.md, "Encrypted pushes"); this is the matching
+// receiver. The iOS notification service extension decrypts the same
+// boxes in Swift with libsodium (plugins/notification-service).
+//
+// Layout: ephemeral public key (32) || crypto_box(message, nonce,
+// recipient pk, ephemeral sk), with crypto_box = XSalsa20-Poly1305 under
+// HSalsa20(X25519 shared secret) and nonce = BLAKE2b-192(epk || rpk).
+// `__tests__/sealedBox.test.ts` pins this against libsodium itself.
+
+export const SEALED_BOX_PUBLIC_KEY_BYTES = 32;
+export const SEALED_BOX_SECRET_KEY_BYTES = 32;
+/** Ephemeral public key (32) + Poly1305 tag (16). */
+export const SEALED_BOX_OVERHEAD_BYTES = 48;
+const NONCE_BYTES = 24;
+const SIGMA = u32(utf8ToBytes('expand 32-byte k'));
+const ZERO_NONCE_PREFIX = new Uint32Array(4);
+export const generateSealedBoxKeyPair = () => {
+  const {
+    secretKey,
+    publicKey
+  } = x25519.keygen();
+  return {
+    publicKey,
+    secretKey
+  };
+};
+export const sealedBoxPublicKeyOf = secretKey => x25519.getPublicKey(secretKey);
+
+/**
+ * The key id the push service derives when the registration carries none:
+ * the first 16 hex characters of SHA-256 over the raw public key. Sent back
+ * as `kid` in every sealed push.
+ */
+export const sealedBoxKeyId = publicKey => bytesToHex(sha256(publicKey)).slice(0, 16);
+
+// crypto_box_beforenm: HSalsa20 over the X25519 shared secret.
+const boxSharedKey = (theirPublicKey, mySecretKey) => {
+  const shared = x25519.getSharedSecret(mySecretKey, theirPublicKey);
+  const words = new Uint32Array(8);
+  hsalsa(SIGMA, u32(shared), ZERO_NONCE_PREFIX, words);
+  clean(shared);
+  return u8(words);
+};
+const sealNonce = (ephemeralPublicKey, recipientPublicKey) => blake2b(concatBytes(ephemeralPublicKey, recipientPublicKey), {
+  dkLen: NONCE_BYTES
+});
+
+/** `crypto_box_seal`: used by the tests and the key tool, not by the app. */
+export function sealedBoxSeal(message, recipientPublicKey) {
+  if (recipientPublicKey.length !== SEALED_BOX_PUBLIC_KEY_BYTES) {
+    throw new Error('sealedBoxSeal: the public key must be 32 bytes');
+  }
+  const ephemeral = generateSealedBoxKeyPair();
+  const key = boxSharedKey(recipientPublicKey, ephemeral.secretKey);
+  const nonce = sealNonce(ephemeral.publicKey, recipientPublicKey);
+  const box = xsalsa20poly1305(key, nonce).encrypt(message);
+  clean(key, ephemeral.secretKey);
+  return concatBytes(ephemeral.publicKey, box);
+}
+
+/**
+ * `crypto_box_seal_open`. Returns null for anything that does not open:
+ * a wrong key, a box for another key, a damaged or truncated box.
+ */
+export function sealedBoxOpen(sealed, publicKey, secretKey) {
+  if (sealed.length < SEALED_BOX_OVERHEAD_BYTES || publicKey.length !== SEALED_BOX_PUBLIC_KEY_BYTES || secretKey.length !== SEALED_BOX_SECRET_KEY_BYTES) {
+    return null;
+  }
+  const ephemeralPublicKey = sealed.subarray(0, SEALED_BOX_PUBLIC_KEY_BYTES);
+  const box = sealed.subarray(SEALED_BOX_PUBLIC_KEY_BYTES);
+  let key = null;
+  try {
+    key = boxSharedKey(ephemeralPublicKey, secretKey);
+    const nonce = sealNonce(ephemeralPublicKey, publicKey);
+    return xsalsa20poly1305(key, nonce).decrypt(box);
+  } catch {
+    return null;
+  } finally {
+    if (key) {
+      clean(key);
+    }
+  }
+}
+//# sourceMappingURL=sealedBox.js.map

package/lib/module/push/sealedBox.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hsalsa","xsalsa20poly1305","clean","concatBytes","u32","u8","utf8ToBytes","x25519","blake2b","sha256","bytesToHex","SEALED_BOX_PUBLIC_KEY_BYTES","SEALED_BOX_SECRET_KEY_BYTES","SEALED_BOX_OVERHEAD_BYTES","NONCE_BYTES","SIGMA","ZERO_NONCE_PREFIX","Uint32Array","generateSealedBoxKeyPair","secretKey","publicKey","keygen","sealedBoxPublicKeyOf","getPublicKey","sealedBoxKeyId","slice","boxSharedKey","theirPublicKey","mySecretKey","shared","getSharedSecret","words","sealNonce","ephemeralPublicKey","recipientPublicKey","dkLen","sealedBoxSeal","message","length","Error","ephemeral","key","nonce","box","encrypt","sealedBoxOpen","sealed","subarray","decrypt"],"sourceRoot":"../../../src","sources":["push/sealedBox.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/push/sealedPush.js

@@ -0,0 +1,117 @@
+"use strict";
+
+import { fromBase64 } from '../e2ee/crypto';
+import { sealedBoxKeyId, sealedBoxOpen } from './sealedBox';
+
+// The envelope of an encrypted chat push (ethora-backend,
+// services/push/README.md, "Encrypted pushes"): the FCM `data` map on
+// Android, the custom keys next to `aps` on iOS. Only ids travel in the
+// clear; everything shown to the user is inside `enc`, a sealed box for
+// the key the device registered with its token.
+
+export const SEALED_PUSH_ALG = 'sealed-box-x25519';
+export const SEALED_PUSH_VERSION = '1';
+
+/** What the box holds: the notification the service would have sent in the clear. */
+
+const str = value => typeof value === 'string' ? value : '';
+
+/** The envelope of `data` when it is a sealed chat push, else null. */
+export const sealedPushEnvelopeOf = data => {
+  if (!data || data.alg !== SEALED_PUSH_ALG) {
+    return null;
+  }
+  const enc = str(data.enc);
+  return {
+    v: str(data.v) || SEALED_PUSH_VERSION,
+    alg: SEALED_PUSH_ALG,
+    kid: str(data.kid),
+    jid: str(data.jid),
+    msgID: str(data.msgID),
+    userJid: str(data.userJid),
+    ...(enc ? {
+      enc
+    } : {})
+  };
+};
+export const isSealedPush = data => sealedPushEnvelopeOf(data) !== null;
+const parseContent = plaintext => {
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(plaintext));
+    if (!parsed || typeof parsed !== 'object') {
+      return null;
+    }
+    return {
+      title: str(parsed.title),
+      body: str(parsed.body),
+      sender: str(parsed.sender),
+      senderJid: str(parsed.senderJid),
+      chat: str(parsed.chat),
+      chatJid: str(parsed.chatJid),
+      msgID: str(parsed.msgID),
+      image: str(parsed.image)
+    };
+  } catch {
+    return null;
+  }
+};
+/**
+ * Open a sealed push with the device key. `key` null means there is no key
+ * on this device. Never throws: every failure names why, so the caller can
+ * show the placeholder and log the reason.
+ */
+export function openSealedPush(envelope, key) {
+  if (!key) {
+    return {
+      ok: false,
+      reason: 'no-key',
+      envelope
+    };
+  }
+  if (envelope.kid && envelope.kid !== sealedBoxKeyId(key.publicKey)) {
+    return {
+      ok: false,
+      reason: 'key-mismatch',
+      envelope
+    };
+  }
+  if (!envelope.enc) {
+    return {
+      ok: false,
+      reason: 'no-ciphertext',
+      envelope
+    };
+  }
+  let sealed;
+  try {
+    sealed = fromBase64(envelope.enc);
+  } catch {
+    return {
+      ok: false,
+      reason: 'bad-ciphertext',
+      envelope
+    };
+  }
+  const plaintext = sealedBoxOpen(sealed, key.publicKey, key.secretKey);
+  if (!plaintext) {
+    return {
+      ok: false,
+      reason: 'bad-ciphertext',
+      envelope
+    };
+  }
+  const content = parseContent(plaintext);
+  if (!content) {
+    return {
+      ok: false,
+      reason: 'bad-content',
+      envelope
+    };
+  }
+  return {
+    ok: true,
+    content,
+    envelope
+  };
+}
+//# sourceMappingURL=sealedPush.js.map

package/lib/module/push/sealedPush.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fromBase64","sealedBoxKeyId","sealedBoxOpen","SEALED_PUSH_ALG","SEALED_PUSH_VERSION","str","value","sealedPushEnvelopeOf","data","alg","enc","v","kid","jid","msgID","userJid","isSealedPush","parseContent","plaintext","parsed","JSON","parse","TextDecoder","decode","title","body","sender","senderJid","chat","chatJid","image","openSealedPush","envelope","key","ok","reason","publicKey","sealed","secretKey","content"],"sourceRoot":"../../../src","sources":["push/sealedPush.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/push/sealedPushTask.js

@@ -0,0 +1,187 @@
+"use strict";
+
+import { AppState, Platform } from 'react-native';
+import { pushLog } from '../utils/devLogger';
+import { loadPushSecretKey } from './pushKeyStore';
+import { openSealedPush, sealedPushEnvelopeOf } from './sealedPush';
+
+// Android half of encrypted pushes. A sealed push is data-only, so the OS
+// shows nothing by itself: expo-notifications hands it to a background
+// task (expo-task-manager, foreground, background and killed app alike)
+// and this task opens the box and posts the notification. iOS does the
+// same in the notification service extension; here `registerSealedPushTask`
+// is a no-op.
+//
+// Both packages are optional peers, required lazily: a host that does not
+// want encrypted pushes never pays for them.
+
+export const SEALED_PUSH_TASK = 'ETHORA_SEALED_PUSH';
+const PLACEHOLDER_TITLE = 'New message';
+let registered = false;
+const loadTaskManager = () => {
+  try {
+    return require('expo-task-manager');
+  } catch {
+    return null;
+  }
+};
+const loadNotifications = () => {
+  try {
+    return require('expo-notifications');
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The FCM data map out of the task payload. expo-notifications passes the
+ * message as `{ notification, data }`; the data keys are on `data`
+ * itself, `data.dataString` carries the same as a JSON string on some
+ * versions, and a Firebase `RemoteMessage` keeps them under `data.data`.
+ */
+export const sealedPushDataOf = payload => {
+  const root = payload && typeof payload === 'object' ? payload : null;
+  if (!root) {
+    return null;
+  }
+  const candidates = [root.data, root];
+  const data = root.data && typeof root.data === 'object' ? root.data : null;
+  if (data) {
+    if (typeof data.dataString === 'string') {
+      try {
+        candidates.unshift(JSON.parse(data.dataString));
+      } catch {
+        // not JSON — fall through to the map itself
+      }
+    }
+    candidates.push(data.data);
+  }
+  for (const candidate of candidates) {
+    if (sealedPushEnvelopeOf(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+};
+const notificationContent = (result, options) => {
+  const {
+    envelope
+  } = result;
+  // What the tap handler (`handlePushPayload` through the host's response
+  // listener) needs: the same ids a plain push carries on `data`.
+  const data = {
+    jid: envelope.jid,
+    msgID: envelope.msgID,
+    userJid: envelope.userJid,
+    sealed: true
+  };
+  if (!result.ok) {
+    return {
+      title: options.placeholderTitle || PLACEHOLDER_TITLE,
+      ...(options.placeholderBody ? {
+        body: options.placeholderBody
+      } : {}),
+      data,
+      sound: 'default'
+    };
+  }
+  const {
+    content
+  } = result;
+  return {
+    title: content.title || content.sender || content.chat || PLACEHOLDER_TITLE,
+    body: content.body,
+    data: {
+      ...data,
+      chatJid: content.chatJid,
+      senderJid: content.senderJid
+    },
+    sound: 'default'
+  };
+};
+
+/**
+ * Open a sealed push and show it. One notification per chat: the room JID
+ * is the identifier, so a newer message replaces the older one the way the
+ * service's collapse key does for plain pushes.
+ */
+export async function presentSealedPush(data, options = {}) {
+  const envelope = sealedPushEnvelopeOf(data);
+  if (!envelope) {
+    return null;
+  }
+  const notifications = loadNotifications();
+  if (!notifications?.scheduleNotificationAsync) {
+    return null;
+  }
+  const result = openSealedPush(envelope, await loadPushSecretKey());
+  // console, not only pushLog: with the app killed this runs headless and
+  // `adb logcat -s ReactNativeJS` is the only place to see it.
+  if (result.ok) {
+    console.log(`[push] sealed push kid=${envelope.kid} opened for ${envelope.jid}`);
+  } else {
+    console.warn(`[push] sealed push kid=${envelope.kid} not opened (${result.reason}), showing the placeholder`);
+    pushLog('warn', `push: sealed push not opened (${result.reason}), showing the placeholder`);
+  }
+  await notifications.scheduleNotificationAsync({
+    identifier: envelope.jid || envelope.msgID || undefined,
+    content: notificationContent(result, options),
+    trigger: options.channelId ? {
+      channelId: options.channelId
+    } : null
+  });
+  return result;
+}
+
+/**
+ * Define and register the background task that renders sealed pushes on
+ * Android. Call it at module scope of a file the app loads first (the
+ * entry file, or the root layout with expo-router): a killed app is
+ * started headless to run it, and the task must exist by then. No-op on
+ * iOS and when expo-task-manager / expo-notifications are not installed.
+ */
+export function registerSealedPushTask(options = {}) {
+  if (Platform.OS !== 'android' || registered) {
+    return registered;
+  }
+  const taskManager = loadTaskManager();
+  const notifications = loadNotifications();
+  if (!taskManager?.defineTask || !notifications?.registerTaskAsync) {
+    pushLog('warn', 'push: expo-task-manager and expo-notifications are needed to show encrypted pushes on Android');
+    return false;
+  }
+  taskManager.defineTask(SEALED_PUSH_TASK, async ({
+    data,
+    error
+  }) => {
+    if (error) {
+      return;
+    }
+    const map = sealedPushDataOf(data);
+    if (!map) {
+      return;
+    }
+    // In the foreground the room is live over XMPP; the host's
+    // notification handler decides about plain pushes there too.
+    if (AppState.currentState === 'active') {
+      return;
+    }
+    try {
+      await presentSealedPush(map, options);
+    } catch (e) {
+      pushLog('warn', 'push: showing a sealed push failed', e);
+    }
+  });
+  registered = true;
+  notifications.registerTaskAsync(SEALED_PUSH_TASK).catch(e => {
+    registered = false;
+    pushLog('warn', 'push: registering the sealed push task failed', e);
+  });
+  return true;
+}
+
+/** Test seam only. */
+export const __resetSealedPushTaskForTests = () => {
+  registered = false;
+};
+//# sourceMappingURL=sealedPushTask.js.map

package/lib/module/push/sealedPushTask.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AppState","Platform","pushLog","loadPushSecretKey","openSealedPush","sealedPushEnvelopeOf","SEALED_PUSH_TASK","PLACEHOLDER_TITLE","registered","loadTaskManager","require","loadNotifications","sealedPushDataOf","payload","root","candidates","data","dataString","unshift","JSON","parse","push","candidate","notificationContent","result","options","envelope","jid","msgID","userJid","sealed","ok","title","placeholderTitle","placeholderBody","body","sound","content","sender","chat","chatJid","senderJid","presentSealedPush","notifications","scheduleNotificationAsync","console","log","kid","warn","reason","identifier","undefined","trigger","channelId","registerSealedPushTask","OS","taskManager","defineTask","registerTaskAsync","error","map","currentState","e","catch","__resetSealedPushTaskForTests"],"sourceRoot":"../../../src","sources":["push/sealedPushTask.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/services/pushRegistration.js

@@ -28,7 +28,7 @@ const readSession = () => {
 };
 const isGateway = session => !!session.gatewayUrl;
 const isReady = session => !!session.authToken && (isGateway(session) ? !!session.xmppUsername && !!session.projectName : !!session.appId);
-const sameRegistration = (token, current, session) => !!current && current.token === token.token && current.tokenType === token.tokenType && current.gateway === isGateway(session) && current.appId === session.appId && current.xmppUsername === session.xmppUsername;
+const sameRegistration = (token, current, session) => !!current && current.token === token.token && current.tokenType === token.tokenType && (current.pushKey || '') === (token.pushKey || '') && current.gateway === isGateway(session) && current.appId === session.appId && current.xmppUsername === session.xmppUsername;
 const slotsNeedingRegistration = session => SLOTS.filter(slot => {
   const token = held.get(slot);
   return !!token && !sameRegistration(token, registered.get(slot), session);
@@ -63,7 +63,8 @@ const registerOne = async (token, session) => {
       appId: session.appId,
       token: token.token,
       tokenType: token.tokenType,
-      authToken: session.authToken
+      authToken: session.authToken,
+      pushKey: token.pushKey
     });
   }
   registered.set(slotOf(token.tokenType), {
@@ -72,7 +73,7 @@ const registerOne = async (token, session) => {
     xmppUsername: session.xmppUsername,
     gateway: isGateway(session)
   });
-  pushLog('rn', `push: ${token.tokenType} token registered` + (isGateway(session) ? ' (gateway)' : ` for app ${session.appId}`));
+  pushLog('rn', `push: ${token.tokenType} token registered` + (isGateway(session) ? ' (gateway)' : ` for app ${session.appId}`) + (token.pushKey && !isGateway(session) ? ' with a device key (encrypted pushes)' : ''));
 };
 const registerNow = () => {
   if (inflight) {
@@ -117,7 +118,7 @@ const runTokenHook = session => {
       if (typeof entry?.token !== 'string' || !entry.token.trim()) {
         continue;
       }
-      hold(entry.token.trim(), entry.tokenType);
+      hold(entry.token.trim(), entry.tokenType, entry.pushKey);
     }
     await registerNow();
   })().catch(error => {
@@ -126,11 +127,15 @@ const runTokenHook = session => {
     pushLog('warn', 'push: getPushTokens failed; will retry', error);
   });
 };
-const hold = (token, tokenType) => {
+const hold = (token, tokenType, pushKey) => {
   const resolved = tokenType ?? detectPushTokenType(token);
+  const key = typeof pushKey === 'string' ? pushKey.trim() : '';
   const entry = {
     token,
-    tokenType: resolved
+    tokenType: resolved,
+    ...(key ? {
+      pushKey: key
+    } : {})
   };
   held.set(slotOf(resolved), entry);
   return entry;
@@ -178,7 +183,7 @@ export async function registerPushToken(token, options) {
   if (typeof token !== 'string' || !token.trim()) {
     throw new TypeError('registerPushToken: token must be a non-empty string');
   }
-  hold(token.trim(), options?.tokenType);
+  hold(token.trim(), options?.tokenType, options?.pushKey);
   ensureWatching();
   const session = readSession();
   if (session.pushDisabled) {