CVE-2026-101904

Executive Summary

CVE-2026-101904 is a prototype-pollution–facilitated request-header injection vulnerability in Axios, a promise-based HTTP client widely used across browser and Node.js applications. Affected versions are 1.0.0 through 1.20.0, where the dispatchRequest function normalizes inherited Object.prototype.headers from a replacement request configuration, allowing attacker-controlled headers — including authorization-related values — to be injected when a separate same-process prototype-pollution flaw has already set Object.prototype.headers and a trusted interceptor returns a new plain configuration without its own headers property. The impact is integrity and confidentiality loss on outbound requests: malicious headers may be observed downstream by the target server or intermediaries, potentially leading to credential/authorization abuse or request forgery against downstream services.

Technical Analysis

The vulnerability is rooted in the interaction between Axios's request-interceptor pipeline and JavaScript's prototype-inheritance semantics. The NVD description states that, from version 1.0.0 until 1.20.0, the dispatchRequest function normalizes inherited Object.prototype.headers from a replacement request configuration.

The mechanism requires two conditions to co-occur in the same process:

1. A separate same-process prototype-pollution flaw must already have set Object.prototype.headers. This means an attacker (or a chained vulnerability elsewhere in the application) must first gain the ability to assign to Object.prototype.headers. On its own, this CVE does not describe how that pollution is achieved — it is explicitly described as a "separate" flaw. This is important: CVE-2026-101904 is the consumer of a polluted prototype, not necessarily the pollution primitive.

2. A trusted request interceptor returns a new ordinary configuration without an own headers property. When this happens, the replacement config does not shadow the polluted prototype. Because headers is not an own property of the returned object, property lookup walks the prototype chain and resolves to the attacker-influenced Object.prototype.headers.

After the interceptor chain completes, dispatchRequest resolves those inherited headers "during normalization." The normalization step therefore folds attacker-controlled header values into the effective request configuration. Downstream request processing — the transport layer that ultimately emits the HTTP request — then observes attacker-controlled headers, explicitly including "authorization-related values."

The CWE classification is CWE-74 (Improper Neutralization of Special Elements in Output Used by a Downstream Component, i.e., injection). This framing is accurate: the polluted prototype supplies data that is not neutralized before being consumed by a downstream component (the HTTP transport), resulting in injection of attacker-chosen headers.

Key technical characteristics:

• Attack surface: Any Axios request path that passes through an interceptor which constructs a fresh config object lacking an own headers property, in a runtime where Object.prototype.headers has been polluted.
• Preconditions: Same-process prototype pollution. The attacker must control or influence a property-assignment sink elsewhere in the application or its dependency tree.
• Effect: Header injection into outbound requests, including authorization-related header values.
• Scope: The flaw is described as spanning both browser and Node.js environments ("a promise-based HTTP client for the browser and Node.js"), so both client-side and server-side Axios usage may be affected, though the practical prototype-pollution prerequisite differs by environment.
• Fix: Version 1.20.0 resolves the issue by (per the description) no longer resolving inherited Object.prototype.headers in dispatchRequest during normalization.

No public proof-of-concept, exploit code, or Nuclei template was identified in the supplied data. Insufficient technical detail is available to specify the exact code change made in 1.20.0 beyond the statement that the inherited-headers resolution behavior was fixed.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred strictly from the vulnerability class described in the NVD entry.

1. Reconnaissance / target identification. The attacker identifies an application or Node.js service that uses Axios versions 1.0.0–1.20.0 and that also exposes a same-process prototype-pollution vector. Because the CVE description references a "separate same-process prototype-pollution flaw," identification hinges on finding a second vulnerability capable of writing Object.prototype.headers.

2. Triggering the flaw class. The attacker exploits the separate prototype-pollution flaw to set Object.prototype.headers to attacker-chosen header values in the target process.

3. Reaching the vulnerable normalization path. A trusted request interceptor, which the application relies upon, returns a new ordinary configuration object that has no own headers property. Axios's dispatchRequest then normalizes the request configuration and, per the description, resolves the inherited Object.prototype.headers value.

4. Execution / payload delivery at the vulnerability-class level. Because the injected headers include authorization-related values, the outbound request carries attacker-controlled header data that downstream request processing observes. This can result in the injection of unauthorized header content into requests the application legitimately makes.

5. Post-exploitation impact. The attacker-influenced headers may be consumed by the destination server or an intermediary, enabling unauthorized access, impersonation, or manipulation of request semantics. The description emphasizes confidentiality and integrity effects on outbound requests; no code-execution or persistence outcome is described.

Impact Assessment

The primary impact is to outbound request integrity and confidentiality. An attacker who first achieves same-process prototype pollution can leverage CVE-2026-101904 to inject headers — including authorization-related values — into requests emitted by an affected Axios instance. This can undermine authentication and authorization decisions at downstream services that trust those headers, or leak/manipulate request metadata.

An inferred CVSS v3.1 vector of CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N reflects: network attack vector; High attack complexity (because a separate prototype-pollution precondition must be met); no privileges required once that precondition is established; no user interaction; unchanged scope; and high confidentiality and integrity impact from header/authorization tampering. Availability impact is not implied. The official CVSS score is not provided (N/A), so no numeric severity should be attributed.

