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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
TREK, a collaborative travel-planning web application, authorizes the DELETE /api/trips/:tripId/collab/notes/:noteId/files/:fileId endpoint against the caller-supplied tripId but then deletes the attachment resolved solely by noteId and fileId, so an authenticated user with edit rights on any single trip can permanently destroy note-file attachments belonging to other users' trips. Exploitation requires only a low-privileged authenticated account with edit access to at least one trip (CVSS:3.1/AV:N/AC:L/PR:L/UI:N, 7.1) and is made practical by sequential, enumerable identifiers, though impact is confined to integrity and availability of attachments - read paths remain trip-scoped, so no data disclosure is possible. All TREK deployments prior to 3.3.0 in a multi-user configuration are affected; no public exploit code has been identified and there is no evidence of active exploitation at time of analysis.
Cache lock takeover in the MongoDB integration for Laravel (mongodb/laravel-mongodb) before 5.11.0 lets an authenticated user who can influence the lock 'owner' value hijack or prematurely expire a lock held by another process, producing duplicated or conflicting operations. The root cause is a NoSQL/aggregation-expression injection (CWE-943) in the MongoLock implementation, where a dollar-prefixed owner string such as '$owner', '$literal' or '$$ROOT' is evaluated by MongoDB as an aggregation expression instead of being treated as a literal value. CVSS 7.1 (VI:H, VA:L, no confidentiality or scope impact) places this as a genuine but moderate integrity-focused flaw: it only affects deployments using the MongoDB cache-lock backend on pre-5.11.0 versions, exploitability depends on the application deriving lock owner values from user-influenced input (not the standard usage pattern), and no public exploit code has been identified at time of analysis.
Credential disclosure in PRTG Network Monitor before 26.2.120.1449 allows an authenticated user who is not restricted to read-only access to expose the configured Windows or domain password through sensor error output. The flaw is in a demo VBScript EXE/Script sensor that multiplies two integer parameters; when a non-numeric value is supplied, cscript.exe returns a Type mismatch error that echoes the supplied value, and the documented %windowspassword placeholder resolves to the stored credential. No public exploit identified at time of analysis; the vendor has released a patch in version 26.2.120.1449.
A double fput() in the Linux kernel's cachefiles_create_tmpfile() error-handling path drops the struct file reference count twice, producing a double-free/reference-underflow that is crash-dominant and can corrupt kernel memory or panic the host. Only systems that actually enable the fscache/cachefiles caching backend with cachefilesd running are exposed; the assessed vector is local-only (AV:L) with some existing privilege (PR:L) and high complexity (AC:H), because the attacker cannot reliably force the internal tmpfile-creation failure that triggers the flaw. Vendor patches are available for the stable branches (6.12.111, 6.18.53) and the 7.2 mainline fix; no public exploit code has been identified at time of analysis and the CVE is not in CISA KEV.
Uninitialized stack memory in the Linux kernel's cifs/SMB client can leave fields of the stack-allocated cifs_open_info_data structure holding stale values, so a client that mounts and operates on an SMB share whose server responses fail to populate those fields may act on incorrect metadata. Exploitation requires a local user with the ability to trigger the affected file operations on a mounted share (CVSS vector AV:L/AC:H/PR:L/UI:N, consistent with our independent assessment of C:L/I:L/A:N rather than the higher-scored 7.0 record) and is realistically driven by a malicious or misbehaving SMB server, not by remote unauthenticated attackers. Only kernels prior to 6.12.111, prior to 6.18.53, and prior to 7.2 are affected; vendor fixes are available and no public exploit has been identified at time of analysis.
The Linux kernel's iwlwifi PCIe transport driver can leave dangling RX pointers (rx_pool, global_table, rxq and alloc_page) on the live transport object after iwl_pcie_rx_free() runs while unwinding a failed iwl_pcie_tx_init(), so a subsequent teardown or driver re-init/retry can touch already-freed RX state. Only systems with Intel WiFi hardware running kernels before 6.12.111, 6.18.53 or 7.2 are affected, and the trigger is an internal nic-init failure path rather than a directly attacker-controlled input, meaning exploitation is local with high complexity and existing low privileges (AV:L/AC:H/PR:L per the assessed vector). There is no public exploit identified at time of analysis and no KEV confirmation of active exploitation, and while the vendor/NVD score is 7.0 (High), the independent assessment rates this at roughly 3.6 (Low) because only integrity and availability of the device's own error/cleanup path are at stake.
Missing project-level authorization in the Task Group APIs of Apache DolphinScheduler allows an authenticated user to read and modify Task Groups that belong to projects they do not have permission to access. Every release before 3.4.3 is affected; the vendor has fixed the flaw in 3.4.3. The issue requires a valid DolphinScheduler account (CVSS PR:L) reachable over the network, so it is chiefly meaningful in multi-tenant or multi-project deployments where project isolation is a security boundary - in single-tenant installs where all users already share project access, the practical impact is negligible. No public exploit code has been identified at time of analysis, and the independent assessment rates the confidentiality and integrity impact as low, making this a genuine but moderate-priority authorization flaw rather than a top-tier emergency.