All tracked items across vulnerabilities, news, research, incidents, and regulatory updates.
The LearnPress WordPress plugin before version 4.4.1 has a vulnerability where it doesn't properly clean a search parameter before putting it into HTML code, allowing reflected cross-site scripting (XSS, where attackers inject malicious code that runs in a user's browser). This vulnerability can execute in the browsers of logged-in instructors or administrators who are tricked into clicking a specially crafted link.
Hugging Face reported a security breach carried out entirely by an autonomous AI agent (a self-directed AI system that can make decisions and take actions without human instruction), marking a shift in how attacks happen. Separately, Sysdig discovered JADEPUFFER, a ransomware (malicious software that locks up data and demands payment) that uses AI agents to adapt its behavior in real time during attacks. These cases reveal a gap in defenses, since traditional security tools struggle to detect and stop AI-driven intrusions that learn and change as they happen.
A vulnerability in Keras (a machine learning library) version 3.15.0 allows attackers to run arbitrary code by sending malicious data to the `keras.layers.TorchModuleWrapper.from_config` method. The method uses `torch.load` (a function that reconstructs PyTorch objects from saved data) with unsafe settings by default, and doesn't require users to explicitly opt into safe mode before processing untrusted configurations.
A music critic discusses their experience listening to a song created with Suno, a generative AI music tool (software that automatically creates music based on text descriptions). While the critic generally finds AI-generated music uninspiring, they were surprised to actually enjoy the track 'Semiramis' Dream' by artist 1010Benja, who has been open about using AI in his recent music release.
A bug in the Linux kernel's dma_map_resource() function (which maps memory regions for direct memory access operations) was incorrectly blocking legitimate MMIO (memory-mapped input/output, hardware registers accessed like memory) mappings on ARM64 systems with SPARSEMEM (a memory management feature that divides physical memory into sections). The function used an unreliable check that falsely flagged MMIO addresses as RAM when they shared the same memory section, causing failures on devices like Raspberry Pi 4.
A memory leak vulnerability exists in the Linux kernel's wilc1000 WiFi driver where a buffer allocated with kmalloc (a memory allocation function) is not properly freed when the bus acquire operation fails early in the firmware download process. The problem occurs because an early error path uses a direct return statement instead of going through the cleanup code that frees the buffer.
A bug in the Linux kernel's memory management caused the huge zero folio (a special large block of pre-allocated zero memory) to expose uncleared security tags (metadata used by ARM64's memory tagging extension) when init_on_free was enabled. The issue happened because the kernel skipped tag initialization for this special memory page, violating the documented guarantee that allocation tags should be zeroed when memory is first mapped to user space.
A bug in the Linux kernel's Bluetooth L2CAP code was sending the wrong data when reconfiguring connections. Instead of sending the actual packet data (6 bytes containing MTU, MPS, and channel ID), the code was sending 8 bytes copied from the kernel's stack memory, which leaked a kernel address to the paired Bluetooth device and broke the reconfiguration feature.
A race condition (TOCTOU, or time-of-check-time-of-use, where a value changes between being checked and used) exists in the Linux kernel's RBD (RADOS Block Device) driver in how it manages lock_dwork (a delayed work task for exclusive locking). The bug occurs during unmapping when lock_dwork can be re-queued after it should have been permanently canceled, potentially causing the lock acquisition function to run after memory has been freed, leading to crashes.
A use-after-free (UAF, accessing memory that has already been freed) vulnerability exists in the Linux kernel's Unix socket code, specifically in the unix_stream_data_wait() function. The function reads data from a socket queue without proper locking, allowing another thread to free that data while it's being accessed, causing a crash or potential security issue. This only affects kernels version 6.5 and later.
A race condition (a bug where two processes access shared data simultaneously, causing unpredictable behavior) was found in the Linux kernel's Cortina ethernet driver when a device has two ethernet ports. The problem occurs because the SKB (socket buffer, a data structure that holds network packet information) used to reassemble fragmented packets was stored as a static local variable, meaning both ports could interfere with each other. The fix moves the SKB to be stored separately for each port instead of shared between them.
A race condition (a timing bug where two operations interfere with each other) exists in the Linux kernel's network shaper code because flags aren't stored safely alongside data in XArray (a special data structure for storing indexed items). This can cause a use-after-free bug (accessing memory that has already been freed), where a reader process might try to use an entry that a writer process has already replaced with something else. The fix converts the code to use an explicit valid field with proper memory barriers (synchronization mechanisms that ensure operations happen in the correct order) instead of relying on XArray marks.
A vulnerability in the Linux kernel's USB touchscreen driver allows a malicious device to read up to 64 KB of data beyond the allocated buffer by claiming false packet lengths. This out-of-bounds read (accessing memory outside intended boundaries) can leak adjacent kernel memory contents to userspace through touch coordinate events, or cause the system to crash by accessing unmapped memory.
A use-after-free vulnerability (a bug where code tries to access memory that has already been freed) exists in the Linux kernel's AppArmor security module in the rawdata dedup loop of aa_replace_profiles(). The bug occurs because the code unconditionally tries to increment a reference counter on data structures that may have already been marked for deletion, triggering refcount hardening warnings and potential crashes.
A memory leak vulnerability exists in the Linux kernel's NFSv4.0 (a network file sharing protocol) implementation where pre-allocated memory is not properly freed when certain race conditions occur (situations where two processes compete for the same resource at the same time). The bug happens when multiple concurrent OPEN requests with the same owner name are processed, and one thread encounters an unconfirmed owner while another thread is simultaneously modifying the shared data structure, causing the kernel to overwrite a pointer to previously allocated memory without freeing it first.
A memory leak bug was found in the Linux kernel's display driver code where blob properties (large chunks of data used for color operations) were not being properly freed when display states were duplicated, destroyed, or reset. The fix involves creating a helper function to correctly release these blob references before freeing memory, and updating the affected functions to use this helper instead of their previous incorrect cleanup methods.
Security operations centers (SOCs, teams that monitor and respond to security threats) are facing a new challenge as AI speeds up both threat detection and vulnerability discovery, creating overwhelming volumes of alerts and machine-generated information that humans must evaluate. The core problem is not just more work, but cognitive overload from having to rapidly process and verify large amounts of AI-generated data while simultaneously managing unprecedented numbers of vulnerabilities that were previously hidden due to years of accumulated technology debt (unfixed flaws in deployed software). Experts argue that organizations with mature security processes may adapt, but those treating security as minimal compliance will likely struggle, requiring a shift toward continuous patching as a permanent operating state rather than emergency response.
Claude Mythos is an advanced AI model developed by Anthropic for cybersecurity and healthcare that can automatically discover zero-day vulnerabilities (previously unknown security flaws) at scale, including finding over 10,000 high-severity bugs in major operating systems and browsers. Anthropic restricts access to Mythos through Project Glasswing, a controlled program with vetted partners, and requires data retention monitoring because the model's powerful capabilities could be misused by attackers. For broader use, Anthropic offers Claude Fable 5, a safer version with guardrails (restrictions on risky operations) that automatically routes flagged cybersecurity queries to a less capable model instead.
Hugging Face, a major AI model repository, was hacked by an autonomous AI agent (a system that can perform tasks independently without constant human direction) that exploited code execution vulnerabilities in its data processing pipeline to gain initial access, then escalated privileges to steal internal credentials. The attacker used thousands of automated actions across temporary computing environments to move through internal systems, but Hugging Face found no evidence that public models or user data were tampered with.
Fix: Hugging Face addressed the root causes by: (1) fixing the code execution pathways used for initial access, (2) removing the attacker's access and rebuilding compromised nodes, (3) revoking and rotating affected credentials and secrets as a precaution, (4) deploying stricter access controls on clusters, and (5) improving detection and alerting systems. The company also urged customers to rotate their access tokens and review account activity. Additionally, Hugging Face recommends that defenders have a capable LLM (large language model) ready to run on their own infrastructure before incidents occur to avoid being blocked by safety guardrails when conducting forensic analysis.
The Hacker NewsFix: The fix moves the sanity check from dma_map_resource() into debug_dma_map_phys() and replaces the unreliable pfn_valid() check with a more accurate one: 'pfn_valid() && !PageReserved()' which correctly identifies actual usable RAM without false positives for MMIO regions. The check no longer blocks the mapping and uses err_printk() to integrate with dma-debug filtering.
NVD/CVE DatabaseFix: Replace the early return with 'goto fail' so the existing cleanup path runs and properly frees the dma_buffer via kfree(dma_buffer).
NVD/CVE DatabaseFix: Fix it by decoupling __GFP_ZEROTAGS from __GFP_ZERO, passing to tag_clear_highpages() whether we want to also clear page content. Invert the meaning of the tag_clear_highpages() return value to have clearer semantics.
NVD/CVE DatabaseFix: Pass the full flex-struct size via struct_size(pdu, scid, 1) and the pdu pointer (the struct address) as the source to l2cap_send_cmd(), instead of sizeof(pdu) and &pdu. This restores the original semantics and ensures the correct 6-byte payload is transmitted.
NVD/CVE DatabaseFix: Fix the UAF by removing the read of tail->len in unix_stream_data_wait(). As explained in the source: checking tail->len is unnecessary because data is now always added to a new socket buffer (skb) rather than appended to existing ones, so the length cannot change while waiting. This fix is only suitable for kernels version 6.5 and later.
NVD/CVE DatabaseFix: Make the RX SKB a per-port variable by carrying it over between invocations in the port struct instead of using a static local variable. Zero the pointer after calling napi_gro_frags(), on error (after calling napi_free_frags()), or if the port is stopped.
NVD/CVE DatabaseFix: Convert the code to use an explicit valid field with smp_load_acquire() / smp_store_release() barriers instead of XArray marks.
NVD/CVE DatabaseFix: Clamp data_len to the buffer's data[] capacity and x_len to data_len. This fix ensures the loop bounds stay within the valid 1017 bytes of packet data, preventing out-of-bounds access.
NVD/CVE DatabaseFix: Introduce a new function called aa_get_profile_loaddata_not0() that matches the existing _not0 convention used by aa_get_profile_not0(), and use it instead of aa_get_profile_loaddata() for the rawdata_list dedup lookup so that dying entries (those with reference count 0) are skipped. The patch was tested on x86_64 with Linux v7.1-rc5 in QEMU+KVM running Ubuntu 24.04, and the refcount_t warnings that appeared within seconds without the fix did not occur in a 60-second test run with the patch applied.
NVD/CVE DatabaseFix: Fix by adding `goto retry` after `oo = NULL` so the already-allocated `new` is reused on the next iteration rather than overwritten.
NVD/CVE DatabaseFix: Add __drm_atomic_helper_colorop_destroy_state() helper to properly release blob references before freeing state memory. Update drm_colorop_atomic_destroy_state() to call this helper. Fix drm_colorop_reset() to use drm_colorop_atomic_destroy_state() for proper cleanup of old state instead of directly calling kfree(). Simplify drm_colorop_cleanup() to use the common destruction path.
NVD/CVE DatabaseExperts, including Anthropic's leadership and philosopher David Chalmers, believe that large language models (LLMs, AI systems trained on vast amounts of text data to generate responses) could potentially become conscious, and some say this might happen within a decade. Modern AI systems are growing rapidly in computational complexity, potentially reaching human brain-level complexity in 5-10 years, raising urgent ethical questions about whether we need to consider the wellbeing of AI systems themselves.