Denial of Service

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.

NULL pointer dereference in the Linux kernel's psxpad-spi driver crashes the kernel when system suspend is triggered on hardware using SPI-connected PlayStation controllers. The probe() function in drivers/input/joystick/psxpad-spi.c omits the spi_set_drvdata() call that stores per-device state, so psxpad_spi_suspend() unconditionally dereferences a NULL pointer on suspend entry, causing a kernel panic. Patches are available across all active stable kernel branches (5.10 through 7.2); EPSS is 0.21% and no active exploitation has been identified.

Out-of-bounds memory read in the Linux kernel's DRM HDMI connector subsystem allows a local, low-privileged user to potentially leak up to 32 bytes of adjacent kernel heap memory or trigger a page fault leading to kernel crash. The flaw exists in a helper function that copies audio infoframe data using the destination buffer size (60 bytes) rather than the source structure size (28 bytes), reading 32 bytes beyond the source allocation. No public exploit code exists, and EPSS sits at the 10th percentile; however, the availability impact is real - the overread can cross a page boundary and cause an access violation.

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.

Btrfs in the Linux kernel fails to reinitialize inode address-space mapping flags and minimum folio order when re-reading previously evicted cached inodes, causing a kernel assertion failure and system crash (denial of service). The defect surfaces only when btrfs is mounted with a block size larger than the host memory page size - a non-default but valid configuration - and manifests after a create/evict/re-read inode cycle. No public exploit code exists and EPSS is 0.20% (10th percentile), reflecting negligible real-world exploitation probability beyond accidental triggering.

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.

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.

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.

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 recursion in Amazon Ion-C before v1.1.6 allows a remote unauthenticated attacker to crash any application that parses untrusted Ion data using this library, causing a denial of service via native call stack exhaustion. The fix, released in v1.1.6 and titled 'Harden container depth,' confirms the root cause is missing or insufficient depth limiting on nested Ion container parsing. No authentication is required and no special configuration is needed beyond the application accepting Ion input from untrusted sources. No public exploit code has been identified at time of analysis.

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.

Connection deadlock in golang.org/x/crypto/ssh (all versions before 0.56.0) allows a malicious remote SSH peer to permanently freeze an SSH connection by flooding the incomingRequests queue of a channel that has been registered in the mux's chanList but not yet established. The attack exploits the absence of any established-state guard in the packet handler, causing a deadlock that renders the entire connection unresponsive without triggering an explicit teardown. No public exploit has been identified and no CISA KEV listing exists, but the network-accessible, no-authentication CVSS vector makes this straightforward to trigger against any Go application using this library for SSH.

Denial-of-service in the Go extended cryptography library's SSH package allows a malicious peer to deadlock an entire SSH connection by sending crafted RFC 4254 channel messages after a channel is established. All versions of golang.org/x/crypto/ssh below 0.56.0 are affected; the flaw manifests because unrecognized channel messages were buffered and allowed to block rather than being rejected as protocol errors. No public exploit or active exploitation has been identified, but the attack requires no privileges in the worst-case client scenario where a malicious SSH server targets a connecting client.

Quadratic CPU exhaustion in HTTPX2's Server-Sent Events parser allows a malicious or compromised SSE endpoint to deny service to Python applications using httpx2.Client.sse() or httpx2.AsyncClient.sse() in versions 2.5.0 through 2.9.x. The _SSELineDecoder.decode() method in _sse.py repeatedly copies and rescans its entire in-memory buffer each time a new chunk arrives for an unterminated line, producing O(n²) processing work proportional to the length of the crafted line. A crafted stream can consume excessive CPU, blocking a synchronous worker thread indefinitely or starving an asynchronous event loop. No public exploit identified at time of analysis; a vendor-released patch is available in version 2.10.0.

BEAM atom table exhaustion in Boruta Server prior to 0.10.0 allows any authenticated end user to crash the entire OAuth 2.0/OpenID Connect umbrella application by repeatedly submitting PUT /users/settings requests with arbitrary novel body keys. The UserSettingsController calls String.to_atom/1 on all user-supplied map keys before any validation, permanently interning them in the Erlang VM's global atom table (hard cap: 1,048,576 entries). Once exhausted, the BEAM runtime aborts with 'no more index entries in atom_tab', taking down the auth, admin, and gateway components simultaneously. No public exploit identified at time of analysis, and the issue has been patched in version 0.10.0.

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.

