.NET 9.0 for Red Hat Enterprise Linux 10.0 has multiple security vulnerabilities including denial of service, privilege escalation, security feature bypass, local code execution, and information disclosure. These issues affect components such as ASP.NET Core, .NET Core, and the .NET Framework. The update addresses these vulnerabilities and includes bug fixes and enhancements.
A stored cross-site scripting (XSS) vulnerability exists in the JoomGallery extension for Joomla versions 4.0.0 through 4.3.0. An authenticated user with elevated privileges can inject malicious JavaScript code into image entries, which then executes in the browsers of any visitors viewing those images. This vulnerability has a high severity rating with a CVSS score of 8.6.
A sophisticated backdoor disguised as a legitimate Malwarebytes installer was distributed to over 100,000 machines through compromised automatic updates of one torrent client (Download Studio) and three adblockers (NetShield Kit, My AdBlock, and Net AdBlock). The backdoor creates a fake Malwarebytes installation directory containing legitimate signed files alongside malicious DLL files. Once executed, it establishes persistence through a Windows service and communicates with command-and-control servers to receive configuration updates and additional payloads. The primary observed payloads were cryptocurrency miners, though the infrastructure supports delivery of multiple persistent threats. The attack demonstrates abuse of software update mechanisms and affects primarily users in Russia, Ukraine, and Kazakhstan.
In the Linux kernel, the following vulnerability has been resolved: net: Stop leased rxq before uninstalling its memory provider netif_rxq_cleanup_unlease() tears down the memory provider that was installed on a physical RX queue through a netkit queue lease. It currently revokes the provider's DMA mappings before stopping the physical queue: __netif_mp_uninstall_rxq(virt_rxq, p); /* DMA unmap */ __netif_mp_close_rxq(phys_rxq->dev, rxq_idx, p); /* queue stop */ This inverts the ordering used by the regular teardown paths (normal device unregister and the io_uring zcrx close path), which stop the queue before revoking the provider's mappings. With the physical queue still live, its NAPI can keep consuming net_iov entries from the page_pool alloc cache after the __netif_mp_uninstall_rxq() has already cleared their dma_addr, opening a window for the device to DMA to a stale or zero address. Fix it by swapping the two calls so the queue is stopped (and its NAPI quiesced) before the provider is uninstalled. No functional regression was observed across repeated runs of the nk_qlease.py HW selftest, which exercises the lease teardown path; this was tested against fbnic QEMU emulation.
In the Linux kernel, the following vulnerability has been resolved: net: openvswitch: fix potential UAF on meter attach failure While attaching a newly created meter attach_meter() function makes the new meter visible to other CPUs but can still fail afterwards. On failure, it detaches the meter back and returns an error. However, this is an unexpected behavior for the ovs_meter_cmd_set() that uses a plain kfree(meter) on attach failure without waiting for RCU readers to stop using it, assuming it was never visible. This is never a problem for ovs-vswitchd as it always creates meters before creating any flows that use them. But the UAF can be triggered with a custom application using uAPI: BUG: KASAN: slab-use-after-free in ovs_meter_execute (net/openvswitch/meter.c:653) Read of size 8 at addr ffff88810d152650 by task meter/2508 Call Trace: ovs_meter_execute (net/openvswitch/meter.c:653) do_execute_actions (net/openvswitch/actions.c:1407) ovs_execute_actions (net/openvswitch/actions.c:1584) ovs_packet_cmd_execute (net/openvswitch/datapath.c:703) ... netlink_sendmsg (af_netlink.c:1900) Allocated by task 2519: __kasan_kmalloc (mm/kasan/common.c:398 mm/kasan/common.c:415) ovs_meter_cmd_set (net/openvswitch/meter.c:422) ... netlink_sendmsg (af_netlink.c:1900) Freed by task 2519: kfree (mm/slub.c:2705 mm/slub.c:6405 mm/slub.c:6720) ovs_meter_cmd_set (net/openvswitch/meter.c:479) ... netlink_sendmsg (af_netlink.c:1900) Fix that by making sure attach_meter() doesn't make the meter visible until all the checks are done and the function can't fail anymore. This also makes sure the "hash" value is calculated after the potential re-sizing of the table. Reported by Trend Micro's Zero Day Initiative as ZDI-CAN-31642.
In the Linux kernel, the following vulnerability has been resolved: net: udp_tunnel: fix memory leak in udp_tunnel_nic_unregister() syzbot reported a memory leak [1] in the UDP tunnel NIC offload code. When device registration fails (e.g. in register_netdevice()), netdev core unwinds by sending a single NETDEV_UNREGISTER notification. If work was queued during NETDEV_REGISTER (utn->work_pending is set), udp_tunnel_nic_unregister() returns early: if (utn->work_pending) return; Because failed registrations do not enter netdev_wait_allrefs_any(), no subsequent NETDEV_UNREGISTER rebroadcast will ever occur. As a result, the struct udp_tunnel_nic allocated in udp_tunnel_nic_alloc() is leaked permanently. Fix this by removing the early return. Instead, synchronously cancel any pending work with cancel_delayed_work_sync() before freeing @utn. To be able to call cancel_delayed_work_sync() while holding RTNL (the work also needs RTNL), switch udp_tunnel_nic_device_sync_work() to rtnl_trylock(). If RTNL is contended, requeue the work with a 1 jiffy delay (via queue_delayed_work()) to prevent high CPU contention while waiting for RTNL lock. The utn->work_pending bookkeeping is no longer needed and is removed, as the workqueue core already tracks the pending/running state of the work. [1] BUG: memory leak unreferenced object 0xffff888127d5f840 (size 96): comm "syz-executor", pid 5806, jiffies 4294942188 backtrace (crc 99fdb6c8): __kmalloc_noprof+0x3bf/0x550 udp_tunnel_nic_alloc net/ipv4/udp_tunnel_nic.c:756 [inline] udp_tunnel_nic_register net/ipv4/udp_tunnel_nic.c:833 [inline] udp_tunnel_nic_netdevice_event+0x804/0xab0 net/ipv4/udp_tunnel_nic.c:931 notifier_call_chain+0x59/0x160 kernel/notifier.c:85 call_netdevice_notifiers_info+0x7d/0xb0 net/core/dev.c:2250 register_netdevice+0xc10/0xeb0 net/core/dev.c:11478
A vulnerability in the Linux kernel's Open vSwitch (OVS) component could cause a socket buffer (skb) memory leak when flow key updates fail during connection tracking (ct). This occurs because ovs_ct_execute() properly frees or steals the skb on failure, but ovs_flow_key_update() does not, leading to leaked memory in rare cases where a packet becomes unparseable after applying certain actions. The issue has been fixed by adjusting error handling to ensure proper skb freeing.
A race condition vulnerability in the Linux kernel's Mellanox mlx5e driver was fixed. The flaw involved improper initialization timing of a delayed work structure and agent pointer during HV VHCA stats agent registration, which could lead to use of uninitialized pointers and kernel memory corruption. This could cause a NULL function pointer dereference and heap corruption in the kernel. The issue was resolved by reordering initialization steps and adding synchronization to ensure safe agent registration and callback execution.
A critical OS command injection vulnerability has been identified in the
Haiwell IoT Cloud HMI Gateway product. The vulnerability exists in the
Net Check feature accessible via the /setting endpoint. The cmdPing
Socket.io event fails to properly sanitize user-supplied input before
passing it to the underlying operating system, allowing an attacker to
inject and execute arbitrary OS commands with root privileges.
yt-dlp versions prior to 2026.7.4 used a fallback URL from a malicious third-party CDN (cdn.bootcdn.net) in its DouyuTV and DouyuShow extractors to fetch a component of the crypto-js library. This JavaScript code could be executed externally via PhantomJS, potentially exposing users to malicious code from a known supply chain attacker. Exploitation requires PhantomJS installed, use of Douyu extractors with specific URLs, and unavailability of the primary CDN cdnjs.cloudflare.com. The issue is fixed in yt-dlp version 2026.7.4.
yt-dlp versions from 2.10.5 up to but not including 2.10.5_7 included DouyuTV and DouyuShow extractors that fetched a component of the crypto-js JavaScript library from a third-party CDN (cdn.bootcdn.net) controlled by a known malicious actor. This JavaScript code was executed externally using PhantomJS, potentially exposing users to malicious code execution if certain conditions were met. The issue is fixed in yt-dlp version 2024.07.07 by removing the malicious CDN URL and invalidating cached data.
CVE-2026-25681 is a high-severity vulnerability in the golang.org/x/net/html package used by the cert-manager Operator for Red Hat OpenShift. The flaw allows specially crafted HTML to bypass input sanitization during parsing and rendering, enabling remote attackers to execute Cross-Site Scripting (XSS) attacks. This can potentially lead to arbitrary code execution in applications that process untrusted HTML content using the vulnerable component without additional protections. Red Hat products that use this component are affected if they do not implement strict output encoding or content security policies. Mitigation involves applying strict input sanitization, proper output encoding, and deploying Content Security Policies. The cert-manager Operator for Red Hat OpenShift 1.19.1 is the affected product version mentioned. No explicit patch version is stated in the advisory, but the operator can be upgraded automatically or manually depending on the approval policy.
This vulnerability allows local attackers to escalate privileges on affected installations of Linux Kernel. An attacker must first obtain the ability to execute high-privileged code on the target system in order to exploit this vulnerability. The ZDI has assigned a CVSS rating of 7.5.
This vulnerability allows local attackers to escalate privileges on affected installations of Linux Kernel. An attacker must first obtain the ability to execute high-privileged code on the target system in order to exploit this vulnerability. The ZDI has assigned a CVSS rating of 7.5.
This vulnerability allows local attackers to escalate privileges on affected installations of Linux Kernel. An attacker must first obtain the ability to execute high-privileged code on the target system in order to exploit this vulnerability. The ZDI has assigned a CVSS rating of 7.5.