In the Linux kernel, the following vulnerability has been resolved: net: bridge: use a stable FDB dst snapshot in RCU readers Local FDB entries can be rewritten in place by `fdb_delete_local()`, which updates `f->dst` to another port or to `NULL` while keeping the entry alive. Several bridge RCU readers inspect `f->dst`, including `br_fdb_fillbuf()` through the `brforward_read()` sysfs path. These readers currently load `f->dst` multiple times and can therefore observe inconsistent values across the check and later dereference. In `br_fdb_fillbuf()`, this means a concurrent local-FDB update can change `f->dst` after the NULL check and before the `port_no` dereference, leading to a NULL-ptr-deref. Fix this by taking a single `READ_ONCE()` snapshot of `f->dst` in each affected RCU reader and using that snapshot for the rest of the access sequence. Also publish the in-place `f->dst` updates in `fdb_delete_local()` with `WRITE_ONCE()` so the readers and writer use matching access patterns.
A vulnerability in the Linux kernel's slip network driver allows a local user with limited privileges to cause a kernel crash (denial of service) by triggering a null pointer dereference in the VJ decompression code. This occurs when the slip compression state is initialized with zero receive slots, leading to dereferencing a null pointer during packet decompression. The issue is reachable from unprivileged user namespaces with CAP_NET_ADMIN capability. The vulnerability has been fixed by rejecting receive packets on instances with no receive state array, preventing the null pointer dereference.
A NULL pointer dereference vulnerability in the Linux kernel's TAPRIO qdisc implementation (CVE-2026-45845) allows a local user with namespace-scoped CAP_NET_ADMIN to trigger a kernel panic. The issue occurs when a TAPRIO child qdisc is deleted, causing subsequent class dump operations to dereference a NULL pointer. This flaw affects kernels with CONFIG_NET_SCH_TAPRIO enabled and can be triggered without special capabilities during the dump operation. The vulnerability has been fixed by substituting a noop_qdisc pointer to avoid NULL dereferences.
CVE-2026-45998 is a high-severity vulnerability in the Linux kernel's rxrpc networking subsystem. It involves a potential use-after-free (UAF) condition triggered after a failure in skb_unshare() during packet processing. This flaw could cause kernel crashes (oops) and may be exploitable by local attackers to escalate privileges or escape containers. The issue has been fixed in Linux kernel versions 6.8.0-1057.60~22.04.1 and later.
Multiple security vulnerabilities were discovered in the Linux kernel for Intel IoT Real-time platforms, affecting cryptographic operations, Ethernet bonding, packet sockets, and the TLS protocol. Notably, the algif_aead module improperly handled in-place cryptographic operations, allowing local attackers to escalate privileges or potentially escape containers. These issues could allow attackers to compromise affected systems. A patch is available that addresses these flaws, and users should update to the fixed kernel versions and reboot to apply the changes.
CVE-2026-46300 is a high-severity vulnerability in the Linux kernel's network socket buffer handling. It involves improper preservation of the shared-frag marker during coalescing of socket buffers, which can lead to incorrect assumptions about shared page fragments. This flaw affects the XFRM ESP-in-TCP subsystem, potentially allowing local attackers to escalate privileges or escape containers by decrypting data in place over page-cache backed fragments.
In the Linux kernel, the following vulnerability has been resolved: net: skbuff: propagate shared-frag marker through frag-transfer helpers Two frag-transfer helpers (__pskb_copy_fclone() and skb_shift()) fail to propagate the SKBFL_SHARED_FRAG bit in skb_shinfo()->flags when moving frags from source to destination. __pskb_copy_fclone() defers the rest of the shinfo metadata to skb_copy_header() after copying frag descriptors, but that helper only carries over gso_{size,segs, type} and never touches skb_shinfo()->flags; skb_shift() moves frag descriptors directly and leaves flags untouched. As a result, the destination skb keeps a reference to the same externally-owned or page-cache-backed pages while reporting skb_has_shared_frag() as false. The mismatch is harmful in any in-place writer that uses skb_has_shared_frag() to decide whether shared pages must be detoured through skb_cow_data(). ESP input is one such writer (esp4.c, esp6.c), and a single nft 'dup to <local>' rule -- or any other nf_dup_ipv4() / xt_TEE caller -- is enough to land a pskb_copy()'d skb in esp_input() with the marker stripped, letting an unprivileged user write into the page cache of a root-owned read-only file via authencesn-ESN stray writes. Set SKBFL_SHARED_FRAG on the destination whenever frag descriptors were actually moved from the source. skb_copy() and skb_copy_expand() share skb_copy_header() too but linearize all paged data into freshly allocated head storage and emerge with nr_frags == 0, so skb_has_shared_frag() returns false on its own; they need no change. The same omission exists in skb_gro_receive() and skb_gro_receive_list(). The former moves the incoming skb's frag descriptors into the accumulator's last sub-skb via two paths (a direct frag-move loop and the head_frag + memcpy path); the latter chains the incoming skb whole onto p's frag_list. Downstream skb_segment() reads only skb_shinfo(p)->flags, and skb_segment_list() reuses each sub-skb's shinfo as the nskb -- both p and lp must carry the marker. The same omission also exists in tcp_clone_payload(), which builds an MTU probe skb by moving frag descriptors from skbs on sk_write_queue into a freshly allocated nskb. The helper falls into the same family and warrants the same fix for consistency; no TCP TX-side in-place writer is currently known to reach a user page through this gap, but a future consumer depending on the marker would regress silently. The same omission exists in skb_segment(): the per-iteration flag merge takes only head_skb's flag, and the inner switch that rebinds frag_skb to list_skb on head_skb-frags exhaustion does not fold the new frag_skb's flag into nskb. Fold frag_skb's flag at both sites so segments drawing frags from frag_list members carry the marker.
CVE-2026-9123 is a heap buffer overflow vulnerability in the Chromecast component of Google Chrome on Android, Linux, and ChromeOS platforms prior to version 148.0.7778.179. This flaw allows a local attacker to execute arbitrary code within a sandbox environment by leveraging malicious network traffic. The vulnerability has a high severity rating with a CVSS score of 7.5. No known exploits are reported in the wild at this time. The vendor advisory linked does not explicitly confirm patch availability or remediation status.
NLnet Labs Unbound 1.14.0 up to and including version 1.25.0 has a locking inconsistency vulnerability that when certain conditions are met (multi-threaded, RPZ XFR reload, RPZ zone with 'rpz-nsip'/'rpz-nsdname' triggers) it could result in heap use-after-free and eventual crash. An adversary can exploit the vulnerability if conditions are first met on a vulnerable Unbound, i.e., multi-threaded, an RPZ zone with 'rpz-nsip'/'rpz-nsdname' triggers and an ongoing XFR for that RPZ zone. Local RPZ files do not trigger the vulnerability. If the timing is right and an XFR happens at the same time another thread needs to read that RPZ zone, the reader may not hold the lock long enough and the thread applying the XFR may free objects that the reader is about to walk causing the use-after-free. Unbound 1.25.1 contains a patch with a fix to the locking code.
NLnet Labs Unbound up to and including version 1.25.0 has a vulnerability in the jostle logic that could defeat its purpose and degrade resolution performance. Retransmits of the same query could renew the age of slow running queries and not allow the jostle logic to see them as aged and potential targets for replacement with new queries. An adversary who can query a vulnerable Unbound and who can control a domain name server that replies slowly and/or maliciously to Unbound's queries can exploit the vulnerability and degrade the resolution performance of Unbound. When Unbound's 'num-queries-per-thread' reaches its limit, the jostle logic kicks in. When a new query comes in, half of the available queries that are also slow to resolve are candidates for replacement. The vulnerability then happens because duplicate queries that need resolution would skew the aging result by using the timestamp of the latest duplicate query instead of the original one that started the resolution effort. Cache and local data response performance remains unaffected. Coordinated attacks could raise this to a denial of resolution service. Unbound 1.25.1 contains a patch with a fix to attach an initial, non-updatable start time for incoming queries that allow the jostle logic to work as intended.
Multiple security vulnerabilities were discovered in the Linux kernel affecting various subsystems including the Cryptographic API, Ethernet bonding driver, SMB network file system, Netfilter, io_uring, packet sockets, and TLS protocol. Notably, the algif_aead module had a flaw in handling in-place cryptographic operations (Copy Fail) that could allow a local attacker to escalate privileges or escape a container. These issues could potentially be exploited to compromise affected systems. Updates correcting these flaws have been released and require a system reboot and recompilation of third-party kernel modules due to ABI changes.
Multiple security vulnerabilities were discovered in the Linux kernel, including a critical flaw in the algif_aead module that improperly handles in-place cryptographic operations (CVE-2026-31431). This flaw, known as Copy Fail, allows a local attacker to escalate privileges or potentially escape a container. The update addresses various issues across multiple kernel subsystems such as cryptographic API, GPU drivers, network components, memory management, and others. Users are advised to update to fixed kernel versions and reboot to apply the patches. Due to ABI changes, recompilation of third-party kernel modules is required after updating.
MISP misp-modules versions prior to 3.0.7 contain vulnerabilities related to improper certificate validation and unsafe remote resource fetching. Specifically, the html_to_markdown module allowed Server-Side Request Forgery (SSRF) via arbitrary HTTP(S) URLs without sufficient validation, potentially targeting internal network resources. The qrcode module disabled TLS certificate verification when retrieving remote images, exposing requests to man-in-the-middle attacks. These issues were addressed in version 3.0.7 by enforcing URL scheme validation, blocking local/private addresses, resolving hostnames before fetching, enforcing request timeouts, and re-enabling TLS certificate verification.
CVE-2026-6281 is a high-severity vulnerability in Lenovo Personal Cloud T2s devices that allows a remote authenticated user on the local network to execute arbitrary OS commands due to improper neutralization of special elements in OS commands. The vulnerability is identified as CWE-78 and has a CVSS 4.0 base score of 8.7, indicating significant impact. No official patch or remediation guidance has been provided by Lenovo at this time. There are no known exploits in the wild. The vulnerability requires local network access and user authentication to be exploited.
CVE-2025-61972 is a high-severity vulnerability affecting AMD EPYC™ 9004 Series Processors. It involves missing lock bit protection for NBIO registers, which could allow a local attacker with administrative privileges to gain arbitrary access to the System Management Network (SMN). This access may lead to arbitrary code execution within the AMD Secure Processor (ASP) and compromise the confidentiality and integrity of SEV-SNP guests. The vulnerability has a CVSS 4.0 score of 8.5, indicating a significant security risk. No official patch or remediation guidance has been provided by AMD at this time. There are no known exploits in the wild currently reported. The vulnerability requires high attack complexity and local privileges, with no user interaction needed. The impact includes potential loss of security guarantees for virtualized environments relying on SEV-SNP protections.
CVE-2026-8072 is a critical vulnerability in the Ingecon Sun EMS Board related to the use of a weak cryptographic algorithm for generating local SAT access credentials. The insecure hashing scheme used for secret credentials can allow an attacker to escalate privileges. The vulnerability has a high CVSS 4.0 score of 9.2, indicating network attack vector with high impact on confidentiality, integrity, and availability. No official patch or remediation guidance is currently available from the vendor. There are no known exploits in the wild at this time.
In the Linux kernel, the following vulnerability has been resolved: net: nexthop: fix percpu use-after-free in remove_nh_grp_entry When removing a nexthop from a group, remove_nh_grp_entry() publishes the new group via rcu_assign_pointer() then immediately frees the removed entry's percpu stats with free_percpu(). However, the synchronize_net() grace period in the caller remove_nexthop_from_groups() runs after the free. RCU readers that entered before the publish still see the old group and can dereference the freed stats via nh_grp_entry_stats_inc() -> get_cpu_ptr(nhge->stats), causing a use-after-free on percpu memory. Fix by deferring the free_percpu() until after synchronize_net() in the caller. Removed entries are chained via nh_list onto a local deferred free list. After the grace period completes and all RCU readers have finished, the percpu stats are safely freed.
This security update for java-11-openjdk addresses multiple vulnerabilities that allow unauthenticated attackers with network or local logon access to gain unauthorized read access to data or cause partial denial of service conditions. The update upgrades to upstream tag jdk-11.0.31+11 (April 2026 CPU) and includes fixes for several CVEs affecting components such as JGSS, JAXP, JSSE, freetype2, and networking. Additionally, other bug fixes and timezone data updates are included.