CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-91112

CVE-2026-91112: Privilege Escalation via CMS_ACCESS_SecurityAdmin in Silverstripe Framework

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 17, 2026·9 min read·3 visits

Executive Summary (TL;DR)

Authenticated Silverstripe users with delegated Security Admin permissions (CMS_ACCESS_SecurityAdmin) can escalate to full ADMIN privileges by modifying or reparenting groups that derive administrative rights through roles or hierarchical inheritance. Upgrading silverstripe/framework to version 6.2.13 resolves the flaw.

Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.

Vulnerability Overview

Silverstripe Framework (silverstripe/framework) provides the core authentication, authorization, and role-based access control (RBAC) architecture for Silverstripe CMS. Within this framework, user privileges are governed by Member associations with Group objects. The /admin/security administrative interface allows privileged operators to create and modify user accounts, organize security groups, and assign permission roles.

To support delegated administration, Silverstripe defines the CMS_ACCESS_SecurityAdmin permission code. This permission grants access to the Security administration interface without conferring full system control (ADMIN). Under the intended security model, an account with CMS_ACCESS_SecurityAdmin is restricted from editing groups that hold ADMIN privileges or configuring group hierarchies in a manner that grants elevated privileges to non-administrative members.

In versions prior to 6.2.13, the authorization verification in SilverStripe\Security\Group fails to account for all mechanisms through which a group can obtain administrative privileges. Specifically, the access checks only inspect direct database records linking a single group to the literal ADMIN code, overlooking privileges conferred via PermissionRole relations or inherited from parent groups.

Classified under CWE-269 (Improper Privilege Management), this flaw allows an authenticated user with CMS_ACCESS_SecurityAdmin to bypass authorization boundaries. By either adding themselves to a group that receives administrative capabilities indirectly, or reparenting a controlled group beneath a role-privileged ancestor, the user achieves full ADMIN control over the Silverstripe installation.

Root Cause Analysis

Understanding the root cause requires examining how Silverstripe resolves permissions for a Group object. The framework supports three distinct mechanisms for granting permission codes to group members: direct assignment in the Permission table (GroupID mapped to Code), role assignment via the Group_Roles many-to-many relation linking to PermissionRole and PermissionRoleCode objects, and hierarchical inheritance where a child group inherits all permissions from its ancestor chain (ParentID).

The first vulnerability resides in Group::canEdit(). When a member with CMS_ACCESS_SecurityAdmin (and without ADMIN) attempts to edit a group, canEdit() executes a query against the Permission ORM model: !Permission::get()->filter(['GroupID' => $this->ID, 'Code' => 'ADMIN'])->exists(). This query contains three distinct flaws in its verification logic.

First, the filter checks only $this->ID, ignoring any permissions the group inherits from its parent or upper ancestors via ParentID. Second, querying the Permission table directly bypasses the PermissionRole subsystem; if a group is granted ADMIN through an attached role rather than a direct checkbox assignment, no corresponding row exists in the Permission table. Third, the query only checks for the hardcoded 'ADMIN' string, failing to block edits to groups holding other escalating permissions configured in Permission.privileged_permissions, such as 'APPLY_ROLES'.

The second vulnerability resides in Group::validate(), which executes before a Group DataObject is written to the database. When a non-admin user reparents a group under a new parent, validate() checks whether any group in $this->Parent()->collateAncestorIDs() possesses codes listed in Permission.privileged_permissions. However, validate() performs this check using Permission::get()->filter(...). While this properly traverses the ancestor IDs and checks all configured privileged codes, it still queries the Permission table directly, failing to detect privileged permissions attached to ancestor groups via PermissionRole records.

Code Analysis

Commit bb4d04a498c34e21e428d029c4ce82bbdcce31b1 addresses both flaws in src/Security/Group.php by replacing direct Permission table queries with helper methods that evaluate the complete ancestor tree and resolve role-assigned permissions.

Before the patch, Group::canEdit() and Group::validate() relied on naive ORM filters:

