Swann Communications SWIFI-SE2KIC devices running firmware version 2.0.22 and earlier have a vulnerability where critical functions lack authentication. This flaw allows an attacker on the local network to access real-time video streams without any authentication. The vulnerability is identified as CWE-306 (Missing Authentication for Critical Function) and has a medium severity with a CVSS score of 6.9. No official patch or remediation has been provided in the available data.
CVE-2026-9218 is an improper input validation vulnerability in the time server (NTP) setting of the NETGEAR CBR40 router. An attacker with local network access and administrator credentials can run unauthorized commands on the router, impacting its integrity. There is no impact on confidentiality or availability. The vulnerability has a medium severity score of 4.3 and affects multiple firmware versions prior to certain fixed releases.
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.
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.
A use-after-free vulnerability in the Linux kernel's RDMA rxe driver was resolved by changing the timing of multicast group insertion into the mcg_tree. The flaw allowed a local userspace RDMA client to trigger a condition where a freed multicast group structure could be dereferenced, causing memory corruption. The fix ensures the multicast group is only published after successful programming of the backing Ethernet multicast address, preventing concurrent access to a group being torn down.
### 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.
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.
AzuraCast versions before 0.23.8 contain a server-side request forgery (SSRF) vulnerability in the station webhook URL validation. The validation incorrectly rejects only literal link-local IP addresses but allows loopback and private network addresses, enabling a user with station-scoped WebHooks permission to configure webhooks targeting internal or private network resources. This can cause the server to send HTTP POST requests with station data to unintended internal endpoints. The vulnerability can be triggered on demand via a specific test endpoint. No patch was available at the time of the advisory.
ClawHub (openclaw/clawhub) application/backend contains a server-side request forgery vulnerability in the public profile preview's image fetching. The preview accepts a user-supplied image URL and checks the textual hostname against private-address patterns, but does not validate or pin the resolved network destination, so a public-looking hostname can resolve to an internal address or change resolution between validation and connection (DNS rebinding). A maintainer-run local harness demonstrated an outbound connection to an owner-controlled loopback listener; access to production internal services, credential disclosure, and code execution were not demonstrated. The issue was confirmed at revision cbfee7343ddc867316dd9b3de6fa8856730f9f41; the complete historical affected range was not established. Fixed by PR #3683, included in revision 8c2de6c506bb4efabe3f0c2ffb8370b9e23d4650, which was deployed to clawhub.ai on 2026-09-11; self-hosted deployments should update to that revision or a later descendant. The npm CLI and OpenClaw runtime are separate products and are not affected.
A vulnerability in the Linux kernel's IPv6 fragment reassembly code allows heap corruption due to stale metadata usage. This occurs when fragment queues are not properly invalidated before flushing, leading to out-of-bounds memory access. The flaw can be leveraged for local privilege escalation in environments with unprivileged network namespaces. The issue has been resolved by properly killing incomplete queues and flushing all queues owned by the dying rhashtable.
CVE-2026-79417 is a local denial-of-service vulnerability in Argus Monitor caused by an exposed IOCTL that allows unprivileged users to disable the x86 MONITOR and MWAIT instructions. Exploiting this vulnerability requires leveraging a time-of-check to time-of-use (TOCTOU) bug related to the SeLocateProcessImageName function. Successful exploitation triggers a HYPERVISOR_ERROR bugcheck, impacting Hyper-V and other kernel components that rely on these instructions.
A vulnerability in the Linux kernel's wifi libipw component was resolved that involved improper boundary checks when reading the WEP key index from network packet data. The function libipw_rx() previously checked for skb->len >= hdrlen + 3 before reading skb->data[hdrlen + 3], which did not sufficiently ensure the byte was within bounds. The fix requires hdrlen + 4 bytes before accessing that byte, preventing a potential out-of-bounds read. This is a local source-boundary check and does not affect key index semantics.
Multiple security vulnerabilities were discovered in the Linux kernel, including a critical issue affecting some Arm processors where a broadcast TLB invalidation could complete before memory writes were globally observed. This flaw could allow a local attacker to write to memory after permissions were revoked, potentially bypassing memory protections or escalating privileges. Additional flaws affect various subsystems such as InfiniBand drivers, network drivers, exFAT file system, NFS client and server, and several networking protocols. These issues were addressed in updated Linux kernel packages for Ubuntu 20.04 LTS and 22.04 LTS.
microsandbox is an easy, fast, local-first microVM runtime and library. Prior to 0.5.10, sdk/rust/lib/runtime/spawn.rs serializes NetworkConfig secret values into the --network-config argument and passes per-sandbox secrets through repeated --env arguments accepted by crates/cli/lib/sandbox_cmd.rs. Other local users or co-resident processes can read these values through the host process table, including /proc process command lines on Linux and process listings on Linux and macOS, for the lifetime of the sandbox. Exploitation does not require code execution inside the sandbox or access to the spawning user's session, and can disclose host-side API keys, tokens, and environment secrets on shared hosts, CI runners, and developer systems. This issue is fixed in version 0.5.10.
A race condition vulnerability in the Linux kernel's OCFS2 cluster filesystem was resolved by synchronizing heartbeat callbacks with the o2net teardown process. The flaw involved use-after-free errors during concurrent teardown and heartbeat callback execution, potentially causing kernel memory corruption. The patch ensures heartbeat callbacks remain registered until local-node teardown completes, preventing stale or conflicting network state updates.
A vulnerability in the Linux kernel's NFS server (NFSD) component allows a local administrator with CAP_SYS_ADMIN privileges to crash the kernel by triggering a NULL pointer dereference during certain unlock operations before the server fully starts. This occurs because the code walks NFSv4 client hash tables that have not yet been allocated, leading to a kernel crash. The issue affects specific Linux kernel versions and has been fixed by gating the relevant code paths on a network-up flag to prevent the NULL dereference.
A vulnerability in the Linux kernel's SUNRPC subsystem was resolved involving improper handling of a NULL return value from rpc_sockaddr2uaddr() in rpcb_register_inet4() and rpcb_register_inet6(). This can lead to a kernel crash (oops) due to a NULL pointer dereference when the system is under memory pressure. The issue occurs when an in-kernel RPC service registers with the local rpcbind and rpc_sockaddr2uaddr() fails to allocate memory but its return value is unchecked. The fix involves adding a check for NULL and returning an error before the NULL pointer is used.
CVE-2026-80995 is a use-after-free vulnerability in the Linux kernel's MCTP (Management Component Transport Protocol) implementation. The flaw occurs because mctp_route_lookup() uses a route device pointer without holding a proper reference, allowing concurrent teardown and leading to a use-after-free condition. This vulnerability can be triggered by an unprivileged local user via the AF_MCTP socket interface without requiring CAP_NET_RAW privileges. The issue is related to improper reference counting and was introduced by a change that moved source address lookup ahead of destination device reference acquisition.
In the Linux kernel, the following vulnerability has been resolved: seg6: reset IP6CB after IPv6 decapsulation decap_and_validate() pulls the outer SRv6 headers and makes the inner packet the skb network header. The IPv6 control block still contains values collected while parsing the outer packet, including nhoff and extension-header flags. End.DX6 and End.DT6 route the inner IPv6 packet directly to the IPv6 input path. An unprivileged user can reach End.DT6 from a user and net namespace by installing a local SID and injecting an outer packet with Hop-by-Hop and Destination Options headers followed by an SRH and a minimal inner IPv6 packet. The outer extension headers leave a large nhoff in IP6CB. After decapsulation, ip6_protocol_deliver_rcu() uses that stale offset on the inner packet and reads beyond the skb head. KASAN reports: BUG: KASAN: slab-out-of-bounds in ip6_protocol_deliver_rcu ip6_protocol_deliver_rcu+0x1118/0x1450 ip6_input_finish+0x11b/0x240 seg6_local_input_core+0xed/0x2e0 lwtunnel_input+0x1e9/0x4e0 ipv6_rthdr_rcv+0x525f/0x6c50 ip6_protocol_deliver_rcu+0xcb7/0x1450 Before clearing IP6CB for an inner IPv6 packet, save its incoming interface index and L3 slave state. Restore both after the clear and set nhoff to the inner IPv6 base-header nexthdr field. Use IP6CB(skb)->iif rather than skb->skb_iif because VRF processing can replace skb_iif with the L3 master while IP6CB keeps the receiving interface. Preserve IP6SKB_L3SLAVE for the same reason.