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.
CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.
An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.
CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.
CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.
The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.
CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.