A shared AI notebook where anyone with a library card can run someone else's saved macros — including the ones holding OpenAI keys and cloud tokens
Langflow's /api/v1/responses endpoint takes a client-supplied flow_id (UUID) and executes the flow. The vulnerable code path in get_flow_by_id_or_endpoint_name (helpers/flow.py) queries the database on UUID alone — no user_id ownership check. Any authenticated caller can therefore invoke any other user's flow by guessing/leaking the UUID. Affected versions: all Langflow < 1.9.2 (the fix in PR #12832 initially shipped in 1.9.1, but the definitive vendor-recommended fixed release is 1.9.2). The endpoint_name resolution branch is *not* vulnerable — only the UUID branch skips the ACL.
Vendor rating is HIGH (8.4) using CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:L. Reality is worse than the label. AC:H assumes UUID guessing is hard, but flows persist secrets — OpenAI/Anthropic keys, AWS/GCP credentials, DB passwords — so a single successful invocation cascades into cross-tenant secret theft. Sysdig TRT observed active exploitation starting 2026-06-25, and CISA added it to KEV on 2026-07-07 with a Friday remediation deadline. On a KEV-listed, actively-exploited auth-bypass in an AI orchestration platform that holds every credential the org uses to talk to LLMs and clouds, HIGH understates it.
4 steps from start to impact.
Obtain any authenticated Langflow account
- Reachable Langflow HTTP(S) endpoint
- Any valid authenticated principal (PR:L)
- Instances behind SSO/VPN reduce the pool of eligible attackers
- Signup-disabled deployments require credential compromise first
Enumerate or brute-force target flow UUIDs
flow_id. UUIDv4 is not directly guessable, but UUIDs leak liberally: shared flow URLs, screenshots in Slack, exported JSON, git commits, error messages, and — critically — other Langflow API endpoints (/api/v1/flows/) often return UUIDs for any authenticated caller. Public exploit PoCs published post-disclosure automate this reconnaissance.- Auth token from step 1
- A leaked/enumerated victim UUID
- Pure external UUID guessing is infeasible (this is what earned AC:H)
- Tenants with zero cross-user API visibility narrow enumeration
/api/v1/flows and /api/v1/responses calls per principal reveals abnormal enumerationInvoke victim flow via /api/v1/responses
/api/v1/responses with flow_id=<victim UUID> and arbitrary input. The backend hits the vulnerable UUID branch, skips ACL, executes the flow under the victim's saved credentials/API keys. Exploit is a single HTTP request — trivially weaponized with curl.- Valid session + valid UUID
- None once the two prerequisites are met — the code path has zero authorization guard
/api/v1/responses calls cross-referenced with flow ownership records will reveal owner-mismatch invocationsHarvest secrets and pivot
- Successful step 3 execution
- Vault-referenced (rather than embedded) secrets limit direct leakage
- Egress DLP on the Langflow host can flag anomalous outbound
The supporting signals.
| In-the-wild status | Active exploitation confirmed — Sysdig TRT first observed 2026-06-25; credential-harvesting campaigns ongoing |
|---|---|
| KEV status | Listed 2026-07-07; CISA BOD 22-01 remediation deadline set for federal agencies within days of listing |
| EPSS | 0.00438 (~0.4%) — low because EPSS lags KEV signal by weeks; treat as stale |
| PoC availability | Public writeups and reproduction steps from Sysdig, Endor Labs, and VulnCheck; single-request curl exploit |
| CVSS vector | CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:L → network-reachable, low-priv auth required, scope-changed to other users' data |
| Affected versions | Langflow < 1.9.2 (all releases prior) |
| Fixed version | 1.9.2 (fix originally in PR #12832 shipped in 1.9.1; upgrade directly to 1.9.2) |
| Exposure data | Shodan / Censys show several thousand internet-facing Langflow banners on tcp/7860; unknown share behind auth |
| Disclosed | 2026-06-23 via GHSA-qrpv-q767-xqq2 |
| Reporter | Langflow maintainers via GitHub Security Advisory; exploitation reported by Sysdig Threat Research Team |
noisgate verdict.
Active KEV-listed exploitation for credential harvesting is the single decisive factor — this is no longer a theoretical CVSS-8.4 IDOR, it is a targeted campaign against Langflow deployments in the wild. The affected component holds LLM/cloud/DB secrets by design, so a successful invocation is functionally a credential-store breach across every flow it can reach.
Why this verdict
- KEV + active exploitation — CISA added this on 2026-07-07 after Sysdig documented in-the-wild credential harvesting. KEV alone forces mitigation-within-hours regardless of the bucket.
- Role multiplier — Langflow is a secret-holding orchestration plane. Flows routinely embed OpenAI/Anthropic/Bedrock API keys, cloud IAM tokens, DB creds, and vector-store secrets. A single successful cross-user execute is effectively a credential vault dump for that tenant. Blast radius: tenant → cloud accounts → LLM billing → downstream data stores. This puts the verdict floor at CRITICAL for canonical AI-platform deployments.
- AC:H is misleading. The high complexity rating reflects UUID guessing, but UUIDs leak via other Langflow APIs, shared links, exports, and git. Once a UUID is known, exploitation is a single HTTP call.
- PR:L barrier is soft — any authenticated user counts, and shared/multi-tenant Langflow instances (SaaS, internal dev sandboxes) are exactly the deploy pattern where cross-user attack is the point of the platform.
- Fix is available and cheap (upgrade to 1.9.2), so there is no legitimate business reason to leave this un-remediated past KEV's window.
Why not higher?
There is no higher bucket than CRITICAL. Score is 9.3 rather than 10.0 because the attacker still needs (a) an authenticated foothold and (b) knowledge of a victim UUID — a completely unauthenticated pre-auth RCE would score higher.
Why not lower?
Downgrading to HIGH would ignore the KEV listing and observed exploitation. Downgrading to MEDIUM would ignore that the affected component is a credential-holding orchestration plane and that fix is a trivial version bump. Neither is defensible with Sysdig's telemetry on the table.
What to do — in priority order.
- Upgrade to Langflow 1.9.2 immediately — This is the vendor fix and the only durable control. Per noisgate CRITICAL SLA and KEV override, deploy within hours to 3 days, not weeks. Test in staging same-day, roll to prod within 72h.
- Restrict Langflow to authenticated users behind SSO + VPN/ZTNA — Remove internet exposure of the
/api/v1surface. Front Langflow with an identity-aware proxy so PR:L is not satisfied by self-signup. Deploy within 3 days. - Rotate every secret referenced in any Langflow flow — Assume breach: rotate OpenAI/Anthropic/Bedrock keys, cloud IAM credentials, and DB passwords stored in flows. If exploitation window overlaps 2026-06-25 → patch date, treat exposed secrets as compromised. Complete within 3 days.
- Move secrets out of flow definitions into a vault reference — Even post-patch, embedded secrets are a systemic risk. Use Langflow's variable/global-variable mechanism backed by an external secret store (Vault, AWS Secrets Manager) so the next IDOR-class bug doesn't turn into another credential dump.
- Audit
/api/v1/responseslogs for owner-mismatch invocations — Cross-reference theflow_idin access logs against the flow's owner. Any hit where invoker ≠ owner between 2026-06-23 and patch date is an incident. Complete within 3 days.
- WAF signatures on
/api/v1/responses— the request is syntactically legitimate; there's no malicious payload to match, just a UUID belonging to someone else. - Rate limiting — exploitation is a single request; rate limits don't stop the attack, only mass enumeration.
- Disabling signup — helps but does not fix the bug for any org where multiple users legitimately share a Langflow instance (which is every enterprise deploy).
- Network-layer egress filtering — flows can be legitimately configured to call OpenAI/AWS endpoints; you cannot distinguish attacker-driven from owner-driven calls at L3/L4.
Crowdsourced verification payload.
Run this from an auditor workstation or CI runner that can reach the Langflow instance over HTTPS. Invoke as ./check_langflow.sh https://langflow.example.internal — no privileges required, uses the unauthenticated /health and version endpoints. Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN.
#!/usr/bin/env bash
# noisgate: CVE-2026-55255 Langflow IDOR version check
# Usage: ./check_langflow.sh <base_url>
# Example: ./check_langflow.sh https://langflow.corp.example.com
set -u
BASE_URL="${1:-}"
if [[ -z "$BASE_URL" ]]; then
echo "Usage: $0 <langflow_base_url>" >&2
exit 2
fi
FIXED_MAJOR=1
FIXED_MINOR=9
FIXED_PATCH=2
# Langflow exposes version via /api/v1/version or /health
VER_JSON=$(curl -sk --max-time 10 "${BASE_URL%/}/api/v1/version" || true)
if [[ -z "$VER_JSON" ]]; then
VER_JSON=$(curl -sk --max-time 10 "${BASE_URL%/}/health" || true)
fi
if [[ -z "$VER_JSON" ]]; then
echo "UNKNOWN: could not reach $BASE_URL" >&2
exit 2
fi
VER=$(echo "$VER_JSON" | grep -oE '"version"[[:space:]]*:[[:space:]]*"[0-9]+\.[0-9]+\.[0-9]+' | head -1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+')
if [[ -z "$VER" ]]; then
echo "UNKNOWN: version string not found in response" >&2
exit 2
fi
IFS='.' read -r MAJ MIN PAT <<<"$VER"
if (( MAJ > FIXED_MAJOR )) || \
(( MAJ == FIXED_MAJOR && MIN > FIXED_MINOR )) || \
(( MAJ == FIXED_MAJOR && MIN == FIXED_MINOR && PAT >= FIXED_PATCH )); then
echo "PATCHED: Langflow $VER >= 1.9.2"
exit 0
else
echo "VULNERABLE: Langflow $VER < 1.9.2 (CVE-2026-55255)"
exit 1
fi
If you remember one thing.
/api/v1/responses logs for owner-mismatch invocations between 2026-06-23 and your patch timestamp. Any hit is a confirmed incident — assume exposed API keys are already being used and rotate them regardless.Sources
What defenders are saying.
Crowdsourced verification outputs.
Results submitted by users who ran the verification payload against their environment.