Summary
Network-AI's MCP SSE server runs without effective authentication when the default empty secret is used, allowing calls to proceed as if fully authorized.
In this configuration, any non-browser client that can reach the server may remotely invoke all exposed MCP tools without credentials, making deployments with broader network exposure especially risky.
Affected context
This vulnerability affects Network-AI deployments using the MCP SSE server where:
- The server is started with the default configuration or without an explicit non-empty secret
- The SSE endpoint is reachable from non-browser clients (e.g., curl, internal services, SSRF vectors)
- The process may be bound to non-loopback interfaces (e.g., 0.0.0.0) despite only emitting a warning
Under these conditions, the MCP server effectively treats all callers as authorized, exposing sensitive orchestration tools and configuration operations.
Exploit preconditions
- Attack surface: MCP SSE server endpoint (typically HTTP-based) reachable over the network or via server-side request forgery.
- Required access: Network-level access to the bound host/port; no valid credentials or tokens are required when the secret is empty.
- Trigger point: Any request that invokes MCP tools (e.g., config_set, agent_spawn, blackboard_write, token_* operations).
- Why exploitation is possible: The authorization logic explicitly treats an empty secret as valid, causing
_isAuthorized()to return true and leaving all MCP tool invocations effectively unauthenticated by default.
Why this happens
The core issue is a missing authentication control in the authorization path, mapping to CWE-306: Missing Authentication for Critical Function.
The SSE MCP server defaults to an empty secret and the _isAuthorized() routine treats this condition as implicitly authorized.
As a result, no actual secret verification occurs for incoming requests, and the system relies only on deployment-time warnings instead of enforcing a hardened, fail-closed authentication requirement for critical orchestration functions.
Potential impact
- Remote invocation of all exposed MCP tools without credentials
- Unauthorized configuration changes via
config_setand related tools - Unauthorized spawning and control of agents through orchestration APIs
- Manipulation of shared state via
blackboard_writeand similar primitives - Abuse of token_* tools for unintended resource or API consumption
- Use of the MCP server as a pivot point in a broader compromise if bound to non-loopback interfaces
General mitigation guidance
Effective mitigation focuses on enforcing strong, non-default authentication and minimizing exposure of orchestration endpoints:
- Require an explicit, non-empty secret or equivalent credential for any MCP SSE server deployment, and treat absence or emptiness as a hard failure.
- Implement a fail-closed authorization check that rejects all requests unless a valid secret is present and verified.
- Restrict network exposure of the MCP server to loopback or tightly controlled internal networks, preferably behind authenticated gateways or service meshes.
- Apply least-privilege design to MCP tools, limiting which operations are exposed and separating highly sensitive functions from general-purpose endpoints.
- Use secure configuration management to avoid relying on in-code defaults for secrets, preferring environment variables or secrets managers with strict policies.
How teams detect issues like this
Detection efforts can focus both on code and runtime behavior:
- Static analysis and code review: Flag authorization helpers that treat empty or missing secrets as valid, and identify critical endpoints (e.g., tool invocation routes) that lack enforced authentication.
- Configuration audits: Review deployment manifests, environment files, and runtime flags to detect empty, placeholder, or default secrets and non-loopback bindings.
- Runtime monitoring: Instrument logs to capture unauthorized or unexpected tool invocations, especially from non-local IPs or untrusted network segments.
- Automated security checks: Integrate policy-as-code tools or CI checks to block deployments where the MCP server secret is empty or where the service is exposed on 0.0.0.0 without protective controls.

