@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
187 lines • 27.4 kB
JavaScript
/**
* TOTP (authenticator) enrollment HTTP routes — Phase 2 of #1780 (#1794).
*
* Provides:
* - GET /api/console/totp/status — enrollment state (no secrets)
* - POST /api/console/totp/enroll/begin — generate secret, return QR + otpauth URI
* - POST /api/console/totp/enroll/confirm — verify code, persist, return backup codes (once)
* - POST /api/console/totp/disable — verify code, clear enrollment
*
* Security model:
* - All endpoints require a valid existing console token. The caller must
* prove they already hold the token before they can enroll a second
* factor — otherwise an attacker with local port access could pre-enroll
* their own authenticator and lock the legitimate user out.
* - Enforcement happens via an always-on `createAuthMiddleware` instance
* mounted at the top of this router, independent of the global
* DOLLHOUSE_WEB_AUTH_ENABLED flag.
* - Backup codes are returned in plaintext exactly once (confirm response)
* and only their sha256 hashes are retained by the store.
* - A sliding-window rate limit throttles confirm/disable attempts on a
* per-IP basis so a bad actor with a live session can't brute-force a
* TOTP window by flooding requests.
*
* @since v2.1.0 — Issue #1794
*/
import express, { Router } from 'express';
import QRCode from 'qrcode';
import { TotpError } from '../console/consoleToken.js';
import { createAuthMiddleware } from '../middleware/authMiddleware.js';
import { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';
import { httpStatusForStoreError, sendStoreError, getNormalizedStringField } from './consoleRouteHelpers.js';
import { logger } from '../../utils/logger.js';
/** JSON body size limit — TOTP requests are tiny, cap hard. */
const BODY_LIMIT = '1kb';
/**
* Default rate limit for code-verification endpoints: 10 attempts per minute.
* TOTP codes are 6 digits (1-in-10^6 guess rate) and the ±30s window gives
* an attacker up to 3 valid codes per minute. 10 attempts caps brute-force
* success probability per minute at ~3e-5 even before network latency.
*
* Limiters are per-endpoint (confirm vs disable) because they protect
* different secrets: confirm tests the in-memory pending enrollment secret
* (bounded lifetime, attacker must also know the pendingId), disable tests
* the persisted enrollment secret (long-lived). A single shared limiter
* would let traffic on one endpoint exhaust budget on the other.
*
* Limiters are global (not per-IP) because the server binds to 127.0.0.1
* only — every request comes from the same loopback address, so keying on
* IP would collapse to a single bucket anyway.
*
* Tests construct a fresh router per `buildApp`, which yields fresh
* limiters, so no cross-test pollution.
*/
const DEFAULT_RATE_LIMIT_MAX = 10;
const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
/**
* Render an otpauth URI as an SVG data URL suitable for direct embedding
* in an <img src> or background-image. Separated into a helper so the
* request handler stays readable.
*/
async function renderQrDataUrl(otpauthUri) {
// errorCorrectionLevel 'M' is the default and balances size vs robustness.
// We emit SVG (not PNG) because it scales to any container size and is
// smaller on the wire for this particular payload.
const svg = await QRCode.toString(otpauthUri, { type: 'svg', margin: 1 });
return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;
}
/**
* Build the Express router exposing TOTP endpoints. The returned router
* should be mounted at `/api/console/totp`; the caller does not need to
* add additional auth middleware — this router enforces its own auth
* regardless of the global feature flag.
*/
export function createTotpRoutes(options) {
const { store } = options;
const router = Router();
const jsonParser = express.json({ limit: BODY_LIMIT, type: 'application/json' });
// Fresh per-endpoint limiters per router instance. Separate buckets for
// confirm vs disable — they protect different secrets, so traffic on one
// should not exhaust the budget of the other. Fresh instances per call
// keep tests isolated.
const rateLimitMax = options.rateLimitMax ?? DEFAULT_RATE_LIMIT_MAX;
const rateLimitWindowMs = options.rateLimitWindowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS;
const confirmLimiter = new SlidingWindowRateLimiter(rateLimitMax, rateLimitWindowMs);
const disableLimiter = new SlidingWindowRateLimiter(rateLimitMax, rateLimitWindowMs);
// Always-on auth — the global feature flag does not apply here. Even
// during Phase 1 rollout (flag off), the TOTP endpoints must verify that
// the caller already holds the console token before letting them enroll
// a second factor. Otherwise an attacker with local port access could
// enroll their own authenticator and lock the real user out.
const auth = createAuthMiddleware({
store,
enabled: true,
label: 'totp',
});
router.use(auth);
/** GET /status — enrollment state (no secret material). */
router.get('/status', (_req, res) => {
res.json(store.getTotpStatus());
});
/** POST /enroll/begin — generate pending secret, return QR + URI. */
router.post('/enroll/begin', jsonParser, async (req, res) => {
// Optional label override — lets the UI label the authenticator entry
// differently if the user has renamed the console token.
const label = getNormalizedStringField(req.body, 'label') ?? undefined;
try {
const begin = store.beginTotpEnrollment(label);
const qrSvgDataUrl = await renderQrDataUrl(begin.otpauthUri);
res.json({
pendingId: begin.pendingId,
secret: begin.secret,
otpauthUri: begin.otpauthUri,
qrSvgDataUrl,
expiresAt: begin.expiresAt,
});
}
catch (err) {
const message = err instanceof Error ? err.message : 'Enrollment could not be started';
logger.debug(`[TOTP] begin failed: ${message}`);
if (err instanceof TotpError) {
sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);
}
else {
sendStoreError(res, 500, 'INTERNAL', message);
}
}
});
/** POST /enroll/confirm — verify code, persist, return backup codes (once). */
router.post('/enroll/confirm', jsonParser, async (req, res) => {
if (!confirmLimiter.tryAcquire()) {
sendStoreError(res, 429, 'RATE_LIMITED', 'Too many confirmation attempts — slow down');
return;
}
const pendingId = getNormalizedStringField(req.body, 'pendingId');
const code = getNormalizedStringField(req.body, 'code');
if (!pendingId || !code) {
sendStoreError(res, 400, 'MISSING_FIELDS', 'pendingId and code are required');
return;
}
try {
const result = await store.confirmTotpEnrollment(pendingId, code);
res.json({
enrolled: true,
enrolledAt: result.enrolledAt,
backupCodes: result.backupCodes,
});
}
catch (err) {
const message = err instanceof Error ? err.message : 'Confirmation failed';
logger.debug(`[TOTP] confirm failed: ${message}`);
if (err instanceof TotpError) {
sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);
}
else {
sendStoreError(res, 500, 'INTERNAL', message);
}
}
});
/** POST /disable — verify code, clear enrollment. */
router.post('/disable', jsonParser, async (req, res) => {
if (!disableLimiter.tryAcquire()) {
sendStoreError(res, 429, 'RATE_LIMITED', 'Too many disable attempts — slow down');
return;
}
const code = getNormalizedStringField(req.body, 'code');
if (!code) {
sendStoreError(res, 400, 'MISSING_FIELDS', 'code is required');
return;
}
try {
await store.disableTotp(code);
res.json({ enrolled: false });
}
catch (err) {
const message = err instanceof Error ? err.message : 'Disable failed';
logger.debug(`[TOTP] disable failed: ${message}`);
if (err instanceof TotpError) {
sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);
}
else {
sendStoreError(res, 500, 'INTERNAL', message);
}
}
});
return router;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"totpRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/totpRoutes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TOTP (authenticator) enrollment HTTP routes — Phase 2 of #1780 (#1794).\n *\n * Provides:\n * - GET    /api/console/totp/status        — enrollment state (no secrets)\n * - POST   /api/console/totp/enroll/begin  — generate secret, return QR + otpauth URI\n * - POST   /api/console/totp/enroll/confirm — verify code, persist, return backup codes (once)\n * - POST   /api/console/totp/disable       — verify code, clear enrollment\n *\n * Security model:\n * - All endpoints require a valid existing console token. The caller must\n *   prove they already hold the token before they can enroll a second\n *   factor — otherwise an attacker with local port access could pre-enroll\n *   their own authenticator and lock the legitimate user out.\n * - Enforcement happens via an always-on `createAuthMiddleware` instance\n *   mounted at the top of this router, independent of the global\n *   DOLLHOUSE_WEB_AUTH_ENABLED flag.\n * - Backup codes are returned in plaintext exactly once (confirm response)\n *   and only their sha256 hashes are retained by the store.\n * - A sliding-window rate limit throttles confirm/disable attempts on a\n *   per-IP basis so a bad actor with a live session can't brute-force a\n *   TOTP window by flooding requests.\n *\n * @since v2.1.0 — Issue #1794\n */\n\nimport express, { Router } from 'express';\nimport type { Request, Response } from 'express';\nimport QRCode from 'qrcode';\nimport { TotpError, type ConsoleTokenStore } from '../console/consoleToken.js';\nimport { createAuthMiddleware } from '../middleware/authMiddleware.js';\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\nimport { httpStatusForStoreError, sendStoreError, getNormalizedStringField } from './consoleRouteHelpers.js';\nimport { logger } from '../../utils/logger.js';\n\n/** JSON body size limit — TOTP requests are tiny, cap hard. */\nconst BODY_LIMIT = '1kb';\n\n/**\n * Default rate limit for code-verification endpoints: 10 attempts per minute.\n * TOTP codes are 6 digits (1-in-10^6 guess rate) and the ±30s window gives\n * an attacker up to 3 valid codes per minute. 10 attempts caps brute-force\n * success probability per minute at ~3e-5 even before network latency.\n *\n * Limiters are per-endpoint (confirm vs disable) because they protect\n * different secrets: confirm tests the in-memory pending enrollment secret\n * (bounded lifetime, attacker must also know the pendingId), disable tests\n * the persisted enrollment secret (long-lived). A single shared limiter\n * would let traffic on one endpoint exhaust budget on the other.\n *\n * Limiters are global (not per-IP) because the server binds to 127.0.0.1\n * only — every request comes from the same loopback address, so keying on\n * IP would collapse to a single bucket anyway.\n *\n * Tests construct a fresh router per `buildApp`, which yields fresh\n * limiters, so no cross-test pollution.\n */\nconst DEFAULT_RATE_LIMIT_MAX = 10;\nconst DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;\n\n/**\n * Render an otpauth URI as an SVG data URL suitable for direct embedding\n * in an <img src> or background-image. Separated into a helper so the\n * request handler stays readable.\n */\nasync function renderQrDataUrl(otpauthUri: string): Promise<string> {\n  // errorCorrectionLevel 'M' is the default and balances size vs robustness.\n  // We emit SVG (not PNG) because it scales to any container size and is\n  // smaller on the wire for this particular payload.\n  const svg = await QRCode.toString(otpauthUri, { type: 'svg', margin: 1 });\n  return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;\n}\n\n/**\n * Options for the TOTP routes factory.\n */\nexport interface TotpRoutesOptions {\n  store: ConsoleTokenStore;\n  /** Maximum code-verification attempts per window. Default: 10. */\n  rateLimitMax?: number;\n  /** Rate limit window in milliseconds. Default: 60_000 (1 minute). */\n  rateLimitWindowMs?: number;\n}\n\n/**\n * Build the Express router exposing TOTP endpoints. The returned router\n * should be mounted at `/api/console/totp`; the caller does not need to\n * add additional auth middleware — this router enforces its own auth\n * regardless of the global feature flag.\n */\nexport function createTotpRoutes(options: TotpRoutesOptions): Router {\n  const { store } = options;\n  const router = Router();\n  const jsonParser = express.json({ limit: BODY_LIMIT, type: 'application/json' });\n  // Fresh per-endpoint limiters per router instance. Separate buckets for\n  // confirm vs disable — they protect different secrets, so traffic on one\n  // should not exhaust the budget of the other. Fresh instances per call\n  // keep tests isolated.\n  const rateLimitMax = options.rateLimitMax ?? DEFAULT_RATE_LIMIT_MAX;\n  const rateLimitWindowMs = options.rateLimitWindowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS;\n  const confirmLimiter = new SlidingWindowRateLimiter(rateLimitMax, rateLimitWindowMs);\n  const disableLimiter = new SlidingWindowRateLimiter(rateLimitMax, rateLimitWindowMs);\n\n  // Always-on auth — the global feature flag does not apply here. Even\n  // during Phase 1 rollout (flag off), the TOTP endpoints must verify that\n  // the caller already holds the console token before letting them enroll\n  // a second factor. Otherwise an attacker with local port access could\n  // enroll their own authenticator and lock the real user out.\n  const auth = createAuthMiddleware({\n    store,\n    enabled: true,\n    label: 'totp',\n  });\n  router.use(auth);\n\n  /** GET /status — enrollment state (no secret material). */\n  router.get('/status', (_req: Request, res: Response) => {\n    res.json(store.getTotpStatus());\n  });\n\n  /** POST /enroll/begin — generate pending secret, return QR + URI. */\n  router.post('/enroll/begin', jsonParser, async (req: Request, res: Response) => {\n    // Optional label override — lets the UI label the authenticator entry\n    // differently if the user has renamed the console token.\n    const label = getNormalizedStringField(req.body, 'label') ?? undefined;\n    try {\n      const begin = store.beginTotpEnrollment(label);\n      const qrSvgDataUrl = await renderQrDataUrl(begin.otpauthUri);\n      res.json({\n        pendingId: begin.pendingId,\n        secret: begin.secret,\n        otpauthUri: begin.otpauthUri,\n        qrSvgDataUrl,\n        expiresAt: begin.expiresAt,\n      });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : 'Enrollment could not be started';\n      logger.debug(`[TOTP] begin failed: ${message}`);\n      if (err instanceof TotpError) {\n        sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);\n      } else {\n        sendStoreError(res, 500, 'INTERNAL', message);\n      }\n    }\n  });\n\n  /** POST /enroll/confirm — verify code, persist, return backup codes (once). */\n  router.post('/enroll/confirm', jsonParser, async (req: Request, res: Response) => {\n    if (!confirmLimiter.tryAcquire()) {\n      sendStoreError(res, 429, 'RATE_LIMITED', 'Too many confirmation attempts — slow down');\n      return;\n    }\n    const pendingId = getNormalizedStringField(req.body, 'pendingId');\n    const code = getNormalizedStringField(req.body, 'code');\n    if (!pendingId || !code) {\n      sendStoreError(res, 400, 'MISSING_FIELDS', 'pendingId and code are required');\n      return;\n    }\n    try {\n      const result = await store.confirmTotpEnrollment(pendingId, code);\n      res.json({\n        enrolled: true,\n        enrolledAt: result.enrolledAt,\n        backupCodes: result.backupCodes,\n      });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : 'Confirmation failed';\n      logger.debug(`[TOTP] confirm failed: ${message}`);\n      if (err instanceof TotpError) {\n        sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);\n      } else {\n        sendStoreError(res, 500, 'INTERNAL', message);\n      }\n    }\n  });\n\n  /** POST /disable — verify code, clear enrollment. */\n  router.post('/disable', jsonParser, async (req: Request, res: Response) => {\n    if (!disableLimiter.tryAcquire()) {\n      sendStoreError(res, 429, 'RATE_LIMITED', 'Too many disable attempts — slow down');\n      return;\n    }\n    const code = getNormalizedStringField(req.body, 'code');\n    if (!code) {\n      sendStoreError(res, 400, 'MISSING_FIELDS', 'code is required');\n      return;\n    }\n    try {\n      await store.disableTotp(code);\n      res.json({ enrolled: false });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : 'Disable failed';\n      logger.debug(`[TOTP] disable failed: ${message}`);\n      if (err instanceof TotpError) {\n        sendStoreError(res, httpStatusForStoreError(err.code), err.code, err.message);\n      } else {\n        sendStoreError(res, 500, 'INTERNAL', message);\n      }\n    }\n  });\n\n  return router;\n}\n"]}