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.

