Heap-based buffer overflow in snac2 before 2.93 enables unauthenticated remote attackers to crash the ActivityPub server by sending a single crafted application/activity+json POST whose JSON string contains a \u0000 escape; the vulnerable parser runs before HTTP signature verification, so federation endpoints are exposed. Publicly available exploit code exists, and the assessed impact is availability-only (server crash/denial of service), with no confirmed code execution or data exposure.
SQL injection in Modern Events Calendar Lite and Pro versions before 7.37.0 allows authenticated users with Subscriber-level access or higher to read arbitrary data from the WordPress database. Publicly available exploit code exists, though CISA's SSVC assessment finds no active exploitation; the practical barrier is the requirement for a valid low-privilege account, making this a credible mid-tier priority rather than an emergency.
Privilege escalation in the Salon Booking System WordPress plugin (10.17 through versions before 10.31.11) lets authenticated users who hold the plugin's custom salon staff role assign arbitrary capabilities, including administrator, to other accounts through the customer-editing function, enabling full site takeover. Publicly available exploit code exists, but the flaw is access-gated: it is not reachable by anonymous visitors or ordinary subscribers and requires a provisioned salon staff account, so exposure depends on how widely that role is granted and on the hygiene of those accounts. It is not confirmed actively exploited (no CISA KEV entry) and no EPSS score was provided.
Reflected cross-site scripting in WP Photo Album Plus before 9.2.11.002 allows remote unauthenticated attackers to inject script through a category navigation value that is reflected into a JavaScript event handler on gallery breadcrumb links. The victim must first open a crafted gallery link and then click the breadcrumb, so exploitation depends on that two-step user interaction; targeting a logged-in administrator yields script execution in a privileged session. Publicly available exploit code exists, and the vendor has released a patched version, 9.2.11.002.
PHP object injection in the WP Chill Strong Testimonials WordPress plugin, affecting all versions through 3.3.12, allows a low-privileged authenticated user to pass serialized data into an unsafe deserialization path and potentially instantiate arbitrary PHP objects. Because the CVSS 8.8 vector is PR:L, exploitation first requires a subscriber-level account, which is trivially obtainable on sites with open registration; user interaction is not needed (UI:N) and the attack is network-reachable with low complexity. Real-world impact beyond the injection itself - such as remote code execution or file manipulation - depends on whether a usable POP gadget chain exists in the site's installed themes and plugins, and no public exploit code or confirmed in-the-wild activity (CISA KEV) has been identified at the time of analysis.
A dentry reference leak in the Linux kernel's in-tree CIFS/SMB client (cifs.ko) is triggered when a process issues an O_CREAT open that the mounted server resolves to an existing non-regular inode, such as a symlink; cifs_atomic_open() calls finish_open() on that inode and attaches a cifsFileInfo, but symlink inodes carry no CIFS release operation, so the dentry reference held by cifsFileInfo is never dropped, and the wrongly set FMODE_OPENED flag also stops the VFS from following the symlink. Systems are affected only if they mount a share from an attacker-controlled or compromised SMB server and a local process then opens a crafted path (UI:R), and the assessed impact is limited to availability (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L); the disclosed score of 8.8 overstates confidentiality and integrity impact relative to that assessment. Patch data shows vendor fixes are available, and no public exploit was identified at time of analysis (EPSS 0.17%, percentile 6%, no CISA KEV listing).
Missing authentication in Vanus 0.8.0 through 0.9.0 allows unauthenticated remote attackers to publish forged CloudEvents into any eventbus through the gateway's CloudEvents HTTP receiver. Attackers can target /namespaces/{ns}/eventbus/{name}/events or the legacy /gateway/{name} path, bypassing token authentication and authPublish checks, so injected events are stored and delivered to subscription sinks. No public exploit code was identified at time of analysis, and the impact is bounded to event-stream integrity rather than data disclosure or denial of service.
Privilege escalation in ProjectSend 2.0.0 through 2.6.x allows a holder of a restricted API token to reset its own owner's password and disable the owner's two-factor authentication, then log in interactively with the owner's full role permissions. The weakness is an incorrect authorization decision in the users API: a token scoped only to manage_users and edit_users can issue PATCH /api/v1/users/{user} against the token owner's account even though the web interface requires the current password for such self-service credential changes. Exploitation requires an already-provisioned, privileged-but-restricted API token (authenticated, PR:H); no public exploit code or confirmed active exploitation was identified at the time of analysis, and version 2.7.0 contains the fix.
SQL injection in the WordPress plugin Support Genix (support-genix-lite) through version 1.4.54 allows an authenticated low-privilege user to inject SQL through plugin input and read sensitive database contents, with limited integrity impact. Exploitation requires the plugin to be installed and active and the attacker to hold valid low-privilege credentials; unauthenticated exploitation is not indicated by the assessed vector. No public exploit code or CISA KEV entry was provided at time of analysis.
Arbitrary Perl code execution in JQ::Lite before 2.51 allows an attacker who controls any portion of a query's regular expression to run code inside the calling process. The module's internal _build_regex helper interpolates the supplied pattern into a qr'...' literal and compiles it as source text via string eval, so a (?{ ... }) code block embedded in the pattern executes in place even though the caller never enabled `use re 'eval'`; the escaping applied to single quotes does nothing to stop a code block. Perl applications that pass untrusted input into test(), match(), or the match and =~ conditions of select() are exposed, and the independently assessed vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) treats the flaw as remotely reachable without authentication with high confidentiality, integrity and availability impact on the hosting process. Exploitation is not confirmed in the wild, EPSS is only 0.17% (6th percentile), and no public exploit code has been identified at time of analysis, but the flaw is a clean, documented code-injection primitive with a published upstream fix.
Unauthenticated attackers can abuse the model-registration endpoint in Xinference through 4.0.1 on Windows to write or delete arbitrary .json files by supplying a model_name containing backslash traversal sequences such as ..\..\evil. Successful exploitation targets files writable by the Xinference process, so configuration or data corruption is possible while confidentiality is not directly impacted. The vendor has published an upstream fix commit, and no public exploit code was identified at time of analysis.
TLS certificate verification in the OpenTelemetry Python OTLP/HTTP exporter is silently disabled when the OTEL_EXPORTER_OTLP_CERTIFICATE environment variable is set to an empty string, allowing an unauthenticated on-path attacker to impersonate the OTLP collector and read or tamper with exported traces, metrics and logs - including the authentication headers configured via OTEL_EXPORTER_OTLP_HEADERS. Only deployments running opentelemetry-exporter-otlp-proto-http 1.5.0 through 1.44.x that export over TLS to a remote collector and carry this specific misconfiguration (empty string rather than unset or a valid CA bundle path) are exposed, and exploitation additionally requires the attacker to occupy a man-in-the-middle position on the export path. There is no CISA KEV listing and no public exploit identified at time of analysis, so this is a genuine but conditional risk rather than an emergency: the vendor has released a fix in 1.45.0.
Linux kernel arm64 KVM running in protected mode (pKVM) fails to remove each CPU's hypervisor stack pages from the host stage-2 mapping, leaving hypervisor-private memory reachable by the host. The flaw sits in the fix_host_ownership() path, which only walks the linear-map alias of memblock regions and therefore misses stacks that are mapped solely in the private VA range for their guard page. Only arm64 systems with pKVM enabled are affected, and the attacker must already hold high privilege in the host kernel (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H, 8.2), so this is a local isolation-bypass primitive rather than a network-reachable flaw; no public exploit has been identified at time of analysis, it is not in CISA KEV, and EPSS is 0.20% (9th percentile).
Privilege escalation in the Login with phone number WordPress plugin (through version 1.8.77) allows unauthenticated remote attackers to potentially obtain elevated privileges, with high attack complexity reflecting conditions such as timing or a specific registration/login state that the attacker does not fully control. The issue is CWE-266 incorrect privilege assignment and carries a CVSS 8.1 score with high confidentiality, integrity, and availability impact. No public exploit identified at time of analysis, and no CISA KEV status was provided; defenders should prioritize patching internet-facing WordPress sites running this plugin.
Out-of-bounds read and write in the Linux kernel IPv6 header parser: ipv6_find_hdr() walks the extension-header chain and skips each header by the length that header declares (ipv6_optlen() returns up to 2048) without ever checking that skip against skb->len, so the offset it stores can land past the end of the packet. When openvswitch installs that offset as the transport header, update_ipv6_checksum()/inet_proto_csum_replace16() then reads and writes the transport checksum field outside the packet buffer, which the upstream report demonstrates as a KASAN slab-use-after-free in the skbuff_small_head cache on kernels up to the 7.3-rc series and the 5.10/5.15/6.1/6.6/6.12/6.18 stable branches. Exploitation requires the openvswitch kernel datapath configured with IPv6 modify actions (e.g. set_ipv6_addr) and an attacker-supplied IPv6 packet whose extension-header chain declares a length extending beyond the actual buffer; the demonstrated path runs through the OVS packet-execute netlink interface, which normally requires CAP_NET_ADMIN, so the assessed vector is local with high attack complexity even though the CNA scored it AV:N/PR:N. No public exploit is identified at time of analysis and the CVE is not in CISA KEV; EPSS is low at 0.22% (12th percentile).
A malicious HID device can trigger an out-of-bounds read in the Linux kernel's Wacom driver when wacom_wac_pen_serial_enforce() walks usage indices past the space its HID report actually reserves. After a hostile device presents a descriptor claiming far more usages than its Report Count holds (the cited case is 12288 usages against Report Count 1), a short 2-byte report makes hid_field_extract() read roughly 12 KB beyond the received buffer; the leaked value lands in wacom_wac->serial[0] and surfaces to userspace as an MSC_SERIAL event, so the impact is information disclosure plus a crash/availability risk. A UHID reproducer verified under KASAN on v6.12.105 confirms the trigger. The flaw requires the attacker to attach or emulate a crafted Wacom-class HID peripheral (physical USB access or Bluetooth HID proximity), which matches the AV:A vector; a public exploit reference exists but is not verified as working exploit code, there is no CISA KEV entry, and EPSS is 0.21% (11th percentile).
Out-of-bounds reads in the Linux kernel's SMB client (cifs module) let a malicious or compromised SMB2/SMB3 server leak kernel memory or crash the client host when a user or an automated mount connects to its share. The parser smb2_parse_contexts() validates the create-context area as a whole but does not clamp each record to its Next field, so a malformed chain can hand bytes beyond the current context to a handler; the same canonical-offset assumption in the SMB2/SMB3 lease parsers and a full-structure cast in the QFid handler widen the exposure, and a valid non-canonical DataOffset with a short DataLength is still accepted. Only hosts that mount SMB shares through the kernel client are affected, impact is read-only (information disclosure or denial of service, no integrity or code execution), and the attack requires the victim to initiate a session to an attacker-controlled endpoint. No public exploit code has been identified at time of analysis, EPSS is 0.17% (6th percentile), and the issue is not in CISA KEV; vendor patches are available and the priority guidance is to remediate this week.
Local privilege escalation in the Linux kernel's RDS Infiniband transport is possible when rds_ib_map_frmr() leaves a stale scatterlist in a memory region returned to the MR pool after a DMA mapping or registration failure; a local user who can open PF_RDS sockets on a kernel built with CONFIG_RDS/CONFIG_RDS_RDMA and the rds_rdma/ib path can later trigger a use-after-free during MR teardown. Exposure is limited to systems using the non-default RDS-over-Infiniband subsystem, and EPSS is 0.22% (12th percentile) with the vuln.today decision label this_week; no public exploit identified at time of analysis, and a vendor patch is available. The assessed CVSS 3.1 vector is AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8), consistent with a local privilege-escalation primitive requiring a local account rather than a remote attack.
Double-free in the Linux kernel's nouveau open-source DRM driver lets a local user who can open the DRM device node corrupt kernel heap memory by forcing the driver's client-teardown path to run twice during a failed open. Only hosts that actually have the nouveau module loaded are exposed - typically desktops, workstations or VMs with an NVIDIA GPU bound to nouveau rather than the proprietary driver - and the CVSS 3.1 score of 7.8 (AV:L/AC:L/PR:L/UI:N, high confidentiality, integrity and availability impact) reflects a local, low-privilege attacker with device access, not a remote one. The flaw has been fixed upstream in the stable trees, no public exploit code has been identified at time of analysis, and EPSS is low at 0.21% (11th percentile), which is consistent with a priority of patching this week rather than an emergency response.
A use-after-free in the Linux kernel's Open vSwitch conntrack handling lets a local user with low privileges corrupt kernel memory when a packet carrying an unconfirmed conntrack entry is cloned and both clones are then committed into the same conntrack zone with differing extension sets - one clone wiring helper/expectation extensions and the other adding a labels extension, which breaks the expectation-list pointer and is later dereferenced on the destruction path. Kernel releases across the 5.10, 5.15, 6.1, 6.6, 6.12, 6.18 and 7.2 branches are affected, with fixes published as 5.10.271, 5.15.222, 6.1.189, 6.6.158, 6.12.112, 6.18.55 and 7.2.9 (mainline 7.3-rc5). The maintainer notes that no practical network pipeline normally commits both clones unmodified into the same zone, so the required configuration is unusual, and no public exploit has been identified at time of analysis; EPSS is 0.21% (11th percentile) and the issue is not in CISA KEV.
A local user able to issue nouveau GEM allocation and UVMM VM-bind ioctls against the Linux kernel's nouveau DRM driver can trigger a slab-use-after-free read when a buffer object remains in TTM_PL_SYSTEM, because nouveau_uvmm_sm's map operation treats the plain struct ttm_resource as a struct nouveau_mem and reads mem->mem.type past the end of the allocation. The CVSS vector is AV:L/AC:L/PR:L/UI:N with high confidentiality, integrity and availability impact, so exploitation requires an authenticated local user on a host with nouveau bound to an NVIDIA GPU; systems without such a GPU, or using the proprietary NVIDIA driver, are not exposed. No public exploit code was identified at time of analysis and EPSS is 0.20 percent (9th percentile), so the practical priority is moderate rather than emergency; vendor fixes are published for stable branches 6.12.112, 6.18.55, 7.2.9 and 7.3-rc5.
Local denial of service in the Linux kernel's Intel Xe graphics driver (drm/xe) can crash the host when a GPU virtual memory is torn down concurrently with eviction of a shared external buffer object. xe_vm_close_and_put() frees vm->pt_root via xe_vm_pt_destroy() before queued contested VMAs are unlinked and destroyed, so a racing xe_bo_trigger_rebind() path in fault mode walks VMAs whose page-table root is already NULL and dereferences it in xe_pt_zap_ptes(), producing a kernel NULL pointer dereference. Affected are kernels containing the Xe driver prior to the stable fixes in 6.12.112, 6.18.55, 7.2.9 and 7.3-rc5; a local user with low-privileged GPU access who can open and tear down Xe VMs is required, and the race window is narrow, so per the independent assessment the realistic outcome is availability loss rather than data compromise. EPSS is low (0.20%, 9th percentile) and no public exploit code was identified at time of analysis; vendor patches are available and tracked as this-week priority.
A missing memory barrier in the Linux kernel's mm/rmap anon_vma preparation path allows a use-after-free of anon_vma->root, which in turn leaves one anon_vma rwsem permanently locked and makes another unacquirable, producing hung-task stalls and memory-management corruption. Only local users are affected (PR:L in the assessed vector), and the bug is reachable only when two threads concurrently fault on two adjacent, anon_vma-compatible but unmerged VMAs while holding mmap_lock for read, and only if the anon_vma->root store is reordered after the vma->anon_vma store - a window observed on arm64 and realistically attainable only on weakly-ordered architectures. No public exploit code was identified at time of analysis, EPSS is low (0.20%, 9th percentile), the issue is not in CISA KEV, and vendor patches are available, so priority is moderately low despite the 7.8 base score.
A use-after-free in the Linux kernel bridge multicast snooping code can be triggered by a local attacker holding CAP_NET_ADMIN (obtainable inside an unprivileged user namespace) on a bridge with MDB snooping enabled. The flaw lives in br_mdb_flush_pgs(), which keeps a pointer-to-pointer cursor over mp->ports while br_multicast_del_pg() re-enters the same MDB entry through br_multicast_sg_del_exclude_ports() and unlinks sibling port groups, leaving the cursor stale; a subsequent RTM_GETMDB dump then dereferences the freed memory (KASAN slab-use-after-free in br_mdb_dump). Impact is rated 7.8 with high confidentiality, integrity and availability consequences, but exploitation requires the specific EXCLUDE-mode (S,G) port-group layout plus a flush-then-dump sequence; EPSS is low (0.20%, 9th percentile), there is no confirmed active exploitation or KEV listing, and the vendor-released fixes are already available for the stable branches.
A use-after-free and a mapping-coverage gap in the Linux kernel's amdgpu/amdkfd driver (kfd_dev_mapping) can hang or destabilize AMD GPUs running under SRIOV with multiple containers. The driver caches the address_space of only the first /dev/kfd opener, so when that container exits the cached inode is freed while the GPU reset path still dereferences it in unmap_mapping_range(), producing an uninterruptible i_mmap_rwsem wait; VMAs belonging to later openers are also never zapped, leaving stale doorbell and MMIO pages mapped after a reset. The vendor-rated score is 7.8 (High) while the independent assessment applies AC:H, reflecting that exploitation is authenticated/local and requires a specific SRIOV multi-container AMD KFD deployment plus a GPU reset after container teardown. No public exploit has been identified at time of analysis (EPSS 0.20%, 9th percentile, no KEV), and vendor patches are available.
A memory-safety defect in the Linux kernel's XFS log-recovery routine (xlog_recover_iunlink_bucket) can leave a released inode pointer (prev_ip) dangling and can construct self-referential unlinked-inode lists, producing use-after-free and list-corruption conditions. Only systems running XFS on affected kernels - 6.0 through the fixed versions 6.12.113, 6.18.55, 7.2.9 and 7.3-rc5 - are exposed, and exploitation requires local access plus the mounting or log recovery of an XFS filesystem whose journal contains unlinked-inode buckets. The use-after-free specifically manifests when the inodegc flush call inside the recovery loop fails; the conditions under which that flush fails are not detailed in the available sources, so triggering reliably is difficult, no public exploit has been identified, EPSS is 0.17% (6th percentile) and the issue is not in CISA KEV.
Use-after-free in the Linux kernel's net/sched act_ct action allows a local user with low privileges (CVSS:3.1/AV:L/AC:L/PR:L/UI:N) to corrupt kernel memory, with high confidentiality, integrity and availability impact (base score 7.8). The flaw only surfaces when act_ct is combined with a conntrack helper (such as an ALG helper) and the affected connection has not yet been confirmed, so unconfirmed flows that gain further conntrack extensions after the helper runs leave a stale pointer in the expectations list. There is no remote or unauthenticated vector, no public exploit identified at time of analysis, no CISA KEV listing, and EPSS is low at 0.17% (6th percentile); the vulnerability is nonetheless patched in stable trees and is prioritised for remediation this week rather than treated as an emergency.
A use-after-free in the Linux kernel's net/sched act_ct connection-tracking action can be triggered when a socket buffer holding an unconfirmed conntrack entry is cloned and both clones are subsequently processed with differing extension sets - the first clone wiring helper extensions into the expectation list, then losing confirmation, and the second clone adding a label or NAT extension that breaks the expectation-list pointer, corrupting memory later on the destruction path. The flaw was introduced in Linux 6.2 with the conntrack helper wiring and affects kernels through 6.18.55, 6.12.112 and 7.2.9, with fixes merged in 7.3-rc5. Triggering requires local access with privileges sufficient to configure tc act_ct (CAP_NET_ADMIN), and the vendor notes no practical pipeline processes both clones in the same zone without header or zone changes; the CVSS 3.1 vector is AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, and per available data there is no confirmed active exploitation and no public exploit code identified, with EPSS at roughly 0.17%.
The Linux kernel's accel/amdxdna accelerator driver allows device buffers that were never intended to be exposed to be exported, creating a local confidentiality and integrity risk scored 7.8 High. Exploitation requires authenticated low-privilege local access (CVSS PR:L) on an affected kernel before 7.2.7 or 7.3-rc1 with the amdxdna driver loaded on AMD XDNA (Ryzen AI NPU) hardware; EPSS is 0.14% (3rd percentile), and no public exploit or CISA KEV entry is identified at time of analysis. Vendor patches are available in Linux 7.2.7 and 7.3-rc1.
Path traversal in Omnigent 0.3.0 through 0.13.x allows authenticated users who can upload an agent bundle to escape the session workspace and read or write host files with the runner user's privileges by setting os_env.cwd to an absolute or parent-traversing path on a nested sub-agent or terminal. Validation in bundles.py only checked the root agent's working directory, so cwd values supplied by nested specs slipped through unvalidated. The most severe host-filesystem exposure arises on runners where OMNIGENT_RUNNER_WORKSPACE is not configured, because the attacker-supplied cwd then becomes the environment root and copytree source; no public exploit code identified at time of analysis, and exploitation requires valid credentials plus bundle-upload rights.
Account takeover in ProjectSend 2.5.0 through 2.6.x lets anyone holding a stolen session cookie for a Social-provisioned account set a durable local password through PUT /settings/password without supplying the current password, flipping the account to local authentication and allowing the attacker to enroll their own second factor. Only accounts whose auth_source is Social (external/provider sign-in) are reachable and the attacker must already hold a live session, but the resulting persistence outlives session expiry and survives routine session hygiene. No public exploit code identified at time of analysis and the issue is not in CISA KEV; the vendor shipped a fix in 2.7.0 that rejects the form path for provider accounts and substitutes an emailed reset link to the account's own address.
Authorization bypass in the Electronic Signature Add-on for Fluent Forms (signature-fluent-contract-forms-add-on) through version 2.0.5 allows remote attackers to read other users' signature and contract records by substituting a user-controlled object identifier in a plugin endpoint. The supplied CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:N/A:N, base 7.5) describes network-reachable, low-complexity access with high confidentiality impact but no integrity or availability impact; the PR:N/UI:N values indicate no authentication or interaction is claimed to be required, though that assumption should be verified against the plugin's access model. This is a CWE-639 IDOR-style flaw; no public exploit was identified at time of analysis.
Memory-safety errors in the Linux kernel's LLC (IEEE 802.2 Logical Link Control) connection and SAP action handlers can be triggered by crafted LLC frames from an adjacent Layer-2 network segment when llc_mac_hdr_init() fails. The buggy error paths free the wrong socket buffer in llc_conn_ac_resend_i_xxx_x_set_0_or_send_rr() - causing a use-after-free read of LLC_I_GET_NR(pdu), a double-free when llc_conn_state_process() drops its reference, and a leak of the newly allocated nskb - while llc_sap_action_send_xid_r() and llc_sap_action_send_test_r() simply leak nskb. There is no confirmed active exploitation (not in CISA KEV) and no verified working exploit code, EPSS is low at 0.21% (11th percentile), and real-world risk is constrained by the rarity of LLC use and the difficulty of forcing the llc_mac_hdr_init() failure branch (AC:H).
An unexpected or stale GRP_ACK_MSG delivered to a TIPC replicast broadcast group can drive the kernel's u16 grp->bc_ackers counter below zero, wrapping it to 65535 and causing tipc_group_bc_cong() to report permanent congestion - blocking all future group broadcasts on that socket. Unprivileged, unauthenticated remote attackers can trigger the defect (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) provided TIPC is loaded and a group-communication socket is active, which is not the case on default distribution installs. Impact is strictly availability on the affected socket, with no code execution, privilege escalation, or data exposure; no public exploit has been identified and EPSS is low (0.21%, 11th percentile), though the vendor has released fixed kernels and the issue is tracked for the current weekly patch cycle.
IPv6 IPsec hardware-offload policy enforcement in the Linux kernel's mlx5e driver installs swapped source and destination prefix masks, so a Mellanox/NVIDIA ConnectX flow-table rule can both fail to cover traffic the XFRM policy is meant to protect and match traffic that falls outside it - a policy-bypass defect in the offload path rather than a memory-safety bug. Only hosts using an mlx5 NIC with IPsec (XFRM) hardware offload enabled and at least one IPv6 policy whose source and destination prefix lengths differ are affected; policies with equal prefix lengths are unaffected. The assessed vector requires privileged access (PR:H) with high attack complexity, EPSS is low at 0.20% (9th percentile), and no public exploit has been identified at time of analysis; patched kernel versions are available and the priority label is this_week.
The software iSCSI initiator (libiscsi_tcp) in the Linux kernel can be induced by a hostile or compromised iSCSI target to write target-supplied bytes into memory that belongs to an in-flight WRITE command, corrupting either the caller's pinned user buffer (O_DIRECT) or page-cache pages (buffered I/O). The flaw is that iscsi_tcp_hdr_dissect() resolves a Data-In PDU's ITT to a task and copies the data segment into that command's scatterlist without verifying the command was a read, unlike iscsi_tcp_r2t_rsp() which rejects R2T PDUs for non-DMA_TO_DEVICE commands; a 512-byte Data-In naming a 128 KB write's ITT leaves the buffer holding target data while pwrite() still returns 131072, and the buffered path logs nothing while reads from those blocks return the target's bytes from page cache. The CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N) reflects remote, low-complexity reachability, but exploitation is bounded by the trust boundary: the initiator must be connected to a malicious or attacker-controlled iSCSI target, which is not the normal deployment model for iSCSI storage. No public exploit code or active exploitation was identified at time of analysis (EPSS 0.18%, 7th percentile), and vendor patches are available across all supported branches.
Authentication bypass and user impersonation in Gitea through 28.1.0 let an authenticated low-privilege attacker assume another user's identity when the instance trusts a user SSH certificate authority and allows arbitrary principals. The flaw is highly configuration-dependent: only deployments with SSH_TRUSTED_USER_CA_KEYS set and SSH_AUTHORIZED_PRINCIPALS_ALLOW=anything are exposed, and Gitea states instances that do not trust a user CA are unaffected. No public exploit has been identified at time of analysis; EPSS is 0.10% (1st percentile) and CISA SSVC records exploitation none and automatable no, while the vendor has released Gitea 28.2.0.
Linux kernel 6.15 and later builds with BPF LSM support can let a local actor who can load and attach a sleepable BPF LSM program to the path_unlink or path_rmdir hooks mutate a victim inode’s extended attributes without holding i_rwsem when the program calls bpf_set_dentry_xattr() or bpf_remove_dentry_xattr(). The verifier incorrectly treats those path hooks as inode-locked and rewrites the helpers to _locked variants, producing integrity and availability impact while confidentiality is unaffected; CVSS is 7.3 (AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:H). Exposure is confined to systems with such a program attached and requires CAP_BPF/CAP_SYS_ADMIN to load/attach it; no public exploit was identified at time of analysis, and EPSS is 0.20% (9th percentile). Vendor patches are listed in 6.18.55, 7.2.9, and 7.3-rc5.
Heap out-of-bounds write in cgltf through 1.15 lets a crafted glTF or GLB file with oversized sparse accessor indices push writes past the end of the output buffer inside cgltf_accessor_unpack_floats(), corrupting heap memory and crashing or potentially achieving code execution in the loading process. The flaw is only reachable when an application parses an untrusted asset and skips cgltf_validate(), the explicit check that would reject the malformed indices; attacks are local with user interaction (the victim must open the file), and no public exploit code was identified at time of analysis. Impact is confined to engines, viewers, converters, and import toolchains that ingest third-party 3D assets without validation, so real-world risk is moderate and highly conditional despite the 7.3 score.
Missing authorization in the Vanus gateway (versions 0.8.0 through 0.9.0) lets any authenticated user invoke Subscribe, Ack, and unregistered streaming RPCs without per-resource permission checks, enabling cross-tenant subscription hijacking, event read/acknowledgment, consumer starvation, and user enumeration via ListUser. Exploitation requires a valid account and a multi-tenant deployment with a targetable subscription ID; single-tenant or single-user deployments have no cross-tenant victim. No public exploit code or CISA KEV entry was identified at time of analysis, and the practical impact is bounded to event-data exposure, denial of the legitimate consumer, and user enumeration rather than host compromise.
SQL injection in JeecgBoot before 3.9.5 allows authenticated low-privilege users to bypass the SqlInjectionUtil keyword blocklist by inserting newline characters into dictionary and online report SQL fragments, then send newline-separated payloads to endpoints such as /sys/dict/getDictItems to perform boolean- or time-based blind extraction of database contents, including administrator password hashes from sys_user. The assessed CVSS 3.1 vector is AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, so the primary precondition is an authenticated session rather than user interaction or a non-default configuration. Vendor-released patch: 3.9.5; no public exploit identified at time of analysis and no CISA KEV entry was provided.
An out-of-bounds read in the Linux kernel netfilter ip6t_rt IPv6 routing-header match can be triggered by a crafted IPv6 packet when a malformed rt match rule requests address matching (IP6T_RT_FST_MASK) but carries zero addresses, letting the loop index run past the 16-entry addrs array so ipv6_addr_equal() reads beyond struct ip6t_rt, producing KASAN/UBSAN reports or a kernel panic. Reaching the flaw requires CAP_NET_ADMIN to install the offending rule (obtainable by an unprivileged local user via a user namespace) plus a matching crafted packet, so it is a local, configuration-dependent issue absent from normal deployments. Vendor patches are available and no public exploit has been identified at time of analysis; EPSS is 0.22% (12th percentile).
Use-after-free in the Linux kernel's hid-alps driver can let a locally or physically attached malformed HID device corrupt memory after the driver's second input device (input2) fails to register. alps_input_configured() publishes data->input2 into drvdata before calling input_register_device(); when registration fails, input_free_device() releases the object while the stale pointer survives, and because hid_hw_open() has already activated URBs, an incoming U1_SP_ABSOLUTE_REPORT_ID report can reach u1_raw_event() and dereference the freed device. Only systems running a pre-fix kernel with hid-alps bound to an ALPS U1 touchpad are exposed, the error-path window is narrow and hard to force (high attack complexity, physical/local vector), and no actively exploited status (not in CISA KEV) or public exploit code was identified at time of analysis; EPSS is 0.21% (11th percentile), consistent with a low real-world likelihood despite the 7.1 base score.
Use-after-free read in the Linux kernel's nouveau DRM scheduler: a finished dma-fence that has been exported to userspace can outlive the nouveau_sched object that backs its scheduler, so a later get_timeline_name() call dereferences freed slab memory (KASAN slab-use-after-free). Affected are systems running the open-source nouveau driver on NVIDIA GPUs, with the object reachable by a local user holding low privileges (CVSS PR:L) who can export a fence via drm_syncobj/sync_file and then trigger nouveau_sched_destroy() followed by the unprivileged SYNC_IOC_FILE_INFO ioctl. Impact is a kernel memory disclosure of high confidentiality severity plus denial of service through the fault, exposure is local only, and no public exploit code or CISA KEV entry was identified at time of analysis; EPSS is 0.20% (9th percentile), and vendor fixes are available in 6.12.112, 6.18.55, 7.2.9 and 7.3-rc5.
Stale AMD SEV guest data can survive in CPU caches after the source VM is destroyed during an intra-host KVM migration on Linux, allowing a local user with enough privilege to recover confidential guest memory contents from cache lines that were never scrubbed. Affected deployments are those running SEV (encrypted) guests under KVM and performing intra-host or live migration followed by memory reclaim; non-SEV hosts and environments without SEV guest migration are not exposed, and the flaw is not remotely reachable. EPSS is 0.20% (9th percentile) with no public exploit identified at time of analysis, and vendor-released fixes exist in the stable trees. Our assessed impact is confidentiality-only (C:H/I:N/A:N), while the vendor record additionally cites integrity and availability effects.
Denial of service in Linux kernel KVM arm64 allows a local authenticated user inside a 32-bit (AArch32) guest to access DBGBXVR<n> debug registers, triggering KVM_BUG_ON and marking the VM dead. The regression affects arm64 KVM hosts running AArch32 guests after the breakpoint/watchpoint accessor consolidation up to fixed releases 6.18.55, 7.2.9, and 7.3-rc5. No public exploit was identified at time of analysis, EPSS is 0.20% (9th percentile), and the independent assessment treats this as a low-urgency availability bug despite the 7.1 CVSS.
Stored cross-site scripting in PowerPack Lite for Beaver Builder (WordPress plugin) through version 1.3.1 allows users with content-creation or editing privileges - contributor or higher in most configurations - to inject persistent script into module fields, which executes when another user views the affected page. The flaw is CWE-79 and rated CVSS 7.1 High; scope is changed, with limited confidentiality and integrity impact and no confirmed availability impact. No public exploit code or CISA KEV entry is identified in the available data.
Stored cross-site scripting in the Simply Schedule Appointments WordPress plugin through 1.6.12.35 allows remote attackers to submit crafted booking input that executes in an administrator’s browser when the entry is viewed in the WordPress admin dashboard. The flaw is CWE-79 with a CVSS 3.1 score of 7.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:L), and exploitation depends on a privileged user opening the malicious booking, so impact is bounded to the victim’s browser session. No public exploit identified at time of analysis, and no CISA KEV active-exploitation entry was provided.
DOM-based cross-site scripting in the Arraytics Booktics WordPress plugin through version 1.0.29 allows unauthenticated remote attackers to run attacker-controlled script in a victim’s browser when the victim is tricked into interacting with crafted input, such as clicking a link or visiting a malicious page. The reported CVSS score is 7.1, but the assessed vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N) confines impact to low confidentiality and integrity effects within the interacting user's browser, with no availability impact. No public exploit code or CISA KEV entry was identified at time of analysis, and exploitation depends on the Booktics plugin being installed and active plus successful victim interaction.
Reflected cross-site scripting in the ThemeGrill eStore WordPress theme through version 1.6.13 allows remote attackers to execute arbitrary script in a victim's browser when the victim opens a crafted URL, with no attacker authentication required but mandatory user interaction. The flaw is CWE-79 and is limited to the victim's session context; no public exploit was identified at time of analysis. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, reflecting low confidentiality and integrity impact and no availability impact.