@ethora/chat-component 26.7.9 → 26.8.2

package/dist/e2ee/index.d.ts

@@ -0,0 +1,53 @@
+import { Client } from '@xmpp/client';
+import { Omemo } from './omemo';
+export { NS_OMEMO, FALLBACK_BODY, formatFingerprint } from './omemo';
+export type { Decrypted, DeviceInfo, Trust } from './omemo';
+export { Omemo } from './omemo';
+/**
+ * Set from IConfig when the chat mounts.
+ *
+ * The config effect and the XMPP `online` event race, and either order is
+ * normal, so both this and onOnline() end in the same maybeStart().
+ */
+export declare function setE2eeEnabled(value: boolean): void;
+export declare function isE2eeEnabled(): boolean;
+/** Called once the XMPP session is up. */
+export declare function onOnline(client: Client): void;
+/** Drops the in-memory instance. Stored keys survive, so a re-login resumes. */
+export declare function stopOmemo(): void;
+/** The live instance, or undefined when encryption is off / not ready. */
+export declare function omemo(): Omemo | undefined;
+/**
+ * The instance once it is usable, rather than whatever exists right now.
+ *
+ * Publishing this device's bundle takes a round trip, and the server starts
+ * pushing archived messages the moment we join a room - so the first page of
+ * history routinely arrives while OMEMO is still starting. Reading `omemo()`
+ * there returns undefined and those messages get permanently rendered as
+ * undecryptable, even though the keys to read them land a moment later.
+ * Awaiting this instead makes the seam wait out that window.
+ */
+export declare function omemoReady(): Promise<Omemo | undefined>;
+/** True when the backend marked this room as end-to-end encrypted. */
+export declare function isE2eeRoom(roomJid: string): boolean;
+/**
+ * Bare JIDs to encrypt for: every member of the room.
+ *
+ * The member list comes from `GET /v1/chats/my` (RoomMember.xmppUsername), so
+ * it is the backend's view of who belongs to the room, not the list of who
+ * happens to be joined right now. That is what we want - somebody offline
+ * still has to be able to read the message later.
+ */
+export declare function roomRecipients(roomJid: string, domain: string): string[];
+/**
+ * The real bare JID behind a MUC `from`.
+ *
+ * `room@conference.host/nick` -> `nick@host`. This works because the SDK
+ * always joins with `client.jid.getLocal()` as the nick (presenceInRoom and
+ * createRoomPresence), so the nick IS the account's localpart. It is also why
+ * OMEMO works here without making rooms non-anonymous: we never need the MUC
+ * to disclose real JIDs.
+ */
+export declare function senderJidFromMuc(from: string | undefined, domain: string): string | undefined;
+/** Account domain taken from our own JID, e.g. "dappros.com". */
+export declare function accountDomain(client: Client | undefined): string;

package/dist/e2ee/omemo.d.ts

