Vault Community Edition and Vault Enterprise did not apply explicit ACL policy deny rules to letter case variants of user and group names in auth methods that treat these names as case-insensitive. This may allow an authenticated user with delegated permissions to modify a protected user or group, potentially leading to privilege escalation. This vulnerability (CVE-2026-128100) is fixed in Vault Community Edition 2.2.2 and Vault Enterprise 2.2.2, 1.21.14, and 1.19.25.
- Dependency on Vulnerable Third-Party Component vulnerability in Johnson Controls FX Server, Johnson Controls FX80, and Johnson Controls FX90 allows CAPEC‑17: Accessing, Modifying or Deleting Files.
This issue affects FX Server: before 14.10.10 and before 14.14.1; FX80: before 14.14.10 and before 14.14.1; FX90: before 14.10.10 and before 14.14.1.
LearnPress Course Wishlist Add-on before 4.1.2 contains an insecure direct object reference vulnerability that allows remote attackers to manipulate any user's course wishlist by supplying an arbitrary user_id parameter to the render_button callback instead of relying on the session identity. Attackers can exploit the publicly accessible load_content_via_ajax REST route, which only requires a public wp_rest nonce, to add or remove courses from any user's wishlist and determine whether a given course is wishlisted by iterating user_id and course_id values.
In FRRouting (FRR) 8.3 through 10.5.1, bgp_notify_decapsulate_hard_reset() in bgpd/bgp_packet.c does not validate the length of the data field of a received BGP NOTIFICATION Cease/Hard Reset message (RFC 8538). When the data field is exactly one byte long, the function reads one byte past the end of a heap buffer and the 16-bit length of the encapsulated data underflows to 65535, causing a 65535-byte out-of-bounds heap read followed by an assertion failure. A remote BGP peer that has established a session and negotiated the Graceful Restart capability with the Notification (N) bit can send such a message to crash the bgpd daemon, terminating all BGP sessions (denial of service). This is fixed in 10.0.5, 10.1.5, 10.2.6, 10.3.4, 10.4.3, 10.5.2 and 10.6.0.
CVE-2026-110330 is a local information disclosure vulnerability in the abrt-server component of Red Hat Enterprise Linux 7. The flaw occurs because abrt-server trusts a client-supplied process ID (PID) when creating problem dumps, running as root, and copies the /proc data including environment variables of that process into a dump directory owned by the unprivileged user. This allows a local attacker to read sensitive environment variables and metadata of other users' or root processes.
CVE-2026-110331 is a vulnerability in the abrt component of Red Hat Enterprise Linux 7 where an incomplete mitigation allows local attackers to bypass authorization checks. The flaw arises because the completeness check only verifies the presence of a "count" element in dump directories, which can be created by unprivileged users. This enables attackers to poison elements or seize ownership of dump directories while privileged ABRT handlers process them. The issue is related to but distinct from previous CVEs CVE-2026-54228 and CVE-2026-54229. Mitigation involves disabling or removing ABRT if not required and restricting local user access.
Devolutions PowerShell Universal versions 2026.3.4 and earlier have incorrect default permissions on the agent configuration folder. This vulnerability allows a local unprivileged user to execute arbitrary code with SYSTEM privileges by crafting a malicious agent configuration file that directs the agent to an attacker-controlled server. The issue is fixed in version 2026.3.5.
The HashiCorp cap JWT validation library before version 0.14.0 is vulnerable to a claims validation bypass that may cause downstream applications to make authorization decisions using claim values different from those validated. Exploitation requires attacker-controlled claims in a JWT signed by a key trusted by the application. This vulnerability (CVE-2026-19194) is fixed in cap 0.14.0.
CVE-2026-102632 is an incorrect privilege assignment vulnerability in Devolutions PowerShell Universal versions 2026.3.4 and earlier. It allows an authenticated user with token creation or update permissions to escalate privileges to administrator. Additionally, in multi-node deployments, a revoked app token can be reinstated via crafted requests that manipulate role or revocation state. This issue is fixed in version 2026.3.5.
## Summary
`LegalitySyllableTokenizer.tokenize` in the NLTK tokenizer package contains an unguarded O(n^2) processing loop. When the method is called on a single token that consists of a long run of vowels (for example `"a" * n`), it consumes CPU time proportional to the square of the token length. An attacker who can supply an untrusted token to this public tokenizer API can force a single request to saturate one CPU core for a prolonged period, degrading availability of any service that syllabifies attacker-controlled text. No authentication, special configuration, or user interaction is required.
## Root Cause
The method walks the token in reverse and, on every iteration after the first vowel is seen, evaluates the membership test `char_lower + current_onset[::-1] in self.legal_onsets`. The set `legal_onsets` is built by `onset()`, which returns only the characters up to the first vowel, so every member is vowel-free. For an all-vowel token the first branch can therefore never match, `onset` never becomes `True`, and the reset branch that would clear `current_onset` is never reached. As a result `current_onset` grows by one character on every iteration. Building `current_onset[::-1]` and hashing the resulting string costs O(k) on iteration k, and this is repeated for k from 1 to n, giving total cost O(n^2). The security invariant that is violated is bounded per-token work: there is no length cap on this code path, so untrusted token length translates directly into quadratic CPU consumption.
```text
Affected function: LegalitySyllableTokenizer.tokenize
Source: nltk/tokenize/legality_principle.py (membership-test sink at line 133; loop over token[::-1] beginning at line 126)
Helper establishing the vowel-free onset set: LegalitySyllableTokenizer.onset (nltk/tokenize/legality_principle.py, returns prefix up to first vowel)
```
## Impact
An attacker who controls a token passed to `LegalitySyllableTokenizer.tokenize` can trigger quadratic CPU work. In the reviewed release a token of roughly 64,000 vowel characters takes about 1.8 seconds on a single core, and the cost grows with the square of the length, so a token in the hundreds of kilobytes to megabyte range consumes a core for many seconds to minutes. Memory use is linear. The demonstrated capability is single-core CPU exhaustion leading to denial of service or latency degradation in any network-reachable component that syllabifies untrusted input. There is no confidentiality or integrity impact; the effect is availability degradation of the affected process. The plausible operational consequence, where multiple concurrent requests are used, is exhaustion of the available worker pool; this is inferred from the per-request cost and was not itself executed against a live deployment.
## Proof of Concept
`Requires only the released nltk package; no corpus download is needed because the quadratic behavior is driven entirely by the attacker token, not by the size of the legal-onset set.`
1. Construct a tokenizer with any small onset source.
2. Call `tokenize` with an all-vowel token of increasing length and time each call.
3. Compare against a consonant-alternating control token of equal length.
```python
import time
from nltk.tokenize import LegalitySyllableTokenizer
tok = LegalitySyllableTokenizer("tr c d".split()) # tiny 3-word onset source
for n in (8000, 16000, 32000):
payload = "a" * n
start = time.perf_counter()
tok.tokenize(payload)
print("vowel-run", n, round(time.perf_counter() - start, 3))
control = "ba" * 32000 # equal-length linear control
start = time.perf_counter()
tok.tokenize(control)
print("control", 64000, round(time.perf_counter() - start, 3))
```
```text
vowel-run 8000 0.031
vowel-run 16000 0.120
vowel-run 32000 0.468 (about 4x per doubling => O(n^2))
control 64000 0.004 (linear, roughly 130x faster at larger size)
```
## Attack Chain
1. **Exposure:** `LegalitySyllableTokenizer` is exported from `nltk.tokenize` and `tokenize` is a public, documented method reachable by any service that syllabifies untrusted text.
2. **Control:** The attacker fully controls the `token` argument, including its length and character content; a run of vowels such as `"a" * n` survives with no normalization or length reduction.
3. **Path:** The token flows into the reverse walk at `nltk/tokenize/legality_principle.py:126` and reaches the membership-test at line 133 on every iteration past the first vowel.
4. **Guard:** There is no length cap on this path. The sibling `SyllableTokenizer` received a `MAX_TOKEN_LEN` cap during the project hardening work, but `legality_principle.py` received no such guard.
5. **Primitive:** Repeated O(k) construction and hashing of `current_onset[::-1]` inside the loop yields cumulative O(n^2) CPU work.
6. **Result:** A single request with a large vowel-run token exhausts one CPU core for a sustained period, degrading service availability.
## Bypass Evidence
No guard blocks this path. Membersh
CVE-2026-128987 is a vulnerability in the dbus component of Red Hat Enterprise Linux 10 where a local attacker can cause a denial of service by triggering a continuous retry loop that leads to excessive CPU consumption. The flaw arises when socket writes encounter broken pipe errors treated as retryable, causing the application to spin indefinitely. This impacts process availability but does not allow privilege escalation or data compromise. No effective mitigation or patch is currently available from Red Hat.
A flaw was found in D-Bus. In configurations where the daemon falls back to using the Unix select() mechanism for event monitoring, it does not verify whether file descriptor numbers exceed allocated limits. A local attacker can exploit this flaw by opening a large number of concurrent connections to trigger an out-of-bounds write on the stack. This can cause the daemon to crash, resulting in a Denial of Service (DoS).
Post to Google My Business plugin for WordPress versions before 3.5.7 contains a blind server-side request forgery (SSRF) vulnerability. Authenticated users with Contributor-level privileges or higher can exploit this flaw by supplying a crafted URL that triggers the server to send requests to arbitrary hosts. This allows attackers to perform internal port scanning, probe internal-only services and cloud metadata endpoints, and cause GET-based side effects on internal systems, bypassing network perimeter controls. The vulnerability is fixed in version 3.5.7.
ARTEX is an AI-enabled penetration testing framework originally designed for authorized security testing but quickly adopted by threat actors for criminal and targeted intrusion campaigns. It automates and accelerates the attack chain by breaking objectives into tasks executed by worker agents using various security tools, significantly lowering the skill threshold and compressing attack timelines. ARTEX and similar AI-enabled frameworks integrate open-source tools and internet services to perform reconnaissance, vulnerability scanning, credential theft, and data exfiltration. Multiple threat actors, including financially motivated cybercriminals and China-nexus groups, have used ARTEX in campaigns targeting sectors such as government, telecommunications, defense, pharmaceuticals, semiconductors, and finance across multiple countries. The rapid and autonomous nature of these frameworks presents significant challenges for detection, mitigation, and incident response, emphasizing the need for automated defensive measures and robust response plans.
A vulnerability in SvelteKit's adapter-node causes the server to crash due to an unhandled URIError when the `reroute` function rewrites malformed percent-encoded pathnames into valid paths. This issue affects versions >=3.0.0 <3.1.1 and versions below 2.70.4. The flaw has been fixed in versions 3.1.1 and 2.70.4.
VITEC EZ TV Platform Server versions prior to 8.5.0 have an unrestricted file upload vulnerability that allows unauthenticated attackers to upload arbitrary files, including malicious ASPX files, to a web-accessible directory. This enables remote code execution under the web server's context. The vulnerability is fixed in version 8.5.0.
A vulnerability in @sveltejs/adapter-vercel allows prerendered paths to be interpreted as regular expressions in the Vercel routing configuration. This occurs if an attacker can influence a link crawled during the prerender phase, potentially causing unintended regex interpretation. The issue affects multiple versions prior to fixed releases and has a medium severity with a CVSS score of 5.9.
CVE-2026-128132 is a high-severity vulnerability in aiohttp, an asynchronous HTTP client/server framework for Python. Versions prior to 3.14.4 have an uncontrolled resource consumption issue where the WebSocket reader continues parsing frames after the receive queue pauses the transport, and empty messages are not counted toward the queue size. This can lead to excessive memory use when a remote peer sends many small or compressed messages rapidly. The issue is fixed in version 3.14.4.
Injection Guard plugin for WordPress versions before 1.4.0 contains a cross-site request forgery (CSRF) vulnerability. This flaw allows unauthenticated attackers to trick a logged-in administrator into triggering a password hash export by loading a crafted link. The vulnerability arises because the ig_settings admin page processes GET parameters without nonce verification. Exploitation results in writing WooCommerce customer email and password hashes to an unprotected file, which can be downloaded without authentication for offline cracking.
CVE-2026-128131 is a high-severity vulnerability in aiohttp, an asynchronous HTTP client/server framework for Python. Versions prior to 3.14.4 decompress concatenated compressed streams inefficiently, causing quadratic CPU usage. This can allow a remote attacker to block the server event loop by sending crafted compressed request bodies or WebSocket messages. The issue is fixed in version 3.14.4.