An interrupt storm in the Linux kernel's stmmac Ethernet driver causes CPU starvation on systems using the XGMAC2 (DWMAC-XGMAC2) 10G MAC core, such as Intel Agilex5 SoCs. Because RBUE (RX Buffer Unavailable) was enabled in the default RX interrupt mask, a DMA RX descriptor ring that drains under heavy receive pressure fires the RBUE interrupt continuously-observed at roughly 1,821,811,555 MAC interrupts against only 2,618,627 actual RX completions on Agilex5, a ~695x amplification-locking the CPU into interrupt handling; the CVSS 3.1 vector is AV:N/PR:N (unauthenticated), and no public exploit has been identified at time of analysis. The flaw is highly constrained: it requires XGMAC2 silicon plus sustained high-rate RX traffic (or page_pool exhaustion), and independent assessment rates it AC:H rather than the NVD AC:L, since exploitation demands prolonged heavy traffic against specific hardware and results only in availability loss (CPU stall), with no data exposure or code execution.
Crafted MAT4 (MATLAB v4) files cause an integer overflow in libsndfile 1.2.2's mat4_read_header() parser, crashing the process and producing a denial of service. The flaw is network-reachable without authentication (CVSS 3.1 PR:N), but our assessment requires a victim to open the file or a backend service to ingest untrusted audio (UI:R); impact is limited to availability, with no code execution or data disclosure. No public exploit code and no vendor-released patch are confirmed at time of analysis.
Unauthenticated path traversal in the eesy_ID2WP - Publish InDesign HTML5 WordPress plugin lets any remote attacker read arbitrary files from the host server on any site running version 1.0.3 or earlier. The flaw is reached through the id2wp_path parameter and requires no authentication, no privileges, and no user interaction (CVSS 3.1 AV:N/AC:L/PR:N/UI:N, 7.5 HIGH), with impact limited to confidentiality because the attacker can only retrieve files the web server process itself is permitted to read. No public exploit code has been identified at time of analysis and there is no confirmed actively exploited (CISA KEV) status; the practical risk is opportunistic scanning of WordPress sites that have this niche plugin installed and active.
Door access control readers operated by Norwegian Cruise Line grant entry based solely on the static 7-byte UID of an NTAG212 NFC credential, so anyone who can read that UID can reproduce a working key to the ship's doors. Because the UID is a manufacturer serial number transmitted in the clear during every read and the NTAG212 has no challenge-response capability, the weakness is intrinsic to the access-control design and present by default rather than a toggled configuration, affecting every credential and reader pair deployed in this scheme. NVD rates the issue 7.5, but the supplied vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) is internally inconsistent with the physical nature of the attack; our independent assessment re-scores it as CVSS:3.1/AV:P/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, reflecting proximity-based exploitation with full integrity impact on door state. Exploitation requires close-range skimming of a victim's NTAG212 chip (typically a few centimetres) followed by physically presenting the cloned credential at a reader, and no public exploit code has been identified at time of analysis.
Unauthenticated network clients can retrieve the complete runtime configuration of an OpenObserve instance - including plaintext PostgreSQL connection strings (meta_postgres_dsn, meta_postgres_ro_dsn, meta_ddl_dsn) and usage_reporting_creds - simply by issuing a GET request to /config/runtime, which is registered without any authentication check. The flaw affects all OpenObserve releases prior to 0.90.3 and stems from a hide_sensitive_fields keyword filter that does not recognize the field names dsn or creds, so those values are serialized verbatim; deployments using a PostgreSQL metadata backend are most severely impacted because live database credentials are exposed, while all deployments leak the root administrator email, internal NATS address, and filesystem layout. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, base 7.5) confirms remote, unauthenticated, no-interaction exploitation against default configurations; no public exploit code or active exploitation was identified at time of analysis. Vendor-released patch: 0.90.3.
Authenticated administrators of PaperCut NG/MF can abuse the device-scripting feature's embedded execution engine to break out of its runtime sandbox and run arbitrary operating system commands with administrative privileges on the host. The weakness is a code-injection flaw (CWE-94) rooted in insufficient sanitization and access restrictions inside that scripting engine, and it is heavily gated: the attacker must already hold administrative access to the management interface (CVSS 4.0 PR:H), and the vendor vector's AT:P indicates a further attack precondition must be satisfied beyond mere admin credentials, so this is a high-technical-impact but low-urgency issue for most defenders rather than a broadly reachable one. No public exploit code has been identified at time of analysis and no active exploitation is confirmed by the available data (there is no CISA KEV entry among the supplied sources); prioritise patching environments where device scripting is enabled and administrative access is widely granted.
Credential exposure in geelen's mcp-remote 0.1.18 through 0.1.38 allows a remote attacker to capture OAuth/authorization tokens by abusing the SSE transport's eventSourceInit fetch wrapper in src/lib/utils.ts, which attaches credentials without correctly scoping them to the intended server origin. Only deployments actually using the SSE transport path are affected; the streamable-HTTP and stdio paths do not exhibit this behavior, and exploitation further requires the attacker to control or observe the out-of-scope origin that receives the leaked token. Impact is limited to confidentiality of the forwarded token (no integrity or availability effect), there is no public exploit identified at time of analysis, and EPSS is low at 0.25% (14th percentile), indicating a moderate credential-exposure issue rather than a mass-exploitation emergency.
Use-after-free in the Linux kernel's HID++ (hidpp) driver leaves a stale pointer in hidpp->input when input_register_device() fails during hidpp_connect_event(), allowing a dangling reference to be used after input_free_device() has released it. Systems running affected kernels (anything prior to the fixed backports 6.12.111, 6.18.53, and 7.2) with a supported Logitech HID++ peripheral attached - such as a Unifying receiver, mouse, keyboard, or touchpad - are exposed to the code path, but the trigger is a registration-error path that is not attacker-controlled and rarely executes, so realistic impact is a local kernel crash or denial-of-service rather than confidentiality or integrity compromise. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation; vendor-released patches are available from kernel.org stable branches.
Improper Thunderbolt domain-teardown handling in the Linux kernel leaves the root-switch pointer (tb->root_switch) referencing a stopped domain, so a Thunderbolt/USB4 peer on the same fabric can race the teardown with an in-flight XDP cross-domain request (tb_xdp_handle_request) and drive the driver into stale-pointer/use-after-free territory that destabilizes or crashes the host. The fix mirrors the firmware connection manager by clearing tb->root_switch when the domain is stopped while deliberately keeping the uuid alive long enough to reply before the domain is fully released. Affected are Thunderbolt-capable Linux systems running unpatched kernels; the scenario is constrained to a physically adjacent attacker with a live Thunderbolt/USB4 link and a timing-dependent window, no public exploit code is identified at time of analysis, and the independent assessment (AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H) rates impact as availability-skewed rather than the 7.5 CVSS vector's C:H/I:H/A:H.
Type confusion in the Perl DBI module's fetchrow_hashref implementation allows an application that assigns a non-string scalar (integer/IV or float/NV) to the FetchHashKeyName attribute and then calls fetchrow_hashref to trigger an out-of-bounds memory read, typically crashing the Perl process (denial of service) and, in principle, exposing adjacent heap memory in error output. Affected are DBI releases before 1.654 on any platform where the module is installed; the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) rates this unauthenticated and remotely triggerable, though independent assessment raises attack complexity to AC:H because exploitation requires the hosting application to propagate attacker-controlled data into a statement-handle attribute that is normally set by the application itself. No public exploit code has been identified at time of analysis, no confirmed active exploitation (not in CISA KEV), and EPSS is low at 0.21% (10th percentile), reflecting the narrow precondition of application-specific attribute misuse.
Unauthenticated remote denial of service in Apache Qpid Broker-J through 10.1.0, where a crafted AMQP 0-8/0-9/0-9-1 field table with deeply nested types drives unbounded recursion in the broker's parser and triggers a StackOverflowError that can crash the broker. The flaw is reachable pre-authentication over the network with no credentials or user interaction (assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, High), affecting any broker exposing the legacy AMQP 0-8/0-9/0-9-1 protocol plugin, including its default configuration. No public exploit code or confirmed active exploitation was identified at time of analysis; impact is limited to availability, with no data disclosure, integrity loss, or code execution.
Pre-authentication denial of service in Apache Qpid Broker-J through 10.1.0: a remote attacker who can reach a broker with the AMQP 0-10 protocol plugin enabled can send frames whose type size and count fields are not properly bounded, driving the decoder into excessive memory allocation and potentially exhausting broker resources. The affected code path is reached before authentication (assessed vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so no credentials or user interaction are required; impact is limited to availability, with no confidentiality or integrity effect. There is no public exploit code identified at time of analysis and no confirmed active exploitation (not in CISA KEV); a vendor-released fix exists in version 10.1.1.
Pre-authentication denial of service in Apache Qpid Broker-J (through 10.1.0) allows a remote attacker to exhaust broker memory or crash it by sending a malformed AMQP 0-8/0-9/0-9-1 frame whose type size/count fields drive an oversized allocation; the decoder handles this frame before authentication is performed, so the assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (availability-only impact, no data disclosure or code execution). Exploitation only requires network reachability to an enabled legacy AMQP 0-8/0-9/0-9-1 listener, so deployments that exclusively use AMQP 1.0 are not on the affected code path, and firewalling the AMQP port to trusted clients removes exposure. There is no public exploit code identified at time of analysis and no confirmed active exploitation (CISA KEV).
A stack-based buffer overflow in Espruino 2v29 (commit bffc6d0) lets an unauthenticated remote attacker crash the JavaScript interpreter by supplying script input that raises an exception and drives execution into the error stack-trace formatting path, where jslPrintTokenLineMarker() passes the address of a 4-byte int column variable to jsvGetLineAndCol(), which performs an 8-byte write through that mismatched pointer on 64-bit builds. The overwrite is small and the written value is not attacker-controlled, so the realistic outcome is a denial-of-service crash rather than code execution (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, availability impact only), and the flaw is specific to 64-bit builds - the ordinary 32-bit microcontroller firmware is not indicated as affected. Risk signals are currently low: EPSS is 0.17% (6th percentile), there is no CISA KEV entry, and no public exploit code has been identified at time of analysis, although genuine remote exploitation requires the interpreter to be reachable by untrusted input, since typical embedded deployments load JavaScript over USB, serial or Bluetooth from the developer.
Parsing a malformed PDF in SumatraPDF 3.6.1 can crash the reader through a signed integer overflow in the PageLabels handling code, producing a local denial-of-service condition. The bug is reached only when a user opens an attacker-crafted document whose /Nums array supplies an /St (start-at) value near INT_MAX, which overflows in EngineMupdf::BuildPageLabelRec(); an independent assessment scores this as AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H (base 7.5 as published, but the network/no-interaction vector is inconsistent with a desktop file-parsing flaw that needs user interaction). There is no confirmed code execution, confidentiality or integrity impact, no public exploit code identified at time of analysis, no CISA KEV listing, and EPSS is only 0.17% (5th percentile), so exploit likelihood is low.
Stored HTML injection in The Post Grid WordPress plugin before version 7.9.5 lets authenticated users with at least the Contributor role persist iframe, style and input elements that WordPress normally strips, because the plugin widens the site-wide allowed-HTML (kses) list instead of limiting the expansion to its own shortcodes. The saved markup renders for every visitor to the affected post and for administrators previewing it, enabling phishing frames, CSS defacement and spoofed input forms, though it stops short of script execution. Publicly available exploit code exists (reported via WPScan), but there is no confirmed active exploitation according to the CISA SSVC record (exploitation: none), and this is a low-to-moderate severity issue rather than a critical priority.
Denial of service in Apache Qpid Broker-J through 10.1.0 allows an authenticated AMQP 1.0 message producer to disrupt message delivery to AMQP 0-10 consumers by publishing messages carrying properties that the AMQP 1.0-to-0-10 conversion encoder cannot encode. The impact is limited to brokers actually bridging the two protocol generations - an AMQP 1.0 producer path feeding AMQP 0-10 consumers must be in use for the flaw to be reachable - and no public exploit code or confirmed active exploitation has been identified at time of analysis. EPSS is 0.16% (4th percentile), consistent with a genuine but moderate availability issue; the vendor has released Qpid Broker-J 10.1.1 as the fix.
Denial of service in NanoSVG at commit 239e102ec affects applications that parse attacker-supplied SVG documents, where a crafted arc command with extreme radius values drives the arc delta-angle calculation to NaN and the subsequent unchecked NaN-to-int conversion causes undefined behavior and process termination. The published CVSS vector is 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so the unauthenticated network attack path is constrained by the requirement that the target actually process a malicious SVG, and manual SVG opening can effectively require user interaction; EPSS is 0.16% and no public exploit identified at time of analysis.
Incorrect buffer size arithmetic in tinyexpr's new_expr() causes an undersized heap allocation for every arity-0 expression node (constants, variables, and zero-argument functions), which the parser then uses as a complete te_expr object. Because tinyexpr is a parsing library with no network surface of its own, exploitation requires a host application that feeds attacker-influenced expression strings to te_compile(), and the visible failure (deterministic process termination) is primarily observed in UBSan-instrumented development or CI builds rather than standard production builds. The binary-unauthenticated CVSS 3.1 score of 7.5 reflects a worst-case A:H impact, but our assessment downgrades availability to Low (AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:L) because plain release builds exhibit undefined behavior without a guaranteed crash; EPSS is 0.15% (4th percentile), there is no CISA KEV entry, and no public exploit code was identified at time of analysis. An upstream fix commit is available.
Denial of service in the MuJS embeddable JavaScript interpreter (git revision e892c9fdb) allows remote attackers to crash the hosting process by supplying JavaScript that builds an excessively large numeric array index, which jsR_isindex() in jsrun.c converts from floating point to integer without validating the value fits in the target integer range. Per the assessed CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I/A:H), the attack is network-reachable and unauthenticated, but the impact is availability-only: no confidentiality or integrity loss, with exploitability gated by whether the embedding application evaluates untrusted JavaScript. Exploitation requires the host to feed attacker-controlled script to the embedded interpreter (for example, opening a document or file that MuJS parses), and no public exploit code or CISA KEV entry was identified at time of analysis; EPSS is 0.15% (4th percentile), indicating low near-term exploitation likelihood. The upstream project has published a fix commit, but no tagged patched release has been independently confirmed.
Pushing a zero-length NAL unit into libde265's de265_push_NAL() API leaves a NAL_unit with a NULL backing buffer that is then handed to memcpy() as the destination in NAL_unit::set_data(); although the copy length is zero, the call violates memcpy()'s nonnull contract and, in UBSan-instrumented or hardened builds, terminates the process, while standard production builds typically survive the call but abort decoding of the affected stream. The issue affects libde265 through the vulnerable snapshot 4d45a6b and any downstream consumer that decodes untrusted HEVC/H.265 data, including software using libheif for HEIF/HEIC handling; it is remotely reachable and unauthenticated (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L), though a victim must actually decode the malicious media. Exploitation status is low-risk: there is no CISA KEV listing and no public exploit identified at time of analysis, EPSS is only 0.15% (4th percentile), and this analyst assessment rates the availability impact as Low rather than the High implied by the published 7.5 score, so the 7.5 overstates real-world impact for typical deployments.
Denial of service in libvips 8.19.0 occurs when a service decodes an attacker-supplied little-endian PFM (Portable FloatMap) image whose text header length is not a multiple of four bytes, leaving the mmap-backed pixel buffer misaligned for float access; vips_avg_scan() then dereferences that buffer as a float pointer, producing undefined behavior that terminates the process on strict-alignment targets or UBSan-instrumented builds. The issue is remote and unauthenticated (CVSS:3.1/AV:N/AC:H/PR:N/UI:N), but real-world impact is narrow: the victim must actually route untrusted PFM input into libvips 8.19.0, and the misaligned float access is harmless on x86/x86_64 and other alignment-tolerant builds, so the assessed attack complexity is high and the practical consequence is availability-only. No public exploit code was identified at time of analysis, EPSS is low at 0.14% (3rd percentile), and there is no CISA KEV listing; the underlying issue is tracked upstream as libvips GitHub issue 5187.
An integer overflow in the BSON encoder of the MongoDB Python Driver's bundled native C extension (PyMongo before 4.18.2) can cause an out-of-bounds write inside the process hosting the driver when an application encodes a single document built from an unusually large (~2 GB) caller-supplied value. Only builds that link the C extension are affected - the pure-Python BSON fallback is not - and successfully triggering it requires that a large attacker-influenced value actually reach the encoding path, so most applications are exposed only through data they already accept from untrusted sources. The flaw is not confirmed as actively exploited (CISA KEV) and no public exploit code has been identified at time of analysis; the vendor has released 4.18.2 as the fixed version, and because impact is confined to the hosting application's own process, risk is best treated as a genuine but precondition-heavy memory-corruption issue.
Local privilege escalation in Evope Collector (all versions before 1.1.7.13) lets an attacker who already has a local foothold with write access to C:\ProgramData\Evope\ plant a file named wtsapi32.dll that Evope.Service.exe, running as NT AUTHORITY\SYSTEM, loads without validating its origin, resulting in arbitrary code execution with SYSTEM privileges. The weakness is an uncontrolled search path element in the service's DLL loading, so exploitation requires no victim interaction, though the service must start or restart before the planted library is loaded (captured as AT:P in the 7.5 CVSS 4.0 vector). No public exploit code or CISA KEV entry was identified at time of analysis, and the vendor has published a fixed version, 1.1.7.13.
Server-side request forgery during OAuth authorization-server metadata discovery in geelen mcp-remote 0.1.32 through 0.1.38 allows a remote attacker to obtain sensitive information from the environment where the client runs. The client trusts an attacker-supplied authorization-server metadata/endpoint URL handled in src/lib/authorization-server-metadata.ts and src/lib/utils.ts without adequate validation, so a victim who connects mcp-remote to an attacker-controlled or attacker-influenced remote MCP server triggers requests to internal targets and discloses the responses. The NVD vector scores it 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) while the independent assessment scores UI:R because the victim must initiate the connection to the malicious server; impact is confidentiality-only, with no integrity or availability effect, and no public exploit identified at time of analysis.
Denial of service in NanoSVG (commit 239e102ec) where a crafted SVG document carrying oversized geometry coordinates drives the rasterizer's fixed-point-scaled edge values past the range of a 32-bit int during nsvg__addActive(), producing undefined behavior that can terminate the process. The issue is rated CVSS 3.1 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), i.e. unauthenticated and low-complexity, but availability-only: there is no code execution, data disclosure, or integrity impact per the assessed vector. Exploitation requires the embedding application to actually rasterize attacker-supplied SVG content rather than merely parse it, so tools that only handle locally trusted assets face a local-input scenario; no public exploit code was identified at time of analysis and the flaw is not confirmed actively exploited (not in CISA KEV), though the vendor issue tracker reference (GitHub issue 292) makes root-cause details publicly discoverable.
Parsing a specially crafted MP4 file with Bento4 1.6.0.0 can terminate the process: an avcC or hvcC atom that declares a size smaller than the atom header causes an integer underflow in AP4_AvccAtom::Create() and AP4_HvccAtom::Create(), wrapping the computed payload length to an enormous unsigned value that drives an invalid buffer allocation and copy. Reachability depends entirely on deployment - a service that automatically ingests untrusted MP4 uploads is remotely reachable, whereas CLI or manual usage requires an operator to open or process the file (user interaction), which is why our assessment scores this AV:L/PR:N/UI:R rather than the upstream AV:N/UI:N 7.5. Impact is limited to availability of the parsing process; there is no confidentiality or integrity effect and no code execution, and no public exploit identified at time of analysis.
Crafted DNS traffic parsed by the nDPI 5.1.0 deep-packet-inspection library can terminate the hosting process wherever that code runs on a strict-alignment CPU (ARM, MIPS, SPARC and similar) or in an UndefinedBehaviorSanitizer/fuzzing build, because the DNS dissector and the serializer deserialization path dereference byte buffers at arbitrary packet offsets through uint16_t/uint32_t/uint64_t pointers without any alignment check. The flaw is remotely reachable and unauthenticated (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5), but impact is limited to availability - process termination, no confidentiality or integrity loss - and the decisive precondition is the build/CPU target: mainstream x86-64 release builds silently tolerate the misaligned load and generally will not crash. It is not listed in CISA KEV and no public exploit identified at time of analysis, although the upstream fix PR does ship fuzz corpus inputs (issue3213_trigger1-3) that reproduce the fault, and EPSS data was not available for this record.
Denial of service in hiredis post-v1.5.0 (commit 29ea279) occurs when the RESP aggregate parser performs an uncontrolled memory allocation based on an oversized element or length count supplied in a Redis server reply. A hiredis-based client that connects to a malicious or compromised Redis server, or whose unencrypted connection is subject to man-in-the-middle redirection, can be driven into memory exhaustion and crash or unresponsiveness; no authentication on the hiredis side and no user interaction are required. The provided data does not include a CISA KEV entry, and no public exploit identified at time of analysis, so exploitation should be assessed as requiring an attacker-controlled or untrusted Redis endpoint rather than as confirmed active exploitation.
Malicious or compromised X servers can crash X clients linked against libXi before 1.8.4 by returning malformed XI2 device-class data that the library's XI2 class parser reads out of bounds, producing an availability-only denial of service against the connected client. The attack needs no authentication on the server side (CVSS AV:N/PR:N) but is gated by user interaction (UI:R), because the victim must establish an X protocol connection to the attacker-controlled server; there is no memory disclosure back to the attacker, no integrity impact, and no code execution. A vendor fix is available (upstream merge request 23, commit e2089ab, with the affected range documented as libXi before 1.8.4), and no public exploit code was identified at time of analysis. Practically, the risk is lower than the 7.4 base score suggests, since the only outcome is a client-side crash.
Authenticated PaperCut NG and PaperCut MF administrators can achieve arbitrary command execution on the underlying host through the Scan-to-Fax component by supplying crafted fax provider settings that contain path-traversal sequences. Exploitation requires a high-privilege admin account (CVSS PR:H) and network reachability to the admin console, and publicly available exploit code exists per the CVSS 4.0 E:P metric; there is no confirmed active exploitation (CISA KEV). The practical risk is concentrated on internet-exposed or compromised admin interfaces rather than opportunistic mass exploitation, making this a serious post-authentication issue rather than a drop-everything emergency.
The Linux kernel's fsl-imx8mq-usb PHY driver leaks the Type-C (TCA) switch reference when probe fails after imx95_usb_phy_get_tca() has already succeeded, because the only release path lived in the driver's .remove() callback, which does not execute on probe failure. Only systems running NXP i.MX8MQ/i.MX95 hardware with the Type-C switch path active are affected, and triggering the bug requires high local privileges to force repeated probe failures; a single probe failure produces only a one-time leak of limited availability impact, and no public exploit has been identified at time of analysis (no KEV confirmation). The headline CVSS 7.4 with PR:N and full C/I/A:H is inflated relative to the assessed CVSS:3.1/AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:N/A:L, which reflects a privileged, hardware-dependent, low-impact resource leak rather than a remotely exploitable compromise.
Use-after-free in the Linux kernel's powerpc/xive interrupt-controller code can crash or corrupt memory on PowerPC systems (POWER9/POWER10-class) that use the XIVE interrupt controller for SMP CPU bring-up, when the global xive_ipis array is freed after a failed xive_init_ipis() call and then dereferenced by xive_setup_cpu_ipi(). Only PowerPC hardware running the affected kernel is exposed; x86, ARM and other architectures are unaffected, and per the authoritative assessment the trigger is a kernel initialization failure (irq_domain_alloc_irqs() failing) reached at boot/probe time with local access and low privileges (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:H), so despite the higher vendor base score of 7.4 the realistic risk is low and exploitation is effectively confined to denial of service/crash under resource-starvation conditions. No public exploit code exists and there is no confirmed active exploitation (not listed in CISA KEV); the flaw is addressed in the upstream stable commits c554a8d376d5aea1b237ed6bef6f9fbfc550e67f and 411a3c016e7a95f5fa105a0587e07d0647a77727, which correspond to the Linux 7.2.6 stable release and the 7.3-rc1 merge window fix.
Kernel panic and denial of service in the Intel iwlwifi 'mld' (multi-link device) driver stem from a use-after-free on the firmware-error recovery path. Hosts are affected only when the MLD driver is loaded and two connections are active at once - an infrastructure BSS link plus a NAN (neighbor awareness networking) link - and a firmware error forces a reconfig that restores the BSS link but fails to restore the NAN link; mac80211 then frees the BSS link's data while a queued async statistics notification still holds a dangling fw_id_to_bss_conf[] pointer, so the workqueue handler dereferences freed memory and panics the kernel. Local access to the machine is required, the race between async_handlers_wk and the reconfig work makes deliberate triggering complex, and no public exploit identified at time of analysis, with no confirmed actively exploited (CISA KEV) status; vendor patches are available in Linux 6.18.53 and 7.2.
Authentication bypass in authentik's SAML Source lets an unauthenticated attacker who holds any validly-signed, unexpired SAML assertion from a trusted identity provider log in as the user named in that assertion, because releases before 2026.2.7, 2026.5.7, and 2026.8.2 never verify that the assertion was issued for that Source (no audience, Destination, or SubjectConfirmationData Recipient binding) and never record assertions already accepted, permitting replay. Attackers must therefore obtain an assertion minted for a different service provider or reuse a previously captured assertion; no authentik-side credentials or user interaction are required (PR:N/UI:N), which is why the issue scores 7.4 despite the High attack complexity driven by that prerequisite. Only SAML Sources are affected - SAML Providers and other Source types are explicitly not - and no public exploit code was identified at time of analysis, with no CISA KEV listing.
Authentication bypass in TÜBİTAK ULAKBİM's UlakPDF allows remote unauthenticated attackers to reach functionality or data that should be protected by authorization checks, affecting builds through 09092026. The CVSS vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N, 7.4) indicates exploitation needs no credentials and no user interaction, but the High attack complexity means a non-trivial precondition - such as a specific request/parameter combination, a valid resource identifier, or a particular application state that causes the authorization decision to be evaluated incorrectly (CWE-863) - must be satisfied, which reduces reliability. Risk assessment: this is a genuinely notable authorization flaw but not a top-tier emergency; no confirmed actively exploited (CISA KEV) status and no public exploit identified at time of analysis, and the product's limited real-world footprint narrows targeting opportunity.
An out-of-bounds read in the dump() function of the jsmn JSON tokenizer's demo utility example/jsondump.c (commit 25647e6) allows an attacker who supplies crafted or malformed JSON to the program to disclose small amounts of adjacent process memory and to crash the utility, giving a confidentiality and availability impact rated Low. Only users who build and run the shipped example - or who copied that demo code into a tool or pipeline that parses untrusted JSON - are affected; consumers of the core jsmn.h library who do not use the example are not exposed. The 7.3 base score is not matched by real-world signals: EPSS is 0.15 percent (4th percentile), there is no CISA KEV entry, and no public exploit was identified at time of analysis, and the assessed vector is local with required user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:L), so this is a low practical priority rather than a remotely exploitable high-severity issue.
Code injection in MongoDB Compass lets an attacker who holds database-creation privileges on a MongoDB server interpolate unescaped shell syntax into the initial input of Compass's embedded MongoDB shell; when a victim user navigates to that database's view and explicitly opens the shell from it, the injected content is evaluated inside the Compass client process with that process's privileges. Exploitation is constrained: the attacker must be able to create databases on the connected server and name one maliciously, and the victim must perform the specific action of opening the shell for exactly that database, which is why the issue carries High attack complexity despite the 7.3 severity. Execution is confined to the Compass client process and does not reach the MongoDB server; Compass v1.49.12 is the fixed release, and no public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.
Stored cross-site scripting in the Capture Validation application of OpenText Vendor Invoice Management for SAP Solutions allows a high-privileged authenticated user to persist malicious script content that later executes in another user's browser when the affected view is opened, potentially exposing or altering invoice data processed by the application. The vendor rates the issue 7.3, while our independent assessment places it at moderate severity (CVSS 3.1 AV:N/AC:L/PR:H/UI:R/S:C/C:L/I:L/A:N) because exploitation requires privileged access to plant the payload, victim interaction to trigger it, and an additional unspecified application condition per the vendor's 'under certain conditions' qualifier. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV.
An authenticated Discourse user who can post content can bypass the administrator's `allowed_iframes` subpath restriction and embed iframe content from a path the administrator never authorized, affecting all Discourse releases prior to 2026.1.8, 2026.6.3, 2026.7.2, and 2026.8.0. The allowlist guard did not treat literal backslashes as path separators after decoding percent-encoded dot segments, so a crafted iframe source passed the subpath check while browser URL normalization resolved the frame outside the permitted path; exploitation requires a victim to view the post and depends on the viewer browser's backslash normalization behavior, consistent with the assessed vector AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N (limited confidentiality and integrity impact, no availability impact, scope change). This is a moderate, non-priority finding - no public exploit identified at time of analysis.
Arbitrary local file and directory deletion on Docmost deployments that use local storage, exploitable by any authenticated low-privileged user. An attacker stores a crafted avatarUrl value that is not confined to the intended avatar directory; when Docmost's avatar cleanup routine later consumes that stored value, it deletes files or directories reachable by the Docmost service account. The issue affects Docmost versions prior to 0.80.1 and is rated CVSS 7.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L) - high integrity impact, low availability impact, no confidentiality loss. There is no public exploit code identified at time of analysis, and exploitation requires a valid account, so risk is concentrated in multi-tenant or shared instances running local storage.
Authenticated path traversal in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows a remote user holding valid low-privileged credentials to reach files outside the directory the application intends to restrict, producing a high integrity impact (I:H) and a limited availability impact (A:L) while the published vector shows no direct confidentiality loss. Exploitation is remote (AV:N) but rated high complexity (AC:H), meaning success depends on target-specific conditions such as exact file paths or platform state, and it requires a valid account (PR:L) with no user interaction (UI:N). No public exploit code or CISA KEV entry was identified at time of analysis, so this is a real but moderate-priority flaw for unpatched 5.4.0.0 deployments; IBM has published a fix through its support advisory.
Botslab G980H dash camera firmware writes sensitive configuration data - including WiFi credentials - into diagnostic logs created during the vendor support process, and those logs persist on the removable storage media (microSD card) after the support session ends. An unauthenticated attacker who physically obtains the card can simply read the log files and recover the device's WiFi credentials and other configuration details; per the CVSS 4.0 vector AV:P/PR:N/UI:N this requires physical possession of the media, and there is no network-reachable path to the data. The issue is a confidentiality-only disclosure (CWE-532) with no public exploit identified at time of analysis, and our independent assessment rates it a genuinely low-priority problem whose 5.1 score is driven almost entirely by the physical attack vector rather than any remote reachability.
An out-of-bounds read exists in the Linux kernel's ntfs3 driver: the readdir path in ntfs_dir_emit() compares a UTF-16LE character count (fname->name_len) against a byte count (e->size) without accounting for the 2-byte encoding or the ATTR_FILE_NAME header, so a crafted NTFS image with a small declared entry size but a large name length slips past the bounds check and lets ntfs_utf16_to_nls() read beyond the index entry. Exploitation is local and requires the victim to mount and list a directory on the attacker-supplied filesystem, typically via removable media or a disk image opened by an auto-mount daemon, and mounting normally requires CAP_SYS_ADMIN or equivalent auto-mount privileges, with user interaction needed to insert the media or open the image. The impact is information disclosure (kernel memory contents adjacent to the entry) plus a denial-of-service crash; no public exploit code or active exploitation was identified at time of analysis, and no EPSS score was supplied, though patch code is already public in the upstream stable trees.
Mounting a crafted NTFS volume on a system running the Linux kernel's ntfs3 driver can drive a slab out-of-bounds read: a malformed directory index entry declares a key_size larger than the bytes actually present in its NTFS_DE payload, and the subsequent directory lookup passes that key to cmp_fnames(), which reads past the end of the kmalloc'ed index buffer. The flaw is local (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H, 7.1) and requires the victim to mount and access the malicious image, typically via removable media, a supplied disk image, or a desktop automount path; the practical consequence is most often a kernel crash or denial of service rather than reliable disclosure of meaningful data, so real-world risk is lower than the headline score implies. No public exploit code or confirmed active exploitation was identified at time of analysis, and vendor-released fixes exist in Linux 6.18.53, 6.12.111, and 7.2.
Malformed f2fs filesystem images can make the Linux kernel read past the end of its inline filename storage while converting an inline directory into a regular dentry block, disclosing kernel memory contents and potentially crashing the system. The attack path is local and requires user interaction: a victim must mount an attacker-supplied corrupted image (for example via USB auto-mount, a container, or a VM) and then access the affected directory so that the inline-to-regular dentry conversion runs; only f2fs filesystems using inline dentries are affected. No public exploit code and no confirmed active exploitation (not in CISA KEV) were identified at time of analysis, and the risk is concentrated in environments that routinely mount untrusted removable media or filesystem images.
A missing read memory barrier in the Linux kernel's in-kernel NFS server (nfsd) netlink status-dump path lets a low-privileged local user (CVSS PR:L) on weakly-ordered CPUs such as ARM or POWER read RPC status fields that have been concurrently modified by nfsd_dispatch, because the hand-rolled seqcount retry in nfsd_nl_rpc_status_get_dumpit() never orders its field reads ahead of the second counter check. The result is information disclosure of inconsistent or torn status data (CVSS C:H/I:N/A:H per the supplied vector), not memory corruption or code execution, and the reordering does not manifest on strongly-ordered x86/x86_64 hardware, which eliminates practical exploitability there. No public exploit code has been identified at time of analysis and there is no KEV confirmation of active exploitation, though our independent assessment scores the issue lower (AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:L) than the supplied 7.1 base score because of the architecture restriction, the local-only vector, and the narrow timing race required against live NFS traffic.
Local low-privileged users on systems with AMD GFXv9-class GPUs can leak adjacent kernel memory through the amdkfd get_wave_state() path in the Linux kernel, because attacker-supplied queue descriptor fields are used unchecked as the length and offset of a copy_to_user(). The bug is reachable only via the AMD KFD device node (/dev/kfd) together with the AMDKFD_IOC_RESTORE_PROCESS (CRIU restore, H3) ioctl, giving an attacker roughly 4 GiB of over-read when the offset exceeds the size (integer underflow) or a 1 MiB read against a 4 KiB allocation that exposes neighbouring MQDs, ring buffers and KASLR-relevant kernel pointers. Vendor-released fixes are available in Linux 6.12.111 and 6.18.53 (and in the 7.2 line), but at the time of analysis there is confirmed no CISA KEV listing and no public exploit code identified, so this should be treated as a real but local-only information-disclosure risk rather than an actively exploited flaw; systems without an AMD GPU or without the KFD driver loaded are not exposed.
An iterator-handling defect in the Linux kernel's GFS2 clustered filesystem quota initialization routine (gfs2_quota_init) can be reached when a GFS2 filesystem is mounted, leading to a potential crash or memory-safety consequence rather than remote compromise. Only systems that build and actually mount GFS2 volumes are exposed, which is uncommon outside high-availability cluster deployments. NVD assigns a 7.1 base score under the AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:H vector, but our independent assessment scores this lower (CVSS:3.1/AV:L/AC:H/PR:L/UI:R/S:U/C:N/I:L/A:H) because the upstream commit is a readability refactor and no concrete triggerable impact beyond a possible crash is established by the available data; there is no public exploit identified at time of analysis and the issue is not confirmed actively exploited (not in CISA KEV).
Incorrectly assigned permissions on critical resources shipped with Dell Trusted Device Client (all versions prior to 8.1.359.0) let a low-privileged local user write to or modify files, directories, registry keys, or service configuration belonging to the agent, enabling tampering with trusted-device state and, per the vendor vector, disclosure of sensitive data (CVSS 3.1 base 7.1, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N). Exploitation is strictly local: it requires an existing interactive or session-level account on the Windows endpoint and the underlying CWE-732 misconfiguration; there is no remote or unauthenticated vector, and no code execution or availability impact is claimed. Our independent assessment narrows the confidentiality component to Low (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:H/A:N) and stresses that the realistic outcome is tampering with client data and configuration rather than host compromise. No confirmed active exploitation (CISA KEV) and no public exploit code were identified at time of analysis; the vendor advisory is the only reference.