@@ -0,0 +1,130 @@
+import { Client } from '@xmpp/client';
+import { Element } from 'ltx';
+import { OmemoStore } from './store';
+export declare const NS_OMEMO = "urn:xmpp:omemo:2";
+/**
+ * The cleartext <body> of an encrypted stanza.
+ *
+ * Two audiences, one string, and it cannot be localised for either: it is
+ * written once by the sender, who does not know the reader's language.
+ *
+ * - clients that cannot read `urn:xmpp:omemo:2` render it in place of the
+ *   message;
+ * - the server's push module copies it into `msgText`, so it is what lands on
+ *   a lock screen. That rules out anything phrased as an error - keep it to a
+ *   short, neutral label.
+ */
+export declare const FALLBACK_BODY = "Encrypted message";
+/** Blind Trust Before Verification: new devices are trusted until one is verified. */
+export type Trust = 'blind' | 'verified' | 'untrusted';
+export interface Decrypted {
+    /**
+     * Content of the SCE envelope: the original <body>, <data> and whatever
+     * else the sender put there, serialized back to XML. Undefined for empty
+     * messages, which exist only to advance a session.
+     */
+    content?: string;
+    /** 'own' - sent from this device, read back from the local cache. */
+    trust: Trust | 'own';
+    error?: string;
+}
+export interface DeviceInfo {
+    id: number;
+    fingerprint: string;
+    trust: Trust | 'own';
+}
+/** Identity key fingerprint as shown to users: hex in groups of 8. */
+export declare function formatFingerprint(ik: Uint8Array): string;
+/** OMEMO 2 for one account on this device, across the MUC rooms it is in. */
+export declare class Omemo {
+    /** Our own bare JID. */
+    readonly jid: string;
+    private readonly xmpp;
+    private readonly store;
+    private keys;
+    private queue;
+    private deviceLists;
+    private constructor();
+    /** Loads (or creates) this device's keys and publishes them. */
+    static create(xmpp: Client, jid: string, store: OmemoStore): Promise<Omemo>;
+    get deviceId(): number;
+    get fingerprint(): string;
+    /** Runs tasks one at a time: sessions and keys are read-modify-write. */
+    private serial;
+    /**
+     * Publishes, and repairs the node if its configuration blocks us.
+     *
+     * Without this, one server-side change to the PEP node configuration locks
+     * every existing account out of publishing its keys for good: the device
+     * can never announce itself, so nobody can encrypt to it and everything it
+     * sends silently degrades to plaintext. Reconfiguring is tried first
+     * because it keeps the published items; deleting the node is the last
+     * resort, and costs only bundles that every device republishes on its next
+     * login anyway.
+     */
+    private publishWithRecovery;
+    /** Rewrites an existing node's configuration to what we publish against. */
+    private configureNode;
+    private deleteNode;
+    private publish;
+    private fetchItems;
+    private fetchDeviceList;
+    private deviceIds;
+    /** Adds this device to our published device list. */
+    private announceDevice;
+    private publishBundle;
+    private fetchBundle;
+    /** Records the device's identity key on first sight and returns its trust. */
+    private trustOf;
+    /** Devices of `jid` (fetching unknown bundles), including this one for our own JID. */
+    devices(jid: string): Promise<DeviceInfo[]>;
+    setTrust(jid: string, id: number, trust: Trust): Promise<void>;
+    /** Encrypts `keyMaterial` for every trusted device of `jid` (except this one). */
+    private encryptKey;
+    /**
+     * Builds the encrypted groupchat stanza for `roomJid`.
+     *
+     * The plaintext stanza's children are split in two:
+     *
+     * - `content` goes inside the SCE envelope and is what OMEMO protects.
+     *   Today that is <body> alone.
+     * - `cleartext` is appended to the stanza untouched, beside <encrypted>.
+     *   That is Ethora's <data> element, which the server's push module reads
+     *   directly off the wire (get_data_map in mod_offline_post takes the
+     *   first <data> sub-element); encrypting it turns every notification into
+     *   a bare JID localpart plus FALLBACK_BODY.
+     *
+     * Nothing in `cleartext` is protected in any way - it is archived in MAM
+     * and POSTed to the push service exactly as an unencrypted room's would
+     * be. Keep it to what the server genuinely has to read, and never move a
+     * message's text into it.
+     *
+     * `members` are the bare JIDs of everyone in the room - ours is added
+     * automatically so our other devices can read it too. `id` must be the id
+     * the plaintext stanza would have used, because the optimistic UI matches
+     * the room's echo by it.
+     */
+    encryptGroupMessage(roomJid: string, members: string[], content: Element[], id: string, cleartext?: Element[]): Promise<Element>;
+    /**
+     * Empty OMEMO message: completes a session the peer started. It targets one
+     * device, so it goes straight to that member's real JID rather than through
+     * the room.
+     */
+    private sendEmpty;
+    /**
+     * Decrypts one OMEMO stanza. `sender` is the real bare JID of the author
+     * (resolved from the room nick by the caller) and `roomJid` the room it
+     * arrived in. Returns undefined when the stanza carries no OMEMO payload.
+     */
+    decrypt(el: Element, sender: string, roomJid: string): Promise<Decrypted> | undefined;
+    private decryptUncached;
+    /**
+     * Checks the SCE envelope (XEP-0420) and returns its content as XML.
+     *
+     * The from/to check is what stops one member replaying another's encrypted
+     * message under their own nick: `from` must be the JID the room nick
+     * resolves to, and `to` must be the room the stanza arrived in.
+     */
+    private openEnvelope;
+    private replacePrekey;
+}

package/dist/e2ee/protobuf.d.ts

