/

CVE-2026-61442

Severity:

HIGH RISK

(7.1)

Missing Authorization (CWE-862) in PraisonAI PATCH APIs

CVE-2026-61442

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Unauthorized Data Modification

Severity:

HIGH RISK

(7.1)

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 Platform exposes PATCH routes for projects, issues, and agents that only check for workspace membership and do not enforce owner or admin authorization.

This allows a regular workspace member to modify owner-created records, including reassigning project ownership and subsequently deleting projects by bypassing stricter delete route checks.

Affected context

The vulnerability occurs in PraisonAI Platform deployments where:

  • PATCH endpoints for projects, issues, and agents are protected only by a workspace-member role check
  • Ownership or administrative privileges are expected for sensitive operations like reassignment or deletions
  • Authorization logic is inconsistent between PATCH and DELETE routes

In this context, any authenticated workspace member can reach these PATCH routes and alter owner-managed resources.

Exploit preconditions

  • Attack surface: Application API (PATCH routes for projects, issues, and agents)
  • Required access: Valid workspace-member account within the target workspace
  • Trigger point: Sending crafted PATCH requests that change critical fields (e.g., lead_id) on owner-created records
  • Why exploitation is possible: The PATCH handlers verify only membership, not ownership or admin roles, allowing privilege-relevant fields to be modified and enabling later bypass of stricter authorization on other routes (like DELETE).

Why this happens

This issue stems from incomplete authorization checks on state-changing operations, mapping directly to CWE-862: Missing Authorization.

The design assumes that a workspace-member role is sufficient to perform PATCH operations, but does not revalidate whether the caller is the resource owner or an admin when changing sensitive attributes.

As a result, authorization logic is inconsistent across endpoints: PATCH routes permit changes that effectively elevate control over resources, while DELETE routes enforce stricter owner/admin checks that can be indirectly bypassed.

Potential impact

  • Workspace members may reassign project ownership or control fields to themselves.
  • Users could delete owner-created projects after manipulating ownership attributes via PATCH.
  • Unauthorized modification of issues and agents, including reassignment or configuration changes.
  • Potential disruption of project workflows and loss of critical workspace data.
  • Erosion of access control guarantees and auditability around resource ownership.

General mitigation guidance

Mitigation focuses on enforcing consistent, role-appropriate authorization on all state-changing endpoints.

Useful patterns include:

  • Applying centralized authorization middleware or policy checks that validate ownership or admin roles for sensitive fields and operations, not just route verbs.
  • Treating resource ownership, lead identifiers, and similar attributes as privileged fields that cannot be changed without elevated permissions.
  • Designing APIs so that destructive or privilege-elevating changes require explicit calls to routes with strong authorization gating.
  • Modeling workspace roles with clear responsibilities and ensuring that least-privilege principles are enforced across all CRUD operations.
  • Regularly reviewing access control policies to align business rules (who should manage projects, issues, agents) with implemented authorization logic.

How teams detect issues like this

Detection typically involves reviewing authorization flows and verifying that access control is applied consistently across related endpoints.

Effective strategies include:

  • Static and manual code review focused on handlers for PATCH, PUT, and DELETE operations to confirm ownership or role checks on sensitive fields.
  • Policy-based tests that attempt actions as different roles (e.g., workspace member vs owner/admin) and validate that unauthorized updates are rejected.
  • Access control matrices mapping roles to resource actions, used to compare intended permissions with implemented checks.
  • Automated security testing tools or API linting rules that flag endpoints performing destructive or privilege-relevant changes without adequate authorization.
  • Logging and monitoring for anomalies, such as frequent ownership changes or deletions initiated by non-owner accounts.

Sources

SourceLink
github.comgithub.com/MervinPraison/PraisonAI/commit/846568c7a5d8ce9e71e56e4c213f027c04909753
github.comgithub.com/MervinPraison/PraisonAI/security/advisories/GHSA-c78w-2q4r-68r7
vulncheck.comvulncheck.com/advisories/praisonai-platform-before-authorization-bypass-via-patch

Frequently asked

questions

Exploitation requires a valid workspace-member account in the affected workspace. Anonymous users cannot directly exploit it, but any member with basic access can modify owner-created records.

No. The missing authorization checks mean that standard workspace-member privileges are sufficient to perform actions that should be restricted to owners or administrators, such as reassignment and deletion of projects.

The safest pattern is to centralize and consistently enforce authorization policies so that all operations on sensitive resources—especially changes to ownership or destructive actions—require explicit owner or admin privileges. PATCH handlers should validate both the operation and the fields being modified against role-based rules.

Preventive measures include designing a clear access control model, implementing uniform authorization middleware for all resource-modifying endpoints, maintaining an access control matrix, and incorporating security-focused tests or code review checklists to validate that new routes honor ownership and least-privilege principles.

Find out what's already
exploitable in your codebase.