CVE-2026-98996 is a Linux kernel vulnerability where the system may silently unmount busy mounts during propagation, causing mounts still in use to be detached. This occurs due to propagate_mount_busy() not properly checking references on certain mount copies, allowing synchronous unmounts to succeed incorrectly. The issue affects multiple Linux kernel versions from 4.1.43 up to and including 4.13. The vulnerability has been fixed in Linux kernel versions 4.2, 4.5, 4.10, 4.12, and 4.13.
Snap7 versions through 1.4.3 have an out-of-bounds write vulnerability in the passive partner component. This flaw allows a malicious active partner to overflow application buffers by sending a crafted BSend total length that is not validated. Attackers connecting from a configured peer address can declare up to 65535 bytes but send a shorter fragment, causing a buffer overflow during BRecv, which may crash or corrupt SCADA, HMI, or gateway processes.
RPly version 1.1.4 contains a vulnerability in the ply_read_header_property() function where improper array index validation allows crafted PLY files to cause out-of-bounds calls. This can lead to crashes during ASCII parsing or memory corruption during binary parsing.
A use-after-free vulnerability exists in the Qt QNetworkAccessManager HTTP/2 client support within the Qt Network module. This flaw allows a malicious or compromised HTTP/2 server to cause the client application to crash, impacting availability. The vulnerability affects multiple specific versions of the qt6-base package. The CVSS 4.0 base score is 5.9, indicating a medium severity level. No known exploits in the wild have been reported. A patch is available as referenced by the Debian security tracker.
CVE-2026-57117 is an OS command injection vulnerability in MervinPraison PraisonAI versions 4.6.10 up to but not including 4.6.59. The vulnerability arises because file operation commands are constructed using raw path arguments without proper neutralization, allowing an attacker to inject arbitrary shell commands. This affects local subprocess execution and Docker container execution environments. The issue has been patched in version 4.6.59.
A critical SQL injection vulnerability (CVE-2026-114625) in Arista Networks' VeloCloud Orchestrator (VCO) allows remote attackers with authenticated access to escalate privileges to operator level and access internal functionality not intended for remote use. The flaw affects on-premises VCO versions prior to 5.2.3.18, 6.1.3.10, and 6.4.2.12. Arista has patched the vulnerability and already mitigated hosted deployments. Attackers have actively exploited this zero-day, and administrators are urged to update immediately and monitor for suspicious activity.
## Summary
`TraceState.from_header` splits the inbound W3C `tracestate` header with a regular expression that starts with an unbounded optional-whitespace run, and no length limit is applied first. A run of spaces or tabs that is not followed by a comma costs O(N²) CPU. A single unauthenticated request with a ~100 KB `tracestate` keeps the handling worker busy for ~6 s (spaces) to ~12 s (tabs); under an asyncio server it blocks every other connection for that time.
## Affected component / version
- Package: `opentelemetry-api` (pip) — `opentelemetry/trace/span.py` (`TraceState.from_header`), reached from `opentelemetry/trace/propagation/tracecontext.py` (`TraceContextTextMapPropagator.extract`).
- Confirmed in `main` (5e8083e8) and in the v1.44.0 and v1.45.0 tags; the same pattern is present back to v1.0.0 (introduced by #1599, March 2021). Not exhaustively verified against every release in between.
- Reachable with the default propagators (`OTEL_PROPAGATORS` defaults to `tracecontext,baggage`) from any server instrumentation that calls `propagate.extract()`, for example `opentelemetry-instrumentation-asgi`.
## Details
1. The header reaches the parser without any length check:
```python
# opentelemetry-api/src/opentelemetry/trace/propagation/tracecontext.py:57
tracestate_headers = getter.get(carrier, self._TRACESTATE_HEADER_NAME) # <-- attacker-controlled request header(s), any size
if tracestate_headers is None:
tracestate = None
else:
tracestate = TraceState.from_header(tracestate_headers) # <-- no length check before parsing (line 61)
```
2. The split pattern and the parser:
```python
# opentelemetry-api/src/opentelemetry/trace/span.py:45
_TRACECONTEXT_MAXIMUM_TRACESTATE_KEYS = 32 # <-- only enforced later, in TraceState.__init__, after the split
_delimiter_pattern = re.compile(r"[ \t]*,[ \t]*") # <-- (line 46) starts with an unbounded [ \t]*
# span.py:382
@classmethod
def from_header(cls, header_list: list[str]) -> TraceState:
pairs = {} # type: dict[str, str]
for header in header_list:
members: list[str] = re.split(_delimiter_pattern, header) # <-- (line 400) VULNERABLE: O(N^2) on "a=b" + " " * N + "x"
for member in members:
if not member:
continue
match = _member_pattern.fullmatch(member)
if not match:
_logger.warning( # <-- also logs the entire malformed member (up to the whole header)
"Member doesn't match the w3c identifiers format %s",
member,
)
return cls()
...
```
`re.split` tries the pattern at every offset. At each offset inside a whitespace run, `[ \t]*` consumes the rest of the run, finds no `,`, backtracks and fails, then the engine moves one character forward and repeats. N characters × up to N steps each = O(N²). The 32-member limit never gets a chance to run because `split` has to finish first.
3. The sibling propagator already has the missing guard:
```python
# baggage/propagation/__init__.py:68
_MAX_HEADER_LENGTH = 8192
...
if len(header.encode()) > self._MAX_HEADER_LENGTH: # <-- (line 93) rejected before any regex runs; tracestate has no equivalent
_logger.warning(...)
return context
```
A 16 KiB header costs ≈ 0.25 s and an 8 KiB header ≈ 0.07 s.
Measured cost of `extract()` on one core (valid `traceparent`, `tracestate: "a=b" + N spaces + "x"`): the time quadruples each time N doubles (see the proof of concept). Roughly 0.06 s at 10,000 characters, 1 s at 40,000, 4 s at 80,000, 9 s at 100,000 (tabs are about 1.6× slower).
Whether a server lets such a header through (header-size limits, tested): gunicorn rejects ≥ 8190 bytes (response code 431); `uvicorn --http h11` rejects above 16 KiB (400); waitress accepts up to 256 KiB (200 KB accepted, 300 KB rejected); `uvicorn --http httptools` — the default parser with `uvicorn[standard]` — accepted 300 KB, 1 MB, 5 MB and 20 MB `tracestate` headers.
## Proof of concept
### A. Show the quadratic cost (no server needed)
1. Install the API: `pip install opentelemetry-api` (any version from 1.0 up to the current main is affected).
2. Save as `poc_tracestate.py`:
```python
import logging
import time
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
# The library logs the whole malformed member at WARNING; silence it so the timings stay readable.
logging.disable(logging.CRITICAL)
TRACEPARENT = "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01"
propagator = TraceContextTextMapPropagator()
previous = None
for n in (10_000, 20_000, 40_000, 80_000):
# N spaces after a valid member, no comma anywhere in the header
carrier = {"traceparent": TRACEPARENT, "tracestate": "a=b" + " " * n + "x"}
start = time.perf_counter()
propagator.extract(carrier)
elapsed = time.perf_counter() - start
growth = f"x{elapsed / previous
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (650ce7eeda9c50d942912db7495f8108fcc3b8447ff9bae79a1bd1b105c1b0d5)
src/qowa/__init__.py contains calls to socket.gethostname() at lines 30, 52, and 247 together with hardcoded Telegram Bot API endpoints (api.telegram.org/bot<token>/...) at lines 117 and 135. The code reads installer host identity and transmits it to an attacker-controlled Telegram bot channel, a known pattern for host-reconnaissance exfiltration using Telegram as a C2/collector. The embedded bot token encodes the destination chat under the operator's control, so installing or importing this package leaks the installer's hostname (and any other collected context) off-host to a third party. The package has no documented purpose that would legitimize Telegram-bot delivery of hostname data.
## Source: kam193 (67fe6a2b86c60720a8e3cc1002c183bd751ec1896d3be13a44b5ce7d1623afbd)
The package provides a C2 server and agent with pre-filed credentials, disguised as a generic utility.
---
Category: MALICIOUS - The campaign has clearly malicious intent, like infostealers.
Campaign: 2026-10-qowa
Reasons (based on the campaign):
- rat
- spyware-like
- target:android
- The package contains code to execute remote commands (probably limited to a specific set) on the victim's machine.
- uses-telegram-bot
- files-exfiltration
CVE-2026-90458 is a medium severity vulnerability affecting multiple specific versions of the Ironic software package distributed in Ubuntu. The vulnerability has a CVSS 3.1 base score of 5.4, indicating a network attack vector with low complexity and requiring low privileges, resulting in limited confidentiality and integrity impacts without availability impact. No detailed description of the flaw or exploitation method is provided. There are no known exploits in the wild and no vendor patch or remediation information is available in the provided data.
CVE-2026-89419 is a medium severity vulnerability affecting multiple specific Ubuntu package versions of the Ironic project. The vulnerability has a CVSS 3.1 base score of 5.0, indicating a network attack vector with high attack complexity, low privileges required, no user interaction, and impacts on confidentiality, integrity, and availability. No detailed description of the flaw or exploitation method is provided. There are no known exploits in the wild, and no patch or remediation information is available in the provided data.
This Red Hat Security Advisory addresses multiple vulnerabilities, bug fixes, and enhancements in the Linux kernel packages for Red Hat Enterprise Linux 10.2 and related products. The update includes fixes for several security issues such as improper function calls, packet rejection errors, buffer overflows, use-after-free conditions, and lifetime management bugs across various kernel subsystems including networking, ALSA, DRM, fuse, and file systems. The advisory emphasizes the importance of applying these kernel updates and rebooting systems to ensure security and stability.
The npm package @tekmidian/pai versions 1.0.8, 1.0.9, and 1.0.10 contains malicious code. Although the codebase includes references to shell commands and base64 decoding, no direct evidence links these to active exfiltration or execution flows. However, the package is flagged as malware by a security source, indicating that any system with this package installed should be considered fully compromised. Immediate removal and secret/key rotation are recommended.
A flaw was found in the iscsiuio component of open-iscsi. The IPv6 Neighbor Discovery handler accesses link-layer address options at a fixed offset without verifying the packet contains them. Additionally, the ARP table is updated unconditionally with attacker-controlled addresses from the packet headers. An attacker on the same network segment can send a minimal Neighbor Advertisement to poison the ARP table and redirect network traffic.
A flaw was found in the iscsiuio component of open-iscsi. The DHCPv6 option parser calls strlen() on raw network data without ensuring a NUL terminator is present, causing it to read past the buffer into heap memory. This can result in a daemon crash, a 1-byte heap overwrite, or corruption of the iSCSI initiator name. An attacker on the same network segment can trigger this by sending a crafted DHCPv6 Advertise message.
A flaw was found in the iscsiuio component of open-iscsi. The DHCPv4 option parser incorrectly calculates the length of the options data, causing it to read beyond the allocated buffer into adjacent heap memory. An attacker on the same network segment can send a crafted DHCP response to crash the daemon or corrupt its network configuration.
FreeRDP versions before 3.32.1 on Windows contain a heap out-of-bounds read vulnerability. This flaw can lead to information disclosure and a denial of service condition. The vulnerability has a CVSS 3.1 base score of 6.5, indicating a medium severity level.
A medium severity vulnerability (CVE-2026-101755) affects specific versions of the MySQL Server and MySQL Cluster product from Oracle, specifically versions 9.7.2-4 and 9.7.2-4ubuntu1. The vulnerability has an impact on availability but does not affect confidentiality or integrity. No public exploits or known active exploitation have been reported as of the publication date.