Higress gateways running the ai-token-ratelimit WASM plugin before version 2.2.4 allow unauthenticated remote clients to bypass AI token rate limiting by sending a Cookie header containing a segment without an equals sign; the resulting Go panic is recovered by the plugin wrapper, which then fails open and returns a continue action instead of blocking the request. The flaw is a fail-open control bypass rather than a confidentiality or code-execution issue: CVSS 4.0 scores it 6.9 (and the independent 3.1 assessment scores AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L), because the only impact is that costly model backend calls can exceed configured thresholds, enabling cost and resource abuse, with no C or S impact. Exposure requires the ai-token-ratelimit plugin to be enabled on a network-reachable route - gateways without that plugin configured are not affected - and no public exploit code was identified at time of analysis.
Improper authentication in ChangeWeDer CRM, up to commit c07bd4c97141521af6475034bc58523beed51bbd, allows unauthenticated remote attackers to manipulate the top.upstudy.crm.utils.LoginUserUtil.releaseUserIdFromCookie cookie-handling path and affect login state (CWE-287). The assessed impact is limited to low confidentiality, integrity, and availability, and this is a low-priority issue despite the medium 6.9 CVSS because ChangeWeDer CRM is an obscure open-source Java application with rolling releases and a tiny real-world footprint. No public exploit code has been identified, no vendor patch is available, and the project has not responded to the reported issue at https://github.com/ChangeWeDer/crm/issues/2.
Unauthenticated information disclosure in Rallly before 4.15.0 allows remote attackers who possess a poll's urlId to retrieve the names and email addresses of scheduled-event invitees through the polls.get tRPC procedure, regardless of the poll's privacy settings. The urlId is embedded in the public invite links Rallly generates and shares, so no credentials, user interaction, or non-default configuration are needed; CVSS 3.1 rates this 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N). There is no public exploit code identified and no indication of active exploitation at time of analysis, and the vendor has released a fix in version 4.15.0.
Unbounded memory growth in the AG-UI Rust client's SSE frame parser (crates/ag-ui-client/src/sse.rs, shipped in the ag-ui 1.0 community SDK) lets a malicious, compromised, or machine-in-the-middle SSE server exhaust the memory of the consuming client process by streaming a frame it never terminates with a blank-line delimiter. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV), but the outcome is a denial of service confined to the client process, matching the independently assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L rather than the higher CVSS 4.0 score of 6.9. Exploitation requires the Rust client to open an SSE connection to an endpoint that the attacker controls, has compromised, or can intercept; a correctly behaving server never triggers the flaw, so this is a client-side parsing weakness rather than a remotely reachable listening service.
Local attackers with authenticated access can retrieve cleartext-stored credentials from the Fermax DuoxMe Android app versions prior to 4.3.4 and impersonate the user account. This CWE-312 vulnerability requires local access to the device, and on non-rooted devices the app sandbox normally protects the data, so root or device-level access is the practical prerequisite. No public exploit code has been identified at time of analysis, and the risk is assessed as a modest-severity local issue.
Hard-coded cryptographic key exposure in Qualitysoft QND's Windows client allows any local authenticated user to decrypt and recover administrator credentials - including login ID and password - stored or processed by the PC management software. All three product lines (QND Advance, QND Premium, QND Standard) through their respective current versions are affected. No public exploit or active exploitation has been identified, but the attack is low-complexity and requires only a standard Windows session on a machine where the QND client is installed.
Credential leakage in the rmcp Rust SDK (the official Rust SDK for the Model Context Protocol) prior to 2.1.0 allows an attacker who controls or compromises an MCP endpoint to harvest API keys and tokens from victim clients. StreamableHttpClientTransport builds its default reqwest HTTP client with automatic redirect following and replays caller-supplied StreamableHttpClientTransportConfig.custom_headers on cross-origin 307/308 redirects without marking them sensitive, so secrets such as x-api-key headers are forwarded to the redirect target where the attacker can capture and reuse them. The issue is not actively exploited per available intelligence, no public exploit code was identified at time of analysis, and exploitation is condition-gated: it requires a client that (a) runs a pre-2.1.0 version, (b) places secrets in custom_headers rather than the standard Authorization path, and (c) talks to a malicious or compromised MCP server, which is why the assessed vector carries high attack complexity and limits impact to confidentiality (CVSS 6.8, AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:N/A:N, CWE-200). A vendor patch is available in rmcp 2.1.0.
Cisco Secure Firewall ASA and FTD software contain a logic error in the DNS over TCP response handler that can be triggered by a crafted DNS reply, causing the device to reload and resulting in a denial-of-service condition. The attacker must be able to respond to DNS queries originating from the device-either by controlling the DNS service or via a machine-in-the-middle position-and the device must use DNS over TCP. No public exploit code has been identified at the time of analysis, and the CVSS score is 6.8 (Medium) with only availability impact.
Command injection (CWE-78) in HP's HPLIP (HP Linux Imaging and Printing) software enables an unauthenticated local user to execute commands or modify files with high integrity impact (VI:H) after active user interaction, matching HP's CVSS 4.0 score of 6.8 (AV:L/AC:L/PR:N/UI:A/VC:L/VI:H/VA:L) and the independent CVSS 3.1 assessment (AV:L/AC:L/PR:N/UI:R/C:L/I:H/A:L). The HP security bulletin HPSBPI04151 bundles this issue with other externally reported HPLIP flaws that could lead to remote code execution, privilege escalation, denial of service, or information disclosure, but the exact vulnerable component is not disclosed. No public exploit code or CISA KEV entry is identified at time of analysis, and the local vector plus mandatory user interaction prevents triggering without a user processing attacker-supplied input.
Information disclosure in Zope AccessControl (zopefoundation AccessControl) versions prior to 7.4 allows authenticated users who already hold through-the-web Python code-authoring privileges to break out of the restricted-execution sandbox and read objects that the security policy is supposed to hide. Reaching str.format or str.format_map through a str subclass bypasses AccessControl's policy-restricted getattr and getitem guards, so a crafted format string can recursively walk attributes and subscriptions to disclose objects reachable from the values available to the formatting call. The impact is confined to confidentiality (CVSS 6.8, C:H with no integrity or availability impact); Vendor-released patch: 7.4, and no public exploit identified at time of analysis.
Stored cross-site scripting (XSS) in the Jenkins Gitee Plugin (versions up to and including 1301.v8957053c7902) allows an authenticated attacker who can trigger builds via the plugin's push webhook and control the sender name field to inject malicious JavaScript into build causes, which executes when a Jenkins user views the affected build's causes page. The vulnerability requires the plugin's webhook endpoint to be reachable and a user to subsequently view the build page (UI:R). No public exploit code has been identified at time of analysis, and the vendor's CVSS score of 6.8 uses a boilerplate vector; independent assessment rates it as CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N.
Local privilege escalation in Dell ECS 3.8.1.0 through 3.8.1.7 and Dell ObjectScale prior to 4.4.0.0 allows an attacker with existing high-privileged local access to elevate privileges. The flaw stems from improper privilege management (CWE-269) and requires authenticated local access (PR:H/AV:L); it is not remotely exploitable. No public exploit code or active exploitation has been identified, and vendor patches are available.
Password hash disclosure in Pepperl+Fuchs ICE2/ICE3 IO-Link Master devices and Phoenix Contact IOL MA8 PN DI8 (plus OEM variants) exposes all user credential hashes to any authenticated low-privileged user. The PHP-based diagnostics endpoint `/index.php/diagnostics_tab/ajax_diag_table_rows` accepts a manipulable `schema` path parameter that, when tampered with using a valid session cookie, causes the server to return the device's full user credential hash store. No public exploit or active exploitation has been identified at time of analysis; three separate CERTVDE advisories (VDE-2026-014, VDE-2026-027, VDE-2026-028) indicate the same underlying vulnerability spans multiple vendor product lines sharing common firmware.
Cross-tenant TLS configuration leakage in flightctl (shipped as Red Hat Edge Manager 1 and embedded in Red Hat Advanced Cluster Management for Kubernetes 2) lets an authenticated organization user have their HTTPS git repository's TLS settings - potentially InsecureSkipVerify, a custom CA bundle, or their own mTLS client certificate - applied to another organization's concurrent git.Clone operations, because the device-render worker installs each per-repository tls.Config into go-git's process-global Protocols map. Exploitation requires a multi-tenant deployment that renders devices for several organizations concurrently from a shared goroutine pool and is inherently non-deterministic (AC:H) since the attacker cannot control which tenant's configuration wins; single-tenant or serialized-rendering deployments are not exposed. The vendor scores this 6.6 (CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:L/A:N) while our independent assessment rates privileges as PR:L because defining an HTTPS git repository only needs a normal authenticated tenant/organization account; no public exploit code was identified at time of analysis, there is no CISA KEV listing, and no EPSS score was provided.
Blind SQL injection in the WP Directory Kit WordPress plugin, affecting all versions up to and including 1.5.4, lets an authenticated attacker with 'custom-level access and above' append arbitrary SQL to an existing query through the unescaped 'order_by' parameter and extract sensitive data from the site's database. The flaw carries a CVSS 3.1 base score of 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) because exploitation is network-reachable and low-complexity but gated behind a valid low-privilege account; confidentiality is the only impacted pillar, as the injection is blind and does not permit direct read-out or data modification. No public exploit code or confirmed active exploitation was identified at time of analysis, so the practical risk is concentrated on sites that expose low-privilege accounts and run a vulnerable plugin version.
Unbound versions 1.22.0 through 1.26.1 built with DNS-over-QUIC support (--with-libngtcp2) can be driven to an abnormal exit by an unauthenticated remote attacker who manipulates QUIC stream state. The attacker sends a DoQ query, withholds ACKs, issues RESET_STREAM to free the per-stream output buffer, then waits for a PTO timeout so ngtcp2 re-encodes a STREAM frame from the freed memory; a spray of roughly 20 such queries forces the daemon down. Default builds compiled without QUIC support are not affected, and exploitation also requires precise timing against the QUIC state machine, making this a moderate, configuration-gated availability threat rather than a top-tier priority. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the authoritative assessment rates it AV:N/AC:H/PR:N/UI:N/S:U with low confidentiality and high availability impact, so the practical outcome is denial of service against the resolver rather than broad data compromise.
Information disclosure in the djust Python WebSocket framework before 1.0.7 causes Django Model instances assigned to public (non-underscore) view attributes to be serialized to the browser with no sensitive-field denylist, exposing fields such as the password hash, is_staff/is_superuser privilege flags, tokens, and other PII inside the render payload sent to the client. Exploitation requires authenticated access to a view that assigns a full model to a public attribute (CVSS:3.1 AV:N/PR:L), and the resulting impact is confidentiality-only but rated High (C:H/I:N/A:N). No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV.
Improper privilege management in Cisco Identity Services Engine (ISE) and Cisco ISE Passive Identity Connector (ISE-PIC) versions 3.1 through 3.5 allows a network-reachable attacker who already holds a high-privilege administrative account on the management plane to escalate their privileges within the product, per CVE-2026-20287 (CVSS 3.1 base 6.5, vector CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:N). The flaw is one of several defects bundled into a Cisco internal-hardening release and is tracked under the CWE-269 improper privilege management pillar; the exact vulnerable sub-feature is not individually described in the grouped advisory. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); because the vector requires PR:H, this is a post-authentication privilege escalation affecting the appliance's administrative layer rather than an initial-access or unauthenticated remote code execution issue. For most organizations it represents a moderate-priority, defense-in-depth concern that is materially mitigated by keeping the ISE management interface off untrusted networks, though the potential for both confidentiality and integrity impact (C:H/I:H) still warrants prioritized patching on any ISE deployment that exposes its admin plane broadly or grants many staff high-privilege accounts.
Missing per-role authorization checks in the CommPilot web-based management interface of Cisco BroadWorks allow an authenticated, low-privilege remote user to alter configurations on select administrative pages via a crafted HTTP request. The issue (CVE-2026-76438, CWE-863, CVSS 6.5 / CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N) affects BroadWorks releases 21.0 through 26.0, including the 21.sp1 line and assorted RI builds, with the assessed impact limited to configuration integrity - no confidentiality or availability loss per the vector. There is no CISA KEV listing and no public exploit identified at time of analysis, so this is a routine, patch-priority access-control defect rather than an emergency: a valid low-privilege CommPilot account is a prerequisite, and BroadWorks management interfaces are normally confined to carrier or management networks.
OS command injection in the IPsec Open API endpoint of Cisco Identity Services Engine (ISE) allows an authenticated, remote attacker holding valid administrative credentials to run arbitrary commands on the underlying operating system, and Cisco notes the obtained privilege level can be escalated easily to root. Exploitation is constrained to ISE nodes that have more than one network interface and that have one of those interfaces configured as an active IPsec tunnel, so default single-interface deployments without IPsec are not exposed; no public exploit code was identified at time of analysis. Although the CVSS 3.1 base score is 6.5 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:N), Cisco has explicitly assigned a Security Impact Rating of High because of the short path from the achieved privilege level to root, making the raw numeric score a poor indicator of real-world severity.
A peer-supplied maximum packet size of zero is accepted during SSH channel-open negotiation in AsyncSSH versions prior to 2.24.0, and the resulting zero-byte send-window processing drives SSHChannel._flush_send_buf into a synchronous infinite loop with no await point, permanently freezing the asyncio event loop. Because the loop is synchronous, a single trigger halts every current and future connection handled by that process, producing a complete denial of service rather than a per-connection failure. The server path is reachable by an authenticated client sending SSH_MSG_CHANNEL_OPEN with send_pktsize=0, while the client path is reachable by a malicious or compromised SSH server sending SSH_MSG_CHANNEL_OPEN_CONFIRMATION with send_pktsize=0 before the first channel write, so exploitation requires the AsyncSSH client to initiate a connection to that server. No public exploit identified at time of analysis, the issue is availability-only (no confidentiality or integrity impact), and vendor-released patch version 2.24.0 addresses it.
An authenticated server-side request forgery (SSRF) in Tanium Threat Response allows a user who already holds valid console or module credentials to coerce the Tanium server into making requests to attacker-influenced URLs, potentially disclosing internal-only resources. The vendor scores it 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), which matches our independent assessment: remote reachability with low attack complexity, but the low-privilege authentication requirement is the main limiting factor and there is no user interaction needed. Impact is confined to confidentiality (high) with no integrity or availability effect and no scope change, and no public exploit code or confirmed active exploitation was identified at the time of analysis.
Information disclosure in the Tanium Discover module allows an authenticated console user to read data they should not have access to, with the vendor confirming the flaw has been addressed. The vulnerability requires network reachability and a valid low-privilege Tanium session (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, base 6.5) but no user interaction, and it affects only organizations that have licensed and deployed the optional Discover component. Impact is confined to confidentiality - there is no integrity or availability effect - and no public exploit code or confirmed active exploitation has been identified at time of analysis.
GPU memory exhaustion in vLLM versions prior to 0.28.0 lets an attacker with low-privileged API access (PR:L in the CVSS vector) force the server to load the PyNvVideoCodec hardware video decoder on demand by setting media_io_kwargs.video.video_backend to 'pynvvideocodec' in a Chat Completions or Responses request, even when the operator configured a software decoder at startup. Because the engine budgets decoder VRAM only from static configuration, the request-selected backend allocates a CUDA context, decoder surfaces, and decoded-frame buffers that were never deducted from the KV-cache budget, so repeated video requests can exhaust shared GPU memory and cause request failures, worker crashes, and denial of service. The issue is availability-only (C:N/I:N/A:H) and exploitable only on video-capable GPU deployments running a video-accepting model with PyNvVideoCodec actually installed; vLLM 0.28.0 and later are not affected. No public exploit code was identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV), though the upstream fix commits and PR are publicly visible.
Out-of-memory worker crashes in vLLM can be induced by a single small compressed audio payload submitted to the /v1/chat/completions input_audio path, because that code path decodes audio without the VLLM_MAX_AUDIO_DECODE_DURATION_S guard already enforced on /v1/audio/transcriptions - an unbounded resource allocation flaw (CWE-770) that expands a tiny compressed file into a very large float32 PCM buffer. The issue affects every vLLM release prior to 0.24.0 that serves an audio-capable model and exposes the chat completions endpoint, with inline data URLs additionally escaping VLLM_AUDIO_FETCH_TIMEOUT; impact is availability-only (no confidentiality or integrity loss). Per the assessed vector the attack is remote and unauthenticated (PR:N, UI:N), while the vendor-published vector scores it PR:L, so whether any front-of-service authentication gate exists is deployment-specific; at time of analysis no public exploit code and no confirmed active exploitation were identified, and a vendor patch exists in 0.24.0.
SQL injection in the ORDER BY direction handling of MikroORM (a TypeScript ORM for Node.js) lets authenticated remote attackers append arbitrary SQL fragments to generated queries, enabling blind or boolean-based extraction of data readable by the configured database account. Affected are SQL drivers in versions prior to 6.6.16 and 7.0.0 through 7.1.6 (SQLite, PostgreSQL, MySQL, MariaDB, MSSQL, libSQL, Oracle); MongoDB is not affected. Exploitation is conditional - the application must bind attacker-controlled request data directly to the orderBy direction in em.find(), em.findOne(), em.findAndCount(), QueryBuilder.orderBy(), or QueryBuilderHelper.getQueryOrderFromObject(); the field key is already validated against entity metadata, and there is no public exploit identified at time of analysis. Vendor-released fixes exist in 6.6.16 and 7.1.7.
Stack-based buffer overflow in the Dell Update Package (DUP) Framework, affecting all versions prior to 26.07.03, allows an unauthenticated attacker who can reach the affected component from an adjacent network segment (AV:A, PR:N, UI:N) to corrupt stack memory and potentially achieve code execution or crash the process. Dell scores this 6.5 with CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (availability-only), whereas independent assessment rates the impact as complete loss of confidentiality, integrity and availability (AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), which aligns with the description's statement that the flaw can lead to remote execution; the practical constraint in both readings is the adjacency requirement rather than internet-wide reachability. No CISA KEV entry and no public exploit code were identified at time of analysis, and Dell has published DSA-2026-417 with a fixed release (26.07.03).
Authenticated blind SQL injection in ScadaLTS 2.8.1-release-candidate build 0 lets any logged-in user with the lowest privilege tier (ROLE_USER, ROLE_ADMIN, or ROLE_PUBLIC) extract arbitrary database contents, including password hashes for every account on the platform. The flaw lives in the JSON sortBy array accepted by POST /api/events/search, whose values are concatenated straight into the SQL ORDER BY clause with no sanitization or parameterization, forcing attackers to use slower time-based and boolean-based inference rather than in-band extraction. CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) is well calibrated: exploitation requires valid credentials but scada-lts deployments that grant ROLE_PUBLIC or self-service low-privilege accounts effectively erase that barrier, and there is no public exploit code and no confirmed active exploitation (CISA KEV) at time of analysis.
BIND 9 secondary (slave) servers that restrict zone transfers with TSIG can be tricked into serving attacker-supplied zone contents: an attacker able to occupy or spoof the position of the configured primary can deliver a multi-message TCP IXFR whose final TSIG-signed message never arrives, and named commits and serves the records already received without rolling back to the pre-transfer state. Affected releases are BIND 9 9.11.0 through 9.18.50, 9.20.0 through 9.20.27, and 9.21.0 through 9.21.25, along with the -S1 builds 9.11.3-S1 through 9.18.50-S1 and 9.20.9-S1 through 9.20.27-S1; no valid TSIG key is required (CVSS 3.1: AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:L, 6.5), but exploitation is conditional on the attacker's network position and the multi-message IXFR condition, so this is an integrity-only, high-complexity issue rather than a broadly reachable critical flaw. No public exploit identified at time of analysis and no CISA KEV listing; vendor patches are downloadable for the 9.20 and 9.21 branches.
Server-side request forgery in the Jenkins Bitbucket Push and Pull Request Plugin (4.0.1 and earlier) lets remote attackers submit a crafted webhook payload whose attacker-controlled URL Jenkins then contacts using the Bitbucket credentials stored in the plugin's configuration, exposing those credentials. Per the vendor CVSS vector (AV:N/AC:L/PR:N/UI:N) the attack is remote, low-complexity, and requires no authentication or user interaction; our independent assessment rates the confidentiality impact as high because successful exploitation yields the stored Bitbucket credential material itself. Exploitation is only possible on Jenkins instances where the plugin is installed, reachable on its webhook trigger endpoint, and actually configured with Bitbucket credentials; no public exploit code has been identified at time of analysis and there is no KEV listing for this CVE.
Keycloak's first broker login flow leaves a temporary account-linking proof behind after a federated identity link is established or manually removed (CWE-613), allowing an attacker who controls the external identity to silently re-establish the link and authenticate as the victim without any further confirmation. The flaw affects Red Hat Build of Keycloak and Red Hat Single Sign-On 7 deployments that use identity brokering, and carries high confidentiality and integrity impact despite a moderate CVSS base of 6.4. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV.
Stored cross-site scripting in the Bold Page Builder plugin for WordPress, affecting all versions up to and including 5.9.6, lets authenticated users with Contributor-level access plant persistent JavaScript that executes in the browser of anyone who views the injected page. The plugin's bt_bb_save_pre filter is bypassable via null-byte injection, and the bt_bb_raw_content shortcode handler outputs base64-decoded content without adequate sanitization, so payloads survive the intended checks. No public exploit code or CISA KEV entry was identified at time of analysis; the supplied Trac changeset indicates an upstream fix has been committed, but no patched release version is confirmed in the available data.
Stored cross-site scripting in the Advanced Popups WordPress plugin (all versions up to and including 1.2.3) lets an authenticated attacker holding author-level rights or above inject arbitrary JavaScript through the popup 'Notification Button Link' field, which is then rendered unsanitized to every visitor of the affected page. Because the payload is persisted in the site's database, any visitor — including administrators — who opens the injected page will execute the script in their own browser session. No public exploit code and no CISA KEV entry were reported at the time of analysis, and the maintainers shipped a fix in version 1.2.4.
Duplicate-submission gate bypass in the Tempo payment method of ZenHive mpp (versions 0.2.0 through 0.16.1) lets an unauthenticated remote client pass the pre-broadcast dedup reservation twice using a single signed transaction - once with recovery id v=27 and once with v=0 - because the reserve key is derived from the caller-supplied raw transaction hex rather than a canonical form of the transaction. The post-broadcast mark then writes the canonical hash key that the raw-keyed reserve never reads, so the two encodings never collide. Impact is real but bounded and conditional: a node that rejects nonce reuse fails closed and produces no harm, while a node that returns the canonical hash for an already-known transaction can issue a second valid Payment-Receipt for a single on-chain payment; confidentiality and availability are unaffected, and no public exploit code has been identified at time of analysis.
ZenHive mpp (MPP.Plug payment middleware for Elixir/Phoenix) versions 0.1.0 through 0.16.1 can allow a shared HTTP cache - a CDN or reverse proxy - to store a paid 200 response together with its Payment-Receipt header and replay both to clients that never paid, because the library's own Cache-Control: private is silently replaced when the mounting application sets its own cache directive on the same connection. An unauthenticated remote client that reaches such a cache can therefore obtain paid content and a valid receipt for free, and a related weaker case has a downstream non-2xx response still carrying a Payment-Receipt for a resource that was never delivered (CWE-524). The real-world risk is tightly bounded: the library's default behavior (private on success, no-store on 402) is safe, so the leak requires an application-level caching misconfiguration plus a shared cache in the response path, and no public exploit code was identified at time of analysis.
Cross-tenant data exposure on the djust live WebSocket path affects installations before 1.0.7 that use host-, subdomain-, or domain-based TenantResolvers for multi-tenancy. Because the request rebuilt by handle_mount and ViewRuntime._build_request carries no client Host, get_host() falls back to "testserver", so the tenant resolves to None on the live path even though the ordinary HTTP path resolves it correctly; with STRICT_MODE=False the tenant-scoped managers then return unscoped rows and an authenticated user can read other tenants' data. With the default STRICT_MODE the identical flaw only yields empty querysets (broken tenancy, no disclosure). No public exploit code exists and there is no confirmed active exploitation; EPSS/KEV data were not provided, and the CVSS vector (AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:N/A:N, 6.3) reflects the high attack complexity and the dependency on an explicit STRICT_MODE=False configuration.
Log telemetry exported over gRPC by OpenTelemetry-Go versions prior to 0.21.0 can be silently intercepted or modified because the otlploggrpc exporter reads TLS certificate settings from environment variables into its config but never applies them to the gRPC transport credentials. When TLS is configured only through OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE, OTEL_EXPORTER_OTLP_CERTIFICATE, and the related client-certificate/key variables - and the application does not additionally call WithTLSCredentials in code - the client falls back to credentials.NewTLS with system roots and no client certificate, so the intended private-CA pinning and mutual TLS are bypassed. A network attacker in a man-in-the-middle position who can present a certificate chaining to the victim host's system trust store can read or alter exported log data; misconfigured code paths that do pass WithTLSCredentials are unaffected, the system-trusted-certificate prerequisite is a significant limiting factor, and no public exploit was identified at time of analysis. The issue is fixed in otlploggrpc v0.21.0.
CPU exhaustion in the OpenTelemetry-Go sdk/log BatchProcessor (BatchingProcessor built via NewBatchingProcessor) before version 0.21.0 lets attacker-driven, high-volume log emission pin a process's CPU when the wrapped log exporter is simultaneously slow or backpressured. The poll loop repeatedly retries a non-blocking queue dequeue and a failed non-blocking EnqueueExport without waiting on its ticker, because the failed enqueue leaves the queue length unchanged at or above batchSize, producing a tight busy-spin that degrades or denies service in the embedding application. This is an availability-only flaw (CWE-400) with no confidentiality or integrity impact, no public exploit code identified at time of analysis, and no confirmed active exploitation (not in CISA KEV); the assessed vector (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L) is unauthenticated but requires the attacker to sustain log volume while the exporter is backpressured, which significantly narrows real-world exploitability.
HTML markup injection in changedetection.io through 0.60.6 allows an attacker who controls the <title> of a page being monitored to inject arbitrary markup into the notification messages that changedetection.io generates. When a user's notification template uses the watch_title token and HTML-format notifications are enabled for a channel such as email or Telegram, that markup is delivered as live content rather than escaped text, enabling content spoofing and phishing inside notifications. Exploitation is unauthenticated (PR:N per the assessed vector) but heavily gated by preconditions - the victim must monitor an attacker-influenced page, use the watch_title token, enable HTML notifications, and actually view the rendered notification - and publicly available exploit code exists, though there is no confirmed active exploitation (CISA KEV).
Improper access controls in Tanium Threat Response let an attacker who already holds a valid low-privileged account manipulate objects they should not be authorized to reach, producing a high integrity impact and limited confidentiality exposure. The flaw is network-reachable and low-complexity but is not pre-authentication: the CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:H/A:N, base 7.1) confirms the attacker must first authenticate with low privileges, so the 'Authentication Bypass' tag in the source intelligence should be read as an authorization bypass rather than an unauthenticated entry point. No public exploit code has been identified and the issue is not listed in CISA KEV, so exploitation is not confirmed actively exploited; Tanium self-reported the issue and published advisory TAN-2026-048.
Cache-key pollution in the @orpc/server CORS plugin (oRPC versions prior to 1.14.8) allows remote, unauthenticated clients to inject arbitrary Vary header values that are copied verbatim into HTTP responses, poisoning the cache keys used by shared caches, CDNs, or reverse proxies and producing inconsistent CORS enforcement for other clients. No authentication or user interaction is required (CVSS 4.0 vector shows PR:N/UI:N), but the impact is gated by deployment topology: per the vendor and independent assessment, default non-cached configurations have no established confidentiality, integrity, or availability impact, so single-instance or non-CDN deployments are effectively unaffected. The realistic exposure is a low-to-moderate integrity issue - scoped to the vulnerable component (S:C with I:L) - rather than the code-execution problem the misleading 'Code Injection' tag implies, and no public exploit code or CISA KEV entry was identified at time of analysis.
Unauthenticated information disclosure in Concrete CMS releases before 9.5.3 allows a remote visitor who knows or can guess a valid Express entity identifier to query a legacy Express entry search endpoint that omits the canViewExpressEntries() permission check, returning entry attribute values that should be restricted to privileged users. The impact is read-only (C:L/I:N/A:N) and exploitation requires that identifier prerequisite, which is why the vendor and independent assessments both score it as hardening-limited rather than trivially exploitable; disclosure is worse for Express entities where supportsEntrySpecificPermissions() returns false, because EntryList::ignorePermissions() then bypasses per-entry filtering entirely. No public exploit code has been identified at time of analysis, and this CVE is not confirmed actively exploited (no CISA KEV listing); the fix is included in the 9.5.3 release.
An out-of-bounds read in the userspace SMB daemon of MikroTik RouterOS before 7.24 allows unauthenticated remote attackers to read memory beyond the end of the request buffer by sending a minimal SMB1 SessionSetupAndX frame with a crafted uniPwdLen field value. The over-read occurs in the SessionSetupAndX handler before any credential validation, so no authentication or user interaction is required, though exploitation is only possible when the non-default SMB service is enabled and reachable on the network. Vendor-released patch: RouterOS 7.24; there is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, and the independent assessment rates the impact as limited memory disclosure (VC:L) with possible service disruption (VA:L) rather than code execution or full memory disclosure.
Stored cross-site scripting in the Modbus transaction management interface of Advantech EKI-1242EIMS and EKI-1242IEIMS industrial gateways (firmware V1.06.01) lets an attacker who already holds high-privileged authenticated access to the gateway web UI persist malicious script that later executes in the browser of any administrator who opens the affected management page. Because the payload is stored and served from the device itself, the more serious consequences land in the victim administrator's browser session (scope change to High per the CVSS:4.0 vector, and C:H/I:H/S:H in the 3.1 assessment) while impact on the gateway itself is limited to Low confidentiality and integrity, with no availability impact. Exploitation requires two compounding preconditions - pre-existing admin credentials (PR:H) and a victim administrator's subsequent page view (UI:P) - so there is no unauthenticated or zero-interaction path; no public exploit code or confirmed active exploitation was identified at time of analysis.
Reflected cross-site scripting in the Better Messages WordPress plugin (Chat Rooms, Group Chat, Private Messages & AI Chat Bots) affects all versions up to and including 2.15.22, where the 'icn' parameter is neither sanitized on input nor escaped on output. An attacker who can craft a link with a malicious 'icn' value and persuade a logged-in or anonymous visitor to click it can execute arbitrary JavaScript in that victim's browser context on the affected site. No public exploit code or active exploitation has been reported, but the flaw is trivially automatable and the fix is already published in the 2.15.23 tag.
Reflected cross-site scripting in the web-based management interface of Cisco Identity Services Engine (ISE) lets a remote, unauthenticated attacker execute arbitrary script code in the browser session of an ISE interface user who is persuaded to click a crafted link (CVSS 3.1 base 6.1, CWE-79). Successful exploitation is confined to the victim's browser context - the attacker can read browser-based information or act as the interface user, but there is no server-side code execution and no availability impact (C:L/I:L/A:N). Exploitation requires user interaction (UI:R) against a legitimate interface user, so exposure drops sharply if the admin interface is not reachable from untrusted networks; at time of analysis there is no CISA KEV entry and no public exploit code identified, although the affected version list is broad, covering ISE 3.1.0 through 3.5 releases.
Server-side request forgery in Chatwoot's Shopify OAuth integration allows an authenticated user to make the Chatwoot server issue attacker-influenced outbound HTTP requests through the OAuth callback handler in callbacks_controller.rb, affecting versions up to 4.17.1 (4.17.0 and 4.17.1 confirmed). The CVSS 4.0 vector carries PR:L, so a valid Chatwoot account is required, and the assessed impact is low (limited confidentiality effect with no scope change), consistent with a constrained or blind SSRF rather than arbitrary internal data retrieval. Publicly available exploit code exists and the issue was reported to the project without a vendor response, but there is no evidence of confirmed active exploitation (not in CISA KEV); the overall risk is low-priority.
SQL injection in itsourcecode Leave Management System 1.0 allows an authenticated remote user to manipulate the ID argument in /module/leave/index.php and potentially read or modify database contents. Publicly available exploit code exists, but the attack requires a valid session and the product is a niche PHP application unlikely to be internet-exposed in production, so our assessment treats this as a low-real-priority issue despite the genuine CWE-89 flaw. No CISA KEV confirmation is provided.
Null pointer dereference in Artifex MuPDF allows a crafted PDF to crash the process that parses it, affecting builds up to commit b6d17493700c621c0e70036980a6ebd06d2202c9. The flaw sits in pdf_open_filter() in pdf-stream.c and is triggered while loading a malformed cross-reference (Xref) structure, so exploitation requires the target application (or automated ingestion pipeline) to process an attacker-supplied PDF - the assessed vector reflects passive user interaction (UI:P) with no confidentiality or integrity impact and only low availability loss. Publicly available exploit code exists (referenced through the Ghostscript/MuPDF bug 709610 attachment), and the vulnerability is not confirmed actively exploited (CISA KEV); EPSS/KEV-based prioritization is not warranted for this crash-only issue, though server-side pipelines that automatically ingest untrusted PDFs are the most realistically exposed deployments.
Cross-site request forgery in PbootCMS 3.2.0 through 3.2.24 lets an attacker make a currently logged-in administrator's browser issue forged requests to the admin User Management endpoints (UserController::del and UserController::mod), silently deleting or modifying administrator accounts without the attacker needing any credentials of their own. Exploitation is constrained: it requires a victim who is an authenticated admin with a live session and who is lured into loading attacker-controlled content, so the framework's own assessment is non-automatable with only partial integrity impact (vendor CVSS 4.0 score 2.1 Low; independent vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N), and publicly available exploit code exists although there is no CISA KEV listing and no EPSS score was provided. A vendor-released patch fixes the issue in version 3.2.25.