@vex-chat/libvex 5.5.2 → 6.0.1

package/dist/utils/sqlSessionToCrypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqlSessionToCrypto.js","sourceRoot":"","sources":["../../src/utils/sqlSessionToCrypto.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,MAAM,UAAU,kBAAkB,CAAC,OAAmB;IAClD,OAAO;QACH,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC;QAClD,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;QAC9C,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,MAAM,EAAE,OAAO,CAAC,MAAM;KACzB,CAAC;AACN,CAAC"}
+{"version":3,"file":"sqlSessionToCrypto.js","sourceRoot":"","sources":["../../src/utils/sqlSessionToCrypto.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,MAAM,UAAU,kBAAkB,CAAC,OAAmB;IAClD,MAAM,WAAW,GAAG,gBAAgB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1D,OAAO;QACH,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI;QACvD,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI;QACvD,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI;QACvD,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC;QAChD,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;QAC9C,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC;QAClD,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,EAAE,EAAE,OAAO,CAAC,EAAE;QACd,EAAE,EAAE,OAAO,CAAC,EAAE;QACd,EAAE,EAAE,OAAO,CAAC,EAAE;QACd,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;QAC9C,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,WAAW;QACX,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,QAAQ,EAAE,OAAO,CAAC,QAAQ;KAC7B,CAAC;AACN,CAAC;AAED,SAAS,gBAAgB,CAAC,GAAW;IACjC,IAAI,CAAC;QACD,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YAChD,OAAO,EAAE,CAAC;QACd,CAAC;QACD,MAAM,GAAG,GAA2B,EAAE,CAAC;QACvC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1C,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACxB,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACf,CAAC;QACL,CAAC;QACD,OAAO,GAAG,CAAC;IACf,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,EAAE,CAAC;IACd,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vex-chat/libvex",
-  "version": "5.5.2",
+  "version": "6.0.1",
   "description": "Library for communicating with xchat server.",
   "type": "module",
   "sideEffects": false,
@@ -93,8 +93,8 @@
     "msgpackr": "^1.11.9",
     "uuid": "^14.0.0",
     "zod": "^4.3.6",
-    "@vex-chat/crypto": "^2.1.2",
-    "@vex-chat/types": "^2.0.0"
+    "@vex-chat/types": "^3.0.0",
+    "@vex-chat/crypto": "^3.0.0"
   },
   "peerDependencies": {
     "better-sqlite3": ">=11.0.0"

package/src/Client.ts

@@ -80,14 +80,23 @@ import { z } from "zod/v4";
 import { WebSocketAdapter } from "./transport/websocket.js";
 import {
     decodeFipsInitialExtraV1,
-    decodeFipsSubsequentExtraV1,
     encodeFipsInitialExtraV1,
-    encodeFipsSubsequentExtraV1,
     fipsP256AdFromIdentityPubs,
     fipsP256PreKeySignPayload,
     isFipsInitialExtraV1,
-    isFipsSubsequentExtraV1,
 } from "./utils/fipsMailExtra.js";
+import {
+    decodeRatchetHeader,
+    deriveBootstrapSendChain,
+    encodeRatchetHeader,
+    hasRemoteDhChanged,
+    initRatchetSession,
+    ratchetStepReceive,
+    ratchetStepSend,
+    sessionToSqlPatch,
+    takeReceiveMessageKey,
+    takeSendMessageKey,
+} from "./utils/ratchet.js";
 
 function debugLibvexDm(
     msg: string,
@@ -1309,9 +1318,6 @@ export class Client {
                 return [signKey, ephKey, ad, index];
             }
             case MailType.subsequent:
-                if (isFipsSubsequentExtraV1(extra)) {
-                    return [decodeFipsSubsequentExtraV1(extra)];
-                }
                 return [extra];
             default:
                 return [];
@@ -2094,7 +2100,9 @@ export class Client {
             // discard the ephemeral keys
             await this.newEphemeralKeys();
 
+            const ratchet = await initRatchetSession(SK, "initiator");
             const sessionEntry: SessionSQL = {
+                ...ratchet,
                 deviceID: device.deviceID,
                 fingerprint: XUtils.encodeHex(AD),
                 lastUsed: new Date().toISOString(),
@@ -2114,6 +2122,7 @@ export class Client {
             const forwardedMsg = forward
                 ? messageSchema.parse(msgpack.decode(message))
                 : null;
+            const shouldEmitHandshakeMessage = forward || message.length > 0;
             const emitMsg: Message = forwardedMsg
                 ? { ...forwardedMsg, forward: true }
                 : {
@@ -2130,7 +2139,9 @@ export class Client {
                       sender: mail.sender,
                       timestamp: new Date().toISOString(),
                   };
-            this.emitter.emit("message", emitMsg);
+            if (shouldEmitHandshakeMessage) {
+                this.emitter.emit("message", emitMsg);
+            }
 
             // send mail and wait for response
             await new Promise((res, rej) => {
@@ -3220,7 +3231,11 @@ export class Client {
                                       timestamp: timestamp,
                                   };
 
-                            this.emitter.emit("message", message);
+                            const shouldEmitIncomingInitial =
+                                mail.forward || plaintext.length > 0;
+                            if (shouldEmitIncomingInitial) {
+                                this.emitter.emit("message", message);
+                            }
                             if (libvexDebugDmEnabled()) {
                                 try {
                                     debugLibvexDm(
@@ -3271,7 +3286,12 @@ export class Client {
                                 deviceEntry;
 
                             // save session
+                            const ratchet = await initRatchetSession(
+                                SK,
+                                "receiver",
+                            );
                             const newSession: SessionSQL = {
+                                ...ratchet,
                                 deviceID: mail.sender,
                                 fingerprint: XUtils.encodeHex(AD),
                                 lastUsed: new Date().toISOString(),
@@ -3305,19 +3325,12 @@ export class Client {
                         }
                         break;
                     case MailType.subsequent: {
-                        const extraBuf = new Uint8Array(mail.extra);
-                        const publicKey = isFipsSubsequentExtraV1(extraBuf)
-                            ? decodeFipsSubsequentExtraV1(extraBuf)
-                            : Client.deserializeExtra(
-                                  mail.mailType,
-                                  extraBuf,
-                              )[0];
-                        if (!publicKey) {
-                            throw new Error(
-                                "Malformed subsequent mail extra: missing publicKey",
-                            );
-                        }
-                        let session = await this.getSessionByPubkey(publicKey);
+                        const ratchetHeader = decodeRatchetHeader(
+                            new Uint8Array(mail.extra),
+                        );
+                        let session = await this.database.getSessionByDeviceID(
+                            mail.sender,
+                        );
                         let retries = 0;
                         while (!session) {
                             if (retries >= 3) {
@@ -3325,14 +3338,44 @@ export class Client {
                             }
                             await sleep(100 * 2 ** retries);
                             retries++;
-                            session = await this.getSessionByPubkey(publicKey);
+                            session = await this.database.getSessionByDeviceID(
+                                mail.sender,
+                            );
                         }
 
                         if (!session) {
                             void healSession();
                             return;
                         }
-                        const HMAC = xHMAC(mail, session.SK);
+
+                        const firstInboundFromSubsequent = !session.DHr;
+                        if (firstInboundFromSubsequent) {
+                            session.DHr = ratchetHeader.dhPub;
+                            // First inbound after X3DH initial mail has no prior DH ratchet.
+                            // If this side has no receiving chain yet (initiator path),
+                            // derive the bootstrap receive chain to match peer's first
+                            // bootstrap send chain.
+                            if (!session.CKr) {
+                                session.CKr = deriveBootstrapSendChain(
+                                    session.RK,
+                                );
+                            }
+                        } else if (
+                            hasRemoteDhChanged(session.DHr, ratchetHeader.dhPub)
+                        ) {
+                            await ratchetStepReceive(
+                                session,
+                                ratchetHeader.dhPub,
+                                ratchetHeader.pn,
+                            );
+                        }
+
+                        const messageKey = takeReceiveMessageKey(
+                            session,
+                            ratchetHeader.dhPub,
+                            ratchetHeader.n,
+                        );
+                        const HMAC = xHMAC(mail, messageKey);
 
                         if (!XUtils.bytesEqual(HMAC, header)) {
                             void healSession();
@@ -3342,7 +3385,7 @@ export class Client {
                         const decrypted = await xSecretboxOpenAsync(
                             new Uint8Array(mail.cipher),
                             new Uint8Array(mail.nonce),
-                            session.SK,
+                            messageKey,
                         );
 
                         if (decrypted) {
@@ -3374,9 +3417,34 @@ export class Client {
                                   };
                             this.emitter.emit("message", message);
 
-                            void this.database.markSessionUsed(
-                                session.sessionID,
-                            );
+                            const sqlPatch = sessionToSqlPatch(session);
+                            const persisted: SessionSQL = {
+                                CKr: sqlPatch.CKr,
+                                CKs: sqlPatch.CKs,
+                                deviceID: mail.sender,
+                                DHr: sqlPatch.DHr,
+                                DHsPrivate: sqlPatch.DHsPrivate,
+                                DHsPublic: sqlPatch.DHsPublic,
+                                fingerprint: XUtils.encodeHex(
+                                    session.fingerprint,
+                                ),
+                                lastUsed: new Date().toISOString(),
+                                mode: session.mode,
+                                Nr: sqlPatch.Nr,
+                                Ns: sqlPatch.Ns,
+                                PN: sqlPatch.PN,
+                                publicKey: XUtils.encodeHex(session.publicKey),
+                                RK: sqlPatch.RK,
+                                sessionID: session.sessionID,
+                                SK: XUtils.encodeHex(session.SK),
+                                skippedKeys: sqlPatch.skippedKeys,
+                                userID: session.userID,
+                                verified: session.verified,
+                            };
+                            await this.database.saveSession(persisted);
+                            this.sessionRecords[
+                                XUtils.encodeHex(session.publicKey)
+                            ] = session;
                         } else {
                             void healSession();
                             this.emitter.emit("retryRequest", {
@@ -3718,12 +3786,19 @@ export class Client {
                 });
             }
 
+            if (!session.CKs) {
+                await ratchetStepSend(session);
+            }
+            const { messageKey, n } = takeSendMessageKey(session);
+            const ratchetHeader = {
+                dhPub: session.DHsPublic,
+                n,
+                pn: session.PN,
+                version: 1 as const,
+            };
             const nonce = xMakeNonce();
-            const cipher = await xSecretboxAsync(msg, nonce, session.SK);
-            const extra =
-                this.cryptoProfile === "fips"
-                    ? encodeFipsSubsequentExtraV1(session.publicKey)
-                    : session.publicKey;
+            const cipher = await xSecretboxAsync(msg, nonce, messageKey);
+            const extra = encodeRatchetHeader(ratchetHeader);
 
             const mail: MailWS = {
                 authorID: this.getUser().userID,
@@ -3747,7 +3822,7 @@ export class Client {
                 type: "resource",
             };
 
-            const hmac = xHMAC(mail, session.SK);
+            const hmac = xHMAC(mail, messageKey);
 
             const fwdOut = forward
                 ? messageSchema.parse(msgpack.decode(msg))
@@ -3770,6 +3845,31 @@ export class Client {
                   };
             this.emitter.emit("message", outMsg);
 
+            const sqlPatch = sessionToSqlPatch(session);
+            const persisted: SessionSQL = {
+                CKr: sqlPatch.CKr,
+                CKs: sqlPatch.CKs,
+                deviceID: device.deviceID,
+                DHr: sqlPatch.DHr,
+                DHsPrivate: sqlPatch.DHsPrivate,
+                DHsPublic: sqlPatch.DHsPublic,
+                fingerprint: XUtils.encodeHex(session.fingerprint),
+                lastUsed: new Date().toISOString(),
+                mode: session.mode,
+                Nr: sqlPatch.Nr,
+                Ns: sqlPatch.Ns,
+                PN: sqlPatch.PN,
+                publicKey: XUtils.encodeHex(session.publicKey),
+                RK: sqlPatch.RK,
+                sessionID: session.sessionID,
+                SK: XUtils.encodeHex(session.SK),
+                skippedKeys: sqlPatch.skippedKeys,
+                userID: session.userID,
+                verified: session.verified,
+            };
+            await this.database.saveSession(persisted);
+            this.sessionRecords[XUtils.encodeHex(session.publicKey)] = session;
+
             await new Promise((res, rej) => {
                 const callback = (packedMsg: Uint8Array) => {
                     const [_header, receivedMsg] =

package/src/__tests__/harness/memory-storage.ts

@@ -234,7 +234,12 @@ export class MemoryStorage extends EventEmitter implements Storage {
     }
 
     saveSession(session: SessionSQL): Promise<void> {
-        if (!this.sessions.find((s) => s.SK === session.SK)) {
+        const idx = this.sessions.findIndex(
+            (s) => s.sessionID === session.sessionID,
+        );
+        if (idx >= 0) {
+            this.sessions[idx] = session;
+        } else {
             this.sessions.push(session);
         }
         return Promise.resolve();
@@ -261,14 +266,31 @@ export class MemoryStorage extends EventEmitter implements Storage {
     }
 
     private sqlToCrypto(s: SessionSQL): SessionCrypto {
+        let skippedKeys: Record<string, string> = {};
+        try {
+            skippedKeys = JSON.parse(s.skippedKeys) as Record<string, string>;
+        } catch {
+            skippedKeys = {};
+        }
         return {
+            CKr: s.CKr ? XUtils.decodeHex(s.CKr) : null,
+            CKs: s.CKs ? XUtils.decodeHex(s.CKs) : null,
+            DHr: s.DHr ? XUtils.decodeHex(s.DHr) : null,
+            DHsPrivate: XUtils.decodeHex(s.DHsPrivate),
+            DHsPublic: XUtils.decodeHex(s.DHsPublic),
             fingerprint: XUtils.decodeHex(s.fingerprint),
             lastUsed: s.lastUsed,
             mode: s.mode,
+            Nr: s.Nr,
+            Ns: s.Ns,
+            PN: s.PN,
             publicKey: XUtils.decodeHex(s.publicKey),
+            RK: XUtils.decodeHex(s.RK),
             sessionID: s.sessionID,
             SK: XUtils.decodeHex(s.SK),
+            skippedKeys,
             userID: s.userID,
+            verified: s.verified,
         };
     }
 }

package/src/__tests__/harness/shared-suite.ts

@@ -126,6 +126,80 @@ export function platformSuite(
             }
         });
 
+        test("two-user DM round-trip decrypts on both clients", async () => {
+            const SK1 = await e2eGenerateSecretKey();
+            const opts1: ClientOptions = e2eClientOptionsBase();
+            const storage1 = await makeStorage(SK1, opts1);
+            const client1 = await Client.create(SK1, opts1, storage1);
+            const username1 = Client.randomUsername();
+            const password1 = "test-pw-1";
+
+            const SK2 = await e2eGenerateSecretKey();
+            const opts2: ClientOptions = e2eClientOptionsBase();
+            const storage2 = await makeStorage(SK2, opts2);
+            const client2 = await Client.create(SK2, opts2, storage2);
+            const username2 = Client.randomUsername();
+            const password2 = "test-pw-2";
+
+            try {
+                const [_user1, regErr1] = await client1.register(
+                    username1,
+                    password1,
+                );
+                expect(regErr1).toBeNull();
+
+                const loginErr1 = await client1.login(username1, password1);
+                expect(loginErr1.ok).toBe(true);
+                await connectAndWait(client1, "client1-roundtrip");
+
+                const [user2, regErr] = await client2.register(
+                    username2,
+                    password2,
+                );
+                expect(regErr).toBeNull();
+
+                const loginErr = await client2.login(username2, password2);
+                expect(loginErr.ok).toBe(true);
+                await connectAndWait(client2, "client2-roundtrip");
+
+                const outbound1 = "roundtrip u1->u2";
+                const receiveOnClient2 = waitForMessage(
+                    client2,
+                    (m) =>
+                        m.direction === "incoming" &&
+                        m.authorID === client1.me.user().userID &&
+                        m.message === outbound1,
+                    `[${platformName}] roundtrip receive on client2`,
+                    15_000,
+                );
+                await client1.messages.send(user2!.userID, outbound1);
+                const inbound2 = await receiveOnClient2;
+                expect(inbound2.decrypted).toBe(true);
+                expect(inbound2.message).toBe(outbound1);
+
+                const outbound2 = "roundtrip u2->u1";
+                const receiveOnClient1 = waitForMessage(
+                    client1,
+                    (m) =>
+                        m.direction === "incoming" &&
+                        m.authorID === user2!.userID &&
+                        m.message === outbound2,
+                    `[${platformName}] roundtrip receive on client1`,
+                    15_000,
+                );
+                await client2.messages.send(
+                    client1.me.user().userID,
+                    outbound2,
+                );
+                const inbound1 = await receiveOnClient1;
+                expect(inbound1.decrypted).toBe(true);
+                expect(inbound1.message).toBe(outbound2);
+            } finally {
+                await client1.close().catch(() => {});
+                await client2.close().catch(() => {});
+            }
+        }, 60_000);
+
         test("group messaging in channel", async () => {
             const SK2 = await e2eGenerateSecretKey();
             const opts2: ClientOptions = e2eClientOptionsBase();