@vex-chat/spire 3.0.0 → 4.0.0

package/dist/Spire.js

@@ -12,32 +12,30 @@ import { fileURLToPath } from "node:url";
 import express from "express";
 import { XUtils } from "@vex-chat/crypto";
 import { setCryptoProfile, xRandomBytes, xSignKeyPairFromSecret, xSignKeyPairFromSecretAsync, } from "@vex-chat/crypto";
-import { MailWSSchema, RegistrationPayloadSchema, TokenScopes, UserSchema, } from "@vex-chat/types";
-import jwt from "jsonwebtoken";
+import { ACCOUNT_PASSWORD_MAX_LENGTH, MailWSSchema, RegistrationPayloadSchema, TokenScopes, UserSchema, } from "@vex-chat/types";
 import morgan from "morgan";
 import { stringify as uuidStringify } from "uuid";
 import { WebSocketServer } from "ws";
 import { z } from "zod/v4";
 import { CallManager } from "./CallManager.js";
 import { ClientManager } from "./ClientManager.js";
-import { Database, hashPasswordArgon2, verifyPassword } from "./Database.js";
+import { Database, hashPasswordArgon2, MAX_ACTIVE_DEVICES_PER_USER, validateAccountPassword, verifyPassword, } from "./Database.js";
 import { resolveIceServersFromEnv } from "./IceServers.js";
 import { NotificationService } from "./NotificationService.js";
 import { initApp, protect } from "./server/index.js";
 import { MailIngressValidationError, validateMailIngress, } from "./server/mailIngress.js";
-import { passkeySecondFactorError } from "./server/passkeySecondFactor.js";
-import { authLimiter, devApiKeySkipsRateLimits } from "./server/rateLimit.js";
+import { accountAuthLimiter, authLimiter, devApiKeySkipsRateLimits, } from "./server/rateLimit.js";
 import { createPendingDeviceEnrollmentRequest } from "./server/user.js";
 import { censorUser, getParam, getUser } from "./server/utils.js";
 import { resolveSpireListenPort } from "./spireListenPort.js";
-import { getJwtSecret } from "./utils/jwtSecret.js";
+import { signAuthJwt, verifyAuthJwt } from "./utils/authJwt.js";
 import { msgpack } from "./utils/msgpack.js";
+import { verifyDevicePayloadPreKeySignature } from "./utils/preKeySignature.js";
 import { spireXSignOpenAsync } from "./utils/spireXSignOpenAsync.js";
-export { passkeySecondFactorError } from "./server/passkeySecondFactor.js";
-// expiry of regkeys = 24hr
+// One-use action tokens expire after ten minutes.
 export const TOKEN_EXPIRY = 1000 * 60 * 10;
