Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

fix(control-api): key trigger rate limits to verified userId

Alfredo Lopez8ead7b21f0fc
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index 82735fc94..5c0eaa98b 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.496",
+ "version": "0.1.497",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.496",
+ "version": "0.1.497",
"dependencies": {
"@clerum/display-field": "file:../packages/display-field",
"@clerum/image-policy": "file:../packages/image-policy",
diff --git a/control-api/package.json b/control-api/package.json
index d861f940d..9d8cd0f10 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.496",
+ "version": "0.1.497",
"description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets",
"main": "dist/main.js",
"engines": {
diff --git a/control-api/src/routes/mcp-host/workflows/trigger.routes.ts b/control-api/src/routes/mcp-host/workflows/trigger.routes.ts
index c6c18eca6..b02703501 100644
--- a/control-api/src/routes/mcp-host/workflows/trigger.routes.ts
+++ b/control-api/src/routes/mcp-host/workflows/trigger.routes.ts
@@ -14,7 +14,7 @@ import {
requireMcpHostControlScope,
requireMcpHostControlWorkflowCaller,
} from '../../workflows/shared/auth.js'
-import { workflowTriggerRateLimit } from '../../workflows/shared/rateLimit.js'
+import { mcpHostWorkflowTriggerRateLimit } from '../../workflows/shared/rateLimit.js'
const logger = rootLogger.child({ module: 'mcp-host-workflows' })
@@ -23,7 +23,7 @@ export function createMcpHostWorkflowTriggerRoutes(gateway: K8sGateway): Router
router.post(
'/workflows/:ns/:name/trigger',
- workflowTriggerRateLimit(),
+ mcpHostWorkflowTriggerRateLimit(),
asyncHandler(async (req: Request, res: Response) => {
const caller = requireMcpHostControlWorkflowCaller(req, res)
if (!caller) return
diff --git a/control-api/src/routes/workflows/shared/rateLimit.ts b/control-api/src/routes/workflows/shared/rateLimit.ts
index 77b2d4ed8..73f50431e 100644
--- a/control-api/src/routes/workflows/shared/rateLimit.ts
+++ b/control-api/src/routes/workflows/shared/rateLimit.ts
@@ -3,6 +3,7 @@ import { ipKeyGenerator, rateLimit } from 'express-rate-limit'
import { createHash } from 'node:crypto'
import { rateLimitMiddleware } from '../../../middleware/rateLimitMiddleware.js'
import { verifyAdminToken } from '../../../utils/auth/adminAuthToken.js'
+import { verifyExternalSessionToken } from '../../../utils/auth/externalSessionAuthToken.js'
import { CONTROL_UI_ADMIN_SESSION_COOKIE, readCookie } from '../../../utils/auth/sessionCookies.js'
import { extractBearerToken } from '../../../utils/extractBearerToken.js'
@@ -149,20 +150,51 @@ export function adminWorkflowTriggerRateLimit() {
})
}
+function hashedWorkflowTriggerBucket(credential: string): string {
+ const hash = createHash('sha256').update(credential).digest('hex').slice(0, 32)
+ return `workflow_trigger:${hash}`
+}
+
+function workflowTriggerRateLimitFor(getCredential: (req: Request) => string | null) {
+ return rateLimitMiddleware({
+ bucketType: 'workflow_trigger',
+ maxPerMinute: WORKFLOW_TRIGGER_PER_MINUTE,
+ getBucketKey: (req: Request) => {
+ const credential = getCredential(req)
+ if (!credential) return null
+ return hashedWorkflowTriggerBucket(credential)
+ },
+ })
+}
+
+function unverifiedTriggerIpCredential(req: Request): string {
+ return `ip:${ipKeyGenerator(req.ip ?? 'unknown')}`
+}
+
+/** Stable per-account key. Raw tokens rotate and must not mint new buckets. */
+function verifiedUserSessionRateLimitSubject(token: string): string | null {
+ const userId = verifyExternalSessionToken(token)?.userId
+ return userId ? `user:${userId}` : null
+}
+
/**
- * Prefer the end-user session when external-rest-api forwards both a service
- * bearer and x-user-session-token. Otherwise every Profile user shares one
- * 10/min bucket keyed to the service identity.
+ * External trigger lane: prefer the verified Profile userId when
+ * external-rest-api forwards both a service bearer and x-user-session-token.
+ * An unverified session header falls back to IP so rotation cannot evade the cap.
*/
export function workflowTriggerRateLimitCredential(req: Request): string | null {
const userSessionToken = String(req.header('x-user-session-token') || '').trim()
- if (userSessionToken) return userSessionToken
+ if (userSessionToken) {
+ return (
+ verifiedUserSessionRateLimitSubject(userSessionToken) || unverifiedTriggerIpCredential(req)
+ )
+ }
const cookie = readCookie(req, CONTROL_UI_ADMIN_SESSION_COOKIE)
const cookieSubject = verifiedAdminRateLimitSubject(cookie)
if (cookieSubject) return cookieSubject
if (cookie) {
- return `ip:${ipKeyGenerator(req.ip ?? 'unknown')}`
+ return unverifiedTriggerIpCredential(req)
}
const bearer = extractBearerToken(req)
@@ -172,17 +204,17 @@ export function workflowTriggerRateLimitCredential(req: Request): string | null
return null
}
+/** mcp-host trigger lane: the authenticated principal is the bearer only. */
+export function mcpHostWorkflowTriggerRateLimitCredential(req: Request): string | null {
+ return extractBearerToken(req)
+}
+
export function workflowTriggerRateLimit() {
- return rateLimitMiddleware({
- bucketType: 'workflow_trigger',
- maxPerMinute: WORKFLOW_TRIGGER_PER_MINUTE,
- getBucketKey: (req: Request) => {
- const credential = workflowTriggerRateLimitCredential(req)
- if (!credential) return null
- const hash = createHash('sha256').update(credential).digest('hex').slice(0, 32)
- return `workflow_trigger:${hash}`
- },
- })
+ return workflowTriggerRateLimitFor(workflowTriggerRateLimitCredential)
+}
+
+export function mcpHostWorkflowTriggerRateLimit() {
+ return workflowTriggerRateLimitFor(mcpHostWorkflowTriggerRateLimitCredential)
}
function workflowAdminReadRateLimit() {
diff --git a/control-api/test/routes.externalWorkflows.test.ts b/control-api/test/routes.externalWorkflows.test.ts
index 9030a0ad6..2adb9e1e6 100644
--- a/control-api/test/routes.externalWorkflows.test.ts
+++ b/control-api/test/routes.externalWorkflows.test.ts
@@ -341,6 +341,7 @@ describe('routes/external/workflows', () => {
const app = makeApp(gateway)
const res = await request(app)
.post(`/external/workflows/${RECIPE_NS}/test-recipe/trigger`)
+ .set('Authorization', 'Bearer service-token')
.set('x-user-session-token', 'user-session-token')
.set('Idempotency-Key', 'external-key-1')
.send({ inputs: { topic: 'alpha' } })
@@ -621,6 +622,48 @@ describe('routes/external/workflows', () => {
expect(keys[0]).not.toBe(keys[1])
})
+ it('reuses one trigger bucket for two session tokens of the same verified user', async () => {
+ mockVerifyExternalSessionToken.mockImplementation(token => {
+ if (token === 'user-session-token' || token === 'user-session-token-rotated') {
+ return USER_SESSION_CLAIMS
+ }
+ return null
+ })
+
+ await gateway.createResource('workflowrecipes', VALID_RECIPE as never, RECIPE_NS)
+ mockRateLimiterAllowed()
+ mockPoolQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 }).mockResolvedValueOnce({
+ rows: [],
+ rowCount: 0,
+ })
+ mockRateLimiterAllowed()
+ mockPoolQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 }).mockResolvedValueOnce({
+ rows: [],
+ rowCount: 0,
+ })
+
+ const app = makeApp(gateway)
+ await request(app)
+ .post(`/external/workflows/${RECIPE_NS}/test-recipe/trigger`)
+ .set('Authorization', 'Bearer service-token')
+ .set('x-user-session-token', 'user-session-token')
+ .set('Idempotency-Key', 'external-key-same-user-a')
+ .send({ inputs: { topic: 'alpha' } })
+ .expect(403)
+ await request(app)
+ .post(`/external/workflows/${RECIPE_NS}/test-recipe/trigger`)
+ .set('Authorization', 'Bearer service-token')
+ .set('x-user-session-token', 'user-session-token-rotated')
+ .set('Idempotency-Key', 'external-key-same-user-b')
+ .send({ inputs: { topic: 'alpha' } })
+ .expect(403)
+
+ const keys = rateLimitBucketKeys()
+ expect(keys).toHaveLength(2)
+ expect(keys[0]).toMatch(/^workflow_trigger:[0-9a-f]{32}$/)
+ expect(keys[0]).toBe(keys[1])
+ })
+
it('reuses one trigger bucket for the same user session and service bearer', async () => {
await gateway.createResource('workflowrecipes', VALID_RECIPE as never, RECIPE_NS)
mockRateLimiterAllowed()
diff --git a/control-api/test/workflows.shared.rateLimit.test.ts b/control-api/test/workflows.shared.rateLimit.test.ts
index 202a129ff..f3e3e17e0 100644
--- a/control-api/test/workflows.shared.rateLimit.test.ts
+++ b/control-api/test/workflows.shared.rateLimit.test.ts
@@ -5,6 +5,8 @@ import {
adminOutputsReadRateLimits,
adminWorkflowRateLimitCredential,
adminWorkflowTriggerRateLimit,
+ mcpHostWorkflowTriggerRateLimit,
+ mcpHostWorkflowTriggerRateLimitCredential,
shouldSkipWorkflowGrantEdgeRateLimit,
verifiedAdminRateLimitSubject,
workflowAdminReadRateLimits,
@@ -18,6 +20,7 @@ import {
const mockCheckAndIncrement = vi.hoisted(() => vi.fn())
const mockVerifyAdminToken = vi.hoisted(() => vi.fn())
+const mockVerifyExternalSessionToken = vi.hoisted(() => vi.fn())
vi.mock('../src/services/rateLimiterService.js', () => ({
checkAndIncrement: (...args: unknown[]) => mockCheckAndIncrement(...args),
@@ -28,6 +31,9 @@ vi.mock('../src/observability/metrics.js', () => ({
vi.mock('../src/utils/auth/adminAuthToken.js', () => ({
verifyAdminToken: (token: string) => mockVerifyAdminToken(token),
}))
+vi.mock('../src/utils/auth/externalSessionAuthToken.js', () => ({
+ verifyExternalSessionToken: (token: string) => mockVerifyExternalSessionToken(token),
+}))
function signedClaims(sub: string) {
return {
@@ -55,6 +61,15 @@ describe('routes/workflows/shared/rateLimit', () => {
mockVerifyAdminToken.mockImplementation((token: string) =>
token.startsWith('signed-') ? signedClaims(token.slice('signed-'.length)) : null
)
+ mockVerifyExternalSessionToken.mockImplementation((token: string) => {
+ if (token === 'user-session-a' || token === 'user-session-a-rotated') {
+ return { userId: 'user-a' }
+ }
+ if (token === 'user-session-b') {
+ return { userId: 'user-b' }
+ }
+ return null
+ })
})
it('adminWorkflowRateLimitCredential accepts HttpOnly admin session cookies', () => {
@@ -413,7 +428,7 @@ describe('routes/workflows/shared/rateLimit', () => {
expect(mockCheckAndIncrement.mock.calls[0]?.[0]).toMatch(/^workflow_grants_read:[0-9a-f]{32}$/)
})
- it('workflowTriggerRateLimitCredential prefers user session over service bearer', () => {
+ it('workflowTriggerRateLimitCredential prefers verified userId over service bearer', () => {
const req = {
header(name: string) {
if (name.toLowerCase() === 'authorization') return 'Bearer service-token'
@@ -422,7 +437,35 @@ describe('routes/workflows/shared/rateLimit', () => {
},
} as express.Request
- expect(workflowTriggerRateLimitCredential(req)).toBe('user-session-a')
+ expect(workflowTriggerRateLimitCredential(req)).toBe('user:user-a')
+ })
+
+ it('workflowTriggerRateLimitCredential reuses one userId across rotated session tokens', () => {
+ const reqFor = (token: string) =>
+ ({
+ header(name: string) {
+ if (name.toLowerCase() === 'authorization') return 'Bearer service-token'
+ if (name.toLowerCase() === 'x-user-session-token') return token
+ return undefined
+ },
+ }) as express.Request
+
+ expect(workflowTriggerRateLimitCredential(reqFor('user-session-a'))).toBe('user:user-a')
+ expect(workflowTriggerRateLimitCredential(reqFor('user-session-a-rotated'))).toBe('user:user-a')
+ })
+
+ it('workflowTriggerRateLimitCredential keys unverified user tokens to IP, not the bearer', () => {
+ const req = {
+ ip: '203.0.113.10',
+ header(name: string) {
+ if (name.toLowerCase() === 'authorization') return 'Bearer service-token'
+ if (name.toLowerCase() === 'x-user-session-token') return 'forged-session'
+ return undefined
+ },
+ } as express.Request
+
+ expect(workflowTriggerRateLimitCredential(req)).toMatch(/^ip:/)
+ expect(workflowTriggerRateLimitCredential(req)).not.toBe('service-token')
})
it('workflowTriggerRateLimitCredential ignores whitespace user tokens and falls back to bearer', () => {
@@ -448,6 +491,18 @@ describe('routes/workflows/shared/rateLimit', () => {
expect(workflowTriggerRateLimitCredential(req)).toBe('service-token')
})
+ it('mcpHostWorkflowTriggerRateLimitCredential ignores an injected user session header', () => {
+ const req = {
+ header(name: string) {
+ if (name.toLowerCase() === 'authorization') return 'Bearer mcp-host-control-token'
+ if (name.toLowerCase() === 'x-user-session-token') return 'user-session-a'
+ return undefined
+ },
+ } as express.Request
+
+ expect(mcpHostWorkflowTriggerRateLimitCredential(req)).toBe('mcp-host-control-token')
+ })
+
it('workflowTriggerRateLimit keys independent buckets for two users behind the same service bearer', async () => {
mockCheckAndIncrement.mockReset()
mockCheckAndIncrement.mockResolvedValue({
@@ -487,6 +542,106 @@ describe('routes/workflows/shared/rateLimit', () => {
expect(keyAAgain).toBe(keyA)
})
+ it('workflowTriggerRateLimit reuses one bucket for two tokens of the same verified user', async () => {
+ mockCheckAndIncrement.mockReset()
+ mockCheckAndIncrement.mockResolvedValue({
+ allowed: true,
+ remaining: 9,
+ resetMs: Date.now() + 60_000,
+ windowStartMs: Date.now(),
+ count: 1,
+ })
+
+ const app = express()
+ app.post('/trigger', workflowTriggerRateLimit(), (_req, res) => {
+ res.status(200).json({ ok: true })
+ })
+
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer service-token')
+ .set('x-user-session-token', 'user-session-a')
+ .expect(200)
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer service-token')
+ .set('x-user-session-token', 'user-session-a-rotated')
+ .expect(200)
+
+ expect(mockCheckAndIncrement).toHaveBeenCalledTimes(2)
+ expect(mockCheckAndIncrement.mock.calls[0]?.[0]).toBe(mockCheckAndIncrement.mock.calls[1]?.[0])
+ })
+
+ it('workflowTriggerRateLimit reuses one IP bucket for rotated unverified user tokens', async () => {
+ mockCheckAndIncrement.mockReset()
+ mockCheckAndIncrement.mockResolvedValue({
+ allowed: true,
+ remaining: 9,
+ resetMs: Date.now() + 60_000,
+ windowStartMs: Date.now(),
+ count: 1,
+ })
+
+ const app = express()
+ app.post('/trigger', workflowTriggerRateLimit(), (_req, res) => {
+ res.status(200).json({ ok: true })
+ })
+
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer service-token')
+ .set('x-user-session-token', 'forged-session-a')
+ .expect(200)
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer service-token')
+ .set('x-user-session-token', 'forged-session-b')
+ .expect(200)
+
+ expect(mockCheckAndIncrement).toHaveBeenCalledTimes(2)
+ expect(mockCheckAndIncrement.mock.calls[0]?.[0]).toMatch(/^workflow_trigger:[0-9a-f]{32}$/)
+ expect(mockCheckAndIncrement.mock.calls[0]?.[0]).toBe(mockCheckAndIncrement.mock.calls[1]?.[0])
+ })
+
+ it('mcpHostWorkflowTriggerRateLimit stays on the bearer when a user session is injected', async () => {
+ mockCheckAndIncrement.mockReset()
+ mockCheckAndIncrement.mockResolvedValue({
+ allowed: true,
+ remaining: 9,
+ resetMs: Date.now() + 60_000,
+ windowStartMs: Date.now(),
+ count: 1,
+ })
+
+ const app = express()
+ app.post('/trigger', mcpHostWorkflowTriggerRateLimit(), (_req, res) => {
+ res.status(200).json({ ok: true })
+ })
+
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer mcp-host-control-token')
+ .expect(200)
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer mcp-host-control-token')
+ .set('x-user-session-token', 'user-session-a')
+ .expect(200)
+ await request(app)
+ .post('/trigger')
+ .set('Authorization', 'Bearer mcp-host-control-token')
+ .set('x-user-session-token', 'forged-session')
+ .expect(200)
+
+ expect(mockCheckAndIncrement).toHaveBeenCalledTimes(3)
+ const [bearerOnly, injectedVerified, injectedForged] = mockCheckAndIncrement.mock.calls.map(
+ call => call[0]
+ )
+ expect(bearerOnly).toMatch(/^workflow_trigger:[0-9a-f]{32}$/)
+ expect(injectedVerified).toBe(bearerOnly)
+ expect(injectedForged).toBe(bearerOnly)
+ })
+
it('workflowTriggerRateLimit falls back to the service bearer without a user token', async () => {
mockCheckAndIncrement.mockReset()
mockCheckAndIncrement.mockResolvedValue({