GHSA-3g43-6gmg-66jw axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollution Gadget in Config Merge
SummaryAxios versions before the fixed releases contain prototype-pollution gadgets in request config processing. If another vulnerability in the same JavaScript process has already polluted `Object.prototype.transformResponse`, affected Axios versions may treat that inherited value as request configuration or as an option validator.Axios does not itself create the prototype pollution. Exploitability requires a separate prototype-pollution vulnerability or equivalent attacker control over `Object.prototype` before Axios creates a request.ImpactFor ordinary prototype-pollution primitives that can only assign JSON-like values, this issue primarily results in request failures or denial-of-service attacks.If the attacker can pollute `Object.prototype.transformResponse` with a function, affected versions of Axios may execute it. In fully affected versions, the function can observe response data and request config, including URL, headers, and `auth`, and can change the response data returned to application code.This function-valued condition is important. Most query-string or JSON parser prototype-pollution bugs cannot create JavaScript functions on their own, so credential exposure and response tampering are conditional rather than automatic consequences of such bugs.Affected FunctionalityThe affected functionality is Axios request config processing and response transformation.Affected use requires all of the following:An affected Axios version.A polluted `Object.prototype` in the same process or browser context.Pollution before Axios merges or validates the request config.A polluted key relevant to Axios config, especially `transformResponse`.This is not specific to the Node HTTP adapter. Browser and Node usage can both pass through the shared config/transform pipeline, though real-world exploitability depends on the surrounding application and any helper vulnerabilities.Technical DetailsIn affected versions, `mergeConfig()` reads config values through normal property access. For config keys present in Axios defaults, including `transformResponse`, a missing own property on the request config can fall through to `Object.prototype`.In the fully affected path, this means `Object.prototype.transformResponse` can replace Axios's default response transform. The selected transform is later executed by `transformData()` with the request config as `this`.Some later affected v1 releases guarded the merge path but still used inherited properties while looking up validators in `validator.assertOptions()`. In that narrower case, a polluted function can still run during config validation and inspect the config argument, but it does not replace the response transform.Fixed versions use own-property checks and null-prototype config objects, so inherited `Object.prototype` values are not treated as Axios config or validator schema entries.Proof of Concept of AttackExpected result on fully affected versions: the polluted transform runs, captures request config and response data, and replaces the response returned to the caller.Expected result on fixed versions: the polluted transform is ignored, and the original response is returned.SummaryThe Axios library is vulnerable to a Prototype Pollution "Gadget" attack that allows any `Object.prototype` pollution in the application's dependency tree to be escalated into **credential theft** and **response hijacking** across all Axios requests.The `mergeConfig()` function reads config properties via standard property access (`config2[prop]`), which traverses the JavaScript prototype chain. When `Object.prototype.transformResponse` is polluted with a function, it **overrides the default JSON response parser** for every request. The injected function executes with `this = config`, exposing `auth.username`, `auth.password`, request URL, and all headers.**Severity:** High (CVSS 8.2)
**Affected Versions:** All versions (v0.x - v1.x including v1.15.0)
**Vulnerable Component:** `lib/core/mergeConfig.js` (Config Merge) + `lib/core/transformData.js` (Transform Execution)CWE**CWE-1321:** Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')CVSS 3.1**Score: 9.4 (High)**Vector: `CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:H`| Metric | Value | Justification |
|---|---|---|
| Attack Vector | Network | PP is triggered remotely via any vulnerable dependency |
| Attack Complexity | Low | Once PP exists, a single property assignment exploits axios. Consistent with GHSA-fvcv-3m26-pcqx scoring |
| Privileges Required | None | No authentication needed |
| User Interaction | None | No user interaction required |
| Scope | Unchanged | Credential theft occurs within the same application process |
| Confidentiality | High | `this.auth.password`, `this.url`, original response data all exfiltrated |
| Integrity | Low | Response data is replaced with `true` — attacker **cannot** return arbitrary data due to `assertOptions` constraint (see below) |
| Availability | High | Polluting with an array value causes `TypeError: validator is not a function` crash (DoS) on every request |Relationship to GHSA-fvcv-3m26-pcqxThis vulnerability is in the same class as GHSA-fvcv-3m26-pcqx ("Unrestricted Cloud Metadata Exfiltration via Header Injection Chain"), which was also a PP gadget in axios rated Critical. Both require zero direct user input and exploit `mergeConfig`'s prototype chain traversal.| Factor | GHSA-fvcv-3m26-pcqx | This Vulnerability |
|---|---|---|
| Attack vector | PP → Header injection → Request smuggling | PP → Transform function override → Credential theft |
| Fixed by 1.15.0 header sanitization? | Yes | **No — different code path** |
| Affects | Requests using form-data package | **All requests** (transformResponse is in defaults) |
| Impact | AWS IMDSv2 bypass, cloud compromise | Credential theft (auth, API keys), response hijacking, DoS |Usage of "Helper" VulnerabilitiesThis vulnerability requires **Zero Direct User Input**.If an attacker can pollute `Object.prototype` via any other library in the stack (e.g., `qs`, `minimist`, `lodash`, `body-parser`), Axios will automatically pick up the polluted `transformResponse` property during its config merge.The critical difference from GHSA-fvcv-3m26-pcqx: this vector was **NOT fixed** by the header sanitization patch in v1.15.0, because it does not use headers at all — it injects a function into the response processing pipeline.Proof of Concept1. The Setup (Simulated Pollution)Imagine a scenario where a known vulnerability exists in a query parser. The attacker sends a payload that sets:**Important constraint:** The polluted value must be a **function returning `true`**, not an array. If an array is used, `assertOptions()` at `validator.js:89-92` crashes with `TypeError: validator is not a function` (which is still a DoS vector). The function must return `true` because `validator.js:93` checks `result !== true`.2. The Gadget Trigger (Safe Code)The application makes a completely safe, hardcoded request:3. The ExecutionAxios's `mergeConfig()` at `mergeConfig.js:99-103` iterates config keys:The polluted function then executes at `transformData.js:21`:4. The ImpactThe response data seen by the application is `true` (the required return value), which will likely cause the application to malfunction but will not reveal the theft.5. DoS VariantVerified PoC OutputImpact Analysis**Credential Theft:** `this.auth.username`, `this.auth.password`, `this.headers.Authorization`, and all other config properties are accessible to the injected function. The attacker can exfiltrate them to an external server.**Response Data Exfiltration:** The original server response (`data` parameter) is available to the injected function before being replaced.**Universal Scope:** Affects **every** axios request in the application, including all third-party libraries that use axios.**Denial of Service:** Polluting with a non-function value crashes every request.**Bypass of 1.15.0 Fix:** The header sanitization patch in v1.15.0 (GHSA-fvcv-3m26-pcqx fix) does not address this vector.Limitations (Honest Assessment)Requires a separate prototype pollution vulnerability elsewhere in the dependency treeResponse data cannot be arbitrarily tampered — the function must return `true` to pass `assertOptions`This is in-process JavaScript function execution, not OS-level RCERecommended FixUse `hasOwnProperty` checks in `defaultToConfig2` to prevent prototype chain traversal:Additionally, validate that `transformResponse` contains only functions before execution:Resources[CWE-1321: Prototype Pollution](https://cwe.mitre.org/data/definitions/1321.html)[GHSA-fvcv-3m26-pcqx: Related PP Gadget in Axios (Fixed in 1.15.0)](https://github.com/advisories/GHSA-fvcv-3m26-pcqx)[Axios GitHub Repository](https://github.com/axios/axios)[Snyk: Prototype Pollution](https://learn.snyk.io/lesson/prototype-pollution/)Timeline| Date | Event |
|---|---|
| 2026-04-15 | Vulnerability discovered during source code audit |
| 2026-04-15 | Initial PoC developed (array payload — crashes at validator.js) |
| 2026-04-16 | PoC corrected (function payload returning true — works) |
| 2026-04-16 | Report revised with accurate constraints |
| TBD | Report submitted to vendor via GitHub Security Advisory |
CVSS v3.1 score: 7