Jan 22, 2026·6 min read·543 visits
Lodash versions prior to 4.17.23 fail to sanitize paths in `_.unset` and `_.omit`. An attacker supplying a path like `__proto__.toString` can delete the `toString` method from `Object.prototype`, causing every object in the running application to lose that method. This leads to immediate application crashes (DoS) or security bypasses if logic relies on the existence of specific prototype methods. The fix involves strict validation of path segments to block `__proto__` and `constructor` access.
A prototype pollution vulnerability in the ubiquitous Lodash library allows attackers to delete critical properties from the global Object prototype. Unlike traditional pollution which injects malicious properties, this flaw uses `_.unset` and `_.omit` to destructively remove core language methods (like `toString` or `hasOwnProperty`) via path traversal, causing widespread Denial of Service or logic failures.
Lodash is the duct tape of the JavaScript ecosystem. It is the library you reach for when you realize JavaScript's standard library is missing the tools you actually need to do your job. It handles deep cloning, debouncing, and, crucially for this story, object manipulation. We trust it implicitly. We feed it our user input, our JSON blobs, and our complex state objects, expecting it to behave deterministically.
But here is the thing about utility belts: if you pull the wrong lever, you might just detach the floor you are standing on. CVE-2025-13465 isn't your standard 'injection' vulnerability where we sneak in a script tag. It is a Prototype Pollution flaw, but with a nihilistic twist.
Usually, hackers use prototype pollution to add properties—polluting the water supply, so to speak. This vulnerability allows us to delete properties. We aren't adding poison to the well; we are evaporating the water entirely. By targeting _.unset or _.omit, we can reach into the very soul of the JavaScript runtime—Object.prototype—and rip out methods that the application needs to breathe.
The root of this vulnerability lies in how Lodash interprets 'paths'. When you tell Lodash to unset a property at a.b.c, it has to traverse the object graph to find c. It does this by splitting the string into segments or accepting an array of keys. The underlying engine for this is a function called baseUnset.
In vulnerable versions (pre-4.17.23), baseUnset was entirely too trusting. It would happily accept path segments like __proto__ or constructor and prototype. It treated them as valid keys to traverse. It didn't pause to ask, "Wait, should I really be climbing up the inheritance chain into the global scope?"
Because JavaScript objects are mutable by default, and because almost everything in JavaScript inherits from Object, traversing up to Object.prototype gives you write access to the blueprint of every object in the system. The flaw isn't just that it traverses; it's that after traversing, it executes the delete operator. While delete cannot remove non-configurable properties, many vital methods on the prototype chain are, in fact, configurable.
Let's look at the smoking gun. The fix was applied in baseUnset. The developers had to introduce a strict validation loop that runs before any traversal happens. They couldn't just check the final key; they had to check every step of the path.
Here is the logic introduced in commit edadd452146f7e4bad4ea684e955708931d84d81:
// The Fix Logic
while (++index < length) {
var key = path[index];
// ... checks for non-string keys ...
// BLOCK 1: The Classic Proto
if (key === '__proto__' && !hasOwnProperty.call(object, '__proto__')) {
return false;
}
// BLOCK 2: The Constructor Bypass
if (key === 'constructor' &&
(index + 1) < length &&
path[index + 1] === 'prototype') {
// ... strict checks for primitive roots ...
return false;
}
}Analysis:
__proto__ Check: It explicitly looks for __proto__. If found, it ensures it's an "own" property (a real key on the object) rather than the inherited accessor. If it's the accessor, it bails.constructor.prototype Check: Attackers often bypass __proto__ filters by going through constructor.prototype. The patch explicitly looks for this sequence. If it sees constructor followed immediately by prototype, it hard-stops the operation.This creates a whitelist of sorts—you can traverse anywhere except the forbidden zones of the prototype chain.
How do we weaponize this? We don't need RCE to ruin a sysadmin's day. A Denial of Service (DoS) via prototype deletion is often harder to debug than a crash. The application enters a "zombie state" where basic language features stop working.
Imagine a backend service that accepts a JSON payload to update user preferences. The code uses _.unset to remove restricted keys before saving.
The Setup:
const _ = require('lodash');
// The victim code
app.post('/update', (req, res) => {
let userInput = req.body;
// Developer tries to be safe by unsetting a specific field
// But 'userInput.fieldToRemove' is controlled by the attacker
_.unset(userInput.data, userInput.fieldToRemove);
});The Attack:
We send a payload where fieldToRemove is constructor.prototype.toString.
The Execution Flow:
['constructor', 'prototype', 'toString'].userInput.data.constructor, which is Object..prototype, which is Object.prototype.delete Object.prototype['toString'].The Aftermath:
The next time any part of that Node.js process tries to cast an object to a string (e.g., inside a logging library, an error handler, or a template engine), it will fail. [object Object] is gone. The application throws TypeError: ... is not a function and crashes. If you have an auto-restarter, it creates a crash loop until the malicious payload is flushed.
You might think, "So it crashes, big deal." But consider the subtlety. You can delete hasOwnProperty.
Many security mechanisms rely on obj.hasOwnProperty('isAdmin') to verify data integrity. If you delete hasOwnProperty from the prototype, the check might throw an error (DoS) or, depending on the implementation (e.g., try/catch blocks that swallow errors), it might fail open.
Furthermore, this vulnerability impacts _.omit as well. If an application uses _.omit(req.body, blocklist), an attacker can craft a request that pollutes the prototype during the omission process. Since Lodash is the backbone of thousands of high-traffic enterprise applications, the blast radius is massive. It turns a simple data processing utility into a remote kill switch.
The remediation is straightforward but urgent. You must upgrade Lodash.
Primary Fix: Update to version 4.17.23 or later.
npm install lodash@latestDefense in Depth: Even with the patch, you should stop trusting objects. JavaScript provides tools to harden your environment against this class of bugs entirely:
Object.freeze(Object.prototype): At the very start of your application, freeze the prototype. This prevents any library from modifying or deleting core methods.Map instead of Objects: For hash maps where keys are user-controlled, use the Map structure. It doesn't have a prototype chain to pollute.CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:L/SC:H/SI:H/SA:H/E:P| Product | Affected Versions | Fixed Version |
|---|---|---|
lodash lodash | >= 4.0.0 < 4.17.23 | 4.17.23 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-1321 |
| CVSS v4.0 | 6.9 (Medium) |
| Attack Vector | Network |
| Impact | Denial of Service / Logic Alteration |
| Affected Function | _.unset, _.omit |
| Exploit Status | PoC Available |
Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')
CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.
CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.
CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.
CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.
CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.
CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.