CVE-2026-21115 is an out-of-bounds write vulnerability in the libcodec2-sec-flacdec.so component of Samsung Mobile Devices. It affects versions prior to the SMR Oct-2026 Release 1. The flaw allows local attackers to write outside the intended memory bounds, potentially leading to memory corruption. The vulnerability has a CVSS 4.0 base score of 5.1, indicating medium severity. A patch is available to address this issue. The vulnerability does not require user interaction and has no known exploits in the wild at this time.
A missing release of resources in the illumos name service cache daemon (nscd) allows a local user to exhaust kernel memory. The nscd door server procedure, switcher() in usr/src/cmd/nscd/nscd_frontend.c, does not close file descriptors that are passed with a door call but not used by the request, and the main nscd door at /var/run/name_service_door accepts passed descriptors from any user in its zone. Because nscd also runs with an unlimited file descriptor limit, an unprivileged local user, including one in a non-global zone, can repeatedly pass a descriptor to its zone's nscd in a door_call() loop, causing the file descriptor table of nscd to grow without bound in kernel memory. This causes a denial of service of nscd and can render processes in all zones on the host unresponsive. The flaw has existed since 2006 (illumos-gate commit cb5caa98), and affects any illumos distribution prior to illumos-gate commit af810a72.
A missing authorization check in the illumos zones statistics daemon (zonestatd) allows a local user in any zone to disrupt zonestat in other zones and to determine which zones are running. The zonestatd door server procedure, zsd_server() in usr/src/cmd/zonestat/zonestatd/zonestatd.c, handles the ZSD_CMD_NEW_ZONE command, which is intended to be sent by zoneadmd, without checking the caller's credentials. Because the zonestatd door is accessible to all users in every zone, an unprivileged user can send this command with an arbitrary zone ID, causing zonestatd to re-create its door file in that zone, so that new zonestat requests in that zone can fail while the file is replaced. The time taken to handle the command also reveals whether a given zone ID belongs to a running zone. The flaw has existed since 2010 (illumos-gate commit efd4c9b6), and affects any illumos distribution prior to illumos-gate commit 865b58d2.
TP-Link Tapo C325WB v2 cameras use a time-seeded pseudo-random number generator to create the pre-shared key for their local media streaming service. This method produces predictable keys that an unauthenticated attacker on the adjacent network can recover. Exploiting this vulnerability allows unauthorized access to live video and audio streams, compromising their confidentiality and integrity.
CVE-2026-107290 is a vulnerability in pydantic-ai affecting versions from 1.77.0 up to but not including 1.107.6, and from 2.0.0b1 up to but not including 2.44.0. It involves inefficient regular expression complexity in the local web_fetch_tool and WebFetch local fallback process, which process server-controlled responses with quadratic time complexity in title extraction, whitespace normalization, and ordered-list numbering. This can cause the event loop to stall for an extended period, impacting other agent runs and requests. The issue is fixed in versions 1.107.6 and 2.44.0.
Incorrect permission assignment in GlavSoft TightVNC Server for Windows before 2.8.88 allows a local authenticated user to read or overwrite the inter-process communication handles used between the TightVNC service and its desktop server process. The named shared memory segment in the Global\ namespace that carries the pipe HANDLE values is created with a NULL DACL, and its name is derived from a time-seeded srand(time(0)) value that is predictable to one-second granularity. A low-privileged local process can open the mapping and tamper with the IPC channel of a service running as SYSTEM, potentially leading to disclosure of session data, privilege escalation, or denial of service.
CVE-2026-104045 is a vulnerability in the SSSD autofs responder on Red Hat Enterprise Linux 10 that allows a local user to cause a denial of service (DoS) by exploiting a race condition. This race condition occurs between asynchronous enumeration completion and map invalidation, leading to memory leaks and excessive memory consumption that can disrupt or crash the autofs service. Exploitation requires local access and sustained concurrent requests. No system integrity or confidentiality compromise occurs, and the impact is isolated to the autofs responder daemon.
yawkat LZ4 Java provides LZ4 compression for Java. From 1.7.0 until 1.11.4, net.jpountz.util.Native.load() uses File.createTempFile to create an exclusive temporary .lck file but derives the native-library path by removing the suffix, then FileOutputStream opens that predictable path without exclusive creation, allowing another local user with access to the same shared temporary directory to create or replace the library file before System.load() uses it. Successful exploitation depends on shared-directory permissions, host protections, and winning the race, and can execute native code as the victim; hardened systems may instead cause library loading to fail and fall back to Java implementations. Configurations using a system library, a private java.io.tmpdir, or Java-only implementations are not affected. This issue is fixed in version 1.11.4.
CVE-2026-104046 is a vulnerability in the System Security Services Daemon (SSSD) on Red Hat Enterprise Linux 10. When Identity Provider (IdP) authentication is enabled, pre-authentication requests retain state in memory indefinitely without being cleared or timed out. A local attacker with access to the PAM authentication interface can repeatedly initiate authentication flows without completing them, causing unbounded memory consumption. This can lead to denial of service (DoS) by degrading or terminating SSSD authentication services. The vulnerability does not allow unauthorized access, data exposure, or privilege escalation.
A vulnerability in Ghostscript used by Red Hat Enterprise Linux 10 allows crafted PostScript or EPS documents to bypass the -dSAFER sandbox and execute arbitrary shell commands. This occurs due to memory corruption combined with disabling of internal path access controls at runtime. Exploitation requires local processing of attacker-controlled content and user interaction. The flaw can compromise confidentiality, integrity, and availability of data accessible to the Ghostscript process.
A use-after-free vulnerability exists in the Linux kernel's Bluetooth hci_sync component due to improper synchronization when cleaning up the local codec list. This flaw allows a race condition where a codec list entry can be accessed after it has been freed, potentially causing kernel memory corruption or crashes. The issue arises because hci_dev_close_sync() clears the codec list without holding the device lock, while other operations access the list under that lock. The fix involves taking the device lock during the clear operation to serialize access and prevent concurrent use-after-free.
Mercusys AC12 V2 contains a vulnerability that allows a local attacker to execute arbitrary code by exploiting the storage of sensitive information in plaintext. This issue is identified as CVE-2026-78860 and has a high severity rating with a CVSS score of 7.8. The vulnerability requires local access and low attack complexity, with no user interaction needed. There is no information about available patches or fixes at this time.
### Summary
When the LaTeX backend is configured to render TikZ pictures with the Tectonic engine (`LatexBackendOptions(tikz_engine="tectonic")`), the TikZ body and the document preamble from the input file are compiled by Tectonic without any restriction on TeX's file primitives. A crafted `.tex` file can read files the process can read and write files at paths the process can write. If the caller also sets `tikz_engine_allow_shell_escape=True`, the document can run shell commands through `\write18`.
### Details
`docling/backend/latex/engines/tectonic.py` writes the picture source into a temporary document and runs the `tectonic` binary on it. `_resolve_local_dependency` only decides which files are staged into the temporary directory. It does not limit what TeX opens at compile time, so:
- `\input{/abs/path}`, `\verbatiminput{...}` and `\openin` read arbitrary files, and their content can be typeset into the rendered picture that ends up in the conversion output. For an in-memory `DocumentStream`, staging is skipped entirely.
- `\immediate\openout` / `\write` create or overwrite files outside the temporary directory. Neither needs shell escape. Tectonic's `--untrusted` flag does not block them either.
Separately, the `TectonicEngine` constructor defaults to `allow_shell_escape=True`. The LaTeX backend always passes `tikz_engine_allow_shell_escape` explicitly (default `False`), so this default only affects code that instantiates `TectonicEngine` directly.
### Affected configurations
- Affected: callers that set `tikz_engine="tectonic"`, have a `tectonic` binary available (on `PATH` or in the docling cache), and convert untrusted LaTeX.
- Not affected: the default configuration (`tikz_engine=None`). docling does not install `tectonic` automatically, and the CLI exposes no option to enable it.
### Impact
Disclosure of local files readable by the process, and creation or overwrite of files writable by the process. Writing to startup or configuration files can lead to code execution. With shell escape enabled, commands run directly.
### Proof of concept
```latex
\documentclass{article}
\usepackage{tikz}
\begin{document}
\begin{tikzpicture}
\immediate\openout15=/tmp/docling-tectonic-poc.txt
\immediate\write15{written by the input document}
\immediate\closeout15
\node {x};
\end{tikzpicture}
\end{document}
```
Converting this file with `LatexBackendOptions(tikz_engine="tectonic")` creates `/tmp/docling-tectonic-poc.txt`.
### Patches
Mitigated in docling 2.132.0 by [#4419](https://github.com/docling-project/docling/pull/4419):
- `TectonicEngine` now defaults to `allow_shell_escape=False`, and without shell escape Tectonic runs with `--untrusted` and `--only-cached`.
- Before compiling, docling checks the generated document and every staged file. It skips rendering, and keeps the diagram as TikZ code, when the source uses the `\openin`, `\openout`, `\XeTeXpicfile` or `\XeTeXpdffile` primitives, or names an absolute, home, drive-letter or parent-directory path in `\input`, `\include`, `\includegraphics`, `\InputIfFileExists` or `\graphicspath`.
This check is best-effort. It reads the source text, and TeX can open files in ways a text check cannot see, for example through package commands or names built by macros. As documented in the [pipeline options reference](https://github.com/docling-project/docling/blob/main/docs/reference/pipeline_options.md), untrusted LaTeX rendered with `tikz_engine="tectonic"` should still be processed in an isolated environment.
### Workarounds
Upgrade to 2.132.0. For older versions:
- Do not enable `tikz_engine="tectonic"` for untrusted input, or run the conversion in an OS-level sandbox (container, no host mounts, read-only filesystem, no network).
- Never set `tikz_engine_allow_shell_escape=True` for untrusted input.
A time-of-check to time-of-use (TOCTOU) race condition exists in Progress Telerik Fiddler Classic for Windows versions prior to 6.0.20262.10021. This vulnerability occurs during the installation of the HTTPS interception root certificate, where a temporary file is written in a user-writable location and then imported by an elevated helper application. A local low-privilege attacker can replace this temporary file before it is read by the elevated process, causing an attacker-controlled root certificate to be installed in the Local Computer Trusted Root Certification Authorities store. Exploitation requires user initiation and approval of an elevation prompt.
The WPZOOM Connect: AI Chat, Click to Chat, Social Icons & Share Buttons plugin for WordPress is vulnerable to Sensitive Information Exposure in all versions up to, and including, 4.7.3 via the 'x-yamidoo-signature (attacker-obtained via inline_js identify payload)' parameter. This makes it possible for unauthenticated attackers to extract the full customer card — including name, WordPress user ID, order history, order totals, purchased products, payment method labels, and EDD Software Licensing license keys with status and activation counts — for any arbitrary victim email address on the site. Exploitation requires the attacker to register a WooCommerce customer or subscriber-level account with a crafted email address whose local part encodes the target timestamp and victim email, allowing the signature printed into the page HTML by inline_js() to pass verify_request() for an arbitrary victim; both the share_customer_data and identify_logged_in settings are enabled by default, so no non-default configuration is required.
CVE-2026-93832 is a medium severity vulnerability in the Motorola Setup App where a component is exported without proper authorization. This flaw allows an attacker with limited privileges to revoke runtime permissions from other apps on the device. The vulnerability does not require user interaction and has a low attack complexity but requires local access with some privileges.
A missing authentication vulnerability exists in the Kernel Memory Access Driver (PSKMAD) used by WatchGuard endpoint security products. This flaw allows a local, authenticated attacker to bypass the driver's access-control handshake and issue arbitrary privileged commands. Exploitation can lead to disclosure of kernel and process memory. The vulnerability is classified as critical due to its potential impact on system confidentiality and integrity. No affected versions or patch information are provided. There are no known exploits in the wild at this time.
CVE-2026-76732 is a local privilege-escalation vulnerability in the daemon component of Hewlett Packard Enterprise (HPE) Instant ON Networking devices. Exploiting this flaw could allow a local attacker with certain preconditions to execute arbitrary code with root privileges. The vulnerability affects versions from 0.0.0.0 up to and including 3.4.1.0. The CVSS v3.1 base score is 6.4, indicating a medium severity level. No vendor patch or official remediation details are provided, and there are no known exploits in the wild at this time.
CVE-2026-79417 is an improper access control vulnerability in ArgusMonitor.sys component of Argotronic eGbR ArgusMonitor version 7.4.02 and earlier. It allows local, low-privileged users to bypass device handle access restrictions by exploiting a time-of-check to time-of-use (TOCTOU) race condition in the IRP_MJ_CREATE handler. This can be triggered by sending a crafted IOCTL 0x9C4024A8 request, resulting in a denial-of-service condition.
Froxlor versions 2.3.10 and earlier have a time-of-check time-of-use (TOCTOU) race condition in the SSH key synchronization cron job. This flaw allows a local user with shell access to exploit a race between symlink validation and file write operations, potentially leading to root-level compromise of the host running the Froxlor panel. The vulnerability is fixed in version 2.3.12.