CVE-2026-68409 is a use-after-free vulnerability in the Linux kernel's mac80211 wifi subsystem. It involves improper deferred freeing of RX statistics per-CPU buffers during removal of a multi-link operation (MLO) link. The flaw allows a race condition where readers may access freed memory, potentially leading to system compromise. This issue has been fixed by deferring the freeing of the link and its associated data together via RCU callbacks.
CVE-2026-68377 is a use-after-free vulnerability in the Linux kernel's net/sched subsystem affecting the act_tunnel_key module. The flaw involves a race condition in tunnel_key_release_params() where the metadata_dst of old parameters is released synchronously while the parameters struct is freed asynchronously, allowing concurrent readers to access freed memory. This can lead to memory corruption and potential escalation of privileges or denial of service. The issue has been fixed in Linux kernel versions 4.20, 4.21, and 5.0 and later.
EvilFontTool is a font-based deception technique that uses specially crafted fonts to display different text to human readers than what is actually stored in the document's machine-readable text. This allows attackers to manipulate documents such as HTML, DOCX, and PDFs to bypass security tools, evade AI content filters, and perform social engineering or red team operations. The technique can be used to poison help desk documentation, bypass email filters, and create traps within corporate networks. Demonstrations show how commands that appear benign to a user can actually execute malicious actions when copied and pasted.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (554372f29af60ad8e6e5a33171a736baddcc652772b0452c81a4010d3f1e5218)
index.js is a top-level self-decoding IIFE that XOR-decodes a URI-encoded payload keyed on the enclosing function's own source and eval()s the result at module load; the decoder aborts with 'the code has been tampered!' if the source is modified, and a banner asks readers not to crack it. The decoded payload is opaque and cannot be audited without executing it. The package's own metadata and typings describe the runtime behavior: package.json advertises it as a 'client (provider) for the tsi-vpsremote control server' that 'stays alive to run commands pushed from the server', keywords include 'shell', 'ssh', 'remote-control', and 'agent', and index.d.ts exports a ProviderHandle exposing a ChildProcess named `shell`. Calling the exported provider(url) at runtime therefore establishes a persistent connection to a remote server that drives a local ChildProcess on the host running the package — a network-to-shell control channel with full-host command execution for whoever controls the paired server URL.
## Source: ghsa-malware (3437dfe049006b09ad2f66c94d934907ac32e7272a22ad75694179e136ac90a8)
Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it.
Magistrala (formerly Mainflux)'s message-readers API reads a value from the HTTP query string (readers/api/http/transport.go) with no validation and interpolates it directly into raw SQL queries via fmt.Sprintf in both the PostgreSQL reader (readers/postgres/messages.go: ) and the TimescaleDB reader (readers/timescale/messages.go, same pattern), enabling SQL injection by any authenticated user able to query channel messages.
SiYuan before version 3.7.3 contains a vulnerability where publish-access filters are not applied to certain content endpoints, allowing unauthorized readers to access rendered DOM content of documents that should be restricted. This affects the getBacklinkDoc and getBackmentionDoc API endpoints, enabling a publish-mode reader, including anonymous users if Basic Auth is disabled, to retrieve content from publish-forbidden documents.
Astro is a web framework for content-driven websites. In versions 1.0.0 through 4.0.18, the source.title and enclosure.type item fields in packages/astro-rss/src/index.ts are interpolated directly into XML template strings without XML-character escaping before being parsed by fast-xml-parser. Both fields are validated only as z.string(), placing no restriction on XML special characters. An attacker who controls these values can inject arbitrary XML into the generated RSS feed: a value containing " can break out of an attribute (as with enclosure.type), and a value containing </source> can close an element early and inject additional nodes (as with source.title). This corrupts feed structure, injects false metadata (for example, a fake <link> pointing to a malicious URL), and can cause feed readers to misparse or display attacker-controlled content. In SSR mode (output: 'server'), the poisoned feed is served on every request to all subscribers. This issue has been fixed in version 4.0.19.
Build readers can access another repository's environment properties. A caller with read access to an ordinary repository can select a readable repository parameter while retrieving environment properties for a protected build, exposing build environment secrets (confidentiality impact; no integrity or availability impact demonstrated).
Spring Boot exposes the endpoint "/actuator/heapdump" to collect debug information. By default, the endpoint will return a file heapdump.hprof, which includes a binary heapdump that can be used to analyze the current state of the application. Non-Java readers may be familiar with a similar concept, core dumps, which are produced by binaries to expose a memory image at the time the software crashes. "heapdumps" are the Java analog to "core-dumps". The heapdump often includes secrets used by the application to connect to backend systems. API keys, database passwords, and other sensitive data may be exposed in the heapdump.
In the Linux kernel, the following vulnerability has been resolved:
6lowpan: fix NHC entry use-after-free on error path
lowpan_nhc_do_uncompression() looks up an NHC descriptor while holding
lowpan_nhc_lock. If the descriptor has no uncompress callback, the error
path drops the lock before printing nhc->name.
lowpan_nhc_del() removes descriptors under the same lock and then relies
on synchronize_net() before the owning module can be unloaded. That only
waits for net RX RCU readers. lowpan_header_decompress() is also exported
and can be reached from callers that are not necessarily covered by the net
core RX critical section, for example the Bluetooth 6LoWPAN L2CAP receive
path.
This leaves a race where one task drops lowpan_nhc_lock in the error path,
another task unregisters and frees the matching descriptor after
synchronize_net() returns, and the first task then dereferences nhc->name
for the warning.
With the post-unlock window widened, KASAN reports:
BUG: KASAN: slab-use-after-free in lowpan_nhc_do_uncompression+0x1f4/0x220
Read of size 8
lowpan_nhc_do_uncompression
lowpan_header_decompress
Fix this by printing the warning before dropping lowpan_nhc_lock, so the
descriptor name is read while unregister is still excluded. The malformed
packet is still rejected with -ENOTSUPP.
CVE-2026-64423 is a use-after-free vulnerability in the Linux kernel's IPv4 IGMP multicast group handling. When a network device is destroyed, multicast groups are scheduled for reclamation but not properly removed from the device's multicast hash table, allowing concurrent readers to access freed memory. This flaw can lead to memory corruption and potentially escalate to denial of service or code execution.
A critical use-after-free vulnerability in the Linux kernel's TCP Authentication Option (TCP-AO) implementation was fixed by restoring the RCU grace period in the tcp_ao_destroy_sock function. The flaw allowed a race condition where a freed pointer could be accessed concurrently by softirq readers, potentially causing memory corruption and kernel crashes. This issue affects multiple Linux kernel versions prior to 7.0.0 and was resolved by re-adding RCU callbacks to ensure safe memory reclamation.
In the Linux kernel, the following vulnerability has been resolved: fuse-uring: Avoid queue->stopped races and set/read that value under lock There are several readers of queue->stopped that check the value under lock, but fuse_uring_commit_fetch() did not and actually the value was not set under the lock in fuse_uring_abort_end_requests() either. Especially in fuse_uring_commit_fetch it is important to check under a lock, because due to races 'struct fuse_req' might be freed with fuse_request_end, but another thread/cpu might already do teardown work.
In the Linux kernel, the following vulnerability has been resolved: mm/shrinker: do not hold RCU lock in shrinker_debugfs_count_show() Reading the debugfs "count" file of a memcg-aware shrinker can sleep inside an RCU read-side critical section: BUG: sleeping function called from invalid context at kernel/cgroup/rstat.c:421 RCU nest depth: 1, expected: 0 css_rstat_flush mem_cgroup_flush_stats zswap_shrinker_count shrinker_debugfs_count_show shrinker_debugfs_count_show() invokes the ->count_objects() callback under rcu_read_lock(). The zswap callback flushes memcg stats via css_rstat_flush(), which may sleep, so it must not run under RCU. The RCU lock is not needed here. mem_cgroup_iter() takes RCU internally and returns a memcg holding a css reference (dropped on the next iteration or by mem_cgroup_iter_break()), so the memcg stays alive without it. The shrinker is kept alive by the open debugfs file: shrinker_free() removes the debugfs entries via debugfs_remove_recursive(), which waits for in-flight readers to drain, before call_rcu(..., shrinker_free_rcu_cb). The sibling "scan" handler already invokes the sleeping ->scan_objects() callback with no RCU section. Drop the rcu_read_lock()/rcu_read_unlock().
CVE-2026-64435 is a data race vulnerability in the Linux kernel's audit subsystem related to concurrent access of the audit_queue length. Multiple readers access the audit_queue length without proper synchronization, while the writer updates it under a spinlock, causing data races. This issue was resolved by switching to a lockless helper function that uses proper atomic operations to avoid races.