@vex-chat/spire 2.3.0 → 2.3.2

package/src/server/index.ts

@@ -28,6 +28,7 @@ import { POWER_LEVELS } from "../ClientManager.ts";
 import { JWT_EXPIRY } from "../Spire.ts";
 import { getJwtSecret } from "../utils/jwtSecret.ts";
 import { msgpack } from "../utils/msgpack.ts";
+import { verifyPreKeyWsSignature } from "../utils/preKeySignature.ts";
 import { spireXSignOpenAsync } from "../utils/spireXSignOpenAsync.ts";
 
 import { getAvatarRouter } from "./avatar.ts";
@@ -716,6 +717,49 @@ export const initApp = (
         res.send(msgpack.encode({ count }));
     });
 
+    api.post("/device/:id/prekey", protect, async (req, res) => {
+        const parsedPreKey = PreKeysWSSchema.safeParse(req.body);
+        if (!parsedPreKey.success) {
+            res.status(400).json({
+                error: "Invalid prekey payload",
+                issues: parsedPreKey.error.issues,
+            });
+            return;
+        }
+
+        const deviceID = getParam(req, "id");
+        const device = await db.retrieveDevice(deviceID);
+        const deviceDetails = req.device;
+        if (!device) {
+            res.sendStatus(404);
+            return;
+        }
+        if (!deviceDetails) {
+            res.sendStatus(401);
+            return;
+        }
+        if (
+            deviceDetails.deviceID !== deviceID ||
+            req.user?.userID !== device.owner
+        ) {
+            res.sendStatus(401);
+            return;
+        }
+
+        const preKey = parsedPreKey.data;
+        if (preKey.deviceID !== deviceID) {
+            res.status(400).send({ error: "Prekey deviceID mismatch." });
+            return;
+        }
+        if (!(await verifyPreKeyWsSignature(preKey, device.signKey))) {
+            res.status(401).send({ error: "Prekey signature invalid." });
+            return;
+        }
+
+        await db.replacePreKey(device.owner, deviceID, preKey);
+        res.sendStatus(200);
+    });
+
     api.post("/device/:id/otk", protect, async (req, res) => {
         const parsedOTKs = z.array(PreKeysWSSchema).safeParse(req.body);
         if (!parsedOTKs.success) {
@@ -732,6 +776,7 @@ export const initApp = (
         }
 
         const userDetails = getUser(req);
+        const deviceDetails = req.device;
 
         const deviceID = getParam(req, "id");
         const otk = submittedOTKs[0];
@@ -741,16 +786,26 @@ export const initApp = (
             res.sendStatus(404);
             return;
         }
-
-        const message = await spireXSignOpenAsync(
-            otk.signature,
-            XUtils.decodeHex(device.signKey),
-        );
-
-        if (!message) {
+        if (
+            !deviceDetails ||
+            deviceDetails.deviceID !== deviceID ||
+            userDetails.userID !== device.owner
+        ) {
             res.sendStatus(401);
             return;
         }
+        for (const submittedOTK of submittedOTKs) {
+            if (submittedOTK.deviceID !== deviceID) {
+                res.status(400).send({ error: "OTK deviceID mismatch." });
+                return;
+            }
+            if (
+                !(await verifyPreKeyWsSignature(submittedOTK, device.signKey))
+            ) {
+                res.status(401).send({ error: "OTK signature invalid." });
+                return;
+            }
+        }
 
         await db.saveOTK(userDetails.userID, deviceID, submittedOTKs);
         res.sendStatus(200);

package/src/server/user.ts

@@ -25,6 +25,7 @@ import { stringify } from "uuid";
 import { z } from "zod/v4";
 
 import { msgpack } from "../utils/msgpack.ts";
+import { verifyDevicePayloadPreKeySignature } from "../utils/preKeySignature.ts";
 import { spireXSignOpenAsync } from "../utils/spireXSignOpenAsync.ts";
 
 import { AppError } from "./errors.ts";
@@ -51,6 +52,11 @@ interface DeviceEnrollmentRequest {
      */
     ownerNotified?: boolean;
     passkeyRegistration?: PendingDevicePasskeyRegistration;
+    /**
+     * Set when the requesting device proved account ownership with a passkey
+     * before asking the existing device cluster for membership approval.
+     */
+    requesterPasskeyID?: string;
     requestID: string;
     resolvedAt?: number;
     status: DeviceEnrollmentStatus;
@@ -111,7 +117,10 @@ export function createPendingDeviceEnrollmentRequest(
         data?: unknown,
         deviceID?: string,
     ) => void,
-    options?: { deferOwnerNotification?: boolean },
+    options?: {
+        deferOwnerNotification?: boolean;
+        requesterPasskeyID?: string;
+    },
 ): {
     challenge: string;
     expiresAt: string;
@@ -128,6 +137,9 @@ export function createPendingDeviceEnrollmentRequest(
         createdAt: Date.now(),
         devicePayload,
         requestID,
+        ...(options?.requesterPasskeyID
+            ? { requesterPasskeyID: options.requesterPasskeyID }
+            : {}),
         status: "pending",
         userID,
         ...(deferOwner ? { ownerNotified: false } : { ownerNotified: true }),
@@ -883,6 +895,10 @@ export const getUserRouter = (
         }
 
         if (tokenValidator(stringify(token), TokenScopes.Device)) {
+            if (!(await verifyDevicePayloadPreKeySignature(deviceData))) {
+                res.status(400).send({ error: "Prekey signature invalid." });
+                return;
+            }
             const userDevices = await db.retrieveUserDeviceList([
                 userDetails.userID,
             ]);
@@ -901,10 +917,26 @@ export const getUserRouter = (
                 }
             }
 
+            let requesterPasskeyID: string | undefined;
+            if (req.passkey?.passkeyID) {
+                const passkeyError = await passkeySecondFactorError(
+                    db,
+                    userDetails.userID,
+                    req.passkey.passkeyID,
+                    "Passkey verification does not match this account.",
+                );
+                if (passkeyError) {
+                    res.status(403).send({ error: passkeyError });
+                    return;
+                }
+                requesterPasskeyID = req.passkey.passkeyID;
+            }
+
             const pendingResponse = createPendingDeviceEnrollmentRequest(
                 userDetails.userID,
                 deviceData,
                 notify,
+                requesterPasskeyID ? { requesterPasskeyID } : undefined,
             );
             res.status(202).send(msgpack.encode(pendingResponse));
         } else {
@@ -1001,10 +1033,14 @@ export const getUserRouter = (
                 return;
             }
 
+            // New clients put the passkey proof on the requesting device.
+            // Older clients may still satisfy this with an approval-side passkey.
+            const approvedByPasskeyID =
+                pending.requesterPasskeyID ?? req.passkey?.passkeyID;
             const passkeyError = await passkeySecondFactorError(
                 db,
                 userID,
-                req.passkey?.passkeyID,
+                approvedByPasskeyID,
                 "Passkey verification does not match this account.",
             );
             if (passkeyError) {
@@ -1034,10 +1070,10 @@ export const getUserRouter = (
                 const device = await db.createDevice(
                     userID,
                     pending.devicePayload,
-                    req.passkey
+                    approvedByPasskeyID
                         ? {
                               approvedByDeviceID: approverDevice.deviceID,
-                              approvedByPasskeyID: req.passkey.passkeyID,
+                              approvedByPasskeyID,
                           }
                         : undefined,
                 );

package/src/utils/preKeySignature.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2020-2026 Vex Heavy Industries LLC
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ * Commercial licenses available at vex.wtf
+ */
+
+import type { DevicePayload, PreKeysWS } from "@vex-chat/types";
+
+import {
+    getCryptoProfile,
+    xConcat,
+    xConstants,
+    xEncode,
+    XUtils,
+} from "@vex-chat/crypto";
+
+import { spireXSignOpenAsync } from "./spireXSignOpenAsync.ts";
+
+export async function verifyDevicePayloadPreKeySignature(
+    payload: Pick<DevicePayload, "preKey" | "preKeySignature" | "signKey">,
+): Promise<boolean> {
+    try {
+        return await verifySignedPreKey(
+            XUtils.decodeHex(payload.preKey),
+            XUtils.decodeHex(payload.preKeySignature),
+            payload.signKey,
+        );
+    } catch {
+        return false;
+    }
+}
+
+export async function verifyPreKeyWsSignature(
+    preKey: PreKeysWS,
+    signKeyHex: string,
+): Promise<boolean> {
+    return verifySignedPreKey(preKey.publicKey, preKey.signature, signKeyHex);
+}
+
+function preKeySignPayload(publicKey: Uint8Array): Uint8Array {
+    return getCryptoProfile() === "fips"
+        ? xConcat(new Uint8Array([0xa1]), publicKey)
+        : xEncode(xConstants.CURVE, publicKey);
+}
+
+async function verifySignedPreKey(
+    publicKey: Uint8Array,
+    signature: Uint8Array,
+    signKeyHex: string,
+): Promise<boolean> {
+    try {
+        const opened = await spireXSignOpenAsync(
+            signature,
+            XUtils.decodeHex(signKeyHex),
+        );
+        return Boolean(
+            opened && XUtils.bytesEqual(opened, preKeySignPayload(publicKey)),
+        );
+    } catch {
+        return false;
+    }
+}