Red Hat has issued a security advisory for a bug fix and enhancement update to Red Hat Hardened Images RPMs, specifically including qt6 packages. The update addresses issues related to CVE-2026-105923 and CVE-2026-95620. No explicit details about the vulnerability or exploit methods are provided. The advisory lists updated qt6 RPM packages across multiple architectures.
A security flaw has been discovered in Zylon PrivateGPT 1.0.0/1.0.1. This vulnerability affects the function load_file_from_uri of the file private_gpt/server/ingest/uri_loader.py of the component URI Artifact Loader. Performing a manipulation of the argument Value results in server-side request forgery. It is possible to initiate the attack remotely. The exploit has been released to the public and may be used for attacks. The vendor was contacted early about this disclosure but did not respond in any way.
A vulnerability has been found in mansi-k Restaurant_IMS d7ad49f61ab7cc1ec6eb359ac2b5378bdbde0694. Affected is the function mysqli_connect of the file lsmodal.php. The manipulation of the argument login_id/epsw leads to sql injection. Remote exploitation of the attack is possible. This product follows a rolling release approach for continuous delivery, so version details for affected or updated releases are not provided. The vendor was contacted early about this disclosure but did not respond in any way.
A vulnerability in the Linux kernel's sched_ext scheduler caused CPU hotplug operations to hang when tasks on a dying CPU were managed by the BPF scheduler. The issue arose because tasks on the dying CPU's runqueue (rq) were not properly re-enqueued, causing the hotplug thread to wait indefinitely. This was fixed by ensuring tasks are re-enqueued on the local dequeue and that dispatch operations continue until the runqueue goes offline.
A vulnerability in the Linux kernel's rust_binder component was resolved that involved improper handling of node refcount updates when a thread exits. Specifically, when a thread exits via BINDER_THREAD_EXIT while holding a pending node refcount increment, the increment could be dropped due to no-op cancel functions. This caused desynchronization between the node's delivery and count states, potentially preventing the node from being freed properly. The fix implements cancellation logic to reschedule the refcount update on thread exit, ensuring proper delivery to userspace.
A vulnerability in the Linux kernel's IPv4 PMTU handling was resolved. The issue involved a null pointer dereference caused by a race condition when the nexthop group shrinks during a PMTU walk. This could lead to a kernel oops. Exploitation requires CAP_NET_ADMIN capability in the network namespace, which can be obtained by a local user in a new user and network namespace if unprivileged user namespaces are allowed.
A vulnerability in the Linux kernel IPv4 implementation was resolved by preventing an exception dump when a nexthop group shrinks during concurrent FIB dumps. The issue involved dereferencing a NULL pointer due to a race condition between fib_info_num_path() and fib_info_nhc() when nexthop groups are replaced with fewer paths.
A type confusion vulnerability in the Linux kernel's ati_remote2 driver was resolved by correcting device attribute handlers. The issue arose because attribute callbacks incorrectly treated usb_interface pointers as usb_device pointers, leading to invalid pointer usage. This was fixed by updating the callbacks to use the correct usb_interface pointers.
A memory leak vulnerability in the Linux kernel ALSA ctxfi component was fixed by ensuring allocated memory for DAO input mappers is properly freed when clearing them. The issue was caused by missing kfree() calls in the dao_clear_input() function, leading to memory not being released on each call.
A race condition in the Linux kernel's cpuset subsystem related to CPU hotplug operations could lead to a NULL pointer dereference. This occurs because the update order of cpu_active_mask and cpu_online_mask allows a race window where the top cpuset may have no active CPU. The issue was fixed by reintroducing a NULL check in guarantee_active_cpus() to prevent dereferencing a NULL pointer.
A vulnerability in the Linux kernel's CIPSO option handling was resolved. The cipso_v4_skbuff_delattr() function removed CIPSO bytes but failed to adjust cached offsets for subsequent options, causing consumers to access incorrect bytes. This could lead to improper interpretation of packet data and potential memory corruption when copying option data into fixed-size storage.
A vulnerability in the Linux kernel's vsock/virtio subsystem related to incorrect accounting of unread bytes in the read_skb() function has been resolved. The flaw caused the rx_bytes counter to underflow after partial stream receives, leading to incorrect socket status reporting and potentially hiding queued data until additional bytes arrived. This issue was identified during a manual source audit following a previous related vulnerability (CVE-2024-50169).
A vulnerability in the Linux kernel's mt7603 WiFi driver involved the use of an uninitialized global station WCID for frames without a station or vif, including those injected via a monitor interface. This led to a NULL pointer dereference causing kernel crashes. The issue was fixed by initializing the WCID before publishing it, preventing crashes during frame transmission.
A vulnerability in the Linux kernel's TCP zerocopy receive mapping was resolved. The issue involved dereferencing a NULL pointer when handling net_iov fragments in zerocopy receive mapping hints, leading to a kernel panic under certain conditions. The fix rejects all net_iov fragments before accessing page mappings, preventing the NULL pointer dereference and associated crash.
A deadlock vulnerability in the Linux kernel's GVE driver was resolved. The issue occurs when disabling XSK pools, where unlocked versions of napi_disable and napi_enable are called while the netdev lock is already held, causing a deadlock. The fix updates these calls to use the locked versions to prevent the deadlock.
A vulnerability in the Linux kernel's gve driver caused XSK buffers to leak when rings were stopped. Specifically, the driver did not free XSK buffers when resetting ring state during queue stoppage, leading to resource leakage. This issue was observed in production environments and has been resolved by ensuring XSK buffers attached to allocated buf_state are freed when stopping rings.
A vulnerability in the Linux kernel's gve driver related to AF_XDP zero-copy (ZC) mode caused a buffer leak when the error bit was set in the RX completion descriptor. The issue was that the XSK buffer was not freed properly on error, leading to resource leakage. This vulnerability has been resolved in the Linux kernel.
A vulnerability in the Linux kernel's dm-integrity device was resolved that caused a NULL pointer dereference crash when the device was activated with the 'R' flag and the SB_FLAG_DIRTY_BITMAP flag was set. The issue occurred in the dm_integrity_resume function when it attempted to read the journal containing the bitmap. The fix prevents writes during resume if the device is activated in 'R' mode.
A use-after-free vulnerability in the Linux kernel's ice driver was fixed. The flaw occurs in the dynamic port cleanup function ice_dealloc_dynamic_port(), where the code frees a VSI object before using its index to erase a dynamic port entry, leading to use-after-free. The fix involves erasing the xarray entry before freeing the VSI, following the reverse order of allocation.
A heap out-of-bounds write vulnerability in the Linux kernel's ksmbd component was fixed in the krb5_authenticate() function. The flaw occurs because the calculation of available buffer space (out_len) for the Kerberos AP-REP token does not account for prior responses in a compounded SMB2 request, leading to an overestimation of buffer headroom. This causes a length check to erroneously pass, allowing memcpy() to write beyond the allocated buffer into adjacent kernel heap memory. The issue is resolved by correctly subtracting the offset of prior responses when computing the available buffer space.