Memory exhaustion in the Russh Rust SSH client/server library prior to 0.63.2 allows an authenticated remote peer to stall the rekey state machine and flood SSH_MSG_CHANNEL_OPEN requests, causing ChannelOpenReply entries to accumulate on an unbounded channel until the process is terminated (CVSS 6.5, AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H). The attack requires a valid authenticated session first and abuses the SSH rekey window: the peer sends SSH_MSG_KEXINIT but withholds the required SSH_MSG_KEX_ECDH_INIT, leaving SessionKexState::InProgress so priority_receiver in russh/src/server/session.rs is never drained while the server keeps enqueuing replies. There is no public exploit identified at time of analysis and no CISA KEV listing, so exploitation remains a moderate-priority availability concern gated by how trusted the server's authenticated user population is.
Improper input validation in the sshd-git component of Apache MINA SSHD lets authenticated SSH clients write arbitrary files onto the server by invoking 'git archive' with the single-argument '-o=file.zip' form. Only deployments that use GitPgmCommandFactory to expose remote JGit command execution to SSH clients are affected, and the attacker must hold valid SSH credentials (PR:L), so impact is a conditional integrity violation (C:N/I:H/A:N, CVSS 6.5) rather than a confidentiality or availability compromise. The flaw is an incomplete fix for CVE-2026-58624, which restricted git subcommands but missed the '-o=file.zip' variant; no public exploit code and no confirmed active exploitation were identified at time of analysis, and fixed releases are available (2.20.0 and 3.0.0-M6).
Devolutions Server versions up to 2026.3.5.0 contain a missing authorization flaw in the data source settings API that lets an authenticated, non-administrative user craft a request to disclose stored integration secrets. The vulnerability requires low-privileged credentials (PR:L) and network access, yielding high confidentiality impact with no integrity or availability effect (CVSS 6.5). No public exploit code or confirmed active exploitation was identified at time of analysis; the vendor has released a patched version 2026.3.7.0.
OS command injection in RaspAP's raspap-webgui (raspap-webgui through version 3.5.5) lets an attacker who already holds a low-privileged authenticated session manipulate the cfg_id parameter of ajax/openvpn/del_ovpncfg.php to inject extra arguments/commands through the incomplete escapeshellcmd() filter. The flaw is remote but requires a valid session (CVSS 4.0 AV:N/AC:L/PR:L/UI:N, assessed as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L), and because escapeshellcmd only neutralizes shell metacharacters rather than argument boundaries, the realistic outcome is constrained argument injection affecting integrity and availability rather than unrestricted remote code execution. Publicly available exploit code exists (a referenced GitHub gist), but there is no indication of confirmed active exploitation (CISA KEV); the vendor was contacted and did not respond, and no vendor-released patch has been identified at time of analysis.
OS command injection in RaspAP's raspap-webgui component (versions up to and including 3.5.5) lets an authenticated, high-privilege RaspAP administrator execute arbitrary operating-system commands on the host by manipulating the SSID value that WiFiManager::writeWpaSupplicant writes into the wpa_supplicant configuration. Exploit code has been published publicly and may be used, so the technical details are already circulating, although there is no confirmation of active exploitation (the CVE is not in CISA KEV). Impact is web-admin-to-host-OS escalation rather than external compromise, since valid administrative web GUI credentials are a hard prerequisite; the vendor was contacted early about the disclosure but did not respond, and no vendor-released patched version has been identified.
Local privilege escalation in HPE Networking Instant On firmware 3.4.1.0 and earlier allows an attacker who already holds high-privilege local access to the affected daemon to achieve arbitrary code execution as root. The CVSS 3.1 vector (AV:L/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H, score 6.4 Medium) shows the barriers are steep: the attacker must be local and already privileged, and exploitation is further gated by 'certain preconditions outside of the attacker's control,' consistent with a high-complexity trigger such as timing or transient system state. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV.
SQL injection in the Apache Airflow Teradata provider's compute-cluster example DAG lets an authenticated Airflow user who holds only permission to trigger that DAG - a lower-trust role needing no Teradata credentials of its own - inject SQL fragments through unvalidated DAG Params that are templated directly into Teradata DDL, executing under whatever connection the task runs as and, because the connection id was itself a free-text Param, redirecting the task to any other connection defined in the deployment. Only deployments that actually run the shipped example DAG or a DAG copied from it are exposed; the provider's operator code is unchanged, and versions before 3.7.0 are affected. No KEV entry, EPSS score, or public exploit code was identified at time of analysis, and the vendor/reporter rating is 'low', though the assessed vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H) reflects high confidentiality, integrity, and availability impact when the preconditions are met.
A user-controlled request path that ends in a Windows reserved device name followed by an empty NTFS alternate data stream marker (for example "NUL:") causes Werkzeug's send_from_directory / safe_join helper to open the special device successfully and then block indefinitely, hanging the handling worker. The flaw only manifests on Windows deployments running on NTFS where an application serves attacker-influenced filenames through Werkzeug prior to 3.1.9; Linux and macOS deployments, which are the typical Flask/Werkzeug production case, are unreachable by this condition. There is no confirmed active exploitation (CISA KEV) and no public exploit code identified at time of analysis, and the assessed impact is limited availability loss rather than data exposure or code execution. Vendor-released patch: 3.1.9.
Uninitialized heap memory disclosure in ImageMagick's GIF decoder affects versions before 7.1.2-32 and 6.9.13-57. An unauthenticated remote attacker can supply a crafted GIF to a service that decodes images with a vulnerable ImageMagick, causing the application extension handler to read uninitialized heap bytes and store them as image metadata; if that metadata is returned or otherwise readable, sensitive heap contents may leak. The assessed impact is confidentiality-only and partial (VC:L) with high attack complexity (AC:H), and no public exploit has been identified at time of analysis; the vendor has released patches.
The pbkdf2 npm library through version 3.1.6 lets a long password drive an event-loop-blocking denial of service in its pure-JavaScript fallback (lib/sync.js), because passwords longer than the digest block size are re-hashed by HMAC on every PBKDF2 iteration. Applications are affected only when running on a runtime that actually uses that fallback - Node.js before 0.12, Bun 1.0.0-1.1.34 or 1.2.6 and later, Deno 2.9.0 and later, or code importing lib/sync.js directly - and only when attacker-controlled data is passed as the PBKDF2 password with no reasonable maximum length enforced. No public exploit code was identified at time of analysis; an upstream fix (commit 493d8d8) pre-hashes over-length keys once instead of per iteration, and the issue is a modest-severity availability bug (CVSS 4.0 6.3; independent assessment ~CVSS 3.1 5.3).
Memory corruption in PyPy's pyexpat module can be triggered by a crafted XML document processed through an external-entity sub-parser, because the child parser keeps a raw C back-pointer to a parent parser struct that PyPy's tracing garbage collector may free while the child is still in use, causing bundled libexpat to dereference freed memory on parsed tokens. Affected builds are PyPy releases prior to 3.11.16 and 3.12.14; the flaw is remotely reachable and unauthenticated (CVSS vectors carry PR:N), but exploitation depends on a specific application coding pattern - creating ExternalEntityParserCreate sub-parsers without retaining a reference to the parent parser - and on that code path processing attacker-supplied XML, which is the AT:P attack requirement in the CVSS 4.0 vector. That prerequisite is why the CVSS 4.0 score is 6.3 Medium with only integrity-low impact recorded, and no public exploit code or confirmed active exploitation was identified at time of analysis; vendor-released patches exist.
Credential-bearing SQL API requests issued by the Apache Airflow Snowflake provider can be redirected to an attacker-chosen host, leaking a valid Snowflake bearer token. In apache-airflow-providers-snowflake before 6.18.0 the connection's `account` and `region` fields are interpolated into request URLs without validation - the SQL API endpoint is built as `https://{account}.snowflakecomputing.com/api/v2/statements`, so an `account` value containing `/`, `?` or `#` demotes the intended host to a path, query or fragment and leaves the attacker in control of the request host. The request carries an `Authorization: Bearer` header holding a JWT minted from the connection's private key or a configured OAuth/programmatic access token, and the captured token can then be replayed against the genuine Snowflake endpoint; an attacker needs only connection-edit privileges (authenticated, CVSS PR:L) rather than Dag-authoring rights, and merely edits the connection and waits for an existing Dag to use it. No public exploit was identified at time of analysis, and no KEV, EPSS or SSVC data was supplied by any source, so severity rests on the description and the vendor's own 'moderate' rating.
Command injection in MODSetter SurfSense through version 2.0.3 allows an authenticated low-privilege user to execute arbitrary shell commands on the host by sending a crafted payload to the /api/search-source/connectors/mcp/test endpoint within the MCP Connector Integration component. Exploitation is remote with low complexity and no user interaction, but requires valid credentials and a reachable/configured MCP connector feature. Publicly available exploit code exists (a proof-of-concept was published to a public gist and referenced by VulDB), and the vendor was contacted about the disclosure but did not respond; no official patched version is confirmed, and the signals on severity conflict (vendor CVSS 4.0 base 5.3 versus our assessed CVSS 3.1 vector of 8.8).
Eclipse NetX Duo's DTLS server implementation uses predictable HelloVerifyRequest cookies due to insufficient randomness (CWE-330), enabling unauthenticated remote attackers to bypass source-address validation and potentially facilitate amplification attacks. Affected deployments are those running NetX Secure as a DTLS server with cookie exchange enabled; exploitation requires high attack complexity and no public exploit or active exploitation has been identified. The independent assessment rates this as a moderate, narrow-trigger weakness.
Eclipse NetX Duo's NetX Secure TLS stack accepts empty application-data records without ever generating or comparing their message authentication code, so the receive sequence number advances on records that were never integrity-checked. An unauthenticated remote attacker who holds a man-in-the-middle position on an already-established TLS connection can inject such records into the stream, yielding a bounded loss of integrity and availability (no confidentiality impact). Exploitation is constrained by high attack complexity, no public exploit code has been identified at time of analysis, and the issue is not confirmed as actively exploited (no CISA KEV listing).
Cross-site scripting in serialize-javascript 7.1.1 arises because function values serialized by the library are not fully protected against script-closing tags: the SCRIPT_CLOSE_REGEXP escaping pattern can match across and swallow a second closing tag, so a surviving </script> terminates the embedding script element early and the remaining output is parsed as HTML in the page origin. Exploitation requires an application on the narrow vulnerable release to serialize a function value whose source is attacker-influenced and embed that output inside an HTML <script> element, and a victim must load the resulting page (user interaction); ordinary data values and options.isJSON output are unaffected. The flaw is fixed in 7.1.2, and no public exploit was identified at time of analysis.
OS command injection in mbailey VoiceMode through version 8.10.1 lets an authenticated local attacker who can reach the update_config MCP tool or the 'voicemode config set' CLI persist an arbitrary shell payload that executes as the service user on the next Whisper or serve service start (or reboot). The injected value is written verbatim into ~/.voicemode/voicemode.env, which the start scripts load with bash 'source', so constructs such as $(...) or backticks run even inside double quotes because bash performs command substitution there. This is a real but low-urgency issue: the config tools are not part of the default MCP tool set, so the deployment must have explicitly opted into exposing them, the vector is local (AV:L) with low privileges (PR:L), and execution is deferred until a service restart; no public exploit was identified at time of analysis and CISA SSVC records no observed exploitation. Vendor-released patch: v8.10.2.
The Windows Pageant client inside the pageant Rust crate (pageant/src/wmmessage.rs) trusts a peer-controlled u32 response length read from the 8192-byte Pageant shared-memory mapping, so a local process that impersonates the Pageant window can drive MemoryMap::read to allocate up to roughly 4 GiB and copy past the end of the mapped view. In practice this reliably crashes a russh-based SSH client that queries the agent via AgentClient::connect_pageant, and can conditionally expose adjacent committed memory. The issue is fixed in pageant 0.2.3 (russh v0.63.2); exploitation is local-only (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 6.2), with no CISA KEV entry and no public exploit identified at time of analysis.
Reflected JavaScript injection in oauthlib's OAuth 2.0 RevocationEndpoint (CWE-79) lets an attacker who can influence the JSONP `callback` parameter have arbitrary JavaScript echoed back in the response body, but only on authorization servers that explicitly opt in with the non-default `enable_jsonp=True`. Because JSONP executes in the origin of the including page rather than the auth server, the real impact lands on browser-based OAuth clients that consume the endpoint via `<script src>` and where the attacker can control the callback value (query-parameter injection, a reflected value, or a MITM downgrade); this also requires victim user interaction, which is why the practical risk is assessed as conditionally gated rather than a broad emergency. Fixed upstream in oauthlib 4.0.0, which removes JSONP support entirely; no public exploit identified at time of analysis, though the upstream advisory itself ships a proof-of-concept script demonstrating the verbatim reflection.
Reflected cross-site scripting in the users.php script of coolbeans1212's MateisHomePage-Website lets remote, unauthenticated attackers inject arbitrary JavaScript into a page rendered to a victim who opens a crafted link. A successful attack requires the victim to click an attacker-supplied URL containing a payload in the 'search' GET parameter (CVSS:4.0 UI:P), so the flaw is non-persistent and must be delivered per victim rather than planted once. Publicly available exploit code exists and the issue has been publicly disclosed alongside a vendor commit, but there is no evidence of confirmed active exploitation (no CISA KEV listing); the independently assessed risk is LOW despite the network attack vector, because the product is a niche personal website and impact is limited to script execution in the victim's browser session (C:L/I:L, S:C).
Sandbox escape in Electron desktop applications lets untrusted content rendered in a CSP-sandboxed top-level document open popup windows that inherit the application's full privileged origin instead of the restricted origin intended by the sandbox, exposing that origin's cookies and localStorage. Exploitation requires the application to load untrusted content into a document sandboxed via a Content-Security-Policy 'sandbox' directive that still permits popups, and requires user interaction (window.open or target=_blank) per the CVSS vector (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:L/A:N); applications that deny popups with setWindowOpenHandler are not affected. The flaw is fixed in Electron 41.10.6, 42.9.2, 43.4.1, and 44.0.0-beta.5, and no public exploit code has been identified at time of analysis.
Server-side request forgery (SSRF) in MODSetter SurfSense 0.0.36 and earlier allows an authenticated, low-privilege user to make the backend dereference attacker-influenced URLs by supplying crafted content to the Document Export Feature (the export_document route in surfsense_backend/app/routes/editor_routes.py). Because the server-side export/conversion pipeline (pypandoc/typst) fetches or processes references embedded in document content, a malicious export request can cause the server to issue outbound requests to resources it can reach. Publicly available exploit code exists and the flaw is remotely reachable, but the assessed impact is confidentiality-limited (VC:L) with no integrity or availability effect, making this a genuinely low-severity issue despite remote reachability.
Cross-site scripting in Chrome's WebUI layer allows a remote, unauthenticated attacker to escape the normal web origin boundary and inject script into a privileged chrome:// internal page when a victim loads a crafted HTML page in Chrome versions prior to 154.0.8037.92. Because the vulnerable surface is Chrome's own WebUI (CWE-79) rather than ordinary web content, successful exploitation crosses a trust boundary (CVSS scope change S:C), giving the attacker low-level read and write influence over the privileged page; the vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, base 6.1) confirms no authentication is required but user interaction is mandatory, and no availability impact is assessed. There is no public exploit identified at time of analysis and no CISA KEV listing; Google has released a fixed build, 154.0.8037.92, so risk is concentrated in unpatched installations. This issue is tracked as EUVD-2026-89395 and documented in the September 2026 Chrome stable channel release notes.
Stored cross-site scripting in mall4j through 4.0 arises from unrestricted file uploads in admin FileController endpoints that require only any valid authenticated token and do not validate uploaded file types. An authenticated attacker can upload HTML or SVG files that execute script in an administrator's browser when the administrator opens the uploaded file from the local storage path, and publicly available exploit code exists. Real-world risk is modest because exploitation requires a token and privileged-user interaction, and the impact is client-side stored XSS rather than server-side code execution.
Electron before 41.10.4, 42.5.2, and 43.0.0 fails to propagate HTML iframe sandbox restrictions to popups opened through its OpenURLFromTab navigation path, so an untrusted iframe configured with 'allow-scripts allow-popups' (but without 'allow-popups-to-escape-sandbox') can open a new window that runs with the embedding application's full origin, granting same-origin script access to that origin's cookies and storage. Exploitation requires the target application to embed untrusted web content in such a sandboxed iframe and to trigger a popup - via a scripted target="_blank" link or a middle-click - so the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:L/A:N rating marks this as unauthenticated but user-interaction dependent, with high confidentiality and low integrity impact and a changed scope. Applications that do not embed untrusted content in sandboxed iframes are explicitly unaffected; no public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is fixed by vendor-released versions 41.10.4, 42.5.2, and 43.0.0.
Open redirect in the MediaWiki Collection extension (versions before 1.46.1, 1.45.5, and 1.43.10) allows an unauthenticated attacker to craft a URL that sends a victim to an arbitrary external site after the victim clicks it, which can be used to fake the source of data and to lend the wiki's domain to phishing or credential-harvesting pages. Exploitation requires victim interaction (UI:R) - the target must follow the crafted link - so delivery is social-engineering based rather than autonomous, and the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N yields a moderate score of 6.1 with limited confidentiality and integrity impact and a scope change because the redirect leaves the trusted origin. Only wikis with the Collection extension installed and enabled are exposed; no public exploit code has been identified at time of analysis, and EPSS is very low at 0.14% (3rd percentile), indicating little observed exploitation activity.
Origin validation error in OpenDMARC through version 1.4.2 lets remote attackers trigger incorrect organizational-domain extraction by sending mail from a specially crafted domain, potentially undermining DMARC alignment and allowing spoofed messages to evade DMARC-based filtering. The flaw carries a CVSS 4.0 base score of 5.3 and affects integrity only; publicly available exploit code exists, but there is no confirmation of active exploitation, and the vendor did not respond to disclosure so no official patch is available.
Stored cross-site scripting in the MediaWiki CentralAuth extension allows an attacker who can persist a crafted payload into a CentralAuth-handled field to have that script execute in the browser session of any user who later views the affected page. Affected are CentralAuth installations on branches before 1.46.1, before 1.45.5, and before 1.43.10; plain MediaWiki deployments that do not run the CentralAuth extension are not affected. The vendor has already published fixed versions, and no public exploit code or active exploitation has been identified at time of analysis, so this rates as a moderate-priority (CVSS 6.1) issue rather than an emergency.
Stored cross-site scripting in the Wikimedia CentralNotice extension lets anyone who can create or edit a banner/campaign persist a JavaScript payload that executes in the browser of every user who views the rendered notice, allowing session-rideable actions and content tampering within the victim's MediaWiki origin. MediaWiki installations running an affected non-default CentralNotice build (before 1.46.1, 1.45.5, or 1.43.10) are exposed; per the CISA SSVC evaluation exploitation has not been observed, automatable exploitation is assessed as no, and no public exploit code was identified at time of analysis, though the vendor's CVSS vector (6.1, PR:N) understates the privilege realistically required to store the payload. Our independent assessment keeps the vendor's CVSS:3.1:AV:N/AC:L/S:C/C:L/I:L/UI:R base but changes the privilege requirement to PR:L, since injecting via a CentralNotice banner field normally demands the centralnotice-admin user right, and impact remains partial confidentiality/integrity with no availability effect.
Stored cross-site scripting in the MediaWiki MassMessage extension allows an authenticated user who can submit message content processed by the extension to inject script that executes in the browser session of any user who later views the generated page. Affected deployments are those running the optional MassMessage extension on a branch older than 1.46.1, 1.45.5, or 1.43.10; core MediaWiki without the extension is not impacted. Rated CVSS 6.1 (Medium) with vector AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N, meaning exploitation requires user interaction (the victim viewing the page) and yields limited confidentiality and integrity impact confined to the victim's browser; no public exploit code has been identified at time of analysis and CISA SSVC records Exploitation=none with Automatable=no.
Reflected cross-site scripting in the MediaWiki Cargo extension before 1.46.1 lets remote attackers inject script into a generated wiki page and execute it in a victim's browser within the wiki origin, with a vendor CVSS 3.1 base score of 6.1 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N). No authentication is required to deliver the payload (PR:N), but exploitation depends on a victim following an attacker-crafted link or loading a crafted page (UI:R), so it is a per-victim social-engineering attack rather than broad automated compromise (SSVC Automatable=no); there is no public exploit identified at time of analysis and no evidence of active exploitation per available KEV data. Impact is limited to the victim's browser session against the wiki origin (low confidentiality and integrity impact, scope change, no availability impact), though the effective severity rises with the privileges of the user whose session is hijacked.
Stored cross-site scripting in the MediaWiki 'Refreshed' skin lets an attacker who can save wiki content plant script that executes in the browser of any user viewing the affected page, affecting all versions before 1.46.1, 1.45.5, and 1.43.10 of this non-default, opt-in third-party skin. The CVSS 3.1 base score is 6.1 (AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N), which bounds impact to in-browser script execution - low confidentiality and integrity, no availability - once a victim loads the tainted page. Exposure is limited to wikis that have installed and enabled Refreshed; CISA's SSVC assessment records exploitation as none with partial technical impact, and no public exploit has been identified at time of analysis. Vendor patches are available.
Stored cross-site scripting in the Wikimedia MediaWiki WikiLambda extension (the software behind Wikifunctions / Abstract Wikipedia) allows an attacker who can store content processed by the extension - such as a ZObject function definition - to have an unneutralized script payload executed in the browser of any user who later views the rendered page. Only installations running the WikiLambda extension at a version before 1.46.1 are affected, which is a narrowly deployed component, and impact is bounded to low confidentiality and integrity with no availability effect (CVSS 6.1, assessed vector AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N). No public exploit code has been identified at time of analysis, no CISA KEV listing applies, and CISA SSVC rates exploitation as none and automatable as no, so this is a genuine but low-urgency issue rather than an emergency; the highest-value outcome for an attacker is planting a payload that is later rendered to a privileged administrator.
Stored cross-site scripting (XSS) in the MediaWiki Wikibase Extension allows remote attackers to inject malicious script that is stored on a wiki page and later executed in another user's browser when that page is viewed; the CVSS 3.1 vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N (6.1). Affected are Wikibase Extension versions before 1.46.1, 1.45.5, and 1.43.10; exploitation requires user interaction (UI:R) and results in low confidentiality and integrity impact with scope change, not full server compromise. No public exploit identified at time of analysis, and CISA SSVC rates exploitation as none and automatable as no; a vendor patch is available.
Stored cross-site scripting in the WikiSEO extension for MediaWiki (all versions before 1.46.1, 1.45.5, and 1.43.10) lets an attacker who can save page content containing WikiSEO SEO/meta directives persist malicious script that runs in the browser of any user who later views the poisoned page. Exploitation is constrained by the need for edit privileges (unauthenticated only on wikis that deliberately allow anonymous editing) and by the requirement that a victim load the affected page, keeping the realistic impact to low confidentiality and integrity effects. No public exploit has been identified at time of analysis and CISA's SSVC framework rates exploitation as 'none'; vendor patches are available, making this a genuine but low-urgency issue.
Stored cross-site scripting in the MediaWiki Flow (StructuredDiscussions) extension lets a user who can post content to a Flow discussion board inject script that executes in the browser of any other user who later views that board. The flaw affects installations running the extension at versions before 1.46.1, 1.45.5, and 1.43.10; Flow is an optional, largely deprecated extension and is not present on a default MediaWiki install. No public exploit code has been identified and CISA's SSVC assessment records no exploitation, so this is a moderate-severity, low-to-moderate-priority issue, with vendor patches already available.
Authorization bypass in the WatchGuard Fireware OS Access Portal reverse proxy lets an authenticated, low-privileged portal user reach back-end web applications they are not entitled to by sending a specially crafted request for a resource they are authorized to access. Exploitation requires valid Access Portal credentials, the SSL clientless portal to be enabled and reachable, and a specific crafted-request condition (CVSS 4.0 AT:P), so this is a genuine but bounded access-control flaw rather than a pre-auth compromise path. Impact is primarily confidentiality: unauthorized read of other portal-published web applications, with limited integrity effects and no availability impact. No public exploit code or confirmed active exploitation was identified at time of analysis.
Stored cross-site scripting in CodeCanyon Rocket LMS up to and including version 2.2 lets an authenticated low-privilege user - for example a self-registered student - inject script through the Student Profile Image Upload component, which then executes in the browser of any admin, instructor, or fellow student who later views that profile; publicly available exploit code exists. Exploitation is not self-contained: it requires victim interaction (a second user must open the crafted profile) and results only in client-side script execution in the viewer's session, not server-side access. Because the vendor was contacted early but did not respond, no vendor-released patch is identified and every affected deployment remains exposed until compensating controls are applied.
Out-of-bounds write in the U-Boot bootloader's RLE8-compressed BMP decoder (video_display_rle8_bitmap in drivers/video/video_bmp.c) lets an attacker who can place or modify a crafted splash/logo image write past the framebuffer, corrupting adjacent memory and crashing the bootloader. All U-Boot versions through 2026.10-rc5 are affected per the wildcard CPE, but exploitation is genuinely constrained: the platform must actually route an attacker-controlled BMP through the BMP display path, which in typical deployments means write access to boot media, the splash partition, or the environment-configured image source, and the outcome is primarily availability loss with only limited integrity impact and no confidentiality exposure. No public exploit code or confirmed active exploitation was identified at time of analysis, and the risk is moderate rather than critical despite the headline score.
Configuration backups from Netcore NAP930 firmware 0.1.241010.141410 can be decrypted by an attacker who obtains a backup artifact because the Backup/Restore component uses a hard-coded AES key (the aes_pass value in /lib/functions/backup_common.sh). The issue is remotely reachable but requires high administrative privileges (PR:H) to generate or retrieve a backup, and it only affects confidentiality, exposing backup contents rather than enabling writes or code execution; publicly available exploit code exists, and the vendor did not respond to early disclosure. This is a low-to-moderate risk finding for affected deployments, scoped to the specific NAP930 firmware build.
Server-side template injection in the Email Template component of ThinkCMF up to 8.0.7 lets an authenticated administrator submit template content that the underlying template engine evaluates server-side, enabling data exposure or logic execution within the application's privileges. Exploitation requires a privileged session able to reach MailController::templatePut in cmf-api/src/admin/controller/MailController.php, so anonymous and low-privilege users cannot trigger it; publicly available exploit code exists (a GitHub write-up targeting ThinkCMF v8.0.1), but there is no indication of confirmed active exploitation in CISA KEV. No vendor patch has been issued because the vendor did not respond to the disclosure, and independent assessment rates this a genuinely low-priority finding despite the SSTI classification.
Information disclosure in the Eclipse ThreadX NetX Duo embedded TCP/IP stack's FTP server addon lets a network attacker consume data belonging to an authenticated FTP session, because the server never ties the passive-mode data connection back to the peer on the control channel. Exploiting this requires the target to be running the NetX Duo FTP server and a client to be performing or negotiating a passive-mode transfer at the moment of attack, and the attacker must reach the announced passive port and win a connection race against the legitimate client before it connects; no authentication is required (PR:N), but the timing dependency makes complexity high (AC:H, UI:P) and the impact is limited to confidentiality (C:H/I:N/A:N, CVSS 4.0 base 6.0). No public exploit code and no confirmed active exploitation were identified at time of analysis, and the flaw should be treated as a genuine but moderate-priority confidentiality issue rather than a high-severity one.
Crafted IPCP configuration options sent by a PPP peer can stall a NetX Duo worker thread and drive an out-of-bounds read in Eclipse ThreadX NetX Duo builds that enable the PPP/IPCP add-on. Only devices that terminate PPP links (serial, cellular modem, PPPoE, or L2TP) and accept negotiation traffic from an attacker-controlled or untrusted peer are exposed, and the assessed vector (CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H) reflects adjacency rather than remote reachability. Exploitation is unauthenticated and needs a specifically crafted IPCP option with an oversized declared length, but no public exploit code has been identified and the issue is not listed in CISA KEV at time of analysis.
Out-of-bounds reads in Eclipse NetX Duo's MSRP (Multiple Stream Reservation Protocol) attribute-list parser allow an attacker positioned on the same layer-2 network segment to crash a device by supplying a malformed attribute list whose length field is never validated. The flaw affects NetX Duo builds that have the MSRP / TSN-AVB stream-reservation feature compiled in and actively processing MSRP traffic; because exploitation requires adjacent-network access and yields only a denial of service - no confidentiality or integrity impact, and no code execution is claimed - this is a bounded availability issue rather than a remotely exploitable high-severity defect. There is no CISA KEV listing and no public exploit code identified at time of analysis, so exploitation is assessed as unconfirmed.
Eclipse NetX Duo can be crashed (high availability impact) by an unauthenticated attacker on the same Layer-2 network segment who manipulates MSRP attribute state so that the sole remaining MSRP attribute is evicted, triggering a NULL pointer dereference. This is a genuine but bounded availability-only risk: MSRP (IEEE 802.1 AVB/TSN) must be enabled, and the attacker must achieve a precise attribute-table condition (AT:P), so it is not a stateless single-packet trigger. No public exploit code has been identified at time of analysis; the vendor-assigned CVSS 4.0 base score is 6.0, and our independent CVSS 3.1 assessment (AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) confirms adjacent-only, state-dependent denial of service.
Attribute table exhaustion in Eclipse ThreadX NetX Duo's MSRP (Multiple Stream Reservation Protocol) handling triggers a NULL pointer dereference that halts the affected device, producing an availability-only denial of service. Only deployments where MSRP/AVB-TSN support is compiled in and actively running are exposed, and the attacker must be on the same Layer-2 bridged segment because MSRP frames are not routed outside the local bridge domain. No public exploit code has been identified at time of analysis, and success requires sustained flooding of attribute registration frames rather than a single packet, giving this an assessed severity in the moderate range despite the total loss of availability on a targeted device.
OpenClaw versions before 2026.9.4 contain an incorrect authorization flaw (CWE-863) in the mcp.app.view method that lets a holder of a read-scoped operator.read Gateway token mint a standalone MCP App ticket and redeem it at the /__openclaw__/mcp-app/view endpoint to invoke state-changing MCP tools through tools/call - operations that should require operator.write scope. Exploitation is authenticated (PR:L) and remote, requires the originating run to carry an App-tool grant (allowedAppToolNames defined and not readOnly), and needs no user interaction; the primary impact is integrity (VI:H) with no confidentiality or availability loss per the assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N vector. There is no public exploit code or confirmed active exploitation identified at time of analysis, and an independent assessment rates this as a genuine but moderate-severity authorization bypass rather than a high-severity emergency.
Sandbox isolation bypass in OpenClaw before 2026.9.5 allows an attacker who controls a sandboxed session to read files belonging to sibling session sandboxes or shared workspace directories through the Gateway's media pipeline. The root cause is an incorrect authorization check (CWE-863): the Gateway's local media root allowlist is overbroad, so media and attachment path resolution is not confined to the active session, and untrusted content can drive the same read path. Impact is confidentiality-only, is gated on a multi-session or untrusted-content deployment that exercises the media staging path, and no public exploit has been identified at time of analysis; the vendor shipped a fail-closed fix in 2026.9.5.
Cross-site scripting in the Joomla CMS link toolbar layout allows an authenticated, high-privilege backend user (administrator or manager level able to reach the link toolbar) to inject script that executes in a second privileged user's browser when that user loads the affected view - a moderate-impact, non-urgent issue rather than an unauthenticated or drive-by attack path. Joomla Core releases 4.0.0 through 5.4.8 and 6.0.0 through 6.1.3 are affected in default configuration, with no special feature flag required. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (no CISA KEV entry); the high-privilege prerequisite plus mandatory victim interaction substantially limit realistic exploitation.
Cross-site scripting in Joomla CMS 4.0.0 through 5.4.8 and 6.0.0 through 6.1.3 lets a high-privileged authenticated backend account inject an unescaped script payload that is rendered through the core generic audio and video media output layouts, executing in the browser of a second user who views the affected page. Because the vulnerable layouts do not escape user-influenced output, a rogue or compromised elevated account (for example a Manager or Super User) can plant the payload and wait for a victim to load the rendered media; exploitation therefore requires both PR:H authentication and victim page interaction, not anonymous remote access. There is no public exploit identified at time of analysis, no evidence of confirmed active exploitation (not in CISA KEV), and the CVSS 4.0 vector marks exploit maturity as unproven (E:U) with a base score of 5.9.