Denial of service in Zapros prior to 0.14.0 allows a malicious or compromised server, or a redirect target, to exhaust resources by returning a response with an excessive number of chained Content-Encoding values, forcing Zapros to construct a deeply nested decompression chain. The vulnerability affects applications that fetch content from untrusted servers or follow redirects to them using unpatched Zapros; no public exploit is identified at time of analysis. The CVSS 4.0 vector indicates network-based, unauthenticated exploitation with only low availability impact (score 6.9), making this a moderate-severity availability issue rather than a high-priority emergency.
Unauthenticated attackers can defeat three login protections in MISP (Malware Information Sharing Platform) versions below 2.5.47 by sending authentication requests over HTTP methods other than POST or PUT: the brute-force blocklist and attempt counter are skipped, the email one-time-password (OTP) second factor is not enforced, and login failures are neither logged nor counted. Per the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:N), successful exploitation yields limited confidentiality and integrity impact rather than direct system access - an attacker gains unlimited, unlogged credential-guessing attempts against the login endpoint with MFA effectively disabled, so the practical outcome is credential compromise and subsequent unauthorized access to the MISP instance. This is a genuine but moderate-severity control-bypass rather than a direct-access vulnerability; no confirmed active exploitation (CISA KEV) and no public exploit code were identified at time of analysis, and a vendor fix is available.
Server-side request forgery in self-hosted draw.io deployments prior to 30.2.7 allows unauthenticated remote attackers to make the server fetch attacker-chosen URLs that resolve to private, link-local, or cloud-metadata addresses, returning internal HTTP responses or instance metadata through the image proxy. The flaw only exists when the server is started with ENABLE_DRAWIO_PROXY=1; the SaaS and desktop editions and default installs are unaffected. Successful exploitation depends on a DNS-rebinding timing race (the hostname must resolve to a public address during validation and to an internal address at connection time), which is why the assessed severity is 6.8 with AC:H rather than a high-severity rating; there is no public exploit code identified at time of analysis and the issue is not in CISA KEV. Vendor-released patch: 30.2.7.
Information disclosure in nvm versions before 0.40.8 allows a local attacker who controls a repository to read arbitrary files readable by the invoking user when the developer runs `nvm use`, `nvm install`, or `nvm which` with a crafted `.nvmrc`, or when the user manually runs `nvm alias` with a traversing name. The path traversal in alias resolution causes nvm to print non-comment lines from the opened file in an error message; the automated `.nvmrc` route exposes only the first non-comment/non-empty line, while the manual `nvm alias` route can expose all such lines. No public exploit code or active exploitation has been identified at time of analysis, and the vendor addressed the issue in nvm 0.40.8.
Memory exhaustion in KubeEdge CloudHub (versions 1.0.0 through 1.21.1, 1.22.0 through 1.22.1, and 1.23.0) allows an authenticated, enrolled edge peer to terminate the cloud-side process or drive it into a restart loop by sending crafted viaduct frames whose 32-bit PackageHeader.PayloadLen declares a far larger payload than the frame contains. Impact is availability-only - no confidentiality or integrity loss and no code execution, which contradicts the single 'RCE' tag attached to the advisory; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H (6.5). There is no public exploit identified at time of analysis, and exploitation requires a valid edge-node credential or an established viaduct connection from a compromised node.
Broken object-level authorization in InvenTree prior to 1.4.0 allows any authenticated low-privilege user - or any holder of an API token with only a general read scope - to retrieve the full serializer output for arbitrary records by posting a crafted internal JSON barcode to /api/barcode/. Because the barcode endpoint authenticates the caller but never checks the caller's per-model view role, an attacker can enumerate integer primary keys for parts, stock items, stock locations, supplier and manufacturer parts, purchase/sales orders, and builds, disclosing commercially sensitive inventory, pricing, supplier, customer, and order data. The vendor rates this CVSS 3.1 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), confirming a network-reachable, read-only confidentiality impact that requires valid low-privilege credentials; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV.
InvenTree versions prior to 1.4.0 render report and label templates with WeasyPrint's default URL fetcher, so an authenticated staff user who can author templates can make the server fetch attacker-chosen resources over http/https or read local files through the file:// scheme and later recover the fetched bytes from the stored PDF attachment. This yields full-read server-side request forgery, local file disclosure (potentially including application credentials), and in the worst case compromise of a superuser account. The issue is access-gated and not a broad internet-facing threat: it requires staff-level template-authoring privileges (CVSS 3.1 AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:L/A:N, base 6.5) plus the ability to retrieve the generated attachment, and no public exploit has been identified at time of analysis. A vendor-released fix is available in InvenTree 1.4.0.
Presence metadata disclosure in Supabase Realtime before 2.111.2 lets an authenticated WebSocket client on a private channel receive presence_diff messages containing other members' application-defined presence state - location, online-status, roster, viewing or typing data - even when that channel's per-extension row-level security policy explicitly denies presence.read while still granting presence.write. The defect is an authorization-logic error (CWE-863) in how presence diffs were dispatched past the read policy; it is tightly gated by a non-default asymmetric policy configuration, and there is no public exploit identified at time of analysis, no CISA KEV listing, and no EPSS score supplied. The vendor's CVSS 6.5 (C:H) likely overstates confidentiality impact, since disclosure is confined to presence metadata and postgres_changes row data is explicitly unaffected, which argues for C:L.
Authenticated Chartbrew users with access to the AI chart-generation feature can execute dangerous SQL statements and database functions that the application's read-only filter fails to block, because versions prior to 5.2.2 relied on a blocklist covering only seven keywords (DROP, DELETE, UPDATE, INSERT, TRUNCATE, ALTER, CREATE). Depending on the database engine, its configuration, and the privileges of the configured connection user, this can result in file read/write, outbound network access from the database server, privilege changes, command execution, or data modification - the independent assessment rates it CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:L, reflecting high confidentiality and integrity impact to the connected database with scope change. Exploitation requires a valid Chartbrew account on a team with the AI feature enabled and configured against a postgres, mysql, or clickhouse connection; no public exploit code was identified at time of analysis and there is no CISA KEV listing, making this an access-gated issue rather than a mass-exploitation emergency.
Authenticated denial of service in the FalkorDB Redis module versions 4.20.1 through 4.20.4 allows a user with query access to crash the database process by submitting a crafted graph query that reaches the aggregation code path handling GROUP operations. The flaw is a stack overflow in the _GetGroup() function in /ops/op_aggregate.c, scored CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H), meaning low-complexity remote exploitation but requiring prior authentication (PR:L), with impact limited to availability and no confirmed data exposure or code execution. There is no public exploit identified at time of analysis and no confirmed vendor patch version in the provided references, so exposure is bounded by who can reach the query interface and by the narrow 4.20.1-4.20.4 version window.
Authenticated administrative users of web2py 3.2.2-stable (commit a7330a2bf21219fa77860b6665de927dd4f98e6d) can abuse the read_file() and write_file() endpoints in the admin application's webservices controller to traverse outside the intended web2py directory and read or overwrite arbitrary files on the host. Because those endpoints sit behind the admin interface password, exploitation requires high privileges (CVSS 3.1 AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:N, base 6.5) and depends on the admin app being enabled and network-reachable, which hardened deployments often prevent by binding it to localhost, disabling it, or fronting it with additional authentication. No public exploit code has been identified at time of analysis and the flaw is not on CISA KEV; EPSS is low at 0.22% (13th percentile), so exploitation is currently assessed as opportunistic rather than widespread.
Broken authorization in MaxKB 2.7.0 through 2.10.4-lts lets an attacker who holds any valid chat token turn a victim's private conversation into a public ChatShareLink and create PublicFileAccess state that makes associated files retrievable without credentials. The POST /chat/api/{application_id}/chat/{chat_id}/share_chat handler verifies only that the conversation exists, never that it belongs to the caller's chat_user_id or to the application bound to the caller's token (CWE-285), and the exposure cannot be undone through the product because there is no revoke path. No public exploit identified at time of analysis and no vendor-released patch exists as of this review; the assessed CVSS 3.1 base score is 6.5 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N), with high attack complexity reflecting the need to know a specific, generally non-enumerable victim chat_id rather than any weakness in the request itself.
Unauthenticated shortcode injection in the GiveWP WordPress donation plugin before version 4.16.9 lets any site visitor submit nested shortcode delimiters through a public donation form, causing the site to execute arbitrary registered shortcodes when the donor-supplied value is rendered. Real-world impact is bounded by which shortcodes are registered on the target: a site with only benign shortcodes suffers little, while one exposing sensitive or administrative shortcodes could face data exposure or content manipulation. No public exploit code identified at time of analysis and the issue is not in CISA KEV; severity is moderate (CVSS 6.5, unauthenticated, no user interaction).
Server-side request forgery in NocoBase v2.1.21 lets an authenticated, low-privilege user drive the server's serverRequest function to issue outbound HTTP requests to arbitrary destinations, enabling internal reachability scanning and probing of services that are not exposed externally. Because exploitation requires a valid low-privilege account (per the CVSS vector PR:L) and the value of the attack depends on the NocoBase host having network access to internal-only resources, the practical impact is internal reconnaissance and reachability enumeration, with fuller information disclosure only where serverRequest returns response bodies to the caller. No public exploit code has been identified at time of analysis, the issue is not in CISA KEV, and EPSS is low (0.18%, 8th percentile), so near-term mass exploitation is unlikely; the vendor scored this 6.5 (C:H) while our independent assessment rates confidentiality impact lower (5.0, C:L).
An insecure direct object reference (CWE-639) in Joplin Server's GET /items/:id/content route lets any authenticated user read notes and items belonging to other users by supplying a guessed or obtained internal item ID, because the handler loads content without verifying ownership. Only Joplin Server deployments (the multi-user self-hosted sync backend, not the desktop or mobile clients) running versions prior to 3.7.2 are affected, and confidentiality is only lost for items not protected by end-to-end encryption - with E2EE enabled the response body is ciphertext. The issue carries a CVSS 3.1 score of 6.5 (Medium, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N); no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor-released fix landed in version 3.7.2.
Command injection in the Feiyu Star Router web management CGI (/send_order.cgi?parameter=del_expmac) lets an attacker who already holds an authenticated router-administration session execute arbitrary shell commands on the device by embedding shell metacharacters in the 'mac' argument; the flaw is confined to firmware build B-MB5E202-210322-r11656 from Chengdu Feiyuxing Technology. The vendor was contacted early but never responded, so no official fix has been published, and publicly available exploit code exists for the affected endpoint. Because exploitation requires admin-level access (CVSS PR:H), risk is real but access-gated: the practical priority is moderate, driven mainly by the prevalence of default or weak credentials on SOHO router management interfaces rather than by any unauthenticated attack path.
Authenticated users with editor (write) rights on at least one event in MISP can reparent an event report belonging to a different event by supplying that report's UUID during report creation or editing, because EventReport::editReport() matched existing rows by UUID without verifying the report's event_id matched the target event. Successful exploitation lets the attacker read and modify private reports they were never authorized to access, though impact is confined to report objects rather than the full instance dataset and the attacker must already know or guess the high-entropy UUID - a barrier that prevents enumeration or automated abuse. Affected versions are MISP before 2.5.47; no public exploit code or confirmed active exploitation was identified at time of analysis.
MaxKB releases prior to 2.10.6-lts allow an authenticated workspace member who can author and run function-library (tool) code to escape the built-in LD_PRELOAD syscall sandbox and act with the sandbox OS user's privileges, reading or writing files, spawning processes, and reaching networks that the sandbox was meant to block. The escape works because the sandbox's dlopen guard relied on a call-stack heuristic that can be satisfied from an importlib.abc.MetaPathFinder callback while loading ctypes, after which the real glibc syscall can be resolved with dlsym/RTLD_NEXT and invoked outside the interception layer. This is a protection-mechanism failure (CWE-693) rather than conventional unauthenticated RCE; the vendor-published score is 6.3, but the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H because once the sandbox is defeated the escaped user's file, process, and network access is fully available. No public exploit was identified at time of analysis, and the issue is fixed in 2.10.6-lts.
An authenticated attacker with the ability to execute tool code inside MaxKB (1Panel-dev) deployments running versions prior to 2.10.6-lts can break out of the ToolExecutor subprocess sandbox and start processes that the sandbox is supposed to forbid. The escape exists because the LD_PRELOAD shim in installer/sandbox.c intercepts execve, execvpe and execveat but never hooks fexecve, leaving a gap a local tool-code executer can drive; impact is scored as limited confidentiality, integrity and availability loss (CVSS 3.1 6.3, AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L), and it is a defense-in-depth bypass rather than an initial-access vector, meaning the attacker must already have authenticated access and a code-executing tool/agent feature exposed. No public exploit code identified at time of analysis, and there is no KEV listing; the vendor has released a fix in 2.10.6-lts.
Outbound request validation bypass via DNS rebinding in Chartbrew before 5.2.2 allows an authenticated user who can create or test API/data-source connections, and who controls DNS for the target hostname, to make the server reach internal services, localhost resources, or cloud metadata endpoints. The server validates the hostname with validateOutboundUrl() but the actual connection is performed by request-promise using an independent DNS lookup, so a public address can be returned during validation and a private address during the request. No public exploit identified at time of analysis; exploitation requires a credentialed account and attacker-controlled DNS plus winning the race between the two lookups, so real-world risk is moderate rather than high.
Graylog's saved-search and dashboard update API allows an authenticated user who holds edit permission on a view - but not ownership of it - to escalate to owner by attaching a crafted shareRequest to the update call, then use that ownership to delete the view or revoke the legitimate owner's access. Affected releases are Graylog 6.3.0 through 6.3.13, 7.0.0 through 7.0.8, and 7.1.0 through 7.1.3; Graylog Cloud customers were patched before the advisory was published. The flaw is rated CVSS 3.1 6.3 (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L), meaning it requires a low-privileged authenticated session, needs no user interaction, and is bounded to low confidentiality, integrity, and availability impact; no public exploit code identified at time of analysis and no confirmed active exploitation.
Hatchet deployments prior to 0.91.1 expose a cross-tenant insecure direct object reference (IDOR) on the durable-task event log endpoint, allowing an authenticated user who already knows another tenant's durable-task UUID to read that task's full event log. Successful abuse discloses task display names, workflow identifiers, user messages, wait conditions, branching logic, and timing metadata - a confidentiality-only impact with no integrity or availability effect. Exploitation requires valid Hatchet credentials (PR:L) plus prior out-of-band knowledge of a 128-bit UUID from a foreign tenant (AC:H), so this is a genuine but moderate-severity authorization flaw rather than a critical drop-everything issue; it is not confirmed as actively exploited (CISA KEV) and no public exploit code has been identified at time of analysis.
Command injection in the Feiyu Star Router (Chengdu Feiyuxing Technology, firmware build B-MB5E202-210322-r11656) lets an attacker who can reach the device's web management interface run arbitrary commands on the underlying operating system by manipulating the session_id cookie handled by /send_order.cgi?parameter=loginout. Publicly available exploit code exists, giving attackers a ready reference implementation, while the vendor did not respond to the disclosure, so no vendor-released patch has been identified at time of analysis. The vendor's CVSS 4.0 base score of 5.3 is internally inconsistent with the flaw class; an independent assessment rates it CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, meaning a low-privilege authenticated attacker over the network can achieve high confidentiality, integrity and availability impact on the device, with the practical caveat that the management interface is normally LAN-facing and default or weak consumer credentials frequently make the PR:L prerequisite trivial to satisfy.
Missing authorization in MISP allows an authenticated user who is not a site administrator - but who already holds legitimate view access to an event - to enumerate attributes, object details and related object data inside that event that are restricted to other sharing groups or higher distribution levels, by abusing the object-reference 'add' workflow that validated only event-level access. The assessed impact is confidentiality-only (CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N; the vendor-published CVSS 4.0 vector scores 6.3), with no integrity or availability effect, and it is bounded by preconditions: valid credentials are required, the target event must actually mix data at different distribution levels, and deployments that do not use sharing groups or distribution segregation have nothing additional to expose. No public exploit identified at time of analysis, no confirmed active exploitation, and a fix is available per the vendor advisory via upstream commit f36634e57.
DOM-based cross-site scripting in the ContextualMenu JavaScript component of MISP (Malware Information Sharing Platform) allows an attacker who can influence the data rendered in the contextual menu - an authenticated low-privilege MISP user or a data-sharing peer feeding values into the UI - to execute script in a victim user's browser within the MISP application origin. The vulnerable code assigns untrusted option text to innerHTML in app/webroot/js/contextual_menu.js, so any string echoed into the menu is parsed as live markup; exploitation requires a victim to actively open the affected contextual menu (PR:L, UI:P) and the resulting impact is bounded to the victim's browser session, enabling session hijacking, data exfiltration, or actions on behalf of the authenticated user. The issue affects MISP versions below 2.5.47 and is fixed by the vendor in 2.5.47 (commit b062698f2); no public exploit code was identified at time of analysis and the CVE is not listed in CISA KEV, with EPSS-style risk driven primarily by the broad MISP deployment base rather than demonstrated active exploitation.
Stored cross-site scripting in the MISP threat-intelligence platform (versions before 2.5.47) lets an authenticated user holding tag-editor privileges plant a crafted misp-galaxy tag whose content is rendered unescaped in the Galaxies index page of the default theme, so it executes in a site administrator's browser session when that page is viewed. Successful exploitation is confined to the administrator's browser context - reading session data and performing actions as the administrator - and does not directly compromise the MISP server process. Exploitation requires authenticated tag-editor access, the default theme (Overmind already HTML-escapes these values and is unaffected), and administrator page-view interaction; no public exploit code has been identified at time of analysis, and EPSS/KEV data are not provided.
Stored cross-site scripting in MISP before 2.5.47 allows an authenticated user holding the perm_galaxy_editor permission to create or modify a galaxy whose name contains arbitrary HTML or JavaScript markup; because the galaxy name is interpolated verbatim via sprintf() into app/View/Users/statistics_galaxymatrix.ctp, the payload executes in the browser of any other user who later opens the galaxy matrix statistics page. Successful exploitation enables session hijacking, credential theft, data exfiltration, or attacker-controlled actions performed within the victim's MISP session, and requires victim interaction (UI:P) since the malicious page must be visited; no public exploit code or confirmed active exploitation was identified at time of analysis, and the flaw is rated medium (CVSS 4.0 6.3). Realistic exposure is limited to multi-user MISP instances where at least one account has galaxy-editing rights and other users consult the statistics view.
Trailing whitespace at the end of a selector string makes Dasel 3.0.0 through 3.11.1 read past the end of its input and panic with an index-out-of-range error, terminating the process - an availability-only denial of service. The trigger is trivially small (dasel query 'a ', or a selector ending in a tab or newline) and is reachable both from the command line and from the Go library entry points dasel.Query and lexer.NewTokenizer(...).Tokenize(), so any embedding application that forwards caller-influenced selector text into Dasel can be crashed. The assessed impact is local and unauthenticated with high availability impact and no confidentiality or integrity effect (CVSS 6.2), no public exploit code was identified at time of analysis, and version 3.11.2 is the fixed release.
Information disclosure in CRMEB Knowledge-Paid System crmeb_zzff_class 1.4.4 allows an attacker to trigger a backend verification function that returns an incorrect value type, causing an error that leaks sensitive information. The assessed vector indicates low-privilege network access (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N), but the true access requirements (local vs. network, authenticated vs. unauthenticated) are not confirmed from available data. No public exploit identified at time of analysis; EPSS is 0.14% (4th percentile), indicating low real-world priority.
Open redirect in ST Engineering iDirect Evolution and Velocity WebServer Evolution (builds up to 20260717) lets remote, unauthenticated attackers craft a link whose manipulated 'Success' argument is processed by the authorize function in /usr/sbin/webserver, causing the victim's browser to be redirected to an attacker-chosen site. Impact is limited to integrity-low on the victim's browsing session - there is no server compromise, data disclosure, or denial of service - and exploitation depends on the victim actively following the crafted link (UI:P). Publicly available exploit code exists (per the VulDB-linked proof-of-concept write-up), but there is no confirmed active exploitation (not in CISA KEV); the vendor was contacted early and did not respond.
Open redirect in ST Engineering iDirect Evolution and Velocity WebServer Evolution (up to version 20260717) allows remote unauthenticated attackers to manipulate the Host argument on /login.html and redirect victims to arbitrary external websites. Exploitation requires user interaction-a victim must click a crafted link-and publicly available exploit code exists, though the vendor did not respond to disclosure. This low-severity issue affects the Management Service, which is typically isolated on satellite operations networks, and the integrity impact is limited to the redirect itself.
Open redirect in WuzhiCMS up to 4.1.0 lets remote attackers redirect users to arbitrary external websites by crafting a link to the member login endpoint (/index.php?m=member&v=Login) with a manipulated forward parameter. The attack requires no authentication and can be launched remotely, but it does require the victim to click the malicious link (UI:P). Publicly available exploit code exists; however, there is no evidence of confirmed active exploitation (CISA KEV) and the impact is limited to integrity (redirecting users), not code execution or data disclosure.
Authorization bypass in Omega Solution FBP Fulfillment by People 2025 allows authenticated low-privilege users to read other users' profile data via the /user/ User Profile API endpoint by manipulating the ID argument. This is a CWE-639 insecure direct object reference, requiring a valid low-privilege account but no user interaction, and results in confidentiality-only disclosure (no integrity or availability impact). Publicly available exploit code exists and the vendor was contacted early but did not respond; there is no CISA KEV listing, and the assessed CVSS 3.1 vector is AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N.
Stored cross-site scripting in draw.io (jgraph/drawio) versions prior to 30.2.5 lets an attacker-crafted .drawio diagram execute JavaScript in the draw.io origin once a victim opens or imports the file and selects the affected cells. The payload survives the earlier CVE-2026-46642 remediation because an HTML sibling cell keeps the formatted-label path enabled while an editable=0 plain-text sibling is excluded from the merged selection style yet remains in the iteration set, so graph.cellRenderer.getLabelValue() returns the label unencoded and mxUtils.canConvertHtmlToSvg() then parses it as HTML. Successful exploitation exposes diagram data, browser storage, non-HttpOnly cookies, and same-origin actions available to the victim; exploitation requires user interaction (opening or importing an untrusted file) and no public exploit code has been identified at time of analysis, with a vendor CVSS of 6.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N).
Reflected cross-site scripting in CuteNews 2.1.2 allows remote unauthenticated attackers to execute arbitrary JavaScript in a victim's browser by luring them to a crafted link whose query-string parameter name - not its value - contains a URL-encoded XSS payload such as "><script>alert(1)</script>, with index.php as the vulnerable entry point. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N = 6.1 Medium) is a textbook reflected-XSS profile: network-reachable, no privileges required, but dependent on victim interaction and limited to script execution in the browser session with no server-side code execution or data compromise. No public exploit code has been identified at time of analysis, and realistic risk is bounded by the required social engineering plus CuteNews's very small deployment base.
DOM-based cross-site scripting in StencilJS core 4.43.5 allows an attacker-controlled string to be parsed as HTML and executed as script in a downstream application's origin, but only when that application has enabled the experimental slot-fixes option, uses scoped components, and writes untrusted data to the textContent property of such a component's host element. The flaw is remotely reachable without credentials (AV:N/PR:N) yet requires victim user interaction (UI:R) and a non-default configuration, and the independent assessment concludes the exposed population is substantially narrower than the raw metrics suggest. No public exploit code or confirmed active exploitation has been identified at time of analysis, and EPSS is 0.14% (4th percentile), indicating low predicted likelihood of exploitation.
Cross-site scripting (XSS) in EMLOG Pro 2.6.29 allows remote attackers to inject malicious scripts into web content, which, when viewed by an authenticated administrator, can lead to the upload of a malicious webshell and potential remote code execution. The vulnerability requires user interaction (UI:R) and a victim with elevated privileges, and exploitation results in a scope change (S:C). With a CVSS score of 6.1 (moderate) and an EPSS score of 0.14% (3rd percentile), no public exploit code has been identified at time of analysis, but the issue is considered a real, lower-priority risk requiring administrator awareness.
Improper control of resource identifiers in Omega Solution HRM OS (versions up to 20260717) allows an authenticated low-privilege user to enumerate the permission mappings of arbitrary roles by manipulating the roleId parameter of the /role-permission/permission endpoint. The outcome is confidentiality-only: role and permission metadata can be read, but no data can be modified and no code can be executed, and the CVSS v4.0 base is only 2.1 (assessed CVSS v3.1 4.3, AV:N/AC:L/PR:L/UI:N/C:L/I:N/A:N). Publicly available exploit code exists (PoC referenced via VulDB and the linked GitHub issue), but there is no confirmed active exploitation (not in CISA KEV); the vendor was contacted early and did not respond, and no vendor-released patch has been identified at time of analysis.
Code injection in RooCMS (versions up to and including 1.2.2, 1.3.4 and 1.4RC2) allows an attacker who holds a privileged content-editing or administrator account to place PHP code into a page's 'content' field, which the frontend renderer passes to eval() in roocms/site_pagePHP.php, resulting in arbitrary PHP execution on the server. The flaw is CWE-94 and is remotely reachable, but exploitation is gated behind high privileges (CVSS:4.0 PR:H / CVSS:3.1 AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), so realistic exposure is limited to insiders or attackers who have already obtained editor credentials rather than an anonymous internet-facing surface. Publicly available exploit code exists (a public proof-of-concept write-up is referenced), the vendor was contacted but did not respond, and no vendor-released patch has been identified at time of analysis.
Missing authorization in Warpgate's admin API allows an authenticated limited administrator who holds any single admin permission to extend an expiring role grant or reinstate a previously revoked one via PUT /@warpgate/admin/api/users/:id/roles/:role_id, bypassing the AdminPermission::AccessRolesAssign check that should gate role-assignment changes. Only Warpgate deployments prior to 0.28.4 on Linux that use delegated/limited admin roles are exposed, and exploitation has a hard precondition: a matching user-and-role assignment must already exist, so an attacker cannot mint a net-new grant and the impact is integrity-only (assessed CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:N). This is a genuine but constrained privilege-boundary flaw rather than an urgent one, and no public exploit identified at time of analysis.
Server-side request forgery in HomeBox prior to 0.26.0 allows an authenticated user with permission to create or test notifiers to reach internal IPv4 destinations that the default BlockBogonNets and BlockCloudMetadata guards are meant to stop, because those guards do not decode IPv4 addresses embedded in NAT64/DNS64 prefixes. Impact is real but conditionally gated: exploitation requires the HomeBox instance's outbound traffic to egress through a NAT64/DNS64 gateway, since without such a gateway the crafted IPv6 destination is unroutable; where present, an attacker can direct the generic:// notifier at cloud metadata or localhost and use the notifier-test response (propagated by Shoutrrr) to read back retrieved data such as temporary credentials. No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; the vendor has released a fix in version 0.26.0.
Envoy Proxy worker processes can be crashed remotely by routine traffic when an upstream cluster is configured with ALPN-based auto protocol selection and HTTP/3 enabled, because ProdClusterManagerFactory::allocateConnPool dereferences transport-socket options without a null check when selecting an HTTP/3 connection pool. The affected code paths are those where the LoadBalancerContext supplies no transport-socket options - synthetic, mirror, health-check and async-client (internal) requests - so any HTTP/3-enabled auto_config deployment that routes through one of these contexts is exposed to a repeatable availability loss; no authentication, user interaction, or unusual client behavior is required (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9, CWE-476). The issue is not reported as actively exploited and no public exploit code has been identified at time of analysis, and the practical impact is gated by the requirement for the specific auto_config-plus-HTTP/3 upstream configuration. Vendor fixes ship in Envoy 1.36.10, 1.37.6, 1.38.4 and 1.39.1.
Stored cross-site scripting in XXL-JOB up to 3.5.0 allows an authenticated user with permission to manage job groups to inject script through the Name parameter of the /jobgroup/insert endpoint, which then executes in the browser of any admin who views the job-group listing. Publicly available exploit code exists (a GitHub proof-of-concept), but there is no evidence of active exploitation (not in CISA KEV), and no fixed version has been released because the vendor did not respond to coordination attempts. The practical risk is moderate: session or token theft, forced admin actions via the victim's browser, and defacement within the admin console, but no direct server-side code execution.
Use-after-free in Envoy's HTTP external-authorization (ext_authz) client crashes the proxy process with a SIGSEGV-class fault when the authorization response is processed after the request callback owner has already been destroyed. Envoy deployments running releases prior to 1.36.10, 1.37.6, 1.38.4, and 1.39.1 that have enabled the HTTP ext_authz filter are affected; per the CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9) an unauthenticated remote client needs only to send traffic that the external authorization service rejects, with triggering gated on a request-rejection-then-stale-callback timing window rather than a single deterministic request. Exploitation is not confirmed actively exploited (no CISA KEV entry) and no public exploit code has been identified at time of analysis; impact is availability-only, with no data exposure or code execution demonstrated.
An out-of-bounds write of up to 895 bytes into static (.bss) memory can be triggered in Zephyr RTOS's Intel SEDI IPM driver (drivers/ipm/ipm_sedi.c) when the peer processor sets a doorbell payload length larger than the 128-byte incoming_data_buf. The vulnerable path is reachable when an application has registered an IPM receive callback via ipm_register_callback(), the driver's normal mode of use, and requires a local, highly privileged attacker (CVSS PR:H) with host-side ISH driver-level or raw BAR access to the device's memory-mapped register window, plus a production image built without CONFIG_DEBUG so the HAL's DBG_CHECK length guard is compiled away. The result is kernel data-structure corruption and a crash primitive - the overflow clobbers the driver context's k_sem and k_mutex and adjacent static data - but the flaw is platform-specific and locally scoped, so it is a moderate, defense-in-depth-relevant issue rather than an urgent internet-facing emergency; no public exploit identified at time of analysis, and an upstream fix commit is available.
Stored cross-site scripting in Leantime (up to and including 3.9.8) lets a low-privileged authenticated user inject HTML/JavaScript that executes in the browser of anyone who later views the affected Kanban, list, or table board. The root cause is the getAllGrouped() grouping-label function in app/Domain/Tickets/Services/Tickets.php, which concatenates user-controlled values such as project names, status labels, ticket types, milestone headlines, and editor names directly into labels that consumers render raw; the maintainers patched it by treating that switch as the escaping boundary (htmlspecialchars with ENT_QUOTES/UTF-8, plus a preg_replace sanitizer for the id used inside inline onclick handlers). Publicly available exploit code exists (a GitHub vulnerability-research write-up), but there is no indication of confirmed active exploitation, and the issue is assessed as moderate severity (CVSS 3.1: AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N) rather than critical, because it requires authenticated low-privileged access and a victim passively viewing the board for the stored payload to fire.
Cross-site scripting in Omega HRM OS up to 20260717 allows an authenticated attacker with high privileges and file-upload permissions to inject malicious SVG files through the /media/view/ endpoint. Publicly available exploit code exists, enabling attacks that execute arbitrary JavaScript in a victim's browser when they view the crafted SVG. This is a low-severity issue due to the high privilege requirement and mandatory user interaction, and no vendor patch is available.
Stored cross-site scripting (XSS) in Leantime 3.9.8 and earlier allows an authenticated user with EDIT permission on a project to plant a malicious status label that executes in the browser of any other user-including project Owners-who views the Project Dashboard. The payload is stored in a project status/label name and echoed without encoding in /app/Domain/Dashboard/Templates/show.blade.php, and it requires a second user to load the dashboard for the script to fire. Publicly available exploit code exists, but the vendor did not respond to the disclosure and no patch has been identified.
SQL injection in Chartbrew versions prior to 5.2.2 allows an authenticated user with access to the AI query orchestrator to smuggle arbitrary SQL into the database by influencing the model-generated row_limit value, which is concatenated into a trailing LIMIT clause after the application's read-only keyword check has already executed. Exploitation is conditional rather than trivial: the attacker cannot pass row_limit directly but must steer the LLM into emitting a non-integer value, and the connected data source must be of type postgres, mysql, or clickhouse for the vulnerable code path to apply. Impact is bounded by the privileges of the database account Chartbrew uses - data can be read or modified, and where that account has file or command privileges, file access or OS command execution becomes possible; no public exploit identified at time of analysis and the CVE is not listed in CISA KEV, with the vendor fix shipping in 5.2.2.
PHP object injection in CuteNews 2.1.2 allows remote attackers to overwrite internal request variables - including __referer - by submitting a base64-encoded serialized PHP payload through the __post_data parameter handled by cn_parse_url(). The flaw is network-reachable and unauthenticated (PR:N) but carries high attack complexity (AC:H) because any impact beyond variable overwrite depends on a usable PHP gadget chain existing in the codebase, and all three impact metrics are rated Low. Risk is tempered by an EPSS score of just 0.23% (14th percentile), no CISA KEV listing, and no public exploit code identified at time of analysis.