@vex-chat/libvex 6.0.1 → 6.1.0

package/src/Client.ts

@@ -498,7 +498,7 @@ export interface PendingDeviceRequest {
     requestID: string;
     signKey: string;
     status: PendingDeviceApprovalStatus;
-    username: string;
+    username?: string | undefined;
 }
 
 /**
@@ -1694,8 +1694,8 @@ export class Client {
     /**
      * Registers a new account on the server.
      *
-     * @param username - The username to register. Must be unique.
-     * @param password - Account password.
+     * @param username - Optional username to register (must be unique when provided).
+     * @param password - Optional account password (device-key auth works without it).
      * @returns `[user, null]` on success, `[null, error]` on failure.
      *
      * @example
@@ -1704,14 +1704,22 @@ export class Client {
      * ```
      */
     public async register(
-        username: string,
-        password: string,
+        username?: string,
+        password?: string,
     ): Promise<[null | User, Error | null]> {
         while (!this.xKeyRing) {
             await sleep(100);
         }
         const regKey = await this.getToken("register");
         if (regKey) {
+            const resolvedUsername =
+                username?.trim().length !== 0 && username !== undefined
+                    ? username.trim()
+                    : Client.randomUsername();
+            const resolvedPassword =
+                password?.trim().length !== 0 && password !== undefined
+                    ? password
+                    : crypto.randomUUID();
             const signKey = XUtils.encodeHex(this.signKeys.publicKey);
             const signed = XUtils.encodeHex(
                 await xSignAsync(
@@ -1722,7 +1730,7 @@ export class Client {
             const preKeyIndex = this.xKeyRing.preKeys.index;
             const regMsg: RegistrationPayload = {
                 deviceName: this.options?.deviceName ?? "unknown",
-                password,
+                password: resolvedPassword,
                 preKey: XUtils.encodeHex(
                     this.xKeyRing.preKeys.keyPair.publicKey,
                 ),
@@ -1732,7 +1740,7 @@ export class Client {
                 ),
                 signed,
                 signKey,
-                username,
+                username: resolvedUsername,
             };
             try {
                 const res = await this.http.post(
@@ -3476,18 +3484,7 @@ export class Client {
         }
 
         const token = await this.getToken("device");
-
-        const username = this.user?.username;
-        if (!username) {
-            throw new Error("No user set — log in first.");
-        }
-        const [userDetails, err] = await this.fetchUser(username);
-        if (!userDetails) {
-            throw new Error("Username not found " + username);
-        }
-        if (err) {
-            throw err;
-        }
+        const userDetails = this.getUser();
         if (!token) {
             throw new Error("Couldn't fetch token.");
         }
@@ -3504,6 +3501,10 @@ export class Client {
         );
 
         const devPreKeyIndex = this.xKeyRing.preKeys.index;
+        const normalizedUsername =
+            userDetails.username.trim().length > 0
+                ? userDetails.username
+                : `key_${userDetails.userID.replaceAll("-", "").slice(0, 12)}`;
         const devMsg: DevicePayload = {
             deviceName: this.options?.deviceName ?? "unknown",
             preKey: XUtils.encodeHex(this.xKeyRing.preKeys.keyPair.publicKey),
@@ -3511,7 +3512,7 @@ export class Client {
             preKeySignature: XUtils.encodeHex(this.xKeyRing.preKeys.signature),
             signed,
             signKey,
-            username: userDetails.username,
+            username: normalizedUsername,
         };
 
         const res = await this.http.post(

package/src/__tests__/ratchet.test.ts

@@ -14,6 +14,9 @@ import {
     encodeRatchetHeader,
     hasRemoteDhChanged,
     initRatchetSession,
+    MAX_SKIP_MESSAGE_GAP,
+    MAX_SKIPPED_KEYS,
+    parseSkippedKeysStrict,
     ratchetStepReceive,
     ratchetStepSend,
     sessionToSqlPatch,
@@ -417,6 +420,47 @@ describe("double ratchet helpers", () => {
 
         expect(alice.Nr + alice.Ns + bob.Nr + bob.Ns).toBeGreaterThan(500);
     });
+
+    it("rejects excessive receive message gap", () => {
+        const state = {
+            CKr: XUtils.decodeHex(
+                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            ),
+            DHr: XUtils.decodeHex(
+                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+            ),
+            Nr: 0,
+            skippedKeys: {} as Record<string, string>,
+        };
+
+        expect(() =>
+            takeReceiveMessageKey(state, state.DHr, MAX_SKIP_MESSAGE_GAP + 1),
+        ).toThrow("Ratchet skip window exceeded");
+    });
+
+    it("sanitizes skipped-keys payload bounds and format", () => {
+        const validDh = "aa".repeat(32);
+        const validValue = "bb".repeat(32);
+        const oversized = Object.fromEntries(
+            Array.from({ length: MAX_SKIPPED_KEYS + 50 }, (_v, i) => [
+                `${validDh}:${String(i)}`,
+                validValue,
+            ]),
+        ) as Record<string, string>;
+        const bounded = parseSkippedKeysStrict(JSON.stringify(oversized));
+        expect(Object.keys(bounded).length).toBe(MAX_SKIPPED_KEYS);
+
+        const filtered = parseSkippedKeysStrict(
+            JSON.stringify({
+                [`${validDh}:0`]: "not-hex",
+                [`${validDh}:1`]: validValue,
+                "bad-key-format": validValue,
+            }),
+        );
+        expect(filtered["bad-key-format"]).toBeUndefined();
+        expect(filtered[`${validDh}:0`]).toBeUndefined();
+        expect(filtered[`${validDh}:1`]).toBe(validValue);
+    });
 });
 
 function hydrateState(

package/src/codecs.ts

@@ -100,7 +100,7 @@ export const PendingDeviceRequestCodec = createCodec(
             z.literal("pending"),
             z.literal("rejected"),
         ]),
-        username: z.string(),
+        username: z.string().optional(),
     }),
 );
 
@@ -120,7 +120,7 @@ export const PendingDeviceRequestArrayCodec = createCodec(
                 z.literal("pending"),
                 z.literal("rejected"),
             ]),
-            username: z.string(),
+            username: z.string().optional(),
         }),
     ),
 );