// Vulnerable validation logic in src/Security/Group.php (Prior to 6.2.13)
if ($this->Parent()->exists() && !Permission::check('ADMIN')) {
    $privilegedCodes = Permission::config()->get('privileged_permissions');
    if (!empty($privilegedCodes)) {
        // FLAW: Only checks direct Permission records; misses PermissionRole assignments
        $inheritedCodes = Permission::get()->filter([
            'GroupID' => $this->Parent()->collateAncestorIDs(),
            'Code' => $privilegedCodes,
        ]);
        if ($inheritedCodes->exists()) {
            $result->addError(...);
        }
    }
}
 
// Vulnerable authorization check in Group::canEdit() (Prior to 6.2.13)
public function canEdit($member = null)
{
    // ...
    if (
        (bool)Permission::checkMember($member, "ADMIN")
        || (
            Permission::checkMember($member, "CMS_ACCESS_SecurityAdmin") &&
            // FLAW: Only checks $this->ID, only checks 'ADMIN', and ignores PermissionRoles
            !Permission::get()->filter(['GroupID' => $this->ID, 'Code' => 'ADMIN'])->exists()
        )
    ) {
        return true;
    }
    return false;
}

The patch introduces two private methods, grantsEscalatingPermissions() and anyGroupGrantsPermission(), and updates both validate() and canEdit() to use them:

// Patched logic in src/Security/Group.php (6.2.13)
public function validate(): ValidationResult
{
    // ...
    if ($this->Parent()->exists() && !Permission::check('ADMIN')) {
        $privilegedCodes = Permission::config()->get('privileged_permissions');
        if (!empty($privilegedCodes)) {
            // FIX: Evaluates both direct permissions and PermissionRoles across all ancestors
            if ($this->anyGroupGrantsPermission($this->Parent()->collateAncestorIDs(), $privilegedCodes)) {
                $result->addError(
                    _t(
                        'SilverStripe\\Security\\Group.HierarchyPermsError',
                        'Can\'t assign parent group "{group}" with privileged permissions (only ADMIN can do this)',
                        ['group' => $this->Parent()->Title]
                    ),
                    ValidationResult::TYPE_ERROR,
                    'HierarchyPermsError'
                );
            }
        }
    }
    // ...
}
 
public function canEdit($member = null)
{
    // ...
    if (
        (bool)Permission::checkMember($member, "ADMIN")
        || (
            Permission::checkMember($member, "CMS_ACCESS_SecurityAdmin") &&
            // FIX: Comprehensive check for any escalating permission across ancestors and roles
            !$this->grantsEscalatingPermissions()
        )
    ) {
        return true;
    }
    return false;
}
 
private function grantsEscalatingPermissions(): bool
{
    if (!$this->exists()) {
        return false;
    }
    $privilegedCodes = Permission::config()->get('privileged_permissions') ?? [];
    // EDIT_PERMISSIONS is excluded because PermissionCheckboxSetField::saveInto()
    // strips privileged codes from non-admin form submissions
    $escalatingCodes = array_diff($privilegedCodes, ['EDIT_PERMISSIONS']);
    return $this->anyGroupGrantsPermission($this->collateAncestorIDs(), $escalatingCodes);
}
 
private function anyGroupGrantsPermission(array $groupIDs, array|string $codes): bool
{
    if (empty($groupIDs) || empty($codes)) {
        return false;
    }
    // Permission::get_groups_by_permission() inspects both Permission and PermissionRole tables
    $grantingGroupIDs = Permission::get_groups_by_permission($codes)->columnUnique('ID');
    return !empty(array_intersect($groupIDs, $grantingGroupIDs));
}

The remediation is complete for the identified attack vectors. By calling Permission::get_groups_by_permission($codes), the code leverages Silverstripe's built-in resolution logic that joins both direct Permission rows and PermissionRole mappings. Combining this with $this->collateAncestorIDs() ensures that the target group and its entire parent hierarchy are validated against all escalating permission codes (ADMIN and APPLY_ROLES).

> [!NOTE] > The exclusion of EDIT_PERMISSIONS inside grantsEscalatingPermissions() is deliberate and safe. While EDIT_PERMISSIONS is listed in privileged_permissions to stop non-admins from granting permission-editing capabilities to others, a group holding EDIT_PERMISSIONS does not allow a non-admin to grant ADMIN, because PermissionCheckboxSetField::saveInto() strips all privileged_permissions codes when a form is submitted by a non-admin user.

