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-91113

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

Alon Barad
Alon Barad
Software Engineer

Nov 17, 2026·9 min read·3 visits

Executive Summary (TL;DR)

Authenticated CMS users with edit access to any GridField record can submit a custom ClassName value in HTTP POST requests to morph the record into an unrelated or restricted DataObject class, bypassing both model hierarchy restrictions and target class permission checks (canCreate and canEdit).

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.

Vulnerability Overview

Silverstripe Framework is the underlying PHP object-relational mapping (ORM) and request-handling engine powering the Silverstripe Content Management System (CMS). Within the administrative interface, tabular data models and relational lists are primarily managed through the GridField component and its associated editing handler, GridFieldDetailForm.

When a CMS user edits an individual record within a GridField, the request is processed by GridFieldDetailForm_ItemRequest. This controller class generates the item editing form and processes incoming HTTP POST submissions via the doSave() and saveFormIntoRecord() methods to persist modifications back to the database.

In versions of silverstripe/framework prior to 6.2.13, GridFieldDetailForm_ItemRequest::saveFormIntoRecord() contains a missing authorization and improper input validation vulnerability classified under CWE-862 (Missing Authorization). When processing form submissions, the method checks if the incoming request data includes a ClassName parameter that differs from the existing record's class name.

If a discrepancy is detected, the framework instantiates a new object of the user-supplied ClassName and overwrites the record's type in the database. Because the framework fails to verify whether the target class belongs to the GridField list's intended model hierarchy and omits canCreate() and canEdit() permission checks against the new class, an authenticated attacker with low-privilege editing rights can morph records into arbitrary DataObject classes.

Root Cause Analysis

The root cause of CVE-2026-91113 resides in how Silverstripe's GridFieldDetailForm_ItemRequest handles polymorphic DataObject instantiation during form persistence. In Silverstripe's ORM, every DataObject database table includes a ClassName enum column that defines the specific PHP class used to hydrate that row. Certain models allow legitimate polymorphic transitions—such as changing a Page record into a specialized BlogPost subclass.

To support polymorphic changes, GridFieldDetailForm_ItemRequest::saveFormIntoRecord($data, $form) inspects the $data array, which is populated directly from the HTTP POST request body. Prior to calling saveFormIntoRecord(), the parent doSave() method executes $form->saveInto($record), which populates form fields onto the current $this->record instance. Subsequently, saveFormIntoRecord() evaluates whether $data['ClassName'] is set and differs from $this->record->ClassName.

Two distinct design flaws occur at this stage of execution. First, the method performs no validation to ensure that the user-supplied $data['ClassName'] is a subclass of—or identical to—the base data class managed by the GridField list ($list->dataClass()). Even if a GridField is explicitly configured without a ClassName dropdown field in its form schema, an attacker can inject the ClassName parameter directly into the POST payload, and the raw array check isset($data['ClassName']) will process it.

Second, the initial permission verification in doSave() only evaluates $this->record->canEdit() against the original record class prior to the type conversion. Converting a record to a different ClassName effectively creates a new instance of the target model and writes form data into its properties. By invoking $this->record->newClassInstance($newClassName) and subsequently calling $this->record->write() without checking canCreate() and canEdit() on the newly morphed instance, the framework permits unauthorized instantiation and modification of restricted models.

Code Analysis

The vulnerability is located in src/Forms/GridField/GridFieldDetailForm_ItemRequest.php within the saveFormIntoRecord() method. In vulnerable versions of Silverstripe Framework, the method directly accepts $data['ClassName'] and invokes newClassInstance() without verifying class inheritance or user permissions.

// Vulnerable code in src/Forms/GridField/GridFieldDetailForm_ItemRequest.php
protected function saveFormIntoRecord($data, $form)
{
    $list = $this->gridField->getList();
 
    // Check object matches the correct classname
    if (isset($data['ClassName']) && $data['ClassName'] != $this->record->ClassName) {
        $newClassName = $data['ClassName'];
        // The records originally saved attribute was overwritten by $form->saveInto($record) before.
        // This is necessary for newClassInstance() to work as expected, and trigger change detection
        // on the ClassName attribute
        $this->record->setClassName($this->record->ClassName);
        // FLAW 1: No check that $newClassName is within $list->dataClass() hierarchy
        // FLAW 2: Replace $record with a new instance without checking canCreate() or canEdit()
        $this->record = $this->record->newClassInstance($newClassName);
    }
 
    // Save form and any extra saved data into this record.
    $form->saveInto($this->record);
    $this->record->write();
    // ...
}

In commit 8b6e9c4514cbe37feeaf9ddddf796a3109448187, the Silverstripe development team remediated the flaw by introducing two consecutive security gates before allowing the record conversion to proceed.

