Skip to main content

Dify CVE-2026-105761

HIGH
Authorization Bypass Through User-Controlled Key (CWE-639)
2026-10-05 security-advisories@github.com
7.1
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate as low-privilege workspace member
  2. Exploit
    Obtain target application's MCP server ID
  3. Execution
    Send crafted PUT to /console/api/apps/<app_id>/server
  4. Impact
    Alter parameters/status, redirect data or disable service

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Object-level authorization, IDOR prevention
Exploitation Conditions

Requires an authenticated account with workspace-member access to the target Dify instance (CVSS PR:L) and reachability of the console API at PUT /console/api/apps/<app_id>/server. The attacker must know or enumerate the numeric/opaque MCP server ID of another application; no special non-default configuration is needed because the vulnerable code path is the standard MCP server management endpoint in versions prior to 1.16.0. Realistic exposure is highest in multi-tenant or multi-team deployments where untrusted or semi-trusted members share a Dify installation; single-user or fully-trusted deployments face little practical risk. Limiting factors: valid workspace credentials are mandatory (not remotely unauthenticated), and the affected endpoint is console-side rather than a public-facing data API.

Impact

This is a genuine but moderate-priority access-control flaw (CWE-639, IDOR/BOLA) rather than a high-urgency internet-facing threat. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L, 7.1 High) is internally consistent with the description: exploitation is network-reachable and low-complexity, but critically requires PR:L - a valid authenticated workspace member - which bounds the attacker population to people who already have accounts in the Dify instance. No EPSS score, KEV listing, or public exploit was provided in the intelligence set, so there is no evidence of active or opportunistic exploitation; the only external references are the fix commit, PR #38177, the 1.16.0 release, and advisory GHSA-ccrj-frp2-c945 - all patch/disclosure artifacts, not exploit code. The impact profile (I:H, A:L, C:N) matches a config-tampering bug: an attacker can alter or disable another application's MCP server but the vector does not assert direct data disclosure. One nuance to verify: the description's phrase 'potentially redirecting data' hints at a downstream confidentiality effect that the official C:N rating does not capture, so defenders in sensitive multi-tenant deployments should treat confidentiality exposure as plausible even though it is not in the base score. Overall: a real authorization defect worth patching promptly in shared/multi-tenant Dify instances, but not a drop-everything issue given the authentication prerequisite and absence of exploitation signals.

Exploit ScenarioDerived

In a shared Dify workspace, a low-privileged but authenticated member who should only control their own apps obtains or guesses the MCP server ID belonging to a colleague's application and sends a crafted PUT /console/api/apps/<app_id>/server request. Because the vulnerable handler looked up the AppMCPServer purely by the client-supplied ID without checking app/tenant ownership, the attacker can flip the target server's status or rewrite its parameters - disabling the service or redirecting its data flow. No public exploit code was identified, but the low attack complexity (AC:L) and absence of required user interaction make exploitation straightforward for any insider with workspace access.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 05, 2026

Authenticated workspace members can tamper with another application's MCP server configuration in Dify versions prior to 1.16.0 by sending a PUT request to /console/api/apps/<app_id>/server with an arbitrary server ID, allowing them to disable or redirect the targeted app's MCP integration. The flaw is a cross-tenant/IDOR access-control gap (CWE-639) rated CVSS 7.1 (PR:L, I:H, A:L) that matters most in multi-tenant or multi-team Dify installations; no public exploit identified at time of analysis.

RemediationAI