Exploitation

Exploiting CVE-2026-91112 requires an authenticated user account with the CMS_ACCESS_SecurityAdmin permission code. In addition, the target Silverstripe environment must meet non-default structural preconditions (reflected in the CVSS AC:H metric): the database must contain either a Group that inherits ADMIN from a parent group, or a Group that obtains ADMIN (or APPLY_ROLES) via an attached PermissionRole.

Attack Path A: Editing a Child or Role-Privileged Group

  1. The attacker authenticates to the Silverstripe CMS backend and navigates to /admin/security/users or /admin/security/groups.
  2. The attacker inspects the existing groups to locate a target group (TargetGroup) that either resides underneath the primary Administrators group (ParentID points to an admin group) or has an administrative PermissionRole assigned in the Roles tab.
  3. The attacker opens the group editor for TargetGroup. Because TargetGroup has no direct row in the Permission table with Code = 'ADMIN', Group::canEdit() returns true.
  4. In the Members tab of TargetGroup, the attacker links their own Member record to the group (or submits an HTTP POST request to the GridField/EditForm endpoint linking their Member ID).
  5. Upon saving, Silverstripe recalculates permissions for the attacker's session, granting full ADMIN privileges.

Attack Path B: Reparenting Under a Role-Privileged Group

  1. If the attacker already belongs to a standard non-privileged group (ControlledGroup) or creates a new group via /admin/security/groups, they can modify its ParentID field.
  2. The attacker selects a parent group (RoleAdminGroup) that receives ADMIN or APPLY_ROLES exclusively through a PermissionRole rather than a direct checkbox assignment.
  3. The attacker submits the form to save ControlledGroup with ParentID set to RoleAdminGroup->ID.
  4. Group::validate() checks Permission::get()->filter(['GroupID' => $this->Parent()->collateAncestorIDs(), 'Code' => $privilegedCodes]). Because RoleAdminGroup gets its privileges from a role, this query returns zero rows and validation passes.
  5. ControlledGroup is saved as a child of RoleAdminGroup, and the attacker immediately inherits ADMIN or APPLY_ROLES permissions from the new parent.

Impact Assessment

CVE-2026-91112 is rated Medium severity with a CVSS v3.1 base score of 6.8 (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N). The Attack Vector is Network (AV:N) as the /admin/security interface is exposed over HTTP/HTTPS. Privileges Required is Low (PR:L) because the attacker must hold an authenticated account with CMS_ACCESS_SecurityAdmin. Attack Complexity is High (AC:H) because exploitation depends on the presence of role-based or inherited administrative group structures, which are not created by a default Silverstripe installation unless configured by an administrator.

Once an attacker escalates to ADMIN (or acquires APPLY_ROLES and subsequently assigns an ADMIN role to their group), they bypass all application-level access controls within Silverstripe CMS. The Confidentiality Impact is High (C:H), allowing the attacker to view all unpublished content, sensitive member records, password hashes (if exported via data model views), and private assets managed by the CMS.

The Integrity Impact is also High (I:H). An ADMIN user can modify any page content, alter site configurations, create persistent backdoor administrator accounts, and revoke access for legitimate administrators. Availability Impact is scored as None (A:N) in the official CVSS vector because the privilege escalation mechanism itself does not degrade service availability or exhaust system resources.

Remediation

The primary remediation is to upgrade silverstripe/framework to version 6.2.13 or later. The patch enforces comprehensive ancestor and role evaluation in both Group::canEdit() and Group::validate().

Administrators can apply the update using Composer:

composer require silverstripe/framework:^6.2.13

After updating the package, run the standard Silverstripe database build task (sake db:build or vendor/bin/sake dev/build) and flush the application cache to ensure the updated class definitions are active.