Blast radius: every application, service, or SSR workload that embeds Axios 1.0.0–1.20.0 and contains a usable prototype-pollution sink. Because Axios is a transitive dependency of countless tools and SDKs, exposure may be much broader than direct dependents realize. The requirement for a second in-process primitive constrains realistic exploitation, but in large Node.js applications where user input reaches unsafe object-merge or deserialization paths, this precondition is frequently satisfiable.

Detection Guidance

Sigma Rule

title: Potential Axios Prototype-Pollution Header Injection (CVE-2026-101904)
id: 8f2c1a44-7b91-4e6a-9c3d-axios-pollution-1019
status: experimental
description: Detects outbound requests or runtime indicators consistent with Object.prototype.headers pollution resolved by Axios dispatchRequest in versions 1.0.0-1.20.0.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-101904
author: valtersit.com
date: 2026/01/01
logsource:
  category: process_creation
  product: linux
detection:
  selection_runtime:
    Image|endswith:
      - '/node'
      - '/nodejs'
    CommandLine|contains:
      - 'Object.prototype.headers'
  selection_proc:
    CommandLine|contains:
      - 'dispatchRequest'
      - 'prototype.headers'
  condition: selection_runtime or selection_proc
falsepositives:
  - Developers debugging prototype behavior
  - Security test tooling in non-production environments
level: medium
tags:
  - attack.t1190
  - cve.2026.101904

YARA Rule

rule CVE_2026_101904_Axios_Prototype_Headers
{
    meta:
        description = "Detects references to Object.prototype.headers normalization tied to CVE-2026-101904 in Axios-related JavaScript."
        author = "valtersit.com"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-101904"
        date = "2026-01-01"
        severity = "medium"

    strings:
        $a = "dispatchRequest"
        $b = "Object.prototype.headers"
        $c = "prototype.headers"
        $d = "axios" nocase

    condition:
        uint32(0) != 0x504b0304 and
        filesize < 2MB and
        (($a and ($b or $c)) or ($d and ($b or $c)))
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-101904 Axios Inherited Headers Prototype Pollution Indicator"; flow:established,to_server; http.header; content:"authorization"; nocase; content:"prototype"; nocase; pcre:"/x-prototype|__proto__/iH"; classtype:attempted-admin; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-101904; sid:2026101904; rev:1;)

Elastic Detection

process where event.type == "start" and
  process.name in ("node", "nodejs") and
  (process.command_line : "*Object.prototype.headers*" or
   process.command_line : "*dispatchRequest*" or
   process.command_line : "*prototype.headers*")

Splunk SPL Query

index=app_logs OR index=proxy_logs (sourcetype=nodejs OR sourcetype=web)
| search ("Object.prototype.headers" OR "dispatchRequest" OR "prototype pollution" OR "__proto__")
| stats count min(_time) as first_seen max(_time) as last_seen by host, process, src_ip, dest_host
| where count > 0
| sort - count

Wazuh OSSEC Rule

<group name="axios,cve-2026-101904,">
  <rule id="101904" level="10">
    <decoded_as>json</decoded_as>
    <field name="message">Object.prototype.headers</field>
    <description>CVE-2026-101904: Possible Axios prototype headers pollution resolved in dispatchRequest</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>prototype_pollution,header_injection,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). No vendor fix or workaround was supplied in the available data; the NVD description states the issue is fixed in version 1.20.0, but no advisory URL, commit hash, or release artifact was provided to verify. Treat remediation as unverified until independently confirmed against the upstream project.

1. Immediate mitigations

   • Inventory Axios usage across direct and transitive dependencies; identify any instance pinned to 1.0.0–1.20.0.
   • Eliminate same-process prototype-pollution sinks. Since the CVE requires a separate pollution primitive, hardening object-merge, deep-clone, and deserialization paths against keys such as __proto__, constructor, and prototype directly reduces exploitability.
   • Freeze or seal critical prototypes where feasible (e.g., Object.freeze(Object.prototype)) in controlled environments, and run Node.js with --disable-proto=throw to block __proto__ assignment.
   • Ensure request interceptors that return replacement configurations always construct objects with an own headers property (e.g., via Object.create(null) or explicit headers assignment) so inherited pollution cannot be resolved.

2. Patch / upgrade steps

   • Upgrade Axios to 1.20.0 or later as stated in the NVD description. Because confidence is 0/4, verify the fix is present in the published artifact and re-scan after upgrading.
   • Rebuild lockfiles so transitive dependents pull the corrected version; audit any fork or vendored copy of Axios.
   • Regression-test interceptor chains after upgrading, confirming that header handling no longer resolves inherited properties.

3. Long-term hardening

   • Adopt dependency SBOM and continuous CVE scanning to catch transitive Axios exposure.
   • Enforce allowlists for outbound HTTP headers and validate authorization headers at the transport boundary.
   • Add static-analysis rules flagging prototype-inherited property access in request-configuration handling.
   • Track upstream Axios releases and the NVD entry for an authoritative patch reference to raise patch confidence above 0/4.

References

• NVD — CVE-2026-101904: https://nvd.nist.gov/vuln/detail/CVE-2026-101904
• Axios project (upstream source/releases): https://github.com/axios/axios
• MITRE CWE-74 — Improper Neutralization in Downstream Components: https://cwe.mitre.org/data/definitions/74.html
• MITRE ATT&CK T1190 — Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
• FIRST EPSS — not yet scored for this CVE; no exploit-in-the-wild evidence or named threat-actor campaign was present in the provided data.