CVE-2026-101905

Executive Summary

CVE-2026-101905 is a transport-endpoint selection vulnerability in the Axios Node HTTP adapter (lib/adapters/http.js) present from version 1.15.2 until version 1.20.0. A separate same-process prototype-pollution flaw places an attacker-controlled function on Object.prototype.createConnection, which Node.js then resolves and invokes because Axios supplies request options without an own createConnection value. Any Node.js application using the affected Axios versions within a process that is exposed to prototype pollution can have outbound HTTP request headers and bodies, including credentials, redirected to an attacker-controlled endpoint while the response appears to originate from the legitimate URL.

Technical Analysis

The vulnerability resides in the interaction between two independent conditions that must both be satisfied within the same Node.js process.

The first condition is a prototype-pollution flaw that writes a function onto Object.prototype.createConnection. The NVD description attributes this as a "separate same-process prototype-pollution flaw" and does not specify its origin; no source component, package, or code path for that pollution is identified in the available data. Analysts should treat the pollution primitive as an external precondition rather than a defect inside Axios itself.

The second condition is the behavior of the Axios Node HTTP adapter. According to the description, from 1.15.2 until 1.20.0, lib/adapters/http.js supplies request options without an own createConnection value. Because the options object does not define its own createConnection property, Node.js falls back to the prototype chain when resolving the property and finds Object.prototype.createConnection — the polluted value. Node.js then resolves and invokes the inherited createConnection socket factory. This is the mechanism described by CWE-441 (Unintended Proxy or Intermediary), where a component ends up communicating through an unintended transport controlled by another party.

The security consequence of the inherited socket factory being attacker-controlled is that the attacker-controlled function "select the transport endpoint." The description states that the attacker endpoint can then receive request headers and bodies, including credentials, and return attacker-controlled responses while the URL appears legitimate. This is a man-in-the-middle–style outcome achieved locally via property resolution rather than via network position or TLS interception — the request destination is chosen by the polluted function, and any response it returns is presented to the calling application as though it came from the requested URL.

Key limitations of what is known: no CVSS score or vector has been assigned, the vulnerability is not in CISA KEV, no EPSS score exists, no public PoC, Nuclei template, or exploit code is available, and no affected OSV packages or explicit affected-version list has been published beyond the "from 1.15.2 until 1.20.0" statement. The patch is the release of Axios 1.20.0.

Because exploitation requires a pre-existing prototype-pollution primitive in the same process, this is not remotely triggerable against Axios in isolation. The attack surface is therefore Node.js server-side applications that (a) run an affected Axios version and (b) are exposed to a prototype-pollution vector elsewhere in their dependency tree or application logic.

Exploitation Scenarios

No public PoC is available. The following chain is described at the vulnerability-class level strictly from the NVD description.

1. Reconnaissance / target identification. The attacker identifies a Node.js application that uses Axios in the range 1.15.2 through 1.19.x for outbound HTTP requests (for example, API integrations, webhook delivery, authentication to internal or third-party services), and that also processes attacker-influenced input capable of reaching a prototype-pollution flaw in the same process.

2. Triggering the flaw class. The attacker first exercises the separate prototype-pollution vulnerability to place a function on Object.prototype.createConnection. The description does not identify the specific pollution vector, so the exact input path is unknown from the available data.

3. Payload / execution. On a subsequent Axios HTTP request, the Node HTTP adapter in lib/adapters/http.js passes request options that contain no own createConnection property. Node.js resolves createConnection through the prototype chain, finds the inherited attacker function, and invokes it as the socket factory. The factory selects the transport endpoint, directing the connection to infrastructure controlled by the attacker instead of the intended host.

4. Post-exploitation impact. The attacker endpoint receives the request headers and body — which may include credentials — and can return attacker-controlled responses. Because the URL presented to the application still appears legitimate, the application consumes forged responses as if they came from the real destination, enabling credential theft, response manipulation, and downstream business-logic abuse.

Impact Assessment

The primary impact categories implied by the description are confidentiality loss (headers and request bodies, including credentials, are delivered to the attacker endpoint) and integrity loss (attacker-controlled responses are returned to the application while the URL appears legitimate). Availability impact is not described.

Blast radius is bounded by two factors: the application must run an affected Axios version, and the process must already be susceptible to prototype pollution. Where both hold, every outbound Axios request in that process is potentially redirectable, which can be significant in services that use Axios for authentication, payment, or internal API calls.

No CVSS score or vector has been assigned, so no numeric subscore assessment can be provided. The vulnerability is not listed in CISA KEV, has no EPSS score, and no exploit-in-the-wild evidence is available in the provided data. The absence of a score should not be read as low severity; it reflects that scoring has not been published.

