Nov 17, 2026·8 min read·1 visit
An unsafe reflection flaw in Silverstripe Framework's i18nTextCollectorTask allows attackers to instantiate arbitrary PHP classes with controlled constructor arguments via the 'writer' parameter, compounded by a route validation flaw in DevelopmentAdminConfirmationMiddleware that bypasses interactive user confirmation.
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.
The Silverstripe Framework (silverstripe/framework) is the core architectural foundation for the Silverstripe Content Management System (CMS). The framework provides a suite of maintenance, diagnostic, and build utilities accessible through both the command-line interface (CLI) and web-accessible endpoints under the /dev/ URI path. Among these built-in utilities is SilverStripe\Dev\Tasks\i18nTextCollectorTask, a build task responsible for traversing application source files to extract translatable strings and write them into localization files.
In Silverstripe Framework versions 6.0.0 through 6.2.12, i18nTextCollectorTask exposes an unsafe reflection vulnerability classified under CWE-470 (Use of Externally-Controlled Input to Select Classes or Code). The task accepts an optional writer parameter via CLI arguments (--writer) or HTTP GET query parameters (?writer=). The task passes this input directly into the framework's dependency injection container (SilverStripe\Core\Injector\Injector) to instantiate a translation writer object.
Because the application does not validate that the requested class implements the SilverStripe\i18n\Messages\Writer interface prior to instantiation, an attacker can specify any class available within the PHP runtime or Composer autoload hierarchy. Furthermore, Silverstripe's Injector parser supports inline constructor argument definitions within the service string specification, permitting the instantiation of arbitrary PHP objects with attacker-controlled constructor parameters.
This vulnerability is compounded by a logic flaw in SilverStripe\Control\Middleware\DevelopmentAdminConfirmationMiddleware. In production environments, this middleware is designed to intercept requests to /dev/ endpoints and force interactive user confirmation to mitigate Cross-Site Request Forgery (CSRF). However, the middleware failed to resolve nested route paths back to their registered parent routes, allowing direct requests to /dev/tasks/SilverStripe-Dev-Tasks-i18nTextCollectorTask to bypass the confirmation prompt entirely.
The primary vulnerability resides in the execute() method of src/Dev/Tasks/i18nTextCollectorTask.php. When the task runs, it retrieves the writer option from the Symfony\Component\Console\Input\InputInterface instance (which Silverstripe's PolyExecution layer populates from either CLI options or HTTP query parameters). If a non-empty value is present, the method invokes Injector::inst()->get($writerName) and passes the resulting object to $collector->setWriter($writer).
Silverstripe's Injector::get() method does not strictly treat its input as a literal class name. Instead, its internal specification parser evaluates strings containing parentheses as constructor argument lists (for example, Vendor\Package\ClassName('arg1', 'arg2')). When Injector::inst()->get() processes such a string, it resolves the target class and invokes its __construct() method with the parsed arguments. Even if a subsequent call to $collector->setWriter() fails due to a PHP type error after instantiation, any side effects within the target class's constructor or __destruct() lifecycle methods have already executed.
The secondary root cause is located in src/Control/Middleware/DevelopmentAdminConfirmationMiddleware.php within the hasAccess(HTTPRequest $request) method. To determine whether a requested URL requires interactive confirmation via /dev/confirm, the middleware strips trailing slashes from $request->getURL() and checks if the exact string exists as a key in the array returned by DevelopmentAdmin::singleton()->getLinks().
Because DevelopmentAdmin::getLinks() only registers top-level administrative endpoints such as dev/tasks rather than individual sub-task routes like dev/tasks/SilverStripe-Dev-Tasks-i18nTextCollectorTask, the isset($registeredRoutes[$url]) check returns false for all specific task URLs. Consequently, the confirmation middleware assumes the route is not a protected development action and passes the request directly to the controller without requiring a CSRF token or user confirmation.
The remediation was implemented in commit 2df498b1fad25db95dbd882117dcd0527a5fdbfa (Pull Request #12035), addressing both the arbitrary class instantiation in i18nTextCollectorTask and the route matching logic in DevelopmentAdminConfirmationMiddleware.
In src/Dev/Tasks/i18nTextCollectorTask.php, the patch introduces a strict pre-instantiation check using PHP's native is_a() function with the $allow_string parameter set to true:
// src/Dev/Tasks/i18nTextCollectorTask.php
$writerName = $input->getOption('writer');
if ($writerName) {
// Validate that $writerName is a valid class name implementing the Writer interface.
// Strings containing Injector constructor arguments (e.g., "MyWriter('arg')")
// fail this check because PHP does not recognize the full string as a valid class name.
if (!is_a($writerName, Writer::class, true)) {
throw new InvalidArgumentException('The writer option must be the name of a class that implements ' . Writer::class);
}
$writer = Injector::inst()->get($writerName);
$collector->setWriter($writer);
}Using is_a($writerName, Writer::class, true) neutralizes two distinct attack vectors simultaneously. First, it rejects any class that does not implement SilverStripe\i18n\Messages\Writer. Second, because is_a() expects a literal PHP class name string, any string containing Silverstripe Injector parameter syntax (such as ValidWriterClass('malicious_arg')) fails class resolution in PHP's autoloader and evaluates to false, preventing constructor argument injection even against legitimate Writer implementations.
In src/Control/Middleware/DevelopmentAdminConfirmationMiddleware.php, the patch replaces the exact string lookup with an iterative path-truncation loop:
// src/Control/Middleware/DevelopmentAdminConfirmationMiddleware.php
$url = rtrim($request->getURL(), '/');
$registeredRoutes = DevelopmentAdmin::singleton()->getLinks();
// Walk up the path hierarchy until a registered parent route is matched
// e.g., dev/tasks/queue/MyTask -> dev/tasks/queue -> dev/tasks
while (!isset($registeredRoutes[$url]) && strpos($url, '/') !== false) {
$url = substr($url, 0, strrpos($url, '/'));
}
return isset($registeredRoutes[$url]);By stripping path segments from the right until a match is found in $registeredRoutes or no / characters remain, any sub-route under dev/tasks/ resolves to the registered dev/tasks entry. The fix is complete and includes comprehensive unit test coverage in tests/php/Dev/Tasks/i18nTextCollectorTaskTest.php verifying that non-writer classes, non-string types, and class specifications containing constructor arguments throw an InvalidArgumentException prior to object construction.
Exploitation of CVE-2026-91115 depends on the environment configuration of the target Silverstripe installation. The vulnerability can be triggered via two distinct operational paths: direct unauthenticated requests against development environments, or cross-site requests targeting authenticated administrators in production environments.
When a Silverstripe instance is configured with SS_ENVIRONMENT_TYPE="dev" (either intentionally on staging servers or due to misconfiguration in production), the framework disables authentication requirements for /dev/ endpoints. An unauthenticated remote attacker can directly issue an HTTP GET request to execute i18nTextCollectorTask:
GET /dev/tasks/SilverStripe-Dev-Tasks-i18nTextCollectorTask?writer=ArbitraryNamespace%5CArbitraryClass('payload_arg1','payload_arg2') HTTP/1.1
Host: target-silverstripe.example.comWhen SS_ENVIRONMENT_TYPE="live" is set, accessing /dev/tasks/ requires an authenticated session possessing ADMIN or BUILDTASK_CAN_RUN permissions. However, because HTTP GET requests can trigger tasks and DevelopmentAdminConfirmationMiddleware failed to intercept nested URLs prior to version 6.2.13, the endpoint is vulnerable to Cross-Site Request Forgery. An attacker can embed the target URL in an HTML <img>, <iframe>, or top-level navigation link on an external website. When a logged-in Silverstripe administrator visits the attacker-controlled page or clicks the link, the browser dispatches the request with the administrator's session cookies, executing the payload without prompting for confirmation.
Once Injector::inst()->get($writerName) is reached, the attacker controls both the class name and the arguments passed to its constructor. Because Silverstripe bundles numerous third-party libraries via Composer (such as Symfony components, Guzzle, Monolog, and League Flysystem) alongside standard PHP extensions, an attacker can instantiate any class whose __construct() or __destruct() methods perform dangerous operations using constructor arguments—such as writing arbitrary files to the webroot, initializing file streams, or executing system commands.
Successful exploitation of CVE-2026-91115 results in Remote Code Execution (RCE) within the security context of the PHP web server process (commonly www-data, nginx, or apache). The vulnerability is assigned a CVSS v3.1 base score of 8.8 (High) with the vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H.
The CVSS vector reflects the production deployment posture where administrative authentication is bypassed by inducing an authenticated user to interact with a malicious link (PR:N/UI:R). For environments exposed to the network with SS_ENVIRONMENT_TYPE="dev", no user interaction or prior privileges are required, elevating the practical severity to critical.
Upon achieving code execution on the underlying host, an attacker gains full access to the Silverstripe environment configuration (including database credentials, API keys, and encryption salts stored in .env or environment variables), complete read and write access to the CMS database, and the ability to modify application source code or implant persistent web shells.
> [!NOTE]
> Silverstripe CMS 5 (5.x release branch) is unaffected by this vulnerability. The vulnerable input handling via PolyExecution and Symfony\Component\Console\Input\InputInterface within i18nTextCollectorTask was introduced in Silverstripe Framework 6.0.0.
The primary remediation is to upgrade silverstripe/framework to version 6.2.13 or later. Administrators and developers can apply the update using Composer:
composer update silverstripe/framework:^6.2.13For environments where an immediate framework upgrade cannot be deployed, administrators should implement defense-in-depth controls at the environment and web server layers. First, verify that all internet-facing production and staging environments explicitly define SS_ENVIRONMENT_TYPE="live" in their .env configuration or server environment variables so that unauthenticated access to /dev/ routes is disabled.
Second, restrict network access to the /dev/ URI prefix at the reverse proxy, load balancer, or web server layer so that development and build tasks can only be invoked from trusted internal management subnets or via the CLI (sake).
# Nginx configuration to block public access to Silverstripe /dev/ endpoints
location ^~ /dev/ {
allow 127.0.0.1;
allow 10.0.0.0/8;
deny all;
try_files $uri /index.php?$query_string;
}Finally, security monitoring teams can inspect web server access logs and Web Application Firewall (WAF) telemetry for HTTP requests targeting /dev/tasks/SilverStripe-Dev-Tasks-i18nTextCollectorTask that include the writer query parameter, particularly values containing parentheses ( and ) or namespace separators (\ or %5C).
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
silverstripe/framework Silverstripe | >= 6.0.0, < 6.2.13 | 6.2.13 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-91115 (GHSA-c94f-87xg-65wf) |
| Weakness Class | CWE-470 (Unsafe Reflection / Arbitrary Class Instantiation) |
| CVSS v3.1 Score | 8.8 High (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) |
| Affected Component | SilverStripe\Dev\Tasks\i18nTextCollectorTask & DevelopmentAdminConfirmationMiddleware |
| Affected Versions | silverstripe/framework >= 6.0.0, < 6.2.13 |
| Patched Version | silverstripe/framework 6.2.13 |
| Impact | Remote Code Execution (RCE) |
| CISA KEV Status | Not Listed |
The application receives input from an upstream component, but it does not restrict or incorrectly restricts the input before using it in reflection or dynamic instantiation to select classes, functions, or methods.
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.
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.
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.
CVE-2026-128074 is an algorithmic complexity and Regular Expression Denial of Service (ReDoS) vulnerability in Nuxt versions 4.6.0 through 4.6.3. The flaw resides in the server-side rendering (SSR) runtime components responsible for payload URL generation and experimental early 404 route evaluation. By sending unauthenticated HTTP requests containing long sequences of repeated forward slashes followed by a non-slash character, an attacker can force the V8 regular expression engine into quadratic O(N^2) backtracking, blocking the single-threaded Node.js event loop and degrading application availability.