Local attackers can trigger a DMA mapping leak in the Linux kernel's stmmac Ethernet driver (Synopsys DesignWare MAC) by causing a DMA mapping failure during TSO transmission, leading to gradual resource exhaustion and potential denial of service. The vulnerability affects kernels from 4.7 up to before 7.2.7 (and before 7.3-rc2), requires low privileges (PR:L) and specific conditions such as memory pressure or IOMMU exhaustion, and is not known to be actively exploited; no public exploit identified at time of analysis. EPSS is low at 0.15%, and the issue is considered a low-priority defensive fix.
The Linux kernel CIFS/SMB client can return stale data after a successful insert-range or collapse-range operation on an SMB3 mounted file. smb3_insert_range() and smb3_collapse_range() invalidate the page cache with truncate_pagecache_range(), but when the target offset or old EOF is not page-aligned, the boundary pages are only partially zeroed and remain uptodate, so the client may serve stale contents. Affected are Linux kernels with the smb/client insert/collapse range support (versions cited from 5.19.12 through 7.2.x, fixed in 7.2.7 and 7.3-rc2); exploitation requires local access on a system that mounts an SMB3/CIFS share and it yields silent stale-data readback rather than code execution. No public exploit was identified at time of analysis, EPSS is low (0.15%), and the issue is not in CISA KEV.
Incorrect zero extension of the result of a 32-bit atomic compare-exchange on a BPF arena pointer in the Linux kernel can leave stale bytes in the upper half of the destination register after a successful cmpxchg, so BPF programs reading that register observe wrong values on architectures where 32-bit cmpxchg does not implicitly clear the upper bits (notably x86-64 'lock cmpxchg', which leaves %eax unchanged on a successful compare). Triggering it requires local access with privileges sufficient to load eBPF programs (CVSS PR:L - CAP_BPF/CAP_SYS_ADMIN, or a kernel configured to permit unprivileged BPF) plus the specific combination of an arena pointer and a 32-bit cmpxchg that the context-access rewriter converts to BPF_PROBE_ATOMIC, so exploitation is both privileged/configuration-gated and architecture-sensitive. Impact is confined to incorrect computation and availability (C:N/I:N/A:H in the assessed vector); no public exploit identified at time of analysis, EPSS is 0.15% (4th percentile), and the issue is not listed in CISA KEV, making this a low-to-moderate, locally scoped reliability bug best handled through routine kernel updates.
Kernel panic in the Linux amdxdna accelerator driver (the DRM accel driver for AMD XDNA NPUs) lets a local user crash the system by racing a modification of the userspace-controlled command_count field of a struct amdxdna_cmd_chain that is stored in shared AMDXDNA_BO_SHARE memory, so the compiler-generated __counted_by bounds check fails. Only systems with AMD XDNA NPU hardware, the accel/amdxdna driver loaded, and an attacker with local access to the accelerator device node are affected; the impact is denial of service via crash, with no confidentiality or integrity impact. No public exploit code was identified at time of analysis, EPSS is 0.15 percent (4th percentile), and vendor fixes are available in Linux 6.18.53, 7.2.7 and 7.3-rc2.
Kernel memory exhaustion in the Linux kernel's ksmbd SMB server can be triggered by an authenticated remote attacker through a tree connection leak in smb2_tree_connect(). The flaw occurs when ksmbd_iov_pin_rsp() fails with a NOMEM error after the tree connection has been stored and counted, leaving it allocated and unreleased; repeated failures slowly exhaust kernel memory. Exploitation requires the non-default ksmbd configuration with an exported share and is rated high complexity with low availability impact; no public exploit code has been identified, and EPSS is 0.14% (3rd percentile).
Insufficient JBD2 transaction credit reservation in the Linux kernel's ext4 filesystem can abort the journal and take down the kernel when writeback converts extents in a corner case where a large folio is sparsely dirtied over a large unwritten extent. Only local users who already hold write access to an ext4 volume can steer the filesystem into this path, and the outcome is a denial of service through journal abort/kernel crash (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, 5.5) with no data disclosure or corruption implied; no public exploit code has been identified at time of analysis, and EPSS is very low at 0.14% (3rd percentile), consistent with a low-priority local availability issue. Vendor-released patch: Linux 7.2.6 and 7.3-rc1 (plus stable backports).
Local users on Linux systems running NVMe multipath against a shared namespace with Flexible Data Placement (FDP) enabled can trigger a race in the kernel's per-namespace FDP placement-ID array initialization, causing inconsistent state and potential availability loss such as a crash or hang. The assessed vector (AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:H) makes this a low-to-moderate priority local availability bug rather than an urgent patch-now item, and it requires a specific FDP-plus-multipath hardware and configuration. A vendor patch is available via stable commits e0a23e3c8c4c3ce11529fa70d2292b4e56d143ba and 56e1c6bbe4bb084d7ecf61698afdf70be23dd35f, with EUVD mapping fixes to 7.2.7 and 7.3-rc2; EPSS is 0.14% (3rd percentile), KEV status is not present, and no public exploit was identified at time of analysis.
The Linux kernel's printk code path can be pushed into a WARN_ON() when kthread_run() fails, because __kthread_create_on_node() returns -EINTR once the target is killed with SIGKILL; a local user who can reach that printk path and signal the kthread can therefore force a kernel warning. Because the outcome is gated by configuration, the practical impact is a denial of service only on kernels built or booted with panic_on_warn enabled, where the warning escalates to a panic. Scoring is low-risk (EPSS 0.14%, third percentile, no CISA KEV entry) and no public exploit has been identified at time of analysis; vendor fixes are available via the kernel stable tree.
Kernel crash in the Linux kernel's accel/amdxdna driver can be triggered by a local process with low privileges (PR:L) that can open the AMD XDNA render node and submits a command chain with command_count set to zero. The zero-command payload passes the size check, the fill loop is skipped, and the resulting zero-length submission reaches drm_clflush_virt_range(cmd_buf, 0), which reads before the buffer and faults on the vmap guard page; affected systems are those with AMD XDNA/Ryzen AI NPU hardware and the amdxdna driver bound. Impact is availability-only (CVSS 5.5, C:N/I:N/A:H), EPSS is 0.14% (3rd percentile), no public exploit identified at time of analysis, and upstream fixes are referenced.
A reference-count leak in the Linux kernel's accel/amdxdna driver (AMD XDNA NPU support) allows a local user who can open the device to leave a GEM buffer-object reference permanently held when the mapping step in amdxdna_cmd_set_error() fails, so repeated triggering slowly consumes kernel memory and can degrade availability of the system. Ordinary command submission does not reach the faulty path - the driver relies on the chained BO having already been resolved and cached by aie2_cmdlist_fill_slot()/amdxdna_gem_vmap(); reachability requires the user to close the BO handle after submitting the chain and then import a dma-buf whose exporter implements no vmap onto the same id, which prime_import() types as AMDXDNA_BO_SHARE and which amdxdna_gem_get_obj() then hands back as an object that cannot be mapped. Scoring is CVSS 3.1 5.5 (AV:L/AC:L/PR:L/UI:N, availability-only High impact), EPSS is low at roughly 0.14% (3rd percentile), the issue is not in CISA KEV, and no public exploit has been identified at time of analysis; vendor-released fixes are available, and the issue is rated a this-month priority rather than an emergency.
In the Linux kernel's NTFS write path, symlink(2) and WSL special-file creation can report success even when set_reparse_index() fails, leaving no reparse data on disk. The bug affects systems where an NTFS volume is mounted read-write through the in-kernel ntfs3 driver and a local user with file-creation privileges triggers the failing index insertion; the trigger for that insertion failure is not described in the available sources. EPSS is 0.14% (3rd percentile), no public exploit was identified at time of analysis, and the assessed impact is low integrity only, consistent with a this_month priority rather than emergency action.
Linux kernel NTFS write error handling can leak a kmap_local_folio() mapping in write_mft_record_nolock(), corrupting per-task kmap_local nesting and producing a local availability impact. The flaw affects Linux kernel code identified by CPE cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:* and EUVD version data covering Linux 7.1 and commit ranges fixed by 5d7f7bf8fba8cf563b42b44aa4ab3d9928ac480c and cf06dcd572845723821b54a608fc2da995c3c8e2. The provided base CVSS is 5.5, the independent assessment uses AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:H and considers this a low-to-moderate risk that does not warrant emergency prioritization; EPSS is 0.14% (percentile 3%), and no public exploit was identified at time of analysis.
The Linux kernel's legacy NTFS driver can silently mark a damaged volume as clean, suppressing the recovery that would otherwise repair on-disk errors. Unlike ntfs_put_super() and the remount-read-only path, which clear the dirty bit only when no volume errors are recorded, ntfs_sync_fs() resets it unconditionally, so a write followed by a sync() on a volume whose $MFTMirr does not match $MFT leaves the on-disk flags at 0x0000 instead of 0x0001 and the volume is later treated as needing no recovery. Exploitation is local and requires an authenticated user with low privileges on a host that mounts NTFS read-write with a pre-existing filesystem error; the error condition is largely environmental rather than attacker-controlled, so real-world risk is LOW, no public exploit is identified at time of analysis, and EPSS is 0.14% (3rd percentile).
The Linux kernel NTFS driver can silently ignore failed zeroing operations during fallocate, potentially leaving stale on-disk data in newly allocated clusters, which may lead to low-impact information disclosure or integrity issues. Exploitation requires local write access to a mounted NTFS volume and a concurrent block-device zeroing failure, making this a low-priority defense-in-depth fix rather than an urgent threat. No public exploit code or active exploitation has been identified, and the EPSS score is 0.14% (3rd percentile).
A local denial-of-service condition in the Linux kernel's legacy NTFS driver allows a user able to mount a crafted NTFS filesystem image to crash the kernel by supplying a boot sector with sectors_per_cluster set to 0 or another non-power-of-two value. The flaw is reached through parse_ntfs_boot_sector(), which computes ffs(sectors_per_cluster) - 1 and then performs an out-of-bounds shift (shift exponent 4294967295), tripping a UBSAN shift-out-of-bounds report in fs/ntfs/super.c; only kernel availability is impacted, with no code execution or data disclosure (CVSS 5.5, AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H). Vendor patches are available (fixed in Linux 7.2.7 and 7.3-rc2 via commits 7524c3145a3bac92bebbc47a29c007f1d874c9b3 and 323751a604e7533fa473874d999371592a614207), and there is no public exploit identified at time of analysis; EPSS is 0.14% (3rd percentile), consistent with a low-priority local bug.
Opening a crafted Gnumeric workbook can trigger a heap use-after-free (CWE-416) during XML parsing of a malformed SheetObjectComponent element, crashing the application and causing a denial of service. This affects GNOME Gnumeric across versions (CPE: cpe:2.3:a:gnome:gnumeric:*:*:*:*:*:*:*:*). The vulnerability requires local access and user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:R), and no public exploit identified at time of analysis.
Server-side request forgery in the WordPress plugin Asset CleanUp: Page Speed Booster (versions up to and including 1.4.0.5) lets an authenticated attacker with administrator-level access trick the site's server into issuing HTTP requests to arbitrary internal or external locations through the 'page_url' parameter, potentially allowing them to probe or interact with internal services. Exploitation is doubly gated: the attacker must already hold admin privileges, and the plugin's dom_get_type setting must be configured to 'wp_remote_post', a non-default administrator-controlled option, so untargeted opportunistic abuse is unlikely and no public exploit code has been identified at time of analysis. The result is a genuine but low-priority issue rather than an urgent one.
Stored cross-site scripting (XSS) in the chat feature of madpsy's ka9q_ubersdr web SDR interface allows an attacker who can post a chat message to execute arbitrary JavaScript in the browsers of every other user who later views that channel in ka9q_ubersdr before 0.1.58. The linkifier that turns chat URLs into anchors does not neutralize quotation characters, so a crafted URL escapes the generated href attribute and injects attacker-controlled HTML attributes; because the payload is persisted server-side and executes on rendering, no click by the victim is required (the assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:N, matching the published 5.4 severity). Impact is limited to client-side script execution in viewers' browsers rather than server compromise, and no public exploit code has been identified at time of analysis, although the public fix commit (6aa858da1c030cae11b94c7d6c72322adb9ec60d, PR #114) does document the exact vulnerable pattern.
Unauthenticated remote attackers can bypass route-based access control rules in tinyauth deployments running versions before 5.1.3 by appending a string that matches an allowed route to a restricted path, because the underlying authorization regex is not anchored. The flaw is remotely reachable wherever tinyauth fronts an application and requires no credentials or user interaction, though exploitation depends on the attacker knowing or inferring the allowed route patterns (CVSS 3.1 base 5.4, AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N). No public exploit identified at time of analysis, and the vendor has released a fix in 5.1.3 per advisory GHSA-r27r-rr9v-vv37.
Stored cross-site scripting in Apache Roller 6.1.5 allows an authenticated user with media-upload rights to store active content on Roller's origin, which executes when a victim opens the uploaded file. Exploitation is constrained: the media-upload feature is disabled by default, so only non-default installations that enable it are exposed, and the attacker must already hold upload privileges while the victim must actively open the file. No public exploit identified at time of analysis; this is a genuine but low-priority issue given the non-default configuration and required victim interaction.
Directory traversal in Input Leap through 3.0.3 allows a connected peer to send a crafted DDRG drag-and-drop protocol message that escapes the intended drop directory on Windows and macOS, writing attacker-controlled files anywhere the Input Leap process has write access - including startup directories, which yields code execution the next time the victim logs in or reboots. The flaw only manifests when the non-default --enable-drag-drop option is explicitly enabled and only against Windows or macOS targets; delivery requires the attacker to act as an authorized/connected peer (PR:L per the assessed vector, which the vendor vector agrees on). No public exploit code or confirmed active exploitation was identified at time of analysis, and while the vendor score is 5.3 (C:N/I:H/A:N), our independent assessment raises the impact ceiling to C:H/I:H/A:H - this is a high-ceiling but low-risk-in-practice issue because of the non-default prerequisite, the platform restriction, and the delayed, login-dependent execution path.
Reflected cross-site scripting in APSL Puput v1.2.1 through v2.2.0 lets an authenticated user holding Wagtail Editor privileges inject a crafted payload through the EntryAbstract.save() blog-entry editing path, which then executes in a victim's browser when the affected content is viewed. The impact is script execution in the victim's session context (CVSS 3.1 base 6.1, scope-changed, confidentiality and integrity low, availability none), enabling session or credential theft, CMS action forgery, and content defacement rather than direct server-side code execution. Risk is bounded: exploitation requires an existing editor account and victim interaction, and there is no public exploit identified at time of analysis and no CISA KEV listing; EPSS is 0.15 percent (4th percentile), reflecting a low predicted likelihood of exploitation.
Stored cross-site scripting (XSS) in Apache Roller 6.1.5 allows an authenticated user with authoring rights to inject persistent script into the blog authoring UI, which executes in another author's or administrator's browser when they open the affected page. Exploitation requires a shared weblog with multiple authors or administrators who are not mutually trusted and victim interaction (opening the authoring UI), but no optional feature or non-default configuration is needed. No public exploit identified at time of analysis; the issue is rated medium severity (CVSS 5.4).
Improper URL sanitization in Zammad's inbound-email/ticket HTML scrubber lets an attacker embed traversal-laden <img src> or srcset URLs that survive the remote-URL check; when an authenticated agent simply views the message, the browser resolves the URL to a same-origin Zammad API endpoint and issues the request with the agent's session cookie, producing disruptive state changes such as forced logout with no further interaction. The attacker needs no Zammad account (the payload is delivered as ordinary inbound email or ticket content), but the effect only triggers on agent view (UI:P) and is confined to low-integrity/low-availability same-origin calls rather than data exfiltration. Exploitation status: no public exploit identified at time of analysis; a vendor-released patch is available in Zammad 7.1.2.
Information disclosure in Zammad lets any sender capable of emailing a helpdesk instance embed an arbitrary external URL in the srcset attribute of an image, so that the agent's browser silently fetches attacker-controlled content the moment the ticket is viewed. Zammad's HtmlSanitizer::Strict blocked external URLs in the src attribute but left the equally allowlisted srcset attribute unchecked, leaking the agent's IP address, User-Agent, Referer and the precise viewing time to the sender. All releases before 7.0.2, and 7.1.x releases before 7.1.0, are affected; fixes are available in 7.0.2 and 7.1.0, and no public exploit code was identified at time of analysis. The impact is a privacy/tracking leak rather than code execution or data theft, and it depends on an agent actually opening the crafted ticket in a browser that honours srcset.
Server-side request forgery in Zammad (versions prior to 7.0.2) lets a user who controls their own profile at a connected federated identity provider (OAuth, OIDC, or SAML) make the helpdesk server issue outbound HTTP requests to attacker-chosen addresses, including internal network locations, by supplying a crafted profile image URL. Because the fetch is blind, the attacker infers internal reachability only from differences in response timing and error patterns, and each probe can block a worker process for several seconds, producing a minor availability side effect. No public exploit code has been identified at time of analysis, and the issue is not confirmed as actively exploited; exploitation requires a non-default deployment where federated login is configured and the attacker can edit their provider-side profile image URL. Fixed in Zammad 7.0.2.
Cross-site scripting in the Wikimedia MediaWiki UploadWizard extension allows attackers to inject script that executes in the browser session of a user interacting with crafted upload-flow content. The flaw is present in all versions of the extension prior to 1.46.1, 1.45.5, and 1.43.10, and the CVSS 4.0 vector confirms no privileges are required to introduce the payload (PR:N) while successful execution depends on victim interaction (UI:P), so exploitation yields low confidentiality and integrity impact scoped to the affected component. A vendor-released patch is available via the linked Wikimedia Gerrit change and Phabricator task, and no public exploit code or confirmed active exploitation has been identified at the time of analysis; the assessed CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N) makes this a genuine but low-priority issue.
Cross-site scripting (XSS) in the Wikibase extension for MediaWiki allows unauthenticated remote attackers to inject malicious scripts into wiki pages, which execute when a victim views the affected content. The flaw affects Wikibase versions prior to 1.46.1, 1.45.5, and 1.43.10; exploitation requires user interaction and yields low confidentiality/integrity impact limited to the victim's browser session. No public exploit code or active exploitation has been identified at time of analysis.
Broken access control in Zammad's GraphQL API allows an authenticated user to read taskbar item data - transient session state that can include auto-saved ticket drafts - belonging to another user by supplying that user's taskbar identifier. The flaw affects Zammad versions prior to 7.0.2 and was addressed upstream in the 7.0.2 release, which adds the missing authorization checks. Exploitation requires a valid low-privilege account (authenticated) plus knowledge or enumeration of the target taskbar item ID; there is no public exploit code identified at time of analysis, and impact is limited to a single victim's taskbar item per request.
The Wikipedia Android App's cookie manager could release Wikimedia CentralAuth session cookies to an attacker-controlled domain, exposing logged-in users' session tokens to interception and reuse. The flaw sits in the app's SharedPreferenceCookieManager, which matched cookie domains with a loose suffix check (`domain.endsWith(domainSpec)`) and did not require both the request domain and the cookie's stored domain to be genuine Wikimedia authorities, so a lookalike host such as a domain ending in wikipedia.org could match an approved suffix. Exploitation is not zero-click: it requires the target to be authenticated (holding CentralAuth cookies) and to be induced into making the app request the attacker's domain, which is why the vendor scores it 5.3 (medium) and our independent assessment lands at CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N; no public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and the underlying logic is fixed by upstream pull request 6768.
Information disclosure in the Zammad helpdesk/customer support system versions prior to 7.1.2 allows a remote, unauthenticated party to embed a tracking pixel that evades the built-in HTML sanitizer, so that when an agent views the crafted ticket or email the recipient's browser silently loads an external image and leaks read-receipt metadata such as when and by whom the ticket was opened. Exploitation requires the recipient to open the article in a browser (CVSS 4.0 base score 5.3; independently assessed as CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N), and impact is bounded to open-time and viewer-fingerprint disclosure rather than ticket contents, credentials, or code execution. No public exploit code has been identified at time of analysis and the CVE is not in CISA KEV; the vendor-released fix is version 7.1.2.
Missing authorization checks in the MediaWiki Translate extension let any logged-in user with network access invoke translation-management functionality that should have been constrained by ACLs, affecting installations running versions prior to 1.46.1, 1.45.5, and 1.43.10. The impact is confined to integrity - an authenticated low-privilege attacker cannot read protected data or cause a denial of service - giving a CVSS 3.1 base score of 5.3, and no public exploit code has been identified at time of analysis. Exploitation requires a valid registered account on a wiki where the Translate extension is enabled, so exposure is limited to those deployments.
Authenticated users of the Zammad helpdesk platform prior to 7.1.2 can read the tag names assigned to any ticket, including tickets they are not authorized to view, because the tag-list/autocomplete endpoint enforced no ticket-scoped authorization. Any account that can authenticate - including low-privilege customers or limited agents - can query the endpoint and, since ticket IDs are sequential integers, enumerate ticket tags in bulk to infer internal categorization and potentially sensitive labels. The exposure is confidentiality-only (no data modification or denial of service), no public exploit code has been identified at time of analysis, and the flaw is fully corrected in Zammad 7.1.2, where the endpoint is restricted to ticket.agent, admin.tag, and knowledge_base.editor permissions.
Prototype pollution in React Native Worklets versions before 0.12.2 allows unauthenticated remote attackers to trigger a denial of service by supplying a crafted object with a __proto__ property through the Worklets serialization path, causing the React Native application to crash. The flaw exists in clonePlainJSObject and the native SerializableObject serialization, where the __proto__ key modifies the prototype of a cloned object instead of being treated as an own property. No public exploit code or confirmed active exploitation has been identified, but if the malformed data is persisted, the denial of service can persist across application restarts.
Stored cross-site scripting in the Zammad helpdesk admin UI (all versions prior to 7.1.2) lets an authenticated attacker inject arbitrary HTML and JavaScript through unsanitized option labels that are rendered as raw HTML in the object-attribute / AI Agent options configuration dialog; the payload executes in the browser of any admin or agent who subsequently opens the affected configuration view. Exploitation requires the attacker to control a rendered label - for example by setting a malicious user or organization name that is later used as a relation-attribute label, or by supplying a crafted custom attribute option value - and then depends on a privileged victim opening that view. Zammad 7.1.2 fixes the flaw; no public exploit code and no confirmed active exploitation were identified at time of analysis (CVSS 5.3, no CISA KEV listing).
Unauthenticated log injection in InvoicePlane (all versions prior to 1.7.2) allows remote attackers to forge entries in the application's error log by supplying a crafted cron_key value containing CRLF characters to the Cron::recur() endpoint. Because the invalid key is reflected straight into log_message('error', ...) without neutralization, an attacker can insert arbitrary fake log lines, corrupting the audit trail and potentially misleading log-based monitoring or forensic analysis. There is no public exploit identified at time of analysis and the vulnerability is not confirmed actively exploited; impact is limited to log integrity (CVSS 5.3, C:N/I:L/A:N) with no data disclosure, code execution, or denial of service, though the EPSS signal is not available and the issue was addressed in the 1.7.2 release.
An improper PGP signature verification flaw in Zammad 7.0.3 and 7.1.1 lets a remote, unauthenticated sender have an inbound email article saved with a successful 'Good signature' status even though the displayed message body is not actually covered by that signature, misleading agents who trust the indicator. Exploitation requires the inbound PGP secure-mailing feature to be configured with a registered/trusted sender key and possession of a genuine opaque ('-----BEGIN PGP MESSAGE-----') signed message from that sender, which is replayed while the displayed body is swapped; an agent must open the article and rely on the signature indicator (UI:R). The impact is limited to integrity of the displayed content, not confidentiality or availability, and no public exploit has been identified at time of analysis. Zammad fixed the issue in version 7.1.2.
Session-termination vulnerability in Zammad helpdesk/customer-support deployments running versions prior to 7.0.2: the HTML sanitizer fails to strip same-origin Zammad API paths from <img> src and srcset attributes, so crafted ticket HTML can reference endpoints such as /api/v1/signout, /api/v1/sessions/switch/N, /api/v1/sessions/switch_back, or /api/v1/getting_started/auto_wizard/<token>, causing the viewing agent's session to be terminated or switched when the ticket is rendered. The attack is unauthenticated per the CVSS 4.0 vector (PR:N) and can be delivered via inbound-email-created tickets, but it requires a second user to view the crafted ticket (UI:P) and is bounded to session availability with no data disclosure or code execution. CVSS 4.0 scores it 5.3 (MEDIUM) and an independent assessment rates it CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L; no public exploit code or CISA KEV entry was identified at time of analysis, and the vendor released 7.0.2 with an allowlist restricting /api/ image sources to attachment endpoints.
Authenticated users holding the Author role on Bludit CMS through 3.22.0 can enumerate and delete media files attached to pages owned by other users, including administrators, by passing arbitrary uuid values to the unprotected content-get-list, list-images, and delete-image AJAX endpoints in bl-kernel/ajax/, which defeats the IMAGE_RESTRICT per-user media isolation control. The issue is a CWE-639 authorization bypass through a user-controlled key, rated CVSS v3.1 5.3 (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N) and CVSS v4.0 5.3 (PR:L, VC:L, VI:L, VA:N) - a genuine but moderate-severity issue whose principal limiting factor is the need for a valid low-privileged login. No public exploit identified at time of analysis, and no confirmed actively exploited (CISA KEV) status applies.
Mass assignment in Bludit CMS 3.22.0 and earlier lets an authenticated user holding the low-privileged Author role tamper with page metadata that should be reserved for administrators. Because Pages::edit() in bl-kernel/pages.class.php writes every field listed in dbFields without per-field authorization, an Author can slip extra parameters such as 'type' and 'username' into an ordinary content-save request to convert a page into a static, site-wide navigation entry or reassign ownership of a page to an arbitrary account. The issue only matters on installations that hand Author-level accounts to untrusted users; it yields integrity-only impact with no confidentiality or availability effect and no code execution, and no public exploit code or confirmed active exploitation was identified at time of analysis (CVE-2026-93364, reported by VulnCheck, CWE-915).
Linux kernel TIPC link-management code can leak uninitialized kernel memory to a remote peer because the interface name was copied with strcpy() into a fixed TIPC_MAX_IF_NAME buffer inside RESET/ACTIVATE link-protocol messages, leaving the trailing bytes of that field filled with whatever was previously in the skb. Only systems running the TIPC (Transparent Inter-Process Communication) subsystem and actively establishing links are exposed, and the attacker must be positioned as (or beside) a TIPC peer on the cluster network; the impact is limited to disclosure of a small, non-controllable set of padding bytes (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N, 5.3). EPSS is 0.18% (7th percentile), the issue is not in CISA KEV, and no public exploit has been identified at time of analysis; vendor patches are available in the listed stable branches.
RustDesk before 1.5.0 on Linux and macOS fails to enforce its own file-transfer permission setting in the Cliprdr clipboard message handler, so an already-connected, authenticated peer whose file-transfer rights have been disabled can still push files onto the host's clipboard and pull back files and clipboard contents from the process-wide clipboard cache. Exploitation is network-reachable but session-gated: the attacker must first hold an authorized peer connection to the target host (CVSS 4.0 base 5.3, PR:L, C:L/I:L per the assessed vector), making this an escalation of an existing restricted session rather than an unauthenticated entry point. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; a vendor patch is available from the upstream RustDesk project.
Authenticated users who lack a collection's access permissions can still push files into that collection in Payload CMS deployments using the @payloadcms/storage-vercel-blob storage adapter, because the adapter's client-upload route is reachable directly and does not re-enforce collection-level authorization. Exploitation requires a valid Payload account (CVSS PR:L) on an installation where the client-upload feature is enabled and reachable, and the resulting impact is limited to unauthorized file uploads (integrity only - no confidentiality or availability loss, assessed CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N, medium severity). This is a genuine but bounded authorization flaw rather than a high-priority emergency: there is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, and the vendor has published advisory GHSA-mc8m-rr6c-r5qr.
Broken access control in GLPI's knowledge-base comment and translation handling lets any authenticated low-privilege user create, update, or delete comments and translations attached to knowledge base items they are not authorized to modify. The affected endpoints (front/knowbaseitem_comment.form.php and front/knowbaseitemtranslation.form.php) perform no per-item permission check, so a valid session with minimal rights is enough; no user interaction, elevated role, or unusual configuration is required, though an account is mandatory and the impact is limited to the integrity of KB comment/translation records (no disclosure, no code execution, no availability loss). The issue is fixed in GLPI 11.0.8 and 10.0.26; no public exploit code and no confirmed active exploitation were identified at time of analysis, and CVSS 5.3 reflects a low-to-moderate-priority flaw rather than a high-severity one.
Authenticated GLPI users who lack configuration-update privileges can enable the application's debug mode on versions 0.72 through 10.0.25 and 11.0.0 through 11.0.7 by injecting a use_mode parameter into the user-setting update endpoint, which pre-patch code failed to gate behind the Config::canUpdate() check. Successful abuse exposes debug-level diagnostic output that a legitimate low-privilege account should not be able to trigger, resulting in limited confidentiality impact; the flaw does not allow data modification or code execution. No public exploit code has been identified at time of analysis and there is no indication of active exploitation, though a vendor fix is available in GLPI 10.0.26 and 11.0.8. NVD rates the issue 5.3 (CVSS 4.0), and the independent assessment concurs that this is a low-to-moderate authorization weakness given the mandatory authentication prerequisite and confined information-exposure impact.
Unauthenticated attackers can overwrite the name, email, phone, and address of any existing customer record in the Bookly WordPress plugin (Online Scheduling and Appointment Booking System - Bookly, all versions up to and including 28.2), hijacking that customer's booking notifications. The flaw is a PHP type-juggling authorization bypass: the plugin compares a session-stored one-time verification code against the attacker-supplied verification_code using a loose != operator, and because the booking AJAX controller registers its methods as wp_ajax_nopriv_ handlers and unconditionally forces csrfTokenValid() to return true, the endpoint is both unauthenticated and CSRF-unprotected. Submitting the JSON boolean true as the verification_code through the json_data channel - which json_decode() passes through with its real PHP type intact so that wp_kses leaves it untouched - satisfies the loose comparison against the non-zero integer code and bypasses the phone/email ownership check. Severity is moderate (CVSS 5.3, integrity-only impact); no public exploit code has been identified at time of analysis and there is no confirmed active exploitation.
Deserialization of untrusted data in the LangChain4j-agentic module's AgenticScopeSerializer.fromJson path allows an attacker who can already write to an AgenticScope persistence store to trigger arbitrary class instantiation through Jackson's insecure default typing. Affected versions are the 1.5.3, 1.11.10 and 1.18.1 beta lines up to and including 1.5.3-beta10, 1.11.10-beta18 and 1.18.1-beta27, with fixes released in 1.5.3-beta11, 1.11.10-beta19 and 1.18.1-beta28 under advisory GHSA-gmwr-7wmf-mrjm. Publicly available exploit code exists, but effective risk is low: exploitation requires that the application have explicitly enabled AgenticScope persistence (opt-in and off by default) and that the attacker already control the writable backing store, with attack complexity rated high; this issue is not confirmed actively exploited (not in CISA KEV), and EPSS-style scoring is negligible given the reported CVSS base of 2.1.
Missing per-ticket authorization in Zammad's GitHub and GitLab issue-tracker integration endpoints prior to 7.0.2 lets any authenticated agent - including one with no tickets assigned - enumerate ticket IDs and read the titles, statuses, labels, and URLs of external GitHub/GitLab issues linked to tickets they are not permitted to see. The flaw carries CVSS 5.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N), reflecting a low-confidentiality-impact disclosure confined to authenticated internal users, and yields nothing on instances where the GitHub/GitLab integration is not configured or no tickets carry linked issues. No public exploit code or active exploitation has been identified at time of analysis; the vendor shipped Zammad 7.0.2 as the fix.
Zammad helpdesk versions prior to 7.1.2 let an authenticated channel administrator read attachments outside their authorized groups by embedding an existing attachment ID in an email signature. The signature processor copies the referenced attachment into a signature-owned record and then serves it based on the copy's ownership rather than the original ticket or knowledge-base object, creating an authorization bypass (CWE-639). The vendor fixed this in 7.1.2; exploitation requires one of the channel-admin permissions and no public exploit code has been identified at time of analysis.
Incomplete masking of Microsoft Graph bearer tokens in Zammad's HTTP log allows an authenticated Zammad administrator with Microsoft Graph channel access to read the payload and signature segments of a still-valid mailbox access token from stored log entries, exposing sensitive JWT claims such as account scope, tenant and timing that could assist in reconstructing the full token while it remains valid. Only Zammad deployments older than 7.1.2 that use a Microsoft Graph email channel and that have recorded a failed Graph API request are affected; the flaw is gated by high administrative privilege and is not remotely reachable by unauthenticated users, and no public exploit identified at time of analysis. The vendor-released patch is Zammad 7.1.2, and independent assessment rates this as a low-severity information-disclosure issue consistent with the CVSS 4.0 score of 5.1.