Denial of Service

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.

Heap metadata corruption in the popt command-line parsing library's `poptConfigFileToString` function can be triggered by a local, low-privileged attacker who supplies specially crafted configuration file content to an affected host. Successful exploitation causes the consuming process to crash, resulting in denial of service. CVSS 2.5 (Low) reflects the strictly local, high-complexity exploitation path with no confidentiality or integrity impact; no public exploit code or active exploitation (CISA KEV) is known at time of analysis.

Buffer overflow in FFmpeg v.7.0 and later within the libavformat/iamf_writer.c component allows an attacker to crash the process by supplying a crafted IAMF (Immersive Audio Model and Formats) file, resulting in a denial of service. The flaw, rooted in improper bounds checking during extradata padding operations (CWE-120), affects the IAMF audio encoder/writer path introduced alongside IAMF support in FFmpeg 7.0. A patch commit (8439e020) and upstream pull request #22988 are available, though a tagged release incorporating the fix has not been independently confirmed. No public exploit code has been identified and EPSS of 0.17% (7th percentile) reflects low exploitation probability at this time.

TX packet pool exhaustion in Zephyr RTOS's IPv6 Neighbor Solicitation path allows an adjacent unauthenticated attacker to render a device permanently unable to transmit any network traffic. The leak in net_ipv6_send_ns() (subsys/net/ip/ipv6_nbr.c) occurs when an NS is already outstanding for a neighbor - each subsequent outbound packet during the ~3-second INCOMPLETE resolution window allocates a new net_pkt that is never released, silently consuming the fixed-size TX pool. With CONFIG_NET_PKT_TX_COUNT defaulting to as low as 4, a brief low-rate spoofed-source burst suffices to produce a complete, reboot-required network denial of service; no public exploit or active exploitation has been identified at time of analysis.

Ethernet bridge input processing in Zephyr RTOS leaks RX packet buffers when CONFIG_NET_ETHERNET_BRIDGE is enabled, allowing any adjacent L2 attacker to exhaust the fixed-size RX pool through a broadcast flood and halt all network reception until reboot. The root cause is eth_bridge_handle_locally() returning NET_OK without consuming the packet, so ethernet_recv() never frees the buffer. An unauthenticated attacker on the same Ethernet segment can emit broadcast or multicast frames with arbitrary EtherType values to permanently consume CONFIG_NET_PKT_RX_COUNT buffers one by one. No public exploit has been identified at time of analysis and this CVE is not in CISA KEV.

Null pointer dereference in FLVMeta up to 1.2.2 causes a process crash when parsing a malformed AMF object from a crafted FLV file, resulting in denial of service. The flaw resides in `amf_object_get` (and the parallel `amf_object_set`) in `src/amf.c`, where a chained double dereference `node->next->next` executes without first confirming `node->next` is non-NULL. A public SEGV proof-of-concept exists, though the project maintainer disputes the security relevance, stating no exploitation path beyond a crash has been demonstrated. No CISA KEV listing; no public exploit identified at time of analysis beyond the crash reproducer.

Race condition in Zephyr RTOS's I3C IBI workqueue subsystem allows a physically-present attacker controlling an I3C peripheral to corrupt kernel memory structures, most realistically causing denial of service. The unsynchronized free-list (sys_slist_t) shared between ISR context and the workqueue handler thread creates a window where a work node can be handed to two consumers simultaneously or a garbage pointer can be dereferenced in a memcpy, producing an out-of-bounds write. No public exploit code has been identified and no CISA KEV listing exists; the patch wrapping all free-list operations in a k_spinlock is confirmed in upstream commit e87e7e2.

Null pointer dereference in armink struct2json 1.0 allows remote attackers to crash any application that deserializes attacker-controlled JSON through the library's `S2J_STRUCT_GET_string_ELEMENT` function. The root cause is an absence of null validation on the `valuestring` field during JSON deserialization in `struct2json/inc/s2jdef.h`, yielding a remotely triggerable denial-of-service. A public proof-of-concept exploit has been disclosed on GitHub; no vendor patch has been issued and the vendor did not respond to responsible disclosure.

Four discrete access control defects in DataEase's sharing link module (versions before 2.10.26) allow any authenticated platform user to cross-access password-protected shares, enumerate other users' share mappings, and disrupt share availability by manipulating tickets they do not own. The flaws span ticket validation (cross-share reuse via ShareTicketManage.validateTicket), password-verification bypass of the mandatory-ticket policy (POST /de2api/share/validate), unauthorized ticket mutation/deletion, and insecure user-ID handling in the share enumeration endpoint. No active exploitation has been confirmed (not in CISA KEV) and no public proof-of-concept code has been identified at time of analysis.

GitList 2.0.0's XML-based commit parser in CommandLine.php can be remotely triggered without authentication to cause a denial-of-service condition, crashing or hanging the PHP process that renders the GitList interface. The root cause is PHP's SimpleXMLElement being used to parse git log output formatted as XML - commit content can be crafted to cause pathological resource consumption or unhandled parse failures (CWE-404). A public proof-of-concept exists per GitHub issue #948 and the CVSS 4.0 E:P exploitability modifier; the flaw is not listed in CISA KEV, so mass active exploitation is not confirmed at time of analysis.

Use-after-free in Valkey 9.1.0's blocked-on-keys subsystem allows a high-privilege authenticated attacker to crash the server by triggering a reentrant client teardown during ready-key iteration. When a key becomes ready and multiple clients are unblocked simultaneously, a reply callback for the first-served client can invoke CLIENT KILL on a successor client, freeing that client's memory while the iterator in `handleClientsBlockedOnKey` still holds a reference to it. A public proof-of-concept exists; the vulnerability is not in CISA KEV, and the high complexity and privilege requirements substantially limit practical exploitation.

