Out-of-bounds reads in the Linux kernel's btintel Bluetooth driver can expose kernel memory or crash a host when an undersized version TLV value is parsed. The issue affects systems with an Intel Bluetooth controller and a pre-fix kernel; the assessed CVSS vector is local, low-privilege, no user interaction, with high confidentiality and availability impact but no integrity impact. Vendor fixes are identified, no public exploit was identified at time of analysis, and EPSS is 0.17% (5th percentile).
Out-of-bounds read (CWE-125) in the Linux kernel's btintel Intel Bluetooth driver occurs when a firmware-ID TLV value is not NUL-terminated: the code treats the value as a string and lets snprintf() read past the advertised TLV value length, which is the only boundary it enforces. Systems running the btintel driver with Intel Bluetooth adapters and processing such a malformed response during firmware/TLV parsing are affected; the assessed vector is local, low-privileged (PR:L), no user interaction, with high confidentiality and high availability impact. EPSS is low at 0.17% (5th percentile), no public exploit has been identified at time of analysis, and vendor fixes are listed as 6.18.53, 6.12.111, 7.2.7 and 7.3-rc2, with a vuln.today priority decision of this_week.
Out-of-bounds read in the Linux kernel's accel/qaic driver can expose kernel memory or cause a denial of service when resp_worker() processes a malformed wire response from a Qualcomm Cloud AI 100 (QAIC) device. Affected systems run vulnerable Linux kernel branches with the QAIC driver loaded and an attached QAIC accelerator; a local attacker with low privileges (CVSS PR:L) who can control or compromise the device/firmware can trigger the missing-bounds-check path. No public exploit has been identified at time of analysis (EPSS 0.16%, 4th percentile), and real-world risk is low-to-moderate because the hardware and device-control prerequisites are substantial.
Local attackers able to execute code on a Linux host that has an active netfs/fscache-backed filesystem mount (e.g. AFS, Ceph, CIFS/SMB, 9p) can race the netfs readahead folio handling, where the application thread appends folios to the rolling buffer while the collector thread inspects or clears them - for instance reading front_folio_order before the next folio has been added, or unlocking folios before the xarray has been scanned. The kernel fixes the race by loading all readahead folios into the queue upfront and deferring the bulk reference drop until the first subrequest is dispatched, with the collector waiting on NETFS_RREQ_NEED_PUT_RA_REFS. Vendor scoring is CVSS 7.1 (AV:L/AC:L/PR:L/UI:N/C:H/I:N/A:H), while our assessment raises attack complexity to High because a narrow timing window must be won on a host with a netfs mount in use; EPSS is 0.16% (4th percentile), there is no CISA KEV listing, and no public exploit identified at time of analysis. Vendor-released patches are available in Linux 7.2.7 and 7.3-rc3 (plus the listed stable commits).
Signature-verification bypass in MinIO (all releases through commit 7aac2a2) and in the pgsty/silo fork (before commit 1233254) lets an attacker who holds a valid SigV4 presigned PUT URL - one scoped to a single object - append an unsigned x-amz-copy-source header to the otherwise unmodified URL and cause a server-side CopyObject executed with the signer's credentials, converting a write grant into reads of every object that signing key can reach. The root cause is a CWE-347 improper-verification-of-signature error: extractSignedHeaders() in cmd/signature-v4-utils.go iterates only the client-claimed X-Amz-SignedHeaders list and never enumerates the x-amz-* headers that actually arrived, so an unsigned header is neither hashed into the canonical request nor rejected, while cmd/api-router.go dispatches CopyObject purely on the presence of x-amz-copy-source. Amazon S3 rejects the equivalent request with HTTP 403 AccessDenied; exploitation here requires a delegated presigned URL plus a signing key with broader read permission, making this a privilege escalation from a delegated credential rather than unauthenticated access, with no public exploit code or confirmed active exploitation identified at time of analysis.
Out-of-bounds read in the Linux kernel NTFS driver allows a local attacker who can mount a crafted NTFS volume to read past a heap allocation while the in-memory $AttrDef table is walked, producing a kernel crash (denial of service) and potential disclosure of adjacent kernel memory. Only systems that mount attacker-controlled NTFS images are affected - the kernel must have the NTFS driver enabled and the attacker needs either local mount capability (CAP_SYS_ADMIN) or an automount service that mounts untrusted removable media; authentication requirements are low privileges per the CVSS vector (AV:L/PR:L). No public exploit code has been identified at time of analysis and EPSS is negligible (0.14%, 3rd percentile), though a vendor patch is available and carries a moderate 7.1 severity score.
S/MIME signature spoofing in Zammad before 7.1.2 lets a remote, unauthenticated sender forge email that Zammad displays with the same 'validly signed' indicator as a genuine message, by presenting a self-made certificate whose subject name matches a certificate already stored for a real, previously trusted sender - no access to that sender's private key is required. Exploitation requires inbound S/MIME signature verification to be enabled on the target instance, a certificate to already exist for the impersonated sender, and a human (agent/user) to view and act on the forged ticket, so impact is confined to integrity/spoofing with no data disclosure or service disruption. There is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; a vendor fix exists in 7.1.2, and the flaw is genuine rather than inflated CVSS.
TX ring memory corruption in the Linux kernel's stmmac (STMicroelectronics DWMAC/DWXGMAC) Ethernet driver allows a local sender to overwrite TX descriptors that are still owned by the DMA engine. The flaw is in the stmmac TSO transmit path: stmmac_tso_xmit() underestimates how many free descriptors a highly-fragmented TSO skb will actually consume, so a nearly-full descriptor ring can pass the availability check and let stmmac_tso_allocator() write past the available slots. Exploitation requires the stmmac driver in use with TSO/GSO enabled and a local sender able to submit a large, heavily-fragmented TSO skb at the moment the ring is almost full; the assessed impact is limited integrity damage and availability loss on affected (largely ARM/embedded STMicro MAC) systems, and no public exploit has been identified at time of analysis.
Out-of-bounds memory access in the Linux kernel's UFS (BSD FFS/UFS2) filesystem driver is reachable when the kernel mounts an attacker-crafted UFS image, because ufs_read_cylinder() caches unvalidated cylinder-group metadata and later uses it as an array index and bitmap-scan start during ordinary block and inode allocation or free. Affected are kernels from the initial git import (commit 1da177e4, i.e. Linux 2.6.12 era) through the 6.12.x, 6.18.x and 7.2.x lines prior to the stable fixes 6.12.111, 6.18.53 and 7.2.7 (mainline 7.3-rc3), with UFS support compiled in; per the CVSS vector the flaw is unauthenticated (PR:N) but requires high-complexity prerequisite conditions and user interaction (AV:L/AC:H/UI:R), since the victim must actually mount the malicious image, typically via removable-media automount or an explicit mount. The CNA scores this 7.0, but our independent assessment rates confidentiality and integrity impact as Low and only availability as High (AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:L/A:H), because mounting arbitrary images normally requires CAP_SYS_ADMIN and the trigger is contingent on subsequent allocation activity; no public exploit code and no CISA KEV entry were identified at time of analysis.
A soundness bug in the Linux kernel BPF verifier lets a crafted eBPF program slip past verification: when handling a 32-bit 'if w1 != 0' comparison, is_branch_taken() fails to distinguish BPF_JMP32 from BPF_JMP, wrongly reports the jump as always taken, and then tracks the wrong execution path for the rest of the program - leaving register bounds inconsistent with runtime behaviour. A local attacker who can load eBPF programs (CAP_BPF/CAP_SYS_ADMIN, or a host where kernel.unprivileged_bpf_disabled has been turned off) can turn this into memory corruption and kernel privilege escalation, with the assessed CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.0) rating high confidentiality, integrity and availability impact. There is no confirmed active exploitation (not listed in CISA KEV) and no public exploit code identified at time of analysis; practical risk is strongly limited by the default posture of disabling unprivileged BPF on modern distributions.
Linux kernel ALSA us122l driver code leaves VM_MAYWRITE set on read-buffer mappings that were created with PROT_READ, so a local user who can open the hwdep character node O_RDWR can simply call mprotect() to upgrade that mapping to writable after the initial rejection. Once writable, the attacker can alter the struct usb_stream read_size field, which the fault handler uses to decide which pages belong to the read buffer and which usb_stream_free() uses to size the free_pages_exact() release, resulting in out-of-bounds page mapping/access and out-of-bounds freeing of memory outside the allocation. Exploitation requires local authenticated access to /dev/snd's us122l hwdep node plus a physically attached Tascam US-122L-class USB audio device, so no public exploit code has been identified at time of analysis and the practical risk is modest despite the 7.0 base score; the independent assessment rates confidentiality and integrity impact as limited with availability impact high.
Linux kernel netfilter logging (the nf_log_syslog and nfnetlink_log backends) contains a teardown-ordering race that leaves a stale per-network-namespace logger pointer which later sysctl reads or packet-logging operations dereference. A local actor able to rebind the kernel's log backend - realistically requiring CAP_NET_ADMIN in the target network namespace - must win a narrow timing window against module unload or network-namespace exit, so the assessed impact is no confidentiality loss, limited integrity impact, and high availability impact (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H). Vendor patches are available in stable releases 6.12.111, 6.18.53 and 7.2.7 (mainline 7.3-rc3), and no public exploit code or confirmed in-the-wild exploitation has been identified at time of analysis.
Double completion of asynchronous crypto requests in Linux kernel s390 protected-key drivers (paes_s390 and phmac_s390) can crash or destabilize IBM Z systems when an error path returns a negative code after the request was already finalized. The issue is local-only, requires some privileges (PR:L) and high complexity (AC:H), and is limited to s390 hardware using these drivers; the independent assessment rates real-world risk as low despite NVD's 7.0 base score, with integrity and availability impact but no confidentiality impact. Vendor patches are available and no public exploit has been identified at time of analysis.
A use-after-free race in the Linux kernel's nfnetlink_cttimeout netfilter module lets a local attacker who holds CAP_NET_ADMIN and can trigger module unload or network-namespace teardown crash or corrupt kernel memory via the connection-tracking timeout policy path. The flaw exists because cttimeout_exit() unregisters the per-net operations (freeing the per-net timeout storage) before clearing the nf_ct_timeout_hook, so a concurrent nf_ct_set_timeout() call reached through an iptables/xtables CT target can dereference the stale hook and read already-freed memory. KASAN-reported use-after-free; no public exploit identified at time of analysis, and exploitation requires a narrow timing race plus elevated privileges (CAP_NET_ADMIN, and CAP_SYS_MODULE/root or repeated netns churn), so the practical outcome is a kernel crash rather than controlled corruption.
The Linux kernel's bcm_sf2 (Broadcom Starfighter2) DSA switch driver walks the entire CFP 'unique' rule bitmap into a caller-supplied rule_locs[] array without limiting the walk to nfc->rule_cnt, so a local, low-privileged user can read/write past the end of that allocation - or, with rule_cnt of 0, trigger a NULL-pointer dereference - simply by issuing the ETHTOOL_GRXCLSRLALL ethtool ioctl with a slot count smaller than the number of installed CFP rules. The ioctl itself requires no CAP_NET_ADMIN, but the bug is only reachable after a privileged administrator has installed at least one CFP classification rule, so it is confined to embedded or networking hardware that uses the Broadcom SF2 integrated switch and is not a risk on generic or default kernels; no public exploit has been identified at time of analysis. Our independent assessment scores it AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H (NVD publishes 7.0), reflecting a local attack path, a privileged precondition, impact dominated by availability, and only limited integrity exposure rather than the confidentiality/integrity compromise implied by the higher vendor score.
An out-of-bounds write, plus a NULL pointer dereference path, exists in the Linux kernel's nfp driver for Netronome/Corigine SmartNICs: nfp_net_get_fs_loc() walks every entry in nn->fs.list and dumps it into rule_locs[] without checking cmd->rule_cnt, the number of slots the caller actually allocated. A local, low-privileged user session can reach this path because the ETHTOOL_GRXCLSRLALL ioctl requires no CAP_NET_ADMIN and sizes the buffer from the userspace-supplied rule_cnt, so passing fewer slots than installed rules (or 0, which leaves the destination pointer NULL) corrupts kernel memory; a system administrator must first have installed ethtool ntuple/flow-steering rules via CAP_NET_ADMIN, and the nfp driver must be loaded on real NFP hardware. The provided CVSS 3.1 record rates this 7.0 with C:H/I:H/A:H, while our independent assessment bounds it to CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:H, keeping local access and the high availability impact but scaling confidentiality and integrity down. No public exploit code or confirmed active exploitation was identified at time of analysis; vendor patches exist in Linux 6.12.111, 6.18.53, 7.2.7 and 7.3-rc3.
The mv88e6xxx DSA switch driver in the Linux kernel can be driven into an out-of-bounds kernel memory write - or a NULL-pointer dereference - by a local user issuing the ETHTOOL_GRXCLSRLALL ioctl on a host where an administrator has previously installed at least one RX-flow classification rule; the ioctl requires no CAP_NET_ADMIN, so any local account can reach the buggy path, although the most likely outcome is a kernel crash with limited integrity impact rather than code execution or data theft. The defect is a missing bound on the policy-rule dump: the caller's rule_cnt buffer limit is clobbered by the driver before it is ever read, and a value of 0 leaves the destination pointer NULL. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; vendor fixes are available in the stable trees (6.12.111, 6.18.53, 7.2.7 and 7.3-rc3), and per the independent assessment exploitation is gated on non-default prerequisites - Marvell switch hardware using this driver plus pre-existing policy rules installed by a privileged administrator.
A use-after-free in the Linux kernel's btrfs RAID stripe-tree insertion path can free an in-flight transaction handle and transaction twice, corrupting kernel memory on systems that enable the opt-in raid-stripe-tree feature (added in Linux 6.7). Only local users who can write to such a filesystem, and only when a memory allocation fails (-ENOMEM) at exactly the btrfs_insert_one_raid_extent() failure site during ordered-extent finishing, can trigger it; the independent assessment scores this AV:L/AC:H/PR:L with no confidentiality impact but high availability impact (C:N/I:L/A:H), noting it is a high-CVSS-but-low-real-risk kernel issue that is not attacker-input-controlled. There is no public exploit identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV); vendor-released patches exist in the affected branches.
The Linux kernel's nvme-rdma host driver mishandles command teardown when a queue_rq submission returns -EIO, unmapping SQE DMA and cleaning up the block-layer request after the host-path-error helper has already completed that request. The result is a double cleanup of the nvme-rdma command and blk-mq request plus a DMA unmap against an already-completed request, which can corrupt request/command state, trigger a kernel crash or denial of service, and - per the assessed vector - cause limited integrity impact. Only hosts running the nvme-rdma driver while connected to an NVMe-oF target over an RDMA fabric (RoCE, iWARP or InfiniBand) are exposed, and the faulting branch only executes on a transient RDMA command-submission failure that is not directly attacker-controllable; the local, high-complexity, privileged nature of the trigger makes real-world risk substantially lower than the base score suggests, and no public exploit identified at time of analysis.
Improper CPU-ID validation in the Linux kernel's BPF subsystem (the BPF_F_CPU map-operation flag) allows a local user with BPF privileges - CAP_BPF, or any environment where unprivileged BPF is enabled - to drive an out-of-bounds per-CPU map access on hosts whose possible-CPU mask is sparse/non-contiguous, producing a kernel paging fault and denial of service (assessed availability impact A:H, with only limited integrity impact and no confidentiality impact). Only kernels exposing the relatively new BPF_F_CPU flag (introduced around Linux 7.0) are in scope, and exploitation additionally requires a machine with a CPU ID gap such as 0,2-3 - typical of certain arm64/embedded boards or virtualized guests with CPU device-tree holes - while mainstream x86 systems with contiguous 0..N-1 CPUs are not affected because num_possible_cpus() equals nr_cpu_ids there. There is no remote vector, exploitation is local and requires BPF privileges (CVSS vector PR:L, AC:H), and no public exploit code was identified at time of analysis; no CISA KEV entry was provided, so active exploitation is not confirmed, and this is best characterized as a high-CVSS-but-low-real-risk issue given the sparse-mask and CAP_BPF prerequisites.
Remote manipulation of Open Web Analytics through 1.8.1 queue bookkeeping is possible through the Remote Event Queue endpoint when event forwarding is enabled, allowing an unauthenticated network attacker to collide with queue-item primary keys, set far-future delivery timestamps, or preload retry counters. The broader CWE-502 object-injection primitive is not reachable solely by an unauthenticated HTTP caller because the vendor patch confirms HTTP input cannot name a class for unserialize; full deserialization exploitation requires an attacker who can already write to the owa_queue_item table or the queue log file, such as via SQL injection, stolen database credentials, or a restored/tampered table. No public exploit identified at time of analysis; vendor-released patch is version 1.8.2.
Denial of service in RabbitMQ's management HTTP API lets an authenticated administrator crash the broker by submitting a user (or importing definitions) whose tags list contains roughly one million unique strings; each string is converted to a permanent Erlang atom until the bounded atom table is exhausted and the BEAM node dies. Affected versions are RabbitMQ 4.0.0 through 4.0.21, 4.1.x before 4.1.14, and 4.2.x before 4.2.7, and the attack requires the management plugin to be enabled and reachable plus full administrator privileges, so there is no unauthenticated or low-privilege path. No public exploit code identified at time of analysis, and vendor-released patches are available in 4.0.22, 4.1.14 and 4.2.7; this is a genuine but low-priority availability issue rather than a confidentiality or integrity risk.
Unauthenticated information disclosure in Flame (pawelmalak's self-hosted homelab dashboard) through 2.4.0 allows any client that can reach the HTTP interface to retrieve the complete application configuration in a single request to GET /api/config, exposing the stored weather API key and internal operational settings. The endpoint is mounted without authentication middleware and the controller serializes the entire config object without redacting secret fields, so no credentials or special conditions are required - the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/A:N, base 6.9) and the independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) both confirm remote, unauthenticated exploitation against default deployments, though confidentiality impact is bounded and there is no integrity or availability impact. There is no public exploit identified at time of analysis and no confirmed active exploitation, but the disclosure requires only a plain HTTP GET, so any internet-exposed instance should be assumed to have had its configuration read.
Unauthenticated information disclosure in Wikimedia Foundation's WikiLambda Extension 1.47.0-alpha allows remote attackers to access a limited amount of sensitive data from affected MediaWiki installations. The issue is CWE-200 exposure of sensitive information, with a CVSS 4.0 base score of 6.9 (low confidentiality impact only and no integrity or availability impact); the independent assessment confirms network reachability with no authentication or user interaction. No public exploit identified at time of analysis, and the upstream remediated code is on the master branch via Gerrit change 1320186, tracked in Phabricator T430601.
Unlimited password guessing against the two-factor authentication login step in Zammad (all versions before 7.1.2) lets unauthenticated network attackers brute-force account passwords without triggering the platform's normal failed-login lockout or rate limiting, and the endpoint's response discloses whether each guessed password was correct before the second factor is ever evaluated. The concrete impact is credential-validity disclosure and unlimited offline-style online brute forcing rather than authentication bypass, since the second factor still gates actual login; risk is highest for accounts protected by weak or reused passwords. Rated CVSS 4.0 base 6.9 (AV:N/AC:L/AT:N/PR:N/UI:N, confidentiality-only), which is consistent with an independent CVSS 3.1 assessment of AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N; no public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and the vendor has released a fix in 7.1.2.
Man-in-the-middle tampering with the Automatic Update channel in Zhonglun CloudPOS 3.0 lets an unauthenticated attacker who holds a non-endpoint position on the network path manipulate the version, url, packagekey and package-name arguments processed in Program.cs, potentially steering or altering the update flow. Exploitation requires no authentication and no user interaction, but VulDB rates the attack as highly complex and the practical difficulty of occupying the required interception position keeps the overall priority low, with only low confidentiality, integrity and availability impact. Publicly available exploit code exists (a proof-of-concept document is linked from the VulDB record), the issue is not listed in CISA KEV so there is no confirmation of active exploitation, and the vendor was contacted early but did not respond.
Reflected cross-site scripting in the MediaWiki Cargo extension (versions through 3.9.4) lets remote, unauthenticated attackers execute arbitrary script in the origin of an affected wiki by convincing a victim to open a crafted URL while logged in. The defect is a CWE-79 improper-neutralization issue that the vendor rates 6.9 (Medium) under CVSS 4.0, whereas the independent assessment applies CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, explicitly requiring victim user interaction that the vendor vector omits; impact is confined to the victim's browser session within the wiki's origin rather than the server host. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and exposure is limited to the subset of wikis where this optional extension is installed and enabled.
Reflected cross-site scripting in the MediaWiki Cargo extension (versions through 3.9.4) allows an unauthenticated remote attacker to inject script that executes in a victim's browser within the wiki's origin, but only after the victim is induced to open a crafted URL. The vulnerable surface is limited to wikis that have separately installed and enabled the optional Cargo add-on, since it is not part of MediaWiki core, and no public exploit code has been identified at time of analysis. With an EPSS-style risk profile consistent with a modest-severity issue and impacts limited to session-scoped confidentiality and integrity, this is best handled as routine patching rather than an emergency response.
Reflected cross-site scripting in the MediaWiki Cargo extension, affecting all versions through 3.9.4, allows an unauthenticated attacker to inject script that executes in the browser of any wiki user who follows a crafted link. Per the assessed CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N), exploitation requires victim interaction - the target must open the malicious URL - and impact is limited to the victim's session on the affected wiki, with the scope change reflecting that the injected content can affect resources beyond the vulnerable component. No public exploit code has been identified and there is no CISA KEV entry: no public exploit identified at time of analysis. Exposure is confined to wikis that have installed and enabled Cargo, a non-core, separately deployed extension, and the Cargo query/reporting functionality must be reachable.
Stored cross-site scripting (XSS) in the MediaWiki Cargo extension through version 3.9.4 allows attackers to inject persistent malicious scripts into wiki pages that execute in the browsers of users viewing the content. The flaw requires the ability to save content that populates Cargo-stored data (typically an authenticated editor, though open wikis with anonymous editing may also be vulnerable) and user interaction from a victim. The Wikimedia Foundation reported the issue, but no public exploit code has been identified, and no vendor patch is yet available.
Information disclosure in the MediaWiki FlaggedRevs extension through 1.46.0 allows unauthenticated remote attackers to obtain limited sensitive information that the extension fails to remove before storage or transfer, per CWE-212. Only MediaWiki installations with the optional FlaggedRevs extension enabled are affected; wikis without it are not exposed. No public exploit identified at time of analysis, and SSVC records exploitation as none, making this a moderate-severity, low-to-medium operational priority.
Zammad 7.0.3 and 7.1.1 return stored LDAP and Exchange integration credentials in cleartext through the integration administration API, allowing an authenticated administrator to read secrets the UI is supposed to mask. Because the vulnerable endpoints are the import 'job_try' responses, a user holding full admin rights - and only such a user - can recover the LDAP bind password, the Exchange EWS password, or a stored OAuth access token, plus raw request parameters that leak into the persisted ImportJob payload. Per the supplied vector the issue requires high privileges (PR:H) and results in confidentiality impact only, with no code execution or data modification; there is no public exploit identified at time of analysis, and the vendor-released fix is Zammad 7.1.2.
Crafted URL injection in the Onion module of the AIL Framework lets unauthenticated content publishers push arbitrary non-onion addresses into the crawler's task queue, degrading the integrity of the framework's target selection. The module used a performance shortcut that accepted any URL of exactly 69 characters ending in '.onion' as a valid onion target, then sliced the domain directly out of the string without proper hostname parsing, so an attacker who can place content in a source the crawler ingests (a monitored paste, leak site, or web feed) can steer the crawler toward unintended network resources. No authentication or user interaction is needed and default configuration is sufficient; the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N) confirms impact limited to low integrity with no confidentiality or availability effect, and there is no public exploit identified at time of analysis.
A stack (or heap) out-of-bounds write in kitty terminal versions 0.40.0 up to but not including 0.49.0 allows any program that can emit escape sequences to the terminal to corrupt a fixed-size four-codepoint buffer while rendering an OSC 66 text-sizing sequence, crashing the kitty process and taking down every window, tab, and child process with it. The flaw is in screen_handle_multicell_command(), which appends each codepoint of a grapheme cluster with lc.chars[lc.count++] = ch without a capacity check in the natural-width branch of the text sizing protocol; a payload carrying a grapheme cluster longer than four codepoints writes one 32-bit value past the buffer for each additional codepoint. Exploitation is local and requires the user to view attacker-influenced terminal output (PR:N, UI:R); the impact is confined to availability - no confidentiality or integrity effect and no evidence of code execution. Vendor-released patch: 0.49.0; no public exploit identified at time of analysis.
Secure Folder 1.2, an Android vault app distributed as com.securefolder.securevault on Google Play, stores files selected for its password-protected vault as unencrypted files inside the Android shared-storage tree, so any co-resident application or file manager holding read access to that path can enumerate, copy, and open the vaulted files without authenticating to Secure Folder. The exposure is strictly local: the CVSS 4.0 vector requires local access with low privileges (AV:L, PR:L) and no user interaction, and impact is confidentiality-only, matching our independent CVSS 3.1 assessment (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), which characterizes real-world risk as low-to-moderate despite the 6.8 base score. There is no public exploit identified at time of analysis and no CISA KEV listing, so this is a design-level information disclosure rather than an actively attacked flaw. Any deployment of version 1.2 with files added to the vault is affected by default, since the plaintext storage behavior is not the result of an optional setting.
mTLS holder-of-key certificate binding is not enforced in Keycloak's Standard Token Exchange V2 flow, so an attacker who already holds valid confidential client credentials can obtain a standard, unrestricted token that escapes the certificate-binding protection the deployment believed was in place. Affected distributions include Red Hat Build of Keycloak and Red Hat Single Sign-On 7, and exploitation is conditional on three things being true at once: the attacker must already possess a stolen client secret or key (the CVSS vector rates this PR:L - a precondition the flaw itself does not grant), the deployment must have Standard Token Exchange V2 enabled and in active use, and the deployment must be relying on mTLS holder-of-key binding as a hardening control. No public exploit code has been identified at time of analysis and there is no CISA KEV listing; the assessed vector (AV:N/AC:H/PR:L/UI:N, C:H/I:H/A:N) reflects a genuine but conditional security-control bypass rather than a mass-exploitable flaw, since certificate-bound tokens are a non-default opt-in configuration.
Privilege escalation in the Fine-Grained Admin Permissions v2 (FGAP v2) feature of Keycloak lets an authenticated delegated administrator with role-assignment rights grant a composite role whose transitive contents are never inspected, silently conferring full realm administrative control. Exploitation requires that FGAP v2 be enabled for delegated administration, a limited-admin credential holding role-mapping permissions (CVSS vector PR:H), and the presence of a composite role that transitively contains realm-admin privileges within that administrator's assignable scope; the high attack complexity (AC:H) reflects these preconditions rather than any exploitation difficulty, and the resulting impact is a complete confidentiality, integrity, and availability compromise of the realm (CVSS 6.6). No public exploit code and no confirmed active exploitation have been identified at time of analysis, so this should be treated as a genuine but conditional authorization-logic flaw rather than a remotely exploitable takeover.
Authenticated path traversal in the Universal Connector Oracle Wallet upload component of IBM Guardium Data Protection 12.2 lets a low-privilege remote user write files to arbitrary filesystem locations on the appliance. The attacker must already hold a valid account with access to the Universal Connector upload function (PR:L) and must craft a traversal sequence that lands a file somewhere useful, which is why the vector carries AC:H despite the high confidentiality and integrity impact. Exploitation has not been observed: CISA SSVC records Exploitation as none and there is no public exploit identified at time of analysis, so this is a genuine but moderate-priority issue rather than a widespread emergency - though the 'total' technical impact rating means a successful hit against a misconfigured deployment could be severe.
An authenticated user with a valid CSRF token can read Django password hashes, request metadata, and related-user attributes from Horilla HR/CRM mail-preview functionality in versions 1.0.0 through pre-1.6.0 and prior to 2.0.0. The get_mail_preview handlers at /recruitment/get-mail-preview/ and /employee/get-employee-mail-preview render a user-supplied mail body as a Django template while the full request object sits in the template context, so template attribute traversal such as request.user.password or request.META exposes the underlying data; the Django template sandbox limits this to information disclosure rather than code execution. Exploitation requires only a low-privileged authenticated session with a CSRF token (no public exploit identified at time of analysis), and the confidentiality impact is high because the leaked password hashes can be attacked offline or used to identify accounts for follow-on compromise; vendor fixes ship in 1.6.0 and 2.0.0.
Server-side request forgery in the Image API (v2) of OpenStack Glance allows an authenticated tenant user (CVSS vector PR:L, network reachable) to make the glance-api service issue HTTP requests to attacker-chosen URLs by manipulating the 'locations' attribute of an image that is in the 'queued' state via a crafted PATCH request, potentially exposing internal-only services or cloud metadata (high confidentiality impact, limited integrity impact per the assessed vector). The vulnerability is strictly gated: it only functions when the non-default, deprecated 'show_multiple_locations' option is explicitly enabled in glance-api.conf, so standard OpenStack deployments that leave this setting off are not exploitable, and the attacker must hold valid tenant credentials and network access to the Glance API endpoint. Scoring is 8.1 with a low EPSS of 0.31% (21st percentile); the issue is not confirmed actively exploited (CISA KEV) and no public exploit identified at time of analysis, although a GitHub repository referencing this CVE and the companion CVE-2026-51773 has appeared and should be treated as a possible proof-of-concept.
Sensitive file disclosure in Apache Roller 6.1.5 allows an authenticated weblog administrator (CVSS PR:L) to read arbitrary files on the application classpath - including Roller configuration files that may contain secrets - by authoring a Velocity template that uses the #include or #parse directive to load a resource outside the active theme namespace. Roller's Velocity sandbox does not confine these directives, no non-default configuration is required, and any weblog whose administrator can author templates is affected; no public exploit identified at time of analysis.
An insecure direct object reference in InvoicePlane's Users::change_password() endpoint (prior to 1.7.2) lets an authenticated secondary administrator replace the password of any other user account - most critically the primary administrator - without knowing or supplying the current password, resulting in full takeover of that account and its privileges. Exploitation requires an existing administrator-level session (CVSS PR:H) and a deployment with at least one other admin account to target, so this is a privilege-consolidation/lateral-movement flaw rather than an unauthenticated remote takeover; no public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited. Vendor-released patch: 1.7.2.
Authenticated employees can read other employees' payroll records in Horilla HR 1.5.0-85 and earlier by substituting the emp_id, allowance_id, or deduction_id identifiers on the allowances_deductions_tab, view_single_allowance, and view_single_deduction endpoints in payroll/views/component_views.py. Exploitation requires only a valid logged-in account at any privilege level - no payroll-view permission and no ownership of the target record are needed - and exposes salary structures, allowance and deduction amounts, personal loan disbursements, and repayment schedules, making this a confidentiality-only disclosure flaw rated CVSS 6.5. There is no confirmed active exploitation (no CISA KEV listing) and no public exploit identified at time of analysis, but the absence of a complete fixed version leaves defenders with limited options.
Authenticated SQL injection in the PESI service of IBM Guardium Data Protection 12.2 allows a logged-in attacker with network reachability to the service to inject SQL through a parameter and read sensitive records from the product's internal database. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) indicates high confidentiality impact with no integrity or availability effects, and the prerequisite is a valid Guardium session - there is no pre-authentication path. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited; IBM has published a vendor advisory covering the fix, making this a genuine but conditional priority that is most urgent for internet- or broadly reachable PESI deployments with many low-privilege accounts.
Cross-site request forgery in InvoicePlane versions prior to 1.7.2 lets an attacker force a logged-in administrator's browser to submit forged POST requests that permanently delete financial and configuration records - including payments, recurring invoices, client-user assignments, users, email templates, families, and import data. The destructive delete()/stop() methods omit the ensure_valid_post_request() CSRF token check that other parts of the application rely on, so although the routes accept only POST, they never validate the request's token; exploitation requires the victim administrator to visit attacker-controlled web content while holding a valid session (CVSS 3.1 6.5, AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N). No public exploit code or confirmed active exploitation was identified at time of analysis, and the integrity impact is bounded to records the admin session could already delete - there is no data exfiltration, and deleted records may be recoverable from backups.
Cross-site request forgery in InvoicePlane versions prior to 1.7.2 lets an attacker silently stop a victim's recurring invoices by luring an authenticated administrator into loading attacker-controlled content that auto-requests the state-changing GET endpoint /invoices/recurring/stop/{id}. Because the route performs a privileged action without CSRF token validation on a simple GET, the attacker needs only a known or brute-forceable recurring-invoice identifier and no user interaction beyond the admin having a live session. The impact is integrity-only and confined to interrupting recurring billing, which can cause financial loss for the organization; the vendor has confirmed the flaw (GHSA-qf9q-2hxm-4wh9) and fixed it in release 1.7.2. No public exploit code has been identified and the issue is not listed as actively exploited in CISA KEV, though the low attack complexity and zero-click nature of the request keep the practical risk moderate.
Authenticated attackers holding low-privileged credentials on an IBM Financial Transaction Manager (FTM) 4.x for Red Hat OpenShift deployment can exploit an XML external entity (XXE) injection flaw to disclose sensitive files and internal resources readable by the application, rated CVSS 3.1 base 6.5 (MEDIUM) with high confidentiality impact and no integrity or availability effect. Exploitation requires network reachability to an FTM endpoint that parses attacker-supplied XML with external-entity resolution enabled, plus valid credentials (PR:L) and no user interaction; because FTM is typically deployed as an internal back-office payments/financial processing system rather than an internet-facing service, exposure is usually limited to authenticated users and adjacent network positions. There is no public exploit identified at time of analysis and no evidence of confirmed active exploitation, and IBM has published an advisory for the affected versions.
Authenticated SQL injection in the Better Messages WordPress plugin (versions up to and including 3.0.4) allows subscribers and higher-privileged users to extract sensitive database information via the 'group_id' parameter, but only when the BuddyBoss Platform plugin is installed with its Social Groups component disabled and the wp_bp_groups table remains present. The vulnerability has a base CVSS score of 6.5 (Medium) with high confidentiality impact but no integrity or availability impact; the independent assessment rates attack complexity as High (AC:H) due to the specific configuration prerequisite. No public exploit code or active exploitation has been identified at time of analysis.
Incomplete property masking in Brocade SANnav's logging subsystem can cause SNMP authentication and privacy passwords to be written into application logs whenever specific configuration conditions are met, so anyone who can read those logs or a generated support bundle can recover the credentials and use them for unauthorized read or management access to the monitored switch environment. The flaw is not remotely exploitable by an unauthenticated attacker: per the available CVSS data (PR:L) and our independent assessment (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), exploitation requires an actor who already holds log or support-bundle read privileges, and the sensitive values only appear under non-universal configuration conditions. No public exploit code and no confirmed active exploitation were identified at time of analysis; the practical risk is a credential-hygiene and information-disclosure exposure realized by insiders or by a post-compromise actor who reuses the recovered SNMP credentials against reachable switches.
Stored cross-site scripting in the CSS & JavaScript Toolbox plugin for WordPress (all versions through 12.0.6) enables authenticated attackers with contributor-level permissions to inject malicious scripts into pages via the cjtoolbox shortcode attributes. The injected code executes when any user, including administrators, views the compromised page, potentially leading to session theft or unauthorized actions. No public exploit has been identified, and the requirement for a valid contributor account limits exposure to sites that grant such access to untrusted users; this is a moderate-priority issue rather than a critical emergency.