Nov 17, 2026·10 min read·1 visit
An authorization bypass in Silverstripe Framework (< 6.2.13) allows authenticated CMS users without model creation permissions to create new database records by sending direct POST requests to the GridFieldDetailForm save endpoint. Upgrade to version 6.2.13 to remediate the flaw.
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.
Silverstripe Framework (silverstripe/silverstripe-framework) is the core PHP web application framework underlying the Silverstripe Content Management System (CMS). Within the administrative backend, the GridField component serves as the primary user interface control for viewing, managing, and editing tabular collections of DataObject models. Detailed record manipulation—such as editing individual model attributes or creating new entries—is delegated to the GridFieldDetailForm component and its associated request handler, GridFieldDetailForm_ItemRequest.
In versions prior to 6.2.13, GridFieldDetailForm_ItemRequest contains a missing authorization vulnerability classified under CWE-862 (Missing Authorization). When a CMS user interacts with a GridField, the framework relies on model-level permission methods (canView(), canEdit(), canDelete(), and canCreate()) to enforce access control policies. While the user interface layer hides creation controls and renders form fields as read-only when canCreate() evaluates to false, the backend persistence routine failed to enforce this restriction during form submission processing.
Specifically, when an HTTP POST request triggers the doSave action for a new record, execution flows into GridFieldDetailForm_ItemRequest::saveFormIntoRecord(). This method checked whether the user could edit the form context but omitted an explicit verification of $this->record->canCreate() for unpersisted records (where $this->record->ID is zero or null). This discrepancy between presentation-layer restrictions and controller-layer enforcement exposes an attack surface accessible to any authenticated user with CMS access.
An authenticated attacker who possesses permissions to view a GridField and edit existing records can exploit this oversight by issuing a direct HTTP POST request to the item/new/ItemEditForm endpoint. The server processes the request, populates a new DataObject instance with the attacker-supplied parameters, and commits the record to the database, violating the application's data integrity constraints.
To understand the root cause of CVE-2026-88989, it is necessary to examine how Silverstripe Framework handles routing and request dispatching within GridField. When a user interacts with a specific item in a GridField, the request is routed to GridFieldDetailForm_ItemRequest via a URL pattern ending in /item/<ID>. When creating a new record, the URL segment <ID> is replaced with the literal string new (.../item/new). During initialization, the request handler resolves the new identifier by instantiating an in-memory, unpersisted DataObject of the target model class where $this->record->ID is 0.
In the standard Silverstripe permission architecture, restricting record creation while allowing record editing is a common access control pattern. For example, a site administrator may configure a DataObject so that content authors can modify existing configuration items (canEdit() returns true), while only administrators can provision new items (canCreate() returns false). At the UI layer, GridFieldAddNewButton checks canCreate() before rendering the creation button. Furthermore, if a user manually navigates to the /item/new URL without creation privileges, ItemEditForm() transforms the form fields into a read-only state.
However, the form action handler in GridFieldDetailForm_ItemRequest did not mirror these restrictions during POST processing. When a form submission includes the action_doSave parameter, the framework invokes doSave($data, $form), which subsequently calls the protected helper method saveFormIntoRecord($data, $form). Prior to version 6.2.13, saveFormIntoRecord() immediately retrieved the underlying DataList from the GridField, validated the object class name, copied the submitted form payload into the $this->record instance, and executed $this->record->write().
Because the form rendering process and the form action execution process occur across independent HTTP requests or within separate execution stages, relying on read-only form transformation is insufficient if the action handler does not validate permissions prior to state mutation. By submitting raw POST parameters alongside a valid CSRF token (SecurityID) directly to the form endpoint, an attacker bypasses the UI controls entirely and triggers database persistence on the unpersisted $this->record object.
The vulnerability was resolved in commit 693c948bae13dd2a854489baa575123ca3e60155 (Pull Request #12043). The patch modifies src/Forms/GridField/GridFieldDetailForm_ItemRequest.php to introduce an explicit authorization gate at the entry point of saveFormIntoRecord(), and adds a corresponding localized error string in lang/en.yml.
File: lang/en.yml
@@ -174,6 +174,7 @@ en:
Save: Save
Saved: 'Saved {name} {link}'
SilverStripe\Forms\GridField\GridFieldDetailForm_ItemRequest:
+ CreatePermissionsFailure: 'It seems you don''t have the necessary permissions to create "{ObjectTitle}"'
EditPermissionsFailure: 'It seems you don''t have the necessary permissions to edit "{ObjectTitle}"'
NEW: 'Add new record'
NEXT: 'Go to next record'
File: src/Forms/GridField/GridFieldDetailForm_ItemRequest.php
@@ -821,6 +821,17 @@ public function httpError($errorCode, $errorMessage = null)
*/
protected function saveFormIntoRecord($data, $form)
{
+ // Check if the record is unpersisted (new) and verify creation permissions
+ if (!$this->record->ID
+ && (!$this->record->hasMethod('canCreate') || !$this->record->canCreate(null, $this->getCreateContext()))
+ ) {
+ // Abort execution with HTTP 403 Forbidden if canCreate() fails
+ $this->httpError(403, _t(
+ __CLASS__ . '.CreatePermissionsFailure',
+ 'It seems you don\'t have the necessary permissions to create "{ObjectTitle}"',
+ ['ObjectTitle' => $this->getModelName()]
+ ));
+ return null;
+ }
+
$list = $this->gridField->getList();
// Check object matches the correct classnameThe added conditional block evaluates three specific conditions before allowing execution to proceed:
!$this->record->ID): In Silverstripe's ORM, a DataObject that has not yet been written to the database has an ID property of 0 (or null). If $this->record->ID is truthy, the operation is an update to an existing record rather than a creation event, and this specific check is bypassed in favor of edit permission checks.!$this->record->hasMethod('canCreate')): In adherence to fail-safe defaults, if the target object does not implement a canCreate method at all, the condition evaluates to true (unauthorized), preventing persistence.!$this->record->canCreate(null, $this->getCreateContext())): The framework calls canCreate() passing null for the member parameter (which defaults to evaluating the currently authenticated Security::getCurrentUser()) and passes $this->getCreateContext() to supply relational context if the GridField is managing a has_many or many_many relationship.> [!NOTE]
> In Silverstripe Framework, invoking $this->httpError(403, ...) throws an HTTPResponse_Exception, which terminates normal controller execution and returns an HTTP 403 Forbidden response to the client. The return null; statement serves as a fallback in case custom error handling overrides the exception behavior.
With respect to fix completeness, placing the check inside saveFormIntoRecord() ensures that both standard save operations (doSave) and any custom controller actions that delegate persistence to saveFormIntoRecord() are protected. Because $this->getCreateContext() is passed to canCreate(), custom permission logic that depends on parent relationships in nested GridField instances is also accurately evaluated.
Exploiting CVE-2026-88989 requires low-level privileges (PR:L), specifically an active authenticated session within the Silverstripe CMS admin interface (such as a user possessing the CMS_ACCESS_LeftAndMain permission or access to a specific ModelAdmin controller). No specialized exploit tooling or complex timing conditions are necessary; standard HTTP client utilities or browser developer tools are sufficient.
To execute the attack, the adversary first authenticates to the CMS and identifies a GridField managing a restricted DataObject model where creation is disabled for their role. Even when the GridFieldAddNewButton is hidden from the interface, the routing structure of GridFieldDetailForm remains predictable. The attacker can navigate to or construct the URL for the new item endpoint by appending /item/new to the GridField field path, or by inspecting the URL structure when editing an existing item (e.g., replacing /item/42 with /item/new).
Once the target endpoint is identified, the attacker retrieves a valid Silverstripe CSRF token (SecurityID) from any authenticated CMS form or via a GET request to the /item/new endpoint. The attacker then transmits a crafted HTTP POST request directly to the ItemEditForm action handler:
POST /admin/my-model-admin/MyModel/EditForm/field/MyModel/item/new/ItemEditForm HTTP/1.1
Host: target.example.com
Cookie: PHPSESSID=a1b2c3d4e5f6g7h8i9j0
Content-Type: application/x-www-form-urlencoded
Content-Length: 89
Title=Unauthorized+Record&Description=Injected+Data&action_doSave=1&SecurityID=9f8e7d6c5b4a3210The vendor's functional test suite (tests/php/Forms/GridField/GridFieldDetailFormCreatePermissionTest.php), committed alongside the patch in 693c948bae13dd2a854489baa575123ca3e60155, demonstrates the exact reproduction mechanics programmatically:
#[DataProvider('provideDoSaveNewRecord')]
public function testDoSaveNewRecord(string $permission, int $expectedStatusCode, int $expectedNumCreated): void
{
// Authenticate as a user with CMS access, but lacking CreateRestrictedObject::CREATE_PERMISSION
$this->logInWithPermission($permission);
// Retrieve the form action URL for the 'new' item endpoint
$formUrl = $this->getItemEditFormUrl('new');
$title = 'Created via a crafted doSave submission';
$numRecordsBefore = CreateRestrictedObject::get()->count();
// Submit the crafted POST request with action_doSave
$response = $this->post($formUrl, [
'Title' => $title,
'action_doSave' => 1
]);
// Verify whether the record was persisted and check the HTTP status code
$numCreated = CreateRestrictedObject::get()->count() - $numRecordsBefore;
$this->assertSame($expectedNumCreated, $numCreated);
$this->assertSame($expectedStatusCode, $response->getStatusCode());
}On unpatched versions (< 6.2.13), the server responds with 200 OK (or a 302 Found redirect to the newly assigned record ID, such as /item/43/edit), and $numCreated equals 1. On patched versions (>= 6.2.13), the server halts execution prior to database insertion, returns 403 Forbidden, and $numCreated remains 0.
CVE-2026-88989 is assigned a CVSS v3.1 base score of 4.3 (Medium) with the vector string CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N. The Attack Vector is Network (AV:N) and Attack Complexity is Low (AC:L), reflecting that the CMS administrative interface is accessible over standard HTTP/HTTPS connections and requires no complex preparation to exploit. Privileges Required is Low (PR:L) because the attacker must possess valid credentials for a low-privileged CMS backend account, and User Interaction is None (UI:N).
The primary security impact is confined to Integrity (I:L), with no direct impact to Confidentiality (C:N) or Availability (A:N). The Scope remains Unchanged (S:U) because both the vulnerable component (the Silverstripe controller layer) and the impacted resource (the application database) reside within the same security authority.
In practical deployment scenarios, the severity of this authorization bypass depends on the nature of the DataObject models exposed via GridField interfaces to non-administrative users:
canCreate() to enforce singleton patterns (where only one configuration record should exist in a table) or quota limits (where canCreate() returns false once a record count threshold is reached) can have their constraints bypassed.GridField exposes security-sensitive models—such as workflow approval rules, API tokens, or role mappings—where low-privileged users are permitted to view or edit non-sensitive metadata on existing entries but forbidden from provisioning new entries, an attacker can create new functional objects to elevate their access.As of the latest threat intelligence data, CVE-2026-88989 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no public exploitation in the wild has been reported.
The definitive remediation for CVE-2026-88989 is to upgrade silverstripe/silverstripe-framework to version 6.2.13 or later. Silverstripe installations are managed via Composer, and administrators should update the framework package along with its dependencies:
composer update silverstripe/silverstripe-framework --with-dependenciesAfter running the update command, verify that the installed package version meets or exceeds 6.2.13:
composer show silverstripe/silverstripe-frameworkIn environments where an immediate upgrade cannot be performed, developers can implement a temporary defense-in-depth workaround at the model layer. Specifically, overriding the onBeforeWrite() lifecycle hook within restricted DataObject classes allows the model itself to enforce canCreate() prior to database insertion:
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\PermissionFailureException;
class RestrictedRecord extends DataObject
{
protected function onBeforeWrite()
{
parent::onBeforeWrite();
// Enforce creation permissions at the ORM layer if the record is new
if (!$this->isInDB() && !$this->canCreate()) {
throw new PermissionFailureException('Creation of this record is not permitted.');
}
}
}> [!WARNING]
> Implementing checks inside onBeforeWrite() can disrupt legitimate background tasks, CLI scripts (sake), or system-level automated routines that instantiate and write records without an active user session. Ensure that system contexts are accounted for before deploying ORM-level hooks in production.
Additionally, security teams operating vulnerable instances should audit database tables and HTTP access logs for evidence of prior exploitation. In web server logs, look for HTTP POST requests targeting URLs matching the pattern */item/new/ItemEditForm that returned HTTP status codes 200 or 302 when initiated by non-administrative user sessions.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
silverstripe/silverstripe-framework Silverstripe Ltd. | < 6.2.13 | 6.2.13 |
| Attribute | Detail |
|---|---|
| Vulnerability ID | CVE-2026-88989 / GHSA-3qh3-54qg-gpq3 |
| Weakness Class | CWE-862: Missing Authorization |
| CVSS v3.1 Score | 4.3 (Medium) - CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N |
| Affected Component | GridFieldDetailForm_ItemRequest::saveFormIntoRecord() |
| Affected Versions | silverstripe/silverstripe-framework < 6.2.13 |
| Patched Version | silverstripe/silverstripe-framework 6.2.13 |
| Impact | Unauthorized creation of DataObject records by low-privileged CMS users |
| Exploit Status | PoC available in vendor test suite; Not listed in CISA KEV |
The software does not perform an authorization check when an actor attempts to access a resource or perform an action.
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.
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.