Severity:

HIGH RISK

(7.1)

Authorization Bypass in Mautic 7 API v2

CVE-2026-9808

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Horizontal Privilege Escalation and Data Exposure

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

Mautic 7's API v2 endpoints, built on API Platform, contain an authorization bypass where owner-scoped role restrictions (such as viewown or editown) are not consistently enforced.

Under specific conditions, a low-privilege authenticated API user can circumvent ownership checks and access or modify resources that belong to other users, violating data isolation expectations.

Affected context

The vulnerability affects Mautic 7 deployments that:

  • Expose the API v2 endpoints based on API Platform
  • Use role-based permissions configured with owner-scope restrictions (e.g., viewown, editown)
  • Rely on these owner-based constraints to segregate data between different users or tenants

The issue manifests where ownership logic is expected to filter which entities a user can view or modify, but the API fails to consistently enforce that logic for some requests or resource operations.

Exploit preconditions

  • Attack surface: Mautic 7 API v2 HTTP endpoints (API Platform).
  • Required access: Authenticated low-privilege account with owner-scoped permissions (e.g., can view or edit only their own resources).
  • Trigger point: Sending crafted API requests to affected endpoints where ownership checks are misapplied or skipped.
  • Why exploitation is possible: The authorization layer validates that a user has a general capability (view/edit) but does not reliably couple it with resource ownership, allowing access to entities not owned by the caller.

Why this happens

This vulnerability is rooted in incomplete or inconsistent enforcement of authorization rules tied to object ownership, aligning with CWE-863: Incorrect Authorization.

Instead of validating both the user's permission and the specific resource's ownership on every relevant API call, some endpoints or operations apply only coarse-grained permission checks (e.g., "can view entity type") without confirming that the entity is owned by the current user.

In an API Platform-based implementation, this often appears as missing ownership filters, incorrect security expressions, or bypassed access control checks on certain operations (such as collection/item operations, custom actions, or batch requests).

Potential impact

  • Unauthorized viewing of other users' contacts, leads, or campaign-related data
  • Unauthorized modification of resources owned by other users, including updates or deletions
  • Cross-account data leakage in multi-user or multi-tenant environments
  • Potential manipulation of marketing workflows, segments, or campaigns owned by other accounts
  • Erosion of auditability and trust boundaries between users or teams sharing the same Mautic instance

General mitigation guidance

Effective mitigation centers on enforcing strict, resource-level authorization checks that always combine permission with ownership verification.

Defensive patterns typically include:

  • Applying consistent, declarative security rules on all API operations, ensuring that any "view" or "edit" capability is conditioned on resource ownership where applicable.
  • Implementing centralized access-control logic (e.g., voter, policy, or guard) that encapsulates ownership checks and is reused across endpoints.
  • Designing data-access layers so that queries are automatically scoped by the authenticated user's ownership constraints, rather than relying on ad hoc filters.
  • Favoring "deny by default" authorization, where endpoints explicitly assert allowed access paths instead of assuming correctness from inherited or default behaviors.
  • Minimizing reliance on client-supplied identifiers for sensitive access decisions; ensure server-side lookups always validate that the target resource belongs to the requesting principal.

These patterns help keep authorization behavior consistent as the API surface evolves.

How teams detect issues like this

Detection and assurance for this class of issue generally involve:

  • Static analysis and code review: Looking for API routes or operations that read or modify user-owned entities without explicitly checking ownership or applying appropriate filters.
  • Policy review: Verifying that security expressions or access-control rules in API Platform (or equivalent) always combine permission checks with ownership constraints for owner-scoped roles.
  • Access-control testing: Building automated tests that attempt to access or mutate resources owned by other users using low-privilege accounts, to validate that operations are consistently denied.
  • Logging and anomaly monitoring: Monitoring access logs for patterns where a single low-privilege account frequently touches resources associated with many different owners or identifiers.
  • Automated tooling: Using authorization-focused test frameworks or security scanners that can exercise multi-user scenarios and report unexpected cross-user access paths.

Sources

SourceLink
github.comgithub.com/mautic/mautic/security/advisories/GHSA-2jrw-c95w-h43g

Frequently asked

questions

Exploitation is limited to authenticated users who already have access to the Mautic API, but any such user with owner-scoped permissions may be able to reach data belonging to others if they can identify or guess resource identifiers.

No. The issue specifically affects low-privilege roles with "own" permissions; these users should only see their own resources but can, under this flaw, reach other users' resources through the API.

The most robust fix is to centralize and enforce ownership-aware authorization logic for every relevant API operation, ensuring that any view or edit action is permitted only when the authenticated user is confirmed as the resource owner (or otherwise explicitly authorized).

Adopt a consistent access-control model that uses deny-by-default rules, central policy enforcement, automated tests for multi-user scenarios, and regular security reviews of new endpoints to ensure ownership checks are always applied where intended.

Find out what's already
exploitable in your codebase.