/

CVE-2026-61427

Severity:

HIGH RISK

(7.3)

Auth Bypass & Input Validation (CWE-20) in PraisonAI MCP

CVE-2026-61427

Deferred

Vulnerability type

Category:

Improper Input Validation and Authorization Control

CWE:

CWE-20

Impact:

Unauthorized tool invocation and unsafe request handling

Severity:

HIGH RISK

(7.3)

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

PraisonAI MCP HTTP-stream transport before 4.6.78 exposes an unauthenticated API surface when the server is started without an API key, allowing arbitrary clients to list and invoke tools over HTTP.

Because tool-call arguments are forwarded without validation against the advertised input schema, an attacker on a reachable network can abuse exposed tools or send malformed inputs that may drive unsafe behavior in downstream handlers.

Affected context

This vulnerability appears when operators run praisonai mcp serve --transport http-stream without configuring an API key, leaving Authorization checks disabled.

The server binds to 127.0.0.1 by default, limiting exposure to the local host, but risk increases significantly when the service is bound to network-accessible interfaces (for example, --host 0.0.0.0) or exposed through tunnels, proxies, or container port mappings.

The issue mainly affects deployments where the MCP tools wrap sensitive operations, external systems, or high-privilege actions, and where tool argument validation relies on the declared inputSchema rather than explicit defensive checks.

Exploit preconditions

  • Attack surface: MCP HTTP-stream endpoint exposed by praisonai mcp serve.
  • Required access: Network reachability to the MCP server (local host by default, or remotely if bound to a public interface or forwarded by other infrastructure).
  • Trigger point: Starting the server without an API key (e.g., --api-key omitted or set to None), which disables Authorization/Bearer enforcement; issuing requests to endpoints like tools/list and tools/call.
  • Why exploitation is possible: The authorization logic is conditional on an API key being configured, so in its absence, any client can establish a session and invoke tools. Additionally, the dispatcher does not validate tool-call arguments against the declared inputSchema, allowing untrusted and potentially malformed inputs to reach tool handlers unchecked.

Why this happens

The core issue is a combination of conditional security enforcement and insufficient input validation.

The authorization mechanism is only activated when an API key is present, creating a configuration-dependent gap where the HTTP-stream transport operates fully open to any client. This pattern reflects an insecure default posture where the absence of credentials disables protection entirely rather than failing closed.

In parallel, the dispatcher forwards tool-call arguments directly to handlers without verifying that the provided data conforms to the advertised inputSchema. This maps to CWE-20: Improper Input Validation, as untrusted inputs are accepted and processed without structural or type checks, potentially causing tools to perform unintended actions or mishandle data.

Together, these design choices turn what should be a protected and schema-governed interface into a permissive channel where authorization and argument validation depend on operator diligence rather than robust, secure-by-default behavior.

Potential impact

  • Unauthenticated clients may list available MCP tools and understand the capabilities exposed by the server.
  • Attackers could invoke tools that perform sensitive operations, including file access, system commands, or integrations with external services, if such tools are configured.
  • Tools receiving malformed or unexpected arguments could behave unpredictably, potentially leading to data corruption, misconfiguration, or abuse of downstream APIs.
  • Local or remote adversaries with network access can misuse the MCP endpoint as an automation or orchestration layer, amplifying their ability to script actions against the host or connected systems.
  • In multi-tenant or shared environments, unauthorized tool invocation could blur isolation boundaries and expose internal workflows or data to unintended parties.

General mitigation guidance

Mitigation focuses on enforcing secure defaults for both authentication and input handling.

Operators can reduce risk by always requiring an authentication mechanism for the MCP HTTP-stream transport and avoiding configurations where the API surface is exposed without an access control layer. Treat MCP endpoints as privileged interfaces and limit binding to local-only addresses unless strict controls are in place.

From a design perspective, authorization checks should follow a fail-closed pattern: the absence of credentials or configuration should not disable protection, and anonymous access should be explicitly configured rather than implicitly allowed. For input handling, tool dispatchers should validate arguments against clearly defined schemas before invoking handlers, rejecting or sanitizing requests that do not conform. Encouraging tool authors to implement conservative input validation and rejecting unexpected fields, types, or values further shrinks the attack surface.

In secure deployments, tools that perform high-risk actions should be gated behind stronger controls, such as role-based policies, separate endpoints, or reduced privileges, ensuring that the MCP service cannot directly exercise broad system powers without defense-in-depth.

How teams detect issues like this

Detection is typically centered on configuration reviews and behavior monitoring rather than exploit signatures.

Security teams can scan MCP service configurations and startup scripts to identify instances where praisonai mcp serve --transport http-stream is used without an API key or is bound to wide-open interfaces (e.g., 0.0.0.0). CI/CD pipelines and infrastructure-as-code templates can incorporate policies that flag or block deployments lacking explicit authentication parameters.

At the code level, review of the authorization logic can highlight patterns where protection is conditional on configuration state instead of defaulting to deny. Static analysis or custom linters may be used to identify dispatcher paths that accept user-supplied arguments without validating them against a known schema or constraints. Runtime monitoring—such as logging tool invocations with source information and unusual argument structures—can help identify suspect activity and confirm that only expected clients are using the MCP endpoint.

Sources

SourceLink
github.comgithub.com/MervinPraison/PraisonAI/security/advisories/GHSA-hc5v-gxvj-58wh
vulncheck.comvulncheck.com/advisories/praisonai-before-authentication-bypass-via-http-stream

Frequently asked

questions

It can be, but only if the MCP server is bound to a network-accessible interface or exposed through tunnels or proxies. By default, the service binds to 127.0.0.1, which restricts access to the local machine. Internet-facing configurations increase the likelihood of remote exploitation.

The attacker needs network reachability to the MCP HTTP-stream endpoint. No credentials, Authorization headers, or specific Origin values are required when the server is started without an API key, making exploitation possible from any client that can connect.

The most robust fix is to adopt a fail-closed authentication model in which the MCP service always enforces access control, and the absence of an API key or other credentials does not result in open access. Additionally, tool invocation should be protected by strict input validation, ensuring that only requests conforming to defined schemas are processed.

Future designs should treat authentication and validation as mandatory components rather than optional configuration toggles. Enforce secure-by-default settings, require explicit configuration for anonymous access, and integrate schema-based validation into the request pipeline. Complement these technical controls with configuration audits, policy checks in deployment pipelines, and code reviews that prioritize clear, consistent authorization and input-handling patterns.

Find out what's already
exploitable in your codebase.