Prototype pollution in the TOON serialization library (all versions prior to 2.3.1) allows unauthenticated remote attackers to corrupt Object.prototype in any Node.js application that decodes attacker-controlled TOON input. The vulnerability spans multiple decode paths - dotted-key expansion via __proto__, plain nested objects, tabular rows, quoted keys, and streaming decode - as well as the encoder's normalization pipeline. Depending on the downstream dependency tree, exploitable outcomes range from reliable denial of service to remote code execution via prototype-pollution gadget chains; no public exploit or active exploitation is confirmed at time of analysis.

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 via crafted HTTP stream causes a persistent denial of service on Cisco Desk Phone 9800 Series, IP Phone 7800 and 8800 Series, and Video Phone 8875 running Cisco SIP Software, requiring a manual reboot to recover. The root cause is CWE-401 (missing release of memory after effective lifetime) in the device's HTTP packet processing path: an attacker sends a continuous stream of specially crafted HTTP packets, causing the phone to leak memory until it becomes unavailable. Exploitation is gated on a non-default configuration - Web Access must be explicitly enabled on devices registered to Cisco Unified Communications Manager - materially limiting real-world attack surface despite the network-accessible vector. No public exploit code and no CISA KEV listing were identified at time of analysis.

Remote code execution in the Silicon One integration of Cisco Nexus 9000 Series Switches (Cisco NX-OS Software) lets an unauthenticated attacker run code as root by connecting to TCP ports 43210 and 43211, which are exposed by default in the Layer 3 default VRF. Crafted input to the S1HAL process is executed with root privileges, and the same flaw can crash S1HAL to force a device reload (denial of service). Rated CVSS 9.8; no public exploit identified at time of analysis and the CVE is not listed in CISA KEV, but the pre-authentication, network-facing nature makes it a top-priority patch.

NULL pointer dereference in NGINX JavaScript (njs) crashes NGINX worker processes when an njs script calls ngx.fetch() against a server that returns a malformed HTTP response and subsequently reads Response.statusText on the result. All versions of F5's NGINX JavaScript module are listed as affected per the wildcard CPE, and the impact is confined entirely to the data plane - worker availability - with no control-plane, confidentiality, or integrity exposure. No public exploit code exists and the CVE is not listed in CISA KEV at time of analysis, but the network-accessible path and zero-privilege requirement make this a credible service-disruption risk for any NGINX deployment using njs-based outbound HTTP fetching.

Heap out-of-bounds write in NGINX JavaScript (njs) xml.exclusiveC14n() allows unauthenticated remote attackers to crash NGINX worker processes or cause unbounded memory growth, with theoretical code execution that has not been demonstrated. The vulnerability is directly reachable in the nginxinc/nginx-saml reference SAML SP implementation, which passes untrusted InclusiveNamespaces/@PrefixList values to xml.exclusiveC14n() before signature verification completes - meaning no valid SAML signature is required to trigger it. Both the njs (default) and QuickJS engines are affected, with differing crash-vs-leak behavior, but both result in denial of service. No public exploit is 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.

Unauthenticated remote denial of service in Libreswan's pluto IKE daemon allows any network attacker to repeatedly crash and restart the VPN service by sending a malformed X.509 certificate in a CERT payload during IKE handshake negotiation. The crash is triggered by a reachable assertion in `add_decoded_cert()`: when NSS's `CERT_ExtractPublicKey()` receives a certificate with an invalid RSA exponent (e.g., zero), it returns NULL, which the FIPS-mode code path does not handle, causing the daemon to abort. The vendor explicitly confirms no remote code execution is possible; impact is limited to availability. No CISA KEV listing and no public exploit code have been identified at time of analysis.

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.

Sandbox-escaping remote code execution in Google Chrome for Android before 152.0.7977.75 stems from a use-after-free in the Shared Tab Groups feature (CWE-416). A remote attacker who lures a victim into visiting a crafted HTML page can corrupt freed memory to execute arbitrary code outside the renderer sandbox. Chromium rates the severity Critical (CVSS 9.6); the vendor has shipped a fix, but no public exploit has been identified at time of analysis.