@@ -0,0 +1,25 @@
+export interface OmemoMessage {
+    n: number;
+    pn: number;
+    dhPub: Uint8Array;
+    ciphertext?: Uint8Array;
+}
+export declare function encodeMessage(m: OmemoMessage): Uint8Array;
+export declare function decodeMessage(buf: Uint8Array): OmemoMessage;
+export interface AuthenticatedMessage {
+    mac: Uint8Array;
+    /** Encoded OMEMOMessage. */
+    message: Uint8Array;
+}
+export declare function encodeAuthenticated(m: AuthenticatedMessage): Uint8Array;
+export declare function decodeAuthenticated(buf: Uint8Array): AuthenticatedMessage;
+export interface KeyExchange {
+    pkId: number;
+    spkId: number;
+    ik: Uint8Array;
+    ek: Uint8Array;
+    /** Encoded OMEMOAuthenticatedMessage. */
+    message: Uint8Array;
+}
+export declare function encodeKeyExchange(m: KeyExchange): Uint8Array;
+export declare function decodeKeyExchange(buf: Uint8Array): KeyExchange;

package/dist/e2ee/ratchet.d.ts

@@ -0,0 +1,54 @@
+import { IdentityKey, KeyPair } from './crypto';
+export interface Bundle {
+    ik: Uint8Array;
+    spkId: number;
+    spk: Uint8Array;
+    spkSignature: Uint8Array;
+    pkId: number;
+    pk: Uint8Array;
+}
+export interface Session {
+    rk: Uint8Array;
+    dhs: KeyPair;
+    dhr?: Uint8Array;
+    cks?: Uint8Array;
+    ckr?: Uint8Array;
+    ns: number;
+    nr: number;
+    pn: number;
+    /** Message keys of skipped messages, by `${dhPub}:${n}`, oldest first. */
+    skipped: Record<string, Uint8Array>;
+    /** X3DH associated data: initiator IK || responder IK. */
+    ad: Uint8Array;
+    /** The peer device's Ed25519 identity key. */
+    peerIk: Uint8Array;
+    /** We initiated and got no reply yet: wrap outgoing messages in a key exchange. */
+    pendingKex?: {
+        pkId: number;
+        spkId: number;
+        ek: Uint8Array;
+    };
+    /** Ephemeral key of the key exchange that created this session (responder side). */
+    kexEk?: Uint8Array;
+}
+/** Starts a session with a device from its published bundle (X3DH, active side). */
+export declare function initiateSession(own: IdentityKey, bundle: Bundle): Session;
+/** Builds the session from a received key exchange (X3DH, passive side). */
+export declare function acceptSession(own: IdentityKey, spk: KeyPair, pk: KeyPair, peerIk: Uint8Array, ek: Uint8Array): Session;
+/** Encrypts with the sending chain; returns an encoded OMEMOAuthenticatedMessage. */
+export declare function ratchetEncrypt(session: Session, plaintext: Uint8Array): [Session, Uint8Array];
+/**
+ * Decrypts an encoded OMEMOAuthenticatedMessage. The input session is left
+ * untouched; the returned one must be stored only after the whole message
+ * was processed successfully.
+ */
+export declare function ratchetDecrypt(session: Session, data: Uint8Array): [Session, Uint8Array];
+/**
+ * Encrypts the SCE envelope. `keyMaterial` (key || truncated HMAC, 48 bytes)
+ * is what gets encrypted for every recipient device.
+ */
+export declare function encryptPayload(plaintext: Uint8Array): {
+    keyMaterial: Uint8Array;
+    payload: Uint8Array;
+};
+export declare function decryptPayload(keyMaterial: Uint8Array, payload: Uint8Array): Uint8Array;

package/dist/e2ee/stanza.d.ts

@@ -0,0 +1,24 @@
+import { Element } from 'ltx';
+export type DecryptOutcome = 
+/** No OMEMO payload; the caller should carry on as before. */
+'not-encrypted'
+/** Rewritten with the sender's original children. */
+ | 'decrypted'
+/** Rewritten with a placeholder body; still a message worth showing. */
+ | 'undecryptable'
+/** Session maintenance only - there is nothing to render, skip it. */
+ | 'drop';
+/**
+ * Finds the <message> that actually carries <encrypted>, looking through the
+ * wrappers a message can arrive in: a mucsub event, a MAM <result>/<forwarded>
+ * pair, or both at once.
+ */
+export declare function encryptedCarrier(stanza: Element, depth?: number): Element | undefined;
+/**
+ * Decrypts `stanza` in place, if it carries OMEMO at all.
+ *
+ * `stanza` may be the message itself or anything wrapping it. Safe to call on
+ * every message: without an OMEMO payload it returns immediately and touches
+ * nothing.
+ */
+export declare function decryptStanzaInPlace(stanza: Element, domain: string): Promise<DecryptOutcome>;

