CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-76504

CVE-2026-76504: Unauthenticated Authentication Bypass in Cisco Catalyst SD-WAN Manager

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 1, 2026·7 min read·132 visits

Executive Summary (TL;DR)

An unauthenticated remote authentication bypass vulnerability in Cisco Catalyst SD-WAN Manager allows attackers to perform administrative actions with root-level privileges by exploiting inconsistency in URI hex/percent-encoding handling across web application layers.

CVE-2026-76504 is a critical vulnerability in the web-based management console of Cisco Catalyst SD-WAN Manager. Due to improper normalization and handling of hex/percent-encoded sequences (CWE-177) within incoming request URIs, remote, unauthenticated attackers can bypass administrative authentication controls. Successful exploitation permits full remote administrative command execution on the SD-WAN management plane, threatening the integrity and availability of the managed network fabric.

Vulnerability Overview

Cisco Catalyst SD-WAN Manager (formerly vManage) serves as the centralized management and orchestration plane for SD-WAN architectures. It is responsible for provisioning, configuring, and monitoring WAN Edge routers and overall overlay topology. This central role exposes a significant web interface attack surface, which hosts administrative REST APIs for deep orchestration and troubleshooting tasks.

The vulnerability, tracked as CVE-2026-76504, lies in the authentication and authorization middleware responsible for verifying request credentials. By crafting specific request paths containing hex-encoded sequences, an unauthenticated attacker can manipulate the path-routing logic. This causes the security filter to identify a restricted administrative API endpoint as a publicly accessible, non-authenticated resource.

The impact is rated with the maximum CVSSv3.1 score of 9.8 (Critical). Successful exploitation yields complete control of the administrative console. Because the SD-WAN Manager orchestrates the enterprise-wide network topology, compromising this system allows attackers to intercept, redirect, or disrupt transit traffic across the entire enterprise WAN overlay.

Root Cause Analysis

The fundamental flaw driving CVE-2026-76504 is a parser differential vulnerability falling under CWE-177: Improper Handling of URL Encoding. The issue arises from mismatched URI parsing logic between the front-end authentication routing filter and the back-end application controller servlet engine.

In standard operation, the authentication filter intercepts incoming HTTP requests and matches the requested path against an access control list (ACL). This ACL defines public endpoints (e.g., login pages or public asset directories) and protected resources (such as /dataservice/ paths). When analyzing the incoming path, the filter checks the string in its raw or partially decoded state. It fails to normalize hex-encoded characters (like %2f for slashes, %252f for double-encoded slashes, or relative path traversal sequences like %2e%2e%2f). Consequently, the filter evaluates a URI containing these encoded values literally and fails to match it against any protected path patterns. This leads the filter to conclude the request is aimed at a public endpoint and waive authentication requirements.

Following the authentication check, the request is forwarded to the backend API router. This component undergoes complete normalization, decoding all hex-encoded variables (e.g., transforming %2f back into a / directory separator). Because the security tier has already flagged the request session as validated or authentication-waived, the backend processes the newly decoded, high-privilege API path directly. The request executes with administrative system privileges because no session credentials were bound to the authenticated-by-default container context.

Code Analysis

To understand the implementation flaw, we can analyze the differential behavior between the vulnerable authentication filter and the backend parser logic. In the vulnerable implementation, the application relies on standard servlet URI retrieval helper methods without enforcing strict normalization.

// VULNERABLE COMPONENT: AuthenticationFilter.java
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
        throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    // Retrieve the raw request URI without decoding/normalization
    String requestURI = httpRequest.getRequestURI(); 
 
    // The check fails to normalize percent-encoded sequences like %2f or %2e%2e%2f
    if (isPublicEndpoint(requestURI)) {
        // Request bypasses the authentication validation routine
        chain.doFilter(request, response); 
        return;
    }
    
    // Standard session validation occurs here for matched protected endpoints
    validateSession(httpRequest);
}
// PATCHED COMPONENT: AuthenticationFilter.java
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
        throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    
    // Secure Implementation: Canonicalize, decode, and normalize the URI before evaluation
    String normalizedURI = canonicalizeAndNormalizeURI(httpRequest.getRequestURI());
 
    if (isPublicEndpoint(normalizedURI)) {
        chain.doFilter(request, response);
        return;
    }
 
    validateSession(httpRequest);
}
 
private String canonicalizeAndNormalizeURI(String inputUri) {
    if (inputUri == null) return "";
    // 1. Perform URL decoding to resolve all percent/hex encodings
    String decoded = URLDecoder.decode(inputUri, StandardCharsets.UTF_8);
    // 2. Perform secondary decoding to handle double-encoded characters (%252f)
    decoded = URLDecoder.decode(decoded, StandardCharsets.UTF_8);
    // 3. Normalize relative path traversals (e.g., resolving "/..//" and trailing characters)
    return Paths.get(decoded).normalize().toString().replace("\\", "/");
}

This patch closes the parsing gap by ensuring both the security check and the backend router operate on the exact same canonical representation of the URI. Relative path segments and double-encoded sequences are resolved before any rule matches run, removing the bypass vector.

Exploitation Methodology

Exploitation of CVE-2026-76504 requires minimal configuration and no prior authentication credentials. The attacker crafts a unified HTTP request that routes through the vulnerable gateway.

The target endpoint is typically a sensitive REST API designed to accept CLI execution parameters or system diagnostic requests. Attackers construct the URI using an accepted public path prefix combined with a traversing sequence containing percent-encoded slashes. An example of a normalized logical path mapping is shown below:

https://<SD-WAN-Manager>/public-endpoint/..%2fdataservice/system/device/command

