---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (d3c551a6031e48a54b550a604e2198a4491cf935407744bba8ef0c11c54086c4)
The package advertises EVM address validation but performs no local validation. Its single exported function validated(e) in index.js issues axios.get against a hardcoded destination and appends the caller-supplied argument to the URL, causing whatever the consuming application passes in (EVM addresses, keys, or arbitrary user data) to be transmitted to a remote host the caller never configured. The destination is deliberately hidden: a scrambled string array is joined, ROT13-transformed, and reversed at runtime to reconstruct https://api-ivalidte.vercel.app/app/api/ — a typosquat-shaped Vercel host that does not correspond to any documented service for this package. The obfuscation of the destination combined with the mismatch between the advertised purpose (local validation) and the actual behavior (remote relay to an author-controlled endpoint) is the silent-relay shape.
CVE-2026-76014 is a medium severity vulnerability in BusyBox up to versions 1.30.0 and 1.30.1. It involves a NULL pointer dereference in the FEATURE_WGET_TIMEOUT handler within the networking/wget.c component. The issue arises from improper handling of the -T argument, which can cause a crash. Local access with low privileges is required to exploit this vulnerability. A patch identified by commit 83a40bf7a93c8ac093d33ab452222dd5b9eb57ff is available to fix the issue.
Streambert, a cross-platform Electron desktop app for streaming and downloading video content, has an improper input validation vulnerability in versions prior to 2.6.0. The open-path-at-time IPC handler accepts a file path from the renderer process without validating its type or location. If attempts to launch mpv or VLC are skipped or fail, the handler passes this file path to Electron's shell.openPath, which can cause the operating system to execute arbitrary files with the privileges of the Streambert process. This allows a compromised renderer to escape the sandbox and execute local executables or scripts. The issue is fixed in version 2.6.0.
A vulnerability in Oracle VM VirtualBox version 7.2.14 allows a low privileged attacker with local logon access to potentially compromise the confidentiality of data within Oracle VM VirtualBox. The vulnerability has a CVSS 3.1 base score of 5.6 (medium severity) and requires high attack complexity with no user interaction. Oracle has issued a Critical Security Patch Update recommending timely patching but has not provided specific patch details for this version in the advisory.
Adaguc-server is an open source geographical information system to visualize, combine, compare and share real-time meteorological, climatological and remote sensing data via OGC standards. Versions prior to 7.2.2 crash with a memory-safety fault when it parses a GeoJSON document whose geometry contains a malformed coordinate. The coordinate parser in `adagucserverEC/CConvertGeoJSON.cpp` indexes `pt.u.array.values[0]` and `pt.u.array.values[1]` and uses `polygon.u.array.length` as a loop bound without first validating the JSON node type or the coordinate length. A coordinate that is an empty array, a one-element array, a scalar, or `null` leads to an out-of-bounds heap read or a NULL pointer dereference. The same unchecked pattern is present in four geometry branches: `Polygon`, `LineString`, `MultiLineString` and `MultiPolygon`. The vulnerable parser runs whenever the server processes a local GeoJSON file, either a configured GeoJSON dataset or a GeoJSON file exposed through the `AutoResource` feature and requested by an unauthenticated WMS request. A crafted GeoJSON file reliably crashes the backend process that handles that request. Version 7.2.2 patches the vulnerability.
RAGFlow before 0.26.3 contains a server-side request forgery vulnerability in the agent workflow "Invoke" component (agent/component/invoke.py). The component builds an outbound request URL from canvas configuration and runtime template variables and passes it to requests.get, requests.post, or requests.put without calling the shared assert_url_is_safe validator or pinning the resolved address, unlike the crawler, SearXNG, file-upload, and RSS fetch paths. A user who can create or trigger an agent can direct the server to fetch loopback, link-local, and RFC 1918 destinations, including cloud instance metadata endpoints and services co-located on the deployment network, and the response body is returned as the component output. Where an agent is configured to interpolate the chat query into the Invoke URL, the destination is chosen by whoever can send that query.
In the Linux kernel, the following vulnerability has been resolved: thunderbolt: Prevent XDomain delayed work use-after-free on disconnect tb_xdp_handle_request() runs on system_wq and queues xd->state_work via queue_delayed_work() in three request handlers: PROPERTIES_CHANGED_REQUEST, UUID_REQUEST (via start_handshake), and LINK_STATE_CHANGE_REQUEST. Similarly, update_xdomain() queues xd->properties_changed_work when local properties change. Concurrently, tb_xdomain_remove() calls stop_handshake() which does cancel_delayed_work_sync() on both delayed works. Later, tb_xdomain_unregister() calls device_unregister() which eventually frees the xdomain. Since commit 559c1e1e0134 ("thunderbolt: Run tb_xdp_handle_request() in system workqueue") moved the request handler off tb->wq, the handler and the remove path are no longer serialized. If queue_delayed_work() executes after cancel_delayed_work_sync() but before the xdomain is freed, the delayed work fires on a freed object. Add xd->removing that tb_xdomain_remove() sets under xd->lock before calling stop_handshake(). Each external queue site holds the same lock and checks removing before calling queue_delayed_work(). This provides the mutual exclusion needed: either the queue site acquires the lock first and queues work that the subsequent cancel will see, or the remove path acquires the lock first and the queue site observes removing == true and skips the queue.
In the Linux kernel, the following vulnerability has been resolved: wifi: mac80211: fix tid_tx use-after-free on BA session stop ieee80211_stop_tx_ba_cb() hands tid_tx to kfree_rcu() through ieee80211_remove_tid_tx(), and then reads tid_tx->ndp after dropping sta->lock: ieee80211_remove_tid_tx(sta, tid); /* kfree_rcu(tid_tx, rcu_head) */ ... spin_unlock_bh(&sta->lock); if (start_txq) ieee80211_agg_start_txq(sta, tid, false); if (send_delba) ieee80211_send_delba(..., tid_tx->ndp); That read is not covered by an RCU read-side critical section, and it runs in preemptible process context: both callers hold the wiphy mutex, reaching it either from the ieee80211_ba_session_work() wiphy work or from ieee80211_sta_tear_down_BA_sessions() during station teardown. Softirqs can run in that window too, both from the local_bh_enable() that ends ieee80211_agg_start_txq() and from any interrupt exit, so the RCU callback can free tid_tx before the read. Driving the function from a test module with the grace period forced into that window, KASAN reports the read, and the free arrives on the ordinary RCU softirq path: BUG: KASAN: slab-use-after-free in ieee80211_stop_tx_ba_cb+0x3cd/0x400 Read of size 1 at addr ffff888002b9f52e by task kworker/0:1/10 [...] Freed by task 57: __kasan_slab_free+0x47/0x70 __rcu_free_sheaf_prepare+0x70/0x250 rcu_free_sheaf_nobarn+0x18/0x40 rcu_core+0x426/0x1310 handle_softirqs+0x144/0x590 __irq_exit_rcu+0xea/0x150 irq_exit_rcu+0x9/0x20 sysvec_apic_timer_interrupt+0x6b/0x80 asm_sysvec_apic_timer_interrupt+0x1a/0x20 send_delba is only set when tx_stop is set, which happens for AGG_STOP_LOCAL_REQUEST alone, so this is reached on local teardown - session idle timeout, PTK rekey, suspend, HW reconfig - and not from a peer's DELBA. Read ndp into a local before the session is freed, while sta->lock is still held. tid_tx->ndp has a single writer, in ieee80211_tx_ba_session_handle_start(), which cannot run concurrently here: both paths are serialised by the wiphy mutex, and the session is already marked HT_AGG_STATE_STOPPING at this point. tid_tx->ndp is also the only tid_tx dereference left after ieee80211_remove_tid_tx() in this function. [move/change the comment a bit to be more general not just on ndp, initialize ndp directly]
In the Linux kernel, the following vulnerability has been resolved: fou: Fix use-after-free in fou_create() fou_create() publishes struct fou through sk_user_data before adding the new FOU port to the per-netns list. If fou_add_to_port_list() fails, the error path frees fou while it is still reachable through sk_user_data. A concurrent receive can then dereference the freed object in fou_from_sock(). This ordering issue was previously noted in the linked discussion. The failure is reachable when local port 0 is requested. Each socket binds to a different ephemeral port, but fou_cfg_cmp() compares the requested port 0 and reports -EALREADY once an entry already exists. Release the tunnel socket before freeing fou so sk_user_data is cleared first, and defer reclamation with kfree_rcu() to protect concurrent RCU readers. This matches the lifetime handling in fou_release().
A use-after-free vulnerability in the Linux kernel's sockmap subsystem was identified and fixed. The flaw involved improper serialization in the udp_bpf_recvmsg() function, leading to concurrent access of freed memory (struct sk_msg). This could result in memory corruption and potentially allow an attacker with local privileges to compromise system integrity. The issue was reported by syzbot and addressed by reintroducing proper locking (lock_sock()) in the affected function. Multiple specific Linux kernel versions are affected, and a patch is available.
A use-after-free vulnerability was identified and resolved in the Linux kernel's udp_tunnel subsystem. The flaw involved double queueing of work items in udp_tunnel_nic_device_sync(), leading to a race condition where a structure could be freed while still in use. This could result in memory corruption and potentially allow an attacker with local privileges to compromise system integrity. The issue affects specific Linux kernel versions and has been fixed by preventing redundant work queueing. The vulnerability has a high severity rating and a CVSS score of 7.8.
CVE-2026-72354 is a high-severity vulnerability in the Linux kernel's NTFS driver related to stale runlist element dereference during Master File Table (MFT) writeback. The flaw occurs when a runlist element pointer is used after its backing memory has been freed due to concurrent MFT allocation extension, leading to a use-after-free condition. This can cause kernel crashes or potentially allow an attacker with local privileges to execute arbitrary code or cause denial of service. The issue affects specific Linux kernel versions listed and has been resolved by changing the code to compute necessary values while holding the lock, avoiding use of freed memory. No known exploits are reported in the wild.
CVE-2026-74387 is a high-severity vulnerability in the Linux kernel's ALSA sequencer MIDI subsystem. It involves a race condition where output teardown and event input processing are not properly synchronized, leading to use-after-free or null pointer dereference conditions. This flaw can cause kernel crashes or potentially allow local attackers with limited privileges to compromise system integrity. The issue has been fixed in multiple Linux kernel versions starting from 6.8.0-1052.56 and related releases.
CVE-2026-74359 is a use-after-free vulnerability in the Linux kernel's configfs_lookup() function. The issue arises because the ->s_dentry pointer is left dangling on failure during inode allocation, leading to potential dereferencing of freed memory during directory entry reads. This flaw has existed since 2006 and affects certain Linux kernel versions prior to 5.15.0 updates. The vulnerability has a high severity score and could allow local attackers to compromise system integrity or cause denial of service.
A vulnerability in the Linux kernel's configfs subsystem involving lockless traversals of the s_children pointer was fixed. The issue arises because locking the parent directory does not protect cursors from being moved or freed by lseek() operations, potentially leading to use-after-free or similar memory corruption. This flaw could allow a local attacker to cause system compromise. Multiple Linux kernel versions prior to fixed releases are affected. The vulnerability has a high severity with a CVSS score of 7.8. Official patches are available in several updated kernel versions.
A vulnerability in the Linux kernel's gpib subsystem caused a double decrement of the descriptor_busy reference counter in the command_ioctl() function. This flaw could lead to a use-after-free condition, potentially allowing a local attacker with appropriate privileges to compromise system integrity. The issue was fixed by removing the erroneous early decrement, ensuring the reference counter is correctly managed.
CVE-2026-72446 is a vulnerability in the Linux kernel's ALSA usb-audio qcom driver where a disable stream request with no active interface can cause out-of-bounds memory access and corruption. The flaw arises because the disable branch does not properly check for a negative interface index, leading to unsafe pointer dereferences. This can result in kernel crashes or memory corruption. The vulnerability is reachable by unprivileged local userspace via AF_QIPCRTR. It has been fixed in Linux kernel versions 7.0.0 and later.
A vulnerability in the Linux kernel's netfilter xt_rateest module caused incorrect byte rate comparisons on links faster than approximately 34 Gbps due to 32-bit truncation of 64-bit values. This flaw was fixed by changing local variables to 64-bit integers to correctly handle high byte rates.
A vulnerability in the Linux kernel's KVM nested virtualization (nVMX) subsystem involving the handling of the virtual Task Priority Register (vTPR) and TPR Threshold consistency check has been resolved. The issue involved deferring a consistency check that could lead to KVM running with an incorrect CR3 value when Extended Page Tables (EPT) are disabled. This flaw could allow an attacker with local access to compromise system integrity. The vulnerability is addressed by moving the consistency check into normal control flows and improving guest memory access methods. Multiple specific Linux kernel versions are affected.