A backdoor weakness in D-Link DIR-505 firmware 1.10B02 allows remote, unauthenticated attackers to manipulate the accu, pass, code, hash, and cmds arguments handled by the main function of the Web Management CGI at /secmark1524.cgi, resulting in a hidden access path into the device. Per the CVSS 3.1 assessment (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) no credentials or user interaction are needed, so any unit with its web interface reachable from the attacker's position is exposed; exposure is limited mainly by WAN-side reachability and by the fact that this is a discontinued product on a specific firmware build. A public PoC reference exists on GitHub; it is not verified as working exploit code, and no confirmed active exploitation has been identified at time of analysis.
Unauthenticated remote attackers can exhaust EspoCRM server workers by concurrently sending a small number of large API requests that drive the password-redaction regular expression applied during API error handling into excessive CPU consumption, degrading or denying service to legitimate users. EspoCRM versions through 10.0.7 and 9.3.10 and earlier are affected; fixes are released in 10.0.8 and 9.3.11. A public advisory exists and a PoC reference is noted, though it is not verified as working exploit code; the vulnerability is not confirmed as actively exploited, and impact is limited to availability (no confidentiality or integrity loss).
Arbitrary file upload in the WordPress plugin The Innovative Form Builder - IvyForms, affecting all versions up to and including 1.5.1, allows a user holding the custom add_edit_forms capability to publish a File Upload field whose allowed-extension list contains a dangerous type such as .php, after which an unauthenticated visitor can push an executable file through the public /wp-json/ivyforms/v1/form/submission/ REST route and achieve remote code execution. Exploitation is therefore two-stage: the first stage requires an account with form-editing rights and a deliberately permissive form configuration, while the second stage - the actual upload - needs no authentication and no user interaction from the victim. The 8.8 CVSS score reflects post-configuration impact rather than immediate exposure, since a site whose forms only allow benign extensions is not exploitable; no public exploit code was identified at the time of analysis and the plugin is not listed in CISA KEV, with priority assessed as this_week.
Remote code execution in Rank Math SEO for WordPress (all versions through 1.0.276) allows authenticated users with Contributor-level access or higher to inject a PHP object through the updateMeta REST API endpoint and, using a POP chain present in the plugin, write a webshell into the uploads directory. The CVSS 3.1 score is 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), and the principal barrier is the Contributor+ account requirement; sites that do not grant that role to untrusted users have a smaller exposed population. No public exploit was identified at time of analysis.
Grafana OSS and Grafana Enterprise 13.2 installations that have explicitly enabled the experimental kubernetesSsoSettingsApi feature toggle let any authenticated user read SSO client secrets and modify instance-wide SSO configuration, because the SSO settings endpoints are missing an authorization check (CWE-285). Default deployments are not exposed, since the toggle ships disabled, and an attacker needs a valid Grafana account but not the SSO-settings permission that should normally be enforced. No public exploit code or confirmed active exploitation has been identified at time of analysis; the Grafana security advisory is the authoritative reference for fixed releases and any interim guidance.
Privilege escalation in Dell PowerProtect Data Domain Feature Release 7.7.1.0 through 8.8 allows an authenticated, low-privileged remote attacker to obtain high-impact confidentiality, integrity, and availability effects on the appliance. Dell has released a vendor fix in 8.9.0.0; no public exploit has been identified at time of analysis, and the issue warrants prompt remediation rather than emergency action.
Cross-site request forgery in the VikRentCar Car Rental Management System plugin for WordPress (all versions through 1.4.8) lets an unauthenticated attacker write arbitrary PHP into the plugin's own template files - including site/helpers/email_tmpl.php - which loadEmailTemplate() and loadPdfTemplate() later include(), achieving remote code execution on the server. The condtext_update_tmpl handler lacks a working nonce check, so the only prerequisite beyond an active plugin is luring a logged-in administrator into clicking a link or visiting a page that fires the forged request (CVSS 3.1: 8.8, AV:N/AC:L/PR:N/UI:R). It is not in CISA KEV and no public exploit code has been identified at time of analysis; Wordfence-driven triage places remediation in this week's queue rather than emergency response, and a forged request is reliable against default installs once an administrator is tricked.
Cross-site request forgery in the MemberPress plugin for WordPress through 1.14.1 allows unauthenticated attackers to change a logged-in member's email address, and the resulting mailbox control can be escalated to full account takeover through the plugin's password-reset functionality. The root cause is a bypassable nonce check in save_profile_fields(): the guard is written as an isset() condition at line 1119, so a request that simply omits the nonce parameter skips verification entirely. Exploitation is not automatic - the attacker must lure a currently authenticated user into clicking a crafted link or loading an attacker-controlled page so the forged request rides that user's session - and no public exploit identified at time of analysis; it is rated a genuine but second-tier priority (this_week).
AnkiMCP Server addon 0.20.0 and earlier ships a FastMCP Streamable HTTP listener enabled by default on 127.0.0.1:3141 with DNS-rebinding protection globally disabled, so a malicious web page that rebinds a hostname to loopback can complete MCP `initialize`, enumerate tools with `tools/list`, and dispatch `tools/call` against the victim's Anki collection without any bearer token, API key, session secret, or Host/Origin allowlist check. Because the flaw needs the victim to browse an attacker-controlled page while Anki and the listener are live, and depends on successful rebinding and timing (CVSS 3.1 AV:N/AC:H/PR:N/UI:R/S:C), the practical window is conditional rather than continuous; the vendor GHSA includes a reproduction harness that reaches real MCP tool dispatch with substituted Anki bridge responses, but it is not verified as working exploit code that modifies a real collection. There is no CISA KEV entry and no confirmed active exploitation at time of analysis; default impact is unauthorised read of the collection plus non-destructive note/deck creation and updates, since destructive tools stay hidden unless `enabled_destructive_tools` is opted into.
Authorization bypass in the Rucio `/credentials/signurl` REST endpoint lets any holder of a valid auth token obtain presigned read, write or delete URLs for arbitrary objects in cloud-backed storage. The endpoint performs its root-only permission check against the client-supplied `X-Rucio-Account` header rather than the token-authenticated identity, so a low-privilege user can simply send `X-Rucio-Account: root` and have the server sign a URL with the RSE's stored S3/GCS/Swift credentials. Exploitation requires an authenticated account (CVSS PR:L) and a cloud-backed RSE, with no user interaction; the advisory documents a proof-of-concept request, and no active exploitation is confirmed (not in CISA KEV).
Authenticated command injection in WSO2 Business Process Server and the BPS profile of WSO2 Enterprise Integrator allows any valid low-privileged account to execute arbitrary OS commands through insufficiently validated input parameters on the BPMN System REST APIs. Rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/C:H/I:H/A:H, CWE-78), the flaw is network-reachable and needs no user interaction, but impact is bounded by the privileges of the product's runtime account - a least-privileged service account limits damage while a root/administrator runtime account yields full host compromise. No public exploit code, PoC reference, or CISA KEV entry appears in the available intelligence; the vendor (WSO2) published advisory WSO2-2026-5692 and prioritization is 'this_week'.
Filesystem sandbox escape in Wasmtime's wasmtime-wasi crate allows a sandboxed guest on macOS or FreeBSD to move host directories accessible to the host process into its own sandbox and then read or write their contents, defeating the runtime's core isolation guarantee. Affected releases are 36.0.17 and earlier, 37.0.0 through 48.0.5, and 49.0.0 through 49.0.2; Linux and Windows hosts are explicitly not affected. Exploitation requires a guest already executing with write access to at least one sandbox directory, and no public exploit code has been identified at time of analysis - though the vendor notes the bug affects every published version as of the advisory and provides no workaround other than upgrading.
Path traversal in Ultralytics's Google Drive download handling lets remote, unauthenticated attackers place files outside the intended download destination and ultimately execute arbitrary code in the context of the current process - provided the victim first visits a malicious page or opens a malicious file. The flaw (CWE-22, ZDI-CAN-32376) is rated 8.8 with a UI:R vector, so it is interaction-gated rather than a self-propagating or wormable issue, and it only applies where the application actually exercises the Google Drive download code path. No public exploit code is confirmed, the CVE is not listed in CISA KEV, and no EPSS score was supplied; the vuln.today decision label places it at this_week priority - genuine and worth scheduling, not a drop-everything emergency.
A stack-based buffer overflow in the Android Auto service on Alpine iLX-F511 head units lets network-adjacent attackers run arbitrary code as root without authentication or user interaction. The flaw is an unchecked length on user-supplied data copied into a fixed-length stack buffer (CWE-121), rated CVSS 8.8 High (AV:A/AC:L/PR:N/UI:N, C/H/I/H/A:H); successful exploitation grants full control of the device in the root context. Confirmed affected firmware is iLX-F511 7.0.000 per ENISA EUVD-2026-112205; no public exploit code and no CISA KEV listing were identified at time of analysis, and the practical constraint is that an attacker must be within the Android Auto connection range (wireless or USB proximity) rather than able to reach the unit over the open internet.
Remote code execution in the framework service of the Alpine iLX-F511 infotainment head unit allows network-adjacent attackers to run arbitrary code as root on affected installations, specifically the 7.0.000 firmware listed by EUVD. Per the assessed CVSS vector (AV:A/AC:L/PR:N/UI:N), no authentication and no user interaction are required - the only real obstacle is proximity, since the attacker must reach the device over the same local network segment, Wi-Fi, or adjacent link rather than from the internet. At the time of analysis there is no CISA KEV listing and no public exploit identified; the ZDI advisory (ZDI-26-824) is the primary reference, and the vulnerability is rated this_week rather than emergency priority: credible and high-severity, but gated by the adjacency requirement.
Juniper Networks Session Smart Router and Session Smart Conductor are exposed to OS command injection through AccessManager, allowing a user who already holds config-write privileges to obtain arbitrary command execution as root by supplying a crafted value in the YANG configuration. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) reflects a network-reachable, low-complexity flaw that is gated by authentication (PR:L) rather than by any user interaction, with full confidentiality, integrity and availability impact once triggered. No public exploit code or active exploitation has been identified at time of analysis, and the realistic threat is confined to lower-tier administrators, insiders or holders of compromised management credentials.
Stack buffer overflow in the DHCP client of Juniper Session Smart Router (CVSS 8.8) lets an unauthenticated attacker on the same local network segment execute arbitrary code by sending a malicious DHCP reply. The CVSS vector AV:A/AC:L/PR:N/UI:N confirms the attack is adjacent-network only, requires no credentials or user interaction, and is not internet-routable; the router must be acting as a DHCP client that accepts and parses the reply. No public exploit was identified at time of analysis, and the supplied sources do not confirm active exploitation.
An authenticated REST API user on Juniper Networks Session Smart Router or Session Smart Conductor can use the ConfigDirector certificate and private-key endpoints to supply a pathname that escapes the intended restricted directory, giving read, overwrite and delete access to arbitrary certificate and key files on the host filesystem. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) - network reachable, no user interaction, but gated behind valid REST credentials, which is the primary limiting factor. No public exploit code and no confirmed active exploitation were identified at time of analysis; the vulnerability is tracked as a this-week priority rather than an emergency, and Juniper advisory JSA112183 is the authoritative reference for affected and fixed releases.
Authenticated OS command injection in the AccessManager component of Juniper Networks Session Smart Router and Session Smart Conductor allows a low-privileged remote user to execute arbitrary commands and delete arbitrary files by way of the deletion of an audit rule. The flaw carries a CVSS score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), and the principal limiting factor is the authentication requirement: this is not reachable by a fully unauthenticated attacker, and exploitation is confined to the audit-rule deletion path within AccessManager. No public exploit code has been identified at time of analysis and there is no CISA KEV confirmation of active exploitation; the priority signal places it in the current week's remediation queue, and JSA112183 should be consulted to confirm exact affected and fixed versions.
Arbitrary code execution and privilege escalation on Juniper Networks Session Smart Router and Session Smart Conductor occur when the PCLI component processes cache files whose authenticity it never verifies. Exploitation is not remote against a default install: consistent with the assessed vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, an attacker must already hold write access to the model cache directory so that PCLI will ingest the tampered cache file - an authenticated, low-privileged local foothold, even though Juniper's published 8.8 score uses AV:N/AC:L/PR:L/UI:N. No public exploit code was identified in the available intelligence at the time of analysis; the vendor reference is advisory JSA112183, and impact once triggered is full loss of confidentiality, integrity and availability.
A link-following flaw (CWE-59) in the unauthenticated web server handlers of Juniper Networks Session Smart Router and Session Smart Conductor lets a local unprivileged user abuse unauthenticated API endpoints to overwrite arbitrary files with root privileges, giving high confidentiality, integrity and availability impact. The exposure is restricted to Mist-managed routers and unmanaged routers that have not yet been onboarded to a Conductor; routers already managed by a Conductor are explicitly unaffected, which meaningfully narrows the exposed population. No public exploit code or confirmed active exploitation was identified in the available sources, and exploitation requires a local account on the device.
The Storage Node edit route in FOG Project's PHP API (PUT /fog/storagenode/{id}/edit) authenticates the request but never checks whether the caller is an administrator, so a low-privileged uType=1 "mobile" account holding both its own API token and the server-wide FOG API token can rewrite a node's user, pass and ftppath fields. When storage replication is enabled and a usable node exists, the root-owned FOGImageReplicator service interpolates those attacker-controlled values into an lftp command invoked through proc_open(), turning the API write into root-level command execution on the imaging server (CVSS 3.1 base 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, assessed with a changed scope for the pivot from the web process into the root service). This is not remote-unauthenticated: exploitation requires API-enabled uType=1 credentials, the additional global API token secret, replication enabled, and at least one Storage Node the replicator will actually contact, so real-world exposure is configuration-dependent rather than universal; no public exploit code and no CISA KEV entry were identified at time of analysis, although the upstream advisory publishes detailed reproduction steps.
PHP object injection in Phoenix Media Rename through 3.13.5 allows an authenticated WordPress user with low-level privileges to trigger unsafe deserialization, which can lead to arbitrary object instantiation and high confidentiality, integrity, and availability impact. The plugin is affected from n/a through 3.13.5, and the supplied CVSS vector confirms network access with low privileges and no user interaction; the exact vulnerable feature or parameter is not described in the available sources. No public exploit identified at time of analysis, and the input does not list a fixed version.
GS Logo Slider, a WordPress plugin from GS Plugins, is affected through version 3.8.9 by PHP object injection: untrusted data reaching a deserialization routine lets an attacker with at least low-privilege access on a WordPress site instantiate arbitrary objects, with a CVSS score of 8.8 reflecting high confidentiality, integrity and availability impact. Because exploitation depends on a usable POP gadget chain being present in the plugin, WordPress core, or another installed plugin or theme, real-world risk varies by installation; the specific vulnerable parameter and trigger are not described in the available sources. A public PoC reference exists in the Patchstack advisory, but it is not verified as working exploit code, and there is no confirmed active exploitation (no CISA KEV listing).
Stack-based buffer overflow in Dell PowerProtect Data Domain allows a low-privileged authenticated remote attacker to potentially gain unauthorized access and affect confidentiality, integrity, and availability. The flaw affects Feature Release versions 7.7.1.0 through 8.8 and the listed LTS2024, LTS2025, and LTS2026 ranges; exploitation requires network reachability to an affected service plus valid low-privileged credentials, so it is not exploitable by a fully unauthenticated attacker. No CISA KEV entry or public exploit is identified at time of analysis, and the vuln.today decision is this_week, a non-emergency prioritization.
OS command injection in Dell PowerProtect Data Domain (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, LTS2026 8.6.1.0 through 8.6.1.20) lets a low-privileged, authenticated remote attacker execute arbitrary operating system commands on the appliance, with high confidentiality, integrity and availability impact. The credential prerequisite is the main limiting factor: an attacker must already hold valid low-level access to the Data Domain system, so unauthenticated internet exposure alone is not sufficient. No public exploit code or CISA KEV confirmation was present in the available sources at time of analysis, and the reference metadata did not supply a fixed version or EPSS score; the priority label is this_week, and the risk is credible but rests on thin signals.
Dell PowerProtect Data Domain appliances running 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, or LTS2026 8.6.1.0 through 8.6.1.20 fail to constrain a user-supplied pathname to its intended restricted directory (CWE-22), allowing an attacker to reach files outside that directory. Exploitation requires the attacker to already hold low-privileged credentials on the appliance (CVSS:3.1/AV:N/AC:L/PR:L/UI:N) and network reachability to it, so a fully unauthenticated remote attacker cannot use it directly; the assessed impact is to confidentiality - unauthorized filesystem read access - and no user interaction is needed. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, but it is a genuine priority for this week's patch cycle rather than an emergency, and the specific feature or request parameter that accepts the traversable pathname is not described in the available sources.
EagleCloud Aquila on-premises deployments through version 2.6.7.2 expose stored access keys, secret keys, and deployment secrets to unauthenticated remote attackers who abuse authentication handling in the tunnel gateway and provisioning interfaces. The flaw carries a CVSS 4.0 base score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N) with impact confined to confidentiality (VC:H, VI:N, VA:N), matching an independent assessment of CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N - the disclosure describes the outcome as privilege escalation, but the measurable effect is read-only access to high-value credentials rather than modification of the system. No CISA KEV listing and no public exploit code were identified in the supplied intelligence, and the vulnerability is triaged as "this_week" priority; exploitation requires that the tunnel gateway or provisioning interfaces be network-reachable on an affected on-premises installation.
Authenticated users holding the Xerte Online Toolkits 'system' permission can execute PHP on servers running versions through 3.15.5 by importing a crafted language-pack ZIP that contains a .inc file and then requesting that file through the language parameter. The upload path is import_language.php and execution is reached through functions.php, so a privileged attacker can turn a permitted language-import workflow into remote code execution. The high-privilege requirement confines realistic exposure to deployments with multiple trusted operators, shared administrative credentials, or a compromised system-level account; no public exploit identified at time of analysis.
Missing 3D Secure hash verification in mews/pos (CVE-2026-118377) through 2.0.0 allows unauthenticated remote attackers to forge payment callbacks for GarantiPos, PayForPos, and InterPos 3D Pay and 3D Host transactions, potentially completing orders without payment. The flaw affects applications using those three gateways in those two 3D models; integrity impact is high while confidentiality and availability are unaffected. VulnCheck assigns a this_week priority, an upstream fix is available via PR #305/commit 7c59d42, and no public exploit identified at time of analysis.
Quadratic CPU exhaustion in python-markdown2 (through 2.5.5) lets remote attackers burn processing time by submitting Markdown containing repeated unclosed inline link or image destinations such as '[a](' or ' is exposed because the standard inline anchor/image parser is the vulnerable path. Impact is confined to availability of the rendering worker (VC:N/VI:N/VA:H, assessed CVSS:3.1 8.7-equivalent severity); no public exploit code was identified at time of analysis, and the issue is not in CISA KEV. An upstream fix exists as a pull request rather than a confirmed tagged release.
Unauthenticated denial of service in OvenMediaEngine through 0.21.0 lets a remote sender stall origin-to-edge stream relay by submitting crafted OVT packets whose header payload_length field exceeds 32750, holding connections open indefinitely while buffered memory accumulates. The flaw sits in OvtPacket::LoadHeader() in the OVT packetizer/depacketizer path (CWE-770, allocation of resources without limits or throttling); the assessed vector is AV:N/AC:L/PR:N/UI:N with availability-only impact, matching the 8.7 CVSS 4.0 score. Exploitability is bounded in practice by exposure: OVT is normally an internal origin-to-edge link, so internet-facing risk exists only where that listener is externally reachable. No public exploit code has been identified at time of analysis, and the vendor fix is referenced upstream (commit ce316146, issue #2330).
n8n versions before 2.43.5 and 2.44.x before 2.44.1 allow an authenticated member who can create and run workflows to bypass project boundaries and list, read, modify, and delete Data Table rows in all projects by supplying a crafted workflow ID such as __proto__. The flaw is a prototype-pollution-style authorization bypass in the in-memory workflow owner-project cache, rated 8.7 with PR:L in the CVSS vector, so exploitation requires a member account and the Data Tables module. Vendor fixes are available in 2.43.5 and 2.44.1; no public exploit was identified at time of analysis, and KEV status was not provided.
Bandit's HTTP/2 request body reader amplifies memory use, letting an unauthenticated remote client make a server hold roughly 5 to 8 times the body bytes it sends in stream process memory. Affected are versions from 0.3.1 before 1.14.1 on listeners where HTTP/2 is enabled and the route's Plug actually reads the request body, which includes anything behind Plug.Parsers for POST, PUT and PATCH. A public proof-of-concept reference exists; it is not verified as working exploit code, and no active exploitation has been confirmed. Vendor-released patch: 1.14.1.
OS command injection in KaliFast's Git remote configuration endpoint allows any authenticated user - including holders of free self-registered accounts - to execute arbitrary commands on the server with www-data privileges by supplying crafted shell metacharacters in the ei_git_repo_url parameter. The flaw is rated 8.7 (CVSS 4.0) and assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, since the low-privilege prerequisite is trivially satisfied by open registration on any reachable instance. It is fixed in version 2026061802; no public exploit code has been identified at time of analysis, and vulnerability-source priority places remediation in the this-week window.
Unauthenticated server-side request forgery in AVideo-Encoder (WWBN / AVideo project) before the 8.1.0 remediation attempt lets anyone who can reach the encoder force it to fetch arbitrary URLs from its own network position, with the raw fetched body reflected back in the JSON login response - enough to harvest cloud instance-metadata credentials or probe internal HTTP, HTTPS, TCP and FTP services. No account or operator interaction is required because the only destination gate (Streamer::isURLAllowed) allows every target when the operator allowlist is empty, which is the default, and TLS peer verification is disabled so untrusted self-signed internal HTTPS endpoints are accepted. A public proof-of-concept reproduction (curl-based) is documented in the vendor security advisory; there is no confirmed active exploitation (not in CISA KEV). Version 8.1.0 is an initial remediation that removes raw-response reflection and adds destination checks, but private-network exemptions and the login TLS-verification default leave the internal-network and TLS variants unresolved.
Authenticated users of Volmarg Personal Management System through 2.1.0 can inject operating system commands into the storage module's tree operation by creating a folder under upload/files whose name contains shell metacharacters such as $(...), then triggering a move or copy of that folder. The unescaped path is passed into a shell call, so the injected payload executes with the privileges of the web server user. The CVSS 4.0 vector requires high privileges (PR:H) and a valid account with access to the storage file manager, and the resulting scope is limited to the web server account; no public exploit code was identified at time of analysis and the case is prioritized for handling this week rather than as an emergency.
Cross-user Store access in LangGraph API (pip package langgraph-api) versions 0.1.2 through 0.14.x lets an ordinary authenticated user read, overwrite, search or delete Store data belonging to another user. The flaw only manifests in deployments running JavaScript or TypeScript custom authentication whose Store authorization handler restricts users by rewriting the requested namespace: the rewritten namespace is not carried across the runtime boundary and applied before the Store operation, so the original (attacker-supplied) namespace is used instead (CWE-639). Python custom authentication and JS/TS handlers that reject unauthorized namespaces rather than rewriting them are unaffected; vendor CVSS 4.0 scores it 8.6 High and the issue is fixed in 0.15.0, with no public exploit identified at time of analysis.
Server-side request forgery in happy-dom (versions up to and including 20.14.6) lets a remote attacker force the Node.js process to issue real HTTP requests to arbitrary internal or cloud-metadata endpoints whenever untrusted HTML containing an <iframe src> or <link rel="stylesheet" href> is parsed under the library's default settings. No authentication, user interaction, or configuration opt-in is required on those defaults, and returned content can expose confidential data such as AWS/GCP/Azure instance credentials, hence the high confidentiality impact (CVSS 8.6, scope changed). No CISA KEV listing or confirmed active exploitation was reported at time of analysis, although the GitHub security advisory and PR #2502 ship a verified proof-of-concept that demonstrates request receipt; external resource loading is off by default from 21.0.0.
Unauthenticated remote denial of service affecting Cisco Secure Firewall Adaptive Security Appliance (ASA) and Threat Defense (FTD) software when the Remote Access SSL VPN service is enabled and secondary authentication is configured on a tunnel group. A crafted request sent while connecting to the SSL remote access VPN triggers logic errors in secondary authentication handling that force the device to reload, disrupting all traffic through the firewall. The CVSS 3.1 score is 8.6 (AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:H); no public exploit code or confirmed active exploitation is identified at time of analysis, and exposure is gated by the non-default secondary-authentication configuration plus network reachability to the VPN listener.
Gearboy's optional `--mcp-http` MCP transport (the affected Gearsystem component) exposes emulator and debugger control tools to any network peer that can route to port 7777, because the socket binds INADDR_ANY while documentation and runtime logging describe a localhost-only service. Unauthenticated POST requests to `/mcp` reach dispatch with no `Authorization`, `Host`, or `Origin` gate, and even a garbage bearer token does not block them, letting a remote caller initialize an MCP session, list tools, and invoke mutating operations such as `write_memory` and `write_z80_register`. Exposure requires the operator to have started the HTTP transport explicitly (stdio is the default MCP mode); impact is bounded to the emulator process, debugging state, and local files the emulator loads as media, with no demonstrated host code execution. Gearboy 3.8.7 contains the patch, and the advisory includes a proof-of-concept reproduction; no confirmed public exploit code or CISA KEV listing is available.
Remote code execution in MONAI's bundle workflow loader (versions 1.2.0 through 1.6.0, fixed in 1.6.1) lets an attacker who publishes a malicious model bundle run arbitrary Python in the context of anyone who loads or runs it. Because ConfigWorkflow.__init__ defaults to the bundle's own configs/logging.conf and hands it to logging.config.fileConfig() without any trust check, a crafted INI handler section executes at object construction - before initialize() or run() - and independently of any MONAI $-expression in the main config, so a bundle with a completely benign train.json still triggers it. Exploitation is gated by user interaction: the victim must fetch and load the attacker's bundle via monai.bundle.load(), monai.bundle.run(), run_workflow(), create_workflow(), or a direct ConfigWorkflow(config_file=...), making this primarily a supply-chain/social-engineering vector against researchers and inference services rather than direct remote exploitation; a public proof-of-concept with dynamic reproduction is published in the upstream advisory, and the issue is prioritized for remediation this week.
DOM-based cross-site scripting in Highcharts Grid (@highcharts/grid-lite and @highcharts/grid-pro) versions 2.0.0 through 3.1.0 allows an attacker who controls the Grid pagination language configuration to inject markup carrying event handlers, which then execute in the origin of the page hosting the Grid when the pagination controls render. No additional user interaction is required once untrusted data reaches the language options and pagination is enabled; the class of impact is script execution in the host page's origin, which the independent assessment scores as scope-changed partial confidentiality and integrity impact with no availability effect. There is no CISA KEV listing and no public exploit code identified at time of analysis, though the vendor advisory, fix commit and workaround are all publicly available, and the vulnerability is prioritised as 'this_week' by vuln.today.
Cross-site scripting in Highcharts Dashboards (npm @highcharts/dashboards) from 1.0.0 through 4.2.1 lets an attacker who can influence dashboard configuration supply an arbitrary chartConstructor value, which the component resolves as an unchecked lookup into the Highcharts namespace and then invokes with the container element and chartOptions; utility members reached this way copy attacker-controlled options onto the container as properties or attributes, so markup and event handlers execute in the origin hosting the page when the board renders, with no user interaction beyond rendering. The CVSS vector requires low-privileged access (PR:L) because the attacker must get untrusted data into the board configuration, and the independently assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:N) rates confidentiality and integrity impact as low with scope change rather than full compromise, while the CNA score is 8.6. No public exploit code and no CISA KEV entry are associated with this CVE at time of analysis, but a vendor workaround and a patched release exist and the issue is prioritized as this_week.
Unauthenticated remote file upload and direct retrieval weaknesses in HCL BigFix AEX allow attackers to place files on the server and then access or download uploaded content without proper authorization. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N) shows the issue is reachable over the network at low complexity with no authentication or user interaction, and the supplied CPE identifies the affected product without a narrower version boundary. No CISA KEV entry or public exploit was identified at time of analysis, but the issue is assessed as a credible high-priority item to address this week rather than an emergency.
Stored cross-site scripting in iCagenda 3.2.1 through 4.0.16 lets an authenticated Joomla user who can create or edit events inject script through a url-type event Custom Field. The payload is stored but requires a second user to view the affected event page, so exploitation is not unauthenticated and depends on victim interaction; exposure is limited to deployments that use the url-type Custom Field feature. No CISA KEV status is indicated, no public exploit identified at time of analysis, and the vuln.today priority is this_week.
Heap buffer overflow in the danoli3 FreeImage fork's animated-GIF playback compositor allows memory corruption when a crafted GIF is loaded with the GIF_PLAYBACK flag; versions before 3.19.25 are affected. The flaw is triggered by a frame whose left offset plus width exceeds the logical screen width, causing GifPlaybackCompositeFrame() and GifPlaybackFillRect() to write past the canvas allocation. Exploitation is conditional: an application must load an attacker-supplied GIF through the multi-page playback path, and the victim must open the file (local vector, user interaction), so no public exploit has been identified at time of analysis, though the vendor fix is a straightforward upgrade to 3.19.25.
A heap buffer overflow in the PBM RLE (ByteRun1) decoder of PluginIFF.cpp in the danoli3 FreeImage fork lets a crafted IFF/LBM image write up to 127 attacker-controlled bytes past the heap-allocated bitmap when a run straddles a scanline end. Applications built on the fork before 3.19.22 are affected; the vector is local (AV:L) with passive user interaction (UI:R) and no authentication requirement (PR:N), so exposure depends on a victim opening a malicious image in a program that routes untrusted IFF/LBM files through this decoder. Exploitation is not confirmed in the wild and no public exploit has been identified at time of analysis, though the vendor has released 3.19.22 with the fix.
Event-handler attribute injection in Highcharts Grid's custom SVG icon definitions (npm packages @highcharts/grid-lite and @highcharts/grid-pro, versions 2.3.0 through 3.1.0) allows an attacker who can influence Grid configuration to execute script in the origin of the page hosting the grid. The flaw lets icon-definition child keys such as onmouseover or onload be written directly onto generated <path> elements; because custom icons override built-ins, the attacker can replace the default column-sort icon shown in every header or the pagination controls without naming a custom icon, and the payload fires when a user hovers over or activates the icon. Exploitation requires that untrusted data actually reach rendering.icons and that a victim interact with the affected icon, so grids with fully static developer-controlled configuration are not exposed; no public exploit identified at time of analysis.
Cross-site scripting in Highcharts Grid Pro 2.0.0 through 3.1.0 lets an attacker who can influence column configuration place event-handler attributes into a column's cells.renderer.attributes or cells.editMode.renderer.attributes map, which are copied verbatim onto the input and select elements the grid creates, so script executes in the origin of the page hosting the Grid. A view renderer plants the handler on the input rendered in every row as soon as the grid draws, while an edit-mode renderer plants it on the input created when a cell enters edit mode, which is focused immediately so an onfocus handler fires the moment editing begins. Exploitation requires that untrusted data reach the Grid configuration and that a user hover over or focus a rendered input or start editing a cell; the Pro DataGrid shipped inside @highcharts/dashboards 3.6.0 is also affected. Fixed in Grid Pro 3.2.0 and Dashboards 4.0.0; no public exploit identified at time of analysis, and the flaw is not reachable when column configuration comes only from fully trusted sources.