Nov 17, 2026·9 min read·3 visits
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.
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.
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.
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.
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.
/admin/security/users or /admin/security/groups.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.TargetGroup. Because TargetGroup has no direct row in the Permission table with Code = 'ADMIN', Group::canEdit() returns true.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).ADMIN privileges.ControlledGroup) or creates a new group via /admin/security/groups, they can modify its ParentID field.RoleAdminGroup) that receives ADMIN or APPLY_ROLES exclusively through a PermissionRole rather than a direct checkbox assignment.ControlledGroup with ParentID set to RoleAdminGroup->ID.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.ControlledGroup is saved as a child of RoleAdminGroup, and the attacker immediately inherits ADMIN or APPLY_ROLES permissions from the new parent.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.
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.13After 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:
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.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.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.CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
silverstripe/framework Silverstripe | < 6.2.13 | 6.2.13 |
| Attribute | Detail |
|---|---|
| Vulnerability ID | CVE-2026-91112 / GHSA-rg72-5958-c65m |
| CWE Classification | CWE-269: Improper Privilege Management |
| CVSS v3.1 Score | 6.8 Medium (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N) |
| Affected Component | SilverStripe\Security\Group (canEdit and validate methods) |
| Attack Vector | Authenticated Network (Requires CMS_ACCESS_SecurityAdmin) |
| Security Impact | Privilege Escalation to Full Administrator (ADMIN) |
| Fixed Version | silverstripe/framework 6.2.13 |
| Exploit / KEV Status | No known public exploits; Not listed in CISA KEV |
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.
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.
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.
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.
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.
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.
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.