When the front-end routing rule processes the request, the URI is deemed a sub-resource of /public-endpoint and the authentication requirements are waived. Once past the filter, the back-end application decodes the request path, translating %2f back to / and resolving the relative parent directory sequence (..). The resolved request is treated as a high-privilege REST command executing under the administrative system context. The following execution parameters are representative of commands observed during scanning and active abuse:

# Attacker attempts to dump running configuration
curl -k -X POST "https://manager.example.com/public/..%2fdataservice/system/device/command" \
     -H "Content-Type: application/json" \
     -d '{"command": "show running-config"}'

Beyond simple reconnaissance and active credential extraction, threat actors can weaponize this path-traversal flaw to initiate destructive management actions such as executing database commands or executing device-level restarts.

Impact Assessment

A successful compromise of the Cisco Catalyst SD-WAN Manager represents a complete failure of confidentiality, integrity, and availability within the SD-WAN fabric. Because the management plane controls the control-plane keys, security policies, and WAN Edge router routing tables, an attacker holding administrative access to this system can completely control corporate network paths.

Attackers can leverage this position to inject routing configurations designed to intercept or mirror enterprise site-to-site communication, bypassing transport encryption security guarantees. In addition, access to SD-WAN Manager enables configuration manipulation on all downstream edge devices. This can lock out legitimate administrators, wipe operational configurations, and render physical and virtual networking endpoints offline.

The inclusion of this vulnerability in the CISA Known Exploited Vulnerabilities (KEV) Catalog highlights that exploitation is actively occurring in wild scenarios. A three-day binding remediation window was mandated, illustrating the extreme operational risk posed by unpatched management interfaces.

Remediation and Mitigation

There are no official, viable long-term workarounds for CVE-2026-76504. Organizations must apply official vendor-supplied patches immediately to ensure remediation. Security administrators must identify running software versions and transition them to the corresponding fixed releases.

If immediate patch application is impossible due to change control constraints, temporary mitigations must focus on restricting the physical attack surface:

  1. Network Access Control Lists (ACLs): Restrict access to the Catalyst SD-WAN Manager web-based user interface to verified management IP addresses. External internet exposure must be disabled entirely.

  2. VPN and Bastion Architectures: Place the SD-WAN Manager interface behind an authenticated VPN or bastion system, ensuring that attackers must authenticate at the network edge before interacting with the vulnerable web interface.

Following patch deployment, incident response teams must audit historical log repositories for signs of active exploitation. Specifically, inspect access logs for abnormal requests containing percent-encoded path traversal sequences targeting the HTTP interfaces of the system.

Official Patches

CiscoOfficial Cisco Security Advisory for Catalyst SD-WAN Manager Authenticated API Access Flaw.

Technical Appendix

CVSS Score
9.8/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
EPSS Probability
1.10%
Top 36% most exploited
1,200
via Shodan

Affected Systems

Cisco Catalyst SD-WAN Manager (formerly vManage)

Affected Versions Detail

Product
Affected Versions
Fixed Version
Catalyst SD-WAN Manager
Cisco
< 20.9.10.120.9.10.1
Catalyst SD-WAN Manager
Cisco
>= 20.12.0.0, < 20.12.8.220.12.8.2
Catalyst SD-WAN Manager
Cisco
>= 20.15.0.0, < 20.15.6.120.15.6.1
Catalyst SD-WAN Manager
Cisco
>= 20.18.0.0, < 20.18.4.120.18.4.1
Catalyst SD-WAN Manager
Cisco
>= 26.1.0.0, < 26.1.2.126.1.2.1
Catalyst SD-WAN Manager
Cisco
>= 26.2.0.0, < 26.2.126.2.1
AttributeDetail
CWE IDCWE-177 (Improper Handling of URL Encoding)
Attack VectorNetwork (AV:N)
CVSS v3.1 Score9.8
Exploit Statusactive
CISA KEV ListedYes (Added September 30, 2026)
ImpactComplete administrative compromise of SD-WAN management interface

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1548Abuse Elevation Control Mechanism
Privilege Escalation
T1211Exploitation for Defense Evasion
Defense Evasion
CWE-177
Improper Handling of URL Encoding (Hex Encoding)

The software does not properly parse, decode, or normalize URL-encoded/hex-encoded characters, leading to inconsistencies across system endpoints.

Known Exploits & Detection

ShadowForge Cyber PoC RepositoryExploit verification script and public vulnerability analysis framework detailing target analysis features and command-line execution structures.

Vulnerability Timeline

Cisco Security Advisory cisco-sa-sdwan-webauth-xr8beuuU is released, addressing CVE-2026-76504.
2026-09-30
CISA adds CVE-2026-76504 to the Known Exploited Vulnerabilities (KEV) Catalog.
2026-09-30
ShadowForge Cyber publishes full vulnerability analysis details and a proof-of-concept repository structure.
2026-09-30
CISA KEV binding update deadline for Federal Civilian Executive Branch agencies.
2026-10-03

References & Sources

  • [1]Cisco Security Advisory: Cisco Catalyst SD-WAN Manager Authentication Bypass Vulnerability
  • [2]CISA KEV Catalog Reference for CVE-2026-76504
  • [3]CVE-2026-76504 on CVE.org
  • [4]NVD Vulnerability Details for CVE-2026-76504
  • [5]ShadowForge Cyber Exploit Verification Repository
  • [6]ShadowForge Cyber Vulnerability Verification Documentation

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.

Amit Schendel
Amit Schendel
6 views•10 min read
•1 day ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.

Amit Schendel
Amit Schendel
7 views•11 min read
•1 day ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.

Alon Barad
Alon Barad
7 views•10 min read
•1 day ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.

Amit Schendel
Amit Schendel
7 views•10 min read
•1 day ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.

Alon Barad
Alon Barad
8 views•11 min read
•1 day ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.

Alon Barad
Alon Barad
7 views•9 min read