// Patched code in src/Forms/GridField/GridFieldDetailForm_ItemRequest.php
        // Check object matches the correct classname
        if (isset($data['ClassName']) && $data['ClassName'] != $this->record->ClassName) {
            $newClassName = $data['ClassName'];
            // FIX 1: Validate that $newClassName is the list's dataClass or a valid subclass
            if (!is_a($newClassName, $list->dataClass(), true)) {
                $this->httpError(403, _t(
                    __CLASS__ . '.ClassNameNotAllowed',
                    'Cannot change record type to "{ClassName}"',
                    ['ClassName' => $newClassName]
                ));
                return null;
            }
            // The records originally saved attribute was overwritten by $form->saveInto($record) before.
            // This is necessary for newClassInstance() to work as expected, and trigger change detection
            // on the ClassName attribute
            $this->record->setClassName($this->record->ClassName);
            // Replace $record with a new instance
            $this->record = $this->record->newClassInstance($newClassName);
            // FIX 2: Enforce both canCreate and canEdit authorization on the newly morphed instance
            $canConvert = $this->record->hasMethod('canCreate')
                && $this->record->canCreate(null, $this->getCreateContext())
                && $this->record->hasMethod('canEdit')
                && $this->record->canEdit();
            if (!$canConvert) {
                $this->httpError(403, _t(
                    __CLASS__ . '.ClassNamePermissionFailure',
                    'It seems you don\'t have the necessary permissions to save "{ObjectTitle}" as "{ClassName}"',
                    ['ObjectTitle' => $this->getModelName(), 'ClassName' => $newClassName]
                ));
                return null;
            }
        }

The first check uses PHP's native is_a($newClassName, $list->dataClass(), true) with the $allow_string parameter set to true. This ensures that $newClassName is strictly identical to or inherits from the model class bound to the GridField's SS_List. If an unrelated class name is supplied, the method aborts before instantiation and throws a 403 Forbidden HTTP exception.

The second check evaluates authorization immediately after newClassInstance($newClassName) creates the in-memory object, but prior to $form->saveInto($this->record) and $this->record->write(). It verifies that the target class implements and passes both canCreate(null, $this->getCreateContext()) and canEdit(). Passing $this->getCreateContext() ensures that contextual creation rules (such as parent relation constraints) are honoured. This dual-gate design completely addresses the vulnerability within GridFieldDetailForm_ItemRequest without leaving residual bypass paths in the form submission handler.

Exploitation

Exploiting CVE-2026-91113 requires an attacker to possess authenticated access to the Silverstripe CMS administrative backend (/admin) with permissions to edit at least one record managed via a GridField detail form. No special configuration is required, as GridField is the standard UI component used across ModelAdmin interfaces and custom CMS sections.

To execute the attack, the adversary navigates to an editable item within any GridField, which typically resolves to a URL path matching /admin/<section>/<ModelName>/EditForm/field/<GridFieldName>/item/<RecordID>/edit. When submitting changes to the record, the browser sends an HTTP POST request to the ItemEditForm endpoint containing the form fields, a valid CSRF token (SecurityID), and the action_doSave=1 trigger.

The attacker intercepts this POST request using an intercepting proxy and appends or modifies the ClassName body parameter to reference a privileged or unrelated DataObject class existing within the application's autoloaded PHP namespace.

POST /admin/my-admin/App-Model-BasicItem/EditForm/field/App-Model-BasicItem/item/42/ItemEditForm HTTP/1.1
Host: vulnerable-cms.example.com
Cookie: PHPSESSID=a1b2c3d4e5f6g7h8i9j0
Content-Type: application/x-www-form-urlencoded
 
Title=ModifiedRecord&ClassName=SilverStripe%5CSecurity%5CMember&SecurityID=9876543210abcdef&action_doSave=1

> [!NOTE] > In Silverstripe's ORM, newClassInstance() updates the ClassName field in the base table of the original record. If the attacker targets a restricted subclass within the same inheritance tree (sharing a base table), the record seamlessly elevates to the restricted subclass and becomes active immediately. If the attacker specifies a completely unrelated DataObject from a different base table, the original base table's ClassName column is corrupted with the foreign class string, causing subsequent ORM queries on that table to hydrate the row as the injected class type.

Impact Assessment

The primary impact of CVE-2026-91113 is unauthorized data modification and model-level privilege escalation within the CMS database, reflected by its CVSS v3.1 score of 4.3 (Medium) (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N). Because exploitation requires an authenticated CMS user account, the Privileges Required (PR) metric is rated as Low (L), and the Integrity (I) impact is rated as Low (L).

In multi-tiered editorial environments, applications frequently define base DataObject models where standard editors can edit basic subtypes, while administrative users manage privileged subtypes that control system configuration, raw HTML injection, or workflow execution. By exploiting this vulnerability, a restricted editor can convert a standard record into a privileged subclass within the same inheritance hierarchy, bypassing both canCreate() and canEdit() restrictions on that subclass.

