CVE-2026-101908

Executive Summary

CVE-2026-101908 is a prototype pollution vulnerability in the axios promise-based HTTP client, affecting versions 1.7.0 through 1.20.0. The flaw allows a same-process attacker who can pollute Object.prototype to override sanitized request headers by exploiting the fetch adapter's use of both the constructed Request object and the original fetchOptions. Successful exploitation can subvert authorization headers, cache behavior, or enable access to cloud metadata services, resulting in potential credential theft or privilege escalation within the hosting environment.

Technical Analysis

Axios is a widely deployed HTTP client for both browser and Node.js environments. From version 1.7.0 onward, the library introduced a fetch-based adapter. The vulnerability arises from a logic flaw in how the fetch adapter constructs and dispatches requests.

Specifically, the fetch adapter:

1. Builds a Request object using a sanitized set of resolved options (resolvedOptions).
2. Then calls the global fetch function with the original fetchOptions as the second argument.

In JavaScript, when fetch is invoked with both a Request object and an init (options) object, properties in the init object override those in the Request. Because the adapter passes the unsanitized fetchOptions, any headers present on that object take precedence over the sanitized ones.

The second component of the vulnerability is a separate, same-process prototype pollution flaw. If an attacker can pollute Object.prototype.headers (for example, via an unrelated prototype pollution vulnerability in the same process or through a crafted input that reaches a vulnerable sink), then fetchOptions.headers will resolve to the attacker-controlled value through prototype inheritance. This inherited headers property is then used by fetch as the authoritative header set, completely overriding the sanitized headers that axios intended to send.

This means an attacker can inject arbitrary HTTP headers into outgoing requests made by the axios client, even though axios intended to sanitize and control those headers. The attack surface is any Node.js or browser application that uses axios (affected versions) with the fetch adapter and that also has a same-process prototype pollution vector.

The vulnerability is classified as CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes), reflecting that the root cause is prototype pollution combined with an insecure option merge pattern.

Exploitation Scenarios

No public PoC or exploit code is available for this CVE. The following attack chain is inferred from the vulnerability class and the NVD description.

1. Reconnaissance / Target Identification

   • Identify Node.js or browser applications that use axios versions 1.7.0 to < 1.20.0 with the fetch adapter enabled (e.g., in Node.js 18+ where fetch is global, or in browsers).
   • The attacker must also identify a prototype pollution vector in the same process. This could be a separate vulnerability in a dependency, a user-controlled JSON merge operation, or any code path that allows setting Object.prototype.headers.

2. Triggering the Specific Flaw Class

   • The attacker first exploits the prototype pollution flaw to set Object.prototype.headers to a malicious object. For example, setting it to { "X-Forwarded-For": "127.0.0.1", "Authorization": "Bearer attacker-token" } or similar attacker-controlled headers.
   • This pollution must occur in the same JavaScript process that runs the axios client. In Node.js, this typically means the same server process; in browsers, the same page context.

3. Payload / Execution Method

   • When the application subsequently makes an HTTP request via axios using the fetch adapter, axios constructs a Request with sanitized headers.
   • However, the adapter calls fetch(request, fetchOptions). The fetchOptions.headers property resolves through the prototype chain to the polluted Object.prototype.headers.
   • The fetch API uses the init object's headers to override the Request's headers, so the attacker's headers are sent instead of the intended sanitized ones.
   • The attacker does not need to directly interact with axios; any request made by the application after pollution will carry the malicious headers.