Detection Guidance

Sigma Rule

title: Potential Axios createConnection Prototype Pollution Transport Hijack
id: 8f2c1a44-7b3e-4d19-9c2a-axios101905
status: experimental
description: Detects prototype pollution of Object.prototype.createConnection in a Node.js process, the precondition for CVE-2026-101905 transport hijacking in Axios.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-101905
author: valtersit.com
date: 2026/01/01
logsource:
  product: linux
  category: process_creation
detection:
  keywords:
    - 'createConnection'
    - '__proto__'
    - 'constructor.prototype'
  condition: keywords
falsepositives:
  - Legitimate Node.js libraries referencing createConnection
level: medium
tags:
  - attack.t1190
  - cwe.441

YARA Rule

rule CVE_2026_101905_Axios_CreateConnection_Hijack
{
    meta:
        description = "Detects prototype pollution of createConnection associated with CVE-2026-101905 in Axios Node HTTP adapter"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-101905"
        author = "valtersit.com"
        date = "2026-01-01"
        severity = "medium"

    strings:
        $axios = "lib/adapters/http.js" ascii
        $cc    = "createConnection" ascii
        $proto1 = "__proto__" ascii
        $proto2 = "constructor.prototype" ascii
        $objpr = "Object.prototype" ascii

    condition:
        uint32(0) == 0x04034b50 or
        ($cc and $proto1 and any of ($objpr, $proto2)) or
        ($axios and $cc and any of ($proto1, $proto2, $objpr))
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-101905 Axios createConnection Prototype Pollution Transport Hijack Indicator"; flow:to_server,established; content:"createConnection"; http_header; nocase; content:"__proto__"; http_header; nocase; reference:cve,2026-101905; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-101905; classtype:attempted-recon; sid:2026101905; rev:1;)

Elastic Detection

process where process.name == "node" and process.command_line : ("createConnection", "__proto__", "constructor.prototype")

Splunk SPL Query

index=nodejs OR index=app_logs sourcetype IN ("nodejs","node:js","application")
(createConnection OR "__proto__" OR "constructor.prototype" OR "lib/adapters/http.js")
| stats count min(_time) as first_seen max(_time) as last_seen
        values(host) as hosts values(user) as users
  by source, sourcetype
| where count > 0

Wazuh OSSEC Rule

<group name="axios,cve-2026-101905,">
  <rule id="101905" level="10">
    <decoded_as>json</decoded_as>
    <field name="message">createConnection</field>
    <description>CVE-2026-101905: Possible Axios createConnection prototype pollution / transport hijack</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>cwe_441,</group>
  </rule>
  <rule id="101906" level="10">
    <decoded_as>json</decoded_as>
    <field name="message">__proto__</field>
    <description>CVE-2026-101905: Prototype pollution indicator in Node.js process log</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 — UNPATCHED. No patch evidence from any tracked source; no vendor fix advisory, affected-version list, or workaround has been published beyond the statement that the issue is fixed in version 1.20.0.

1. Immediate mitigations

• Upgrade Axios to version 1.20.0 or later, the version identified as containing the fix.
• Treat prototype pollution as a first-class risk: audit application code and dependencies that accept structured input and assign properties to objects, and apply input validation and prototype-free object handling (for example, rejecting or stripping proto, constructor, and prototype keys in parsed input).
• Reduce exposure of outbound Axios traffic to credential-bearing flows in processes that accept untrusted input.
• Monitor process logs and dependency manifests for pollution indicators correlated with subsequent outbound requests.

2. Patch / upgrade steps

• Identify all Node.js services and lockfiles that resolve Axios versions 1.15.2 through 1.19.x.
• Pin Axios to 1.20.0 or later in package.json and regenerate lockfiles; rebuild and redeploy affected services.
• Re-scan transitive dependencies for the separate prototype-pollution component; the description does not name it, so its remediation must be handled independently.

3. Long-term hardening

• Add dependency and SCA scanning that flags prototype-pollution patterns in the Node.js supply chain.
• Enforce strict own-property checks and hardened object creation in application input handling.
• Maintain an inventory of outbound HTTP clients per service so transport-level changes are detectable.
• Track NVD and the Axios project for a CVE score assignment and any further advisory.

References

• NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-101905
• Axios project repository and release notes for version 1.20.0
• CWE-441 — Unintended Proxy or Intermediary: https://cwe.mitre.org/data/definitions/441.html
• CISA KEV catalog: not listed (https://www.cisa.gov/known-exploited-vulnerabilities-catalog)
• FIRST EPSS: no score currently assigned (https://www.first.org/epss/)