package/dist/e2ee/store.d.ts

@@ -0,0 +1,12 @@
+/** Key-value storage for OMEMO keys, sessions and decrypted messages. */
+export interface OmemoStore {
+    get<T>(key: string): Promise<T | undefined>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * IndexedDB database per account. Private keys are stored unencrypted, like
+ * in other web clients: anyone with access to this browser profile can read them.
+ */
+export declare function openIndexedDbStore(jid: string): Promise<OmemoStore>;
+export declare function createMemoryStore(): OmemoStore;

package/dist/{handleCopyClick-CdTri-Fg.js → handleCopyClick-tizCFAb8.js}

@@ -1,4 +1,4 @@
-import { v as e, x as t } from "./main-BNdWGLpK.js";
+import { v as e, x as t } from "./main-DkokKp7d.js";
 const i = e.div`
   display: flex;
   flex-direction: column;

package/dist/helpers/findMessagesForFile.d.ts

@@ -0,0 +1,25 @@
+import { IRoom } from '../types/types';
+export interface FileMessageMatch {
+    roomJID: string;
+    messageId: string;
+}
+export interface DeletableFileRef {
+    _id: string;
+    roomName?: string;
+    location?: string;
+}
+/**
+ * Finds every locally loaded message that carries the given file, so
+ * deleting a file from the Files panel can also tombstone its chat
+ * message(s) instead of leaving a broken-image bubble behind.
+ *
+ * `file.roomName` is checked first: sent-media messages stamp `attachmentId`
+ * on the message (see useSendMessage.tsx / sendMediaMessage.xmpp.ts) with
+ * the same id the backend gives the file, and the Files API's `roomName`
+ * field actually holds the room's JID (see FilesList.tsx / bug 3), so most
+ * of the time the right room is known outright. When that doesn't resolve
+ * anything - a different backend shape, or the id genuinely isn't on the
+ * message - every locally loaded room is searched by attachment location as
+ * a fallback, since a matching URL is still a correct match.
+ */
+export declare const findMessagesForFile: (rooms: Record<string, IRoom>, file: DeletableFileRef) => FileMessageMatch[];

package/dist/helpers/xmppIdShape.d.ts

@@ -0,0 +1,9 @@
+export declare const toLocalPart: (value?: string) => string;
+/**
+ * True when `value` (a full JID or already-bare local part) is a
+ * machine-generated Ethora id rather than anything a human would recognize
+ * as their own name - `<24 hex>_<24 hex>` (appId_userId) or a bare 24-hex
+ * id. Kept narrow on purpose: a handle a person actually picked is never
+ * this shape, so it is never mistaken for one.
+ */
+export declare const isOpaqueXmppUserId: (value: string | undefined | null) => boolean;

package/dist/helpers/xmppUsername.d.ts

@@ -1,3 +1,3 @@
-export declare const toLocalPart: (value?: string) => string;
+export { toLocalPart, isOpaqueXmppUserId } from './xmppIdShape';
 export declare const normalizeXmppUsername: (value: string | undefined | null) => string;
 export declare const isSameXmppUsername: (a: string | undefined | null, b: string | undefined | null) => boolean;

package/dist/hooks/useChatWrapperInit.d.ts

@@ -17,6 +17,10 @@ interface useChatWrapperInitResult {
 }
 export declare const resolveLegacyTranslatesLangSource: (translatesConfig?: IConfig["translates"]) => Iso639_1Codes | undefined;
 export declare const resolveExternalReaderLocaleLangSource: (readerLocale?: string) => Iso639_1Codes | undefined;
-export declare const isStatusConnectionLost: (status?: string | null) => boolean;
+export declare const isStatusConnectionLost: (status?: string | null, isRecoveringAuth?: boolean, hasEverBeenOnline?: boolean) => boolean;
+export declare const hasHostRefreshedSession: (user: {
+    xmppUsername?: string;
+    xmppPassword?: string;
+}) => boolean;
 declare const useChatWrapperInit: ({ roomJID, wasAutoSelected, config, }: useChatWrapperInitProps) => useChatWrapperInitResult;
 export default useChatWrapperInit;