Sandbox-escaping remote code execution in Google Chrome for Android before 152.0.7977.75 stems from a use-after-free in the WebGL implementation, letting a remote attacker who lures a victim to a crafted HTML page execute arbitrary code OUTSIDE the renderer sandbox. Rated Critical by Chromium with a CVSS 9.6 (scope-changed) vector; a vendor patch shipped in the September 2026 Stable channel update. No public exploit identified at time of analysis, though the tracker bug (issues.chromium.org/546260492) and Google's own reporting indicate the flaw is well characterized.

Use-after-free in Chrome's TabStrip component enables remote code execution outside the renderer sandbox in Google Chrome versions prior to 152.0.7977.75. An attacker must social-engineer a user into a specific UI interaction to trigger the memory-corruption primitive, after which arbitrary code executes at browser-process privilege - a full sandbox escape. Google has issued a stable channel patch; no public exploit or CISA KEV listing has been identified at time of analysis.

Use-after-free in Google Chrome's Browser process prior to version 152.0.7977.75 enables sandbox escape, allowing an attacker who has already compromised the renderer process to execute arbitrary code outside the Chrome sandbox via a crafted HTML page. The CVSS vector (AV:N/AC:H/S:C/C:H/I:H/A:H) reflects both the network-reachable delivery and the scope change from renderer to host-level execution. No public exploit or CISA KEV listing has been identified at time of analysis, but sandbox-escape primitives of this class are highly valued in exploit chains.

Remote code execution inside Chrome's sandbox is achievable via a use-after-free in WebRTC, triggered when a victim visits a specially crafted HTML page. Affected versions are all Chrome releases prior to 152.0.7977.75 across desktop platforms. No public exploit code or CISA KEV listing has been identified at time of analysis, though the sandboxed execution boundary limits the practical impact compared to the raw CVSS 8.8 score - Google's own Chromium severity rating of 'Medium' reflects this containment.

Remote code execution in Google Chrome for Android before 152.0.7977.75 stems from a use-after-free in Dawn, Chrome's WebGPU/GPU graphics abstraction layer, and - per Google's advisory - allows a crafted HTML page to execute arbitrary code outside the renderer sandbox. Exploitation only requires an unauthenticated victim to visit a malicious page, giving the attacker high-impact code execution on the device. No public exploit has been identified at time of analysis and the issue is not in CISA KEV, though the sandbox-escape framing makes it a high-priority browser patch.

Remote code execution in Google Chrome desktop before 152.0.7977.75 stems from a use-after-free in the Proxy component that a remote attacker can trigger with crafted network traffic to run arbitrary code OUTSIDE the browser sandbox. Google rates the Chromium severity High and a patched Stable channel build is available; no public exploit code has been identified at time of analysis. Because the flaw yields a sandbox escape rather than a contained renderer bug, successful exploitation gives attacker-controlled code on the host at browser-process privilege.

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.

Unbounded recursion in Net::DNS before 1.57 for Perl allows a remote unauthenticated attacker to exhaust memory and terminate any DNS forwarder or proxy process by sending a crafted DNS message carrying a TSIG record misplaced in the answer or authority section with an empty MAC field. Because the library's decoder does not drop the malformed packet as RFC 8945 section 5.2 requires, the TSIG survives the re-encoding strip step and drives `sig_data` into infinite recursion; payloads under 100 bytes on the wire are sufficient to crash the process. No public exploit has been identified at time of analysis, and EPSS indicates low current exploitation probability (0.17%), though the trivially small payload and zero-authentication requirement make this an operational priority for any Perl-based DNS forwarder or proxy deployment.