Use-after-free in open62541 up to version 1.5.5 allows remote unauthenticated attackers to crash the OPC UA server's History Backend by sending crafted requests targeting the `UA_DataValue_backend_copyRange` function in the in-memory history data plugin. The impact is availability loss only - no confidentiality or integrity compromise. A public proof-of-concept exists via a GitHub issue, and the project closed the disclosure report on procedural grounds rather than issuing a formal security advisory.

Use-after-free in Systerel S2OPC OPC UA stack up to version 1.7.3 allows remote low-privileged attackers to crash the OPC UA server by supplying a crafted EventFilter argument to the subscription monitored-item handler, resulting in a denial of service against industrial communication endpoints. No confirmed active exploitation (not in CISA KEV), though a proof-of-concept is publicly available per the referenced GitLab work item, materially lowering the exploitation barrier. In OT/ICS environments, even a VA:L crash impact can carry significant operational consequences by halting process monitoring or control communications.

Infinite loop denial-of-service in BBEdit's Lasso Language Tokenizer affects all versions up to 15.5.5, allowing a remote attacker to hang the application by delivering a specially crafted Lasso language file that the victim opens. The vulnerability is limited to application-level availability loss with no confidentiality or integrity impact, and requires user interaction to trigger. No active exploitation has been identified; vendor-released fix is available in BBEdit 16.0.

Infinite-loop denial-of-service in ash_ai's ToolLoop component (versions 0.6.0 through <1.0.0) allows an attacker who can influence LLM model output - most practically via prompt injection - to hang the agent loop indefinitely and drive unbounded, repeated model API requests. When the LLM returns tool_call_ids that are either invalid or already present in the session history, the post-filter call list empties, yet the loop recurses with a byte-identical message state, making no forward progress and wasting unbounded API budget. No public exploit code or active exploitation has been identified at time of analysis; however, the prompt-injection attack path is well within reach of applications that ingest untrusted user content.

CVE-2026-80489 cannot be meaningfully summarized - the description is absent and no CVSS, CWE, CPE, EPSS, KEV, or patch data was provided. The sole intelligence signal is a Ubuntu vendor report, suggesting the affected package may be distributed via Ubuntu repositories, but the specific product, vulnerability class, and impact are entirely unconfirmed. No exploitation status, severity, or affected scope can be determined from available data.

Out-of-bounds read in Exiv2's RemoteIo::Impl::populateBlocks() function affects versions prior to 0.28.9, exploitable only when the tool is invoked against a remote URL rather than a local file. An attacker controlling a remote server can serve a crafted image to trigger the read when a user runs exiv2 against that URL, potentially causing information disclosure or a crash. No public exploit code or active exploitation has been identified; the vulnerability is rated low severity and fixed in the 0.28.9 release.

Reachable assertion (CWE-617) in Open5GS through 2.7.7 allows remote authenticated attackers to abort the SMF (Session Management Function) process by supplying an invalid ARP preemption capability or vulnerability enum value via the Nudm SDM interface, disrupting all active PDU sessions managed by that instance. The root cause is the use of ogs_assert() for enum validation in smf_nudm_sdm_handle_get() - when preemptCap or preemptVuln holds an unexpected value, the assertion fires unconditionally and kills the process. No public exploit code has been identified and the vulnerability is not listed in CISA KEV; vendor-confirmed fix is available in version 2.8.0.

Null pointer dereference in Open5GS versions up to 2.7.7 allows network-accessible low-privileged attackers to crash the AMF (Access and Mobility Management Function) by sending crafted SBI messages with missing required body fields to the N1/N2 Transfer Endpoint. The vulnerability exists across multiple code paths in src/amf/namf-handler.c, including UE context transfer, registration status update, and UE MM context list decoding, where pointers were dereferenced without null guards. Successful exploitation causes AMF process termination, denying 5G mobility and UE registration services to all subscribers managed by the affected AMF instance. No public exploit code and no CISA KEV listing have been identified at time of analysis.