-export const JWT_EXPIRY = "7d";
-export const DEVICE_AUTH_JWT_EXPIRY = "7d";
+export const JWT_EXPIRY = "1h";
+export const DEVICE_AUTH_JWT_EXPIRY = "1h";
 /**
  * Passkey-scoped JWTs grant destructive admin powers (delete a
  * device, recover a device enrollment) without further user
@@ -48,6 +46,7 @@ export const JWT_EXPIRY_PASSKEY = "5m";
 const DEVICE_CHALLENGE_EXPIRY = 1000 * 60; // 60 seconds
 // 3-19 chars long
 const usernameRegex = /^(\w{3,19})$/;
+const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 // ── Zod schemas for trust-boundary validation ──────────────────────────
 const wsAuthMsg = z.object({
     token: z.string().min(1),
@@ -56,22 +55,58 @@ const wsAuthMsg = z.object({
 const jwtPayload = z.object({
     bearerToken: z.string().optional(),
     exp: z.number().optional(),
+    scope: z.literal("user"),
     user: UserSchema,
 });
 const authPayload = z.object({
-    password: z.string().min(1),
-    username: z.string().min(1),
+    password: z.string().min(1).max(ACCOUNT_PASSWORD_MAX_LENGTH),
+    username: z.string().trim().min(3).max(19).regex(usernameRegex),
+});
+const boundedRegistrationPayload = z.object({
+    deviceName: z.string().trim().min(1).max(100),
+    intent: z.enum(["create-account", "enroll-device"]),
+    password: z.string().max(ACCOUNT_PASSWORD_MAX_LENGTH).optional(),
+    preKey: z
+        .string()
+        .min(2)
+        .max(8192)
+        .regex(/^(?:[0-9a-fA-F]{2})+$/),
+    preKeyIndex: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    preKeySignature: z
+        .string()
+        .min(2)
+        .max(16_384)
+        .regex(/^(?:[0-9a-fA-F]{2})+$/),
+    signed: z
+        .string()
+        .min(2)
+        .max(8192)
+        .regex(/^(?:[0-9a-fA-F]{2})+$/),
+    signKey: z
+        .string()
+        .min(2)
+        .max(8192)
+        .regex(/^(?:[0-9a-fA-F]{2})+$/),
+    username: z.string().trim().min(3).max(19).regex(usernameRegex).optional(),
 });
 const deviceAuthPayload = z.object({
-    deviceID: z.string().min(1),
-    signKey: z.string().min(1),
+    deviceID: z.string().regex(uuidRegex),
+    signKey: z
+        .string()
+        .min(64)
+        .max(8192)
+        .regex(/^(?:[0-9a-fA-F]{2})+$/),
 });
 const deviceVerifyPayload = z.object({
-    challengeID: z.string().min(1),
-    signed: z.string().min(1),
+    challengeID: z.string().regex(uuidRegex),
+    signed: z
+        .string()
+        .min(2)
+        .max(16_384)
+        .regex(/^(?:[0-9a-fA-F]{2})+$/),
 });
 const mailPostPayload = z.object({
-    header: z.custom((val) => val instanceof Uint8Array),
+    header: z.custom((val) => val instanceof Uint8Array && val.byteLength === 32),
     mail: MailWSSchema,
 });
 const MAIL_BATCH_MAX_ITEMS = 256;
@@ -80,9 +115,9 @@ const mailBatchPostPayload = z.object({
 });
 const notificationSubscribePayload = z.object({
     channel: z.literal("expo"),
-    events: z.array(z.string().min(1)).default(["mail"]),
+    events: z.array(z.string().min(1).max(64)).max(32).default(["mail"]),
     platform: z.enum(["android", "ios", "web"]).optional(),
-    token: z.string().min(1),
+    token: z.string().min(1).max(4096),
 });
 const directories = ["files", "avatars", "emoji"];
 for (const dir of directories) {
@@ -124,6 +159,16 @@ const getCommitSha = () => {
         return "unknown";
     }
 };
+export function resolveTrustProxyHops(value) {
+    if (value === undefined || value.trim() === "") {
+        return 0;
+    }
+    const hops = Number(value);
+    if (!Number.isInteger(hops) || hops < 0 || hops > 10) {
+        throw new Error("SPIRE_TRUST_PROXY_HOPS must be an integer from 0 to 10.");
+    }
+    return hops;
+}
 /**
  * Masks identifying material in the access-log URL: hyphenated UUIDs, and
  * `/device/...` path segments that hold public-key material (32B ed25519 hex, or
@@ -138,7 +183,7 @@ function redactAccessLogUrl(url) {
 /** FIPS: sign key loaded inside `Spire.createAsync` before the constructor runs. */
 let pendingFipsKeyPair = null;
 export class Spire extends EventEmitter {
-    actionTokens = [];
+    actionTokens = new Map();
     api = express();
     calls;
     clients = [];
@@ -174,12 +219,10 @@ export class Spire extends EventEmitter {
             setCryptoProfile(this.cryptoProfile);
             this.signKeys = xSignKeyPairFromSecret(XUtils.decodeHex(SK));
         }
-        // Trust a single proxy hop (nginx / cloudflare / load balancer).
-        // Required so `req.ip` and `express-rate-limit`'s keyGenerator see
-        // the real client address via X-Forwarded-For. Never use `true` —
-        // that lets attackers spoof the header and bypass rate limiting.
-        // If spire is deployed without a proxy, set this to 0 instead.
-        this.api.set("trust proxy", 1);
+        // Proxy trust must match the deployment topology. Defaulting to zero
+        // prevents direct deployments from accepting attacker-supplied
+        // X-Forwarded-For values and bypassing IP rate limits.
+        this.api.set("trust proxy", resolveTrustProxyHops(process.env["SPIRE_TRUST_PROXY_HOPS"]));
         this.api.disable("etag");
         this.db = new Database(options);
         this.calls = new CallManager(this.db, this.notify.bind(this));
@@ -252,19 +295,17 @@ export class Spire extends EventEmitter {
         }
     }
     createActionToken(scope) {
+        this.pruneActionTokens();
         const token = {
             key: crypto.randomUUID(),
             scope,
             time: new Date().toISOString(),
         };
-        this.actionTokens.push(token);
+        this.actionTokens.set(token.key, token);
         return token;
     }
     deleteActionToken(key) {
-        const idx = this.actionTokens.indexOf(key);
-        if (idx !== -1) {
-            this.actionTokens.splice(idx, 1);
-        }
+        this.actionTokens.delete(key.key);
     }
     disconnectDevices(deviceIDs) {
         if (deviceIDs.length === 0) {
@@ -327,7 +368,7 @@ export class Spire extends EventEmitter {
                         throw new Error("Expected { type: 'auth', token }, got: " +
                             JSON.stringify(authResult.error.issues));
                     }
-                    const result = jwt.verify(authResult.data.token, getJwtSecret());
+                    const result = verifyAuthJwt(authResult.data.token);
                     const jwtResult = jwtPayload.safeParse(result);
                     if (!jwtResult.success) {
                         throw new Error("Invalid JWT payload: " +
@@ -525,9 +566,10 @@ export class Spire extends EventEmitter {
                 res.status(500).json({ error: msg, ok: false });
             }
         });
-        this.api.post("/goodbye", protect, (req, res) => {
-            jwt.sign({ user: req.user }, getJwtSecret(), { expiresIn: -1 });
-            res.sendStatus(200);
+        this.api.post("/goodbye", protect, (_req, res) => {
+            // Access tokens are stateless. Clients clear them locally; this
+            // endpoint exists only as a clean session boundary for callers.
+            res.sendStatus(204);
         });
         // ── Device-key auth ──────────────────────────────────────────
         this.api.post("/auth/device", authLimiter, async (req, res) => {
@@ -611,18 +653,8 @@ export class Spire extends EventEmitter {
                         .status(404)
                         .send({ error: "Device owner not found." });
                 }
-                const passkeyError = await passkeySecondFactorError(this.db, user.userID, req.passkey?.passkeyID, "Passkey verification does not match this device.");
-                if (passkeyError) {
-                    const body = {
-                        error: passkeyError,
-                    };
-                    if (passkeyError === "Passkey verification required.") {
-                        body.username = user.username;
-                    }
-                    return res.status(403).send(body);
-                }
-                // Issue short-lived JWT (1 hour, not 7 days)
-                const token = jwt.sign({ user: censorUser(user) }, getJwtSecret(), { expiresIn: DEVICE_AUTH_JWT_EXPIRY });
+                // Device proof restores the same bounded account session as password login.
+                const token = signAuthJwt({ scope: "user", user: censorUser(user) }, DEVICE_AUTH_JWT_EXPIRY);
                 return res.send(msgpack.encode({ token, user: censorUser(user) }));
             }
             catch (_err) {
@@ -811,7 +843,7 @@ export class Spire extends EventEmitter {
             });
             res.sendStatus(removed ? 204 : 404);
         });
-        this.api.post("/auth", authLimiter, async (req, res) => {
+        this.api.post("/auth", authLimiter, accountAuthLimiter, async (req, res) => {
             const parsed = authPayload.safeParse(req.body);
             if (!parsed.success) {
                 res.status(400).json({
@@ -819,10 +851,12 @@ export class Spire extends EventEmitter {
                 });
                 return;
             }
-            const { password, username } = parsed.data;
+            const { password } = parsed.data;
+            const username = parsed.data.username.toLowerCase();
             try {
                 const userEntry = await this.db.retrieveUser(username);
                 if (!userEntry) {
+                    await verifyPassword(password, null);
                     res.sendStatus(401);
                     return;
                 }
@@ -835,16 +869,7 @@ export class Spire extends EventEmitter {
                     const newHash = await hashPasswordArgon2(password);
                     await this.db.rehashPassword(userEntry.userID, newHash);
                 }
-                const passkeyError = await passkeySecondFactorError(this.db, userEntry.userID, req.passkey?.passkeyID, "Passkey verification does not match this account.");
-                if (passkeyError) {
-                    res.status(403).send({
-                        error: passkeyError,
-                    });
-                    return;
-                }
-                const token = jwt.sign({ user: censorUser(userEntry) }, getJwtSecret(), { expiresIn: JWT_EXPIRY });
-                // just to make sure
-                jwt.verify(token, getJwtSecret());
+                const token = signAuthJwt({ scope: "user", user: censorUser(userEntry) }, JWT_EXPIRY);
                 res.send(msgpack.encode({ token, user: censorUser(userEntry) }));
             }
             catch (_err) {
@@ -852,7 +877,7 @@ export class Spire extends EventEmitter {
                 res.sendStatus(500);
             }
         });
-        this.api.post("/register", authLimiter, async (req, res) => {
+        this.api.post("/register", authLimiter, accountAuthLimiter, async (req, res) => {
             try {
                 const regParsed = RegistrationPayloadSchema.safeParse(req.body);
                 if (!regParsed.success) {
@@ -863,8 +888,15 @@ export class Spire extends EventEmitter {
                     return;
                 }
                 const regPayload = regParsed.data;
-                if (regPayload.username !== undefined &&
-                    !usernameRegex.test(regPayload.username)) {
+                const bounded = boundedRegistrationPayload.safeParse(regPayload);
+                if (!bounded.success) {
+                    res.status(400).json({
+                        error: "Invalid registration payload",
+                        issues: bounded.error.issues,
+                    });
+                    return;
+                }
+                if (!usernameRegex.test(regPayload.username)) {
                     res.status(400).send({
                         error: "Username must be between three and nineteen letters, digits, or underscores.",
                     });
@@ -872,13 +904,34 @@ export class Spire extends EventEmitter {
                 }
                 const normalizedPayload = {
                     ...regPayload,
-                    username: normalizeRegistrationUsername(regPayload.username, regPayload.signKey),
+                    username: normalizeRegistrationUsername(regPayload.username),
                 };
                 const regKey = await spireXSignOpenAsync(XUtils.decodeHex(normalizedPayload.signed), XUtils.decodeHex(normalizedPayload.signKey));
                 if (regKey &&
                     regKey.length === 16 &&
                     this.validateToken(uuidStringify(regKey), TokenScopes.Register)) {
+                    if (!(await verifyDevicePayloadPreKeySignature(normalizedPayload))) {
+                        res.status(400).send({
+                            error: "Signed prekey signature is invalid.",
+                        });
+                        return;
+                    }
                     const existingUser = await this.db.retrieveUser(normalizedPayload.username);
+                    if (normalizedPayload.intent === "create-account" &&
+                        existingUser) {
+                        res.status(409).send({
+                            error: "Username is already registered. Sign in instead.",
+                        });
+                        return;
+                    }
+                    if (normalizedPayload.intent === "enroll-device" &&
+                        !existingUser) {
+                        await verifyPassword(normalizedPayload.password ?? "", null);
+                        res.status(401).send({
+                            error: "Invalid username or password.",
+                        });
+                        return;
+                    }
                     if (existingUser) {
                         const existingBySignKey = await this.db.retrieveDevice(normalizedPayload.signKey);
                         if (existingBySignKey) {
@@ -889,15 +942,46 @@ export class Spire extends EventEmitter {
                         }
                         let requesterPasskeyID;
                         if (req.passkey?.passkeyID) {
-                            const passkeyError = await passkeySecondFactorError(this.db, existingUser.userID, req.passkey.passkeyID, "Passkey verification does not match this account.");
-                            if (passkeyError) {
+                            const passkey = await this.db.retrievePasskeyInternal(req.passkey.passkeyID);
+                            if (!passkey ||
+                                passkey.userID !== existingUser.userID) {
                                 res.status(403).send({
-                                    error: passkeyError,
+                                    error: "Passkey verification does not match this account.",
                                 });
                                 return;
                             }
                             requesterPasskeyID = req.passkey.passkeyID;
                         }
+                        else {
+                            if (typeof normalizedPayload.password !==
+                                "string" ||
+                                normalizedPayload.password.trim().length ===
+                                    0) {
+                                res.status(401).send({
+                                    error: "Password is required to add this device.",
+                                });
+                                return;
+                            }
+                            const { needsRehash, valid } = await verifyPassword(normalizedPayload.password, existingUser);
+                            if (!valid) {
+                                res.sendStatus(401);
+                                return;
+                            }
+                            if (needsRehash) {
+                                const newHash = await hashPasswordArgon2(normalizedPayload.password);
+                                await this.db.rehashPassword(existingUser.userID, newHash);
+                            }
+                        }
+                        const activeDevices = await this.db.retrieveUserDeviceList([
+                            existingUser.userID,
+                        ]);
+                        if (activeDevices.length >=
+                            MAX_ACTIVE_DEVICES_PER_USER) {
+                            res.status(409).send({
+                                error: `Each account is limited to ${String(MAX_ACTIVE_DEVICES_PER_USER)} active devices. Remove an old device before adding another.`,
+                            });
+                            return;
+                        }
                         const pendingResponse = createPendingDeviceEnrollmentRequest(existingUser.userID, normalizedPayload, this.notify.bind(this), {
                             deferOwnerNotification: true,
                             ...(requesterPasskeyID
@@ -914,6 +998,13 @@ export class Spire extends EventEmitter {
                         });
                         return;
                     }
+                    const passwordError = validateAccountPassword(normalizedPayload.password, normalizedPayload.username);
+                    if (passwordError) {
+                        res.status(400).send({
+                            error: passwordError,
+                        });
+                        return;
+                    }
                     const [user, err] = await this.db.createUser(regKey, normalizedPayload);
                     if (err !== null) {
                         const errCode = "code" in err && typeof err.code === "string"
@@ -952,8 +1043,7 @@ export class Spire extends EventEmitter {
                             return;
                         }
                         const censored = censorUser(user);
-                        const token = jwt.sign({ user: censored }, getJwtSecret(), { expiresIn: JWT_EXPIRY });
-                        jwt.verify(token, getJwtSecret());
+                        const token = signAuthJwt({ scope: "user", user: censored }, JWT_EXPIRY);
                         res.send(msgpack.encode({
                             device,
                             token,
@@ -1003,6 +1093,15 @@ export class Spire extends EventEmitter {
             ...(deviceID ? { deviceID } : {}),
         });
     }
+    pruneActionTokens(now = Date.now()) {
+        for (const [key, token] of this.actionTokens) {
+            const createdAt = new Date(token.time).getTime();
+            if (!Number.isFinite(createdAt) ||
+                now - createdAt >= TOKEN_EXPIRY) {
+                this.actionTokens.delete(key);
+            }
+        }
+    }
     removeClient(client) {
         const idx = this.clients.indexOf(client);
         if (idx !== -1) {
@@ -1010,36 +1109,21 @@ export class Spire extends EventEmitter {
         }
     }
     validateToken(key, scope) {
-        for (const rKey of this.actionTokens) {
-            if (rKey.key === key) {
-                if (rKey.scope !== scope) {
-                    continue;
-                }
-                const age = Date.now() - new Date(rKey.time).getTime();
-                if (age < TOKEN_EXPIRY) {
-                    this.deleteActionToken(rKey);
-                    return true;
-                }
-            }
+        this.pruneActionTokens();
+        const token = this.actionTokens.get(key);
+        if (!token || token.scope !== scope) {
+            return false;
         }
-        return false;
+        this.deleteActionToken(token);
+        return true;
     }
 }
 // Usernames are case-insensitive at the protocol level — `User` and
 // `user` must resolve to the same account. We canonicalize to
 // lowercase at the registration boundary so the persisted row, the
 // UNIQUE index, and every downstream lookup all agree on a single
-// representation. Lookups in `Database.retrieveUser` also fold case
-// at compare time so legacy mixed-case rows still resolve.
-function normalizeRegistrationUsername(username, signKeyHex) {
-    const trimmed = username?.trim().toLowerCase();
-    if (trimmed && trimmed.length > 0) {
-        return trimmed;
-    }
-    const seed = signKeyHex
-        .toLowerCase()
-        .replace(/[^a-f0-9]/g, "")
-        .slice(0, 12);
-    return `key_${seed}`;
+// representation. `Database.retrieveUser` applies the same normalization.
+function normalizeRegistrationUsername(username) {
+    return username.trim().toLowerCase();
 }
 //# sourceMappingURL=Spire.js.map