The ITE IT8xxx2 SHI host-command backend in subsys/mgmt/ec_host_cmd/backends/ec_host_cmd_backend_shi_ite.c arms the SPI peripheral before its receive context exists. shi_ite_init_registers() sets the state machine to SHI_STATE_READY_TO_RECV and calls irq_enable() while the device initializes at POST_KERNEL priority CONFIG_KERNEL_INIT_PRIORITY_DEFAULT (40), but data->rx_ctx and data->tx are only assigned later by shi_ite_backend_init(), which ec_host_cmd_init() invokes at CONFIG_EC_HOST_CMD_INIT_PRIORITY (default 80).
If the attached host processor starts a SPI transaction inside that window, the Rx-valid-length interrupt fires, shi_ite_int_handler() passes its state check and calls shi_ite_parse_header(), which stores the host-derived request length through the still-NULL data->rx_ctx. On the IT8xxx2 low addresses are not backed by RAM, and with CONFIG_NULL_POINTER_EXCEPTION_DETECTION_PMP the first bytes of the address space are explicitly made inaccessible, so the store raises a fatal access fault in interrupt context. The window widens further when CONFIG_EC_HOST_CMD_INITIALIZE_AT_BOOT is disabled and the application calls ec_host_cmd_init() itself.
The result is a kernel panic on the embedded controller: with Zephyr's default fatal handler the CPU halts, so the controller stops servicing host commands until a hardware reset. Because the trigger is traffic from the attached host processor -- an untrusted peer from the controller firmware's point of view -- software on that host can provoke the fault by forcing a controller reset and issuing transactions during the reboot, turning a recoverable reset into a persistent outage. Impact is limited to availability: the faulting address is fixed and not attacker-chosen, so no memory-corruption primitive follows.
The fix leaves the interface at SHI_STATE_DISABLED with the interrupt masked during device init, moves irq_enable() into shi_ite_backend_init() after the buffers are published, and makes shi_ite_int_handler() reject a NULL data->rx_ctx while write-clearing IT83XX_SPI_ISR and IT83XX_SPI_RX_VLISR so that an unexpected early interrupt cannot storm.
A vulnerability in the Linux kernel's ksmbd component involves insufficient space reservation for a UTF-16 terminator in stream info. The function smb_strtoUTF16() writes a terminating zero UTF-16 unit beyond the allocated buffer when the stream entry exactly fills the 448-byte small response buffer, potentially causing a buffer overflow. The fix involves reserving an extra UTF-16 unit in the buffer allocation. The terminator is not part of the wire format, so reported lengths remain unchanged.
A heap out-of-bounds write vulnerability exists in the Linux kernel's ksmbd component within the krb5_authenticate() function. The flaw occurs when processing SMB2_SESSION_SETUP as a non-first element in a compounded SMB2 request, causing an incorrect calculation of buffer headroom. This miscalculation allows memcpy() to write past the end of the allocated buffer into adjacent kernel heap memory. The issue has been fixed by adjusting the calculation to correctly reflect the remaining buffer space.
A vulnerability in the Linux kernel's btrfs filesystem causes the entire filesystem to become read-only when enable_verity() hits the quota group (qgroup) limit or when there is a lack of space during verity item cleanup. This occurs because rollback_verity() requires its own metadata reservation, and failure to obtain it leads to the filesystem being forced read-only even if the qgroup limit applies only to one subvolume. Additionally, orphan cleanup at the next mount fails, leaving leftover items that prevent the subvolume from being accessible or the filesystem from mounting in read-write mode.
A vulnerability in the Linux kernel's vhost component related to invalidation of vring access on IOTLB transitions has been resolved. The issue arises when VIRTIO_F_ACCESS_PLATFORM changes, causing cached vring pointers and IOTLB metadata to be interpreted in a different address space, potentially leaving stale ring mappings in use. The fix involves clearing and invalidating cached metadata and ring access during transitions to prevent mixed address space mappings and ensure proper synchronization.
A vulnerability in the Linux kernel's net/sched cls_u32 component allows duplicate handles to be created when the node ID pool is exhausted. This occurs because the function gen_new_kid() returns a fallback handle instead of an error when ID allocation fails, causing handle collisions in the hash table. This breaks handle uniqueness and can lead to incorrect removal and reuse of live nodes. The issue affects configurations with CONFIG_NET_SCHED and CONFIG_CLS_U32 enabled and can be triggered by adding a large number of u32 filters or proto entries. The vulnerability has been resolved by adding proper exhaustion checks and returning errors when the node ID space is exhausted.
In the Linux kernel, the following vulnerability has been resolved: perf/x86/intel/pt: Fix stop/start with no update If pt_event_stop() is called without PERF_EF_UPDATE flag, then perf_aux_output_end() is not called. A subsequent call to pt_event_start() will call perf_aux_output_begin() again which violates the rule against nesting and triggers a WARNING in perf_aux_output_begin(). Originally, pt_event_stop() was never called without PERF_EF_UPDATE, because the only code paths to do so are from event overflow, and Intel PT does not do that. However the introduction of group throttling by commit 9734e25fbf5ae ("perf: Fix the throttle logic for a group") meant that an Intel PT event could be throttled if it was part of a group. Throttling calls PMU ->stop() / ->start() callbacks without flags. An example is when AUX area sampling is used. The following commands hit the issue: echo 10000 > /proc/sys/kernel/perf_event_max_sample_rate perf record -F32000 --aux-sample -e '{intel_pt//u,cycles:u}' \ -- bash -c 'for i in `seq 1 100000` ; do true ; done' Use PERF_HES_UPTODATE to track whether perf_aux_output_begin() and perf_aux_output_end() are balanced. A cleared PERF_HES_UPTODATE bit indicates that an AUX output context is still open. Amend pt_event_start() / pt_event_stop() accordingly so that begin/end stay balanced: - In non-snapshot mode, stop() always closes the buffer (the buffer may have run out of space, and that accounting is done by the update), so a following start() opens a fresh one as before. - In snapshot/overwrite mode, stop() without PERF_EF_UPDATE leaves the buffer open so that pt_event_snapshot_aux() can still copy from it, and start() then only re-enables tracing instead of calling perf_aux_output_begin() again. Note that pt_event_del() calls pt_event_stop() with PERF_EF_UPDATE flag set (as is required by the documentation), so a final call to perf_aux_output_end() is assured.
Unit 42 researchers identified that AWS AgentCore Harness's default configuration enables a built-in shell tool with root privileges, which can be exploited via prompt injection to exfiltrate plaintext credentials from the AgentCore Identity vault. The shell tool is enabled by default and can execute arbitrary shell commands with root access, posing a risk if allowedTools is not scoped properly. AWS reviewed the finding and classified it as informative under the shared responsibility model, emphasizing customer-side controls such as scoping allowedTools and egress filtering. Mitigation involves restricting allowedTools to only necessary tools, applying least privilege to identity vault service accounts, and monitoring outbound traffic from harness containers. No official patch or fix is indicated; remediation relies on configuration and operational controls.
A use-after-free vulnerability was identified and fixed in the ALSA core component of the Linux kernel in the snd_card_do_free() function. The flaw occurs when a sound card managed by devres is unbound while a user-space application still holds an open file descriptor, leading to a race condition where memory is freed prematurely and then accessed. This triggers a Kernel Address Sanitizer (KASAN) use-after-free error. The fix involves caching the managed flag before signaling completion to prevent dereferencing freed memory.
A use-after-free vulnerability in the Linux kernel's ARM architecture code was fixed by acquiring the mmap write lock around show_pte() for user faults. This issue occurs when CONFIG_DEBUG_USER=y and the kernel command line includes "user_debug=31", allowing concurrent munmap() calls to free page table pages while show_pte() is traversing them. On systems with CONFIG_ARM_LPAE=y, this can cause a kernel panic. The fix restricts show_pte() calls to user-space addresses and avoids locking for kernel faults to prevent deadlocks.
In the Linux kernel, the following vulnerability has been resolved: nvme-tcp: reject a read that transferred too few bytes nvme_tcp_recv_data() completes a request once the current C2HData PDU has been consumed. Nothing compares the total bytes received against the length the command asked for: struct nvme_tcp_request has no receive-side counter, queue->data_remaining is per queue, and blk_mq_end_request() completes for blk_rq_bytes(rq) unconditionally with no residual concept anywhere above. A controller can therefore answer a 4096-byte read with 512 bytes and have it reported as a complete read; user space then gets 4096 bytes of which 3584 are whatever was already in the page. I reproduced that with a test target. Count the bytes received and refuse to complete a successful read whose count does not match, at the two NVME_TCP_F_DATA_SUCCESS paths and in nvme_tcp_process_nvme_cqe(). The success test shifts req->status right by one, because the driver keeps the wire value there and shifts it on completion, so the check must see what the completion path will see. Only REQ_OP_READ is checked, because there the length comes from the sectors the request covers; a passthrough command is built by its submitter, which picks both command and buffer, so the kernel has nothing to compare against.
CVE-2026-89649 is a critical vulnerability in the Linux kernel's Ceph filesystem implementation. It involves improper bounds checking of the last extended attribute (xattr) value length in the __build_xattrs() function. A malicious or compromised Ceph metadata server can specify an oversized value length for the final attribute, causing the kernel to copy data beyond the allocated buffer into user space. This results in disclosure of adjacent kernel heap memory to a local user via the getxattr(2) system call.
A vulnerability in the Linux kernel's NTFS3 filesystem driver allows information leakage due to uninitialized kernel memory being exposed during partial LZNT decompression in the ni_read_frame() function. This occurs because decompress_lznt() may write fewer bytes than expected, leaving the remainder of the buffer uninitialized and potentially exposing kernel memory to userspace. This flaw can leak kernel pointers and defeat Kernel Address Space Layout Randomization (KASLR).
A buffer overflow vulnerability was identified and resolved in the Linux kernel's device mapper (dm) raid1 component. The issue involved insufficient space reserved for a NUL-terminator in the build_constructor_string() function, which could lead to overflow when formatting a long long value with sprintf().
In the Linux kernel, the following vulnerability has been resolved: net: tun: bound receive headroom tun_get_user() uses tun->align both as skb headroom and when choosing how much packet data to keep linear. OVS can propagate an oversized headroom request from another port to TUN or TAP. When align is larger than the usable space in a one-page skb head, SKB_MAX_HEAD(align) underflows and the result becomes negative when stored in good_linear. That value later wraps when assigned to the size_t linear variable, and tun_alloc_skb() can place skb->data outside the allocated head. Bound the headroom stored by TUN to the one-page skb-head budget and the largest non-sentinel 16-bit skb header offset. Leave one linear byte for raw TUN and a complete Ethernet header for TAP, including NET_IP_ALIGN. Also pull the raw-TUN protocol byte and the TAP Ethernet header before accessing them, so these checks remain safe for nonlinear skbs supplied by other allocation paths.
A vulnerability in the Linux kernel NFC subsystem involves uninitialized values in RF discover and activated notification handlers. Specifically, on-stack structures used to parse notifications are not zero-initialized when technology-specific parameters are absent, leading to uninitialized memory reads. This flaw affects certain Linux kernel versions and could expose uninitialized data to user space via NFC commands.
In the Linux kernel, the following vulnerability has been resolved: net: gro: properly validate BIG TCP aggregation criteria When GRO attempts to aggregate packets beyond GRO_LEGACY_MAX_SIZE (64KB), BIG TCP should only be permitted for plain IPv4 TCP and plain IPv6 TCP (with sufficient MAC header room to insert the temporary HBH jumbo header). However, commit b1a78b9b9886 ("net: add support for ipv4 big tcp") loosened the check in skb_gro_receive(), leading to several issues: 1. skb_gro_receive() checked skb_headroom(p) instead of the actual space before the MAC header (p->mac_header). Because skb_headroom(p) includes mac_len, crafted frames (e.g. injected via AF_PACKET) can pass the check with p->mac_header < 8 bytes. When ipv6_gro_complete() inserts the temporary HBH jumbo header, the memmove() starts before skb->head, causing an out-of-bounds write and wrapping skb->mac_header. 2. It allowed non-IP protocols such as software VLAN (ETH_P_8021Q / ETH_P_8021AD) to aggregate beyond 64KB because p->protocol != ETH_P_IPV6 was true. 3. It checked p->encapsulation instead of NAPI_GRO_CB(skb)->encap_mark, allowing encapsulated flows (e.g. SIT / IPv6-in-IPv4) to aggregate beyond 64KB. Fix skb_gro_receive() to strictly enforce: - NAPI_GRO_CB(skb)->proto == IPPROTO_TCP - Not encapsulated (!NAPI_GRO_CB(skb)->encap_mark && !p->encapsulation) - Protocol must be either ETH_P_IP or ETH_P_IPV6 - If ETH_P_IPV6, p->mac_header must be at least sizeof(struct hop_jumbo_hdr) Returning -E2BIG from skb_gro_receive() ensures that packets which cannot become BIG TCP are cleanly flushed at <= 64KB and delivered intact without dropping. This issue does not exist in mainline (7.0+) because the subsystem was rewritten in commit 81be30c1f5f2 ("net/ipv6: Drop HBH for BIG TCP on RX side"), making this fix relevant only for older stable branches like 6.18.y.