Denial of service in Open5GS AMF (Access and Mobility Management Function) versions up to 2.7.7 allows a remote low-privileged attacker to crash the AMF process by submitting a crafted N1N2MessageTransfer request containing an unrecognized ngapIeType value, triggering an unchecked assertion termination. The AMF is a singleton or small-cluster critical component of 5G core infrastructure; its crash disconnects all user equipment registered through that instance until service restarts. A public exploit exists (GitHub issue #4396) and the fix is available in version 2.8.0, making patching the clear immediate action.

Relay node query crash in AshGraphql (ash_graphql 0.27.0 through 1.10.x) allows an unauthenticated remote caller to abort the Absinthe node(id:...) resolver by supplying a base64-encoded relay ID whose type segment resolves to an existing BEAM VM atom that is not a registered relay resource type. Because the resolver calls Map.fetch!/2 before Absinthe's rescue handlers run, the resulting KeyError surfaces as an unhandled process exception rather than a structured GraphQL error, potentially leaking an internal stacktrace with module names and file paths. No public exploit code has been identified at time of analysis, though the fix commit is publicly visible on GitHub.

Denial of service via improper resource shutdown in Magma 1.9.0's gNB Termination Handler allows remote low-privileged attackers to disrupt or crash the AMF's NGAP processing of 5G base station connections. The flaw in tasks/ngap/ngap_amf.c stems from CWE-404 (improper resource release), producing availability impact against the vulnerable system with no confidentiality or integrity consequence. A public proof-of-concept exploit exists per the referenced GitHub issue #16019, though CISA has not confirmed active exploitation.

SQL LIKE wildcard injection in ash_sql (Elixir, versions 0.1.1-rc.10 through 0.7.0) allows any user who can supply a search string to the contains/2, string_starts_with/2, or string_ends_with/2 filter functions to reintroduce live LIKE wildcards that the escape helper was intended to neutralize. The escape helper prefixes % and _ with backslash but never first escapes a backslash already present in user input, so the sequence \% survives escaping with its % intact as an unescaped wildcard, enabling attackers to widen query matches, evade negated filter guards, or crash individual queries with a trailing lone backslash. No public exploit has been identified at time of analysis, and a vendor-released fix is available in version 0.7.1.

Cubic-complexity denial of service in ash_paper_trail's full-diff list change builder allows any user permitted to invoke a paper-trailed Ash action with an accepted array attribute to exhaust backend CPU and memory. Versions 0.1.1 through 0.6.x are affected; the root cause is an O(n³) list accumulation pattern in `AshPaperTrail.ChangeBuilders.FullDiff.ListChange` where unbounded action input directly drives allocation. No public exploit has been identified and the issue is not in CISA KEV, but no rate-limiting or length check guards the vulnerable path, making the attack trivially reproducible by any user with action access.

Comma-split value parsing in the qs npm library (versions 6.14.2 through 6.15.3) bypasses the caller-configured `arrayLimit` when the bracket-push key form (`a[]=`) is combined with both `comma: true` and `throwOnLimitExceeded: true` options. An `isFlatArrayValue` flag in `parseArrayValue` incorrectly excluded `[]=` key forms from the pre-split comma count check introduced by the CVE-2026-2391 patch, allowing a single crafted parameter to allocate an arbitrarily large inner array while the documented limit silently fails open. A proof-of-concept is confirmed in the vendor advisory; the CVE is not listed in CISA KEV and no active exploitation has been confirmed. The fix ships in v6.16.0 via commit 8859c37.

Partial Denial of Service in NetApp StorageGRID versions 11.5 and higher arises from unbounded resource allocation (CWE-774) reachable only under a non-standard configuration and specific operational scenario. An authenticated network attacker with some degree of environmental control can exhaust handles or descriptors to degrade availability, though impact is explicitly partial and limited to the vulnerable system. No public exploit code has been identified and no active exploitation is confirmed; the vendor-assigned CVSS 4.0 score of 2.3 accurately reflects the tightly constrained real-world risk.

Local denial-of-service in IBM Cloud Pak for Data System 11.3.0.2 through Interim Fix 001 allows a local attacker to exhaust system resources and render the platform unavailable, without requiring any credentials. The vulnerability stems from improper resource allocation controls (CWE-770), meaning the system places no effective cap on resource consumption triggered by local access. No public exploit has been identified at time of analysis, and a vendor patch is available via IBM's support portal.

NULL pointer dereference in TP-Link TL-WR841N v14's UPnP service allows adjacent-network attackers to crash the UPnP process by sending a specially crafted SOAP state variable query, resulting in a denial-of-service condition. The affected UPnP functionality - including device discovery and state management - remains unavailable until the process is restarted or the device is rebooted. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in CISA's Known Exploited Vulnerabilities catalog.

NULL pointer dereference in the UPnP SOAP request handler of the TP-Link TL-WR841N v14 allows an adjacent-network attacker to crash the UPnP daemon by sending a crafted SOAP action request with unexpected XML content, producing a denial-of-service condition until the service is restarted or the device rebooted. Impact is confined to UPnP functionality; the router itself continues operating. No public exploit identified at time of analysis, and this CVE is not listed in the CISA KEV catalog. TP-Link has released a firmware patch addressing this flaw.

Use-after-free (CWE-416) in Microsoft Edge (Chromium-based) allows a remote, unauthenticated attacker to crash the browser through a crafted webpage, resulting in a denial-of-service condition. Critically, the CVE description claims code execution capability, but the CVSS vector (C:N/I:N/A:L, score 4.3) directly contradicts this - a genuine RCE would produce C:H/I:H impact in the 8-9+ range; this discrepancy should be verified against the full MSRC advisory. No active exploitation has been confirmed and no public POC has been reported; a vendor patch is available via the Microsoft Security Response Center.

Heap out-of-bounds read and stack out-of-bounds access in GIMP's file-psd plugin allow an attacker to crash the application or disclose limited memory contents by convincing a user to open a specially crafted PSD image. The flaw affects GIMP as shipped in Red Hat Enterprise Linux 6 through 9 and stems from missing validation of the channel-count parameter during PSD parsing. No active exploitation has been identified; the attack requires local file delivery and deliberate user interaction, significantly constraining real-world risk.

Stack-based buffer overflow vulnerabilities in the PLANET GS-4210-16P2S managed PoE switch web management interface allow a remote authenticated attacker to crash the CGI process and disrupt web-based device administration. Three separate POST parameter handlers in /cgi-bin/dispatcher.cgi - processing usrPass, enbPass, usrName, and usrPass - copy user-supplied input into fixed-size stack buffers without bounds validation, triggering CWE-121 conditions. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; impact is confined to denial of service against the web management plane.

Stack-based buffer overflow and null pointer dereference vulnerabilities in the PLANET GS-4210-16P2S managed PoE switch firmware (all versions before 3.441b260626) allow a remote authenticated attacker to crash the CGI-based web management service by submitting crafted POST requests to RADIUS server configuration handlers. The `web_radiusSrv*_post` handler family in `/cgi-bin/dispatcher.cgi` copies user-controlled parameters into fixed-size stack buffers without bounds checking and dereferences `radName`/`radIp` pointers without confirming their presence. No public exploit code exists and the vulnerability is not listed in the CISA KEV catalog at time of analysis; a vendor-released firmware patch is available.

Stack-based buffer overflows in PLANET GS-4210-16P2S managed switch firmware before 3.441b260626 allow a remote administrator to crash the web management interface by sending crafted HTTP POST requests to /cgi-bin/dispatcher.cgi. More than 30 named CGI handler functions - spanning VLAN, SNMP v3, ACL, AAA, DHCP, STP, PoE, and cable diagnostics subsystems - copy attacker-supplied POST parameters into fixed-size stack buffers without length validation. The confirmed impact is denial of service of the web management service; the vulnerability is not listed in CISA KEV and no public exploit code has been identified at time of analysis, though a vendor patch is available.

Null pointer dereference in PLANET GS-4210-16P2S managed switch firmware before 3.441b260626 allows remote authenticated attackers to crash the web management interface by sending a crafted request. The web_poe_alive_rmtip_post handler in /cgi-bin/dispatcher.cgi dereferences the rmtIP POST parameter without first validating its presence, meaning a missing parameter is dereferenced as NULL, faulting the CGI process and rendering the web management interface unavailable. No active exploitation (CISA KEV) or public proof-of-concept has been identified at time of analysis, though the trigger is trivially simple - a single omitted parameter - for any attacker already holding administrative credentials.

Heap out-of-bounds read in GIMP's file-pvr plugin exposes users of Red Hat Enterprise Linux 6 through 9 to application crashes and limited heap memory disclosure when opening a crafted PVR image file. The VQ (Vector Quantization) compressed-texture decoder omits mandatory bounds validation, allowing a malicious image to read beyond allocated heap regions. Impact is primarily denial of service via crash, with a secondary low-severity information disclosure path; no public exploit code and no CISA KEV listing are associated with this issue at time of analysis.

Heap out-of-bounds read in GIMP's file-ico plugin allows a local attacker to crash GIMP or leak limited heap memory contents by delivering a specially crafted ICO image file to a victim user. Affected packages span Red Hat Enterprise Linux 6 through 9. No public exploit code or CISA KEV listing exists at time of analysis, but the user-interaction requirement (opening a malicious file) is the primary delivery mechanism and a realistic social-engineering target in image-processing workflows.

Out-of-bounds memory write in libsolv crashes RPM-based package manager tools (dnf, yum, zypper) when processing a corrupted or specially crafted .solv repository cache file. The root cause is an absent array-index bounds check on directory-id values read from compressed filelist data during .solv file rewriting - but because the out-of-bounds write stores only a fixed, non-attacker-controlled value, the vendor explicitly rules out arbitrary code execution, confining impact to denial of service. No public exploit has been identified and no active exploitation is confirmed; note that the 'RCE' metadata tag conflicts directly with the description and appears to be erroneous.

Heap out-of-bounds read in GIMP's file-iff plugin allows a local attacker to crash the application or disclose limited heap memory contents by delivering a specially crafted IFF/ILBM image file. The flaw stems from missing validation of HAM row size when the number of color planes (nPlanes) is zero, causing a size mismatch that bypasses memory bounds checking. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis.

Memory exhaustion and disk consumption in Ericsson CodeChecker's massStoreRun API endpoint allows authenticated users holding analysis-run storage permissions to trigger denial of service via a decompression bomb. The processing path accepts Base64-encoded zlib payloads and fully materializes the decompressed output in memory before any disk write, with no maximum decompressed size enforced - a small compressed payload can expand to gigabytes. A proof-of-concept exists (CVSS 4.0 supplemental metric E:P) and the attack is automatable (AU:Y), meaning a compromised or malicious account with store permissions can repeatedly crash the service or exhaust host resources.

Uncontrolled payload size acceptance in SvelteKit's remote form function handler allows unauthenticated remote attackers to crash the underlying Node.js process by submitting oversized POST payloads. All @sveltejs/kit versions prior to 2.69.1 are affected; no authentication or special configuration is required to trigger the crash. Repeated exploitation can sustain denial-of-service against the application process; no public exploit code or CISA KEV listing has been identified at time of analysis.

Stack exhaustion via crafted compressed IMAP data in OX Dovecot Pro and OX Dovecot CE allows an authenticated remote attacker to crash the IMAP process, causing denial of service. The flaw (CWE-674, Uncontrolled Recursion) is triggered by sending specially constructed compressed payloads that exceed stack depth limits during decompression processing. No public exploit code exists, and exploitation requires valid IMAP credentials, meaningfully limiting the attacker pool.

IMAP compression in OX Dovecot Pro and OX Dovecot CE allows any authenticated user to exhaust the memory of the imap-login process by negotiating a memory-intensive decompression algorithm across multiple simultaneous connections. The process crashes after only a few such connections, terminating all sessions it manages and causing denial of service for all active IMAP users sharing that process. No public exploits are known and CISA KEV does not list this CVE, but the low prerequisite bar - any valid IMAP credential - makes it a meaningful risk in multi-tenant or hosted email environments.

Login process denial-of-service in OX Dovecot Pro and OX Dovecot CE allows a host designated as a trusted proxy to crash the Dovecot authentication process by injecting a NUL byte into proxy forwarding headers, disrupting subsequent login attempts for all users. The vulnerability carries a CVSS 4.3 (Medium) score with an adjacent-network vector, confining realistic exposure to deployments that explicitly configure trusted proxy hosts - a non-default setup. No public exploit is identified at time of analysis, and Open-Xchange has issued a security advisory with patch guidance.

CPU exhaustion via infinite loop in OX Dovecot CE's ManageSieve login handler allows unauthenticated remote attackers to deny Sieve script management and potentially degrade the entire mail server. The flaw is triggered at the pre-authentication stage, requiring only network access to the ManageSieve port; repeated connections can saturate all available CPU cores. No public exploit code exists, and the CVSS AC:H metric indicates the attack requires precisely crafted input, limiting opportunistic exploitation.

OX Dovecot Pro and OX Dovecot CE are susceptible to a hash-collision denial-of-service attack where an attacker who can deliver mail to a target user can craft message headers engineered to collide in an internal hash table, causing the IMAP THREAD command to consume CPU disproportionate to message size. Any mail client issuing THREAD against the poisoned mailbox triggers sustained CPU exhaustion, degrading or denying IMAP service. This is a distinct issue from CVE-2026-40014 and is not resolved by that fix; no public exploit is identified at time of analysis.

CPU exhaustion in OX Dovecot's IMAP THREAD command allows a remote unauthenticated attacker to degrade or deny IMAP service by sending a specially crafted message header to any mailbox user. The vulnerability triggers when a mail client subsequently issues a THREAD command on the affected mailbox, causing disproportionate CPU consumption relative to message size. No public exploit code exists and the CVE has not been added to the CISA KEV catalog, but the low attack complexity and zero-authentication requirement make it operationally significant for any organization running OX Dovecot at scale.

Memory corruption via out-of-bounds write in OX Dovecot Pro and OX Dovecot CE's ManageSieve service allows authenticated network attackers to crash the ManageSieve process, denying all users the ability to remotely manage Sieve email filter scripts. The root cause is improper handling of extreme numeric literals during Sieve script compilation. The vendor notes that remote code execution may theoretically be achievable via the same memory corruption primitive, though no public exploit demonstrates this; no public exploits are known and the vulnerability is not listed in CISA KEV.

Uncontrolled CPU consumption in OX Dovecot Pro and OX Dovecot CE allows authenticated IMAP users to trigger a denial of service by issuing malformed or resource-intensive IMAP LIST commands. Both the commercial (Pro) and community (CE) editions of Open-Xchange's Dovecot distribution are affected across all tracked versions per CPE data. No public exploit code has been identified at time of analysis, and the CVSS score of 4.3 reflects the authenticated-access prerequisite and limited availability impact.

Submission-login process crashes with an epoll() panic in OX Dovecot Pro and CE when the per-IP connection limit (mail_max_userip_connections, default 10) is reached, due to improper file descriptor handling (CWE-403). In high-performance mode - the default for Pro releases - the crash terminates all connections managed by the affected process, not just the triggering one, creating a broader denial-of-service for email submission. A secondary side effect of duplicate message delivery is possible when backend TLS is absent. No public exploits are known and this vulnerability is not listed in CISA KEV.

Heap buffer overflow in FFmpeg's TDSC screen-capture codec decoder exposes Red Hat Enterprise Linux AI 3 and OpenShift AI deployments to denial of service or potential arbitrary code execution. The tdsc_load_cursor() function performs erroneous stride-based pointer arithmetic in two locations when rendering cursor data from crafted TDSC video, writing past a heap-allocated buffer boundary. No public exploit or active exploitation has been confirmed at time of analysis, and the upstream fix is available as FFmpeg commit 242ff799c.

In the Linux kernel, the following vulnerability has been resolved: drm/amd/display: use proper context for logging The same as the rest of the code, get_ss_info_from_atombios() uses calc_pll_cs->ctx->logger for logging. But calc_pll_cs->ctx is initialized only later in calc_pll_max_vco_construct(). Therefore, any output using DC_LOG_SYNC() leads to a NULL pointer deference in get_ss_info_from_atombios(). According to Sashiko, the very same problem exists in dce112_get_pix_clk_dividers() and dcn3_get_pix_clk_dividers() too. To avoid accessing the NULL context, use clk_src->base.ctx->logger everywhere. That context in base is initialized earlier in dce110_clk_src_construct() and dce112_clk_src_construct(). Before get_ss_info_from_atombios() or Sashiko's get_pix_clk_dividers functions above are actually called. This is done by redefining DC_LOGGER to CTX->logger. Before: dce110_clk_src_construct() did: -> sets clk_src->base.ctx = ctx; -> ss_info_from_atombios_create() -> get_ss_info_from_atombios() <- uses calc_pll_cs->ctx # BOOM -> calc_pll_max_vco_construct() <- sets calc_pll_cs->ctx After: dce110_clk_src_construct() does: -> sets clk_src->base.ctx = ctx; -> ss_info_from_atombios_create() -> get_ss_info_from_atombios() <- uses clk_src->base.ctx (cherry picked from commit 6f16fcbb0c46a87e3d9685407e906573d60104b0)

In the Linux kernel, the following vulnerability has been resolved: erofs: ensure valid f_path for page cache sharing Previously, backing files for page cache sharing were set up with f_path left as NULL (only f_inode was valid). It worked, but a recent mincore fix relies on f_path.mnt and crashes (found by "erofs/028" on 7.2-rc4): BUG: kernel NULL pointer dereference, address: 0000000000000018 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP PTI CPU: 3 UID: 0 PID: 675528 Comm: fincore Not tainted 7.2.0-rc4-00002-g[]-dirty #1 PREEMPT(lazy) Hardware name: Red Hat KVM, BIOS 1.16.0-4.al8 04/01/2014 RIP: 0010:__do_sys_mincore+0xc0/0x2c0 ... Specify valid paths using valid disconnected dentries together with erofs_ishare_mnt instead of leaving f_path empty, so they are more like real backing files in a pseudo filesystem and standard backing_file_open() can be used directly.

In the Linux kernel, the following vulnerability has been resolved: tracing/mmiotrace: Add NULL check for mmio_trace_array in logging functions mmio_trace_rw() and mmio_trace_mapping() retrieve mmio_trace_array into tr and pass it to __trace_mmiotrace_rw() and __trace_mmiotrace_map(). If these functions are invoked while mmio_trace_array is NULL (e.g. before initialization or after disabled), accessing tr->array_buffer.buffer will result in a NULL pointer dereference crash. Fix this by adding an explicit NULL check for tr at the beginning of __trace_mmiotrace_rw() and __trace_mmiotrace_map().

In the Linux kernel, the following vulnerability has been resolved: mm: migrate_device: fix pte_pfn/pte_dirty called on non-present PTE pte_pfn() and pte_dirty() have undefined behaviour when called on a non-present PTE. In migrate_vma_collect_pmd(), these functions may be invoked on non-present entries (e.g., device-private entries), leading to potential crashes from pte_pfn() or incorrect dirty folio accounting from pte_dirty(). Fix both by guarding with pte_present() checks.

In the Linux kernel, the following vulnerability has been resolved: s390/dasd: Fix potential NULL pointer dereference dasd_release_space() checks the implementation of the is_ese() discipline function before calling it to determine if a given device is an ESE DASD. The current usage of the logical AND operator will lead to a NULL pointer dereference as the function is called even if the function pointer is NULL. Fix this by using the logical OR operator.

In the Linux kernel, the following vulnerability has been resolved: drm/rockchip: dw_dp: Fix null-ptr-deref in dw_dp_remove() Attempting to access driver data in the platform driver ->remove() callback may lead to a null pointer dereference since there is no guaranty that the component ->bind() callback invoking platform_set_drvdata() was executed. A common scenario is when Rockchip DRM driver didn't manage to run component_bind_all() because of an (unrelated) error causing early return from rockchip_drm_bind(). Drop the unnecessary call to platform_get_drvdata() and, instead, reference the target device structure via platform_device.

In the Linux kernel, the following vulnerability has been resolved: accel/amdxdna: Guard management mailbox channel cleanup against NULL pointer The management mailbox channel cleanup helpers can be called from error handling paths when mgmt_chann has already been destroyed. Add NULL checks to xdna_mailbox_free_channel() and xdna_mailbox_stop_channel() so the cleanup path safely returns instead of dereferencing a NULL mailbox channel pointer.

In the Linux kernel, the following vulnerability has been resolved: soc: xilinx: Fix race condition in event registration The zynqmp_power driver registers handlers for suspend and subsystem restart events using register_event(). However, the work structures (zynqmp_pm_init_suspend_work and zynqmp_pm_init_restart_work) used by these handlers were allocated and initialized after the registration call. This created a race window where, if the firmware triggered an event immediately after registration but before allocation, the callback (suspend_event_callback or subsystem_restart_event_callback) would dereference a NULL pointer in work_pending(), leading to a crash. Fix this by allocating and initializing the work structures before registering the events.

In the Linux kernel, the following vulnerability has been resolved: soc: xilinx: Shutdown and free rx mailbox channel A mbox rx channel is requested using mbox_request_channel_byname() in probe. In remove callback, the rx mailbox channel is cleaned up when the rx_chan is NULL due to incorrect condition check. The mailbox channel is not shutdown and it can receive messages even after the device removal. This leads to use after free. Also the channel resources are not freed. Fix this by checking the rx_chan correctly.

In the Linux kernel, the following vulnerability has been resolved: crypto: ccp/sev-dev-tsm - bail out early when pdev->bus is NULL dsm_create() initially checks pdev->bus when computing segment_id: u8 segment_id = pdev->bus ? pci_domain_nr(pdev->bus) : 0; But the next two lines unconditionally dereference pdev->bus via pcie_find_root_port() and especially pci_dev_id(pdev), which expands to PCI_DEVID(dev->bus->number, dev->devfn). If pdev->bus is in fact NULL, segment_id is initialised to 0 but the very next statement crashes the kernel. smatch flags this: drivers/crypto/ccp/sev-dev-tsm.c:253 dsm_create() error: we previously assumed 'pdev->bus' could be null (see line 251) Make the NULL handling consistent: if pdev->bus is NULL the device has no PCI context to work with and SEV TIO setup cannot proceed, so return -ENODEV before any of the bus-dependent lookups. The remaining initialisation now runs only on the path where pdev->bus is known to be valid. No change for callers where pdev->bus is non-NULL, which is the only case where dsm_create() did meaningful work before this change.

In the Linux kernel, the following vulnerability has been resolved: ocfs2: don't BUG_ON an invalid journal dinode [BUG] A fuzzed OCFS2 image can corrupt the current slot journal dinode while mount is still in progress. The mount path first reports the invalid journal block and then crashes in shutdown: kernel BUG at fs/ocfs2/journal.c:1034! Oops: invalid opcode: 0000 [#1] SMP KASAN NOPTI RIP: 0010:ocfs2_journal_toggle_dirty+0x2d6/0x340 fs/ocfs2/journal.c:1034 Call Trace: ocfs2_journal_shutdown+0x414/0xc30 fs/ocfs2/journal.c:1116 ocfs2_mount_volume fs/ocfs2/super.c:1785 [inline] ocfs2_fill_super+0x30a9/0x3cd0 fs/ocfs2/super.c:1083 get_tree_bdev_flags+0x38b/0x640 fs/super.c:1698 get_tree_bdev+0x24/0x40 fs/super.c:1721 ocfs2_get_tree+0x21/0x30 fs/ocfs2/super.c:1184 vfs_get_tree+0x9a/0x370 fs/super.c:1758 fc_mount fs/namespace.c:1199 [inline] do_new_mount_fc fs/namespace.c:3642 [inline] do_new_mount fs/namespace.c:3718 [inline] path_mount+0x5b8/0x1ea0 fs/namespace.c:4028 do_mount fs/namespace.c:4041 [inline] __do_sys_mount fs/namespace.c:4229 [inline] __se_sys_mount fs/namespace.c:4206 [inline] __x64_sys_mount+0x282/0x320 fs/namespace.c:4206 ... [CAUSE] ocfs2_journal_toggle_dirty() used to return -EIO when journal->j_bh no longer contained a valid dinode, because the startup and shutdown paths already handled that failure. Commit 10995aa2451a ("ocfs2: Morph the haphazard OCFS2_IS_VALID_DINODE() checks.") changed the check to a BUG_ON() under the assumption that the journal dinode had already been validated. That turns an unexpected invalid journal dinode during mount teardown into a kernel crash instead of a normal mount failure. [FIX] Replace the BUG_ON() with WARN_ON() and return -EIO. This keeps the invariant warning for debugging, but restores the original behavior of failing startup or shutdown cleanly instead of panicking the kernel.

In the Linux kernel, the following vulnerability has been resolved: netfilter: conntrack: revert ct extension genid infrastructure This infrastructure is not used anymore after moving ct timeout and helper to use datapath refcount to track object use. Revert commit c56716c69ce1 ("netfilter: extensions: introduce extension genid count") this patch disables all ct extensions (leading to NULL) for unconfirmed conntracks, when this is only targeted at ct helper and ct timeout. There is also codebase that dereferences the ct extension without checking for NULL which could lead to crash.

In the Linux kernel, the following vulnerability has been resolved: wifi: mt76: mt7996: Fix NULL pointer dereference in mt7996_init_tx_queues() When MT76_NPU and CONFIG_NET_MEDIATEK_SOC_WED are enabled and mt76 detects properly the Airoha NPU SoC, mt7996_init_tx_queues() will dereference a NULL WED pointer. Fix the issue by always passing the WED pointer from mt7996_dma_init().

In the Linux kernel, the following vulnerability has been resolved: net: enetc: fix potential divide-by-zero when num_vsi is zero For i.MX94 series, all the standalone ENETCs do not support SR-IOV, so pf->caps.num_vsi is zero. This leads to a divide-by-zero in enetc4_default_rings_allocation() when distributing rings among PF and VFs. Division by zero is undefined behavior in C. On ARM64, the UDIV/SDIV instructions silently return zero rather than raising an exception, so the issue does not cause a visible crash. However, relying on this behavior is incorrect and poses a cross-platform compatibility risk. Add an explicit check for num_vsi == 0 and return early after the PF's rings have been configured.

In the Linux kernel, the following vulnerability has been resolved: HID: picolcd: prevent NULL pointer dereference in picolcd_send_and_wait() In picolcd_send_and_wait(), an integer overflow of the signed loop counter 'k' can theoretically lead to a NULL pointer dereference of 'raw_data'. If the loop executes more than INT_MAX times, 'k' becomes negative, making the condition 'k < size' true even when 'size' is 0. Change the type of 'k' to 'unsigned int' to prevent the overflow and eliminate the out-of-bounds access. Found by Linux Verification Center (linuxtesting.org) with the Svace static analysis tool. [jkosina@suse.com: extended hash length]

In the Linux kernel, the following vulnerability has been resolved: mtd: maps: vmu-flash: fix NULL pointer dereference in initialization The mtd_info contains a struct device, which must be linked to its parent. Without this, the initialization of the MTD fails with a NULL pointer dereference.

In the Linux kernel, the following vulnerability has been resolved: Input: ims-pcu - fix potential infinite loop in CDC union descriptor parsing The driver parses CDC union descriptors in ims_pcu_get_cdc_union_desc() by iterating through the extra descriptor data. However, it does not verify that the bLength of each descriptor is at least 2. A malicious device could provide a descriptor with bLength = 0, leading to an infinite loop in the driver. Add a check to ensure bLength is at least 2 before proceeding with parsing.

Arbitrary file deletion via path traversal in the Shared Files and Shared Files Pro WordPress plugins (versions before 1.7.67 and 1.7.68 respectively) enables unauthenticated attackers to trigger deletion of critical server files such as wp-config.php, causing denial of service and potential site takeover. The plugin's single-pass traversal filter is bypassable during frontend file submission, allowing a crafted path pointing outside the uploads directory to be stored; when an administrator later permanently deletes the corresponding file entry, the resolved arbitrary file is removed. A publicly available proof-of-concept exists, though SSVC assessment rates exploitation as none at time of analysis, likely reflecting the two-stage attack dependency on administrator action.

Unauthenticated BLE packet injection in BitChat for iOS v1.5.0 (reported in the CVE as v1.15.0) allows any device within Bluetooth adjacency range to inject crafted MESSAGE packets into the mesh gossip cache, causing denial of service for all mesh participants. The attack exploits a TTL=0 validation bypass in BLEService.swift that accepted packets as anonymous without full sender authentication. A public proof-of-concept is available at a named GitHub repository; no active exploitation has been confirmed by CISA KEV.

NULL pointer dereference in Wazuh agent enrollment (versions 4.0.0-4.14.6) allows a network-positioned attacker operating a rogue manager or performing a man-in-the-middle attack to deterministically crash the agent process by supplying a malformed key response containing fewer than four space-separated fields. The flaw resides in `w_enrollment_process_agent_key()` in `src/shared/enrollment_op.c`, which passes unvalidated NULL entries from `OS_StrBreak()` directly into `OS_IsValidName()`, where an unguarded `strlen()` call on a NULL pointer terminates the agent. The attack is constrained by high complexity conditions (no CA certificate configured, or active MITM capability), and no public exploit code or CISA KEV listing has been identified at time of analysis. The issue is fixed in Wazuh 4.14.7.

Heap-based buffer overflow in WatchGuard Fireware OS's iked process allows an authenticated administrator to crash the IKE daemon by saving a specially crafted configuration, resulting in denial of service and disruption of IPsec VPN services. The CVSS 4.0 score of 6.9 with PR:H reflects the high-privilege requirement, meaning exploitation is gated behind valid administrator credentials. No active exploitation has been identified (not in CISA KEV) and no public exploit code is known at time of analysis.

Denial of service in Silicon Labs SiSDK v2026.6.0 and earlier affects EFR32MG24 and EFR32MG26 wireless SoCs running concurrent multiprotocol Zigbee and Thread. Under high network traffic loads, ACK packets are dropped, causing the device networking stack to fail and rendering the IoT endpoint unresponsive. No public exploit has been identified and active exploitation has not been confirmed by CISA KEV, but the patch is available from the vendor.

Denial of service in jwcrypto's JWE.deserialize() function allows a remote unauthenticated attacker to crash any service that processes untrusted JWE tokens by submitting a malformed compact serialization containing an excessive number of period delimiters, triggering uncontrolled memory allocation and a MemoryError. Affected deployments include Red Hat Ansible Automation Platform 2, RHEL 9 and 10, OpenShift AI (RHOAI), and OpenStack Platform 16.2 as disclosed via Red Hat Bugzilla 2524147 and upstream advisory GHSA-96rv-c4vc-h4f4. No public exploit code or CISA KEV listing exists at time of analysis, and impact is confined to availability with no confidentiality or integrity exposure.

Denial of Service in Spring Cloud Config's Monitor component allows unauthenticated remote attackers to crash or degrade the configuration server by submitting malicious payloads to the webhook endpoint. Affected versions span the 3.x, 4.x, and 5.x release lines, covering a broad installed base of Spring Boot microservice environments. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, though the unauthenticated network-accessible attack surface (PR:N, AV:N, AC:L) means exploitation requires minimal capability.

Spring Cloud Stream's dynamic destination cache lacks an upper bound on its size, exposing applications to limited information disclosure and integrity concerns under constrained conditions. Affected versions span the 4.2.x, 4.3.x, and 5.0.x release lines, reported by VMware (Broadcom), the Spring project maintainer. No public exploit code exists and the vulnerability is not listed in CISA KEV; the low CVSS score of 3.1 reflects the highly constrained exploitation prerequisites including high privilege requirements and user interaction.

Resource exhaustion in Spring for GraphQL's WebSocket client allows unauthenticated remote attackers to trigger a Denial of Service when the keepAlive feature is enabled. Three release trains are affected: 1.3.x through 1.3.9, 1.4.x through 1.4.6, and 2.0.x through 2.0.4, as confirmed by the VMware/Spring vendor advisory. No public exploit code has been identified and EPSS at 0.15% (4th percentile) indicates low near-term exploitation probability, though the lack of authentication requirement warrants patching for any deployment exposing WebSocket endpoints to untrusted networks.

Regular expression denial of service in NLTK's Pl196xCorpusReader allows unauthenticated remote attackers to exhaust CPU resources by supplying malformed TEI corpus data containing many unmatched opening tags. Applications exposing NLTK's words() or tagged_words() public APIs over a network boundary-such as NLP services processing user-supplied corpora-are at risk of near-quadratic runtime growth in the read_block method. No public exploit code or CISA KEV listing has been identified at time of analysis; patch 3.10.3 is available.

Uncontrolled recursion in NLTK's FeatStructReader component (all versions before 3.10.3) enables unauthenticated remote attackers to crash any Python application that parses user-supplied feature structures or feature grammars. Attackers submit trivially crafted payloads containing deeply nested brackets, exhausting Python's call stack and raising an unhandled RecursionError that terminates the application process. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified at time of analysis; a vendor patch is available in NLTK 3.10.3.

Quadratic CPU exhaustion in NLTK before 3.10.3 allows denial of service via malformed XML corpus files processed by XMLCorpusView._read_xml_fragment(). The method rescans the entire accumulated XML buffer on every 1 KiB block read, creating O(n²) time complexity that scales severely with input size. Applications exposing XML corpus ingestion to untrusted input - such as those using BNCCorpusReader - are at realistic risk; no public exploit has been identified and this is not listed in CISA KEV.

Uncontrolled resource consumption in the jahlives openssl_encrypt PHP library (versions before 1.4.9) allows local attackers with write access to identity stores to crash the host by supplying an excessively large memory_cost parameter in a crafted identity file. The flaw manifests during Argon2 key derivation when the library unlocks identities prior to authentication, triggering an out-of-memory condition on the host. No public exploit code has been identified at time of analysis, and this vulnerability has not been added to the CISA KEV catalog.

The optional D-Bus crypto service in jahlives/openssl_encrypt 1.4.x before 1.4.9 exposes org.freedesktop.DBus.Properties.Set without polkit authorization or input validation, enabling any local system-bus user to persistently disable the root daemon. Setting MaxConcurrentOperations to zero or a negative value causes the concurrency gate to reject all subsequent cryptographic requests from the daemon; setting it to an arbitrarily large value or manipulating DefaultTimeout degrades stability in the opposite direction. No public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV.

CVE-2026-77117 is associated with Ubuntu based on a single vendor source tag, but no description, CVSS score, CWE, or supplementary intelligence is available to characterize the vulnerability. No meaningful impact, affected versions, or exploitation conditions can be determined from the provided data. This record should be treated as a placeholder until substantive NVD or vendor advisory data is available.

Integer overflow in FFmpeg's libavfilter/vf_scale.c video scaling filter allows a remote attacker to crash the FFmpeg process by delivering a crafted video file that a user then opens or processes. Affected is FFmpeg development build N-122528-gdd2976b9e1, a git-snapshot identifier rather than a stable release. No public exploit and no active exploitation are identified at time of analysis; EPSS sits at 0.15% (4th percentile), confirming low observed exploitation probability despite the ubiquitous deployment footprint of FFmpeg.

Division-by-zero in FFmpeg's libswscale library allows remote attackers to crash the process by supplying a crafted media file that triggers an unhandled zero-divisor during scaling context initialization. The fault occurs in ff_sws_init_single_context within /libswscale/utils.c when malformed input parameters produce a zero-valued denominator, resulting in a process crash and denial of service. No active exploitation has been confirmed, and EPSS at 0.15% (4th percentile) indicates negligible observed exploitation activity.

HTTP/1.1 request pipelining in Reactor Netty causes unbounded memory growth, exposing Spring WebFlux applications to availability degradation or denial of service from unauthenticated remote clients. Three release trains are affected - 1.0.x through 1.0.52, 1.1.0 through 1.2.18, and 1.3.0 through 1.3.6 - giving this issue broad coverage across current and legacy Spring reactive deployments. No public exploit code has been identified and this vulnerability is not listed in CISA KEV, though the low exploitation complexity warrants attention in deployments that expose Reactor Netty directly to the internet.

Spring AMQP's optional message decompression feature allows any principal with queue publish access to crash the consumer JVM by sending a single crafted ~1 MB compressed message. Affected versions span the 2.4.x, 3.2.x, 4.0.x, and 4.1.0 release lines, making this a broad supply-chain concern for Spring-based Java messaging infrastructure. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog, but the low attack complexity and high availability impact warrant prompt remediation in any environment where queue publish access is shared or externally reachable.