Furthermore, if an attacker injects an unrelated DataObject class name outside the inheritance hierarchy, the database row's ClassName enum value is overwritten. When Silverstripe's DataList or ORM queries subsequently load that record, the framework instantiates the injected class instead of the expected model class. This induces type confusion across the application and allows matching field names submitted in the POST request to populate properties on the target class.

Remediation

Silverstripe has resolved this vulnerability in silverstripe/framework version 6.2.13. Engineering and operations teams managing Silverstripe installations should upgrade the framework package immediately using Composer.

composer require "silverstripe/framework:^6.2.13" --no-update
composer update silverstripe/framework

For environments running legacy major release branches (such as Silverstripe 4.x or 5.x) or deployments where an immediate upgrade is not feasible, administrators can apply the patch directly to src/Forms/GridField/GridFieldDetailForm_ItemRequest.php using cweagans/composer-patches, or implement a custom Extension on GridFieldDetailForm_ItemRequest.

If neither upgrading nor patching the vendor code is immediately possible, developers should audit custom DataObject classes and implement strict validation inside onBeforeWrite() hooks to verify that changes to $this->ClassName are authorized for the currently active member (Security::getCurrentUser()).

Security monitoring teams can detect exploitation attempts by inspecting web server access logs and Web Application Firewall (WAF) telemetry for HTTP POST requests targeting /ItemEditForm endpoints that contain a ClassName parameter in the request body, particularly where the GridField model does not expose a class selection field in the UI. On patched instances, blocked exploitation attempts will generate HTTP 403 responses containing the message Cannot change record type to or It seems you don't have the necessary permissions to save.

Official Patches

SilverstripeSilverstripe Framework Release 6.2.13
SilverstripeOfficial Silverstripe Security Release Advisory for CVE-2026-91113
GitHubPull Request #12042 containing the security fix and unit tests

Fix Analysis (1)

Technical Appendix

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

Affected Systems

silverstripe/frameworksilverstripe/cms

Affected Versions Detail

Product
Affected Versions
Fixed Version
silverstripe/framework
Silverstripe
< 6.2.136.2.13
AttributeDetail
CVE IDCVE-2026-91113 (GHSA-4qv2-g5vp-wjjw)
Weakness ClassCWE-862: Missing Authorization
CVSS v3.1 Score4.3 Medium (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N)
Affected ComponentGridFieldDetailForm_ItemRequest::saveFormIntoRecord()
Affected Versionssilverstripe/framework < 6.2.13
Patched Versionsilverstripe/framework 6.2.13
Exploit StatusNo known public exploits or KEV listing

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-862
Missing Authorization

The software does not perform an authorization check when an actor attempts to access a resource or perform an action.

Vulnerability Timeline

Pull Request #12042 submitted and fix commit 8b6e9c4514cbe37feeaf9ddddf796a3109448187 authored by Steve Boyd.
2026-10-28
CVE-2026-91113 published by GitHub CNA on CVE.org and scored by NVD.
2026-11-16
GitHub Security Advisory GHSA-4qv2-g5vp-wjjw published.
2026-11-16

References & Sources

  • [1]GitHub Security Advisory GHSA-4qv2-g5vp-wjjw
  • [2]NVD Vulnerability Record for CVE-2026-91113
  • [3]CVE.org Official Record: CVE-2026-91113
  • [4]Silverstripe Framework Fix Pull Request #12042
  • [5]Fix Commit 8b6e9c4514cbe37feeaf9ddddf796a3109448187
  • [6]Silverstripe Framework Release 6.2.13
  • [7]Vendor Security Advisory Announcement (Silverstripe.org)
  • [8]FriendsOfPHP Security Advisory Record

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

•about 2 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 3 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 4 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 5 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
•about 6 hours ago•CVE-2026-128134
7.8

CVE-2026-128134: Local Code Execution via Untrusted Search Path in NLTK dependencygraph

In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.

Amit Schendel
Amit Schendel
4 views•11 min read
•about 7 hours ago•CVE-2026-119790
6.3

CVE-2026-119790: Cross-Request Cache Poisoning and Information Disclosure via Race Condition in Next.js

A race condition in Next.js versions 16.3.0 through 16.4.4 allows cross-request cache poisoning and unauthorized information disclosure across root parameters. When an application invokes the same `'use cache'` function both directly during rendering and wrapped inside `unstable_cache()`, a concurrent `unstable_cache()` request arriving during a cold start cache fill joins the in-flight execution. Because the `unstable_cache()` execution context lacks root parameter tracking, the parameter mismatch verification fails, causing `unstable_cache()` to persist root-parameter-scoped data under a global cache key.

Alon Barad
Alon Barad
5 views•9 min read