Uncontrolled CPU consumption in js-yaml versions 3.0.0-3.15.1 and 4.0.0-4.3.1 allows unauthenticated remote attackers to exhaust server CPU by submitting a small YAML document containing aliased sequences of empty mappings merged into many targets, triggering O(N×K) processing while the library's `maxTotalMergeKeys` safety counter is never incremented. Any Node.js application that exposes js-yaml parsing to untrusted input is affected, because merge key (`<<`) processing is enabled by default on both release lines. No confirmed active exploitation appears in CISA KEV at time of analysis, but the attack is trivially reproducible from the published advisory and pathological test case, and the library's ubiquity in the npm ecosystem makes this a high-priority availability risk.

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 remote denial-of-service in HPE AOS-CX allows any network-reachable attacker to crash or interrupt a targeted API service on affected switches, degrading or halting normal network operations. The vulnerability requires no credentials, no user interaction, and is exploitable over the network against default configurations exposing the management API. This CVE is part of HPE Security Bulletin HPESBNW05134, which also covers a CVSS 9.8 unauthenticated RCE (CVE-2026-73749) and a CVSS 7.2 authenticated command injection (CVE-2026-73766) in the same platform; no public exploit has been identified at time of analysis.

Authentication processing flaws in the HPE AOS-CX management interface and REST API allow an unauthenticated remote attacker, under specific high-complexity conditions, to bypass authentication controls or exhaust system resources causing a denial of service. Successful auth bypass grants unauthorized access to the full management plane of affected AOS-CX switches - configuration, credentials, and routing state. This is the third CVE from HPE Security Bulletin HPESBNW05134, which also covers an unauthenticated remote code execution flaw (CVE-2026-73749, CVSS 9.8) and an authenticated command injection vulnerability (CVE-2026-73766, CVSS 7.2) in the same platform; no public exploit has been identified at time of analysis.

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.

Unauthenticated remote denial of service in HPE Networking Fabric Composer's API allows a network-adjacent or internet-reachable attacker to disrupt the availability of the management interface with no credentials required. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) confirms a low-complexity, fully unauthenticated attack path yielding high availability impact, with no confidentiality or integrity exposure. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Unauthenticated remote exploitation of an API endpoint in HPE Networking Fabric Composer can cause high-impact denial of service requiring manual administrator intervention, along with limited unauthorized modifications to the underlying operating system. The CVSS 8.2 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:H) confirms no authentication, no special conditions, and network-level accessibility with no user interaction required. No public exploit code or active exploitation is confirmed at time of analysis, but the management-plane targeting makes this a remediation priority for organizations running HPE fabric orchestration infrastructure.

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.

Memory exhaustion in gRPC-Go before version 1.83.1 allows an unauthenticated remote attacker to crash any service built on this library by sending HTTP/2 streams fragmented into millions of tiny one-byte DATA frames. Each fragment is stored as a separate recvMsg object in recvBuffer, creating severe heap overhead that bypasses HTTP/2 flow-control protections - which limit payload bytes, not the number of allocated metadata objects. No public exploit has been identified at time of analysis, but the attack is fully derivable from the public GitHub advisory and PR diff.

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.

Worker process exhaustion in Erlang/OTP's inets httpd enables unauthenticated remote denial of service by exploiting a bare-catch error-handling flaw in the chunked transfer-encoding decoder, permanently consuming HTTP worker processes until the pool is exhausted and the server becomes unresponsive to legitimate clients. The defect lies in httpd_request_handler:handle_info/2, where a throw exception raised by an invalid chunk-size is silently coerced into a normal return tuple rather than propagated as an error, leaving the worker suspended indefinitely with the request timeout already cancelled and no default byte-rate watchdog to reclaim it. Affected OTP versions span three active release lines (27.x, 28.x, 29.x) in their default configurations; no public exploit is confirmed, though the fix commit includes a regression test that is functionally equivalent to a proof-of-concept attack.

Heap-based buffer overflow in the gvfs SFTP backend (gvfsd-sftp) exposes GNOME desktop users to process-level denial of service or potential arbitrary code execution when connecting to a malicious SFTP server. The read_reply() function trusts the server-supplied response length without validating it against the client's allocated buffer, allowing a rogue server to overflow adjacent heap memory in the gvfsd-sftp daemon. No public exploit or CISA KEV listing is confirmed at time of analysis, but the high CVSS score of 8.8 and the C:H/I:H/A:H triad reflect worst-case RCE potential once a user mounts an attacker-controlled share.

