Mozilla Firefox before 157 can disclose sensitive process memory to a remote, unauthenticated attacker who persuades a user to load a crafted JavaScript page, because the browser's JavaScript JIT compiler can miscompile code and trigger a type-confusion condition. Exploitation requires user interaction (the victim must visit or be redirected to attacker-controlled content), and impact is limited to confidentiality within the content process; Mozilla fixed the issue in Firefox 157, and no public exploit code has been identified at the time of analysis, with EPSS at 0.15% (4th percentile).
Authentication bypass in the captive portal of HPE Networking Instant On (all versions up to and including 3.4.1.0) lets a network-reachable, unauthenticated remote attacker circumvent the portal's authentication controls and obtain limited read access to data plus the ability to make limited changes inside that component. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N, base 6.5 Medium) confirms a low-friction attack path requiring no credentials and no user interaction, although the impact is bounded to the captive-portal component with no availability effect. No public exploit code or confirmed in-the-wild exploitation has been identified - no public exploit identified at time of analysis - and no EPSS score was supplied with the source data.
Authentication bypass in the PAPI control-plane protocol of HPE Networking Instant On access points running firmware 3.4.1.0 and earlier allows an unauthenticated attacker on the same Layer 2 segment to circumvent existing authentication controls and push unauthorized traffic to the device. The issue is rated CVSS 6.5 (AV:A/AC:L/PR:N/UI:N, integrity-only impact) because exploitation requires an adjacent network position rather than internet reachability, and the PAPI interface is not routable from the public internet. No public exploit code has been identified at time of analysis, the flaw is not confirmed actively exploited (not in CISA KEV), and the principal exposure limiter is the requirement for an existing on-network or on-air foothold.
Memory exhaustion in the sshd-sftp component of Apache MINA SSHD (1.0.0 through 2.19.0 and 3.0.0-M1 through 3.0.0-M5) lets an authenticated remote SFTP client crash the server by driving the SFTP v6 check-file-name/check-file-handle extension to build an oversized reply entirely in server memory. Per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H), the session must be authenticated and must negotiate SFTP protocol version 6, and the attacker must point the request at a very large (possibly sparse) file using a tiny block size such as the 256-byte minimum, so that file-size divided by block size yields an enormous number of hashes; availability impact is high while confidentiality and integrity are unaffected. This is a genuine but bounded availability risk with no public exploit identified at time of analysis, and deployments that already cap SFTP message size (typically 256kB, as OpenSSH does) are not exposed.
Memory exhaustion denial of service in Apache MINA SSHD's SCP subsystem (module sshd-scp) affects all releases before 2.20.0 and the 3.0.0-M1 through 3.0.0-M5 milestones, requiring a connected SSH peer that has reached the SCP protocol handler - on a server deployment this typically means successful low-privilege authentication, which is the main gating factor (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, 6.5 Medium). The peer only needs to stream a single malformed SCP command line that never terminates with an LF, causing the handler to buffer the endless input until the JVM throws OutOfMemoryError and the application crashes; there is no confidentiality or integrity impact. No public exploit code and no confirmed active exploitation were identified at time of analysis, so the practical risk is a bounded availability issue for deployments that expose or use the SCP subsystem.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
Stored cross-site scripting in the Joomla CMS module list layout allows an authenticated administrator-level backend user to supply values that are rendered without escaping, so script executes in the browser of another privileged user who views the module list. Affected releases are Joomla CMS 4.0.0 through 5.4.8 and 6.0.0 through 6.1.3, and the vendor-assigned CVSS 4.0 base score is 5.9. Because exploitation requires a pre-existing high-privilege account (PR:H) and a victim who opens the affected administrative view (UI:P), the issue is confined to the backend and cannot be triggered by anonymous front-end visitors; no public exploit code and no CISA KEV entry are associated with this CVE at time of analysis, and a vendor advisory covering the fixed releases is available from the Joomla Security Centre.
Cross-site scripting in Joomla CMS core (HTMLHelper::link) allows an authenticated, high-privileged backend user to inject unescaped markup into links that later executes in a victim's browser when the affected page is rendered. All Joomla releases from 1.5.0 through 5.4.8 and 6.0.0 through 6.1.3 are affected, so any site still running a legacy 1.5/2.5/3.x branch as well as current 5.x and 6.x installations needs attention. Exploitation requires a high-privilege Joomla account (CVSS PR:H) plus a victim who views the crafted link (UI:P/UI:R); no public exploit code exists and there is no indication of active exploitation (not listed in CISA KEV), and the E:U metric keeps the practical risk moderate despite the network attack vector.
Denial of service in the Zephyr RTOS LwM2M client: the CoAP Block1 write handler can be driven into a NULL pointer dereference that crashes or resets the device. Affected are Zephyr builds using the LwM2M engine with block-wise transfer handling, particularly NoSec deployments where CONFIG_LWM2M_DTLS_SUPPORT is disabled (it has no default, so this is a common configuration); an unauthenticated remote peer that can reach the LwM2M UDP socket - an on-path or address-spoofing attacker, or a bootstrap/lower-trust server - first exhausts the static Block1 context pool (CONFIG_LWM2M_NUM_BLOCK1_CONTEXT, default 3) with three incomplete block-wise writes, then sends a fourth first-block write to hit the unguarded store. The assessed impact is availability only (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, CVSS 5.9), and no public exploit code was identified at time of analysis; the multi-request pool-exhaustion sequence is the main factor keeping complexity high.
Race condition in CPython's tempfile.TemporaryDirectory cleanup can be exploited by a local attacker who can write into the directory tree while it is being removed, allowing files outside the temporary directory to be deleted or to have their permissions and file flags reset with the privileges of the cleaning process. The attack is a TOCTOU race: the attacker must swap a directory for a symbolic link (or otherwise mutate the tree) during the rmtree walk, so exploitation is local, timing-dependent, and only meaningful when the cleanup runs with higher privilege than the attacker. Deletion outside the tree is restricted to platforms where shutil.rmtree.avoids_symlink_attacks is False, while permission/flag resets outside the tree can occur on all platforms; no public exploit code was identified at time of analysis, and the upstream fix exists as a PR/commit rather than a confirmed released patched version.
Cleartext transmission of sensitive information in Dell Secure Connect Gateway (SCG) Policy Manager versions prior to 5.34.00.16 exposes data to anyone able to observe network traffic to or from the product. The flaw is unauthenticated (PR:N) and requires no user interaction (UI:N), but its High attack complexity reflects that an attacker must first obtain an on-path position - a man-in-the-middle or passive-sniffing vantage point on the communication path - before any data can be read; confidentiality impact is rated High with no integrity or availability effect. At time of analysis there is no public exploit identified and no CISA KEV listing, so this is a moderate, defensively-weighted exposure rather than an actively exploited emergency. No EPSS score was supplied in the available intelligence.
A heap-based out-of-bounds write in Eclipse ThreadX GUIX's gx_binres_theme_load() lets a local attacker corrupt memory by supplying a binary theme resource in which the requested theme id is at or beyond the theme count the resource declares. The loader sizes and allocates a zero-byte buffer for that out-of-range id, then walks past the end of the theme table and writes a GX_THEME structure and its tables into the empty allocation, producing out-of-bounds heap corruption. Exploitation requires local placement or substitution of the malicious resource plus application/user interaction to load it (AV:L, PR:N, UI:R), so risk is moderate rather than high; no public exploit has been identified at time of analysis.