Username enumeration is possible against Tinyauth instances running versions before 5.1.0 because the local-user login handler and the HTTP basic-auth middleware return as soon as an account is reported missing, while an existing account triggers a comparatively slow bcrypt password verification, leaving a remotely measurable timing discrepancy (CWE-208). Unauthenticated attackers with network reach to the authentication endpoints can take repeated latency measurements and statistically distinguish valid local usernames from invalid ones; the independent assessment rates this CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N, so the outcome is limited to disclosure of valid usernames with no direct password, session, or data compromise, and exploitation is constrained by network/server jitter requiring many samples. Deployments that authenticate exclusively through external OAuth/OIDC providers and maintain no local users do not exercise the vulnerable bcrypt path, and no public exploit code was identified at time of analysis; the vendor-released fix is version 5.1.0.
Sync-in Server versions prior to 2.4.0 fail to increment the failed-attempt counter when a valid username and password are paired with an incorrect TOTP code on the desktop sync registration endpoint (POST /api/app/sync/register), so the account lockout threshold of 10 is never reached. An attacker who already possesses working first-factor credentials-and is targeting an account with 2FA enabled-can repeatedly guess the rotating 6-digit TOTP without triggering lockout; a successful guess yields a client ID and token that can be exchanged for a full JWT, after which the attacker can call POST /api/auth/2fa/disable to permanently remove MFA. Exploitation requires authenticated access (PR:L) and the high attack complexity (AC:H) reflects the need to guess a time-based code within its short validity window; no public exploit identified at time of analysis. This is a real, credible authentication-security issue but not a mass-exploitation emergency.
An authenticated user of Sync-in Server (any version prior to 2.4.0) can render the entire instance unresponsive indefinitely by submitting a catastrophic-backtracking regular expression to the sync diff endpoint, which compiles the user-supplied string into a RegExp without complexity validation. Because Node.js runs JavaScript on a single shared event loop, a pattern such as '^(a+)+b' stalls processing for all connected users, and the service remains frozen until the container is manually restarted - an availability-only impact rated CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H). Version 2.4.0 fixes the issue; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV).
File owners on Nextcloud Server cannot release TYPE_TOKEN file locks that other users have placed on their files, leaving the file locked with no in-product recovery path; administrators currently have to clear the orphaned lock directly in the database. The defect is an access-control gap (CWE-284) reachable over the network by any authenticated user who can acquire a token lock, typically in shared-folder or multi-user collaboration scenarios, and it is availability-only - no confidentiality or integrity impact - as reflected in the assessed vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H. No public exploit code has been identified and there is no evidence of active exploitation, so despite a 6.5 base score this behaves as an accidental or malicious file-lockout rather than a scalable remote attack.
Deeply nested JSON or XML parsed by Dasel 3.0.0 through 3.11.0 exhausts the Go goroutine stack and triggers an unrecoverable fatal error that terminates the entire process, giving attackers a denial-of-service condition against any tool, pipeline, or service that runs dasel on untrusted documents. Exploitation requires the attacker to control the parsed input - via the dasel CLI, the parse selector function, or a program embedding the library through parsing.Format(...).NewReader(...).Read(data) - and the assessed vector is local (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so realistic risk concentrates on wrappers that feed externally sourced data into dasel. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the flaw is strictly availability-only: there is no confidentiality or integrity impact, and the fix in 3.11.1 simply rejects input nested beyond 10,000 levels.
Server-side request forgery in CKAN MCP Server (ondata/@aborruso ckan-mcp-server) before version 0.4.108 allows an attacker who can influence the caller-supplied server_url parameter to force the server to issue requests to loopback addresses and to the cloud instance metadata service at 169.254.169.254. The flaw is the third bypass of the same validateServerUrl guard: because that guard only inspects the hostname string and never resolves DNS, any hostname that resolves to an internal address (documented examples lvh.me to 127.0.0.1 and *.nip.io to IMDS) slips through, and exploitation realistically requires prompt injection into content the victim's AI assistant processes while the MCP server is connected (CVSS UI:R). No confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis, though a proof-of-concept for an earlier, related SSRF variant in the same package is published; impact is highest for cloud-hosted deployments where IMDS returns IAM credentials.
Missing authentication in the Role Permission API of Omega Solution HRM OS (versions up to 20260717) lets remote, unauthenticated attackers read role-permission data without a session or credential. Manipulating the roleId argument on the /role-permission/permission endpoint bypasses the intended access check entirely (CWE-306), and publicly available exploit code exists for this path. The exposure is limited to low-confidentiality disclosure - no integrity or availability impact was assessed - so the practical risk depends on whether the HRM OS instance and this API endpoint are reachable from attacker-controlled networks.
Unauthenticated SQL injection in QCMS through 6.0.6 allows remote attackers to inject arbitrary SQL through the ID argument processed by the self_Tmp function in Lib/Config/Controllers.php, reachable via the public Content Detail Page. No authentication or user interaction is required (CVSS vector PR:N/UI:N), and publicly available exploit code exists - a proof-of-concept write-up has been published in a public GitHub issue. Exploitation is moderated in practice by the application's router, which parses the raw REQUEST_URI without URL-decoding, so payloads must contain literal space characters; percent-encoded (%20) payloads never decode before route parsing and fail, which gives edge proxies, CDNs and WAFs a usable filtering point. This is a moderate-priority issue against an obscure PHP CMS whose vendor has not issued a fix and has responded to the reporter with hostility.
SQL injection in the Drogon C++ web framework's ORM layer (Mapper::orderBy in Mapper.h, versions through 1.9.13) lets a remote, unauthenticated attacker inject arbitrary SQL through the sort argument of a list or search endpoint. The flaw is a library defect rather than a default-on endpoint: it is only reachable when application code forwards attacker-controlled input into orderBy, so applications that hardcode or whitelist sort columns are not exploitable. Publicly available exploit code exists (a public gist referenced by the disclosure), and the vendor did not respond to the report; no CISA KEV entry is associated with this CVE, and the realistic impact is high-confidentiality, limited-integrity data exposure rather than direct code execution.
Tinyauth versions prior to 5.1.0 can be forced into a temporary, instance-wide login lockdown by an unauthenticated remote attacker who sends POST /api/user/login requests using 257 distinct nonexistent usernames, filling the MaxLoginAttemptRecords limit so that legitimate users receive HTTP 429 responses until the default auth.loginTimeout of roughly 300 seconds elapses. The flaw is an availability-only, low-severity issue (CVSS 3.1 5.3, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L; CWE-307) that grants no confidentiality or integrity access and does not invalidate or degrade existing authenticated sessions; the attacker gains nothing beyond the temporary denial of new logins and must repeat the request burst to sustain it. No public exploit code was identified at time of analysis, and there is no evidence of active exploitation (not in CISA KEV); deployments that have disabled lockdown mode are unaffected. The issue is fixed in Tinyauth 5.1.0.
Sync-in Server versions prior to 2.4.1 leak account existence through a timing side channel in the login endpoint, allowing unauthenticated remote attackers to enumerate valid usernames or email addresses. The issue arises because login attempts for nonexistent accounts return early without running the bcrypt comparison performed for real accounts, producing a measurable difference in response times. This is a low-severity information-disclosure weakness (CVSS 5.3) that reveals only whether an account is registered, but can be chained into credential-stuffing, password-spraying, or phishing attacks; no public exploit identified at time of analysis.
Authenticated low-privileged users of jshERP through 3.6 can overwrite role button-permission definitions for any role in their tenant by sending arbitrary roleId and btnStr values to the POST /userBusiness/updateBtnStr endpoint, because that handler performs no authorization check on the caller's privileges. Publicly available exploit code exists (a Python POC script is published on GitHub) and the CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L reflects moderate impact confined to the integrity and availability of permission configuration with no confidentiality exposure; the CVE is not listed in CISA KEV, so there is no confirmation of active exploitation.
Authenticated tenant isolation bypass in jshERP through 3.6 allows any logged-in user to read other tenants' records from the GET /tenant/info endpoint by iterating tenant primary keys, exposing login names, validity dates, user quotas, and enabled state for every tenant on the platform. Exploitation requires only a valid account of any privilege level (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N) and publicly available exploit code exists, though CISA KEV does not list this CVE as actively exploited. Impact is a bounded confidentiality leak - CVSS 5.0 with changed scope but no integrity or availability effect - and only materializes on instances that are genuinely multi-tenant with other tenants' records present; a single-tenant deployment exposes nothing beyond the caller's own data.
Authenticated users of lamp-cloud through 5.10.0 can read any other employee's role codes, permission codes, and full front-end router tree by supplying arbitrary employeeId values to the /anyone/visible/resource endpoint, which never verifies that the requested identifier belongs to the caller. Exploitation is trivial - any low-privilege account suffices, the identifiers appear to be enumerable integers, no user interaction or elevated privilege is required, and publicly available exploit code exists (a Python PoC targeting this exact BOLA condition). The flaw is confirmed as an object-level authorization failure (CWE-639) and is not known to be actively exploited (no CISA KEV listing); impact is limited to read-only disclosure of authorization metadata, which matches the assessed CVSS 4.3 (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N).
Cross-tenant information disclosure in Hatchet before 0.106.1 allows an authenticated tenant worker in a multi-tenant deployment to read durable event-log records belonging to another tenant if it knows that tenant's durable-task UUIDv4. The flaw is in the WorkerStatus gRPC polling path, where ListSatisfiedEntries was called without a tenant filter; single-tenant installs are unaffected, and the UUIDv4 requirement makes practical exploitation unlikely. Vendor-released patch: 0.106.1. No public exploit identified at time of analysis.
nginx-ignition versions 2.33.0 through 2.35.0 do not enforce single-use semantics on TOTP one-time codes, so a code that has already been used to authenticate can be replayed again within its normal 30-second validity window. Only accounts with OTP 2FA enabled are affected, and exploitation requires the attacker to already hold the victim's password plus a live-interception position (for example an adversary-in-the-middle phishing proxy) to capture the code as the victim types it, which is why the independent assessment treats this as a genuine but low-priority authentication weakness rather than an emergency. No public exploit code has been identified at time of analysis and the flaw is not listed as confirmed actively exploited (CISA KEV); nginx-ignition 2.35.1 patches the issue.
Denial of service in vLLM through 0.29.0 allows remote, unauthenticated attackers to exhaust the Mooncake connector's sender task pool by submitting prefill requests that are rejected before engine admission, causing legitimate KV-cache transfers to be delayed by up to roughly 480 seconds while the service's health checks keep reporting success. The issue only affects deployments running disaggregated prefill/decode with the MooncakeConnector KV-transfer backend (kv_producer/kv_consumer roles), which is a specialized, non-default topology rather than a standard single-node vLLM serve; a standard vLLM installation is not exposed. There is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis - the VulnCheck advisory and an upstream GitHub pull request (PR #51236) that adds an orphan-transfer timeout constitute the primary public signals, and impact is bounded to availability degradation rather than crash, data disclosure, or code execution.
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.
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.
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.
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.
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.