ReDoS in @xmldom/xmldom versions 0.7.0 through 0.8.14 allows remote unauthenticated attackers to stall the Node.js event loop by submitting a small crafted XML document containing a malformed end tag. The SAX parser in lib/sax.js uses an unanchored global regex /[ \t\n\r]+$/g to trim end-tag names; a tag with N whitespace characters followed by one non-whitespace character causes the engine to retry the match from every character position with O(N) backtracking per position, yielding O(N²) total work that blocks the single-threaded event loop. No public exploit code or CISA KEV listing is identified at time of analysis, but the CVSS 4.0 score of 8.7 with VA:H and PR:N reflects the severity of unauthenticated, network-reachable availability impact.

Erlang/OTP's inets HTTP server (httpd) fails to enforce an administrator-configured request body-size limit when processing chunked transfer-encoded requests, enabling unauthenticated remote attackers to exhaust server memory and cause denial of service. Affected OTP branches span 17.x through 27.3.4.16, 28.x through 28.5.0.5, and 29.x through 29.0.5, covering inets versions 5.10 through 9.7.1. No public exploit code has been identified and the CVE is not listed in the CISA KEV catalog, but the zero-authentication, low-complexity network attack path makes this an operationally straightforward DoS risk for any deployment exposing inets httpd to untrusted clients.

Quadratic namespace-map allocation in xmldom's SAX parser allows unauthenticated remote attackers to exhaust the Node.js process heap by sending a compact, crafted XML document with repeated namespace prefix declarations. The unmaintained legacy `xmldom` package (versions 0.1.5-0.6.0) has no available fix, while `@xmldom/xmldom` is patched in releases 0.8.15 and 0.9.12. No public exploit has been identified at time of analysis, but the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) indicates the attack is trivially automatable against any application that parses untrusted XML with this library.

Two independent quadratic-complexity denial-of-service paths in the xmldom JavaScript XML parser allow remote unauthenticated callers to exhaust CPU and memory by submitting crafted XML. The `@xmldom/xmldom` package before versions 0.8.15 and 0.9.12, and all versions of the legacy `xmldom` package (0.3.0-0.6.0), expose both paths through the default `DOMParser.parseFromString()` interface, requiring no authentication or special configuration. No public exploit has been identified at time of analysis, but the security advisories and fix commits are publicly available on GitHub.

Unbounded memory exhaustion in the Erlang/OTP inets httpc HTTP client allows any server the client connects to - including via redirect or man-in-the-middle - to crash the BEAM VM by returning an arbitrarily large volume of response headers. The root cause is that max_header_size defaults to the atom nolimit and the header accumulation loop in httpc_response:parse_headers/6 collects all header data into an in-process list before any size check fires. A proof-of-concept server delivering 100,000 headers of ~4,000 bytes each consumed over 13 GB of RAM in under 30 seconds; no public exploit code has been separately released but the PoC is embedded in the official advisory, and vendor patches are available for OTP 27, 28, and 29 branches.

Erlang/OTP's inets HTTP server (httpd) is vulnerable to a slow-body resource exhaustion attack exploitable by unauthenticated remote attackers across OTP versions 17.0 through 29.0. The request handler cancels its active timeout after successfully parsing request headers, then re-arms the socket for body data without installing any replacement timer, allowing an attacker to open connections with syntactically valid headers and a large Content-Length and then stall indefinitely - permanently occupying a worker process per connection. Vendor patches are available for the OTP 27.x, 28.x, and 29.x branches; no public exploit code or CISA KEV listing has been identified at time of analysis.

Unauthenticated denial of service in Erlang/OTP's inets httpd allows any remote attacker to exhaust a server's process pool, memory, and file descriptors by holding open an unlimited number of TCP connections. The flaw affects all inets httpd deployments across OTP 17.x through 29.x that do not explicitly configure the max_clients option; when that option is absent, a type-comparison defect caused by Erlang's term-ordering rules makes the connection-count guard unconditionally pass, accepting connections without bound. Vendor patches are available in OTP 27.3.4.17, 28.5.0.6, and 29.0.6; no public exploit code or CISA KEV listing has been identified at time of analysis.

Quadratic regex backtracking in @xmldom/xmldom versions 0.9.0-beta.9 through 0.9.10 allows unauthenticated remote attackers to stall the Node.js event loop by supplying a small malformed XML document containing an unterminated processing instruction with a long whitespace tail. The flaw resides in the processing-instruction production regex in lib/grammar.js, where the greedy S+ separator and lazy Char*? data group endlessly repartition whitespace when the required closing ?> is absent, causing O(n²) backtracking in both parsePI and parseProcessingInstruction. No public exploit has been identified at time of analysis, but the fix commit and GitHub Security Advisory GHSA-g53g-w8rj-fmg7 fully document the vulnerable code path, making independent reproduction straightforward. Vendor-released patch: 0.9.11.

