Feb 26, 2026·6 min read·164 visits
The Yii2 framework's `__set()` magic method allows developers to attach 'behaviors' dynamically. However, prior to version 2.0.48, it failed to validate that user-supplied configurations were actually Behaviors before instantiating them. Attackers can exploit this via mass assignment to instantiate arbitrary classes (like Guzzle gadgets) and achieve Remote Code Execution.
A critical Unsafe Reflection vulnerability in the core `yii\base\Component` class of the Yii2 framework allows attackers to instantiate arbitrary objects via the framework's behavior attachment mechanism. By leveraging PHP magic methods and the dependency injection container, remote attackers can execute arbitrary code (RCE) or perform other malicious actions by manipulating request parameters.
In the world of PHP frameworks, "Magic Methods" are the double-edged sword that developers love and security researchers drool over. Yii2, one of the heavyweights of the PHP ecosystem, relies extensively on __get, __set, and __call to implement its component-based architecture. This allows for mixins, dynamic properties, and event handling that feels almost like wizardry.
At the heart of this system is yii\base\Component. This class is the great-grandfather of nearly everything in a Yii2 application—Models, Controllers, Views, you name it. If you find a bug here, you aren't just breaking a feature; you are breaking the foundation.
CVE-2024-4990 allows us to abuse a specific feature of this component system: Behaviors. Behaviors are Yii2's way of injecting functionality into a class at runtime. The framework allows you to attach a behavior simply by setting a property that starts with as . For example, $model->{'as timestamp'} = TimestampBehavior::class;. It's a convenient piece of syntactic sugar, but as we're about to see, it's also a convenient entry point for Remote Code Execution.
The vulnerability lies in how yii\base\Component::__set() handles these dynamic behavior assignments. The logic is simple: check if the property name starts with as , trim the prefix to get the behavior name, and then instantiate the value provided.
Here is the logic in pseudocode terms: "If the user sends me a property named as evil, take the value they sent, create an object out of it, and attach it to the component." The critical failure here is the order of operations. The code calls Yii::createObject($value)—a powerful factory method that wraps a Dependency Injection (DI) container—before checking if the resulting object is actually a valid Behavior.
Yii::createObject is incredibly flexible. If you pass it an array with a class key, it will instantiate that class. If you pass it arguments, it will feed them to the constructor. Because __set is reachable via user input (e.g., during mass assignment of POST data to a Model), an attacker can trick the application into instantiating any class available in the autoloader, not just the intended Behaviors. It's like a nightclub bouncer who lets people in before checking their ID.
Let's look at the vulnerable code in yii\base\Component.php prior to version 2.0.48. This snippet shows the __set implementation:
public function __set($name, $value)
{
// ... standard setter logic ...
// The Vulnerable Logic
} elseif (strncmp($name, 'as ', 3) === 0) {
// as behavior: attach behavior
$name = trim(substr($name, 3));
// DANGER: Yii::createObject is called on user-controlled $value
$this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
return;
}
// ...
}The line $value instanceof Behavior ? $value : Yii::createObject($value) is the killer. If $value is an array (which it will be coming from a JSON payload), instanceof fails, so it proceeds to Yii::createObject($value). By the time the code realizes the object isn't a Behavior (inside attachBehavior), the object has already been created, and its constructor has already run.
Now, look at the initial patch (which was later bypassed, but we'll get to that):
// The "Fix"
if ($value instanceof Behavior) {
$this->attachBehavior($name, $value);
} elseif (isset($value['class']) && is_subclass_of($value['class'], Behavior::class, true)) {
// Checking class name before instantiation
$this->attachBehavior($name, Yii::createObject($value));
} ...The developers attempted to validate the class key before instantiation. However, they missed a crucial detail about their own DI container: Yii2 supports __class as an alias for class. This oversight led to CVE-2024-58136, a regression that kept the door wide open.
To exploit this, we need a "Gadget Chain". Since we can instantiate any class, we need a class that does something dangerous in its __construct or __destruct methods. A classic favorite in the PHP ecosystem is GuzzleHttp\Psr7\FnStream.
When FnStream is destroyed (which happens when the script ends or the object is discarded), it executes a user-defined callback. This gives us instant RCE.
The Attack Flow:
$model->load($_POST) or parses JSON into a component configuration.as exploit to trigger the __set logic.Proof of Concept (RCE via Guzzle):
{
"User": {
"username": "admin",
"as exploit": {
"class": "GuzzleHttp\\Psr7\\FnStream",
"methods": {
"close": "passthru",
"args": ["id; ls -la"]
}
}
}
}When Yii2 processes this, it instantiates FnStream. The framework realizes FnStream isn't a Behavior and throws an exception or discards it. However, the object was created. When PHP creates the exception or finishes the request, the FnStream object is garbage collected. Its __destruct method fires, calling close(), which runs passthru('id; ls -la').
This is a Critical severity vulnerability because it requires zero authentication (if the vulnerable endpoint is public, like a registration or login page) and results in full Remote Code Execution.
Yii2 is used by massive enterprise applications, CRMs, and e-commerce platforms. An attacker exploiting this can:
PDO object to connect to an external malicious MySQL server (SSRF) or simply use the shell access to dump the local database.Because the vulnerability exists in the base Component class, the attack surface is effectively "everywhere mass assignment is used in the application." It transforms a standard development convenience into a catastrophic security hole.
The remediation journey for this bug was bumpy. The initial fix in 2.0.48 was incomplete because it only validated the class array key, ignoring the __class alias supported by Yii's DI container.
Immediate Action Required:
yiisoft/yii2 version 2.0.52 or later. Do not stop at 2.0.48 or 2.0.51, as they are still vulnerable to the bypass (CVE-2024-58136).$model->load($_POST) blindly on sensitive models without a strict scenarios() definition or explicit attribute safe-listing.Defense in Depth:
If you cannot upgrade immediately, you can implement a WAF rule to block any HTTP request body containing keys matching the regex "as\s+[a-zA-Z0-9_]+". However, WAFs are bypassable (e.g., via JSON encoding tricks), so patching the root cause is the only real solution.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
yiisoft/yii2 Yii Software | < 2.0.52 | 2.0.52 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-470 |
| Attack Vector | Network |
| CVSS | 9.1 (Critical) |
| Impact | Remote Code Execution (RCE) |
| Exploit Status | PoC Available / Weaponized |
| Prerequisites | None (if endpoint exposes mass assignment) |
Use of Externally-Controlled Input to Select Classes or Code (Unsafe Reflection)
An incorrect authorization vulnerability (CWE-863) exists in the ASP.NET Core SignalR HTTP Connection Dispatcher (`Microsoft.AspNetCore.Http.Connections`). The connection negotiation process failed to bind the authenticated caller identity to the generated connection state, and subsequent transport or message dispatch handlers failed to verify caller consistency. Consequently, an authenticated low-privilege attacker who obtains a valid connection identifier or token can inject messages into or hijack another user's SignalR session, achieving an elevation of privilege across security boundaries.
CVE-2026-109478 is a network-accessible Denial of Service (DoS) vulnerability in ASP.NET Core caused by inefficient algorithmic complexity (CWE-407) when parsing comma-separated HTTP request headers. Prior to the patch, the internal helper method ParsingHelpers.GetHeaderSplit repeatedly called StringValues.Concat inside a loop iterating over each comma-separated token. Because StringValues allocates a new array of size k + 1 and copies all existing elements upon each concatenation, processing N tokens incurs O(N^2) time and space complexity. An unauthenticated remote attacker can send HTTP requests with headers containing thousands of short, comma-separated values to exhaust CPU cycles and induce severe Garbage Collection (GC) pauses, rendering the web application unresponsive.
CVE-2026-114147 is a high-severity Denial of Service (DoS) vulnerability affecting ASP.NET Core and specifically the Microsoft.AspNetCore.SignalR.StackExchangeRedis scale-out provider across .NET 8.0, 9.0, 10.0, and 11.0 preview releases. The vulnerability originates from a string comparison mismatch between internal per-connection group collections and the centralized Redis channel subscription registry, compounded by a race condition during connection teardown. Remote unauthenticated attackers can exploit this flaw to leave orphaned connection contexts and active Redis pub/sub listeners pinned in memory, leading to unbounded memory exhaustion and application process termination.
CVE-2026-114156 is an improper resolution of path equivalence vulnerability (CWE-41) in Microsoft ASP.NET Core affecting .NET 11.0 preview releases and Microsoft Visual Studio 2026. The vulnerability stems from a discrepancy between how path prefix validation helpers (such as PathString.StartsWithSegments) and downstream routing mechanisms handle alternate path separators and percent-encoded characters. An unauthenticated remote attacker can exploit this mismatch over the network to bypass path-based authorization middleware and access restricted endpoints.
CVE-2026-114157 is a high-severity local privilege escalation and security feature bypass vulnerability affecting ASP.NET Core on Microsoft Windows. The flaw resides in the Kestrel web server's Named Pipes transport layer (Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes) and stems from a race condition (CWE-362) during broken pipe error recovery. When an active connection throws an IOException during handshake acceptance, the connection listener previously disposed of the broken NamedPipeServerStream instance before acquiring a replacement stream from its internal pool. This sequence created a momentary window where zero server instances of the named pipe existed in the Windows Named Pipe File System (NPFS). A local, low-privileged attacker can exploit this timing window to create a named pipe with the identical name and a permissive Discretionary Access Control List (DACL), hijacking subsequent inter-process communications and escalating privileges across security boundaries.
CVE-2026-124194 is a forced authentication and spoofing vulnerability in Microsoft Office Outlook caused by a missing user interface warning before dereferencing remote network paths (CWE-356). By embedding an attacker-controlled Universal Naming Convention (UNC) path within MAPI message properties such as PidLidReminderFileParameter, an unauthenticated remote attacker can force a victim's system to initiate an outbound SMB or WebDAV connection upon opening or previewing a crafted message. This automatic authentication handshake leaks the user's NetNTLMv2 hash, enabling offline password cracking or real-time NTLM relay attacks. The vulnerability was exploited in the wild as a zero-day prior to its remediation in Microsoft's November 2026 Patch Tuesday updates and is listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.