Server-side request forgery in WSO2 API Manager and related WSO2 products lets a remote attacker direct the server to arbitrary internal or external network locations and to filesystem resources reachable from the WSO2 host. The vendor CVSS vector requires low-level privileges (PR:L), while the advisory text claims an unauthenticated actor can exploit the flaw, so the authentication barrier is unresolved and should be confirmed with WSO2. No public exploit identified at time of analysis, no CISA KEV entry is present in the supplied data, and the issue is prioritized for handling this week.
Coder deployments that run workspace agents on Google Compute Engine with GCP instance-identity authentication accept replayed GCE identity tokens because the POST /api/v2/workspaceagents/google-instance-identity endpoint never validated the token's audience claim, allowing an attacker holding an unexpired format=full token minted for a different relying party to exchange it for that workspace agent's session token. The resulting agent token stays valid until the workspace's next build, well past the identity token's roughly one-hour lifetime. Affected releases are those before 2.29.21 and the 2.30.0-2.34.11, 2.35.0-2.35.8, 2.36.0-2.36.6 and 2.37.0-2.37.3 ranges, fixed in 2.38.0 and the listed backports; the flaw is unauthenticated per the supplied vector (PR:N) but conditional, since the attacker must already possess a genuine, unexpired token from a VM backing an agent on the workspace's latest build, and no public exploit was identified at time of analysis. The vendor advisory credits independent reports from a customer security team and an external researcher.
russh's SSH agent server signs with keys loaded under the confirm constraint without ever invoking the application's approval hook, so any process able to reach the agent socket - another local process running as the same user, or the remote host when the agent is forwarded with ssh -A - can authenticate or sign data as the user while the key stays loaded. The regression spans russh 0.50.0-beta.12 through 0.64.1 and only affects applications that override Agent::confirm with a real approval or policy check; the default always-true confirm and checks implemented in Agent::confirm_request remain effective, and the private key itself is never exposed. The vendor advisory ships a reproducible test PoC demonstrating the bypass (a unit test, not working exploit code); the issue is not listed in CISA KEV and active exploitation is not confirmed.
Cross-tenant IDOR and missing function-level authorization in YosemiteCrew allow any registered platform user - down to a self-registrable patient or companion-app account - to modify or delete another organization's FHIR service catalogue and PMS task-library/template definitions, with service records additionally readable with no authentication at all. The exposed routes (PATCH and DELETE on /fhir/v1/service/:id, PUT on /v1/task/pms/library/:libraryId, and the PMS template create, update and delete routes) carry only authorizeCognito, while sibling create routes already enforce withOrgPermissions() and requirePermission(...), and the service layer resolves records by global ID without an organisationId filter. Vendor-released patch: none identified at time of analysis - the issue is confirmed at main/dev commit bc1a1824b1a7eba2bc61176cdb61d9a2a11bce57 with no fix queued, and no public exploit code was identified at time of analysis.
Improper authentication in Dell PowerProtect Data Domain allows a remote attacker who already holds low-privileged credentials to bypass protection mechanisms, with high impact on confidentiality and integrity and limited impact on availability (CVSS 3.1 score 8.3, vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L). Affected builds are Feature Release 7.7.1.0 through 8.8, LTS2024 7.13.1.0 through 7.13.1.80, LTS2025 8.3.1.0 through 8.3.1.40 and LTS2026 8.6.1.0 through 8.6.1.20. No public exploit code or confirmed active exploitation is identified in the available data, and the flaw is tracked as a this-week priority rather than an emergency; the prerequisite is an existing low-privileged foothold on the appliance rather than unauthenticated access.
XML External Entity (XXE) injection in the SAF-T import feature of the TACTiS NoviGest Desktop App allows an authenticated local user to read local files that are accessible to the application process by submitting a crafted SAF-T XML file. Only users who can reach and use the import function are affected (PR:L, AV:L per the CVSS:4.0 base vector, scored 8.3), and disclosure of sensitive system files specifically depends on the application running with elevated privileges. No public exploit code or confirmed active exploitation is associated with this CVE at time of analysis; INCIBE published the advisory and the issue is prioritized as remediation work for this week rather than an emergency.
Integer overflow in libexpat through 2.9.0's storeAtts() can crash applications or corrupt heap memory when they parse attacker-supplied XML whose single start tag carries more than 2^30 attributes, and the assessed impact is high availability with no confidentiality or integrity effect. The assessed vector is AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H: no authentication or user interaction is required, but exploitation is gated by the need to deliver and parse a multi-gigabyte document, so front-end size or quota limits may prevent it. No public exploit was identified at time of analysis, and patch references exist upstream in libexpat PR #1450 and related commits.
A denial-of-service NULL pointer dereference (CWE-476) in libexpat through 2.9.0 lets remote, unauthenticated attackers crash applications that parse XML with external-entity subparsing enabled, by controlling how input is split across XML_Parse calls so an external-entity subparser's first parse is an empty, non-final buffer. Only availability is affected (VC:N/VI:N/VA:H) and there is no memory corruption, code execution, or data exposure described; the vendor's own patch (PR #1444, commit 7b0d50e4) plus a VulnCheck advisory make the mechanism well-established rather than speculative. No public exploit code and no CISA KEV entry were identified at time of analysis, though exploitation has real preconditions: the application must use XML_ExternalEntityParserCreate via an external-entity-ref handler and the attacker must influence stream chunking.
Memory exhaustion in LibreSSL's ocspcheck command-line utility (versions through 4.4.0) lets an attacker who controls the OCSP responder named in a certificate's AIA extension, or who can intercept plaintext HTTP OCSP traffic, deny certificate status checks by streaming unbounded response headers or body data. The victim must actually run ocspcheck against the hostile or intercepted responder, so this is a conditional, position-dependent flaw rather than something triggerable against arbitrary Internet hosts, and the impact is availability-only with no confidentiality or integrity effect. No public exploit code and no CISA KEV entry are associated with this CVE at time of analysis; the vendor has published upstream fixes, and the mixed signals (High headline severity versus a required on-path/responder-control precondition) point to moderate, conditional risk.
Stale authentication state in GraphQL Tools' legacy WebSocket executor lets a later caller inherit a previous caller's downstream identity: the closure-scoped executorConnectionParams object retains per-request extensions.connectionParams after cleanupWebsocket tears down the socket, and the retained keys are replayed in a subsequent connection_init payload. Only applications that reuse a single buildWSLegacyExecutor instance across different authorization contexts are exposed - most notably gateway, schema-stitching, or GraphQL Mesh deployments that pass per-user Authorization or tenant values through extensions.connectionParams; an anonymous or lower-privileged request that omits the sensitive key can then have its downstream subscription executed under the earlier user's token, though the credential itself is never disclosed. Applications that build a fresh executor per request, including the in-repository UrlLoader wrapper, are not affected; exploitation is remote and unauthenticated from the library's perspective but gated by the shared-executor architecture, and no public exploit code was identified at time of analysis.
Quadratic CPU consumption in the npm package decode-uri-component 0.5.0 and earlier lets unauthenticated remote attackers stall the Node.js event loop by supplying malformed percent-encoded input that contains many distinct encoded runs plus a single sequence the native decoder rejects, forcing a fallback path that runs one full-string regular-expression replacement per distinct run. A payload of roughly 224 KB blocks the process for about 20 seconds, but Node's default 16 KB header limit throttles URL-derived input to roughly 40 ms per request, so full impact requires an application that decodes request bodies, such as form bodies parsed with query-string.parse(). The flaw is fixed in 0.5.1, which replaces the replacement loop with a single-pass in-place decode; a public proof-of-concept snippet accompanies the vendor advisory, and it is not verified as working exploit code. Exploitation status: no confirmed active exploitation (not in CISA KEV).
Integrity verification bypass in MONAI before 1.6.1 lets an attacker who can tamper with a download path - via man-in-the-middle or control of a registry/CDN/release channel such as NGC, GitHub releases, or MONAI hosting - substitute bundles, datasets, or model archives because check_hash() silently returns True when hash_val is None and defaults to MD5 when a hash is supplied. The flaw affects default download functions (_download_from_github, _download_from_monaihosting, _download_from_ngc, MedNIST/Decathlon datasets, MMAR/auto3dseg templates), all of which pass hash_val=None, so no integrity check occurs. Direct impact is malicious file delivery (integrity); code execution depends on downstream bundle handling tracked separately, and exploitation requires the attacker to occupy a network or registry position. A public PoC demonstration exists; it demonstrates the silent bypass and is not verified as end-to-end exploit code. No confirmed active exploitation (CISA KEV) is reported.
Denial of service in Labstack Echo's Proxy middleware (v4.15.0 through v4.16.0 and v5.0.0 through v5.4.0) lets unauthenticated remote clients tie up server resources by disconnecting from a WebSocket proxy route while the upstream keeps its side of the connection open, leaving the handler, copy goroutines and network connections retained instead of released. Repeated connections accumulate these leaked resources until the service is degraded or unavailable; only availability is affected, with no confidentiality or integrity impact claimed. Exploitation is conditional rather than trivial - it requires a reachable raw/WebSocket proxy route, an upstream that holds the connection open (a rejected upgrade response delivered over HTTP keep-alive is one such trigger), and permissive or absent connection deadlines. No public exploit code identified at time of analysis; vendor patches are available in 4.16.1 and 5.4.1.
Unbounded gzip expansion in Echo v4's opt-in Decompress middleware (versions 4.0.0 through 4.16.0) allows a small compressed request to decode into a very large body, consuming excessive memory or CPU when a downstream handler reads or binds it; repeated or concurrent requests can exhaust server resources and cause denial of service. The middleware is not enabled by default, so exposure is limited to applications that explicitly wire it onto a reachable route and pass the decoded body to a handler, and exposure is further reduced where an effective body limit is applied after decompression. No public exploit code has been identified at time of analysis; the vendor fixed the issue in Echo v4.16.1 by adding a configurable maximum decompressed size.
Echo v4's opt-in BodyDump middleware can be driven to exhaust process memory by unauthenticated remote clients that send large request bodies or cause large responses on routes where the middleware is enabled, resulting in denial of service. Versions 4.0.0 through 4.16.0 are affected; BodyDump is not enabled by default, so default Echo deployments are not exposed. The flaw is fixed in 4.16.1, and no public exploit has been identified at time of analysis.
MailWatch for MailScanner 1.2.26 and earlier applies the per-role tenant filter when listing or reading quarantined mail but does not apply it on the quarantine action endpoint, so any authenticated tenant account - the low-privilege U/user, D/domain-admin and H/host roles, not just A/admin - can act on other users' and domains' quarantined messages. By supplying an arbitrary, enumerable message id to mailscanner/quarantine_action.php, an attacker can force-deliver held mail (including malware or phishing that the quarantine was containing) to the recipient's inbox or permanently delete it, giving high integrity and availability impact with no confidentiality impact (CVSS 8.1, AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H). The advisory documents a reporter reproduction against v1.2.26; there is no CISA KEV entry and no confirmed active exploitation, and the practical limiting factor is that the attacker must already hold a valid low-privilege account on the instance, making a malicious or compromised internal/tenant user the realistic threat.
Unauthenticated remote code execution is possible in Red Hat JBoss Enterprise Application Platform 7 and 8 when the server runs in -secmgr mode with the openjdk-orb CORBA/IIOP listener exposed on TCP 3528. An attacker who can reach that listener can send a CDR-encoded object whose attacker-supplied codebase URL is honoured by JDKBridge during unmarshalling, causing the server JVM to load and instantiate arbitrary classes from a remote location before EJB security interceptors are evaluated. Exploitation is gated on non-default conditions - the -secmgr startup flag and a network-reachable IIOP/CDR listener - and the sources do not confirm active exploitation (CISA KEV) or verified working exploit code; the decision label is 'this_week', indicating a credible high-severity threat that is not a drop-everything emergency.
CVE-2026-109411 is tracked through the Ubuntu vendor channel, which indicates the affected code is a package distributed by Ubuntu, but the supplied record carries no description, CVSS vector, CWE classification, or reference links, so the specific package, the vulnerable versions, and the resulting impact are all unverified. No public exploit code or proof-of-concept reference is present in the supplied data, and risk cannot be meaningfully quantified from the supplied data. The only prioritization signal available is the vuln.today decision label 'this_month', which places it below immediate-action items.
Mattermost server 11.7.x through 11.7.10, 11.8.x through 11.8.5, and 11.9.x through 11.9.1 can be induced to replace an installed plugin and execute code on the server when an authenticated user with posting rights in a channel visible to a system administrator crafts a post containing a forged mention reminder and the administrator clicks it. The Agents plugin's mention reminder component fails to validate the target post ID, so the administrator's browser sends an unintended API request; CVSS 3.1 is 8.0 with PR:L, UI:R, AC:H, and S:C, meaning exploitation needs an authenticated attacker plus a privileged click and is not a default remote path. No public exploit was identified at time of analysis, and the issue is not in CISA KEV; the supplied priority label is this_week.
A stack-based buffer overflow in the prh_sdp_service_search_decode function of the Alpine iLX-F511 in-vehicle head unit (version 7.0.000 per EUVD) allows network-adjacent attackers to execute arbitrary code as root. Exploitation requires Bluetooth radio proximity and that the attacker first pair a malicious Bluetooth device with the target, which depends on user interaction to accept the pairing; after pairing, crafted SDP service-search data is copied into a fixed-size stack buffer without length validation. No public exploit or confirmed active exploitation was identified at time of analysis, and the priority signals (this_week) reflect a genuine high-severity flaw with meaningful prerequisites rather than an emergency.
A stack-based buffer overflow in the vCard parser of the Alpine iLX-F511 in-dash multimedia receiver (build 7.0.0000) lets an attacker within Bluetooth range execute arbitrary code as root on the head unit. The attacker must operate a malicious Bluetooth device and convince the user to connect the iLX-F511 to it, after which a crafted vCard containing contact data is parsed without adequate length validation and overruns a fixed-length stack buffer; no authentication is required on the attacker's side. Reach is proximity-bound and dependent on that deliberate user-initiated pairing, and no public exploit code was identified at time of analysis, so this is a patch-priority issue rather than a mass-exploitation emergency. The flaw was reported through the Zero Day Initiative as ZDI-CAN-29017 / ZDI-26-821.
Out-of-bounds kernel memory writes in Zephyr's GPIO syscall verification layer let a user-mode thread escape the userspace sandbox: in builds with CONFIG_USERSPACE=y, z_vrfy_gpio_pin_configure(), z_vrfy_gpio_pin_get_config() and z_vrfy_gpio_pin_interrupt_configure() checked only the device object and passed the caller-supplied gpio_pin_t straight to the driver, where the sole pin guard was an __ASSERT compiled out of production builds. All releases from 2.2.0 through 4.4.2 are affected, and the attacker must already hold a legitimate grant to a GPIO device object - the grant meant to confine it to that controller's pins. Downstream impact is driver- and SoC-dependent (STM32 EXTI callback array overflow, ITE it8xxx2 out-of-bounds MMIO base pointer, gpio_emul flags[] overflow), yielding supervisor-mode memory corruption, possible arbitrary code execution, or a crash; a public proof-of-concept accompanies the GHSA advisory, though it is not verified as general-purpose exploit code, and there is no KEV or confirmed active-exploitation signal.
Code injection in Ultralytics' parse_model function lets an attacker execute arbitrary Python code with the privileges of the current user when the victim opens a malicious model file or otherwise loads attacker-controlled input. The root cause is CWE-94: a user-supplied string is not validated before being used to execute Python code; the assessed vector is CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, so no privileges are required but user interaction is mandatory. There is no network-facing, zero-click path in the described flaw, and no public exploit has been identified at time of analysis; the vuln.today decision label is 'this_week'.
Deserialization of untrusted data in Ultralytics' load_dataset_cache_file function allows arbitrary code execution in the context of the current user when a victim loads an attacker-supplied dataset whose cache data is processed by that routine. The flaw is rated 7.8 (CVSS:3.0/3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) because exploitation is local rather than network-reachable and depends entirely on convincing the user to open or load the malicious file - a social-engineering prerequisite that meaningfully narrows realistic exposure despite the high confidentiality, integrity and availability impact. Reported to the vendor by Trend Micro Zero Day Initiative (ZDI-CAN-30124 / ZDI-26-816); no public exploit code has been identified at time of analysis and no CISA KEV entry exists, and the source data provides no EPSS score.
Code injection in Ultralytics' parse_model function lets an attacker execute arbitrary Python in the context of the current user when a victim loads a crafted model definition or configuration, such as by visiting a malicious page or opening a malicious file (ZDI-CAN-30123). The CVSS vector is local (AV:L) and requires user interaction (UI:R) with no privileges required (PR:N), giving a 7.8 High severity score with high confidentiality, integrity and availability impact, though code execution is bounded by the victim's own privileges (S:U). No public exploit code has been identified at time of analysis and the flaw has not been reported as actively exploited; the vendor advisory ZDI-26-815 is the primary reference.
OS command injection in Ultralytics' torch_safe_load function allows an attacker who supplies a crafted model file to execute arbitrary code with the privileges of the user who loads it. Reachability is limited: the assessed vector is local (AV:L) with mandatory user interaction (UI:R), so an attacker cannot trigger the flaw across the network and must instead convince the victim to open a malicious model/weights file or visit a page that causes such a load - CVSS 3.0 base score 7.8 (High) is scored PR:N but the practical gate is the victim's action. No public exploit code identified at time of analysis, and realistic exposure is confined to environments that ingest third-party or community weights rather than only trusted, internally produced models.
Code injection in the Ultralytics Python package's check_det_dataset function lets an attacker execute arbitrary Python in the context of the user running the library. Per the supplied CVSS vector the weakness is locally reachable and unauthenticated (AV:L/PR:N), but it is gated by user interaction (UI:R) - the victim must open a crafted file or visit a malicious page that feeds an unvalidated string into the vulnerable call - and the resulting code runs only with the current user's privileges (S:U). No CISA KEV entry or confirmed public exploit code was identified at time of analysis; the only public reference is the ZDI advisory ZDI-26-813, and the CPE string wildcards all Ultralytics versions as potentially affected.
Deserialization of untrusted data in Ultralytics' torch_load function allows code to run in the context of the current user when a victim loads a malicious PyTorch model or weights file, or visits a page that causes such a file to be deserialized. The assessed vector is CVSS 3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (7.8): no authentication is required (PR:N), but the Local vector and mandatory user interaction mean there is no unauthenticated network-reachable trigger, and code execution does not cross a privilege boundary. No CISA KEV entry and no public exploit were identified at time of analysis; priority is scheduled remediation this week rather than emergency response.
Local privilege escalation in the Alpine iLX-F511 in-vehicle media receiver lets code already running as a low-privileged user reach root through an exposed dangerous method in the Fiv service, with high impact to confidentiality, integrity and availability. The attack is local-only and requires a prior foothold on the device (CVSS PR:L), so it is a post-compromise escalation step rather than a remotely reachable entry point; no user interaction is needed once that prerequisite is met. EUVD lists version 7.0.000 as affected, a public ZDI advisory (ZDI-26-820, ZDI-CAN-29095) documents the finding, and no vendor-released patch was identified at time of analysis, with no public exploit identified at time of analysis and no CISA KEV listing.
KaringX ClashMi through 1.0.32.1801 ships an HttpUtils helper that disables TLS certificate validation by default, so any HTTPS response the app fetches - including its auto-update manifest - is accepted regardless of the certificate presented. An attacker who controls or intercepts the proxy node the user routes through can return a forged update manifest that omits the sha256 integrity field and point the updater at a malicious installer, yielding code execution with the privileges of the app when the update runs. Exploitation is unauthenticated (PR:N) but conditional: the adversary must sit in the update request's HTTPS path and the auto-update flow must actually execute, and no public exploit code or CISA KEV entry was identified at time of analysis; the VulnCheck-sourced report is prioritized for remediation this week.
Server-side request forgery in KServe lets any principal that holds namespace-scoped create or update rights on InferenceService custom resources point the model-serving controller at an attacker-chosen destination: the crafted `storageUri` is fetched by the `storage-initializer` init container, which issues arbitrary outbound HTTP/HTTPS requests from inside the cluster. The result is information disclosure rather than data corruption - successful abuse can expose the node's cloud IAM role credentials through instance-metadata endpoints or reach internal-only cluster services that the tenant namespace could not otherwise touch. Exploitation is access-gated, requiring the attacker to already hold those InferenceService RBAC permissions (CVSS PR:L, scope-changed, confidentiality-only), and no public exploit was identified at time of analysis; the vendor rates it this_week, not an emergency.
Grafana OSS and Grafana Enterprise can be tricked into sending server-side requests to an attacker-controlled endpoint that carry the Azure Monitor data source's Azure access token, handing that credential to the attacker. The flaw is only reachable in deployments that have an Azure Monitor data source configured, and only by an authenticated account holding query access to that data source (PR:L) - anonymous users cannot reach it, and instances without an Azure Monitor data source are not exposed. Because the stolen token grants access outside Grafana itself, the vector carries a scope change with high confidentiality impact and no integrity or availability impact; no public exploit was identified at time of analysis and the issue is not in CISA KEV, placing it in a this-week remediation cadence rather than an emergency.
Grafana OSS and Grafana Enterprise 12.4.x through 13.2.x allow an authenticated user who can edit contact points but is denied permission to edit their protected fields to change those protected settings - including a contact point's destination URL - by switching an integration to a legacy schema version, potentially exposing stored credentials and redirecting alert notifications. The underlying issue is an incorrect authorization check (CWE-863) rated 7.7 with a scope change; no public exploit code and no CISA KEV entry are identified at time of analysis, and the vuln.today decision label is 'this_week', making this a credible operational priority rather than an emergency.
Authorization bypass in mongodb/laravel-mongodb can let an authenticated user with basic privileges read, change, or delete documents that an application intended to withhold when it relies on an absence-of-related-record relationship check. The flaw is a type-handling error in relationship query building (CWE-843) that silently compiles that check with an identifier of the wrong data type; exploitation is conditional on the application using this authorization pattern and on a triggering identifier type, matching the assessed CVSS:3.1 vector AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H. No public exploit was identified at time of analysis, and the vendor references release 5.12.0.
OS command injection in Dell PowerProtect Data Domain Virtual Edition allows an attacker who already holds administrative privileges on the appliance to execute arbitrary operating system commands over the network. The flaw affects the Feature Release train from 7.7.1.0 through 8.8 as well as the LTS2024 (7.13.1.0-7.13.1.80), LTS2025 (8.3.1.0-8.3.1.40) and LTS2026 (8.6.1.0-8.6.1.20) builds, and carries a CVSSv3.1 base score of 7.2 (AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). Exploitation is gated by the PR:H prerequisite, so realistic abuse is confined to malicious administrators or attackers who have already obtained admin credentials; no public exploit has been identified at time of analysis, the issue is not in CISA KEV, and the assessed priority is 'this_week' rather than an emergency.
OutOfMemoryError denial of service in jackson-dataformat-protobuf allows a remote unauthenticated attacker to crash a protobuf-consuming service with a 33-byte payload when a length-prefixed string or bytes field has an attacker-controlled varint length near Integer.MAX_VALUE. Affected packages are com.fasterxml.jackson.dataformat:jackson-dataformat-protobuf through 2.22.3 (including 2.18.11 and 2.21.7) and tools.jackson.dataformat:jackson-dataformat-protobuf through 3.2.3 (including 3.1.7); default ProtobufMapper configurations are vulnerable, and the evidence confirms that maxStringLength, maxDocumentLength, maxNestingDepth, and -Xmx tuning do not prevent the allocation failure. This is a genuine but bounded priority: impact is availability-only, and exploitation requires that the service deserialize attacker-reachable protobuf using a schema with an attacker-influenced string or bytes field; the advisory includes a 33-byte reproduction confirmed against shipping 2.21.7 and 3.1.7 jars, while no CISA KEV listing is indicated.
Arbitrary file upload in the Affiliate Toolkit WordPress plugin through 3.9.2 lets authenticated contributor-level users place files that may be executable onto the server, which can lead to remote code execution, though the path is only reachable when the plugin's 'import product image' option is enabled. The upload_image routine in ATKPTools.php validates uploads with a weak Content-Type prefix check and derives the file extension from the attacker-controlled URL path with no dangerous-extension stripping, so a crafted image URL attached to a product post can carry an executable extension past the check. No CISA KEV entry or public exploit code is associated with this CVE at time of analysis, and the required authenticated foothold, non-default setting and high attack complexity temper the practical priority.
MongoDB Database Tools builds prior to 100.20.0 (specifically 100.19.0, compiled with Golang 1.26.8) will accept TLS server certificates chaining to the eMudhra CA, which Go's crypto/x509 denylist only began rejecting in Golang 1.27.3. An attacker holding a man-in-the-middle position on the network path and a usable eMudhra-issued certificate for the targeted hostname could therefore intercept DB Tools connections to a MongoDB server and read or alter traffic; the victim must actively initiate the connection. No public exploit code or confirmed active exploitation was identified at the time of analysis, and the flaw is resolved in DB Tools 100.20.0.
Authenticated SQL injection in OpenCATS prior to 0.10.0 lets any logged-in user who can reach the home Calls DataGrid (home:CallsDataGrid) or activity DataGrid (activity:ActivityDataGrid) rewrite the date-filter SQL and read data beyond their intended scope, including user accounts, candidate records, contacts, company records, job orders and activity history. The flaw sits in the request-controlled period, startDate and endDate parameters, which are concatenated into SQL date comparisons in modules/home/dataGrids.php and modules/activity/dataGrids.php without validation or escaping; a valid OpenCATS login is required and unauthenticated exploitation is not established. The confidentiality impact dominates (the data exposure is the practical harm), and no public exploit code was identified at time of analysis; the vendor-released patch is OpenCATS 0.10.0.
Out-of-bounds write in Dell PowerProtect Data Domain allows a low-privilege authenticated remote attacker to trigger memory corruption and deny service on affected appliances. The exposure spans Feature Release 7.7.1.0 through 8.8 and LTS2024 7.13.1.0 through 7.13.1.80, LTS2025 8.3.1.0 through 8.3.1.40, and LTS2026 8.6.1.0 through 8.6.1.20. The assessed impact is availability-only (C:N/I:N/A:H); no public exploit was identified at time of analysis, and priority is this_week rather than emergency.
Denial of service in jackson-dataformat-protobuf (2.21.6-2.21.7, 2.22.0-2.22.3, 3.1.6-3.1.7 and 3.2.2-3.2.3) lets an 8-byte malformed protobuf message force an oversized buffer allocation that ends in OutOfMemoryError, so any application that streaming-parses untrusted protobuf against a schema containing a string-keyed map (map<string, V>) is exposed. The overflow occurs in ProtobufParser._readStringKey(), where a declared key length of 0x7FFFFFFF wraps the signed bounds check and reaches TextBuffer.expandCurrentSegment(); StreamReadConstraints (maxStringLength, maxNameLength, maxDocumentLength, maxNestingDepth) do not block it, and JVMs started with -XX:+ExitOnOutOfMemoryError terminate outright (observed exit code 3). The CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), consistent with pure availability impact and no demonstrated confidentiality or integrity effect; a working proof-of-concept payload is documented in the vendor advisory, but there is no CISA KEV listing and no confirmed active exploitation, and the vuln.today decision label places remediation in this week's queue.
Eager, unbounded memory allocation in the asynchronous Smile parser (NonBlockingByteArrayParser) lets a Smile feed of roughly ten bytes force a byte[] allocation of approximately 2 GB before any body bytes are consumed, producing an OutOfMemoryError that crashes the request or processing thread on reactive/async Smile endpoints; a VInt crafted to overflow int instead yields a negative length and a NegativeArraySizeException that is not a JacksonException and so escapes the parser contract. Only applications that construct the non-blocking parser via SmileFactory.createNonBlockingByteArrayParser and feed it attacker-supplied Smile bytes are exposed - the blocking SmileParser already contains the (value >>> 25) overflow guard - and no authentication, privileges or user interaction are required beyond the ability to submit data for parsing (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CWE-789). No public exploit code has been identified at time of analysis, although the upstream advisory includes a code-verified reproduction recipe, and fixes are published across all supported branches.
Stored cross-site scripting in the Menu Cart for WooCommerce plugin before 3.2.1 allows unauthenticated attackers to persist crafted cart item variation data that executes in another user's session when the cart slide-out is rendered, including a logged-in administrator's session. Execution requires user interaction: a victim must load a page that displays the stored payload. EPSS is 0.19% (percentile 9%), no public exploit is identified at time of analysis, and the vendor has released version 3.2.1 as the fix.
Unauthenticated SQL injection in the AVideo-Encoder streamer login endpoint (objects/login.json.php) lets remote attackers read arbitrary data from the encoder database, including stored upstream streamer credentials, allowlist configuration and job queue records. All deployments prior to 8.1.0 are affected, and exploitation additionally requires the operator to have left the streamer allowlist empty (the default) and to be reachable by an attacker-controlled login-response host. CVSS 3.1 base score is 7.5 (HIGH), driven entirely by confidentiality impact from a network-reachable, low-complexity, unauthenticated attack; there is no CISA KEV entry, exploitation in the wild is not confirmed, and while the vendor advisory documents a public proof-of-concept reproduction, it is not verified as working exploit code.
Broken access control in the Bricks Builder WordPress plugin/theme through version 2.4.3 lets unauthenticated remote attackers read content that WordPress would otherwise withhold, including draft and private posts and WooCommerce coupon records, through the plugin's /wp-json/bricks/v1/query_result REST endpoint. An attacker submits crafted post_status and post_type values inside the originalQueryVars parameter; the required nonce is described as publicly obtainable, so it does not act as a real barrier, and no authentication or user interaction is needed. Scored 7.5 with confidentiality-only impact (CWE-862) and flagged as a this-week priority; no public exploit identified at time of analysis.
Unauthenticated attackers can leak password hashes, email addresses, and post metadata from WordPress sites running Bricks Theme 2.4.3 and earlier by injecting dynamic-data tags through the query_result REST endpoint. The flaw is remotely exploitable with no authentication or user interaction (CVSS 7.5, confidentiality-only impact), and the vendor has released Bricks 2.4.4 as the fix. No CISA KEV entry is present and no public exploit was identified at time of analysis, but the unauthenticated confidentiality impact makes this a high-priority update.
Server-side request forgery in Happy DOM's @happy-dom/server-renderer package (versions <= 21.0.1) lets unauthenticated remote attackers redirect the proxy's outbound fetch to any HTTP or HTTPS endpoint the host can reach - including localhost and internal services - and read the relayed response headers and body. The flaw is limited to deployments that run ServerRendererServer in reverse-proxy/SSR mode with a configured server.targetOrigin and expose its HTTP/2 port; using happy-dom purely as a DOM or test library does not trigger it. Version 21.0.2 fixes the issue by rejecting any request whose resolved origin no longer matches targetOrigin, and the vendor advisory includes a complete proof-of-concept reproduction (Dockerfile plus poc.py) that demonstrates the bypass and the leaked internal response.
Labstack Echo's global Static middleware serves files whose paths were percent-encoded to dodge route- or group-level middleware guards: when `middleware.Static` is mounted with `e.Use(...)` and an application protects a path such as `/admin` with a group middleware, a request for `/admin%2Fsecret.txt` skips the guard because the router matches on the raw, still-encoded path, yet the handler opens and returns the same file because it reads the already-decoded `c.Request().URL.Path`. Echo v5 releases from 5.0.0 before 5.4.0 and v4 releases before 4.16.0 are affected; the advisory ships a reproduction PoC against v5.3.1 (literal path returns 401, `%2F` form returns the file) and there is no CISA KEV entry or confirmed active exploitation. Impact is bounded to files already inside the served static root - nothing outside the root is reachable - so this is an authorization-consistency flaw exploitable only by deployments that both publish a directory statically and rely on a route guard, rather than keeping sensitive files out of that root.
Quadratic-time denial of service in RE2JS (npm re2js 2.2.0 through 2.8.6) lets attacker-influenced text pin a CPU core when an application compiles a lookbehind pattern with the opt-in RE2JS.LOOKBEHINDS flag and scans it with a repeated-matching API such as matcher().find() in a loop, matchAll(), split(), or matcher().replaceAll(). The engine's advertised linear-time guarantee breaks down because lookbehind automata are re-seeded from offset zero on every match request, so a dense match stream produces Θ(n²) total work - roughly 36-39 seconds of CPU on a single 16,000-character input in the reporter's measurement. No authentication, user interaction, or crafted payload is required: ordinary dense alternating input triggers it, and on Node.js the single-threaded worker is frozen for the duration. No CISA KEV listing is present in the supplied data; a full copy-paste reproduction script is published in the vendor advisory and fix PR, though it is not independently verified as working exploit code here. Fixed in 2.8.7.
An integer overflow (CWE-190) in the deep-packet-inspection certificate scanner of Juniper Networks Session Smart Router allows a remote attacker to deny service by feeding a specially crafted TLS server certificate through the inspection path. Per the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), the flaw is network-reachable, low complexity, and requires no authentication or user interaction, but its entire impact is availability - no confidentiality or integrity effect is assessed. Exposure is bounded by configuration: only deployments in which the DPI certificate scanner actually inspects attacker-influenced TLS certificates are reachable, and whether that inspection is enabled by default is not confirmed in the available sources; no public exploit has been identified at time of analysis, and vulnerability prioritization places this in the this-week remediation window rather than an emergency one.