@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.
174 lines • 24.3 kB
JavaScript
/**
* Express middleware for console Bearer token authentication (#1780).
*
* Checks the `Authorization: Bearer <token>` header on requests to protected
* endpoints, with a `?token=<token>` query parameter fallback for SSE streams
* (EventSource cannot set custom headers).
*
* Behavior is gated on the `DOLLHOUSE_WEB_AUTH_ENABLED` env var. When the flag
* is false (the default during Phase 1 rollout) the middleware is a no-op —
* requests pass through unconditionally. When true, every protected request
* must carry a valid token or receive a 401.
*
* Phase 1 design notes:
* - Every valid token is treated as admin-scoped. Scope enforcement is a
* stubbed hook (`authorizeScope`) that always returns true. Phase 2 swaps
* in real scope checks without touching any route handler.
* - Element boundaries and tenant filtering are similarly stubbed for Phase 3.
* - The middleware attaches the matched token entry to `res.locals.tokenEntry`
* so downstream handlers can inspect it (audit logs, scope decisions, etc.).
*
* @since v2.1.0 — Issue #1780
*/
import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
import { logger } from '../../utils/logger.js';
/** Query parameter name used as a fallback for SSE streams. */
const TOKEN_QUERY_PARAM = 'token';
/** Header name we look at for Bearer tokens. */
const AUTH_HEADER = 'authorization';
/** Prefix expected on the Authorization header value. */
const BEARER_PREFIX = 'Bearer ';
/**
* Strict format for console tokens — 64 lowercase hex characters (256 bits).
* Any presented token that does not match this pattern is rejected before it
* reaches the constant-time comparison. This blocks any non-ASCII Unicode
* payload (homographs, zero-width, bidi overrides, etc.) from ever touching
* the verify path. DMCP-SEC-004 mitigation.
*/
const TOKEN_FORMAT = /^[0-9a-f]{64}$/;
/**
* Sanitize a raw token string pulled from a request.
*
* - Normalizes to NFC via UnicodeValidator (DMCP-SEC-004)
* - Validates against the strict hex format
* - Returns the cleaned value, or null if anything looks wrong
*
* Any failure here results in a 401 at the call site. Legitimate tokens are
* 64-char lowercase hex, so normalization and format validation are effectively
* no-ops for valid input and hard rejections for anything malicious.
*/
function sanitizePresentedToken(raw) {
if (!raw)
return null;
const normalized = UnicodeValidator.normalize(raw).normalizedContent;
if (!TOKEN_FORMAT.test(normalized))
return null;
return normalized;
}
/**
* Extract a Bearer token from a request.
* Checks Authorization header first, then query parameter.
* Applies Unicode normalization and strict format validation before returning.
* Returns the sanitized token string, or null if none was found or the value
* failed validation.
*/
function extractToken(req) {
// Preferred: Authorization: Bearer <token>
const header = req.headers[AUTH_HEADER];
if (typeof header === 'string' && header.startsWith(BEARER_PREFIX)) {
const value = header.slice(BEARER_PREFIX.length).trim();
if (value) {
const sanitized = sanitizePresentedToken(value);
if (sanitized)
return sanitized;
}
}
// Fallback for EventSource: ?token=<token>
const q = req.query[TOKEN_QUERY_PARAM];
if (typeof q === 'string' && q.length > 0) {
return sanitizePresentedToken(q);
}
if (Array.isArray(q) && q.length > 0 && typeof q[0] === 'string') {
return sanitizePresentedToken(q[0]);
}
return null;
}
/**
* Create the core authentication middleware.
*
* The returned handler enforces Bearer token auth on every request it sees.
* Mount it with `app.use(createAuthMiddleware(...))` before protected routers,
* or attach it to individual routes that need protection.
*
* When `enabled: false`, the handler immediately calls `next()` — allowing
* the infrastructure to land with the default-off feature flag without
* breaking existing traffic.
*
* Phase 3 hardening (tracked in #1789): Add 401 rate limiting to prevent
* DoS from floods of bad-token requests. Brute-forcing a 256-bit token is
* infeasible, but an attacker flooding /api with wrong tokens could saturate
* the verify path. A sliding-window limiter keyed on the requesting IP is
* the right shape.
*/
export function createAuthMiddleware(options) {
const { store, enabled, label = 'console' } = options;
const publicPaths = options.publicPathPrefixes ?? [];
return (req, res, next) => {
if (!enabled) {
return next();
}
// Public path allowlist — skip auth for whitelisted prefixes.
// Use originalUrl.pathname so we match regardless of mount point.
const pathToCheck = req.originalUrl.split('?')[0];
for (const prefix of publicPaths) {
if (pathToCheck === prefix || pathToCheck.startsWith(prefix + '/')) {
return next();
}
}
const presented = extractToken(req);
if (!presented) {
return respondUnauthorized(res, 'missing_token', label, store, 0);
}
const entry = store.verify(presented);
if (!entry) {
// Log presented-length only — never the presented value itself.
// Distinguishes "token missing" from "token wrong length" from
// "length matches but content differs" when troubleshooting.
return respondUnauthorized(res, 'invalid_token', label, store, presented.length);
}
// Stubbed authorization hook — Phase 2 flips real scope checks on here.
if (!authorizeScope(entry, req)) {
return respondForbidden(res, 'scope_denied', label, entry);
}
// Stash the matched entry for downstream handlers and log success at debug.
res.locals.tokenEntry = entry;
logger.debug(`[Auth:${label}] verified token id=${entry.id} name="${entry.name}" route=${req.method} ${req.originalUrl.split('?')[0]}`);
return next();
};
}
/**
* Scope authorization hook.
*
* Phase 1: every valid token is treated as admin — returns true unconditionally.
* Phase 2: this function will check `entry.scopes` against the route's required
* scopes (which can be attached via `res.locals.requiredScope` or a route
* metadata system).
*/
function authorizeScope(_entry, _req) {
return true;
}
/**
* Respond with 401 Unauthorized and a helpful hint about where to find the token.
* Includes presented-token length at debug level for troubleshooting — never the value.
*/
function respondUnauthorized(res, reason, label, store, presentedLength) {
logger.debug(`[Auth:${label}] 401 ${reason} presentedLength=${presentedLength}`);
res.status(401).json({
error: 'Authentication required',
reason,
hint: `Token file: ${store.getFilePath()}. Send 'Authorization: Bearer <token>' header, or append ?token=<token> for SSE streams.`,
});
}
/**
* Respond with 403 Forbidden — token was valid but scope did not permit this route.
* Phase 1 never reaches here because `authorizeScope` always returns true, but
* the code path exists so Phase 2 can wire it up without changing the middleware shape.
*/
function respondForbidden(res, reason, label, entry) {
logger.debug(`[Auth:${label}] 403 ${reason}`, { tokenId: entry.id, scopes: entry.scopes });
res.status(403).json({
error: 'Token scope does not permit this action',
reason,
});
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authMiddleware.js","sourceRoot":"","sources":["../../../src/web/middleware/authMiddleware.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Express middleware for console Bearer token authentication (#1780).\n *\n * Checks the `Authorization: Bearer <token>` header on requests to protected\n * endpoints, with a `?token=<token>` query parameter fallback for SSE streams\n * (EventSource cannot set custom headers).\n *\n * Behavior is gated on the `DOLLHOUSE_WEB_AUTH_ENABLED` env var. When the flag\n * is false (the default during Phase 1 rollout) the middleware is a no-op —\n * requests pass through unconditionally. When true, every protected request\n * must carry a valid token or receive a 401.\n *\n * Phase 1 design notes:\n * - Every valid token is treated as admin-scoped. Scope enforcement is a\n *   stubbed hook (`authorizeScope`) that always returns true. Phase 2 swaps\n *   in real scope checks without touching any route handler.\n * - Element boundaries and tenant filtering are similarly stubbed for Phase 3.\n * - The middleware attaches the matched token entry to `res.locals.tokenEntry`\n *   so downstream handlers can inspect it (audit logs, scope decisions, etc.).\n *\n * @since v2.1.0 — Issue #1780\n */\n\nimport type { Request, Response, NextFunction, RequestHandler } from 'express';\nimport type { ConsoleTokenStore, ConsoleTokenEntry } from '../console/consoleToken.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\n\n/** Query parameter name used as a fallback for SSE streams. */\nconst TOKEN_QUERY_PARAM = 'token';\n\n/** Header name we look at for Bearer tokens. */\nconst AUTH_HEADER = 'authorization';\n\n/** Prefix expected on the Authorization header value. */\nconst BEARER_PREFIX = 'Bearer ';\n\n/**\n * Strict format for console tokens — 64 lowercase hex characters (256 bits).\n * Any presented token that does not match this pattern is rejected before it\n * reaches the constant-time comparison. This blocks any non-ASCII Unicode\n * payload (homographs, zero-width, bidi overrides, etc.) from ever touching\n * the verify path. DMCP-SEC-004 mitigation.\n */\nconst TOKEN_FORMAT = /^[0-9a-f]{64}$/;\n\n/**\n * Sanitize a raw token string pulled from a request.\n *\n * - Normalizes to NFC via UnicodeValidator (DMCP-SEC-004)\n * - Validates against the strict hex format\n * - Returns the cleaned value, or null if anything looks wrong\n *\n * Any failure here results in a 401 at the call site. Legitimate tokens are\n * 64-char lowercase hex, so normalization and format validation are effectively\n * no-ops for valid input and hard rejections for anything malicious.\n */\nfunction sanitizePresentedToken(raw: string): string | null {\n  if (!raw) return null;\n  const normalized = UnicodeValidator.normalize(raw).normalizedContent;\n  if (!TOKEN_FORMAT.test(normalized)) return null;\n  return normalized;\n}\n\n/**\n * Extract a Bearer token from a request.\n * Checks Authorization header first, then query parameter.\n * Applies Unicode normalization and strict format validation before returning.\n * Returns the sanitized token string, or null if none was found or the value\n * failed validation.\n */\nfunction extractToken(req: Request): string | null {\n  // Preferred: Authorization: Bearer <token>\n  const header = req.headers[AUTH_HEADER];\n  if (typeof header === 'string' && header.startsWith(BEARER_PREFIX)) {\n    const value = header.slice(BEARER_PREFIX.length).trim();\n    if (value) {\n      const sanitized = sanitizePresentedToken(value);\n      if (sanitized) return sanitized;\n    }\n  }\n\n  // Fallback for EventSource: ?token=<token>\n  const q = req.query[TOKEN_QUERY_PARAM];\n  if (typeof q === 'string' && q.length > 0) {\n    return sanitizePresentedToken(q);\n  }\n  if (Array.isArray(q) && q.length > 0 && typeof q[0] === 'string') {\n    return sanitizePresentedToken(q[0]);\n  }\n\n  return null;\n}\n\n/**\n * Options for the auth middleware factory.\n */\nexport interface AuthMiddlewareOptions {\n  /** The token store holding valid tokens. */\n  store: ConsoleTokenStore;\n  /** Whether auth is enforced. When false, middleware is a no-op. */\n  enabled: boolean;\n  /**\n   * Path prefixes that are never protected. A request whose URL path starts\n   * with any of these strings will skip auth and be passed through to the\n   * next handler. Used to exempt health checks, version info, client detection,\n   * and similar public metadata endpoints.\n   *\n   * Paths are compared against `req.path` (the route-relative path), so include\n   * the full pathname starting with `/` — e.g. `/api/health`, `/api/setup/version`.\n   */\n  publicPathPrefixes?: string[];\n  /** Optional label for log messages (e.g. \"api\" or \"sse\"). */\n  label?: string;\n}\n\n/**\n * Create the core authentication middleware.\n *\n * The returned handler enforces Bearer token auth on every request it sees.\n * Mount it with `app.use(createAuthMiddleware(...))` before protected routers,\n * or attach it to individual routes that need protection.\n *\n * When `enabled: false`, the handler immediately calls `next()` — allowing\n * the infrastructure to land with the default-off feature flag without\n * breaking existing traffic.\n *\n * Phase 3 hardening (tracked in #1789): Add 401 rate limiting to prevent\n * DoS from floods of bad-token requests. Brute-forcing a 256-bit token is\n * infeasible, but an attacker flooding /api with wrong tokens could saturate\n * the verify path. A sliding-window limiter keyed on the requesting IP is\n * the right shape.\n */\nexport function createAuthMiddleware(options: AuthMiddlewareOptions): RequestHandler {\n  const { store, enabled, label = 'console' } = options;\n  const publicPaths = options.publicPathPrefixes ?? [];\n\n  return (req: Request, res: Response, next: NextFunction) => {\n    if (!enabled) {\n      return next();\n    }\n\n    // Public path allowlist — skip auth for whitelisted prefixes.\n    // Use originalUrl.pathname so we match regardless of mount point.\n    const pathToCheck = req.originalUrl.split('?')[0];\n    for (const prefix of publicPaths) {\n      if (pathToCheck === prefix || pathToCheck.startsWith(prefix + '/')) {\n        return next();\n      }\n    }\n\n    const presented = extractToken(req);\n    if (!presented) {\n      return respondUnauthorized(res, 'missing_token', label, store, 0);\n    }\n\n    const entry = store.verify(presented);\n    if (!entry) {\n      // Log presented-length only — never the presented value itself.\n      // Distinguishes \"token missing\" from \"token wrong length\" from\n      // \"length matches but content differs\" when troubleshooting.\n      return respondUnauthorized(res, 'invalid_token', label, store, presented.length);\n    }\n\n    // Stubbed authorization hook — Phase 2 flips real scope checks on here.\n    if (!authorizeScope(entry, req)) {\n      return respondForbidden(res, 'scope_denied', label, entry);\n    }\n\n    // Stash the matched entry for downstream handlers and log success at debug.\n    res.locals.tokenEntry = entry;\n    logger.debug(`[Auth:${label}] verified token id=${entry.id} name=\"${entry.name}\" route=${req.method} ${req.originalUrl.split('?')[0]}`);\n    return next();\n  };\n}\n\n/**\n * Scope authorization hook.\n *\n * Phase 1: every valid token is treated as admin — returns true unconditionally.\n * Phase 2: this function will check `entry.scopes` against the route's required\n * scopes (which can be attached via `res.locals.requiredScope` or a route\n * metadata system).\n */\nfunction authorizeScope(_entry: ConsoleTokenEntry, _req: Request): boolean {\n  return true;\n}\n\n/**\n * Respond with 401 Unauthorized and a helpful hint about where to find the token.\n * Includes presented-token length at debug level for troubleshooting — never the value.\n */\nfunction respondUnauthorized(\n  res: Response,\n  reason: 'missing_token' | 'invalid_token',\n  label: string,\n  store: ConsoleTokenStore,\n  presentedLength: number,\n): void {\n  logger.debug(`[Auth:${label}] 401 ${reason} presentedLength=${presentedLength}`);\n  res.status(401).json({\n    error: 'Authentication required',\n    reason,\n    hint: `Token file: ${store.getFilePath()}. Send 'Authorization: Bearer <token>' header, or append ?token=<token> for SSE streams.`,\n  });\n}\n\n/**\n * Respond with 403 Forbidden — token was valid but scope did not permit this route.\n * Phase 1 never reaches here because `authorizeScope` always returns true, but\n * the code path exists so Phase 2 can wire it up without changing the middleware shape.\n */\nfunction respondForbidden(\n  res: Response,\n  reason: string,\n  label: string,\n  entry: ConsoleTokenEntry,\n): void {\n  logger.debug(`[Auth:${label}] 403 ${reason}`, { tokenId: entry.id, scopes: entry.scopes });\n  res.status(403).json({\n    error: 'Token scope does not permit this action',\n    reason,\n  });\n}\n"]}