package/src/storage/sqlite.ts

@@ -44,6 +44,8 @@ import {
 import { EventEmitter } from "eventemitter3";
 import { type Kysely, sql } from "kysely";
 
+import { parseSkippedKeysStrict } from "../utils/ratchet.js";
+
 export class SqliteStorage extends EventEmitter implements Storage {
     public ready = false;
     /** 32-byte AES-256 (or nacl) key for local at-rest `secretbox` (see `XUtils.deriveLocalAtRestAesKey`). */
@@ -730,24 +732,6 @@ export class SqliteStorage extends EventEmitter implements Storage {
         return false;
     }
 
-    private parseSkippedKeys(raw: string): Record<string, string> {
-        try {
-            const parsed: unknown = JSON.parse(raw);
-            if (typeof parsed !== "object" || parsed === null) {
-                return {};
-            }
-            const out: Record<string, string> = {};
-            for (const [k, v] of Object.entries(parsed)) {
-                if (typeof v === "string") {
-                    out[k] = v;
-                }
-            }
-            return out;
-        } catch {
-            return {};
-        }
-    }
-
     /**
      * Encrypt a hex-encoded secret for at-rest storage.
      * Returns hex(nonce || ciphertext) where nonce is 24 random bytes.
@@ -797,7 +781,7 @@ export class SqliteStorage extends EventEmitter implements Storage {
     }
 
     private sqlToCrypto(session: SessionSQL): SessionCrypto {
-        const skippedKeys = this.parseSkippedKeys(session.skippedKeys);
+        const skippedKeys = parseSkippedKeysStrict(session.skippedKeys);
         return {
             CKr: session.CKr ? XUtils.decodeHex(session.CKr) : null,
             CKs: session.CKs ? XUtils.decodeHex(session.CKs) : null,

package/src/utils/ratchet.ts

@@ -16,6 +16,8 @@ import {
 } from "@vex-chat/crypto";
 
 const VERSION = 1;
+export const MAX_SKIP_MESSAGE_GAP = 1024;
+export const MAX_SKIPPED_KEYS = 4096;
 
 const encoder = new TextEncoder();
 
@@ -103,6 +105,25 @@ export async function initRatchetSession(
     };
 }
 
+export function parseSkippedKeysStrict(raw: string): Record<string, string> {
+    try {
+        const parsed: unknown = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null) {
+            return {};
+        }
+        const entries = Object.entries(parsed).slice(0, MAX_SKIPPED_KEYS);
+        const out: Record<string, string> = {};
+        for (const [k, v] of entries) {
+            if (typeof v === "string" && isHex(v) && isSkippedKeyIdFormat(k)) {
+                out[k] = v;
+            }
+        }
+        return out;
+    } catch {
+        return {};
+    }
+}
+
 export async function ratchetStepReceive(
     state: {
         CKr: null | Uint8Array;
@@ -120,11 +141,17 @@ export async function ratchetStepReceive(
     pn: number,
 ): Promise<void> {
     if (state.CKr && state.DHr) {
+        if (pn - state.Nr > MAX_SKIP_MESSAGE_GAP) {
+            throw new Error("Ratchet skip window exceeded for PN.");
+        }
         while (state.Nr < pn) {
             const { chainKey, messageKey } = kdfChain(state.CKr);
             state.CKr = chainKey;
-            state.skippedKeys[skippedKeyId(state.DHr, state.Nr)] =
-                XUtils.encodeHex(messageKey);
+            state.skippedKeys = putSkippedMessageKey(
+                state.skippedKeys,
+                skippedKeyId(state.DHr, state.Nr),
+                XUtils.encodeHex(messageKey),
+            );
             state.Nr += 1;
         }
     }
@@ -230,14 +257,21 @@ export function takeReceiveMessageKey(
         throw new Error("Missing receiving chain key.");
     }
 
+    if (n - state.Nr > MAX_SKIP_MESSAGE_GAP) {
+        throw new Error("Ratchet skip window exceeded for message index.");
+    }
+
     while (state.Nr < n) {
         const { chainKey, messageKey } = kdfChain(state.CKr);
         state.CKr = chainKey;
         if (!state.DHr) {
             throw new Error("Missing DHr when storing skipped key.");
         }
-        state.skippedKeys[skippedKeyId(state.DHr, state.Nr)] =
-            XUtils.encodeHex(messageKey);
+        state.skippedKeys = putSkippedMessageKey(
+            state.skippedKeys,
+            skippedKeyId(state.DHr, state.Nr),
+            XUtils.encodeHex(messageKey),
+        );
         state.Nr += 1;
     }
 
@@ -261,6 +295,20 @@ export function takeSendMessageKey(state: {
     return { messageKey, n };
 }
 
+function isHex(value: string): boolean {
+    return value.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(value);
+}
+
+function isSkippedKeyIdFormat(value: string): boolean {
+    const idx = value.lastIndexOf(":");
+    if (idx <= 0 || idx === value.length - 1) {
+        return false;
+    }
+    const dhHex = value.slice(0, idx);
+    const nPart = value.slice(idx + 1);
+    return isHex(dhHex) && /^[0-9]+$/.test(nPart);
+}
+
 function kdfChain(ck: Uint8Array): {
     chainKey: Uint8Array;
     messageKey: Uint8Array;
@@ -282,6 +330,19 @@ function kdfRoot(
     };
 }
 
+function putSkippedMessageKey(
+    skippedKeys: Record<string, string>,
+    id: string,
+    keyHex: string,
+): Record<string, string> {
+    let entries = Object.entries(skippedKeys).filter(([key]) => key !== id);
+    if (entries.length >= MAX_SKIPPED_KEYS) {
+        entries = entries.slice(entries.length - MAX_SKIPPED_KEYS + 1);
+    }
+    entries.push([id, keyHex]);
+    return Object.fromEntries(entries);
+}
+
 function skippedKeyId(dhPub: Uint8Array, n: number): string {
     return `${XUtils.encodeHex(dhPub)}:${String(n)}`;
 }

package/src/utils/sqlSessionToCrypto.ts

@@ -9,8 +9,10 @@ import type { SessionSQL } from "@vex-chat/types";
 
 import { XUtils } from "@vex-chat/crypto";
 
+import { parseSkippedKeysStrict } from "./ratchet.js";
+
 export function sqlSessionToCrypto(session: SessionSQL): SessionCrypto {
-    const skippedKeys = parseSkippedKeys(session.skippedKeys);
+    const skippedKeys = parseSkippedKeysStrict(session.skippedKeys);
     return {
         CKr: session.CKr ? XUtils.decodeHex(session.CKr) : null,
         CKs: session.CKs ? XUtils.decodeHex(session.CKs) : null,
@@ -32,21 +34,3 @@ export function sqlSessionToCrypto(session: SessionSQL): SessionCrypto {
         verified: session.verified,
     };
 }
-
-function parseSkippedKeys(raw: string): Record<string, string> {
-    try {
-        const parsed: unknown = JSON.parse(raw);
-        if (typeof parsed !== "object" || parsed === null) {
-            return {};
-        }
-        const out: Record<string, string> = {};
-        for (const [k, v] of Object.entries(parsed)) {
-            if (typeof v === "string") {
-                out[k] = v;
-            }
-        }
-        return out;
-    } catch {
-        return {};
-    }
-}