/

CVE-2026-56075

Severity:

HIGH RISK

(8.8)

Broken Approval Control (CWE-863) in PraisonAI Agents

CVE-2026-56075

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-863

Impact:

Arbitrary Command Execution via LLM Agent

Severity:

HIGH RISK

(8.8)

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 before 4.5.128 contains a broken approval control vulnerability where UI modules forcibly set the LLM agent approval_mode to auto, ignoring administrator configuration from the PRAISON_APPROVAL_MODE environment variable.

Under these conditions, an authenticated user can direct the agent to execute arbitrary shell commands via subprocess.run with shell=True, bypassing manual approval workflows and weak command blocklists.

Affected context

This issue appears in PraisonAI deployments that use the affected UI modules to orchestrate LLM agents capable of running system commands.

It is especially relevant when:

  • Administrators rely on PRAISON_APPROVAL_MODE to enforce manual approval of shell actions
  • The UI layer is reachable to authenticated users who can craft prompts or tasks
  • Agent execution uses subprocess.run with shell=True on the host or container

In these setups, the UI's hardcoded approval_mode can silently override safer server-side defaults.

Exploit preconditions

  • Attack surface: PraisonAI web UI or API endpoints that trigger LLM agent actions
  • Required access: Valid authenticated user account or session that can interact with the agent
  • Trigger point: Submitting a prompt, task, or workflow that instructs the agent to execute shell commands
  • Why exploitation is possible: The UI forces approval_mode=auto, bypassing administrator-set manual approval via PRAISON_APPROVAL_MODE; combined with subprocess.run(shell=True) and weak blocklists, this enables arbitrary command execution as soon as the agent acts on user instructions.

Why this happens

The core flaw is a mismatch between intended authorization policy and actual enforcement in the UI layer, aligning with CWE-863: Incorrect Authorization.

Security-critical behavior (whether shell commands require manual approval) is controlled via an environment variable, but the UI modules unconditionally override this by hardcoding approval_mode to auto.

As a result, the application trusts a less privileged, client-facing component to dictate approval policy, while also invoking subprocess.run with shell=True and relying on incomplete blocklists for sanitization.

This combination creates a broken approval control path where user-driven LLM instructions are executed directly as shell commands without the expected human gate.

Potential impact

  • Attackers may execute arbitrary shell commands with the privileges of the PraisonAI process.
  • Attackers may access, modify, or exfiltrate sensitive data reachable from the host or container.
  • Attackers may tamper with application configuration, prompts, or model outputs.
  • Attackers may install backdoors or persistence mechanisms on the underlying system.
  • Attackers could pivot laterally to other systems or services reachable from the compromised environment.

General mitigation guidance

Effective mitigation typically combines stricter policy enforcement with safer execution primitives:

  • Enforce approval and authorization logic on the server side, independent of UI defaults, and treat UI-supplied modes as untrusted hints rather than authorities.
  • Use explicit allow-lists of permissible operations or commands for agent execution instead of blocklists of disallowed substrings.
  • Avoid shell=True when running subprocesses; prefer argument-based invocation and constrained wrappers around a limited command set.
  • Isolate agent execution into hardened sandboxes or containers with minimal privileges and restricted filesystem and network access.
  • Centralize configuration so that security-sensitive settings (like approval modes) cannot be overridden by individual modules without validation.

How teams detect issues like this

Organizations can look for this pattern by:

  • Reviewing code for authorization checks that are enforced only in UI or client-facing layers, especially around approval_mode or similar flags.
  • Using static analysis or linters to flag subprocess.run with shell=True and other risky command-execution APIs in agent implementations.
  • Implementing configuration audits that detect discrepancies between environment-level security settings and effective runtime behavior.
  • Monitoring logs for anomalous agent-initiated shell commands, unusual command patterns, or sequences indicative of manual probing by users.
  • Applying policy-as-code in CI pipelines to prevent merging changes that weaken centralized approval or privilege boundaries.

Sources

SourceLink
github.comgithub.com/MervinPraison/PraisonAI/security/advisories/GHSA-qwgj-rrpj-75xm
vulncheck.comvulncheck.com/advisories/praisonai-arbitrary-shell-command-execution-via-hardcoded-approval-mode-override

Frequently asked

questions

Yes, if the PraisonAI interface is exposed over the network and an attacker can obtain valid credentials, they can exploit the agent workflow remotely through standard UI or API interactions.

No special system-level privileges are required; an authenticated user account that can interact with the LLM agent is typically sufficient, because the approval gate intended to restrict command execution is bypassed.

Move all approval and authorization decisions for dangerous actions to a trusted server-side layer, ensure they honor centralized configuration, and decouple them from UI preferences; combine this with safer command execution primitives that avoid shell=True and enforce strict allow-lists.

Design agent and tooling architectures with clear trust boundaries: treat UI inputs as untrusted, enforce policies near the resource being protected, avoid relying on blocklists for command safety, and include automated checks in development pipelines to catch authorization logic implemented only at the presentation layer.

Find out what's already
exploitable in your codebase.