For environments where an immediate upgrade to 6.2.13 cannot be performed, administrators can implement the following workarounds to eliminate the preconditions required for exploitation:

  1. Audit and Restrict CMS_ACCESS_SecurityAdmin: Remove the CMS_ACCESS_SecurityAdmin permission from all groups and roles that do not also hold the full ADMIN permission. If only trusted super-administrators can access /admin/security, the privilege boundary cannot be crossed.
  2. Flatten Administrative Group Hierarchies: Ensure that groups possessing ADMIN permissions have no child groups underneath them. Move any sub-groups to the root level of the security tree and assign only explicit, non-administrative permissions.
  3. Replace Administrative Permission Roles with Direct Assignments: If any group receives ADMIN or APPLY_ROLES through a PermissionRole, remove the role assignment and instead check the Administrator permission directly on the group's Permissions tab. When ADMIN is assigned directly on a root-level group with no children, the legacy Group::canEdit() filter (Permission::get()->filter(['GroupID' => $this->ID, 'Code' => 'ADMIN'])) properly detects the row and blocks non-admin modifications.

Official Patches

SilverstripeOfficial Silverstripe Security Release Advisory for CVE-2026-91112
GitHubGitHub Security Advisory GHSA-rg72-5958-c65m
SilverstripeSilverstripe Framework 6.2.13 Release Tag

Fix Analysis (1)

Technical Appendix

CVSS Score
6.8/ 10
CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N

Affected Systems

Silverstripe Framework (silverstripe/framework)Silverstripe CMS

Affected Versions Detail

Product
Affected Versions
Fixed Version
silverstripe/framework
Silverstripe
< 6.2.136.2.13
AttributeDetail
Vulnerability IDCVE-2026-91112 / GHSA-rg72-5958-c65m
CWE ClassificationCWE-269: Improper Privilege Management
CVSS v3.1 Score6.8 Medium (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N)
Affected ComponentSilverStripe\Security\Group (canEdit and validate methods)
Attack VectorAuthenticated Network (Requires CMS_ACCESS_SecurityAdmin)
Security ImpactPrivilege Escalation to Full Administrator (ADMIN)
Fixed Versionsilverstripe/framework 6.2.13
Exploit / KEV StatusNo known public exploits; Not listed in CISA KEV

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-269
Improper Privilege Management

The product does not properly assign, modify, track, or verify privileges for an actor, creating an unintended sphere of control that allows the actor to perform actions outside the intended authorization boundary.

Vulnerability Timeline

Fix committed to silverstripe/silverstripe-framework repository (bb4d04a498c34e21e428d029c4ce82bbdcce31b1)
2026-10-28
Silverstripe Framework 6.2.13 released
2026-11-16
CVE-2026-91112 published by GitHub CNA and NVD
2026-11-16
GitHub Security Advisory GHSA-rg72-5958-c65m published
2026-11-16

References & Sources

  • [1]Silverstripe Official Security Advisory: CVE-2026-91112
  • [2]GitHub Security Advisory GHSA-rg72-5958-c65m
  • [3]Fix Commit bb4d04a498c34e21e428d029c4ce82bbdcce31b1
  • [4]Silverstripe Framework Pull Request #12036
  • [5]Silverstripe Framework 6.2.13 Release Notes
  • [6]National Vulnerability Database (NVD) - CVE-2026-91112
  • [7]CVE.org Record - CVE-2026-91112
  • [8]FriendsOfPHP Security Advisory - CVE-2026-91112

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•14 minutes ago•CVE-2026-88989
4.3

CVE-2026-88989: Authorization Bypass in Silverstripe Framework GridFieldDetailForm

CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.

Amit Schendel
Amit Schendel
0 views•10 min read
•about 2 hours ago•CVE-2026-91113
4.3

CVE-2026-91113: Missing Authorization and Arbitrary Record Type Conversion in Silverstripe Framework GridFieldDetailForm

A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.

Alon Barad
Alon Barad
4 views•9 min read
•about 3 hours ago•CVE-2026-91115
8.8

CVE-2026-91115: Remote Code Execution in Silverstripe Framework via i18nTextCollectorTask

CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 4 hours ago•CVE-2026-129237
5.4

CVE-2026-129237: Partial Path Traversal (Zip Slip) in qbee-agent Tar Extractor

CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 6 hours ago•CVE-2026-128071
6.5

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Amit Schendel
Amit Schendel
5 views•11 min read