Apply the vendor fix by upgrading Dify to 1.16.0 or later (release: https://github.com/langgenius/dify/releases/tag/1.16.0); the fix is carried in commit 62cb5b586504b730731e28e743c038b72950058e and PR 38177, and the advisory at https://github.com/langgenius/dify/security/advisories/GHSA-ccrj-frp2-c945 documents the change. If an immediate upgrade is not possible, restrict workspace membership to fully trusted users because the flaw requires only a valid workspace-member account, and audit or alert on PUT requests to /console/api/apps/<app_id>/server where the server ID in the body does not belong to the app named in the URL, since that pattern is the signature of exploitation. Review configured MCP servers for unexpected status or parameter changes and re-enable any that were disabled; note that these compensating measures are detective and access-narrowing rather than a true fix, and tightening membership reduces collaboration capabilities for legitimate team members.

Affected ProductsAI

Dify (langgenius/dify) open-source LLM app development platform, all releases prior to 1.16.0 are affected; the vulnerable endpoint is PUT /console/api/apps/<app_id>/server in api/controllers/console/app/mcp_server.py. Fixes are documented in the GitHub Security Advisory GHSA-ccrj-frp2-c945 and the 1.16.0 release at https://github.com/langgenius/dify/releases/tag/1.16.0, with the corresponding code change in commit https://github.com/langgenius/dify/commit/62cb5b586504b730731e28e743c038b72950058e and pull request https://github.com/langgenius/dify/pull/38177. No separate CPE strings were provided in the input data, but the product identifier is Dify before 1.16.0.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Dify is an open-source LLM application development platform where each app can register one or more MCP (Model Context Protocol) servers that expose tools and data sources to the app's agents and workflows. The vulnerable code lives in api/controllers/console/app/mcp_server.py, where AppMCPServerController.put() fetched an AppMCPServer record using only the client-supplied payload.id via db.session.get() and then applied status/parameter changes, without comparing the record's app_id or tenant_id to the caller's context. This is a classic CWE-639 authorization bypass through a user-controlled key: the object reference is trusted as the authorization boundary instead of being scoped to the authenticated tenant and application. The upstream fix commit 62cb5b586504b730731e28e743c038b72950058e introduces AppRefService.create_mcp_server_ref() and replaces the unscoped lookup with a select filtered on AppMCPServer.id, tenant_id, and app_id, so an MCP server can only be modified via the app that owns it. The same commit applies comparable tenant-scoping refactors in annotation.py, audio.py, and generator.py, indicating a broader hardening pass across console API controllers rather than an isolated one-line patch.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 7.1 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L
vuln.today AI 7.1 HIGH

Network console endpoint and no user interaction (AV:N/UI:N), trivially repeatable (AC:L), but an authenticated workspace member is required (PR:L); confirmed impact is config tampering (I:H) and service disablement (A:L), with confidentiality only a potential downstream effect (C:N).

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
High
Availability
Low

DescriptionCVE.org

Dify is an open-source LLM app development platform. Prior to 1.16.0, the PUT /console/api/apps/&lt;app_id&gt;/server endpoint in api/controllers/console/app/mcp_server.py used AppMCPServerController.put() to retrieve an AppMCPServer by the client-supplied server ID without verifying that the server belonged to the requested application and tenant. An authenticated workspace member could therefore change another application's MCP server status and parameters, potentially redirecting data or disabling the service. This issue is fixed in version 1.16.0.

Technical POC Analysis

CWE-639 (Authorization Bypass Through User-Controlled Key); the advisory also classifies it as CWE-862 (Missing Authorization).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Dify, an AI application development platform, contains a high-severity cross-tenant access control flaw that allows authenticated workspace members to tamper with another application's MCP server configuration, potentially disrupting or redirecting critical AI integrations. This vulnerability (CVE-2026-105761) primarily impacts multi-tenant or multi-team Dify deployments, undermining tenant isolation and trust. Although no public exploit identified at time of analysis, leadership should act swiftly to mitigate the risk of unauthorized changes and service disruptions across organizational boundaries.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict access to /console/api/apps/*/server to trusted IPs; enforce strict authentication and authorization; monitor for unauthorized PUT requests; segment tenants; disable MCP integrations if not essential; deploy WAF rules to block malicious requests.

Threat Intelligence Overview

EPSS Score
0.2%
Top 86% exploitable
Prevalence
Medium
popular open-source LLM app platform, common in AI teams but not ubiquitous enterprise infrastructure
Data Quality
6 sources
Confidence: High
NVD CVE.org EPSS Vulnrichment GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +36
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy