Denial Of Service
Monthly
Improper input validation in the modem firmware component of 22 MediaTek chipsets allows a local user-privileged process to trigger a system crash, resulting in a denial of service. The flaw, tracked as patch ID MOLY01810811 / MSV-9232, requires user interaction to trigger and is confined to an unprivileged local context, limiting its practical impact to availability disruption rather than data exposure or code execution. No public exploit has been identified and SSVC rates exploitation as none at this time.
NULL-pointer dereference in code handling Authentication and Key Agreement (AKA) Synchronization-Failure messages causes a process crash when a malformed or unexpected AKA-Synchronization-Failure response is processed. The vulnerability affects software that implements 3GPP AKA authentication - a protocol used in mobile network authentication (3G/4G/5G) and EAP-AKA for Wi-Fi/IMS - as packaged by Ubuntu. No public exploit or CISA KEV listing has been identified at time of analysis, and the primary real-world impact is denial of service via crash of the authentication handling daemon.
Unbounded iteration during PKCS#7 container decryption exposes affected systems to a denial-of-service condition where a crafted cryptographic payload causes a parsing loop to run without termination bounds. The specific library or package is not identified in the available intelligence - Ubuntu is the reporting source, suggesting this affects a cryptographic library they distribute (candidates include OpenSSL, GnuTLS, NSS, or similar). An attacker able to supply a malformed PKCS#7 container to a vulnerable parsing routine can exhaust CPU resources and halt service availability. No public exploit has been identified at time of analysis, and no CVSS score or severity rating has been assigned.
Infinite-loop denial of service in libpcap's BPF interpreter allows a local low-privileged attacker to hang any process that evaluates a crafted BPF filter program via pcap_offline_filter(). The 'ja L' (jump always) instruction stores its target offset as a signed integer, enabling backward jumps that implement looping, but the interpreter imposed no cap on iterations, so a self-referential or backward-looping filter causes unbounded CPU consumption. The upstream fix (commit ff3c83475a) introduces a MAX_BACKWARD_JUMPS limit of 64 per packet and adds validator rejection of self-jumps; no active exploitation or public exploit code has been identified at time of analysis.
Missing authorization on the Subsonic startScan endpoint in gonic before v0.22.0 permits any authenticated user - not just administrators - to repeatedly trigger CPU- and I/O-intensive media library filesystem scans. Multi-user gonic instances are the meaningful target: an attacker with a regular account can flood the endpoint to exhaust server resources and deny service to all users. No public exploit code has been identified at time of analysis, and the patch is available in v0.22.0.
NULL pointer dereference in libxml2's xmlRegNewParserCtxt() function crashes any application invoking the XML regular-expression engine under memory-pressure conditions. Versions before 2.15.4 call strlen() on the return value of xmlStrdup() without first verifying the pointer is non-NULL; when strdup() fails due to memory exhaustion, the subsequent strlen(NULL) causes a process crash. No confidentiality or integrity impact is possible - the vulnerability is limited to a local, high-complexity denial-of-service. No public exploit or CISA KEV listing exists; the fix shipped in libxml2 2.15.4.
Unthrottled resource allocation in freegpt-webui's getJailbreak function (server/backend.py) enables remote unauthenticated attackers to exhaust server resources via crafted Jailbreak Mode requests (CWE-770). The affected product is an unmaintained hobby GPT wrapper by ramon-victor, pinned to all commits through 098db3dfeb41555c2ca9269df0f13e10ec1c35dc with no patched release forthcoming. A public proof-of-concept exploit is available on GitHub, and no vendor fix will be issued as the maintainer has abandoned the project.
Privilege escalation and kernel DoS in PassMark's shared DirectIo64.sys kernel driver affect PerformanceTest (before 11.1 build 1012), BurnInTest (before 11.1 build 1000), and OSForensics (before 11.1 build 1016), allowing a local low-privileged attacker to read arbitrary Model-Specific Registers or write zero to any MSR via IOCTLs with an insufficient blocklist. Writing zero to the system call handler MSR (e.g., IA32_LSTAR) causes an immediate unrecoverable kernel panic on the next system call, while reading security-sensitive MSRs (such as those storing kernel base addresses) enables KASLR bypass to support privilege escalation chains. A public proof-of-concept is available via GitHub, and vendor patches have been released; no KEV listing at time of analysis.
Heap out-of-bounds read in libtpms during TPM 2.0 state restoration allows an adjacent unauthenticated attacker to crash the swtpm process and deny TPM services to dependent virtual machines. The flaw arises in the state-blob parser: an attacker-controlled oversized skip-block length drives the internal INT32 size counter negative; subsequent bounds checks cast that counter to UINT32, wrapping it to a large positive value and bypassing the check, which then drives the parser to read memory outside the heap buffer. Vendor and upstream commit confirm the impact is denial of service only - no data corruption or information disclosure was confirmed. No public exploit or CISA KEV listing has been identified.
In the Linux kernel, the following vulnerability has been resolved: mshv: Order pt_vp_array publish against irqfd assertion path mshv_partition_ioctl_create_vp() initialises a VP struct (allocations, mutex_init, init_waitqueue_head, page mappings) and then publishes the pointer into partition->pt_vp_array. Several ISR paths read this array locklessly: the intercept ISR, the two scheduler ISRs, and mshv_try_assert_irq_fast() on the irqfd fast path. Of these, only mshv_try_assert_irq_fast() can structurally race the publish. It runs from an eventfd waker without holding pt_mutex, and MSHV_IRQFD does not require the target lapic_apic_id (== vp_index) to refer to an existing VP at registration time. A user can therefore register an irqfd targeting a yet-to-be-created VP, then trigger mshv_try_assert_irq_fast() concurrently with MSHV_CREATE_VP for the same index. On weakly-ordered architectures the reader can observe a non-NULL pointer in pt_vp_array before the initialising stores to the VP struct become visible, leading to use of partially-initialised fields (e.g. vp_register_page). The other ISR readers cannot reach this race: the hypervisor will not generate intercept or scheduler messages for a VP that has never been told to run, and the user can only call MSHV_RUN_VP on the VP fd returned by MSHV_CREATE_VP, which by construction is returned after the publish. Leave those readers as plain loads. Use smp_store_release() in mshv_partition_ioctl_create_vp() to publish the pointer, and pair it with smp_load_acquire() in mshv_try_assert_irq_fast(). On x86 these compile to plain accesses under TSO; on ARM64 they emit one-instruction acquire/release barriers, acceptable on this fast path. The destroy-side path (destroy_partition() clearing pt_vp_array[i] to NULL after kfree(vp)) has a separate ordering and lifetime concern that is out of scope here.
Memory exhaustion via compression bomb in undici's decompress interceptor (versions 7.15.0-<7.29.1 and 8.0.0-<8.10.2) allows a malicious or compromised upstream HTTP server to crash a Node.js process by returning a small compressed payload that expands to hundreds of megabytes in client heap memory. The interceptor respects the untrusted Content-Encoding header and enforces no ceiling on total decompressed output size, making the attack purely asymmetric - a kilobyte-scale upstream payload can trigger unbounded client-side allocation. No public exploit has been identified and the vulnerability is not in the CISA KEV catalog; fixed versions 7.29.1 and 8.10.2 are available.
Chunked-body handling in undici's dump interceptor triggers a double-completion assertion that tears down the underlying TCP connection while returning a misleading success status to the application. Affected are undici versions 7.1.0 through 7.29.0 and 8.0.0 through 8.10.1; fixed releases 7.29.1 and 8.10.2 are available. No public exploit or active exploitation has been identified; the CVSS 3.7 score reflects the high attack complexity and limited real-world impact relative to the narrow exploitation path.
In the Linux kernel, the following vulnerability has been resolved: serial: msm: Disable DMA for kernel console UART At the moment, concurrent writes from userspace and the kernel to the console can trigger a race condition that results in an infinite loop of the same messages printed over and over again. This is most likely to happen during system startup or shutdown when the init system starts/stops a large number of system services that interact with various kernel code. When userspace writes to the TTY device, the driver initiates an asynchronous DMA transfer and releases the port lock. At the same moment, the kernel printk path might grab the port lock and re-configure the UART controller for PIO, without waiting for the DMA operation to complete. It seems like this collision results in zero progress being reported for the DMA engine, so the same text is printed to the console over and over again. For the kernel console, we want a reliable output path that will be functional even during crashes etc. So rather than implementing complex code to synchronize the kernel console write routines with the userspace DMA write routines, simply disable DMA for the console UART instance. Similar checks exist in many other serial drivers, e.g. 8250_port.c, imx.c, sh-sci.c etc.
Out-of-bounds read in IBM Db2 Mirror for i versions 7.4, 7.5, and 7.6 enables a remote unauthenticated attacker to cause a denial of service by sending a crafted network request to the mirroring service. The flaw (CWE-125) is exploitable with no authentication or user interaction and can disrupt high-availability replication continuity. IBM has released a patch via advisory node/7285904; no public exploit code has been identified at time of analysis.
Stack-based buffer overflow in IBM i 7.3 through 7.6 allows remote authenticated attackers to cause a denial of service by sending specially crafted network input that exceeds a stack-allocated buffer in a network-accessible component. The vulnerability is gated behind low-privilege authentication (PR:L) and carries no confidentiality or integrity impact, as IBM's advisory scores it CVSS 4.3 with A:L. No public exploit code or active exploitation has been identified; a vendor-released patch is available via the IBM support portal.
Stack-based buffer overflow in IBM i 7.3 through 7.6 allows an authenticated local attacker to crash the system, producing a denial of service with no confidentiality or integrity impact. The flaw is classified as CWE-121 and is limited in severity by both the access prerequisites and the bounded availability-only outcome. A vendor patch is available via IBM's support portal, and no public exploit code has been identified at time of analysis.
Denial of service in IBM i 7.3 through 7.6 is achievable by any remote authenticated low-privilege user via a NULL pointer dereference, causing complete availability loss with no data exposure. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) confirms low-complexity network exploitation requiring only a valid user account and no user interaction. No public exploit code and no CISA KEV listing have been identified at time of analysis; IBM has released a patch via its support portal.
Uncontrolled recursion in IBM App Connect Enterprise (versions 12.x and 13.x) and IBM Integration Bus for z/OS (version 10.1.x) allows a local authenticated attacker to crash the integration runtime via stack exhaustion, resulting in a denial of service. The flaw is classified as CWE-674 and affects a broad version range across both product lines, with a vendor-released patch now available. No public exploit code or active exploitation has been identified at time of analysis.
Denial of service on IBM i versions 7.3 through 7.6 is achievable by exploiting an off-by-one write in the LPD (Line Printer Daemon) queue name parser, corrupting adjacent memory and crashing the affected service. The vendor description specifies a local authenticated attacker as the threat actor, yet IBM's own submitted CVSS vector (AV:N/AC:L/PR:N/UI:N) characterizes this as an unauthenticated network-reachable flaw - a direct contradiction that materially affects risk prioritization. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.
Integer overflow in IBM i versions 7.3 through 7.6 allows remote authenticated attackers to cause a denial of service condition. The vulnerability (CWE-190) is network-reachable but requires prior authentication, and its impact is limited to partial availability degradation with no confidentiality or integrity consequences. IBM has released a patch, and no public exploit code or CISA KEV listing has been identified at time of analysis.
IBM i versions 7.3 through 7.6 expose authenticated remote attackers to a denial-of-service condition via a memory leak (CWE-401). An attacker with low-privilege credentials can repeatedly trigger the vulnerable code path over the network, causing progressive memory exhaustion that degrades or halts system services. No active exploitation has been identified, and IBM has released a patch via Security Advisory 7285844.
Process-crashing denial of service in undici's WebSocket permessage-deflate implementation allows a remote unauthenticated attacker to terminate any Node.js process hosting the affected client by sending a crafted compressed WebSocket frame. The size-limit enforcement routine strips all event listeners - including the error handler - from the zlib inflate stream while the stream is still active; a subsequent malformed DEFLATE byte then emits an uncaught error that Node.js treats as a fatal unhandled exception, killing the process. Versions 6.25.0-6.28.0, 7.28.0-7.29.0, and 8.1.0-8.10.1 are confirmed affected; fixed releases are available per OpenJS advisory GHSA-3wwx-pv8p-q78v, and no public exploit has been identified at time of analysis.
In the Linux kernel, the following vulnerability has been resolved: tcp: fix AO info use-after-free in tcp_ao_connect_init() tcp_v4_connect() adds a SYN-SENT socket to the ehash before calling tcp_connect(). If TCP-AO is configured, tcp_connect() first verifies that a key matches the peer and the bound device's current L3 master. tcp_ao_connect_init() later resolves the L3 master again and removes keys which do not match it. The socket lock does not stabilize the bound device's VRF membership. Detaching the device from its VRF between the initial validation and the L3-master calculation in tcp_ao_connect_init() can therefore make the validation succeed while initialization observes the default L3 domain and removes the only key. The subsequent AO lookup then fails, so the no-key path clears tp->ao_info and frees it directly. The receive path can find the socket in the ehash and load tp->ao_info under RCU before acquiring the socket lock. A reader which loaded the old pointer can thus continue into tcp_inbound_ao_hash() after the direct free. The issue was found during a static audit of TCP-AO object lifetime. An unprivileged reproducer in self-created user and network namespaces raced connect() with detaching a veth from its VRF while sending TCP-AO segments. It triggered the same KASAN report on two fresh boots: BUG: KASAN: slab-use-after-free in tcp_inbound_ao_hash+0x585/0x19f0 Write of size 8 at addr ffff88800bf88128 by task tcp_ao_vrf_race/232 Call Trace: tcp_inbound_ao_hash+0x585/0x19f0 tcp_inbound_hash+0x677/0xa80 tcp_v4_rcv+0x1c3e/0x3ab0 Allocated by task 235: tcp_ao_alloc_info+0x43/0xf0 tcp_ao_add_cmd+0xdf7/0x13b0 do_tcp_setsockopt+0x168c/0x2640 Freed by task 235: kfree+0x1b8/0x550 tcp_connect+0x252/0x4f00 tcp_v4_connect+0x1114/0x1720 The bad address is 40 bytes inside the freed 128-byte object, matching the tcp_ao_info counters.key_not_found field. The two runs used 1000 attempts each, reached the no-key path 366 and 411 times, and produced one and two KASAN reports respectively. With this change, the same reproducer reached the no-key path 366 times in 1000 attempts without a KASAN report or oops. Use tcp_ao_destroy_sock() for the no-key path. It unpublishes the AO info, updates the socket memory and static-key accounting, and defers the free until after an RCU grace period. Also drop the WARN_ON_ONCE() and its stale comment. The VRF detach race makes the no-key state reachable during normal operation, so it is a handled condition rather than an impossible assertion. On panic_on_warn kernels the WARN would turn this handled race into a kernel panic.
In the Linux kernel, the following vulnerability has been resolved: net/packet: defer vmalloc TX_RING free until skbs finish AF_PACKET TX_RING skbs keep a raw pointer to their ring frame. The skb page references preserve page-backed ring blocks after pg_vec is freed, but they do not preserve a vmalloc mapping. tpacket_destruct_skb() currently drops the pending reference before writing the timestamp and TP_STATUS_AVAILABLE to the frame. Move the decrement after those stores. The smp_wmb() in __packet_set_status() orders the frame stores before the decrement. Also recheck pending TX frames under pg_vec_lock before non-closing ring replacement, so a racing send cannot add a pending skb between the initial check and the ring swap. Ring allocation can produce a mixture of page-backed and vmalloc-backed blocks. Allocate deferred-work storage during TX ring setup when the first vmalloc-backed block is encountered, and keep its pointer in the pg_vec allocation header. If allocation fails, return -ENOMEM from ring setup. On socket close, a non-NULL pointer identifies a vmalloc-backed vector without a scan. If TX skbs remain, defer the whole vector to system_long_wq. After pg_vec is detached, a late destructor can skip the pending decrement. Use socket write-memory accounting as the deferred lifetime gate instead: an skb remains charged through its final sock_wfree(), after all ring-frame accesses. The delayed work retains a socket reference and reschedules itself until no TX skbs remain. Move pending_refcnt release to packet_sock_destruct() so late skb destructors and deferred cleanup can safely use it after packet_release(). Page-backed teardown remains synchronous, and no lock is added to the TX completion hot path.
Resource exhaustion in IBM MQ Agent CD (v1.0.0-v2.0.1) allows any authenticated console user to monopolize the LLM agent worker pool by submitting arbitrarily large or computationally expensive requests. When multiple such requests are issued concurrently, all available agent workers remain occupied for extended periods - from tens of seconds to over ten minutes each - causing complete unavailability of the AI Agent feature for all other IBM MQ Console users. No public exploit code has been identified at time of analysis, and exploitation requires a valid authenticated session.
In the Linux kernel, the following vulnerability has been resolved: iommu/iommufd: Fix NULL pointer deref in iommufd_ioas_change_process when racing with iopt_map_file_pages iommufd_ioas_change_process() iterates every IOAS area while only holding every IOAS iova_rwsem, so it assumes every area has a non-NULL pages pointer. That assumption can be false when it runs concurrently with iopt_map_file_pages(). iopt_map_pages() executes in two phases. It first creates the area and inserts it into the interval tree under iova_rwsem, with area->pages still NULL. It then drops iova_rwsem and later fills area->pages under domains_rwsem. This leaves a window between area creation and area->pages fill where a concurrent iommufd_ioas_change_process() can observe the area and dereference a NULL area->pages pointer, leading to a NULL pointer dereference: BUG: kernel NULL pointer dereference, address: 00000000000000c0 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 4b655067 P4D 4b655067 PUD 0 Oops: Oops: 0000 [#1] SMP NOPTI CPU: 0 UID: 0 PID: 11841 Comm: syz.1.628 Not tainted 7.1.0 #3 PREEMPT(full) Hardware name: QEMU Ubuntu 24.04 PC v2 (i440FX + PIIX, arch_caps fix, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 RIP: 0010:iommufd_ioas_change_process+0x419/0xd50 drivers/iommu/iommufd/ioas.c:538 Code: 48 89 c3 48 85 c0 0f 84 cc 00 00 00 e8 10 f5 cb fd 48 8d 7b 68 e8 a7 b5 eb fd 48 8b 6b 68 48 8d bd c0 00 00 00 e8 17 b2 eb fd <8b> ad c0 00 00 00 bf 01 00 00 00 89 ee e8 85 ef cb fd 83 fd 01 74 RSP: 0018:ffffc90015c17d28 EFLAGS: 00010246 RAX: ffff8880186d5328 RBX: ffff88801d25e240 RCX: 0000000080000000 RDX: 00000000000002d7 RSI: ffffffff83ba9e10 RDI: 00000000000000c0 RBP: 0000000000000000 R08: ffffffff8e781eb8 R09: 0000000000000000 R10: 00000000000000c0 R11: ffffffff83ba9e29 R12: ffff88802e216008 R13: ffff88802e216000 R14: 0000000000000001 R15: 0000000000000000 FS: 00007f4aea3f66c0(0000) GS:ffff8880b1fa1000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00000000000000c0 CR3: 000000004b75c000 CR4: 0000000000350ef0 Call Trace: <TASK> iommufd_fops_ioctl+0x287/0x400 drivers/iommu/iommufd/main.c:533 vfs_ioctl fs/ioctl.c:51 [inline] __do_sys_ioctl fs/ioctl.c:597 [inline] __se_sys_ioctl fs/ioctl.c:583 [inline] __x64_sys_ioctl+0x120/0x170 fs/ioctl.c:583 x64_sys_call+0x1092/0x1fb0 arch/x86/include/generated/asm/syscalls_64.h:17 do_syscall_x64 arch/x86/entry/syscall_64.c:63 [inline] do_syscall_64+0x10a/0x680 arch/x86/entry/syscall_64.c:94 entry_SYSCALL_64_after_hwframe+0x77/0x7f RIP: 0033:0x7f4aec1a82bd Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b0 ff ff ff f7 d8 64 89 01 48 RSP: 002b:00007f4aea3f6018 EFLAGS: 00000246 ORIG_RAX: 0000000000000010 RAX: ffffffffffffffda RBX: 00007f4aec436090 RCX: 00007f4aec1a82bd RDX: 0000200000000180 RSI: 0000000000003b92 RDI: 0000000000000003 RBP: 00007f4aec250295 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000 R13: 00007f4aec436128 R14: 00007f4aec436090 R15: 00007ffd04ef23e0 </TASK> Modules linked in: CR2: 00000000000000c0 ---[ end trace 0000000000000000 ]--- RIP: 0010:iommufd_ioas_change_process+0x419/0xd50 drivers/iommu/iommufd/ioas.c:538 Code: 48 89 c3 48 85 c0 0f 84 cc 00 00 00 e8 10 f5 cb fd 48 8d 7b 68 e8 a7 b5 eb fd 48 8b 6b 68 48 8d bd c0 00 00 00 e8 17 b2 eb fd <8b> ad c0 00 00 00 bf 01 00 00 00 89 ee e8 85 ef cb fd 83 fd 01 74 RSP: 0018:ffffc90015c17d28 EFLAGS: 00010246 RAX: ffff8880186d5328 RBX: ffff88801d25e240 RCX: 0000000080000000 RDX: 00000000000002d7 RSI: ffffffff83ba9e10 RDI: 00000000000000c0 RBP: 0000000000000000 R08: ffffffff8e781eb8 R09: 0000000000000000 R10: 00000000000000c0 R11: ffffffff83ba9e29 R12: ffff88802e216008 R13: ffff88802e216000 R14: 0000000000000001 R15: 0000000000000000 FS: 00007f4aea3f66c0(000 ---truncated---
In the Linux kernel, the following vulnerability has been resolved: ALSA: FCP: Use a private URB for the notification endpoint fcp_init_notify() used mixer->urb, which snd_usb_mixer_status_create() allocates for the optional UAC2 status interrupt endpoint and mixer.c kills, resubmits and frees. On a device with that endpoint, fcp_init_notify()'s "already set up" early return fires on the status URB and returns success without doing anything. No FCP notification URB is submitted, and cmd_done is left zeroed because it is initialised past that early return and nowhere else. fcp_init() then issues init1_opcode and wait_for_completion_timeout() would crash adding to the zeroed wait.head. fcp_cleanup_urb() would also kill and free mixer.c's status URB. Use a separate URB in fcp_data, and initialise cmd_done in fcp_init_private() where fcp_data is allocated. fcp_init_notify() is reached again after suspend via fcp_reinit(), and the URB kill path in fcp_notify() completes cmd_done, leaving a stale count that would satisfy the next command's wait before the device ACKs. Use reinit_completion() to clear it.
In the Linux kernel, the following vulnerability has been resolved: ALSA: scarlett2: Use a private URB for the notification endpoint scarlett2_init_notify() used mixer->urb, which snd_usb_mixer_status_create() allocates for the UAC2 status interrupt endpoint and mixer.c manages. On a device with that endpoint, the "already in use" check fires on the status URB and returns 0 for success without doing anything. No notification URB is submitted, and cmd_done is left zeroed because it is initialised past that check and nowhere else. scarlett2_usb_init() then issues SCARLETT2_USB_INIT_1 and wait_for_completion_timeout() would crash adding to the zeroed wait.head. Use a separate URB in scarlett2_data, as done for FCP, and initialise cmd_done in scarlett2_init_private(). mixer.c was also freeing the URB in snd_usb_mixer_free() and resubmitting it in snd_usb_mixer_activate(), so scarlett2 must now do both: add scarlett2_cleanup_urb(), called from private_free and private_suspend, and a private_resume callback to re-establish the URB after resume. scarlett2_init_notify() is reached from there, and the URB kill path in scarlett2_notify() completes cmd_done, leaving a stale count that would satisfy the next command's wait before the device ACKs. Use reinit_completion() to clear it. Also free the URB if the transfer buffer allocation fails, and both if usb_submit_urb() fails. Move scarlett2_init_notify() up next to scarlett2_cleanup_urb() so scarlett2_init_private() can reference it without a forward declaration.
In the Linux kernel, the following vulnerability has been resolved: nvmet: fix NULL pointer dereference in nvmet_execute_identify_nslist() When a host issues an Identify command with CNS 07h (Active Namespace ID List for a specific I/O Command Set), nvmet_execute_identify_nslist() is called with match_css set. The command-set filter dereferences req->ns, but this handler never calls nvmet_req_find_ns(), so req->ns is always NULL (nvmet_req_init() resets it to NULL). As soon as an enabled namespace with an NSID greater than the requested value exists, req->ns->csi dereferences a NULL pointer and oopses. Besides the crash, the comparison is logically wrong: to filter the list by command set it must test the command set of the namespace being iterated, not a single fixed value. Use the loop variable ns->csi.
In the Linux kernel, the following vulnerability has been resolved: ipv6: fix use-after-free in ip6_finish_output2() ip6_finish_output2() caches a pointer to the IPv6 destination address (daddr) before invoking lwtunnel_xmit(). The LWT-BPF transmit path or other encapsulation operations within lwtunnel_xmit() can reallocate the skb head, freeing the memory that daddr points to. When lwtunnel_xmit() returns LWTUNNEL_XMIT_CONTINUE, the function continues to use the stale daddr pointer to compute the nexthop and to look up or create the neighbour entry. This results in a use-after-free read, which can leak sensitive kernel data, pollute the neighbour table with arbitrary values, misdirect traffic, or crash the system. Fix this by re-fetching the IPv6 header and the destination address pointer after lwtunnel_xmit() returns LWTUNNEL_XMIT_CONTINUE, ensuring that the subsequent nexthop computation and neighbour lookup operate on valid memory.
In the Linux kernel, the following vulnerability has been resolved: HID: hyperv: validate initial device info bounds The Hyper-V synthetic HID host supplies SYNTH_HID_INITIAL_DEVICE_INFO messages that contain a HID descriptor followed by the report descriptor bytes. mousevsc_on_receive_device_info() trusts bLength and wDescriptorLength without checking that the received packet contains both byte ranges. A malformed host or backend message can therefore make the guest read past the received VMBus packet while copying the report descriptor. Pass the received initial-device-info size into the parser and reject descriptor lengths that exceed the packet. Impact: A malicious Hyper-V host or backend can crash a guest by sending a short initial device-info message with an oversized HID report descriptor length.
Out-of-bounds read in Turso through 0.8.0-pre.8 crashes any application that opens a crafted database file, causing denial of service. The table-leaf page reader in `core/storage/pager.rs` accepts the cell-count field from a SQLite page header at face value without validating it against the actual page payload bounds; supplying an inflated count causes an index-out-of-bounds panic in Rust, aborting the host process. No public exploit has been identified and the vulnerability is not listed in CISA KEV; real-world exposure is limited to applications with a file-ingestion pathway that accepts externally supplied database files.
CPU exhaustion via crafted chunked HTTP responses affects the Elixir Mint HTTP client library (versions 1.9.3 through before 1.10.0). The chunk-size hex parser in `lib/mint/http1/parse.ex` accumulates digits into an arbitrary-precision integer using `acc * 16 + digit` with no upper bound on digit count, producing O(N²) cost per parse pass; compounded by a re-parse-from-start design on each socket message, a server that trickles digits forces the client to pay this cost repeatedly. Benchmark data in the advisory confirms ~512,000 hex digits produces over ten seconds of CPU in a single pass, and an intermediary inspecting only headers sees a normal 200 response. No public exploit identified at time of analysis; patch is available in version 1.10.0.
Unbounded synchronous DNS amplification in Robots::Validate for Perl (versions 0.3.2 through 0.3.10) allows a network attacker who controls the reverse DNS zone for their IP address to force arbitrarily many forward DNS lookups per validation call, exhausting server threads and causing application-level denial of service. The _check_dns FCRDNS loop issues one forward query per PTR record returned for the connecting IP, with no cap; Net::DNS's default TCP fallback for truncated UDP answers removes the 512-byte payload as a natural limit. No public exploit has been identified and EPSS is 0.17% (7th percentile), but the attack primitive requires only a cloud VM with PTR editing rights and knowledge of the target's bot-rule configuration.
Integer overflow in Corosync's membership commit token processing crashes the daemon on 32-bit cluster nodes, enabling a denial-of-service attack from any adjacent network host. The CWE-190 flaw causes the length validation to be bypassed on 32-bit systems where arithmetic wraps before the bounds check is applied, resulting in an out-of-bounds memory access that kills the Corosync process. Modern 64-bit deployments of the same packages are explicitly not affected, substantially narrowing real-world exposure despite the CVSS 6.5 rating; no public exploit code or CISA KEV listing exists at time of analysis.
Denial of service in Eleveo Quality Management 9.7.0 allows authenticated remote attackers to crash or degrade the Conversation Handler component by supplying a malformed or oversized 'labels' argument to the /enc-fwk-data/api/v3/conversations/<ID>/events API endpoint. The vendor did not respond to pre-disclosure contact, meaning no official patch exists at time of analysis. A public proof-of-concept exploit has been released, raising the practical risk for organizations running this version in contact-center environments.
Synchronous CSS color string parsing in colord (npm, versions prior to 2.9.4) exposes Node.js applications to event-loop denial of service through catastrophic regex backtracking (ReDoS). The ambiguous numeric pattern `([+-]?\d*\.?\d+)` used across five color-model parsers - RGB, HSL, HWB, LCH, and CMYK - allows overlapping quantifiers to partition the same digit sequence in O(n²) ways during rejection, blocking the JavaScript thread for seconds per malformed payload. An unauthenticated attacker who can supply an unbounded color string to any exposed application endpoint that calls `colord()`, `getFormat()`, `isEqual()`, `mix()`, or `contrast()` can render the service unresponsive; no public exploit code has been identified at time of analysis.
Quadratic algorithmic complexity (O(D²)) in stream-json's pick, ignore, filter, and replace path filters allows an attacker supplying a small, deeply-nested JSON document to block the Node.js event loop for seconds to minutes, effectively causing denial of service. The root cause is that filter-base.js recomputes the full dot-separated path string by rejoining the entire nesting stack on every checkable token - so a document of depth D incurs O(D²) CPU work regardless of byte size. All applications passing untrusted or large JSON through a string or RegExp filter (including the library's flagship README example pick({filter: 'data'})) are affected in versions up to and including 3.4.0. A proof-of-concept is included in the published GHSA advisory; no public exploit or CISA KEV listing has been identified at time of analysis.
IBM Qiskit SDK versions 2.1.0 through 2.5.1 crash when deserializing a specially crafted QPY (Quantum Python) payload, due to a CWE-502 deserialization flaw that triggers a segmentation fault. Local attackers who can supply malicious QPY data to a deserializing process can cause the application to crash, resulting in denial of service with no confidentiality or integrity impact. No public exploit code or active exploitation has been identified at time of analysis, and IBM has released a patch via its support portal.
Incorrect Authorization (CWE-863) in Kibana allows a low-privileged authenticated user to exploit misconfigured access control levels, resulting in partial denial of service against the Kibana instance. Affected across Kibana 8.x and 9.x branches, with fixes released in versions 8.19.21, 9.4.6, and 9.5.3 per Elastic advisory ESA-2026-174. No public exploit code or active exploitation has been identified at time of analysis.
OpenVPN on Windows (versions 2.0.0-2.6.22 and 2.7_alpha1-2.7.6) creates the --service exit event and netsh.exe guard semaphore with a NULL Discretionary Access Control List, granting any local process unrestricted access to these named synchronization objects. A low-privileged local user can acquire and hold the world-accessible semaphore indefinitely or signal the exit event, disrupting or terminating all other users' OpenVPN sessions on the same Windows host. The issue is Windows-only, affects only deployments not using the Interactive Service (iservice), and has been resolved in v2.7.7; no public exploit code has been identified.
Integer wraparound in the MongoDB C Driver BSON library's JSON parser allows an unauthenticated party supplying a sufficiently large JSON document to crash any linked application on 32-bit-size builds. The overflow produces an undersized heap allocation that is freed, while a subsequent copy operation continues writing through the now-dangling pointer - a use-after-free sequence that terminates the host process. No public exploit code or active exploitation has been identified; impact is confined to denial of service, and the attack is constrained to 32-bit size builds of the library.
Process termination via out-of-bounds memory read affects the MongoDB C++ Driver's BSON document builder, caused by a numeric type conversion error (CWE-681) that misinterprets a field name length when an application supplies an extremely large, non-null-terminated field name in a specific form. All versions of the C++ Driver are indicated as in scope per the wildcard CPE. No public exploit code and no CISA KEV listing exist at time of analysis; MongoDB's own Jira (CXX-3548) is the sole public tracking reference, and no fixed release version has been disclosed in the available data.
Uncontrolled resource consumption in NousResearch hermes-agent 0.18.0 allows a remote attacker, with passive user interaction, to trigger excessive memory or resource allocation through the Electron main process via the `resourceBufferFromUrl` function. The impact is limited to low availability degradation (DoS) with no confidentiality or integrity exposure. Critically, the description acknowledges the vulnerable `copyImageFromUrl()` entry point was removed by v2026.8.19, making this effectively self-patched in current builds; the vulnerability is specific to the v2026.8.3 codebase window. No public exploit or active exploitation is identified.
Stack exhaustion in gfs2-utils's metawalk.c metadata walk code allows a local attacker to cause denial of service by supplying a crafted GFS2 filesystem image containing a maliciously large inode height value that drives unbounded alloca() calls. Affected systems include Red Hat Enterprise Linux 7, 8, and 9 with gfs2-utils installed; the CVSS 4.7 medium rating reflects a local, high-complexity, user-interaction-required attack path with no confidentiality or integrity impact. No public exploit code or active exploitation has been identified at time of analysis.
Stack exhaustion in gfs2-utils allows an attacker who can deliver a crafted GFS2 filesystem image to crash fsck.gfs2, gfs2_edit, or savemeta on Red Hat Enterprise Linux 7, 8, and 9. The root cause is unbounded use of alloca() in metawalk.c's hash table traversal, where the allocation size is derived exponentially from the on-disk di_depth field with no upper-bound check, so a sufficiently large di_depth value causes the process stack to be fully consumed. The impact is limited to denial of service of the affected utility; no public exploit has been identified at time of analysis, and EPSS data is not available in the provided intelligence.
Uncontrolled resource consumption in 2FastLabs agent-squad up to version 1.1.4 allows a low-privileged remote attacker to degrade or deny service by manipulating the streaming agent response workflow through the `AgentSquad.routeRequest` function in `orchestrator.ts`. A public proof-of-concept exploit is available on GitHub, and the project maintainers had not responded to the disclosure at time of analysis, meaning no patch exists. The impact is limited to availability - no confidentiality or integrity compromise is indicated.
In the Linux kernel, the following vulnerability has been resolved: ASoC: xilinx: formatter_pcm: pass aud_drv_data to irq handlers The irq handlers take a struct device pointer and call dev_get_drvdata() to obtain the driver data. However, the driver data is only set at the end of probe, after devm_request_irq(), so an interrupt taken in between causes the handlers to pass a NULL pointer to readl() and crash. Pass the private data directly as the devm_request_irq() argument instead of the device pointer, matching what the handlers expect.
In the Linux kernel, the following vulnerability has been resolved: drm/log: Fix infinite loop when scale is too large for display When scale is large enough that scaled_font exceeds the display dimensions, rows or columns become 0. A columns value of 0 causes an infinite loop in drm_log_draw_kmsg_record() because the loop never decrements len. Check for zero rows/columns in drm_log_setup_modeset() and return an error, cleaning up the already allocated buffer to avoid a leak.
In the Linux kernel, the following vulnerability has been resolved: ring-buffer: Fix crash passing ERR_PTR to kthread_stop() In test_ringbuffer()'s out_free cleanup loop, the check `!rb_threads[cpu]` only catches NULL entries and misses entries that hold an ERR_PTR. rb_threads[] is static, so unassigned slots are NULL. But when kthread_run_on_cpu() fails for a cpu, it stores ERR_PTR(-ENOMEM) (or -EINTR) in rb_threads[cpu] before the creation loop jumps to out_free. That entry is non-NULL, so the old `!ptr` check does not break, and the cleanup proceeds to call kthread_stop() on the ERR_PTR. kthread_stop() then dereferences the bogus pointer, crashing the kernel during the late_initcall self-test. crash logs: BUG: kernel NULL pointer dereference, address: 000000000000001c Oops: 0002 [#1] SMP NOPTI CPU: 1 PID: 1 Comm: swapper/0 Not tainted 7.2.0-rc6-dirty #7 PREEMPT(lazy) RIP: 0010:kthread_stop+0x2e/0x220 RBX: fffffffffffffff4 CR2: 000000000000001c Call Trace: <TASK> test_ringbuffer+0x1ec/0x650 do_one_initcall+0x6c/0x2c0 kernel_init_freeable+0x21d/0x420 kernel_init+0x15/0x1c0 ret_from_fork+0x21b/0x320 </TASK> Kernel panic - not syncing: Fatal exception
Denial of service in Hitachi Energy RTU500 Series CMU firmware allows an unauthenticated remote attacker to crash the IEC 60870-5-104 communication process by flooding the device with General Interrogation (GI) requests at short intervals. The high-load condition triggers a NULL pointer dereference in the last entry of the enhanced message queue, causing a BCI_IEC104 fatal write error, connection interruption, and automatic restart - severing bidirectional telecontrol communication. No public exploit code has been identified at time of analysis, and exploitation requires the ability to sustain elevated request rates against a reachable IEC 104 endpoint.
Heap over-read and crash vulnerabilities in Slurm's slurmd compute-node daemon expose HPC clusters to memory disclosure and denial of service. When slurmd receives a malformed forward data RPC, insufficient input validation allows an attacker to trigger a heap over-read during message unpacking or crash the daemon outright if the RPC lacks a required socket address. The primary impact is availability loss on affected compute nodes; the heap over-read additionally carries a low-severity information disclosure risk. No public exploit code has been identified at time of analysis.
Credential verification bypass in Slurm's sbcast facility allows broadcast of shared objects (.so files) to job-allocated nodes without proper authentication checks, potentially enabling library injection across compute nodes. A second concurrent flaw permits invalid sbcast filenames to crash the slurmd daemon, causing a denial of service on affected compute nodes. Both issues affect Slurm HPC workload manager environments where sbcast is used; the credential bypass carries the higher severity given its potential for integrity compromise across cluster nodes.
Denial of service in simular-ai Agent-S up to version 0.3.2 allows low-privileged remote attackers to disrupt the GUI action execution workflow by manipulating action parameters in grounding.py. The attack targets the model-generated action budget processing logic, causing improper resource handling (CWE-404) that results in agent availability loss. A public proof-of-concept titled 'AgentS_Action_Parameter_Budget_DoS_Report' is available on GitHub; the vendor did not respond to coordinated disclosure, leaving no official patch in place.
Uncontrolled resource consumption in simular-ai Agent-S up to version 0.3.2 allows remote unauthenticated attackers to exhaust server resources via the OCR HTTP API's ImageData function. By supplying crafted img_bytes input to the exposed endpoint in gui_agents/s1/utils/ocr_server.py, an attacker can trigger a denial-of-service condition against the OCR processing service. Publicly available exploit code exists on GitHub; the vendor did not respond to responsible disclosure, leaving no official patch.
Denial of service in simular-ai Agent-S 0.3.1/0.3.2 allows authenticated remote attackers to crash or exhaust the CodeAgent service by sending crafted input to code_agent.py. The root cause is CWE-404 (Improper Resource Shutdown or Release), meaning a resource - likely a subprocess, file handle, or socket - is not properly released on certain code paths, enabling resource exhaustion. A public proof-of-concept is available on GitHub; no vendor patch exists as the vendor did not respond to disclosure.
Uncontrolled memory allocation in sigoden aichat up to version 0.30.4 allows remote unauthenticated attackers to exhaust server memory via the HTTP API endpoint implemented in src/serve.rs, causing a denial-of-service condition. The vulnerability is a CWE-400 resource exhaustion flaw triggered by sending a crafted request body to the aichat serve component. A public proof-of-concept has been published; the vendor did not respond to responsible disclosure, meaning no patch has been released.
Unauthenticated remote denial of service in rowboatlabs rowboat through v0.9.1 allows any network attacker to disrupt the Composio webhook endpoint by sending a crafted HTTP request body that exploits improper resource handling in the Next.js route handler (apps/rowboat/app/api/composio/webhook/route.ts). A proof-of-concept is publicly available on GitHub, removing any skill barrier for exploitation. The vendor resolved the issue in v0.9.2 by deleting the legacy Next.js application entirely rather than patching the underlying flaw, meaning no security control was introduced - only the attack surface was removed.
Targeted repository denial-of-service in Sonatype Nexus Repository 3 allows any authenticated user holding deploy privileges to permanently disable component browsing on a specific hosted Maven repository. Uploading a crafted POM file with an oversized metadata field (CWE-770) corrupts the repository's internal data such that subsequent listing and browse operations fail indefinitely until an administrator repairs the underlying record. Impact is confined to the single targeted repository; the broader Nexus instance and all other repositories remain unaffected. No public exploit has been identified at time of analysis.
Uncontrolled resource consumption in ntegrals openbrowser's Browser Agent Message Construction component allows remote attackers to degrade availability by crafting malicious messages that exhaust agent resources. The affected code resides in packages/core/src/agent/agent.ts, and the flaw requires passive user interaction (UI:P) per the CVSS 4.0 vector, limiting full automation. A public proof-of-concept has been published on GitHub; the vendor was notified but did not respond, and no patch exists.
Uncontrolled memory consumption in Grafana's SQL macro evaluator allows authenticated users with query permissions to crash the Grafana server process via a bypass of the prior CVE-2026-33375 fix. By injecting the timeGroup macro into a WHERE clause rather than the positions blocked by the original regex-based patch, attackers cause the macro evaluator to consume unbounded memory, terminating the server. Microsoft SQL Server, PostgreSQL, and MySQL data source integrations are all confirmed affected, and no public exploit has been identified at time of analysis.
Memory exhaustion denial of service in Filebeat's HTTP ingestion endpoint allows an authenticated low-privileged attacker to crash the Filebeat process by sending specially crafted compressed payloads that trigger unbounded decompression (a decompression-bomb / zip-bomb pattern). Affected versions span the 8.x and 9.x branches, with patched releases 8.19.18 and 9.3.1 published under Elastic Security Advisory ESA-2026-165. No public exploit code or CISA KEV listing has been identified at time of analysis, and exploitation is constrained to attackers who can reach the HTTP input endpoint.
Incorrect authorization in Elastic Fleet Server allows any authenticated enrolled agent to interfere with multi-part upload sessions belonging to other enrolled agents, causing a denial of service of those upload operations. Fleet Server fails to verify session ownership during chunked data uploads, meaning a low-privileged agent credential is sufficient to disrupt peer agent activity. No public exploit exists and no active exploitation has been confirmed; CVSS rates this Low (3.1) reflecting the authentication prerequisite and high complexity timing condition.
Kibana's request processing layer fails to enforce memory allocation limits, allowing any authenticated low-privilege user to trigger unbounded heap consumption and deny service to all users of the instance. Elastic's advisory ESA-2026-163 discloses the issue across all Kibana branches and releases fixes in versions 8.19.16, 9.3.5, and 9.4.2. No public exploit code or active exploitation has been identified at time of analysis.
Persistent denial of service in Elastic APM Server allows an authenticated user with write access to source map content to upload specially crafted, highly compressed payloads that exhaust server memory upon processing. The condition (CWE-409, CAPEC-130) is self-reinforcing: every restart triggers re-processing of the stored content and re-crashes the server, making recovery impossible without manual removal of the malicious content. No public exploit code has been identified and the vulnerability is not listed in CISA KEV; however, the persistence characteristic significantly elevates operational impact compared to a transient DoS.
Unauthenticated denial of service in WP Go Maps WordPress plugin (versions <= 10.1.08) allows remote attackers without any credentials to exhaust server resources, degrading or disrupting availability for the affected WordPress installation. The vulnerability stems from CWE-770 (resource allocation without limits or throttling), enabling unconstrained consumption of server capacity via crafted network requests. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified at time of analysis.
Unauthenticated denial of service against WordPress sites running Really Simple SSL plugin version 9.8.0 and earlier allows remote attackers to partially degrade site availability without any credentials. The vulnerability stems from CWE-770 (Allocation of Resources Without Limits or Throttling), meaning the plugin fails to constrain resource consumption on certain request paths, enabling an attacker to send crafted requests that exhaust server resources. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, and the CVSS-assigned availability impact is rated Low, suggesting partial rather than complete service disruption.
Denial of service in zhayujie CowAgent up to version 2.1.7 allows a low-privileged remote attacker to crash or degrade availability by manipulating input to the Bash Tool component (agent/tools/bash/bash.py). The root cause is CWE-404 (Improper Resource Shutdown or Release), suggesting the Bash Tool fails to bound, drain, or release output buffers when executing shell commands - consistent with the public PoC title 'CowAgent_Bash_Output_Buffer_DoS_Report'. A proof-of-concept exploit is publicly available on GitHub, though no patch has been released and the vendor was unresponsive to disclosure.
Denial of service in zhayujie CowAgent up to version 2.1.3 allows a low-privileged remote attacker to crash or hang the agent service by sending a crafted input to the BrowserTool component in `agent/tools/browser/browser_tool.py`. The underlying cause (CWE-404) is improper resource shutdown or release - likely a browser subprocess or evaluation call that hangs indefinitely rather than timing out cleanly. A public proof-of-concept exists on GitHub; the vendor was unresponsive to disclosure, and no patch has been released.
Denial of service in NousResearch hermes-agent 0.18.0 allows authenticated remote attackers to crash or degrade the Session Chat Interface by exploiting improper resource shutdown or release (CWE-404) in gateway/platforms/api_server.py. The CVSS 4.0 score of 2.1 with VA:L reflects a low-impact, low-privilege DoS against the vulnerable system only - no confidentiality or integrity impact is present. No public exploit identified at time of analysis is inaccurate here: a PoC has been published on GitHub (E:P), and the vendor has not acknowledged or responded to the disclosure.
Denial of service in NousResearch hermes-agent affects the HermesACPAgent.prompt function within acp_adapter/session.py, exploitable by low-privileged remote users through the ACP Prompt Workflow interface. Versions up to and including 0.18.2 are confirmed affected, with no vendor patch issued following pre-disclosure contact. A public proof-of-concept exploit is available on GitHub, lowering the barrier to exploitation against exposed deployments.
Unauthenticated denial-of-service in HPE AOS-CX allows an adjacent-network attacker to crash or disrupt affected switches by sending specially crafted packets, resulting in loss of normal network operations. The vulnerability requires no credentials and no user interaction, making it exploitable by any actor with access to the same Layer-2 or adjacent network segment. No public exploit code or active exploitation has been identified at time of analysis; this is part of a multi-CVE bundle disclosed in HPE bulletin HPESBNW05134, which also covers higher-severity RCE flaws (CVE-2026-73749, CVE-2026-73782) and an auth bypass (CVE-2026-73778) in the same product line.
Denial-of-service conditions in HPE AOS-CX's command line interface allow a low-privileged authenticated user with network access to disrupt normal system operation. Part of the broader HPE advisory hpesbnw05134 addressing multiple AOS-CX vulnerabilities, this issue targets the CLI layer - accessible over SSH - but requires high attack complexity to successfully trigger. No public exploit code has been identified at time of analysis, and active exploitation has not been confirmed.
Heap-exhaustion denial-of-service in Hono web framework before 4.13.5 allows unauthenticated network attackers to crash the JavaScript server process by submitting form requests with deeply nested or numerous dot-separated field names when dot-notation parsing is explicitly enabled. The `parseBody()` function expands dot-separated keys into nested JavaScript objects without any bound on nesting depth or total intermediate object count, allowing a normal-sized request body to produce an object graph orders of magnitude larger and exhaust the runtime heap. Exploitation causes server process termination and service outage until manual restart; no public exploit is identified at time of analysis.
Infinite loop denial of service in pypdf prior to 6.16.0 allows any attacker who can supply a crafted PDF to a pypdf-based write pipeline to permanently hang the processing worker. The root cause is in TreeObject.insert_child within pypdf/generic/_data_structures.py, which traverses /Next links without cycle detection; a PDF whose tree nodes form a circular reference (A→B→C→A) causes unbounded traversal. No public exploitation has been confirmed and no CISA KEV entry exists, but a functional proof-of-concept is embedded in the upstream fix PR (#3964).
Denial-of-service in HPE Networking Fabric Composer's API allows an authenticated low-privilege operator to interrupt service availability. The flaw requires high-complexity conditions (AV:N/AC:H/PR:L) and produces only limited availability impact, placing it at CVSS 3.1. No public exploit code or CISA KEV listing has been identified at time of analysis.
Denial of service in HPE Networking Fabric Composer's web-based management interface can be triggered by an authenticated low-privilege operator, disrupting the availability of the management UI. The CVSS vector (AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:N/A:L) reflects a low-severity, network-accessible flaw requiring valid credentials and user interaction, yielding only limited availability impact. No exploitation has been publicly demonstrated, and the vulnerability does not affect the underlying fabric infrastructure - only the management interface itself.
Multiple denial-of-service vulnerabilities in the HPE Networking Fabric Composer API allow an authenticated low-privilege operator to disrupt management plane availability. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) confirms network-accessible exploitation requiring only standard operator credentials with no additional user interaction. No public exploit code has been identified at time of analysis, and the HPE advisory hpesbnw05133en_us is the sole authoritative source confirming the issue.
Denial of service in Kibana allows an authenticated user holding Streams management privileges to crash the Kibana process by submitting specially crafted compressed content that expands to a disproportionately large volume during server-side processing, exhausting available memory. The host OS terminates the Kibana process, and the service remains unavailable to all users until manually restarted. The advisory ESA-2026-125 identifies fixed versions as 8.19.21, 9.4.6, and 9.5.2; no public exploit or KEV listing has been identified at time of analysis.
Uncaught exception handling in Kibana's Observability AI Assistant allows any low-privileged authenticated user to crash the entire Kibana Node.js process by submitting a specially crafted request, denying service to all users and spaces on that instance until an administrator manually restarts it. The blast radius is instance-wide regardless of the attacker's permission scope, making this disproportionately severe relative to its CVSS 6.5 Medium rating. Elastic confirmed the fix in versions 9.4.5 and 9.5.1 via advisory ESA-2026-115; no public exploit code or CISA KEV listing has been identified at time of analysis.
Unbounded memory allocation in Kibana's Agent Builder feature allows any authenticated user with minimal read-level privileges to crash the Kibana process, denying service to all users of the affected instance. The vulnerability stems from CWE-770 (no resource throttling), meaning a single low-privileged user can trigger full process termination via one crafted request. Elastic has addressed this in Kibana 9.4.6 via security advisory ESA-2026-84; no public exploit or active exploitation has been identified at time of analysis.
Unthrottled resource allocation in Kibana allows an authenticated network user to submit a specially crafted request that drives excessive server-side resource consumption, potentially rendering the Kibana dashboard fully unavailable. Reported by Elastic and addressed in ESA-2026-48, the vulnerability is classified under CWE-770 and maps to the CAPEC-130 excessive allocation attack pattern. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, and the fix is confirmed in Kibana 8.19.19 and 9.3.5.
Denial of service in Elasticsearch allows an authenticated user with elevated cluster privileges to submit a specially crafted API request that causes unbounded memory consumption, potentially crashing the targeted node and disrupting cluster availability. The flaw is classified as CWE-770 (Allocation of Resources Without Limits or Throttling) with CAPEC-130 attack pattern, and is confirmed by Elastic via advisory ESA-2026-47. No public exploit code or CISA KEV listing has been identified at time of analysis; the elevated-privilege requirement (PR:H) meaningfully constrains realistic attackers to insiders or compromised admin accounts.
Denial of service in Elastic Kibana allows any authenticated low-privilege user to render the analytics interface unavailable by submitting specially crafted requests that trigger unbounded resource consumption (CWE-770, CAPEC-130). All Kibana versions prior to 8.19.17 and 9.3.0 are affected. No public exploit or CISA KEV listing exists at time of analysis; the risk is real but limited to authenticated accounts.
Crash of the gvfsd-mtp daemon in gvfs is achievable by anyone who can connect a malicious USB MTP device to a target Linux system. The do_read() function in gvfsbackendmtp.c accepts the byte-count reported by the device at face value and passes it uncapped to memcpy(), causing an out-of-bounds read that triggers a segmentation fault when the device deliberately over-reports its response length. The vulnerability affects gvfs as packaged across Red Hat Enterprise Linux 6 through 10; no public exploit has been identified and exploitation is constrained by physical proximity.
Heap buffer overflow in the gvfs AFP (Apple Filing Protocol) backend allows a malicious AFP server to crash the gvfsd-afp process on connecting clients, resulting in denial of service. When a client mounts an AFP share, the DSI (Data Stream Interface) read path accepts a server-supplied length value without validating it against the pre-allocated reply buffer, enabling the server to write past buffer boundaries. This affects RHEL 6 through 10 and requires user interaction to mount a malicious share; no public exploit or CISA KEV listing has been identified at time of analysis.
Uncontrolled resource consumption in Mozilla Firefox's built-in PDF Viewer component allows a remote, unauthenticated attacker to crash or hang the browser by inducing a victim to open a specially crafted PDF file. All Firefox releases prior to version 155 are affected, as confirmed by Mozilla Security Advisories MFSA2026-82 and MFSA2026-86. No public exploit code or CISA KEV listing has been identified, and EPSS at 0.14% (4th percentile) reflects very low real-world exploitation probability.
Unauthenticated network attackers can elicit Java stack traces from Red Hat IdM's Dogtag CA REST enrollment endpoint (POST /ca/rest/certrequests) by submitting malformed requests, causing HTTP 500 responses that expose internal implementation details under CWE-209. The same error path simultaneously amplifies the CA debug log with large multi-line stack traces, creating a log-fill resource exhaustion vector that drives disk growth and I/O contention on affected RHEL 6 through 10 deployments. No public exploit has been identified at time of analysis, but the attack requires no authentication and low complexity, making it accessible to unskilled opportunistic attackers targeting IdM infrastructure.
NULL pointer dereference in Samsung mTower's TEE kernel allows a Non-Secure caller to crash the secure world by supplying an invalid, zero, or stale session ID to the ioctl invoke path. The flaw exists in tee_ioctl_invoke() (entry_std.c) and tee_ta_invoke_command() (tee_ta_manager.c), where find_session() returns NULL without a guard before dereferencing sess->ctx, causing a secure-world fault. All mTower versions prior to commit afef59aa6f55c5d5ebf9b14bc020bf1c2c37489a are affected; no public exploit has been identified at time of analysis.
Scheduler exhaustion in ash Framework (Elixir) versions 2.19.0 through 3.32.2 allows any workload triggering concurrent slow async read operations to pin BEAM scheduler threads at 100% CPU. The root cause is a busy-polling loop in Ash.Actions.Read.AsyncLimiter.await_at_least_one/1 that called Task.yield(task, 0) repeatedly with zero timeout rather than sleeping until a task completed, keeping the calling scheduler thread active throughout the wait. Multiple concurrent slow related-data loads or calculations compound the impact by saturating additional scheduler threads, potentially degrading or denying service to the entire Elixir node. No public exploit identified at time of analysis; vendor-released patch ash 3.32.2 resolves the issue.
Improper input validation in the modem firmware component of 22 MediaTek chipsets allows a local user-privileged process to trigger a system crash, resulting in a denial of service. The flaw, tracked as patch ID MOLY01810811 / MSV-9232, requires user interaction to trigger and is confined to an unprivileged local context, limiting its practical impact to availability disruption rather than data exposure or code execution. No public exploit has been identified and SSVC rates exploitation as none at this time.
NULL-pointer dereference in code handling Authentication and Key Agreement (AKA) Synchronization-Failure messages causes a process crash when a malformed or unexpected AKA-Synchronization-Failure response is processed. The vulnerability affects software that implements 3GPP AKA authentication - a protocol used in mobile network authentication (3G/4G/5G) and EAP-AKA for Wi-Fi/IMS - as packaged by Ubuntu. No public exploit or CISA KEV listing has been identified at time of analysis, and the primary real-world impact is denial of service via crash of the authentication handling daemon.
Unbounded iteration during PKCS#7 container decryption exposes affected systems to a denial-of-service condition where a crafted cryptographic payload causes a parsing loop to run without termination bounds. The specific library or package is not identified in the available intelligence - Ubuntu is the reporting source, suggesting this affects a cryptographic library they distribute (candidates include OpenSSL, GnuTLS, NSS, or similar). An attacker able to supply a malformed PKCS#7 container to a vulnerable parsing routine can exhaust CPU resources and halt service availability. No public exploit has been identified at time of analysis, and no CVSS score or severity rating has been assigned.
Infinite-loop denial of service in libpcap's BPF interpreter allows a local low-privileged attacker to hang any process that evaluates a crafted BPF filter program via pcap_offline_filter(). The 'ja L' (jump always) instruction stores its target offset as a signed integer, enabling backward jumps that implement looping, but the interpreter imposed no cap on iterations, so a self-referential or backward-looping filter causes unbounded CPU consumption. The upstream fix (commit ff3c83475a) introduces a MAX_BACKWARD_JUMPS limit of 64 per packet and adds validator rejection of self-jumps; no active exploitation or public exploit code has been identified at time of analysis.
Missing authorization on the Subsonic startScan endpoint in gonic before v0.22.0 permits any authenticated user - not just administrators - to repeatedly trigger CPU- and I/O-intensive media library filesystem scans. Multi-user gonic instances are the meaningful target: an attacker with a regular account can flood the endpoint to exhaust server resources and deny service to all users. No public exploit code has been identified at time of analysis, and the patch is available in v0.22.0.
NULL pointer dereference in libxml2's xmlRegNewParserCtxt() function crashes any application invoking the XML regular-expression engine under memory-pressure conditions. Versions before 2.15.4 call strlen() on the return value of xmlStrdup() without first verifying the pointer is non-NULL; when strdup() fails due to memory exhaustion, the subsequent strlen(NULL) causes a process crash. No confidentiality or integrity impact is possible - the vulnerability is limited to a local, high-complexity denial-of-service. No public exploit or CISA KEV listing exists; the fix shipped in libxml2 2.15.4.
Unthrottled resource allocation in freegpt-webui's getJailbreak function (server/backend.py) enables remote unauthenticated attackers to exhaust server resources via crafted Jailbreak Mode requests (CWE-770). The affected product is an unmaintained hobby GPT wrapper by ramon-victor, pinned to all commits through 098db3dfeb41555c2ca9269df0f13e10ec1c35dc with no patched release forthcoming. A public proof-of-concept exploit is available on GitHub, and no vendor fix will be issued as the maintainer has abandoned the project.
Privilege escalation and kernel DoS in PassMark's shared DirectIo64.sys kernel driver affect PerformanceTest (before 11.1 build 1012), BurnInTest (before 11.1 build 1000), and OSForensics (before 11.1 build 1016), allowing a local low-privileged attacker to read arbitrary Model-Specific Registers or write zero to any MSR via IOCTLs with an insufficient blocklist. Writing zero to the system call handler MSR (e.g., IA32_LSTAR) causes an immediate unrecoverable kernel panic on the next system call, while reading security-sensitive MSRs (such as those storing kernel base addresses) enables KASLR bypass to support privilege escalation chains. A public proof-of-concept is available via GitHub, and vendor patches have been released; no KEV listing at time of analysis.
Heap out-of-bounds read in libtpms during TPM 2.0 state restoration allows an adjacent unauthenticated attacker to crash the swtpm process and deny TPM services to dependent virtual machines. The flaw arises in the state-blob parser: an attacker-controlled oversized skip-block length drives the internal INT32 size counter negative; subsequent bounds checks cast that counter to UINT32, wrapping it to a large positive value and bypassing the check, which then drives the parser to read memory outside the heap buffer. Vendor and upstream commit confirm the impact is denial of service only - no data corruption or information disclosure was confirmed. No public exploit or CISA KEV listing has been identified.
In the Linux kernel, the following vulnerability has been resolved: mshv: Order pt_vp_array publish against irqfd assertion path mshv_partition_ioctl_create_vp() initialises a VP struct (allocations, mutex_init, init_waitqueue_head, page mappings) and then publishes the pointer into partition->pt_vp_array. Several ISR paths read this array locklessly: the intercept ISR, the two scheduler ISRs, and mshv_try_assert_irq_fast() on the irqfd fast path. Of these, only mshv_try_assert_irq_fast() can structurally race the publish. It runs from an eventfd waker without holding pt_mutex, and MSHV_IRQFD does not require the target lapic_apic_id (== vp_index) to refer to an existing VP at registration time. A user can therefore register an irqfd targeting a yet-to-be-created VP, then trigger mshv_try_assert_irq_fast() concurrently with MSHV_CREATE_VP for the same index. On weakly-ordered architectures the reader can observe a non-NULL pointer in pt_vp_array before the initialising stores to the VP struct become visible, leading to use of partially-initialised fields (e.g. vp_register_page). The other ISR readers cannot reach this race: the hypervisor will not generate intercept or scheduler messages for a VP that has never been told to run, and the user can only call MSHV_RUN_VP on the VP fd returned by MSHV_CREATE_VP, which by construction is returned after the publish. Leave those readers as plain loads. Use smp_store_release() in mshv_partition_ioctl_create_vp() to publish the pointer, and pair it with smp_load_acquire() in mshv_try_assert_irq_fast(). On x86 these compile to plain accesses under TSO; on ARM64 they emit one-instruction acquire/release barriers, acceptable on this fast path. The destroy-side path (destroy_partition() clearing pt_vp_array[i] to NULL after kfree(vp)) has a separate ordering and lifetime concern that is out of scope here.
Memory exhaustion via compression bomb in undici's decompress interceptor (versions 7.15.0-<7.29.1 and 8.0.0-<8.10.2) allows a malicious or compromised upstream HTTP server to crash a Node.js process by returning a small compressed payload that expands to hundreds of megabytes in client heap memory. The interceptor respects the untrusted Content-Encoding header and enforces no ceiling on total decompressed output size, making the attack purely asymmetric - a kilobyte-scale upstream payload can trigger unbounded client-side allocation. No public exploit has been identified and the vulnerability is not in the CISA KEV catalog; fixed versions 7.29.1 and 8.10.2 are available.
Chunked-body handling in undici's dump interceptor triggers a double-completion assertion that tears down the underlying TCP connection while returning a misleading success status to the application. Affected are undici versions 7.1.0 through 7.29.0 and 8.0.0 through 8.10.1; fixed releases 7.29.1 and 8.10.2 are available. No public exploit or active exploitation has been identified; the CVSS 3.7 score reflects the high attack complexity and limited real-world impact relative to the narrow exploitation path.
In the Linux kernel, the following vulnerability has been resolved: serial: msm: Disable DMA for kernel console UART At the moment, concurrent writes from userspace and the kernel to the console can trigger a race condition that results in an infinite loop of the same messages printed over and over again. This is most likely to happen during system startup or shutdown when the init system starts/stops a large number of system services that interact with various kernel code. When userspace writes to the TTY device, the driver initiates an asynchronous DMA transfer and releases the port lock. At the same moment, the kernel printk path might grab the port lock and re-configure the UART controller for PIO, without waiting for the DMA operation to complete. It seems like this collision results in zero progress being reported for the DMA engine, so the same text is printed to the console over and over again. For the kernel console, we want a reliable output path that will be functional even during crashes etc. So rather than implementing complex code to synchronize the kernel console write routines with the userspace DMA write routines, simply disable DMA for the console UART instance. Similar checks exist in many other serial drivers, e.g. 8250_port.c, imx.c, sh-sci.c etc.
Out-of-bounds read in IBM Db2 Mirror for i versions 7.4, 7.5, and 7.6 enables a remote unauthenticated attacker to cause a denial of service by sending a crafted network request to the mirroring service. The flaw (CWE-125) is exploitable with no authentication or user interaction and can disrupt high-availability replication continuity. IBM has released a patch via advisory node/7285904; no public exploit code has been identified at time of analysis.
Stack-based buffer overflow in IBM i 7.3 through 7.6 allows remote authenticated attackers to cause a denial of service by sending specially crafted network input that exceeds a stack-allocated buffer in a network-accessible component. The vulnerability is gated behind low-privilege authentication (PR:L) and carries no confidentiality or integrity impact, as IBM's advisory scores it CVSS 4.3 with A:L. No public exploit code or active exploitation has been identified; a vendor-released patch is available via the IBM support portal.
Stack-based buffer overflow in IBM i 7.3 through 7.6 allows an authenticated local attacker to crash the system, producing a denial of service with no confidentiality or integrity impact. The flaw is classified as CWE-121 and is limited in severity by both the access prerequisites and the bounded availability-only outcome. A vendor patch is available via IBM's support portal, and no public exploit code has been identified at time of analysis.
Denial of service in IBM i 7.3 through 7.6 is achievable by any remote authenticated low-privilege user via a NULL pointer dereference, causing complete availability loss with no data exposure. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) confirms low-complexity network exploitation requiring only a valid user account and no user interaction. No public exploit code and no CISA KEV listing have been identified at time of analysis; IBM has released a patch via its support portal.
Uncontrolled recursion in IBM App Connect Enterprise (versions 12.x and 13.x) and IBM Integration Bus for z/OS (version 10.1.x) allows a local authenticated attacker to crash the integration runtime via stack exhaustion, resulting in a denial of service. The flaw is classified as CWE-674 and affects a broad version range across both product lines, with a vendor-released patch now available. No public exploit code or active exploitation has been identified at time of analysis.
Denial of service on IBM i versions 7.3 through 7.6 is achievable by exploiting an off-by-one write in the LPD (Line Printer Daemon) queue name parser, corrupting adjacent memory and crashing the affected service. The vendor description specifies a local authenticated attacker as the threat actor, yet IBM's own submitted CVSS vector (AV:N/AC:L/PR:N/UI:N) characterizes this as an unauthenticated network-reachable flaw - a direct contradiction that materially affects risk prioritization. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.
Integer overflow in IBM i versions 7.3 through 7.6 allows remote authenticated attackers to cause a denial of service condition. The vulnerability (CWE-190) is network-reachable but requires prior authentication, and its impact is limited to partial availability degradation with no confidentiality or integrity consequences. IBM has released a patch, and no public exploit code or CISA KEV listing has been identified at time of analysis.
IBM i versions 7.3 through 7.6 expose authenticated remote attackers to a denial-of-service condition via a memory leak (CWE-401). An attacker with low-privilege credentials can repeatedly trigger the vulnerable code path over the network, causing progressive memory exhaustion that degrades or halts system services. No active exploitation has been identified, and IBM has released a patch via Security Advisory 7285844.
Process-crashing denial of service in undici's WebSocket permessage-deflate implementation allows a remote unauthenticated attacker to terminate any Node.js process hosting the affected client by sending a crafted compressed WebSocket frame. The size-limit enforcement routine strips all event listeners - including the error handler - from the zlib inflate stream while the stream is still active; a subsequent malformed DEFLATE byte then emits an uncaught error that Node.js treats as a fatal unhandled exception, killing the process. Versions 6.25.0-6.28.0, 7.28.0-7.29.0, and 8.1.0-8.10.1 are confirmed affected; fixed releases are available per OpenJS advisory GHSA-3wwx-pv8p-q78v, and no public exploit has been identified at time of analysis.
In the Linux kernel, the following vulnerability has been resolved: tcp: fix AO info use-after-free in tcp_ao_connect_init() tcp_v4_connect() adds a SYN-SENT socket to the ehash before calling tcp_connect(). If TCP-AO is configured, tcp_connect() first verifies that a key matches the peer and the bound device's current L3 master. tcp_ao_connect_init() later resolves the L3 master again and removes keys which do not match it. The socket lock does not stabilize the bound device's VRF membership. Detaching the device from its VRF between the initial validation and the L3-master calculation in tcp_ao_connect_init() can therefore make the validation succeed while initialization observes the default L3 domain and removes the only key. The subsequent AO lookup then fails, so the no-key path clears tp->ao_info and frees it directly. The receive path can find the socket in the ehash and load tp->ao_info under RCU before acquiring the socket lock. A reader which loaded the old pointer can thus continue into tcp_inbound_ao_hash() after the direct free. The issue was found during a static audit of TCP-AO object lifetime. An unprivileged reproducer in self-created user and network namespaces raced connect() with detaching a veth from its VRF while sending TCP-AO segments. It triggered the same KASAN report on two fresh boots: BUG: KASAN: slab-use-after-free in tcp_inbound_ao_hash+0x585/0x19f0 Write of size 8 at addr ffff88800bf88128 by task tcp_ao_vrf_race/232 Call Trace: tcp_inbound_ao_hash+0x585/0x19f0 tcp_inbound_hash+0x677/0xa80 tcp_v4_rcv+0x1c3e/0x3ab0 Allocated by task 235: tcp_ao_alloc_info+0x43/0xf0 tcp_ao_add_cmd+0xdf7/0x13b0 do_tcp_setsockopt+0x168c/0x2640 Freed by task 235: kfree+0x1b8/0x550 tcp_connect+0x252/0x4f00 tcp_v4_connect+0x1114/0x1720 The bad address is 40 bytes inside the freed 128-byte object, matching the tcp_ao_info counters.key_not_found field. The two runs used 1000 attempts each, reached the no-key path 366 and 411 times, and produced one and two KASAN reports respectively. With this change, the same reproducer reached the no-key path 366 times in 1000 attempts without a KASAN report or oops. Use tcp_ao_destroy_sock() for the no-key path. It unpublishes the AO info, updates the socket memory and static-key accounting, and defers the free until after an RCU grace period. Also drop the WARN_ON_ONCE() and its stale comment. The VRF detach race makes the no-key state reachable during normal operation, so it is a handled condition rather than an impossible assertion. On panic_on_warn kernels the WARN would turn this handled race into a kernel panic.
In the Linux kernel, the following vulnerability has been resolved: net/packet: defer vmalloc TX_RING free until skbs finish AF_PACKET TX_RING skbs keep a raw pointer to their ring frame. The skb page references preserve page-backed ring blocks after pg_vec is freed, but they do not preserve a vmalloc mapping. tpacket_destruct_skb() currently drops the pending reference before writing the timestamp and TP_STATUS_AVAILABLE to the frame. Move the decrement after those stores. The smp_wmb() in __packet_set_status() orders the frame stores before the decrement. Also recheck pending TX frames under pg_vec_lock before non-closing ring replacement, so a racing send cannot add a pending skb between the initial check and the ring swap. Ring allocation can produce a mixture of page-backed and vmalloc-backed blocks. Allocate deferred-work storage during TX ring setup when the first vmalloc-backed block is encountered, and keep its pointer in the pg_vec allocation header. If allocation fails, return -ENOMEM from ring setup. On socket close, a non-NULL pointer identifies a vmalloc-backed vector without a scan. If TX skbs remain, defer the whole vector to system_long_wq. After pg_vec is detached, a late destructor can skip the pending decrement. Use socket write-memory accounting as the deferred lifetime gate instead: an skb remains charged through its final sock_wfree(), after all ring-frame accesses. The delayed work retains a socket reference and reschedules itself until no TX skbs remain. Move pending_refcnt release to packet_sock_destruct() so late skb destructors and deferred cleanup can safely use it after packet_release(). Page-backed teardown remains synchronous, and no lock is added to the TX completion hot path.
Resource exhaustion in IBM MQ Agent CD (v1.0.0-v2.0.1) allows any authenticated console user to monopolize the LLM agent worker pool by submitting arbitrarily large or computationally expensive requests. When multiple such requests are issued concurrently, all available agent workers remain occupied for extended periods - from tens of seconds to over ten minutes each - causing complete unavailability of the AI Agent feature for all other IBM MQ Console users. No public exploit code has been identified at time of analysis, and exploitation requires a valid authenticated session.
In the Linux kernel, the following vulnerability has been resolved: iommu/iommufd: Fix NULL pointer deref in iommufd_ioas_change_process when racing with iopt_map_file_pages iommufd_ioas_change_process() iterates every IOAS area while only holding every IOAS iova_rwsem, so it assumes every area has a non-NULL pages pointer. That assumption can be false when it runs concurrently with iopt_map_file_pages(). iopt_map_pages() executes in two phases. It first creates the area and inserts it into the interval tree under iova_rwsem, with area->pages still NULL. It then drops iova_rwsem and later fills area->pages under domains_rwsem. This leaves a window between area creation and area->pages fill where a concurrent iommufd_ioas_change_process() can observe the area and dereference a NULL area->pages pointer, leading to a NULL pointer dereference: BUG: kernel NULL pointer dereference, address: 00000000000000c0 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 4b655067 P4D 4b655067 PUD 0 Oops: Oops: 0000 [#1] SMP NOPTI CPU: 0 UID: 0 PID: 11841 Comm: syz.1.628 Not tainted 7.1.0 #3 PREEMPT(full) Hardware name: QEMU Ubuntu 24.04 PC v2 (i440FX + PIIX, arch_caps fix, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 RIP: 0010:iommufd_ioas_change_process+0x419/0xd50 drivers/iommu/iommufd/ioas.c:538 Code: 48 89 c3 48 85 c0 0f 84 cc 00 00 00 e8 10 f5 cb fd 48 8d 7b 68 e8 a7 b5 eb fd 48 8b 6b 68 48 8d bd c0 00 00 00 e8 17 b2 eb fd <8b> ad c0 00 00 00 bf 01 00 00 00 89 ee e8 85 ef cb fd 83 fd 01 74 RSP: 0018:ffffc90015c17d28 EFLAGS: 00010246 RAX: ffff8880186d5328 RBX: ffff88801d25e240 RCX: 0000000080000000 RDX: 00000000000002d7 RSI: ffffffff83ba9e10 RDI: 00000000000000c0 RBP: 0000000000000000 R08: ffffffff8e781eb8 R09: 0000000000000000 R10: 00000000000000c0 R11: ffffffff83ba9e29 R12: ffff88802e216008 R13: ffff88802e216000 R14: 0000000000000001 R15: 0000000000000000 FS: 00007f4aea3f66c0(0000) GS:ffff8880b1fa1000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00000000000000c0 CR3: 000000004b75c000 CR4: 0000000000350ef0 Call Trace: <TASK> iommufd_fops_ioctl+0x287/0x400 drivers/iommu/iommufd/main.c:533 vfs_ioctl fs/ioctl.c:51 [inline] __do_sys_ioctl fs/ioctl.c:597 [inline] __se_sys_ioctl fs/ioctl.c:583 [inline] __x64_sys_ioctl+0x120/0x170 fs/ioctl.c:583 x64_sys_call+0x1092/0x1fb0 arch/x86/include/generated/asm/syscalls_64.h:17 do_syscall_x64 arch/x86/entry/syscall_64.c:63 [inline] do_syscall_64+0x10a/0x680 arch/x86/entry/syscall_64.c:94 entry_SYSCALL_64_after_hwframe+0x77/0x7f RIP: 0033:0x7f4aec1a82bd Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b0 ff ff ff f7 d8 64 89 01 48 RSP: 002b:00007f4aea3f6018 EFLAGS: 00000246 ORIG_RAX: 0000000000000010 RAX: ffffffffffffffda RBX: 00007f4aec436090 RCX: 00007f4aec1a82bd RDX: 0000200000000180 RSI: 0000000000003b92 RDI: 0000000000000003 RBP: 00007f4aec250295 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000 R13: 00007f4aec436128 R14: 00007f4aec436090 R15: 00007ffd04ef23e0 </TASK> Modules linked in: CR2: 00000000000000c0 ---[ end trace 0000000000000000 ]--- RIP: 0010:iommufd_ioas_change_process+0x419/0xd50 drivers/iommu/iommufd/ioas.c:538 Code: 48 89 c3 48 85 c0 0f 84 cc 00 00 00 e8 10 f5 cb fd 48 8d 7b 68 e8 a7 b5 eb fd 48 8b 6b 68 48 8d bd c0 00 00 00 e8 17 b2 eb fd <8b> ad c0 00 00 00 bf 01 00 00 00 89 ee e8 85 ef cb fd 83 fd 01 74 RSP: 0018:ffffc90015c17d28 EFLAGS: 00010246 RAX: ffff8880186d5328 RBX: ffff88801d25e240 RCX: 0000000080000000 RDX: 00000000000002d7 RSI: ffffffff83ba9e10 RDI: 00000000000000c0 RBP: 0000000000000000 R08: ffffffff8e781eb8 R09: 0000000000000000 R10: 00000000000000c0 R11: ffffffff83ba9e29 R12: ffff88802e216008 R13: ffff88802e216000 R14: 0000000000000001 R15: 0000000000000000 FS: 00007f4aea3f66c0(000 ---truncated---
In the Linux kernel, the following vulnerability has been resolved: ALSA: FCP: Use a private URB for the notification endpoint fcp_init_notify() used mixer->urb, which snd_usb_mixer_status_create() allocates for the optional UAC2 status interrupt endpoint and mixer.c kills, resubmits and frees. On a device with that endpoint, fcp_init_notify()'s "already set up" early return fires on the status URB and returns success without doing anything. No FCP notification URB is submitted, and cmd_done is left zeroed because it is initialised past that early return and nowhere else. fcp_init() then issues init1_opcode and wait_for_completion_timeout() would crash adding to the zeroed wait.head. fcp_cleanup_urb() would also kill and free mixer.c's status URB. Use a separate URB in fcp_data, and initialise cmd_done in fcp_init_private() where fcp_data is allocated. fcp_init_notify() is reached again after suspend via fcp_reinit(), and the URB kill path in fcp_notify() completes cmd_done, leaving a stale count that would satisfy the next command's wait before the device ACKs. Use reinit_completion() to clear it.
In the Linux kernel, the following vulnerability has been resolved: ALSA: scarlett2: Use a private URB for the notification endpoint scarlett2_init_notify() used mixer->urb, which snd_usb_mixer_status_create() allocates for the UAC2 status interrupt endpoint and mixer.c manages. On a device with that endpoint, the "already in use" check fires on the status URB and returns 0 for success without doing anything. No notification URB is submitted, and cmd_done is left zeroed because it is initialised past that check and nowhere else. scarlett2_usb_init() then issues SCARLETT2_USB_INIT_1 and wait_for_completion_timeout() would crash adding to the zeroed wait.head. Use a separate URB in scarlett2_data, as done for FCP, and initialise cmd_done in scarlett2_init_private(). mixer.c was also freeing the URB in snd_usb_mixer_free() and resubmitting it in snd_usb_mixer_activate(), so scarlett2 must now do both: add scarlett2_cleanup_urb(), called from private_free and private_suspend, and a private_resume callback to re-establish the URB after resume. scarlett2_init_notify() is reached from there, and the URB kill path in scarlett2_notify() completes cmd_done, leaving a stale count that would satisfy the next command's wait before the device ACKs. Use reinit_completion() to clear it. Also free the URB if the transfer buffer allocation fails, and both if usb_submit_urb() fails. Move scarlett2_init_notify() up next to scarlett2_cleanup_urb() so scarlett2_init_private() can reference it without a forward declaration.
In the Linux kernel, the following vulnerability has been resolved: nvmet: fix NULL pointer dereference in nvmet_execute_identify_nslist() When a host issues an Identify command with CNS 07h (Active Namespace ID List for a specific I/O Command Set), nvmet_execute_identify_nslist() is called with match_css set. The command-set filter dereferences req->ns, but this handler never calls nvmet_req_find_ns(), so req->ns is always NULL (nvmet_req_init() resets it to NULL). As soon as an enabled namespace with an NSID greater than the requested value exists, req->ns->csi dereferences a NULL pointer and oopses. Besides the crash, the comparison is logically wrong: to filter the list by command set it must test the command set of the namespace being iterated, not a single fixed value. Use the loop variable ns->csi.
In the Linux kernel, the following vulnerability has been resolved: ipv6: fix use-after-free in ip6_finish_output2() ip6_finish_output2() caches a pointer to the IPv6 destination address (daddr) before invoking lwtunnel_xmit(). The LWT-BPF transmit path or other encapsulation operations within lwtunnel_xmit() can reallocate the skb head, freeing the memory that daddr points to. When lwtunnel_xmit() returns LWTUNNEL_XMIT_CONTINUE, the function continues to use the stale daddr pointer to compute the nexthop and to look up or create the neighbour entry. This results in a use-after-free read, which can leak sensitive kernel data, pollute the neighbour table with arbitrary values, misdirect traffic, or crash the system. Fix this by re-fetching the IPv6 header and the destination address pointer after lwtunnel_xmit() returns LWTUNNEL_XMIT_CONTINUE, ensuring that the subsequent nexthop computation and neighbour lookup operate on valid memory.
In the Linux kernel, the following vulnerability has been resolved: HID: hyperv: validate initial device info bounds The Hyper-V synthetic HID host supplies SYNTH_HID_INITIAL_DEVICE_INFO messages that contain a HID descriptor followed by the report descriptor bytes. mousevsc_on_receive_device_info() trusts bLength and wDescriptorLength without checking that the received packet contains both byte ranges. A malformed host or backend message can therefore make the guest read past the received VMBus packet while copying the report descriptor. Pass the received initial-device-info size into the parser and reject descriptor lengths that exceed the packet. Impact: A malicious Hyper-V host or backend can crash a guest by sending a short initial device-info message with an oversized HID report descriptor length.
Out-of-bounds read in Turso through 0.8.0-pre.8 crashes any application that opens a crafted database file, causing denial of service. The table-leaf page reader in `core/storage/pager.rs` accepts the cell-count field from a SQLite page header at face value without validating it against the actual page payload bounds; supplying an inflated count causes an index-out-of-bounds panic in Rust, aborting the host process. No public exploit has been identified and the vulnerability is not listed in CISA KEV; real-world exposure is limited to applications with a file-ingestion pathway that accepts externally supplied database files.
CPU exhaustion via crafted chunked HTTP responses affects the Elixir Mint HTTP client library (versions 1.9.3 through before 1.10.0). The chunk-size hex parser in `lib/mint/http1/parse.ex` accumulates digits into an arbitrary-precision integer using `acc * 16 + digit` with no upper bound on digit count, producing O(N²) cost per parse pass; compounded by a re-parse-from-start design on each socket message, a server that trickles digits forces the client to pay this cost repeatedly. Benchmark data in the advisory confirms ~512,000 hex digits produces over ten seconds of CPU in a single pass, and an intermediary inspecting only headers sees a normal 200 response. No public exploit identified at time of analysis; patch is available in version 1.10.0.
Unbounded synchronous DNS amplification in Robots::Validate for Perl (versions 0.3.2 through 0.3.10) allows a network attacker who controls the reverse DNS zone for their IP address to force arbitrarily many forward DNS lookups per validation call, exhausting server threads and causing application-level denial of service. The _check_dns FCRDNS loop issues one forward query per PTR record returned for the connecting IP, with no cap; Net::DNS's default TCP fallback for truncated UDP answers removes the 512-byte payload as a natural limit. No public exploit has been identified and EPSS is 0.17% (7th percentile), but the attack primitive requires only a cloud VM with PTR editing rights and knowledge of the target's bot-rule configuration.
Integer overflow in Corosync's membership commit token processing crashes the daemon on 32-bit cluster nodes, enabling a denial-of-service attack from any adjacent network host. The CWE-190 flaw causes the length validation to be bypassed on 32-bit systems where arithmetic wraps before the bounds check is applied, resulting in an out-of-bounds memory access that kills the Corosync process. Modern 64-bit deployments of the same packages are explicitly not affected, substantially narrowing real-world exposure despite the CVSS 6.5 rating; no public exploit code or CISA KEV listing exists at time of analysis.
Denial of service in Eleveo Quality Management 9.7.0 allows authenticated remote attackers to crash or degrade the Conversation Handler component by supplying a malformed or oversized 'labels' argument to the /enc-fwk-data/api/v3/conversations/<ID>/events API endpoint. The vendor did not respond to pre-disclosure contact, meaning no official patch exists at time of analysis. A public proof-of-concept exploit has been released, raising the practical risk for organizations running this version in contact-center environments.
Synchronous CSS color string parsing in colord (npm, versions prior to 2.9.4) exposes Node.js applications to event-loop denial of service through catastrophic regex backtracking (ReDoS). The ambiguous numeric pattern `([+-]?\d*\.?\d+)` used across five color-model parsers - RGB, HSL, HWB, LCH, and CMYK - allows overlapping quantifiers to partition the same digit sequence in O(n²) ways during rejection, blocking the JavaScript thread for seconds per malformed payload. An unauthenticated attacker who can supply an unbounded color string to any exposed application endpoint that calls `colord()`, `getFormat()`, `isEqual()`, `mix()`, or `contrast()` can render the service unresponsive; no public exploit code has been identified at time of analysis.
Quadratic algorithmic complexity (O(D²)) in stream-json's pick, ignore, filter, and replace path filters allows an attacker supplying a small, deeply-nested JSON document to block the Node.js event loop for seconds to minutes, effectively causing denial of service. The root cause is that filter-base.js recomputes the full dot-separated path string by rejoining the entire nesting stack on every checkable token - so a document of depth D incurs O(D²) CPU work regardless of byte size. All applications passing untrusted or large JSON through a string or RegExp filter (including the library's flagship README example pick({filter: 'data'})) are affected in versions up to and including 3.4.0. A proof-of-concept is included in the published GHSA advisory; no public exploit or CISA KEV listing has been identified at time of analysis.
IBM Qiskit SDK versions 2.1.0 through 2.5.1 crash when deserializing a specially crafted QPY (Quantum Python) payload, due to a CWE-502 deserialization flaw that triggers a segmentation fault. Local attackers who can supply malicious QPY data to a deserializing process can cause the application to crash, resulting in denial of service with no confidentiality or integrity impact. No public exploit code or active exploitation has been identified at time of analysis, and IBM has released a patch via its support portal.
Incorrect Authorization (CWE-863) in Kibana allows a low-privileged authenticated user to exploit misconfigured access control levels, resulting in partial denial of service against the Kibana instance. Affected across Kibana 8.x and 9.x branches, with fixes released in versions 8.19.21, 9.4.6, and 9.5.3 per Elastic advisory ESA-2026-174. No public exploit code or active exploitation has been identified at time of analysis.
OpenVPN on Windows (versions 2.0.0-2.6.22 and 2.7_alpha1-2.7.6) creates the --service exit event and netsh.exe guard semaphore with a NULL Discretionary Access Control List, granting any local process unrestricted access to these named synchronization objects. A low-privileged local user can acquire and hold the world-accessible semaphore indefinitely or signal the exit event, disrupting or terminating all other users' OpenVPN sessions on the same Windows host. The issue is Windows-only, affects only deployments not using the Interactive Service (iservice), and has been resolved in v2.7.7; no public exploit code has been identified.
Integer wraparound in the MongoDB C Driver BSON library's JSON parser allows an unauthenticated party supplying a sufficiently large JSON document to crash any linked application on 32-bit-size builds. The overflow produces an undersized heap allocation that is freed, while a subsequent copy operation continues writing through the now-dangling pointer - a use-after-free sequence that terminates the host process. No public exploit code or active exploitation has been identified; impact is confined to denial of service, and the attack is constrained to 32-bit size builds of the library.
Process termination via out-of-bounds memory read affects the MongoDB C++ Driver's BSON document builder, caused by a numeric type conversion error (CWE-681) that misinterprets a field name length when an application supplies an extremely large, non-null-terminated field name in a specific form. All versions of the C++ Driver are indicated as in scope per the wildcard CPE. No public exploit code and no CISA KEV listing exist at time of analysis; MongoDB's own Jira (CXX-3548) is the sole public tracking reference, and no fixed release version has been disclosed in the available data.
Uncontrolled resource consumption in NousResearch hermes-agent 0.18.0 allows a remote attacker, with passive user interaction, to trigger excessive memory or resource allocation through the Electron main process via the `resourceBufferFromUrl` function. The impact is limited to low availability degradation (DoS) with no confidentiality or integrity exposure. Critically, the description acknowledges the vulnerable `copyImageFromUrl()` entry point was removed by v2026.8.19, making this effectively self-patched in current builds; the vulnerability is specific to the v2026.8.3 codebase window. No public exploit or active exploitation is identified.
Stack exhaustion in gfs2-utils's metawalk.c metadata walk code allows a local attacker to cause denial of service by supplying a crafted GFS2 filesystem image containing a maliciously large inode height value that drives unbounded alloca() calls. Affected systems include Red Hat Enterprise Linux 7, 8, and 9 with gfs2-utils installed; the CVSS 4.7 medium rating reflects a local, high-complexity, user-interaction-required attack path with no confidentiality or integrity impact. No public exploit code or active exploitation has been identified at time of analysis.
Stack exhaustion in gfs2-utils allows an attacker who can deliver a crafted GFS2 filesystem image to crash fsck.gfs2, gfs2_edit, or savemeta on Red Hat Enterprise Linux 7, 8, and 9. The root cause is unbounded use of alloca() in metawalk.c's hash table traversal, where the allocation size is derived exponentially from the on-disk di_depth field with no upper-bound check, so a sufficiently large di_depth value causes the process stack to be fully consumed. The impact is limited to denial of service of the affected utility; no public exploit has been identified at time of analysis, and EPSS data is not available in the provided intelligence.
Uncontrolled resource consumption in 2FastLabs agent-squad up to version 1.1.4 allows a low-privileged remote attacker to degrade or deny service by manipulating the streaming agent response workflow through the `AgentSquad.routeRequest` function in `orchestrator.ts`. A public proof-of-concept exploit is available on GitHub, and the project maintainers had not responded to the disclosure at time of analysis, meaning no patch exists. The impact is limited to availability - no confidentiality or integrity compromise is indicated.
In the Linux kernel, the following vulnerability has been resolved: ASoC: xilinx: formatter_pcm: pass aud_drv_data to irq handlers The irq handlers take a struct device pointer and call dev_get_drvdata() to obtain the driver data. However, the driver data is only set at the end of probe, after devm_request_irq(), so an interrupt taken in between causes the handlers to pass a NULL pointer to readl() and crash. Pass the private data directly as the devm_request_irq() argument instead of the device pointer, matching what the handlers expect.
In the Linux kernel, the following vulnerability has been resolved: drm/log: Fix infinite loop when scale is too large for display When scale is large enough that scaled_font exceeds the display dimensions, rows or columns become 0. A columns value of 0 causes an infinite loop in drm_log_draw_kmsg_record() because the loop never decrements len. Check for zero rows/columns in drm_log_setup_modeset() and return an error, cleaning up the already allocated buffer to avoid a leak.
In the Linux kernel, the following vulnerability has been resolved: ring-buffer: Fix crash passing ERR_PTR to kthread_stop() In test_ringbuffer()'s out_free cleanup loop, the check `!rb_threads[cpu]` only catches NULL entries and misses entries that hold an ERR_PTR. rb_threads[] is static, so unassigned slots are NULL. But when kthread_run_on_cpu() fails for a cpu, it stores ERR_PTR(-ENOMEM) (or -EINTR) in rb_threads[cpu] before the creation loop jumps to out_free. That entry is non-NULL, so the old `!ptr` check does not break, and the cleanup proceeds to call kthread_stop() on the ERR_PTR. kthread_stop() then dereferences the bogus pointer, crashing the kernel during the late_initcall self-test. crash logs: BUG: kernel NULL pointer dereference, address: 000000000000001c Oops: 0002 [#1] SMP NOPTI CPU: 1 PID: 1 Comm: swapper/0 Not tainted 7.2.0-rc6-dirty #7 PREEMPT(lazy) RIP: 0010:kthread_stop+0x2e/0x220 RBX: fffffffffffffff4 CR2: 000000000000001c Call Trace: <TASK> test_ringbuffer+0x1ec/0x650 do_one_initcall+0x6c/0x2c0 kernel_init_freeable+0x21d/0x420 kernel_init+0x15/0x1c0 ret_from_fork+0x21b/0x320 </TASK> Kernel panic - not syncing: Fatal exception
Denial of service in Hitachi Energy RTU500 Series CMU firmware allows an unauthenticated remote attacker to crash the IEC 60870-5-104 communication process by flooding the device with General Interrogation (GI) requests at short intervals. The high-load condition triggers a NULL pointer dereference in the last entry of the enhanced message queue, causing a BCI_IEC104 fatal write error, connection interruption, and automatic restart - severing bidirectional telecontrol communication. No public exploit code has been identified at time of analysis, and exploitation requires the ability to sustain elevated request rates against a reachable IEC 104 endpoint.
Heap over-read and crash vulnerabilities in Slurm's slurmd compute-node daemon expose HPC clusters to memory disclosure and denial of service. When slurmd receives a malformed forward data RPC, insufficient input validation allows an attacker to trigger a heap over-read during message unpacking or crash the daemon outright if the RPC lacks a required socket address. The primary impact is availability loss on affected compute nodes; the heap over-read additionally carries a low-severity information disclosure risk. No public exploit code has been identified at time of analysis.
Credential verification bypass in Slurm's sbcast facility allows broadcast of shared objects (.so files) to job-allocated nodes without proper authentication checks, potentially enabling library injection across compute nodes. A second concurrent flaw permits invalid sbcast filenames to crash the slurmd daemon, causing a denial of service on affected compute nodes. Both issues affect Slurm HPC workload manager environments where sbcast is used; the credential bypass carries the higher severity given its potential for integrity compromise across cluster nodes.
Denial of service in simular-ai Agent-S up to version 0.3.2 allows low-privileged remote attackers to disrupt the GUI action execution workflow by manipulating action parameters in grounding.py. The attack targets the model-generated action budget processing logic, causing improper resource handling (CWE-404) that results in agent availability loss. A public proof-of-concept titled 'AgentS_Action_Parameter_Budget_DoS_Report' is available on GitHub; the vendor did not respond to coordinated disclosure, leaving no official patch in place.
Uncontrolled resource consumption in simular-ai Agent-S up to version 0.3.2 allows remote unauthenticated attackers to exhaust server resources via the OCR HTTP API's ImageData function. By supplying crafted img_bytes input to the exposed endpoint in gui_agents/s1/utils/ocr_server.py, an attacker can trigger a denial-of-service condition against the OCR processing service. Publicly available exploit code exists on GitHub; the vendor did not respond to responsible disclosure, leaving no official patch.
Denial of service in simular-ai Agent-S 0.3.1/0.3.2 allows authenticated remote attackers to crash or exhaust the CodeAgent service by sending crafted input to code_agent.py. The root cause is CWE-404 (Improper Resource Shutdown or Release), meaning a resource - likely a subprocess, file handle, or socket - is not properly released on certain code paths, enabling resource exhaustion. A public proof-of-concept is available on GitHub; no vendor patch exists as the vendor did not respond to disclosure.
Uncontrolled memory allocation in sigoden aichat up to version 0.30.4 allows remote unauthenticated attackers to exhaust server memory via the HTTP API endpoint implemented in src/serve.rs, causing a denial-of-service condition. The vulnerability is a CWE-400 resource exhaustion flaw triggered by sending a crafted request body to the aichat serve component. A public proof-of-concept has been published; the vendor did not respond to responsible disclosure, meaning no patch has been released.
Unauthenticated remote denial of service in rowboatlabs rowboat through v0.9.1 allows any network attacker to disrupt the Composio webhook endpoint by sending a crafted HTTP request body that exploits improper resource handling in the Next.js route handler (apps/rowboat/app/api/composio/webhook/route.ts). A proof-of-concept is publicly available on GitHub, removing any skill barrier for exploitation. The vendor resolved the issue in v0.9.2 by deleting the legacy Next.js application entirely rather than patching the underlying flaw, meaning no security control was introduced - only the attack surface was removed.
Targeted repository denial-of-service in Sonatype Nexus Repository 3 allows any authenticated user holding deploy privileges to permanently disable component browsing on a specific hosted Maven repository. Uploading a crafted POM file with an oversized metadata field (CWE-770) corrupts the repository's internal data such that subsequent listing and browse operations fail indefinitely until an administrator repairs the underlying record. Impact is confined to the single targeted repository; the broader Nexus instance and all other repositories remain unaffected. No public exploit has been identified at time of analysis.
Uncontrolled resource consumption in ntegrals openbrowser's Browser Agent Message Construction component allows remote attackers to degrade availability by crafting malicious messages that exhaust agent resources. The affected code resides in packages/core/src/agent/agent.ts, and the flaw requires passive user interaction (UI:P) per the CVSS 4.0 vector, limiting full automation. A public proof-of-concept has been published on GitHub; the vendor was notified but did not respond, and no patch exists.
Uncontrolled memory consumption in Grafana's SQL macro evaluator allows authenticated users with query permissions to crash the Grafana server process via a bypass of the prior CVE-2026-33375 fix. By injecting the timeGroup macro into a WHERE clause rather than the positions blocked by the original regex-based patch, attackers cause the macro evaluator to consume unbounded memory, terminating the server. Microsoft SQL Server, PostgreSQL, and MySQL data source integrations are all confirmed affected, and no public exploit has been identified at time of analysis.
Memory exhaustion denial of service in Filebeat's HTTP ingestion endpoint allows an authenticated low-privileged attacker to crash the Filebeat process by sending specially crafted compressed payloads that trigger unbounded decompression (a decompression-bomb / zip-bomb pattern). Affected versions span the 8.x and 9.x branches, with patched releases 8.19.18 and 9.3.1 published under Elastic Security Advisory ESA-2026-165. No public exploit code or CISA KEV listing has been identified at time of analysis, and exploitation is constrained to attackers who can reach the HTTP input endpoint.
Incorrect authorization in Elastic Fleet Server allows any authenticated enrolled agent to interfere with multi-part upload sessions belonging to other enrolled agents, causing a denial of service of those upload operations. Fleet Server fails to verify session ownership during chunked data uploads, meaning a low-privileged agent credential is sufficient to disrupt peer agent activity. No public exploit exists and no active exploitation has been confirmed; CVSS rates this Low (3.1) reflecting the authentication prerequisite and high complexity timing condition.
Kibana's request processing layer fails to enforce memory allocation limits, allowing any authenticated low-privilege user to trigger unbounded heap consumption and deny service to all users of the instance. Elastic's advisory ESA-2026-163 discloses the issue across all Kibana branches and releases fixes in versions 8.19.16, 9.3.5, and 9.4.2. No public exploit code or active exploitation has been identified at time of analysis.
Persistent denial of service in Elastic APM Server allows an authenticated user with write access to source map content to upload specially crafted, highly compressed payloads that exhaust server memory upon processing. The condition (CWE-409, CAPEC-130) is self-reinforcing: every restart triggers re-processing of the stored content and re-crashes the server, making recovery impossible without manual removal of the malicious content. No public exploit code has been identified and the vulnerability is not listed in CISA KEV; however, the persistence characteristic significantly elevates operational impact compared to a transient DoS.
Unauthenticated denial of service in WP Go Maps WordPress plugin (versions <= 10.1.08) allows remote attackers without any credentials to exhaust server resources, degrading or disrupting availability for the affected WordPress installation. The vulnerability stems from CWE-770 (resource allocation without limits or throttling), enabling unconstrained consumption of server capacity via crafted network requests. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified at time of analysis.
Unauthenticated denial of service against WordPress sites running Really Simple SSL plugin version 9.8.0 and earlier allows remote attackers to partially degrade site availability without any credentials. The vulnerability stems from CWE-770 (Allocation of Resources Without Limits or Throttling), meaning the plugin fails to constrain resource consumption on certain request paths, enabling an attacker to send crafted requests that exhaust server resources. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, and the CVSS-assigned availability impact is rated Low, suggesting partial rather than complete service disruption.
Denial of service in zhayujie CowAgent up to version 2.1.7 allows a low-privileged remote attacker to crash or degrade availability by manipulating input to the Bash Tool component (agent/tools/bash/bash.py). The root cause is CWE-404 (Improper Resource Shutdown or Release), suggesting the Bash Tool fails to bound, drain, or release output buffers when executing shell commands - consistent with the public PoC title 'CowAgent_Bash_Output_Buffer_DoS_Report'. A proof-of-concept exploit is publicly available on GitHub, though no patch has been released and the vendor was unresponsive to disclosure.
Denial of service in zhayujie CowAgent up to version 2.1.3 allows a low-privileged remote attacker to crash or hang the agent service by sending a crafted input to the BrowserTool component in `agent/tools/browser/browser_tool.py`. The underlying cause (CWE-404) is improper resource shutdown or release - likely a browser subprocess or evaluation call that hangs indefinitely rather than timing out cleanly. A public proof-of-concept exists on GitHub; the vendor was unresponsive to disclosure, and no patch has been released.
Denial of service in NousResearch hermes-agent 0.18.0 allows authenticated remote attackers to crash or degrade the Session Chat Interface by exploiting improper resource shutdown or release (CWE-404) in gateway/platforms/api_server.py. The CVSS 4.0 score of 2.1 with VA:L reflects a low-impact, low-privilege DoS against the vulnerable system only - no confidentiality or integrity impact is present. No public exploit identified at time of analysis is inaccurate here: a PoC has been published on GitHub (E:P), and the vendor has not acknowledged or responded to the disclosure.
Denial of service in NousResearch hermes-agent affects the HermesACPAgent.prompt function within acp_adapter/session.py, exploitable by low-privileged remote users through the ACP Prompt Workflow interface. Versions up to and including 0.18.2 are confirmed affected, with no vendor patch issued following pre-disclosure contact. A public proof-of-concept exploit is available on GitHub, lowering the barrier to exploitation against exposed deployments.
Unauthenticated denial-of-service in HPE AOS-CX allows an adjacent-network attacker to crash or disrupt affected switches by sending specially crafted packets, resulting in loss of normal network operations. The vulnerability requires no credentials and no user interaction, making it exploitable by any actor with access to the same Layer-2 or adjacent network segment. No public exploit code or active exploitation has been identified at time of analysis; this is part of a multi-CVE bundle disclosed in HPE bulletin HPESBNW05134, which also covers higher-severity RCE flaws (CVE-2026-73749, CVE-2026-73782) and an auth bypass (CVE-2026-73778) in the same product line.
Denial-of-service conditions in HPE AOS-CX's command line interface allow a low-privileged authenticated user with network access to disrupt normal system operation. Part of the broader HPE advisory hpesbnw05134 addressing multiple AOS-CX vulnerabilities, this issue targets the CLI layer - accessible over SSH - but requires high attack complexity to successfully trigger. No public exploit code has been identified at time of analysis, and active exploitation has not been confirmed.
Heap-exhaustion denial-of-service in Hono web framework before 4.13.5 allows unauthenticated network attackers to crash the JavaScript server process by submitting form requests with deeply nested or numerous dot-separated field names when dot-notation parsing is explicitly enabled. The `parseBody()` function expands dot-separated keys into nested JavaScript objects without any bound on nesting depth or total intermediate object count, allowing a normal-sized request body to produce an object graph orders of magnitude larger and exhaust the runtime heap. Exploitation causes server process termination and service outage until manual restart; no public exploit is identified at time of analysis.
Infinite loop denial of service in pypdf prior to 6.16.0 allows any attacker who can supply a crafted PDF to a pypdf-based write pipeline to permanently hang the processing worker. The root cause is in TreeObject.insert_child within pypdf/generic/_data_structures.py, which traverses /Next links without cycle detection; a PDF whose tree nodes form a circular reference (A→B→C→A) causes unbounded traversal. No public exploitation has been confirmed and no CISA KEV entry exists, but a functional proof-of-concept is embedded in the upstream fix PR (#3964).
Denial-of-service in HPE Networking Fabric Composer's API allows an authenticated low-privilege operator to interrupt service availability. The flaw requires high-complexity conditions (AV:N/AC:H/PR:L) and produces only limited availability impact, placing it at CVSS 3.1. No public exploit code or CISA KEV listing has been identified at time of analysis.
Denial of service in HPE Networking Fabric Composer's web-based management interface can be triggered by an authenticated low-privilege operator, disrupting the availability of the management UI. The CVSS vector (AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:N/A:L) reflects a low-severity, network-accessible flaw requiring valid credentials and user interaction, yielding only limited availability impact. No exploitation has been publicly demonstrated, and the vulnerability does not affect the underlying fabric infrastructure - only the management interface itself.
Multiple denial-of-service vulnerabilities in the HPE Networking Fabric Composer API allow an authenticated low-privilege operator to disrupt management plane availability. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) confirms network-accessible exploitation requiring only standard operator credentials with no additional user interaction. No public exploit code has been identified at time of analysis, and the HPE advisory hpesbnw05133en_us is the sole authoritative source confirming the issue.
Denial of service in Kibana allows an authenticated user holding Streams management privileges to crash the Kibana process by submitting specially crafted compressed content that expands to a disproportionately large volume during server-side processing, exhausting available memory. The host OS terminates the Kibana process, and the service remains unavailable to all users until manually restarted. The advisory ESA-2026-125 identifies fixed versions as 8.19.21, 9.4.6, and 9.5.2; no public exploit or KEV listing has been identified at time of analysis.
Uncaught exception handling in Kibana's Observability AI Assistant allows any low-privileged authenticated user to crash the entire Kibana Node.js process by submitting a specially crafted request, denying service to all users and spaces on that instance until an administrator manually restarts it. The blast radius is instance-wide regardless of the attacker's permission scope, making this disproportionately severe relative to its CVSS 6.5 Medium rating. Elastic confirmed the fix in versions 9.4.5 and 9.5.1 via advisory ESA-2026-115; no public exploit code or CISA KEV listing has been identified at time of analysis.
Unbounded memory allocation in Kibana's Agent Builder feature allows any authenticated user with minimal read-level privileges to crash the Kibana process, denying service to all users of the affected instance. The vulnerability stems from CWE-770 (no resource throttling), meaning a single low-privileged user can trigger full process termination via one crafted request. Elastic has addressed this in Kibana 9.4.6 via security advisory ESA-2026-84; no public exploit or active exploitation has been identified at time of analysis.
Unthrottled resource allocation in Kibana allows an authenticated network user to submit a specially crafted request that drives excessive server-side resource consumption, potentially rendering the Kibana dashboard fully unavailable. Reported by Elastic and addressed in ESA-2026-48, the vulnerability is classified under CWE-770 and maps to the CAPEC-130 excessive allocation attack pattern. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, and the fix is confirmed in Kibana 8.19.19 and 9.3.5.
Denial of service in Elasticsearch allows an authenticated user with elevated cluster privileges to submit a specially crafted API request that causes unbounded memory consumption, potentially crashing the targeted node and disrupting cluster availability. The flaw is classified as CWE-770 (Allocation of Resources Without Limits or Throttling) with CAPEC-130 attack pattern, and is confirmed by Elastic via advisory ESA-2026-47. No public exploit code or CISA KEV listing has been identified at time of analysis; the elevated-privilege requirement (PR:H) meaningfully constrains realistic attackers to insiders or compromised admin accounts.
Denial of service in Elastic Kibana allows any authenticated low-privilege user to render the analytics interface unavailable by submitting specially crafted requests that trigger unbounded resource consumption (CWE-770, CAPEC-130). All Kibana versions prior to 8.19.17 and 9.3.0 are affected. No public exploit or CISA KEV listing exists at time of analysis; the risk is real but limited to authenticated accounts.
Crash of the gvfsd-mtp daemon in gvfs is achievable by anyone who can connect a malicious USB MTP device to a target Linux system. The do_read() function in gvfsbackendmtp.c accepts the byte-count reported by the device at face value and passes it uncapped to memcpy(), causing an out-of-bounds read that triggers a segmentation fault when the device deliberately over-reports its response length. The vulnerability affects gvfs as packaged across Red Hat Enterprise Linux 6 through 10; no public exploit has been identified and exploitation is constrained by physical proximity.
Heap buffer overflow in the gvfs AFP (Apple Filing Protocol) backend allows a malicious AFP server to crash the gvfsd-afp process on connecting clients, resulting in denial of service. When a client mounts an AFP share, the DSI (Data Stream Interface) read path accepts a server-supplied length value without validating it against the pre-allocated reply buffer, enabling the server to write past buffer boundaries. This affects RHEL 6 through 10 and requires user interaction to mount a malicious share; no public exploit or CISA KEV listing has been identified at time of analysis.
Uncontrolled resource consumption in Mozilla Firefox's built-in PDF Viewer component allows a remote, unauthenticated attacker to crash or hang the browser by inducing a victim to open a specially crafted PDF file. All Firefox releases prior to version 155 are affected, as confirmed by Mozilla Security Advisories MFSA2026-82 and MFSA2026-86. No public exploit code or CISA KEV listing has been identified, and EPSS at 0.14% (4th percentile) reflects very low real-world exploitation probability.
Unauthenticated network attackers can elicit Java stack traces from Red Hat IdM's Dogtag CA REST enrollment endpoint (POST /ca/rest/certrequests) by submitting malformed requests, causing HTTP 500 responses that expose internal implementation details under CWE-209. The same error path simultaneously amplifies the CA debug log with large multi-line stack traces, creating a log-fill resource exhaustion vector that drives disk growth and I/O contention on affected RHEL 6 through 10 deployments. No public exploit has been identified at time of analysis, but the attack requires no authentication and low complexity, making it accessible to unskilled opportunistic attackers targeting IdM infrastructure.
NULL pointer dereference in Samsung mTower's TEE kernel allows a Non-Secure caller to crash the secure world by supplying an invalid, zero, or stale session ID to the ioctl invoke path. The flaw exists in tee_ioctl_invoke() (entry_std.c) and tee_ta_invoke_command() (tee_ta_manager.c), where find_session() returns NULL without a guard before dereferencing sess->ctx, causing a secure-world fault. All mTower versions prior to commit afef59aa6f55c5d5ebf9b14bc020bf1c2c37489a are affected; no public exploit has been identified at time of analysis.
Scheduler exhaustion in ash Framework (Elixir) versions 2.19.0 through 3.32.2 allows any workload triggering concurrent slow async read operations to pin BEAM scheduler threads at 100% CPU. The root cause is a busy-polling loop in Ash.Actions.Read.AsyncLimiter.await_at_least_one/1 that called Task.yield(task, 0) repeatedly with zero timeout rather than sleeping until a task completed, keeping the calling scheduler thread active throughout the wait. Multiple concurrent slow related-data loads or calculations compound the impact by saturating additional scheduler threads, potentially degrading or denying service to the entire Elixir node. No public exploit identified at time of analysis; vendor-released patch ash 3.32.2 resolves the issue.