Description
Nimbus accepted the `uploadedJarLocation` argument of `submitTopology` / `submitTopologyWithOpts` as a
server-side path and opened it directly, without checking that it referred to a file the caller had
actually uploaded. The intended flow is that a client first calls `beginFileUpload`, which returns a path
inside the Nimbus inbox, and uploads the jar in chunks to that location; nothing bound submission to that
flow, and the `uploaders` map populated by `beginFileUpload` was never consulted at submit time.
An authenticated user with topology submission rights could therefore submit any path readable by the
Nimbus daemon user as their topology jar. Nimbus copied the file into the topology's jar blob, and the
blob ACL grants the submitting subject read access, so the contents could then be retrieved with the
ordinary blob download RPCs. Candidate targets include the Nimbus Kerberos keytab, Thrift and UI TLS
private keys, and `storm.yaml` with the ZooKeeper authentication payload. Possession of the Nimbus keytab
turns an ordinary tenant into a cluster administrator.
In a deployment configured as the documentation recommends, submission is available to every
authenticated principal when `nimbus.users` is unset, so no elevated privilege is required.
Mitigation
Upgrade to 3.1.0, where the submitted location is canonicalised and must resolve inside the Nimbus inbox.
Users who cannot upgrade immediately should restrict topology submission to trusted principals via
`nimbus.users` or `nimbus.groups`, and should treat any file readable by the Nimbus daemon user as
potentially exposed to submitters: rotate the Nimbus keytab and any TLS private keys or ZooKeeper
credentials reachable from that account. Local mode is unaffected.
Credit
Independently reported to the Apache Storm PMC by n0mi1k, with a proof of concept.
Also found by the ASF using Claude agents to study the security of open-source projects, validated and reported by Apache Storm.
A vulnerability in the Linux kernel's memory management pagewalk code causes an out-of-bounds write due to improper handling of walk->action state during page table walks. This bug was introduced after a specific commit and leads to duplicate callbacks and memory corruption when certain conditions occur. The issue was identified by a local fuzzer and affects multiple specific Linux kernel versions.
CVE-2026-80995 is a use-after-free vulnerability in the Linux kernel's MCTP (Management Component Transport Protocol) implementation. The flaw occurs because mctp_route_lookup() uses a route device pointer without holding a proper reference, allowing concurrent teardown and leading to a use-after-free condition. This vulnerability can be triggered by an unprivileged local user via the AF_MCTP socket interface without requiring CAP_NET_RAW privileges. The issue is related to improper reference counting and was introduced by a change that moved source address lookup ahead of destination device reference acquisition.
A use-after-free vulnerability exists in the Linux kernel's NFSD component related to the unlock_filesystem interface. This flaw occurs when a local administrator stops the NFS server and then writes to /proc/fs/nfsd/unlock_filesystem, causing the system to access freed memory. The issue arises because the cancellation of async COPY operations happens before proper locking and verification that the server is running. This vulnerability has been resolved by moving the async COPY cancel operation into a protected section that ensures the server is running before accessing state tables.
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 memory leak vulnerability in the Linux kernel's ocfs2 filesystem was identified and resolved. The issue occurs during copy-on-write operations, specifically when using copy_file_range() within the same filesystem, causing unreferenced memory objects. This flaw was detected through local fuzzing on kernel version 6.12.94 and involves failure to properly run deallocations on copy-on-write completion.
A use-after-free vulnerability in the Linux kernel's IPMI subsystem was fixed by restoring a missing synchronize_rcu() call before freeing command receivers. This flaw could allow local attackers with limited privileges to cause memory corruption, potentially leading to high impact on confidentiality, integrity, and availability.
A high-severity vulnerability in the Linux kernel's dm-pcache component allows a local user with CAP_SYS_ADMIN privileges to cause out-of-bounds reads by supplying a segment offset (seg_off) that is at or beyond the segment's data size. This flaw was addressed by bounding the persisted tail-position offset to prevent reading past the segment data.
In the Linux kernel, the following vulnerability has been resolved: seg6: reset IP6CB after IPv6 decapsulation decap_and_validate() pulls the outer SRv6 headers and makes the inner packet the skb network header. The IPv6 control block still contains values collected while parsing the outer packet, including nhoff and extension-header flags. End.DX6 and End.DT6 route the inner IPv6 packet directly to the IPv6 input path. An unprivileged user can reach End.DT6 from a user and net namespace by installing a local SID and injecting an outer packet with Hop-by-Hop and Destination Options headers followed by an SRH and a minimal inner IPv6 packet. The outer extension headers leave a large nhoff in IP6CB. After decapsulation, ip6_protocol_deliver_rcu() uses that stale offset on the inner packet and reads beyond the skb head. KASAN reports: BUG: KASAN: slab-out-of-bounds in ip6_protocol_deliver_rcu ip6_protocol_deliver_rcu+0x1118/0x1450 ip6_input_finish+0x11b/0x240 seg6_local_input_core+0xed/0x2e0 lwtunnel_input+0x1e9/0x4e0 ipv6_rthdr_rcv+0x525f/0x6c50 ip6_protocol_deliver_rcu+0xcb7/0x1450 Before clearing IP6CB for an inner IPv6 packet, save its incoming interface index and L3 slave state. Restore both after the clear and set nhoff to the inner IPv6 base-header nexthdr field. Use IP6CB(skb)->iif rather than skb->skb_iif because VRF processing can replace skb_iif with the L3 master while IP6CB keeps the receiving interface. Preserve IP6SKB_L3SLAVE for the same reason.
In the Linux kernel, the following vulnerability has been resolved: net: skbuff: don't touch shared zerocopy state in skb_tx_error() skb_tx_error() completes the zerocopy uarg and clears SKBFL_ALL_ZEROCOPY, and skb_zcopy_downgrade_managed() clears SKBFL_MANAGED_FRAG_REFS. Both live in skb_shinfo(), which every clone shares, while the caller only owns the reference it is about to drop. Through a clone it tells the producer its pages are free and drops SKBFL_SHARED_FRAG for an skb that is still in flight. Open vSwitch reaches this with a non-last OVS_ACTION_ATTR_RECIRC: clone_execute() sends a skb_clone() into ovs_dp_process_packet() while do_execute_actions() keeps forwarding the original, and skb_clone() does not privatise the frags here -- skb_orphan_frags() returns early on SKBFL_DONT_ORPHAN. A flow miss on the clone then strips the marker from the packet still being forwarded, and a later local ESP delivery decrypts in place over frags it does not own privately. Skip it for a cloned skb. Nothing is lost: skb_release_data() clears the zerocopy state once the last reference to the shared data goes.
A vulnerability in the Linux kernel's Open vSwitch (openvswitch) component was resolved that involved improper handling of packet skb flags during error processing. The issue caused the stripping of the SKBFL_SHARED_FRAG flag on a live socket buffer (skb) that was still being forwarded, leading to an unprivileged write to page-cache memory. This was due to skb_tx_error() being called on a packet that was not yet dropped, affecting in-place decryption of ESP-in-UDP packets and enabling a local page-cache write primitive. The fix moves the skb_tx_error() call to the appropriate flow-miss drop path to prevent this unsafe modification.
In the Linux kernel, the following vulnerability has been resolved: sctp: fix NULL deref on untransmitted RECONF completion sctp_process_strreset_outreq(), sctp_process_strreset_addstrm_out() and sctp_process_strreset_resp() complete a pending stream reconfiguration request by stopping the reconf timer on the transport it was sent on: t = asoc->strreset_chunk->transport; if (timer_delete(&t->reconf_timer)) sctp_transport_put(t); chunk->transport is assigned by __sctp_packet_append_chunk() when the chunk is appended to an outbound packet, and sctp_outq_flush_ctrl() arms the reconf timer at that same point. A request already published in asoc->strreset_chunk but not yet transmitted has neither, so completing it dereferences NULL. Two ways to get there. sctp_send_asconf_del_ip() sets asoc->src_out_of_asoc_ok without sending anything when the address being removed is the association's last one, and sctp_outq_flush_ctrl() then leaves every non-ASCONF control chunk queued; as only sctp_process_asconf_ack() clears that flag, it persists. An unprivileged process that removes such an address and then asks for a stream reset panics the kernel from softirq. A peer needs neither ASCONF nor local help: sctp_cmd_interpreter() uncorks the outqueue only once the whole packet has been processed, so a reply built while walking a RECONF chunk stays untransmitted for the rest of that walk, and one RECONF chunk carrying [Incoming SSN Reset Request, Outgoing SSN Reset Request, Response] -- or two RECONF chunks in one packet -- reaches the same dereference. KASAN: null-ptr-deref in range [0x00000000000001e8-0x00000000000001ef] RIP: 0010:timer_delete+0x67/0x110 Call Trace: <IRQ> sctp_process_strreset_addstrm_out (net/sctp/stream.c:832) sctp_sf_do_reconf (net/sctp/sm_statefuns.c:4212) sctp_do_sm (net/sctp/sm_sideeffect.c:1172) sctp_assoc_bh_rcv (net/sctp/associola.c:1044) sctp_rcv (net/sctp/input.c:243) ip_local_deliver (net/ipv4/ip_input.c:262) process_backlog (net/core/dev.c:6680) </IRQ> A response can only acknowledge a request that was actually sent, so do not match asoc->strreset_chunk while chunk->transport is NULL. Guarding the lookup covers all three completion sites.
A vulnerability in the Linux kernel's cxl/features component allows an attacker with local privileges to cause an out-of-bounds read and potentially crash the kernel (kernel oops). This occurs because the fwctl_cmd_rpc() function copies a user-controlled payload without properly validating the size parameters, leading to reading beyond the allocated buffer. The flaw affects specific Linux kernel versions used in the linux-hwe-edge product line.
A vulnerability in the Linux kernel's ACPI APEI GHES component involving improper use of spinlock types for CXL CPER work locks has been resolved. The issue caused a potential deadlock when interrupts occurred on the same CPU holding a spinlock with local interrupts enabled. The fix involves converting spinlock_t to raw_spinlock_t and restructuring work registration and unregistration to prevent race conditions and stale work execution.
A local privilege escalation vulnerability exists in the iDirect iQ200 VSAT terminal running firmware 23.0.1.0. The iQ200 is a rackmount satellite modem deployed across oil and gas, maritime, defense, and remote infrastructure as the primary, and often sole communications link for offshore rigs, vessels, and remote sites. Important context: the device ships from the factory with a pre-configured low-privilege local user account. This account is intended for field technicians who need shell access for maintenance and diagnostics but should not have full administrative control over the device. This built-in account provides the initial access required to exploit this vulnerability. No additional credentials need to be obtained or brute-forced.
NetBSD contains a use-after-free and double-free vulnerability in msg_recv_copyin() within the COMPAT_NETBSD32 compatibility layer due to a missing return statement before the cleanup label on the success path. Any local user able to execute a 32-bit binary on a 64-bit NetBSD system can trigger a kernel panic or memory corruption by calling recvmsg() with msg_iovlen between 9 and IOV_MAX, causing the kernel to access a freed iovec buffer and subsequently free the same allocation a second time.
CVE-2026-18994 is a high-severity vulnerability in the Lenovo File Manager Android Application, distributed exclusively in the Chinese market. It involves improper authorization due to improper export of application components, allowing a local authenticated user to read or modify protected files within the app. The affected versions are all versions prior to 9.8.1.77. There is no information about an available patch or official fix at this time.
GitPython versions up to 3.1.58 contain a vulnerability in the TagReference.create() method where a positional 'reference' argument bypasses the unsafe option guard for '--file', enabling an attacker to read arbitrary local files. This occurs because the guard only inspects keyword arguments, allowing '--file=<path>' passed positionally to reach the underlying git tag command and return file contents as the annotated tag message. The vulnerability requires the embedding application to forward user-controlled input to this method. A fix is available in version 0.7.2_7.
CVE-2026-21086 is a medium severity vulnerability in the ProxyHandler component prior to SMR Aug-2026 Release 1. It involves improper authorization that allows local attackers to access proxy configuration settings without proper permissions. No patch or remediation information is provided in the available data. The vulnerability requires local access and does not involve user interaction. There are no known exploits in the wild at this time.