A race condition in the Linux kernel's ftrace subsystem could trigger a warning (WARN_ON_ONCE) during concurrent calls to ftrace_dump_one() and reading from trace_pipe. This occurs because the ring buffer data may be consumed by other readers between checks, causing an unpopulated iterator sequence and triggering the warning. The issue has been fixed by moving the trace_printk_seq() call to ensure the iterator sequence is properly populated before use.
In the Linux kernel, the following vulnerability has been resolved: ftrace: Also allocate and copy hash for reading of filter files Currently the reader of set_ftrace_filter and set_ftrace_notrace just adds the pointer to the global tracer hash to its iterator. Unlike the writer that allocates a copy of the hash, the reader keeps the pointer to the filter hashes. This is problematic because this pointer is static across function calls that release the locks that can update the global tracer hashes. This can cause UAF and similar bugs. Allocate and copy the hash for reading the filter files like it is done for the writers. This not only fixes UAF bugs, but also makes the code a bit simpler as it doesn't have to differentiate when to free the iterator's hash between writers and readers.
Anatsa, an Android banking malware first discovered in 2020, has evolved with new capabilities and targets. The latest variant now affects over 831 financial institutions worldwide, including new countries and cryptocurrency platforms. Anatsa has streamlined its payload delivery, implemented DES runtime decryption, and added device-specific restrictions. The malware uses decoy applications in the Google Play Store, some exceeding 50,000 downloads. Alongside Anatsa, 77 other malicious apps from various families were identified, totaling over 19 million installs. Anatsa's evasion techniques include emulation checks, device model verification, and the use of malformed archives to hide malicious code. The malware primarily steals credentials through fake banking login pages tailored to detected financial apps on the user's device.
CVE-2025-38588 is a vulnerability in the Linux kernel's IPv6 implementation where an infinite loop can occur in the rt6_nlmsg_size() function. This happens due to a race condition involving list_del_rcu() calls that can confuse RCU readers, causing them to lose the list head and loop indefinitely. The issue affects multiple Linux kernel versions and has been fixed in later releases.
This tutorial provides an in-depth analysis of a malware infection chain using shellcode generated by the Donut tool. It covers various stages of the attack, including initial download, trace concealment, and final payload delivery. The tutorial aims to familiarize readers with common analysis tools like dnSpy, IDA Pro, x64dbg, and ProcessHacker, while demonstrating both static and dynamic analysis techniques. It highlights malware behaviors such as dynamic API resolution, process injection, and AMSI bypassing. The excerpt focuses on analyzing an unknown function in the shellcode, explaining PC-relative addressing and position-independent code techniques used by malware to access resources.
A Linux kernel vulnerability in the arm_ffa firmware component involved the use of a mutex in atomic context, which can cause kernel warnings due to sleeping in an invalid context. The issue was resolved by replacing the mutex with a read-write lock (rwlock) to prevent sleeping during read-side locking and allow concurrent readers, thus avoiding contention and potential deadlocks.
Missing Release of Resource after Effective Lifetime (CWE-772) in the Gallagher T-Series Reader allows an attacker with physical access to the reader to perform a limited denial of service when 125 kHz Card Technology is enabled.
This issue affects T-Series Readers: 9.20 prior to vCR9.20.250213a (distributed in 9.20.1827 (MR2)), 9.10 prior to vCR9.10.250213a (distributed in 9.10.2692(MR5)), 9.00 prior to vCR9.00.250619a (distributed in vEL9.00.3371 (MR7)), all versions of 8.90 and prior.
CVE-2024-38601 is a race condition vulnerability in the Linux kernel's ring buffer implementation. It involves a timing window where the doubly-linked list used by the ring buffer can become temporarily inconsistent during concurrent reader page swaps and buffer resize operations. This inconsistency can trigger warnings and stop tracing, potentially causing denial of service. The issue arises because the resize operation may detect the inconsistent state when the parent trace buffer has recording disabled, a condition made more common by a recent kernel commit. The vulnerability affects multiple Linux kernel versions and has been fixed in several patched releases.
The Online-Ausweis-Funktion eID scheme in the German National Identity card through 2024-02-15 allows authentication bypass by spoofing. A man-in-the-middle attacker can assume a victim's identify for access to government, medical, and financial resources, and can also extract personal data from the card, aka the "sPACE (Spoofing Password Authenticated Connection Establishment)" issue. This occurs because of a combination of factors, such as insecure PIN entry (for basic readers) and eid:// deeplinking. The victim must be using a modified eID kernel, which may occur if the victim is tricked into installing a fake version of an official app. NOTE: the BSI position is "ensuring a secure operational environment at the client side is an obligation of the ID card owner."
Closing of an event channel in the Linux kernel can result in a deadlock.
This happens when the close is being performed in parallel to an unrelated
Xen console action and the handling of a Xen console interrupt in an
unprivileged guest.
The closing of an event channel is e.g.triggered by removal of a
paravirtual device on the other side. As this action will cause console
messages to be issued on the other side quite often, the chance of
triggering the deadlock is not neglectable.
Note that 32-bit Arm-guests are not affected, as the 32-bit Linux kernel
on Arm doesn't use queued-RW-locks, which are required to trigger the
issue (on Arm32 a waiting writer doesn't block further readers to get
the lock).