Sep 28, 2026·4 min read·161 visits
A critical vulnerability in Cisco ISE (CVSS 10.0) allows remote, unauthenticated attackers to bypass authentication and gain full administrative control via crafted API requests.
On September 16, 2026, Cisco disclosed a critical authentication bypass vulnerability affecting Cisco Identity Services Engine (ISE) and Cisco ISE Passive Identity Connector (ISE-PIC). This vulnerability allows unauthenticated, remote attackers to bypass the administrative interface controls and execute privileged API requests. Due to active exploitation in the wild, the Cybersecurity and Infrastructure Security Agency (CISA) added this vulnerability to the Known Exploited Vulnerabilities (KEV) Catalog with an immediate remediation deadline.
CVE-2026-76460 is an authentication bypass vulnerability affecting Cisco Identity Services Engine (ISE) and Cisco ISE Passive Identity Connector (ISE-PIC). The vulnerability resides in the application's administrative API endpoints. It allows network-based, unauthenticated attackers to perform privileged operations.
Under normal operations, administrative functions are protected by robust session verification controls. However, due to routing configuration errors, specific API endpoints do not enforce authorization verification. This permits external entities to access critical database and configuration pathways.
Cisco ISE serves as an enterprise network access control policy platform. A compromise of this service exposes internal network policy configurations, active authentication sessions, and identity store credentials.
The root cause of the vulnerability is a logical failure in the routing and authorization infrastructure (CWE-648). The application uses a central API gateway middleware to inspect incoming HTTP traffic and evaluate tokens or session identifiers. However, specific administrative API endpoints were mapped outside of these central protection filters.
This configuration omission allows incoming HTTP requests targeting /api/v1/management/ paths to proceed directly to the backend controller without token interrogation. Because the backend controller relies entirely on the gateway layer to perform authentication, it processes these requests as pre-authorized.
As a consequence of this trust assumption, the controller executes the associated administrative queries and returns sensitive response payloads directly to unauthenticated clients.
Analysis of the routing mechanics highlights the difference between vulnerable routing configurations and secure implementations. In the vulnerable configuration, routing patterns for administrative API endpoints are evaluated without enforcing bearer token validation.
Consider the vulnerable endpoint pattern representing this routing flow:
# Vulnerable Endpoint Definition
@app.route("/api/management/users", methods=["GET"])
def management_users():
# Vulnerability: The controller executes queries without verifying authorization
logger = app.config["AUDIT_LOGGER"]
if app.config.get("MODE") == "vulnerable":
logger.warning("unauthenticated access granted to management_users")
return jsonify({"users": USERS, "warning": "unauthenticated access allowed"})In the patched implementation, explicit token validation is implemented at the controller level as a secondary defense layer:
# Patched Endpoint Definition
@app.route("/api/management/users", methods=["GET"])
def management_users():
logger = app.config["AUDIT_LOGGER"]
token = request.headers.get("Authorization", "")
# Strict validation of bearer token presence
if not token.startswith("Bearer "):
logger.warning("authorization failed: missing or malformed bearer token")
return jsonify({"error": "authentication required"}), 401
token_value = token.split(" ", 1)[1]
identity = require_auth(token_value, session_tokens)
# Verification of cryptographic validity
if not identity:
logger.warning("authorization failed: invalid token")
return jsonify({"error": "invalid token"}), 401
return jsonify({"users": USERS})Exploitation of CVE-2026-76460 requires direct network access to the administrative port of Cisco ISE. Attackers identify exposed instances by scanning for standard web service ports, typically HTTPS on port 443.
Once identified, the attacker transmits a crafted HTTP GET request directly to the vulnerable administrative endpoints. Because the endpoint does not challenge the client, the application processes the action and responds with data, which may include user accounts, system configuration databases, and active session tokens.
The retrieved information allows the attacker to compromise associated sessions or construct local administrative profiles within the ISE system.
Successful exploitation of CVE-2026-76460 enables unauthenticated remote code execution equivalent access over the Cisco ISE administrative system. Attackers gain the ability to manipulate internal database assets, modify network security policies, and deploy unauthorized access roles.
The vulnerability facilitates lateral movement within the enterprise environment. By controlling Cisco ISE, the attacker can authorize unauthorized network connections and compromise domain services linked to the identity infrastructure.
The maximum CVSS score of 10.0 reflects the low attack complexity, lack of privilege requirements, and severe potential consequences on the confidentiality, integrity, and availability of critical network assets.
There are no temporary workarounds that address this vulnerability. Organizations must apply official patches issued by Cisco to resolve the underlying logical routing flaws on affected nodes.
To detect potential exploitation attempts, security personnel should audit administrative web server logs. Analyze the logs for successful HTTP 200 OK responses on /api/management/ paths that do not possess associated Authorization headers or valid session cookies.
Additionally, restrict network-level administrative access to Cisco ISE consoles, exposing them only to trusted subnet ranges and internal management VPNs.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Cisco Identity Services Engine (ISE) Software Cisco | 3.1.0 <= Patch 11 | 3.1.0 Patch 12 |
Cisco Identity Services Engine (ISE) Software Cisco | 3.2.0 <= Patch 10 | 3.2.0 Patch 11 |
Cisco Identity Services Engine (ISE) Software Cisco | 3.3.0 <= Patch 11 | 3.3.0 Patch 12 |
Cisco Identity Services Engine (ISE) Software Cisco | 3.4.0 <= Patch 6 | 3.4.0 Patch 7 |
Cisco Identity Services Engine (ISE) Software Cisco | 3.5.0 <= Patch 3 | 3.5.0 Patch 4 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-648 |
| Attack Vector | Network |
| CVSS Severity | 10.0 (Critical) |
| EPSS Score | 0.14026 |
| Exploit Status | Active Exploitation in the Wild |
| CISA KEV Status | Listed |
The application exposes administrative or privileged capabilities through its API endpoint interface without properly verifying that the calling entity possesses valid credentials.
pgEdge RAG Server versions prior to 2.0.0 contain a race condition in the hybrid search pipeline orchestrator (CWE-362, CWE-488). The server maintains a single shared, in-memory BM25 index instance across all incoming HTTP requests on a pipeline. Concurrent queries to the unauthenticated HTTP REST API interleave non-atomic clear, document addition, and search operations on this singleton index. As a result, documents fetched using one caller's search filter can be queried and returned to another concurrent caller, bypassing multi-tenant data isolation without generating any anomalous audit trail in server or database logs.
CVE-2026-118740 is a Missing Authorization (CWE-862) vulnerability in the Microsoft Aspire Dashboard and Aspire.Dashboard.Sdk.linux-x64 packages. In versions 13.6.1 prior to 13.6.5, an architectural flaw in the Blazor routing configuration (Routes.razor) causes unmapped (404 / Not-Found) routes to bypass the AuthorizeRouteView component. By navigating to an arbitrary non-existent route, an unauthenticated remote attacker forces the application into the NotFound template, which unconditionally renders the primary MainLayout component and initializes global user interface services, interaction providers, and underlying SignalR/Blazor circuits without verifying authentication credentials.
An elevation of privilege vulnerability exists in .NET Aspire versions prior to 13.6.5 due to the insertion of sensitive information into sent data (CWE-201). When the Developer Control Plane (DCP) container tunneling feature is enabled, the orchestration engine implicitly exposes all endpoints of the Aspire Dashboard—including its administrative frontend and management APIs—to containerized workloads instead of restricting tunnel access solely to OpenTelemetry Protocol (OTLP) collection endpoints. This exposure allows an attacker operating within a compromised or untrusted container to query the dashboard frontend, extract sensitive environment variables and connection strings, and elevate privileges across the host orchestration boundary.
CVE-2026-118750 is an uncontrolled resource allocation vulnerability (CWE-770) affecting the Microsoft.AspNetCore.WebUtilities component in ASP.NET Core. Specifically, the FileBufferingReadStream class eagerly allocates large memory buffers from the shared ArrayPool<byte> inside its constructor prior to reading any incoming request payload data. An unauthenticated remote attacker can exploit this behavior by opening numerous concurrent connections and stalling or omitting request body transmission, exhausting shared memory pools and causing a server-wide Denial of Service (DoS).
CVE-2026-114155 is a local elevation of privilege vulnerability affecting Microsoft .NET on Linux and macOS platforms. The vulnerability exists within the dotnet-watch (Hot Reload) component and is caused by a Time-of-Check Time-of-Use (TOCTOU) race condition (CWE-367) during the generation and execution of temporary XML solution files (.slnx) in shared system temporary directories. A local attacker with low privileges can intercept and modify the temporary solution file before MSBuild evaluates it, achieving arbitrary code execution in the security context of the user running dotnet-watch.
CVE-2026-118748 is a remote Denial of Service (DoS) vulnerability in Microsoft ASP.NET Core (.NET 11.0 preview releases prior to 11.0.0) and Microsoft Visual Studio 2026 (prior to 18.12.0). The flaw originates from unbounded resource allocation (CWE-770) within the Blazor static server-side rendering (static-SSR) validation pipeline, where dynamic or attacker-supplied form field identifiers are cached in a singleton-scoped memory structure without size limits or eviction policies. Unauthenticated remote attackers can exploit this condition over the network by sending repeated HTTP requests with unique field names, exhausting heap memory and terminating the host process via an unhandled OutOfMemoryException.