/

CVE-2026-79750

Severity:

HIGH RISK

(7.7)

Broken Access Control (CWE-639) in MCPHub Tool API

CVE-2026-79750

Awaiting Analysis

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-639

Impact:

Cross-tenant unauthorized access and server-side request forgery

Severity:

HIGH RISK

(7.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

MCPHub contains an authorization gap in its tool-execution API: authenticated non-admin users may invoke tools on MCP servers owned by other users, even when those servers are excluded from their list and configuration views. This may enable cross-tenant file access, SSRF, and use of connected services with another user's credentials.

Affected context

The issue occurs in MCPHub deployments where non-admin access is restricted by server ownership for listing and configuration operations, but the tool-execution path does not apply the same ownership or authorization checks. Risk is greatest when connected MCP servers expose filesystem operations, outbound HTTP access, cloud APIs, or other capabilities tied to the server owner's credentials.

Exploit preconditions

  • Attack surface: The authenticated MCPHub tool-execution API
  • Required access: A valid account with non-admin permissions
  • Trigger point: Invocation of a tool associated with an MCP server
  • Authorization condition: The target server is owned by another user and

is not available through the caller's authorized server scope

  • Why exploitation is possible: The execution endpoint fails to enforce

the ownership restrictions applied by server listing and configuration APIs

Why this happens

The underlying bug is an inconsistent authorization model across related API operations. Server visibility and configuration changes enforce ownership, while tool execution trusts a server or tool reference without independently verifying that the caller is authorized to use it. This maps to CWE-639, Authorization Bypass Through User-Controlled Key, because a user-controlled identifier can select a resource outside the caller's permitted scope.

Potential impact

  • An attacker may read files from another tenant's connected host.
  • An attacker could access secrets exposed through a victim-owned MCP server.
  • The vulnerable workflow may enable server-side request forgery against internal services.
  • An attacker may invoke cloud or external APIs using the server owner's credentials.
  • Cross-tenant confidentiality, integrity, and availability could be affected.

General mitigation guidance

Mitigation generally focuses on enforcing authorization at every capability

boundary, especially immediately before tool execution.

Common defensive patterns include:

  • Deriving the caller's permitted server set from trusted session and tenancy

context rather than accepting authorization from client-supplied identifiers.

  • Applying ownership, role, and tenant checks independently to every execution request.
  • Using deny-by-default authorization for tools with filesystem, network, or cloud access.
  • Separating high-risk capabilities and granting only the minimum required privileges.
  • Limiting connected services' credentials, network reachability, and filesystem scope.
  • Returning resource-disclosure-resistant errors and avoiding authorization decisions

based solely on list-view filtering.

How teams detect issues like this

Organizations can detect similar authorization gaps through:

  • Static analysis and policy checks that compare authorization middleware across

list, read, update, and execute endpoints.

  • Code review searches for tool or resource lookups performed without a subsequent

tenant, ownership, or role check.

  • Integration tests that attempt to use each capability across tenant boundaries,

including resources omitted from the caller's list response.

  • API gateway or service policies requiring an authorization decision before

execution of filesystem, HTTP, or cloud operations.

  • Audit monitoring for tool invocations involving resources outside the caller's

normal ownership scope.

Automated security review tools may help identify inconsistent access-control

enforcement, but authorization tests should reflect the application's tenancy model.

Sources

SourceLink
github.comgithub.com/samanhappy/mcphub/releases/tag/v1.0.30
github.comgithub.com/samanhappy/mcphub/security/advisories/GHSA-wfqf-hqwq-8wvf

Frequently asked

questions

Yes, where the MCPHub tool-execution API is network-accessible and an attacker

can authenticate with a non-admin account. Exploitation does not require the

target server to appear in the attacker's server list.

The attacker generally needs a valid authenticated user account and the ability

to submit tool-execution requests. Administrative privileges should not be

necessary.

Enforce ownership, tenant, role, and capability authorization immediately before

every tool execution, using trusted server-side identity and scope information.

Apply consistent deny-by-default authorization across all resource operations,

test cross-tenant access boundaries, minimize connected-service privileges, and

monitor high-risk tool usage.

Find out what's already
exploitable in your codebase.