Denial-of-service in Rockwell Automation RSLinx Classic allows unauthenticated remote attackers to crash the communication service by sending a specially crafted CIP packet with a manipulated data length field. The root cause is an integer underflow (CWE-191) in the packet length validation routine, causing the service to terminate and requiring a manual restart to recover. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the zero-barrier network attack vector against a critical ICS communication layer makes this a high-priority remediation target.

Denial-of-service in Rockwell Automation RSLinx Classic allows unauthenticated remote attackers to crash the RSLinx Classic communication service by sending a single crafted CIP packet targeting the Forward Close service. Because RSLinx Classic acts as the primary communication bridge between engineering workstations and Allen-Bradley PLCs, a crash forces a manual service restart and can halt production operations in industrial environments. No public exploit code has been identified at time of analysis, and this CVE is not listed in the CISA Known Exploited Vulnerabilities catalog.

Remote denial-of-service in Rockwell Automation RSLinx Classic allows an unauthenticated network attacker to crash the RSLinx Classic service by sending a single crafted CIP (Common Industrial Protocol) packet, after which the service must be manually restarted to restore communications. The flaw is rooted in an integer-overflow (CWE-190) style mishandling of a malformed packet and carries a CVSS 4.0 base score of 9.2 driven by high availability impact on both the service and dependent systems. No public exploit has been identified at time of analysis, and the issue is not listed in CISA KEV.

Denial-of-service in a Rockwell Automation industrial module allows unauthenticated remote attackers to crash the device by sending a single crafted CIP (Common Industrial Protocol) packet, requiring a manual restart to restore availability. The vulnerability affects operational technology (OT) environments where CIP is network-accessible, making it particularly dangerous in industrial control system (ICS) contexts where device downtime can disrupt physical processes. No public exploit code has been identified at time of analysis, and Rockwell Automation has published advisory SD1798 addressing the issue.

Rockwell Automation's ArmorStart LT industrial motor control device contains a denial-of-service flaw in its embedded web server, exploitable by sending a crafted HTTP PUT request with no authentication or special preconditions. The root cause (CWE-770) is improper resource throttling during HTTP PUT processing, which causes the web server to become unavailable. No public exploit code has been identified and the vulnerability is not listed in CISA KEV, but the unauthenticated network attack surface in an OT/ICS context makes this a material operational risk wherever the device's web interface is reachable.

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.

Memory exhaustion in Ash Framework's runtime filter engine allows an attacker controlling filter inputs to crash an Elixir node by submitting a query that spans multiple to-many relationships against large in-memory datasets. The vulnerable `flatten_relationships/2` function in `lib/ash/filter/runtime.ex` (versions 1.29.0-rc0 through 3.32.2) eagerly materializes the full Cartesian product of related rows before evaluating any predicate, producing O(M^K) intermediate records for K relationships with M rows each. No public exploit has been identified at time of analysis; a vendor-released patch is available in version 3.32.2.

Integer overflow in Ash Framework's vector encoding corrupts stored vectors in any Elixir application using Ash versions 2.14.13 through 3.32.1, enabling persistent denial of service against affected database records. The dimension count for a vector submitted with more than 65,535 elements silently wraps modulo 65,536 in a 16-bit header field, causing every subsequent read of the corrupted record to raise an exception. Applications that expose vector ingestion to untrusted users are at risk of permanent per-record data loss; no public exploit has been identified at time of analysis.

CPU exhaustion in Ash Framework's string type constraint handler allows denial of service against Elixir applications that use Ash string attribute validation with both length and regex match constraints. The `Ash.Type.String.apply_constraints/2` function evaluated the `:match` regex unconditionally, even when a length constraint had already failed, allowing attacker-controlled input of arbitrary size to reach the regex engine directly. Against backtracking patterns this produces catastrophic exponential evaluation time; against linear patterns, CPU cost scales with input size, enabling sustained per-request service degradation. No public exploit has been identified at time of analysis.