/

CVE-2026-41325

Severity:

HIGH RISK

(8.8)

Authorization Bypass in Kirby CMS Content Creation

CVE-2026-41325

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation and Unauthorized Content/User Creation

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

Kirby CMS contained an authorization weakness where attackers could inject dynamic blueprint configuration into model data during page, file, or user creation.

By overriding the options for a target model and enabling 'create' => true, an attacker could bypass the permissions and options defined by site developers, gaining unauthorized capability to create content or users under certain conditions.

Affected context

This vulnerability appears in Kirby CMS installations that:

  • Rely on user blueprints (site/blueprints/users/...) and model blueprints (site/blueprints/pages/... etc.) to enforce fine-grained permissions via options
  • Allow users to submit or influence content creation data for pages, files, or users
  • Process incoming model data in a way that includes user-controlled or client-provided blueprint properties

In such contexts, dynamic blueprint configuration is interpreted during creation workflows, affecting the effective permissions applied at runtime.

Exploit preconditions

  • Attack surface: Content creation endpoints or flows (e.g., APIs, panel UI, or other integrations) that accept model data for pages, files, or users.
  • Required access: At least a low-privileged authenticated user account or any role with some access to creation flows, depending on deployment and exposure of creation endpoints.
  • Trigger point: Submission of creation data that includes an injected blueprint property with crafted options, such as 'create' => true, during the creation of pages, files, or users.
  • Why exploitation is possible: The normalization logic for creation requests trusted and merged dynamic blueprint configuration from the request data, allowing it to override the statically configured permissions and options defined by the site developer.

Why this happens

The underlying issue stems from improper authorization enforcement when combining declarative blueprint permissions with dynamic configuration from user-influenced data.

Kirby's normalization logic treated the blueprint property in incoming creation requests as authoritative, merging its options into the model's effective configuration. This allowed client-supplied or user-controlled configuration to override security-critical settings like pages.create, files.create, and users.create. Conceptually, this maps to CWE-863: Incorrect Authorization, where the system bases authorization decisions on untrusted or overrideable metadata rather than on immutable, server-controlled policy. The bug class involves mixing configuration and data channels, allowing user-controlled configuration to influence access checks.

Potential impact

  • Unauthorized creation of pages that may contain unapproved or malicious content
  • Unauthorized creation of files, which could be used to upload harmful or policy-violating assets
  • Unauthorized creation of user accounts, potentially with elevated roles if other controls are weak
  • Bypassing site developer intent for permission separation between roles and content types
  • Expansion of a low-privileged user's capabilities, enabling broader privilege escalation within the CMS

General mitigation guidance

Mitigation generally focuses on hardening the boundary between user data and security-critical configuration:

  • Treat blueprint configuration and options as strictly server-controlled and immutable from client input.
  • Introduce normalization layers that explicitly filter or ignore blueprint or configuration-like properties from incoming creation requests.
  • Centralize authorization checks around role and model definitions stored on the server, ensuring client data cannot downgrade or override access decisions.
  • Implement defense-in-depth by validating effective permissions at the point of action (e.g., content creation), even if earlier configuration processing appears safe.
  • Reduce reliance on dynamic runtime configuration for core authorization logic, preferring static or read-only policy definitions loaded from trusted sources only.

How teams detect issues like this

Detection efforts can focus on both code-level and runtime indicators:

  • Static analysis and code review:
  • Search for flows where request or user data is merged into configuration objects or blueprint definitions.
  • Flag uses of dynamic configuration fields (like blueprint or options) derived from user input and subsequently used in authorization decisions.
  • Review normalization or deserialization routines that manipulate security-related metadata before permission checks.
  • Policy and architectural review:
  • Audit authorization logic to ensure policies come exclusively from trusted, server-side sources.
  • Enforce coding guidelines prohibiting user-controlled configuration in access-control paths.
  • Runtime monitoring:
  • Log creation operations (pages, files, users) with associated roles and origins and alert on anomalous patterns, such as unexpected resource creation by low-privilege roles.

Automated security scanning tools and CI-integrated linters can help identify patterns where client data affects authorization or configuration, complementing manual review.

Sources

SourceLink
github.comgithub.com/getkirby/kirby/releases/tag/4.9.0
github.comgithub.com/getkirby/kirby/releases/tag/5.4.0
github.comgithub.com/getkirby/kirby/security/advisories/GHSA-6gqr-mx34-wh8r

Frequently asked

questions

Exploitability depends on how content creation flows are exposed. In many deployments, an attacker would need at least a valid user account or an integration point that allows submitting creation data; however, within that scope, they could bypass configured restrictions on creating pages, files, or users.

Not necessarily. A low-privileged user who can access creation endpoints and influence the submitted data may exploit this weakness by injecting a crafted blueprint configuration, thereby obtaining capabilities that site developers explicitly intended to withhold.

The core fix pattern is to treat blueprint and permission configuration as strictly server-side: filter out or ignore any blueprint or configuration-like fields supplied by clients and ensure that effective permissions are derived only from trusted blueprints and roles, not from request data.

Preventing similar issues requires a clear separation between configuration and data. Design access control so that policies are immutable from the client side, enforce robust input filtering for configuration-shaped fields, and introduce regular security reviews focused on how user input can influence authorization paths. Additionally, codify these rules into secure coding guidelines and automated checks within your development pipeline.

Find out what's already
exploitable in your codebase.