CVE-2026-42044

What it actually does

Axios versions 1.0.0 through versions before 1.15.2 can invoke an inherited Object.prototype.parseReviver function during JSON response parsing because the default transformResponse path calls JSON.parse(data, this.parseReviver) using the merged request configuration object as this. If any other vulnerability, malicious dependency, compromised script, or unsafe merge operation pollutes Object.prototype with a parseReviver function, Axios may apply that attacker-controlled reviver to every key-value pair in JSON responses. This can silently alter response data after it is received and before application code consumes it, enabling targeted integrity compromise such as changing roles, feature flags, authorization decisions, monetary values, IDs, or status fields. The flaw is best understood as an Axios prototype-pollution gadget: it does not itself necessarily create the initial pollution condition, but it turns an existing Object.prototype pollution primitive into broad JSON response manipulation.

Why it matters to the business

Applications that rely on Axios to consume JSON APIs may make business decisions based on silently modified response data. In practical terms, this can lead to incorrect authorization decisions, privilege escalation in user workflows, inaccurate financial or inventory values, tampered account state, or bypassed client-side or service-side logic when downstream code trusts parsed Axios responses. The CVSS score is moderate, EPSS is currently low, it is not listed in CISA KEV, and no mature public exploitation is indicated in the provided data; however, the impact can be significant in applications that already have a prototype pollution weakness elsewhere in the dependency tree or that process untrusted JavaScript/configuration data.

How an attack unfolds

An attacker first needs a way to pollute Object.prototype in the JavaScript runtime used by the vulnerable application. That initial primitive may come from a separate prototype pollution vulnerability in application code, a dependency that performs unsafe recursive merges, untrusted JSON/configuration handling, malicious package code, or compromised browser-side script execution. The attacker then sets Object.prototype.parseReviver to a function that inspects JSON.parse keys and values and selectively returns modified values. When vulnerable Axios versions parse a JSON response, the default transformResponse implementation passes this.parseReviver into JSON.parse. Because parseReviver is inherited from Object.prototype and is not constrained by Axios defaults or option validation, the attacker-controlled function is executed for each parsed JSON property. The attacker can keep most fields unchanged while modifying only security-sensitive fields, making the tampering hard to notice in normal logs or UI behavior. Successful exploitation depends heavily on the surrounding application behavior and on whether parsed Axios response values are trusted for authorization, financial, workflow, or state-changing decisions.

How to fix it

Upgrade Axios to version 1.15.2 or later wherever it is used. If exact package management is available, update the axios npm package to >=1.15.2 and regenerate lockfiles so transitive and bundled copies are not left behind. Because the provided fixed_versions field is empty but the description identifies 1.15.2 as the fixed release, use 1.15.2 as the minimum remediation target. Also review applications for independent prototype pollution sources, especially unsafe deep merge utilities, parsing of untrusted objects containing __proto__, constructor, or prototype keys, and dependencies with known prototype pollution advisories. As defense in depth, avoid trusting client-side parsed response fields for authorization or financial decisions, validate security-critical server responses against schemas, and consider hardening JavaScript runtimes by preventing prototype mutation where feasible. Temporary mitigation is limited: replacing Axios transformResponse with a safe custom parser that does not read inherited parseReviver may reduce exposure, but upgrading is the preferred fix.

How to confirm the fix worked

Confirm all deployed applications, build artifacts, containers, serverless bundles, and frontend packages use Axios 1.15.2 or later. Check package-lock.json, yarn.lock, pnpm-lock.yaml, npm ls axios, yarn why axios, pnpm why axios, SBOMs, and bundled JavaScript output for older Axios versions. Validate runtime behavior by confirming Axios no longer passes an inherited Object.prototype.parseReviver into JSON.parse during default JSON response handling. Test for exposure in a non-production environment by setting Object.prototype.parseReviver to a benign function that changes a known test field, then making an Axios JSON request; vulnerable behavior is indicated if parsed response data changes through the inherited reviver. Also run prototype pollution tests against application input paths and dependency scanners to ensure there is no remaining pollution primitive that could combine with similar gadgets.

Typical attack path

1. Identify an application using Axios 1.0.0 through a version before 1.15.2 to process JSON API responses.
2. Find or introduce a separate primitive that pollutes Object.prototype in the same JavaScript runtime.
3. Set Object.prototype.parseReviver to an attacker-controlled function.
4. Wait for the application to make Axios requests that parse JSON responses through the default transformResponse behavior.
5. Use the reviver function to selectively alter sensitive response fields such as role, isAdmin, balance, permissions, status, plan, or authorization flags.
6. Allow application logic to consume the modified Axios response and make incorrect trust, authorization, financial, or workflow decisions.
7. Avoid noisy changes by returning original values for unrelated keys, leaving responses mostly intact.

How to detect it

There is no single network IOC for this issue because exploitation occurs inside the JavaScript runtime during JSON parsing and depends on a separate Object.prototype pollution source. Detection should focus on evidence of prototype pollution and suspicious runtime tampering. Review application logs, browser telemetry, server-side JavaScript logs, dependency integrity alerts, and error reports for attempts to submit object keys such as __proto__, constructor, prototype, or parseReviver in JSON bodies, query strings, form fields, headers, local storage, or configuration objects. Search source and built assets for assignments to Object.prototype.parseReviver, __proto__.parseReviver, or constructor.prototype.parseReviver. In Node.js applications, inspect runtime crash logs or diagnostics for unexpected parseReviver references, anomalous JSON parsing behavior, or modified authorization-related response values. In frontend applications, review web application firewall logs and client-side monitoring for suspicious payloads containing prototype pollution keys. For forensic review, compare raw API responses captured at the network boundary with parsed application state or subsequent actions; mismatches in sensitive fields such as role, permissions, balance, status, or entitlements may indicate response manipulation. Also inspect package integrity and recent dependency changes for malicious or unexpected code that mutates Object.prototype.

• Object.prototype.parseReviver
• __proto__.parseReviver
• constructor.prototype.parseReviver
• prototype.parseReviver
• "parseReviver"
• 'parseReviver'
• "__proto__"
• '__proto__'
• "constructor"
• "prototype"
• JSON.parse(data, this.parseReviver)
• lib/defaults/index.js

What your security team should do

• Prioritize upgrading Axios to 1.15.2 or later across all repositories, images, and bundled frontend assets.
• Search dependency manifests and lockfiles for axios versions >=1.0.0 and <1.15.2, including transitive and vendored copies.
• Review applications that use Axios responses for authorization, roles, entitlements, balances, pricing, workflow state, or other high-integrity decisions.
• Investigate and remediate separate prototype pollution vulnerabilities in the same dependency trees; this issue becomes dangerous when paired with a pollution primitive.
• Add SCA/SBOM policy checks to block Axios versions before 1.15.2.
• Add regression tests that fail when inherited properties such as Object.prototype.parseReviver influence JSON parsing behavior.
• For internet-facing or high-value applications, review recent anomalous authorization changes, account privilege changes, and unexpected financial or state transitions that could reflect response tampering.
• Do not rely on client-side response values alone for security decisions; enforce authorization and business rules server-side.