4. Post-Exploitation Impact

   • Authorization Bypass / Privilege Escalation: By injecting an Authorization header, the attacker may impersonate a privileged user or service, gaining unauthorized access to APIs.
   • Cache Poisoning: Manipulating Cache-Control or Vary headers could cause sensitive responses to be cached or served to unintended users.
   • Metadata Service Access: In cloud environments, injecting headers like Metadata-Flavor: Google or altering Host could allow access to instance metadata services (e.g., http://169.254.169.254), potentially leading to credential theft.
   • Application-Specific Behavior: Many applications use custom headers for routing, feature flags, or internal authentication. Overriding these can alter application logic in unexpected ways.

The attack is not remote by itself; it requires a same-process prototype pollution primitive. However, once that is achieved, the impact is high because the attacker can silently manipulate all outgoing HTTP requests from the affected axios client.

Impact Assessment

• Confidentiality: High. Attackers can exfiltrate sensitive data by redirecting requests to attacker-controlled endpoints or by injecting headers that bypass authentication to internal services.
• Integrity: High. Attackers can alter request semantics, leading to unauthorized actions, data modification, or cache poisoning.
• Availability: None. The vulnerability does not directly cause denial of service.
• CVSS v3.1 Score: N/A (not provided). Using the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N, the base score would be 7.4 (High). The high attack complexity (AC:H) reflects the prerequisite of a separate prototype pollution vector in the same process.
• Blast Radius: Any application using affected axios versions with the fetch adapter and a co-located prototype pollution flaw. This includes Node.js backends (especially serverless functions and microservices), Electron apps, and browser-based SPAs. The impact is limited to the process where pollution occurs, but in Node.js this often means the entire server instance.

Detection Guidance

Sigma Rule

title: Potential Axios Prototype Pollution Header Override
id: 3a7b8c9d-1e2f-4a5b-8c7d-9e0f1a2b3c4d
status: experimental
description: Detects attempts to pollute Object.prototype.headers in Node.js processes that may affect axios fetch adapter
author: Threat Intelligence
date: 2026-01-01
logsource:
  product: nodejs
  service: application
detection:
  selection:
    EventID: 'RuntimeException' # Placeholder for actual Node.js error logs
    Message|contains:
      - 'Object.prototype.headers'
      - 'fetchOptions.headers'
  condition: selection
falsepositives:
  - Legitimate debugging or development activity
level: high
tags:
  - attack.t1190
  - cve.2026.101908

YARA Rule

rule CVE_2026_101908_Axios_Prototype_Pollution
{
    meta:
        description = "Detects patterns indicative of axios fetch adapter header override via prototype pollution"
        author = "Threat Intelligence"
        date = "2026-01-01"
        reference = "CVE-2026-101908"
        severity = "high"
    strings:
        $s1 = "Object.prototype.headers" ascii wide nocase
        $s2 = "fetchOptions.headers" ascii wide nocase
        $s3 = "resolvedOptions" ascii wide nocase
        $s4 = "fetch(request" ascii wide nocase
    condition:
        any of them
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-101908 Axios Prototype Pollution Header Override Attempt"; flow:to_server; content:"Authorization"; http_header; content:"Bearer"; http_header; pcre:"/Object\.prototype\.headers/i"; sid:1000001; rev:1;)

Elastic Detection

process where process.name == "node" and
  (
    process.args : "*Object.prototype.headers*" or
    process.args : "*fetchOptions.headers*"
  )

Splunk SPL Query

index=nodejs_logs (Message="*Object.prototype.headers*" OR Message="*fetchOptions.headers*" OR Message="*resolvedOptions*")
| stats count by host, process, Message
| where count > 0

Wazuh OSSEC Rule

<group name="axios_cve_2026_101908,">
  <rule id="100001" level="12">
    <decoded_as>json</decoded_as>
    <field name="message">Object\.prototype\.headers|fetchOptions\.headers</field>
    <description>CVE-2026-101908: Potential axios prototype pollution header override detected</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). Although the NVD description states the issue is fixed in version 1.20.0, no patch source or vendor fix has been confirmed by tracked sources. Treat as unpatched until verified.

1. Immediate Mitigations

   • Update axios to version 1.20.0 or later as soon as possible, as this is the version that fixes the issue according to the NVD description. Verify the release and its integrity.
   • If immediate upgrade is not possible, avoid using the fetch adapter. Force axios to use the XHR adapter (in browsers) or the http adapter (in Node.js) by setting adapter: 'http' or adapter: 'xhr' in the axios configuration.
   • Prevent prototype pollution in the same process by hardening all code that merges user input into objects. Use Object.create(null) for configuration objects, freeze Object.prototype, and validate/sanitize all JSON inputs.
   • Monitor for and patch any known prototype pollution vulnerabilities in dependencies (e.g., via npm audit or SCA tools).

2. Patch/Upgrade Steps

   • Run npm install axios@1.20.0 or later.
   • Verify the installed version with npm list axios.
   • Review the axios changelog for the fix and ensure no regressions.
   • Re-deploy all affected services and applications.

3. Long-term Hardening

   • Implement a robust dependency management policy that includes automated vulnerability scanning and timely patching.
   • Adopt a defense-in-depth approach: never rely solely on a single library for security-critical header sanitization.
   • Use security linters and runtime application self-protection (RASP) to detect prototype pollution attempts.
   • Regularly test for prototype pollution vulnerabilities in your codebase, especially in any code that handles user-supplied JSON or query parameters.
   • Consider restricting outbound HTTP requests from application processes to known endpoints to limit the impact of header manipulation (e.g., blocking access to cloud metadata IPs at the network layer).

References

• NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2026-101908
• Axios GitHub Repository: https://github.com/axios/axios
• Axios Release v1.20.0: https://github.com/axios/axios/releases/tag/v1.20.0
• CWE-1321: https://cwe.mitre.org/data/definitions/1321.html
• OWASP Prototype Pollution: https://owasp.org/www-community/vulnerabilities/Prototype_Pollution

No known threat actor campaigns or exploit-in-the-wild evidence have been observed for this CVE as of the report date.