Eclipse Foundation
Monthly
The AES-CBC-with-HMAC JWE path in Eclipse KeyPont gose (published as github.com/ThalesGroup/gose v0.9.0 through v0.13.0-rc1) provides no ciphertext integrity at all: HmacShaCryptor.Hash returned the MAC of the empty message for every input, so the authentication tag is constant per key and independent of the message. An unauthenticated remote attacker who has observed a single legitimately produced JWE under the target key can replay that tag onto arbitrary attacker-chosen header, IV and ciphertext and pass verification, enabling bit-flipping manipulation of the recovered plaintext and padding-oracle-style attacks; confidentiality alone is not broken. Only the CBC-HMAC direct encryption/decryption blocks are affected, AEAD/GCM modes do not use this cryptor, and the evaluator rates it AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N with no public exploit identified at time of analysis.
Denial of service in Eclipse OpenJ9 through 0.63.0 affects deployments that enable the optional JITServer mode, where unauthenticated remote attackers or a malicious JITServer peer can crash the daemon or a client JVM with malformed protocol messages. The vendor CVSS 4.0 score is 8.7 (High), and the assessed CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H confirms remote, low-complexity, availability-only impact with no confidentiality or integrity loss. JITServer is not enabled in default JVM operation, so standard OpenJ9 installations are not exposed; no public exploit or CISA KEV entry was identified at time of analysis.
Denial of service in Eclipse OpenJ9's optional JITServer component (versions prior to 0.63.0) allows an unauthenticated remote attacker to crash the server process by sending a crafted DataDescriptor message. The flaw is an unsigned integer underflow caused by missing cross-field validation of _size, _paddingSize, and _dataOffset, leading to an out-of-bounds heap read and SIGSEGV. Exploitation requires JITServer to be enabled and network-reachable; no public exploit code or CISA KEV entry was identified at time of analysis, and the assessed impact is availability-only (CVSS 3.1 base 7.5), narrower than the headline CVSS 4.0 score of 8.7 suggests.
Remote denial of service in Eclipse OpenJ9 JITServer before 0.63.0 lets unauthenticated network attackers exhaust compilation worker threads by sending crafted TCP connections with a malicious 4-byte length prefix. The integer overflow in MessageBuffer::computeRequiredCapacity() drives a worker thread into an infinite loop at roughly 100% CPU, so a small number of connections can silently stop compilation services for all connected client JVMs. The vendor base score of 8.7 reflects availability-only impact; no public exploit was identified at time of analysis.
Integer overflow in the Eclipse ThreadX module manager lets a loaded module under-allocate an object-pool block and corrupt the adjacent byte-pool block. When a module calls txm_module_object_allocate with an object_size near ULONG_MAX, the manager's unchecked addition of its fixed 16-byte private header wraps, so the pool serves a block smaller than the header and the subsequent header write spills past its end into the neighbouring allocation. The issue is locally exploitable by a low-privileged attacker who already has code running inside a loaded module, affects only builds that compile in and use the ThreadX module subsystem, requires no user interaction, and no public exploit code was identified at time of analysis (no CISA KEV listing was provided).
Eclipse ThreadX's Cortex-A7 MMU module port accepts a caller-supplied buffer range after validating only its first byte, so an authenticated local attacker who can execute code in a protected module can cause privileged dispatch code to read or write beyond the module's declared memory. The weakness sits in a shared range-check macro used by protected-module dispatchers that consume buffers or extra-parameter arrays, and exposure is limited to systems running the ThreadX Module Manager with memory-protected modules on that port. No public exploit identified at time of analysis, and the attack path is local rather than remote or unauthenticated.
Eclipse ThreadX firmware built with Module Manager and loadable modules enabled contains a use-after-free in txm_module_object_deallocate: a module can request release of a kernel object control block by address, and the manager frees it even if the kernel still references it. The object remains on its created list and, for threads or timers, on scheduler/timer lists, so the byte pool can reallocate the same memory while the kernel still uses it. Exploitation requires local low-privilege code execution inside a loaded module (PR:L, AV:L) and is not remotely reachable in default builds; no public exploit code was identified at time of analysis.
Heap out-of-bounds read in the NetX Secure TLS 1.3 Certificate-message parser of Eclipse ThreadX NetX Duo can be triggered by a malicious or man-in-the-middle TLS 1.3 server, crashing the connecting peer. The flaw is unauthenticated (CVSS PR:N) and reachable during the normal handshake, before certificate verification completes, but requires the victim device to act as a TLS client and connect to an attacker-controlled endpoint - an attacker cannot trigger it against an unsolicited listening service. Vendor/independent assessment rates impact as availability-only (CVSS 4.0 base 8.7; CVSS 3.1 AV:N/AC:L/PR:N/UI:N/A:H), and no public exploit code or CISA KEV active-exploitation entry was identified at time of analysis.
A four-byte malformed TLS 1.3 Certificate handshake header can drive the NetX Secure certificate parser in Eclipse ThreadX NetX Duo past the end of its session packet buffer, crashing the device or stack. The flaw is remotely reachable, unauthenticated, and requires no cryptographic validity or user interaction - the parser decrements the message length to skip a certificate_request_context byte without first confirming a byte exists, so a zero-length message wraps the unsigned length to 0xFFFFFFFF and renders the subsequent bounds check vacuous. Impact is bounded to availability (out-of-bounds read leading to fault/denial of service) per the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H vector, and no public exploit code or confirmed active exploitation was identified at time of analysis; the practical exposure limit is that the target must actually negotiate TLS 1.3 and enter the Certificate-message parsing path.
Denial of service in the Eclipse ThreadX NetX Duo Web add-on's HTTP server, which mishandles a `Content-Length` underflow while processing a `PUT` request and ends up dereferencing and freeing an uninitialized pointer. The flaw is reachable by an unauthenticated remote client with a single malformed request (CVSS 4.0 AV:N/AC:L/AT:N/PR:N/UI:N), making the realistic outcome a crash of the HTTP service or the whole device (VC:N/VI:L/VA:H) rather than code execution or data exposure. Only deployments that have compiled in and network-exposed the Web add-on's HTTP server are affected; devices running NetX Duo without that component are not exposed, and no public exploit code was identified at time of analysis.
Out-of-bounds write in Eclipse NetX Duo's X.509 certificate-chain verification lets unauthenticated remote attackers corrupt static memory by presenting a certificate with an RSA modulus larger than the 4096-bit NX_CRYPTO_MAX_RSA_MODULUS_SIZE buffer dimension. The flaw is reachable pre-authentication on TLS/DTLS clients validating a malicious server chain and on servers configured for client-certificate authentication, because the peer-supplied issuer is resolved before the trusted store. No public exploit was identified at time of analysis, but the issue is rated critical (CVSS 4.0 9.3; independently assessed CVSS 3.1 9.8).
Heap-based out-of-bounds write in the Eclipse ThreadX GUIX binary resource (font) loader: a font page header declaring first_glyph greater than last_glyph underflows the glyph count (CWE-190), the count-times-record-size allocation multiply then wraps to a small value, and the load pass writes attacker-controlled glyph records past the end of the undersized buffer. Exploitation requires the target embedded application to load an attacker-supplied or tampered GUIX binary font resource - the assessed vector is local (AV:L) with high attack complexity and required user/application interaction - so realistic exposure is limited to devices that parse externally sourced or updatable GUIX resources rather than fixed build-time font assets; no public exploit code or confirmed active exploitation was identified at time of analysis. Successful corruption can yield code execution, data disclosure, or denial of service in the GUIX process context (CVSS 4.0 base 7.1).
The Eclipse ThreadX GUIX PNG decoder can be driven out of bounds by a crafted PNG that places a second IHDR chunk after IDAT, enabling memory corruption in applications that render attacker-supplied images. Any integration with the GUIX PNG decoder enabled is in scope, since the decoder is compiled in by default, and exploitation is local and requires user/application interaction to open the crafted file. No public exploit was identified at time of analysis; the reporter rates the issue 8.4, and the independent assessment treats it as a local, user-interaction-dependent memory-corruption flaw.
Out-of-bounds heap write in Eclipse FileX allows an attacker who can supply a malformed FAT image to corrupt heap memory during fault-tolerant log replay, with the write position and value under attacker control. On embedded layouts where the FX_MEDIA driver callback is within reach, this can redirect the instruction pointer and yield code execution; the CVSS 3.1 score is 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), reflecting a local path that requires the victim to mount attacker-controlled media. No public exploit code or CISA KEV entry was identified at time of analysis, and practical exposure is limited to builds with FileX fault tolerance enabled that mount untrusted FAT images.
Unauthenticated attackers can bypass JWT signature verification in Eclipse ioFog Controller 3.8.0 through 3.9.1 on the operator WebSocket upgrade handlers for the exec and log routes, allowing them to open privileged sessions for any microservice or fog node whose UUID they know. By crafting a token with an 'admin' group claim, the attacker matches the built-in admin role without needing an account or RoleBinding. No public exploit identified at time of analysis, but the flaw is rated CVSS 9.8 and requires immediate attention.
Unauthenticated remote attackers can exhaust Eclipse ioFog Controller 3.8.0 through 3.9.1 by sending small JSON bodies to POST, PUT, or PATCH routes that perform template substitution, stalling or aborting the control-plane process before bearer-token and RBAC checks run. The bearer check does not reject missing or invalid tokens and the DoS rate limit covers only login routes, so a reachable templating route is enough to disrupt the agent API and in-process WebSocket relays. No public exploit was identified at time of analysis, and the impact is limited to availability with no confidentiality or integrity effect; reporting is consistent with a genuine, impact-limited availability threat.
Security-constraint bypass in Eclipse Jetty leaves some request URL patterns unprotected when annotation and deployment-descriptor security metadata are mixed, specifically in the jetty-annotations and jetty-eeN-annotations modules. The flaw triggers only in a narrow application layout: a servlet declared in web.xml with more than one url-pattern, a web.xml security-constraint that covers only a subset of those patterns, and @ServletSecurity annotations present at the same time, in which case the Jakarta Servlet specification's authoritative url-pattern precedence rules are not applied and the uncovered patterns remain reachable. Because the resulting access is reachable over the network with no credentials (CVSS 4.0 AV:N/PR:N/UI:N, independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N), an unauthenticated remote attacker can read content that should have been restricted, yielding a high confidentiality impact with a low integrity impact and no availability impact; exploitation is strictly gated by the application-level web.xml/annotation layout rather than by the Jetty version alone, and no public exploit identified at time of analysis.
Eclipse Jetty's HttpClient can disclose proxy authentication credentials to a malicious server when the server returns a 407 Proxy Authentication Required status. This information disclosure (CWE-200) affects applications using Jetty's HttpClient with an authenticated forward proxy and connecting to attacker-controlled destinations. Exploitation requires the attacker to control the destination server and the client to be configured with proxy credentials; no public exploit code has been identified at time of analysis, and the CVSS 4.0 score is 8.2 (High).
Path-normalization weakness in Eclipse Jetty's HttpClient causes credential disclosure: when HttpClient receives a redirect whose target contains a non-normalized traversal segment such as /secure/../evil, Jetty matches the stored Authorization credential against the literal /secure prefix rather than resolving the path to /evil, and then follows the redirect - sending the /secure-scoped Authorization header to an endpoint that should never receive it. Per the provided CVSS vector (PR:N) the attacker is unauthenticated, but exploitation carries high attack complexity (AC:H): the attacker must be able to control or influence the redirect response returned to HttpClient, and must already have a malicious application deployed on the SAME domain as the target so the leaked header lands on an endpoint they control. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Unauthenticated remote attackers can exhaust server memory in Eclipse Vert.x deployments that expose the io.vertx:vertx-grpc-server component by sending small, highly compressed gRPC messages whose decompressed payload greatly exceeds the configured per-message maximum size, producing an availability-only denial-of-service condition. The affected ranges are Vert.x 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, and the flaw is only reachable when a gRPC endpoint is network-reachable and accepts client-supplied message compression (standard gRPC gzip/deflate negotiation). The source reports a CVSS 4.0 base score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H with no confidentiality or integrity impact); our independent CVSS 3.1 assessment agrees it is availability-only (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), and there is no public exploit code and no CISA KEV listing identified at time of analysis - the practical precondition is simply that the per-message size limit is being relied upon as the sole defense, since that limit is enforced against compressed bytes only.
Unbounded inbound memory retention in the Eclipse Vert.x MQTT client (io.vertx:vertx-mqtt) allows a malicious or compromised MQTT broker to drive the Vert.x process into memory exhaustion and eventual out-of-memory termination. Client-side applications embedded in Vert.x 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 that subscribe to QoS 2 (exactly-once) topics are affected; the attacker supplies QoS 2 PUBLISH packets with distinct packet identifiers and never sends the matching PUBREL, so each message is retained indefinitely in the client's internal qos2inbound map. The assessed vectors rate this AV:N/AC:H/PR:N with high availability impact only (no confidentiality or integrity impact), reflecting that exploitation requires the attacker to occupy the broker role rather than being an arbitrary remote peer; no confirmed active exploitation (CISA KEV) and no public exploit code were identified at time of analysis, and EPSS data was not provided. Note that the maxInflightQueue option does not mitigate this issue because it constrains only the outbound publish path.
Denial of service in Eclipse Vert.x JSON Schema validation (io.vertx:vertx-json-schema) allows a remote unauthenticated attacker to burn disproportionate CPU by sending a single moderately sized JSON array to any endpoint whose active schema uses the uniqueItems keyword. The affected ranges are 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, and the defect propagates to the dependent modules vertx-web-openapi-router, vertx-web-validation and vertx-openapi. No public exploit code was identified at time of analysis, yet the issue is rated CVSS 4.0 8.7 (HIGH) entirely on availability impact (VA:H with VC:N/VI:N), and applications that do not use uniqueItems in attacker-reachable schemas or that cap request body/array size upstream are not practically exploitable.
Unbounded direct-memory allocation in Eclipse Vert.x's MySQL client (io.vertx:vertx-mysql-client) versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 allows a malicious, compromised, or man-in-the-middle MySQL server to crash the client with an out-of-memory condition before authentication completes. The attacker sends a continuous stream of maximum-length (0xFFFFFF) MySQL protocol packets, preventing the decoder from reaching the end-of-message boundary. This is a denial-of-service issue; no public exploit code has been identified at time of analysis (not in CISA KEV).
An unbounded-memory denial of service in the Eclipse Vert.x PostgreSQL client (io.vertx:vertx-pg-client) allows a malicious, compromised, or man-in-the-middle PostgreSQL server to crash a client application by sending a wire-protocol message header whose 4-byte length field is set to an extremely large value (up to Integer.MAX_VALUE). The client-side decoder performs no maximum-size validation, so it keeps accumulating TCP data into a composite buffer until the JVM exhausts heap and terminates; the abuse happens during connection startup, before authentication completes, so no valid database credentials are required - the attacker only needs to control the server side of the connection or sit on the client-to-PostgreSQL TCP path. Per the independent assessment this is a genuine but conditional availability risk (CVSS 8.2, AV:N/AC:H, availability-only impact) rather than a mass-exploitation priority: no public exploit code or confirmed active exploitation was identified at time of analysis, and clients that connect exclusively to trusted, authenticated, TLS-verified PostgreSQL servers are not realistically exposed.
Denial of service in the Vert.x MySQL client (io.vertx:vertx-mysql-client) lets an attacker who controls or intercepts the client-to-database path crash a Vert.x application: a crafted MySQL result-set packet declaring an extremely large column count causes the client to attempt an unbounded heap allocation, and the resulting OutOfMemoryError kills the Netty event loop thread, taking down all connections and verticles in the process. Affected builds are 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, across all platforms where vertx-mysql-client is used. No authentication or user interaction is required once the hostile source or man-in-the-middle position exists (CVSS 4.0 PR:N), but the vendor rates the attack complexity as high (AC:H) because the database endpoint is normally trusted and operator-controlled; there is no public exploit identified at time of analysis, and the CVE is not listed in CISA KEV.
Denial of service in Eclipse Vert.x's vertx-pg-client component allows an attacker controlling the PostgreSQL server or positioned as a man-in-the-middle on an unencrypted connection to crash the client application. The flaw resides in the binary array decoder (DataTypeCodec.binaryDecodeArray), which allocates a Java array based on a server-supplied 32-bit dimension count without upper bound checking, leading to a multi-gigabyte heap allocation and OutOfMemoryError. Affected versions include 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0. Exploitation requires no authentication (PR:N) but does require control of the database server or a MITM position on a non-TLS connection (AC:H), and no public exploit code has been identified at time of analysis.
Eclipse Vert.x DB2 Client versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 can deserialize attacker-controlled DRDA UDT column data, enabling remote code execution if a Java deserialization gadget chain is present on the classpath or denial of service otherwise. The affected component is io.vertx:vertx-db2-client, and exploitation requires an application to connect to a malicious or man-in-the-middle DRDA server that returns a result-set column tagged with FDOCA LID 0x50; legitimate DB2 servers never emit that type, and client-side TLS is disabled by default. The CVSS 4.0 score is 9.2 with PR:N, but practical exploitation requires attacker server-side/MITM position (AC:H) and, for RCE, a classpath gadget chain; no public exploit identified at time of analysis, and the real-world blast radius is narrower than the score alone suggests.
Unbounded direct-memory allocation in Eclipse Vert.x's MSSQL client (io.vertx:vertx-mssql-client) lets a malicious, compromised, or man-in-the-middle SQL Server endpoint crash a connecting client application by streaming TDS packets that never set the END_OF_MESSAGE status flag. Affected versions are [4.0.0, 4.5.34], [5.0.0, 5.0.12], [5.1.0, 5.1.9] and 5.2.0: the TDS message decoder aggregates inbound packets into a composite direct-memory buffer with no cumulative size cap, so the buffer grows until memory is exhausted and the process dies (availability impact only, with no confidentiality or integrity loss, per the assessed CVSS:3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H). The flaw is reachable before authentication completes, meaning no valid server credentials are required, but exploitation is not available to an arbitrary remote attacker - it demands control of, or a man-in-the-middle position on, the server side of the connection, which is why access complexity is rated High. No public exploit code or confirmed active exploitation was identified at time of analysis.
Denial of service in the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) affects versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0: the RESP parser trusts a server-declared array, push, or attribute length and pre-allocates that many elements without an upper bound, so a crafted response triggers a massive heap allocation that terminates the Vert.x event-loop thread with OutOfMemoryError and denies service to every connection and verticle sharing that loop. Exploitation is conditional rather than opportunistic - a remote, unauthenticated attacker qualifies only if they control or have compromised the Redis server the client talks to, or if they can occupy a man-in-the-middle position on the client-to-Redis path; neither user interaction nor prior client authentication is required, which is why the assessed vector is AV:N/PR:N but AC:H, and impact is availability-only (no confidentiality or integrity loss). No public exploit code or confirmed active exploitation was identified at time of analysis, and this is a genuine but conditional DoS issue rather than a top-tier emergency.
Denial of service in Eclipse Vert.x HTTP proxy (io.vertx:vertx-http-proxy) affects versions 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, allowing remote unauthenticated attackers to cause indefinite heap allocation. Exploitation requires the application to explicitly configure an intercepting body transformer-a non-default, developer-enabled feature-and the flaw lies in the transformer interceptor's reliance on a max buffered bytes limit that fails to keep per-request buffers bounded. No public exploit code has been identified at time of analysis; the CVSS 4.0 score is 8.7 with high availability impact.
Denial-of-service in Eclipse Vert.x allows unauthenticated remote attackers to exhaust server memory by sending compressed WebSocket frames that decompress to massive sizes (a zip bomb), because the WebSocket implementation lacks a maximum byte-allocation limit during decompression. Affected versions include 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, and exploitation requires WebSocket compression (permessage-deflate) to be negotiated. No public exploit code has been identified at time of analysis, but a vendor advisory (GHSA-h722-h6c2-6j3c) is available; the impact is limited to availability loss.
Eclipse NetX Duo's NetX Secure DTLS server can be driven into completing handshakes with forged source addresses because the cookie it issues in a HelloVerifyRequest is never actually validated: the ClientHello parser copies the client-supplied cookie bytes over the value the server generated, and the server then treats the peer as verified based on the cookie's length alone, so a single arbitrary cookie byte in the first ClientHello skips the return-routability exchange entirely. The defect is remotely reachable with no authentication and no user interaction (CVSS 4.0 base 8.7, High; the independent assessment confirms AV:N/AC:L/PR:N/UI:N with an availability-only impact), and the practical harm is anti-spoofing and availability abuse - spoofed-source handshakes, amplification potential, and handshake state/resource exhaustion - not data compromise or code execution. No public exploit code has been identified at time of analysis, and CVE-2026-106465 is not listed in CISA KEV.
Out-of-bounds read in Eclipse NetX Duo's X.509 certificate parser (routine `_nx_secure_x509_parse_signature_data`) lets a peer that supplies a certificate with an empty ASN.1 BIT STRING signature corrupt the parser's internal signature length to 0xFFFFFFFF and drive a signature pointer one byte past the end of the buffer, producing a crash or destabilization of the device. Because certificates are parsed from the remote peer during the TLS handshake, the issue is network-reachable and unauthenticated - affected devices are those acting as a TLS client toward an attacker-influenced server, or as a TLS server that requests client certificates; the independent assessment rates it AV:N/AC:L/PR:N/UI:N with availability-only impact (A:H). Neither CISA KEV active exploitation nor public exploit code is associated with this CVE at time of analysis, and the principal limiting factor is reachability: only systems that negotiate TLS with untrusted peers are exposed.
Out-of-bounds write in the Eclipse NetX Duo TLS 1.3 client lets a malicious or compromised server corrupt memory past the caller-supplied TLS packet buffer by returning a HelloRetryRequest containing an oversized cookie; the copy happens before certificate authentication completes, so no valid certificate is required. It is remotely triggerable without authentication (CVSS:4.0 base 9.3; independently assessed as CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) and affects only devices acting as TLS 1.3 clients that initiate an outbound handshake to an attacker-controlled or MITM-positioned server. No public exploit code or CISA KEV entry was identified at time of analysis.
Heap out-of-bounds write in Eclipse ThreadX GUIX's binary theme resource loader (gx_binres_theme_load) lets a crafted binary resource (theme) file overwrite memory past the end of the loader's own arena with bytes taken verbatim from the file, producing high confidentiality, integrity, and availability impact on the affected process. The vector is local rather than network-reachable: an attacker must get the malformed theme file onto the device and the target application must actively load it (CVSS 4.0 AV:L/UI:A; assessed CVSS 3.1 AV:L/UI:R, PR:N, so no privileges are needed once the file is loaded), and deployments that only load theme resources compiled into firmware, or that never accept externally sourced theme files, are not exposed. GX_BINARY_RESOURCE_SUPPORT is enabled in the shipped default configuration, so no special build option is required for the flaw to be reachable; no public exploit code was identified at time of analysis, and no caller-side workaround is possible because the public API takes no buffer-size parameter.
Out-of-band XML External Entity (XXE) injection in Eclipse JAXB RI (jaxb-ri) lets an unauthenticated remote attacker read local files when an application unmarshals attacker-influenced XML through the affected JAXB factory helpers (XmlFactory in the core and xsom modules). The pre-patch code relied solely on XMLConstants.FEATURE_SECURE_PROCESSING, so on JAXP/SAX/DocumentBuilder implementations where that single feature does not disable DOCTYPE declarations, external general entities, external parameter entities, or external DTD loading, external entity resolution remains possible and file content can be exfiltrated out-of-band. Exploitation requires both conditions to hold - untrusted XML reaching JAXB unmarshalling, plus a parser stack where secure processing alone is insufficient - which is why the vector carries AC:H and the score is 8.3 (High) on both the supplied CVSS 4.0 vector and the independently assessed CVSS 3.1 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:L). No confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis.
Out-of-bounds write in the TLS 1.3 client of Eclipse ThreadX NetX Duo 6.5.1.202602 allows a malicious or compromised server to corrupt memory in the session control block by sending an oversized handshake message before certificate authentication completes, potentially achieving code execution or causing denial of service. The flaw is client-side and unauthenticated from the network perspective, requiring the victim device to initiate a TLS 1.3 handshake to an attacker-controlled server; no valid server certificate is needed and certificate pinning does not prevent exploitation. No public exploit code was identified at time of analysis, but the CVSS 9.3 base score and the pre-authentication nature make this a high-priority memory-corruption issue for affected embedded deployments.
Server-side request forgery in Eclipse Che 7.29.0 and later allows any authenticated low-privilege user to make the workspace server fetch attacker-chosen URLs through the GET /api/scm/resolve and POST /api/factory/resolver endpoints, which pass the URL to URLFetcher.fetch() without any scheme or host allow-list. Successful abuse yields high confidentiality loss: arbitrary local file reads inside the Che pod (notably the Kubernetes service-account token at file:///var/run/secrets/kubernetes.io/serviceaccount/token), access to internal HTTP services and cloud instance metadata at 169.254.169.254, and delivery of the victim's stored SCM personal access token as an Authorization header to a host of the attacker's choosing; integrity impact is more limited, largely the unauthorized use of forwarded credentials. No vendor-released patch was identified at time of analysis and no public exploit code was identified at time of analysis, though the affected code paths are reachable by any authenticated user. A second, interaction-dependent variant triggers the credential forwarding when a victim opens a workspace from a malicious devfile whose parent.uri points at an attacker-controlled server.
An out-of-bounds heap write in Eclipse ThreadX LevelX's NAND flash-translation-layer metadata parser can give a local attacker control-flow hijack when the device mounts a crafted NAND flash image through lx_nand_flash_open(), overwriting a driver function pointer with an attacker-chosen 8-byte value; two accompanying out-of-bounds reads were also demonstrated. The bug (CWE-787) is rated 8.6 under CVSS 4.0 and independently assessed as CVSS 3.1 AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, meaning no authentication or user interaction is needed but the attacker must first supply or tamper with the flash image (removable or attached NAND media, modified firmware or OTA image, or supply-chain/provisioning substitution). No public exploit code was identified at time of analysis, though the issue was reproduced verbatim under ASan at HEAD 9f1cfdc; devices that only mount internally trusted flash images are not realistically reachable, while those accepting field-swappable or externally sourced NAND are directly exposed, with the worst impact on bare-metal or non-memory-protected targets where the hijacked pointer yields code execution.
The SNMP agent addon in Eclipse ThreadX NetX Duo can be driven into an out-of-bounds read by a single unauthenticated remote SNMP packet whose object identifier uses BER multibyte length encoding to claim a length larger than the receive buffer, causing `_nx_snmp_utility_object_id_get` to decode adjacent heap bytes as OID components. On memory-protected (MMU/MPU) builds this faults into a crash of the SNMP agent thread, producing denial of service, while on bare-metal no-MMU targets the out-of-bounds read succeeds silently and instead corrupts the agent's internal OID state with neighboring heap data. Exposure is conditional: the NetX Duo SNMP addon must be compiled into the firmware and actively listening (typically UDP/161), so builds without an SNMP-enabled agent are unaffected; no public exploit code has been identified at time of analysis (no CISA KEV listing).
Unauthenticated remote clients can exhaust the packet pool of the Eclipse ThreadX NetX Duo RTSP server addon, causing a denial of service: roughly two dozen RTSP requests carrying a Session header value that the parser cannot convert (empty or non-numeric) leak one packet block each until the pool hits zero and the server can no longer serve any client. The leak occurs because the Session branch of _nx_rtsp_server_error_response_send's caller returns the raw NetX error code instead of mapping it to an RTSP status, and the error-response path then drops the already-allocated response packet on that unrecognized code. No public exploit identified at time of analysis, and no CISA KEV entry was provided; the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) confirms remote, unauthenticated, availability-only impact, with blast radius worst when the RTSP server shares its packet pool with the rest of the application, as in the shipped sample (22-block pool exhausted by ~26 requests).
Heap out-of-bounds write in the mDNS responder of Eclipse ThreadX NetX Duo allows an unauthenticated attacker on the same local network segment to corrupt packet memory by sending two ordinary mDNS PTR records in response to a _http._tcp service query. The flaw arises from a string-table bucket collision: owner names of 12-15 characters round to the same slot size, causing the responder to reuse a shorter stored entry and write 1-3 bytes past the transmit packet's data end. With the mDNS addon active and adjacency to the target, the realistic impact is denial of service through corrupted neighboring packets or pool free lists, though code execution is not demonstrated; no public exploit code or active exploitation has been identified at time of analysis.
Malformed ICMPv6 Neighbor Discovery option parsing in Eclipse NetX Duo can stall the IP thread or read past packet buffers, causing denial of service on devices reachable from the same local link. The affected product is NetX Duo with IPv6/ICMPv6 ND enabled; an adjacent-network attacker with no authentication or user interaction can send crafted Router Advertisement, Router/Neighbor Solicitation, Neighbor Advertisement, or Redirect messages so that a one- or two-byte residue bypasses option validation and later processing loops indefinitely or underflows its counters. The vendor's CVSS 4.0 score is 7.1 (availability-only), the referenced advisory is GHSA-39p4-p83c-58hr, no public exploit identified at time of analysis, and no CISA KEV confirmation is provided.
Memory disclosure and denial of service in the Eclipse NetX Duo TFTP server addon (nxd_tftp_server) are reachable by an unauthenticated remote attacker sending a single oversized DATA datagram over the network, because the DATA branch enforces only a four-byte minimum (nxd_tftp_server.c:1037) and never validates an upper bound against the protocol maximum of 4 + NX_TFTP_FILE_TRANSFER_MAX. The oversized length is passed as nx_packet_length - 4 into FileX via fx_file_write, and since nx_packet_length measures the whole packet chain rather than the first contiguous buffer, FileX reads past the end of that buffer and the leaked heap contents are written into the file the attacker is uploading, which a subsequent TFTP read request returns to the attacker; the same datagram also wedges the server permanently because nx_packet_copy with NX_WAIT_FOREVER suspends the server thread once the request exceeds the packet pool capacity. Rated CVSS 4.0 base 8.8 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:H), consistent with an independent assessment of CVSS 3.1 AV:N/AC:L/PR:N/UI:N/C:H/I:N/A:H, and no public exploit code was identified at time of analysis, though the attack path is trivially scriptable and requires only that the optional TFTP addon be compiled in and reachable.
Unauthenticated remote attackers can exploit an out-of-bounds read in Eclipse NetX Duo's DTLS ClientHello parser to disclose up to 255 bytes of adjacent process memory over the network, or to crash the device. The flaw triggers on the very first ClientHello and requires no prior session, credentials, or user interaction, affecting default DTLS-enabled deployments with a reachable DTLS/UDP listener. No public exploit code has been identified at time of analysis, but the issue is rated CVSS 8.8 and is considered a high-priority risk among the NetX Secure DTLS/TLS advisory cluster.
User-mode-to-kernel privilege escalation in Eclipse ThreadX lets a loaded, memory-protected TXM module register an arbitrary function pointer as the global trace-full callback, which privileged kernel code then invokes directly with no pointer validation and no privilege-dropping trampoline when the trace buffer wraps. Affected builds are those compiled with the non-default TX_ENABLE_EVENT_TRACE option and running modules in TXM_MODULE_USER_MODE with TXM_MODULE_MEMORY_PROTECTION; an invalid pointer crashes the kernel (denial of service), while a pointer into the module's own code has been observed executing with kernel privilege (CONTROL.nPRIV = 0), producing a scope-crossing compromise of the RTOS kernel by a local, low-privileged attacker. Exploitation requires the attacker to already control executing code inside a loaded module plus the non-default trace build flag, and no public exploit code has been identified at time of analysis.
Secure memory disclosure in Eclipse ThreadX occurs because multiple TrustZone-M non-secure callable (NSC) entry functions fail to validate caller-supplied pointers, allowing code already executing in the non-secure world to hand the secure firmware pointers into secure memory that are then dereferenced without an NS-region check. Only builds that enable Arm TrustZone-M secure/non-secure separation and expose NSC entry points taking raw pointer arguments are exposed; a single-world ThreadX build without TrustZone-M NSC surfaces is not affected. Exploitation requires a local, already-established non-secure foothold (AV:L, PR:L) with no user interaction and no network vector, making this an access-gated trust-boundary flaw rather than an internet-facing critical, and no public exploit code has been identified at time of analysis.
Malformed MQTT PUBLISH frames leak packet buffers in the Eclipse ThreadX NetX Duo MQTT client, letting a peer that can deliver a few dozen such messages exhaust the network driver's receive pool and halt all inbound traffic on the device until it is rebooted. Only builds including the NetX Duo MQTT client are exposed, and delivery requires broker control, a man-in-the-middle position on the MQTT session, or publish rights on a topic the client subscribes to, which is why the impact is availability-only (CVSS 4.0 base 8.2; assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) despite a network attack vector. No public exploit code and no confirmed active exploitation have been identified at time of analysis.
An out-of-bounds write in Eclipse NetX Duo's WebSocket client allows unauthenticated remote attackers to corrupt NX_PACKET control block structures via a maliciously crafted masked WebSocket frame, potentially leading to code execution or denial of service. The vulnerability, tracked as CVE-2026-102761 with a CVSS 4.0 score of 9.3, affects all versions of NetX Duo per the CPE. No public exploit code has been identified at time of analysis, and no KEV status is reported.
Memory corruption in the Eclipse ThreadX NetX Duo NetX Secure TLS stack can overrun the packet pool and crash a device, because each outbound TLS record is zeroed after the TCP layer has already taken ownership of - and may have freed and recycled - the underlying packet chain. The defect is a CWE-416 use-after-free write with a length underflow on reused packets, reachable from the network without authentication (CVSSv3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H, with the published CVSS 4.0 score of 8.3 reflecting the availability impact). It is not present in default builds: exploitation requires the non-default NX_SECURE_KEY_CLEAR compile-time option plus packet-pool free/reuse timing an attacker cannot deterministically force, so practical risk is lower than the headline score; no public exploit identified at time of analysis and no confirmed active exploitation.
Privilege escalation in Eclipse ThreadX allows an unprivileged, memory-protected ThreadX module to break out of its MPU isolation boundary and obtain privileged (kernel-mode) read and write access to arbitrary memory, including the ability to clear the MPU enable bit and remove its own protection. The attack is local and low-complexity and requires the attacker to already be able to execute code as a loaded, unprivileged module (PR:L), for example by supplying or subverting a loadable module in a deployment that uses the ThreadX Module feature with MPU-based memory protection; systems that do not use isolated modules are not affected. No public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV, but the high integrity and confidentiality impact on isolated-module deployments makes it significant.
Credentialed cross-origin reads and namespace takeover were possible against the hosted open-vsx.org registry because its CDN/edge layer reflected the requesting Origin back in Access-Control-Allow-Origin while simultaneously emitting Access-Control-Allow-Credentials: true on authenticated /user/ endpoints. A page on any origin could then issue credentialed requests in a logged-in user's browser and read the responses, exposing /user (login name, avatar, homepage, tokens URL), /user/tokens, /user/namespaces, /user/extensions, /user/search/{name}, /user/namespace/{name}/members and - critically - /user/csrf; with the CSRF token readable, the write-endpoint protection collapsed, and chaining /user/csrf with /user/token/create let the attacker page mint and exfiltrate a personal access token carrying publish and delete rights over the victim's namespaces. Attackers need no authentication of their own (CVSS 4.0 PR:N) and only passive victim interaction - the victim must be logged in to open-vsx.org and visit the attacker's page - while no public exploit code has been identified at time of analysis.
A local unprivileged user can hijack the Control Interface of another workload in Eclipse Ankaios 0.1.0 through 1.0.2 by pre-creating the agent's predictable run-folder path hierarchy and Control Interface FIFOs under the shared default location `$TMPDIR/ankaios`. Because the agent reuses an existing directory or FIFO based only on an existence/file-type check — without verifying ownership or permissions — it treats the attacker-owned pipes as the legitimate Control Interface and executes requests under that workload's configured `controlInterfaceAccess` permissions, enabling workload impersonation and unauthorized reading or modification of the cluster's desired state. The flaw is CWE-379 (insecure temporary file/permissions), carries a CVSS 4.0 base score of 8.4 (AV:L/PR:L/AT:P, high confidentiality and integrity impact), and has no public exploit code or CISA KEV listing at time of analysis; EPSS is 0.09%, consistent with a local, non-automatable attack. The vendor released v1.0.3 with an ownership/permission validation check (PR #799).
HTTP/2 thread-exhaustion denial-of-service in Eclipse Jetty allows unauthenticated remote clients to permanently block all server threads by exploiting a race condition in RST_STREAM and GOAWAY frame handling. The race incorrectly resets the `HTTP2Flusher.terminated` field from a non-null terminal state back to null, allowing new write-queue entries to be enqueued in a flusher that will never drain them; the write-blocked threads waiting on those entries hang indefinitely. Across five affected Jetty major branches (9.4, 10.0, 11.0, 12.0, 12.1), any internet-exposed HTTP/2 endpoint is reachable without authentication. No public exploit has been identified at time of analysis.
HTTP/1.1 request smuggling in Eclipse Jetty allows unauthenticated remote attackers to desynchronize request boundary parsing between Jetty and an upstream proxy, enabling manipulation of other users' HTTP sessions. The root cause is Jetty's acceptance of a bare LF character (\n) as a line terminator during chunked transfer encoding parsing - specifically in chunk extensions, chunk data termination, or trailer termination - where RFC 7230 mandates CRLF (\r\n). Depending on the Jetty version and configured HTTP compliance mode, a crafted request can cause the proxy and Jetty to disagree on where one request ends and the next begins, enabling request injection against co-located tenants. No public exploit has been identified at time of analysis.
Unauthenticated remote denial-of-service in Eclipse Jetty's WebSocket implementation allows any network-accessible client to exhaust the JVM heap by sending a single WebSocket frame with an unknown opcode and an arbitrarily large declared payload length. When auto-fragmentation is enabled, unknown opcodes bypass the normal maximum frame size check, causing Jetty to attempt heap allocation for the declared payload size before the opcode is ever validated - a logic-ordering flaw classified under CWE-770. The CVSS 4.0 score of 8.7 (AV:N/AC:L/PR:N/UI:N/VA:H) reflects high impact and low attack barrier; no public exploit has been identified at time of analysis.
Incorrect authorization in Eclipse Ankaios v0.5.1-v1.0.1 allows an authenticated workload to bypass its scoped access restrictions on the agent-side Control Interface. When the cluster is configured with multi-segment allow rules whose first path segment is a wildcard (e.g., `*.workloads.some_workload`), submitting a CompleteStateRequest or UpdateStateRequest with an empty field mask is incorrectly evaluated as matching the scoped rule, granting the workload full read or write access beyond its authorized state subtree. No public exploit is identified at time of analysis; a patched release (v1.0.2) is available.
TLS certificate validation is disabled by default in the Federator component of Eclipse aeriOS, enabling man-in-the-middle interception of all outbound HTTPS connections made by the component. Any attacker who can position themselves on the network path between the Federator and external services - including OAuth authorization servers - can impersonate those services and harvest OAuth client credentials and bearer tokens. This affects only the current pre-release development codebase; a source-level fix is confirmed in commit 9c63b60, but no official tagged release exists. No public exploit or CISA KEV listing has been identified at time of analysis.
Path traversal in Eclipse aeriOS Self-orchestrator prior to version 1.2.1 allows unauthenticated remote attackers to write or delete arbitrary JSON files on the host filesystem by embedding path separator sequences (e.g., '../') in resource identifiers submitted to the REST API. The vulnerability stems from direct string concatenation of user-supplied names into `fs.writeFileSync()` paths without sanitization, confirmed by the upstream commit diff. Real-world impact is amplified by the complete absence of API authentication (PR:N) and by the container running with elevated privileges in the affected deployment, extending the writable filesystem scope beyond the intended `./facts/` directory. No public exploit code has been identified at time of analysis.
Authorization bypass in Eclipse Arrowhead 5.0.0-5.2.1 allows any authenticated system - regardless of privilege level - to reach every protected management API endpoint by submitting percent-encoded paths that defeat the raw-URL substring check while still being routed by Spring MVC's decoded dispatcher. Exploiting the flaw is trivial: encoding a single character in '/mgmt/' (e.g. 'm' → '%6D') causes the filter to fall through without authorizing the request, yet Tomcat decodes and dispatches it normally. The highest-impact target is POST /authentication/mgmt/identities, which creates new sysop-level accounts, yielding full administrative takeover of the Arrowhead local cloud. No public exploit has been identified at time of analysis.
Authentication bypass in Eclipse Arrowhead 5.0.0 through 5.2.1 lets an unauthenticated attacker who can publish to the MQTT broker impersonate the cloud's system operator. When the MQTT API runs with the certificate authentication policy, CertificateMqttFilter reads an X.509 certificate straight from the MQTT message payload and trusts its Subject DN without ever verifying the signature or issuer chain, reducing authorization to two string comparisons on public, attacker-controlled values. By minting a self-signed certificate with CN=Sysop.<cloud>.<org>.arrowhead.eu and dnQualifier=op, the attacker gains isSysOp==true and full management access. No public exploit is identified at time of analysis, but the technique is described in full detail in the advisory.
Improper certificate validation in the KrakenD-based API Gateway of Eclipse aeriOS allows a network man-in-the-middle to compromise bearer-token validation. The bundled KrakenD configuration hard-codes disable_jwk_security to true with no Helm override, so KrakenD skips TLS certificate verification (and in the shipped config fetched the JWKS over plaintext HTTP) when retrieving the JSON Web Key Set used to validate JWTs. Only pre-release development builds are affected; there is no public exploit identified at time of analysis and the flaw is not in CISA KEV.
Template injection in Eclipse Ditto's ImplicitThingCreationMessageMapper (versions 1.3.0 through 3.9.6) allows authenticated connection publishers to override the administrator-configured access policy of a newly provisioned digital twin by embedding JSON-breaking characters in attacker-controlled inbound message headers. The mapper substitutes header placeholder values as raw, unescaped strings into a pre-configured JSON thing-template before parsing, enabling a crafted header value containing a double-quote to escape its string context and inject an inline _policy object - effectively granting the attacker full read/write access to the twin while permanently revoking the legitimate owner's access. Exploitation requires a non-default mapper configuration and a template that reflects attacker-controllable headers; no public exploit code or active exploitation (CISA KEV) has been identified.
Path traversal in Eclipse Theia 1.73.0-1.74.x AI Agent Mode allows arbitrary file writes outside the workspace with backend OS user privileges through model-supplied paths that bypass workspace-containment checks. The affected tools - writeFileContent, suggestFileContent, and associated replacement and state helpers - accept relative paths such as ../.bashrc, absolute paths, or tilde-expanded paths like ~/.ssh/authorized_keys without boundary validation. Because path arguments derive from LLM output, an indirect prompt injection attack embedded in developer-loaded content can steer writes to host-executed files and escalate to backend code execution; Agent Mode applies writes silently with no confirmation dialog. No public exploit code or CISA KEV listing exists at time of analysis, though the prompt-injection attack surface is realistic in cloud IDE deployments.
Authorization bypass in Eclipse Lyo 2.0.0 through 7.0.0 lets remote attackers abuse the 2-legged OAuth flow to promote a self-registered 'provisional' trusted client into a fully trusted one without the required administrator approval. Applications that build their authorization filters on Lyo's AbstractAdapterCredentialsFilter are affected, allowing an attacker to act as a trusted OAuth client and access protected OSLC resources. No public exploit identified at time of analysis, and it is not listed in CISA KEV; fixes shipped in 6.0.1.Final and 7.0.0.Beta3.
Remote code execution in Eclipse Theia 1.69.0 and earlier allows an attacker to execute arbitrary commands with the victim's user privileges by embedding a malicious git repository configuration inside a cloned repository. Any Theia-based IDE or application including the @theia/git extension or the bundled VS Code git extension is affected, because both automatically invoke git commands such as git status upon folder open without first presenting a workspace trust prompt. This vendor-confirmed issue is fixed in version 1.70.0 via workspace trust enforcement; no public exploit code has been identified at time of analysis and it does not appear in the CISA KEV catalog.
XXE injection in Eclipse RDF4J exposes applications to local file disclosure and server-side request forgery when parsing untrusted XML-based RDF data or SPARQL query results. The root cause is an incomplete remediation of CVE-2018-1000644: while that earlier fix hardened some parser entry points, several XML parser interfaces remained unprotected against DOCTYPE declarations, external entity references, and external DTD loading. No public exploit has been identified at time of analysis, and no CISA KEV listing exists, but the unauthenticated network vector (CVSS 4.0: 8.7, PR:N) means any application exposing RDF ingestion endpoints is at risk without upgrading to RDF4J 5.3.2.
Server-Side Request Forgery combined with CSRF in Eclipse GlassFish's DownloadServlet ContentSources handler allows a remote attacker to exfiltrate the administrative `gfresttoken` to an attacker-controlled host when an authenticated administrator visits a malicious page. Affecting Eclipse GlassFish 8.0.x prior to 8.0.4, successful token theft yields full control of the GlassFish administrative domain until the token expires, effectively an unauthenticated takeover of the management plane. No public exploit identified at time of analysis, and the issue is not in CISA KEV, but the CVSS 9.6 rating and low attack complexity make it high priority.
Remote file inclusion and path traversal in Eclipse Mojarra 2.3 through 5.0 allows unauthenticated network attackers to force server-side Facelet resolution of attacker-controlled URLs via the `DefaultFaceletFactory` component, exposing restricted files with the privileges of the application server. The attack targets the JSF template resolution pipeline and can leak sensitive configuration data from `WEB-INF/web.xml` (which typically contains database credentials and security settings) or OS-level files such as `/etc/passwd`. SSVC rates the attack as automatable with no confirmed active exploitation at time of analysis, but the CVSS:3.1 AV:N/AC:L/PR:N/UI:N vector means no barriers exist between a remote attacker and a vulnerable endpoint.
Unauthenticated arbitrary file read in Eclipse Theia browser-mode deployments (versions ≤1.73.1) allows any network client to exfiltrate files accessible to the backend process, including paths outside the opened workspace such as SSH keys, cloud credential tokens, and system configuration files. The vulnerability combines two compounding flaws: the `@theia/filesystem` HTTP endpoints perform no workspace confinement when resolving client-supplied URIs to filesystem paths, and a middleware defect in `@theia/core` re-issues the session cookie and calls `next()` without validating the connection token on HTTP requests - token enforcement applies only to WebSocket upgrades, leaving all HTTP file endpoints fully exposed. Electron deployments are explicitly not affected via this path. No public exploit is identified at time of analysis.
Silent authorization bypass in Eclipse Milo OPC UA server SDK versions 1.0.0-1.1.4 allows anonymous network clients to invoke protected methods, read role-permission metadata, and delete protected nodes. The defect is a missing field copy in `OpcUaServerConfig.copy()`: when servers construct their running configuration via this method, the configured `RoleMapper` is silently dropped, causing the `DefaultAccessController` to receive empty role ID lists for every session and skip all role-permission enforcement. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV.
Unauthenticated remote denial-of-service in Eclipse Milo 0.6.0-1.1.4 allows any network-accessible client to exhaust the OPC UA server's off-heap direct memory pool by repeatedly sending incomplete UASC message chunks and disconnecting before message assembly completes. The UASC server-side asymmetric handler and ChunkDecoder fail to invoke ReferenceCountUtil.safeRelease() on retained Netty ByteBuf objects when the channel lifecycle ends, causing unbounded off-heap memory accumulation. No authentication is required and no special server configuration is necessary; the fix commit is publicly available on GitHub, serving as an effective blueprint for exploitation, though no standalone POC tool or CISA KEV listing has been identified at time of analysis.
Authorization bypass in Eclipse Milo's OPC UA Call service (versions 1.0.0-1.1.4) permits unauthenticated or low-privileged OPC UA clients to invoke server-side methods they are explicitly denied access to. The server correctly computes per-method authorization for a mixed batch CallRequest but then dispatches the original unfiltered batch - including denied methods - to address-space handlers, rendering the authorization check effectively inert. No active exploitation is confirmed and no public exploit code has been identified, but the attack requires only standard OPC UA client tooling and zero authentication, making exploitation trivially accessible to any network-reachable client.
Password recovery in Eclipse Milo (the open-source OPC UA SDK for Java) versions 0.6.0 through 1.1.4 allows an on-path attacker to break username-token confidentiality via a Bleichenbacher-style padding oracle. The server returns distinguishable error responses for invalid RSA PKCS#1 v1.5 padding versus other authentication failures during username-token processing, so an attacker who captures a victim's Basic128Rsa15-encrypted username token can send repeated unauthenticated ActivateSession requests to recover the cleartext password and then authenticate as the victim. No public exploit identified at time of analysis and it is not listed in CISA KEV; the weakness and its upstream fix are confirmed by the Eclipse Foundation.
Server-side request forgery in the Eclipse CSI PIA `POST /v1/upload/sbom` endpoint lets remote attackers coerce the server into connecting to an arbitrary host, port, and scheme of their choosing. By exploiting a parser-differential between Python's `urlparse` (used for the issuer allowlist check) and `requests`/`urllib3`/`urllib` (used for OIDC discovery and JWKS retrieval), an attacker crafts a JWT `iss` claim containing a backslash that passes validation but resolves to a different host during the actual fetch. The `iss` claim is only checked in its unverified form, so no legitimate token is needed; no public exploit has been identified at time of analysis and the issue is not listed in CISA KEV.
Authorization bypass in Eclipse BaSyx Go Components through 1.0.0 lets unauthenticated network attackers reach ABAC-protected API handlers by appending a trailing slash to a route (e.g. GET /shells/ instead of GET /shells). The ABAC middleware evaluates the slashed path, finds no matching policy route, and passes the request onward, after which Chi's middleware.StripSlashes normalizes the path and executes the protected handler with no ABAC decision and none of the expected ABAC query filters. Publicly available upstream fix exists (PR #442, v1.0.1) and SSVC rates technical impact as total, though EPSS is low (0.35%) and no active exploitation is confirmed.
Cross-origin credential leakage in Eclipse Vert.x vertx-core (4.x through 4.5.29 and 5.x through 5.1.4) occurs because DefaultRedirectHandler copies all original request headers verbatim when the HttpClient follows an HTTP 30x redirect, stripping only Content-Length and never comparing the origin (scheme/host/port). An application that lets untrusted input influence a request URL - webhook dispatchers, image proxies, SSRF-style URL fetchers - can be steered to an attacker-controlled redirect target that then receives Authorization, Cookie, Proxy-Authorization, and custom headers like X-API-Token. No public exploit has been identified at time of analysis, and the flaw is not in CISA KEV.
Cross-domain cookie injection in Eclipse Vert.x Web Client (WebClientSession) lets any server a victim application contacts set a cookie scoped to an unrelated third-party domain, which the client later replays to that domain. Versions up to 4.5.29 (4.x) and 5.1.4 (5.x) fail to enforce the RFC 6265 Domain-attribute ownership check, so an attacker can bind their own session cookie into the victim's WebClientSession and have the victim's later requests to a target service execute under the attacker's account, exposing sensitive request payloads. No public exploit identified at time of analysis and it is not listed in CISA KEV; scored CVSS 4.0 8.2 (High) by Eclipse.
Log integrity spoofing in Eclipse Kura before 5.6.2 lets an unauthenticated remote attacker forge the client IP recorded in audit logs by supplying a crafted X-Forwarded-For header, because the Jetty ForwardedRequestCustomizer is installed unconditionally on every connector and getRemoteAddr() reflects the header value. This enables bypass of IP-based brute-force defenses like fail2ban (spoofing a non-routable source to evade bans) or a denial of service against a third party by injecting a victim IP so their address is banned. No public exploit is identified at time of analysis and it is not on CISA KEV; CVSS 4.0 base score is 8.8.
Unauthenticated arbitrary file write in Eclipse BaSyx Java Server SDK (2.0.0-milestone-05 through 2.0.0-milestone-12) lets remote attackers plant files anywhere the Java process can write when the server is deployed with the MongoDB file backend, potentially escalating to remote code execution. The AAS thumbnail API trusts a client-supplied fileName that is later reused as a filesystem path, so a traversal or absolute-path filename lands attacker-controlled bytes outside the intended directory. There is no public exploit identified at time of analysis and the issue is not in CISA KEV, but the vendor-fixed release (2.0.0-milestone-13) is available.
Server-side request forgery in Eclipse Theia (version 1.26.0 and later) lets a low-privileged user connected to the /services messaging endpoint coerce the backend into fetching an attacker-supplied URL and returning the full response body, exposing localhost admin interfaces and cloud instance metadata that sit behind the browser network boundary. The flaw is exploitable by any client with access to the Theia service connection, making multi-tenant and publicly-reachable deployments the primary concern. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV.
Cross-site WebSocket hijacking in Eclipse Theia's browser backend (versions 1.8.1 and later) lets a foreign-origin web page reach the unauthenticated /services shell-terminal RPC namespace and execute arbitrary OS commands on the victim's host. The flaw stems from fail-open Origin validation in @theia/core combined with a client-controllable fix-origin header, so simply luring a developer running Theia to a malicious site yields remote code execution. There is no public exploit identified at time of analysis, and CVSS is rated 8.8 (High) driven by the user-interaction-only barrier.
Server-side request forgery and OIDC token forgery in Eclipse CSI PIA lets an unauthenticated attacker abuse a flawed Jenkins issuer allowlist (a bare `startswith('https://ci.eclipse.org')` check in `is_issuer_known`, pia/models.py:139) to redirect OIDC discovery and JWKS fetches to an attacker-controlled host. By posting a crafted issuer such as `https://ci.eclipse.org@evil.host` or `https://ci.eclipse.org.evil.host` to `POST /v1/upload/sbom`, an attacker forces PIA to make outbound requests to arbitrary hosts and to accept a JWT signed with the attacker's own key, effectively bypassing token verification. No public exploit identified at time of analysis, but the flaw is unauthenticated and network-reachable, and the CVSS 3.1 base score is 8.2.
Denial of service in Eclipse Parsson before 1.1.8 lets remote unauthenticated attackers exhaust CPU and memory on any application that parses attacker-controlled JSON. Because the parser enforced no default cap on characters consumed per document, a single oversized payload - large arrays, strings, numbers, deep nesting, or whitespace - can hang or crash the service. No public exploit is identified at time of analysis; the fix (1.1.8) adds a configurable default limit of 15 million parser-consumed characters.
Stored cross-site scripting in Eclipse Open VSX Registry (versions 0.1.0 through before 1.0.2) allows an attacker who self-registers a publisher account to upload a VSIX containing malicious HTML that the /vscode/unpkg/ endpoint serves inline as text/html within the open-vsx.org origin, with no Content-Security-Policy or Content-Disposition: attachment header. When a logged-in victim is lured to the resulting URL, the script runs in the registry's origin and can steal session tokens, mint Personal Access Tokens, and publish trojanized extension versions - turning a single XSS into a supply-chain compromise of VS Code, VSCodium, Cursor, and Windsurf users. No public exploit is identified at time of analysis and EPSS risk is low (0.17%), but the downstream blast radius is severe.
Denial of service in Eclipse ThreadX NetX Duo HTTP server arises from a flawed remediation of CVE-2025-0728, where the refactored shared cleanup label invokes fx_file_close() on an uninitialized file handle whenever an error occurs before file open. Remote attackers can reach the vulnerable PUT path over the network without authentication, triggering undefined behavior, double-close conditions, or memory corruption that can crash the embedded HTTP service. No public exploit identified at time of analysis, and the issue is not listed in CISA KEV.
Arbitrary command execution in Eclipse Theia versions prior to 1.69.0 allows a malicious repository to run host commands with the user's privileges when its workspace is opened, because custom task definitions in .theia/tasks.json or .vscode/tasks.json bypass the workspace trust gate. When the victim has also enabled AI chat with tool confirmation disabled via a workspace .theia/settings.json, the chain triggers automatically on the first chat message. No public exploit identified at time of analysis, but the attack pattern mirrors well-known VS Code workspace-trust bypass classes.
Indirect prompt injection in Eclipse Theia before 1.71.0 allows a malicious repository to automatically override the AI agent's system prompts when a victim opens the workspace, by placing files under .prompts/*.prompttemplate that Theia auto-loads. Combined with built-in AI chat features, the hijacked prompt can chain to data exfiltration via Markdown image rendering or arbitrary command execution via task definitions. No public exploit identified at time of analysis and the vulnerability is not listed in CISA KEV.
Indirect prompt injection in Eclipse Theia versions prior to 1.71.0 allows attackers who control a workspace's filesystem layout to coerce the built-in AI chat agent into executing attacker-supplied instructions, enabling data exfiltration through Markdown image rendering or arbitrary command execution through task definitions. No public exploit identified at time of analysis, but the CVSS 4.0 base score of 8.4 reflects high impact across confidentiality, integrity and availability once a developer opens an untrusted repository. The flaw is reported by the Eclipse Foundation and fixed in version 1.71.0.
Remote code execution in Eclipse GlassFish allows attackers with administrative access to the Administration Console to execute arbitrary operating system commands as the application service user. The flaw stems from improper input handling in admin panel requests (CWE-94), and while CVSS rates it 9.1 due to scope change and full CIA impact, exploitation requires high privileges (PR:H). No public exploit identified at time of analysis and the issue is not listed in CISA KEV.
The AES-CBC-with-HMAC JWE path in Eclipse KeyPont gose (published as github.com/ThalesGroup/gose v0.9.0 through v0.13.0-rc1) provides no ciphertext integrity at all: HmacShaCryptor.Hash returned the MAC of the empty message for every input, so the authentication tag is constant per key and independent of the message. An unauthenticated remote attacker who has observed a single legitimately produced JWE under the target key can replay that tag onto arbitrary attacker-chosen header, IV and ciphertext and pass verification, enabling bit-flipping manipulation of the recovered plaintext and padding-oracle-style attacks; confidentiality alone is not broken. Only the CBC-HMAC direct encryption/decryption blocks are affected, AEAD/GCM modes do not use this cryptor, and the evaluator rates it AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N with no public exploit identified at time of analysis.
Denial of service in Eclipse OpenJ9 through 0.63.0 affects deployments that enable the optional JITServer mode, where unauthenticated remote attackers or a malicious JITServer peer can crash the daemon or a client JVM with malformed protocol messages. The vendor CVSS 4.0 score is 8.7 (High), and the assessed CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H confirms remote, low-complexity, availability-only impact with no confidentiality or integrity loss. JITServer is not enabled in default JVM operation, so standard OpenJ9 installations are not exposed; no public exploit or CISA KEV entry was identified at time of analysis.
Denial of service in Eclipse OpenJ9's optional JITServer component (versions prior to 0.63.0) allows an unauthenticated remote attacker to crash the server process by sending a crafted DataDescriptor message. The flaw is an unsigned integer underflow caused by missing cross-field validation of _size, _paddingSize, and _dataOffset, leading to an out-of-bounds heap read and SIGSEGV. Exploitation requires JITServer to be enabled and network-reachable; no public exploit code or CISA KEV entry was identified at time of analysis, and the assessed impact is availability-only (CVSS 3.1 base 7.5), narrower than the headline CVSS 4.0 score of 8.7 suggests.
Remote denial of service in Eclipse OpenJ9 JITServer before 0.63.0 lets unauthenticated network attackers exhaust compilation worker threads by sending crafted TCP connections with a malicious 4-byte length prefix. The integer overflow in MessageBuffer::computeRequiredCapacity() drives a worker thread into an infinite loop at roughly 100% CPU, so a small number of connections can silently stop compilation services for all connected client JVMs. The vendor base score of 8.7 reflects availability-only impact; no public exploit was identified at time of analysis.
Integer overflow in the Eclipse ThreadX module manager lets a loaded module under-allocate an object-pool block and corrupt the adjacent byte-pool block. When a module calls txm_module_object_allocate with an object_size near ULONG_MAX, the manager's unchecked addition of its fixed 16-byte private header wraps, so the pool serves a block smaller than the header and the subsequent header write spills past its end into the neighbouring allocation. The issue is locally exploitable by a low-privileged attacker who already has code running inside a loaded module, affects only builds that compile in and use the ThreadX module subsystem, requires no user interaction, and no public exploit code was identified at time of analysis (no CISA KEV listing was provided).
Eclipse ThreadX's Cortex-A7 MMU module port accepts a caller-supplied buffer range after validating only its first byte, so an authenticated local attacker who can execute code in a protected module can cause privileged dispatch code to read or write beyond the module's declared memory. The weakness sits in a shared range-check macro used by protected-module dispatchers that consume buffers or extra-parameter arrays, and exposure is limited to systems running the ThreadX Module Manager with memory-protected modules on that port. No public exploit identified at time of analysis, and the attack path is local rather than remote or unauthenticated.
Eclipse ThreadX firmware built with Module Manager and loadable modules enabled contains a use-after-free in txm_module_object_deallocate: a module can request release of a kernel object control block by address, and the manager frees it even if the kernel still references it. The object remains on its created list and, for threads or timers, on scheduler/timer lists, so the byte pool can reallocate the same memory while the kernel still uses it. Exploitation requires local low-privilege code execution inside a loaded module (PR:L, AV:L) and is not remotely reachable in default builds; no public exploit code was identified at time of analysis.
Heap out-of-bounds read in the NetX Secure TLS 1.3 Certificate-message parser of Eclipse ThreadX NetX Duo can be triggered by a malicious or man-in-the-middle TLS 1.3 server, crashing the connecting peer. The flaw is unauthenticated (CVSS PR:N) and reachable during the normal handshake, before certificate verification completes, but requires the victim device to act as a TLS client and connect to an attacker-controlled endpoint - an attacker cannot trigger it against an unsolicited listening service. Vendor/independent assessment rates impact as availability-only (CVSS 4.0 base 8.7; CVSS 3.1 AV:N/AC:L/PR:N/UI:N/A:H), and no public exploit code or CISA KEV active-exploitation entry was identified at time of analysis.
A four-byte malformed TLS 1.3 Certificate handshake header can drive the NetX Secure certificate parser in Eclipse ThreadX NetX Duo past the end of its session packet buffer, crashing the device or stack. The flaw is remotely reachable, unauthenticated, and requires no cryptographic validity or user interaction - the parser decrements the message length to skip a certificate_request_context byte without first confirming a byte exists, so a zero-length message wraps the unsigned length to 0xFFFFFFFF and renders the subsequent bounds check vacuous. Impact is bounded to availability (out-of-bounds read leading to fault/denial of service) per the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H vector, and no public exploit code or confirmed active exploitation was identified at time of analysis; the practical exposure limit is that the target must actually negotiate TLS 1.3 and enter the Certificate-message parsing path.
Denial of service in the Eclipse ThreadX NetX Duo Web add-on's HTTP server, which mishandles a `Content-Length` underflow while processing a `PUT` request and ends up dereferencing and freeing an uninitialized pointer. The flaw is reachable by an unauthenticated remote client with a single malformed request (CVSS 4.0 AV:N/AC:L/AT:N/PR:N/UI:N), making the realistic outcome a crash of the HTTP service or the whole device (VC:N/VI:L/VA:H) rather than code execution or data exposure. Only deployments that have compiled in and network-exposed the Web add-on's HTTP server are affected; devices running NetX Duo without that component are not exposed, and no public exploit code was identified at time of analysis.
Out-of-bounds write in Eclipse NetX Duo's X.509 certificate-chain verification lets unauthenticated remote attackers corrupt static memory by presenting a certificate with an RSA modulus larger than the 4096-bit NX_CRYPTO_MAX_RSA_MODULUS_SIZE buffer dimension. The flaw is reachable pre-authentication on TLS/DTLS clients validating a malicious server chain and on servers configured for client-certificate authentication, because the peer-supplied issuer is resolved before the trusted store. No public exploit was identified at time of analysis, but the issue is rated critical (CVSS 4.0 9.3; independently assessed CVSS 3.1 9.8).
Heap-based out-of-bounds write in the Eclipse ThreadX GUIX binary resource (font) loader: a font page header declaring first_glyph greater than last_glyph underflows the glyph count (CWE-190), the count-times-record-size allocation multiply then wraps to a small value, and the load pass writes attacker-controlled glyph records past the end of the undersized buffer. Exploitation requires the target embedded application to load an attacker-supplied or tampered GUIX binary font resource - the assessed vector is local (AV:L) with high attack complexity and required user/application interaction - so realistic exposure is limited to devices that parse externally sourced or updatable GUIX resources rather than fixed build-time font assets; no public exploit code or confirmed active exploitation was identified at time of analysis. Successful corruption can yield code execution, data disclosure, or denial of service in the GUIX process context (CVSS 4.0 base 7.1).
The Eclipse ThreadX GUIX PNG decoder can be driven out of bounds by a crafted PNG that places a second IHDR chunk after IDAT, enabling memory corruption in applications that render attacker-supplied images. Any integration with the GUIX PNG decoder enabled is in scope, since the decoder is compiled in by default, and exploitation is local and requires user/application interaction to open the crafted file. No public exploit was identified at time of analysis; the reporter rates the issue 8.4, and the independent assessment treats it as a local, user-interaction-dependent memory-corruption flaw.
Out-of-bounds heap write in Eclipse FileX allows an attacker who can supply a malformed FAT image to corrupt heap memory during fault-tolerant log replay, with the write position and value under attacker control. On embedded layouts where the FX_MEDIA driver callback is within reach, this can redirect the instruction pointer and yield code execution; the CVSS 3.1 score is 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), reflecting a local path that requires the victim to mount attacker-controlled media. No public exploit code or CISA KEV entry was identified at time of analysis, and practical exposure is limited to builds with FileX fault tolerance enabled that mount untrusted FAT images.
Unauthenticated attackers can bypass JWT signature verification in Eclipse ioFog Controller 3.8.0 through 3.9.1 on the operator WebSocket upgrade handlers for the exec and log routes, allowing them to open privileged sessions for any microservice or fog node whose UUID they know. By crafting a token with an 'admin' group claim, the attacker matches the built-in admin role without needing an account or RoleBinding. No public exploit identified at time of analysis, but the flaw is rated CVSS 9.8 and requires immediate attention.
Unauthenticated remote attackers can exhaust Eclipse ioFog Controller 3.8.0 through 3.9.1 by sending small JSON bodies to POST, PUT, or PATCH routes that perform template substitution, stalling or aborting the control-plane process before bearer-token and RBAC checks run. The bearer check does not reject missing or invalid tokens and the DoS rate limit covers only login routes, so a reachable templating route is enough to disrupt the agent API and in-process WebSocket relays. No public exploit was identified at time of analysis, and the impact is limited to availability with no confidentiality or integrity effect; reporting is consistent with a genuine, impact-limited availability threat.
Security-constraint bypass in Eclipse Jetty leaves some request URL patterns unprotected when annotation and deployment-descriptor security metadata are mixed, specifically in the jetty-annotations and jetty-eeN-annotations modules. The flaw triggers only in a narrow application layout: a servlet declared in web.xml with more than one url-pattern, a web.xml security-constraint that covers only a subset of those patterns, and @ServletSecurity annotations present at the same time, in which case the Jakarta Servlet specification's authoritative url-pattern precedence rules are not applied and the uncovered patterns remain reachable. Because the resulting access is reachable over the network with no credentials (CVSS 4.0 AV:N/PR:N/UI:N, independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N), an unauthenticated remote attacker can read content that should have been restricted, yielding a high confidentiality impact with a low integrity impact and no availability impact; exploitation is strictly gated by the application-level web.xml/annotation layout rather than by the Jetty version alone, and no public exploit identified at time of analysis.
Eclipse Jetty's HttpClient can disclose proxy authentication credentials to a malicious server when the server returns a 407 Proxy Authentication Required status. This information disclosure (CWE-200) affects applications using Jetty's HttpClient with an authenticated forward proxy and connecting to attacker-controlled destinations. Exploitation requires the attacker to control the destination server and the client to be configured with proxy credentials; no public exploit code has been identified at time of analysis, and the CVSS 4.0 score is 8.2 (High).
Path-normalization weakness in Eclipse Jetty's HttpClient causes credential disclosure: when HttpClient receives a redirect whose target contains a non-normalized traversal segment such as /secure/../evil, Jetty matches the stored Authorization credential against the literal /secure prefix rather than resolving the path to /evil, and then follows the redirect - sending the /secure-scoped Authorization header to an endpoint that should never receive it. Per the provided CVSS vector (PR:N) the attacker is unauthenticated, but exploitation carries high attack complexity (AC:H): the attacker must be able to control or influence the redirect response returned to HttpClient, and must already have a malicious application deployed on the SAME domain as the target so the leaked header lands on an endpoint they control. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Unauthenticated remote attackers can exhaust server memory in Eclipse Vert.x deployments that expose the io.vertx:vertx-grpc-server component by sending small, highly compressed gRPC messages whose decompressed payload greatly exceeds the configured per-message maximum size, producing an availability-only denial-of-service condition. The affected ranges are Vert.x 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, and the flaw is only reachable when a gRPC endpoint is network-reachable and accepts client-supplied message compression (standard gRPC gzip/deflate negotiation). The source reports a CVSS 4.0 base score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H with no confidentiality or integrity impact); our independent CVSS 3.1 assessment agrees it is availability-only (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), and there is no public exploit code and no CISA KEV listing identified at time of analysis - the practical precondition is simply that the per-message size limit is being relied upon as the sole defense, since that limit is enforced against compressed bytes only.
Unbounded inbound memory retention in the Eclipse Vert.x MQTT client (io.vertx:vertx-mqtt) allows a malicious or compromised MQTT broker to drive the Vert.x process into memory exhaustion and eventual out-of-memory termination. Client-side applications embedded in Vert.x 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 that subscribe to QoS 2 (exactly-once) topics are affected; the attacker supplies QoS 2 PUBLISH packets with distinct packet identifiers and never sends the matching PUBREL, so each message is retained indefinitely in the client's internal qos2inbound map. The assessed vectors rate this AV:N/AC:H/PR:N with high availability impact only (no confidentiality or integrity impact), reflecting that exploitation requires the attacker to occupy the broker role rather than being an arbitrary remote peer; no confirmed active exploitation (CISA KEV) and no public exploit code were identified at time of analysis, and EPSS data was not provided. Note that the maxInflightQueue option does not mitigate this issue because it constrains only the outbound publish path.
Denial of service in Eclipse Vert.x JSON Schema validation (io.vertx:vertx-json-schema) allows a remote unauthenticated attacker to burn disproportionate CPU by sending a single moderately sized JSON array to any endpoint whose active schema uses the uniqueItems keyword. The affected ranges are 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, and the defect propagates to the dependent modules vertx-web-openapi-router, vertx-web-validation and vertx-openapi. No public exploit code was identified at time of analysis, yet the issue is rated CVSS 4.0 8.7 (HIGH) entirely on availability impact (VA:H with VC:N/VI:N), and applications that do not use uniqueItems in attacker-reachable schemas or that cap request body/array size upstream are not practically exploitable.
Unbounded direct-memory allocation in Eclipse Vert.x's MySQL client (io.vertx:vertx-mysql-client) versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 allows a malicious, compromised, or man-in-the-middle MySQL server to crash the client with an out-of-memory condition before authentication completes. The attacker sends a continuous stream of maximum-length (0xFFFFFF) MySQL protocol packets, preventing the decoder from reaching the end-of-message boundary. This is a denial-of-service issue; no public exploit code has been identified at time of analysis (not in CISA KEV).
An unbounded-memory denial of service in the Eclipse Vert.x PostgreSQL client (io.vertx:vertx-pg-client) allows a malicious, compromised, or man-in-the-middle PostgreSQL server to crash a client application by sending a wire-protocol message header whose 4-byte length field is set to an extremely large value (up to Integer.MAX_VALUE). The client-side decoder performs no maximum-size validation, so it keeps accumulating TCP data into a composite buffer until the JVM exhausts heap and terminates; the abuse happens during connection startup, before authentication completes, so no valid database credentials are required - the attacker only needs to control the server side of the connection or sit on the client-to-PostgreSQL TCP path. Per the independent assessment this is a genuine but conditional availability risk (CVSS 8.2, AV:N/AC:H, availability-only impact) rather than a mass-exploitation priority: no public exploit code or confirmed active exploitation was identified at time of analysis, and clients that connect exclusively to trusted, authenticated, TLS-verified PostgreSQL servers are not realistically exposed.
Denial of service in the Vert.x MySQL client (io.vertx:vertx-mysql-client) lets an attacker who controls or intercepts the client-to-database path crash a Vert.x application: a crafted MySQL result-set packet declaring an extremely large column count causes the client to attempt an unbounded heap allocation, and the resulting OutOfMemoryError kills the Netty event loop thread, taking down all connections and verticles in the process. Affected builds are 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, across all platforms where vertx-mysql-client is used. No authentication or user interaction is required once the hostile source or man-in-the-middle position exists (CVSS 4.0 PR:N), but the vendor rates the attack complexity as high (AC:H) because the database endpoint is normally trusted and operator-controlled; there is no public exploit identified at time of analysis, and the CVE is not listed in CISA KEV.
Denial of service in Eclipse Vert.x's vertx-pg-client component allows an attacker controlling the PostgreSQL server or positioned as a man-in-the-middle on an unencrypted connection to crash the client application. The flaw resides in the binary array decoder (DataTypeCodec.binaryDecodeArray), which allocates a Java array based on a server-supplied 32-bit dimension count without upper bound checking, leading to a multi-gigabyte heap allocation and OutOfMemoryError. Affected versions include 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0. Exploitation requires no authentication (PR:N) but does require control of the database server or a MITM position on a non-TLS connection (AC:H), and no public exploit code has been identified at time of analysis.
Eclipse Vert.x DB2 Client versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 can deserialize attacker-controlled DRDA UDT column data, enabling remote code execution if a Java deserialization gadget chain is present on the classpath or denial of service otherwise. The affected component is io.vertx:vertx-db2-client, and exploitation requires an application to connect to a malicious or man-in-the-middle DRDA server that returns a result-set column tagged with FDOCA LID 0x50; legitimate DB2 servers never emit that type, and client-side TLS is disabled by default. The CVSS 4.0 score is 9.2 with PR:N, but practical exploitation requires attacker server-side/MITM position (AC:H) and, for RCE, a classpath gadget chain; no public exploit identified at time of analysis, and the real-world blast radius is narrower than the score alone suggests.
Unbounded direct-memory allocation in Eclipse Vert.x's MSSQL client (io.vertx:vertx-mssql-client) lets a malicious, compromised, or man-in-the-middle SQL Server endpoint crash a connecting client application by streaming TDS packets that never set the END_OF_MESSAGE status flag. Affected versions are [4.0.0, 4.5.34], [5.0.0, 5.0.12], [5.1.0, 5.1.9] and 5.2.0: the TDS message decoder aggregates inbound packets into a composite direct-memory buffer with no cumulative size cap, so the buffer grows until memory is exhausted and the process dies (availability impact only, with no confidentiality or integrity loss, per the assessed CVSS:3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H). The flaw is reachable before authentication completes, meaning no valid server credentials are required, but exploitation is not available to an arbitrary remote attacker - it demands control of, or a man-in-the-middle position on, the server side of the connection, which is why access complexity is rated High. No public exploit code or confirmed active exploitation was identified at time of analysis.
Denial of service in the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) affects versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0: the RESP parser trusts a server-declared array, push, or attribute length and pre-allocates that many elements without an upper bound, so a crafted response triggers a massive heap allocation that terminates the Vert.x event-loop thread with OutOfMemoryError and denies service to every connection and verticle sharing that loop. Exploitation is conditional rather than opportunistic - a remote, unauthenticated attacker qualifies only if they control or have compromised the Redis server the client talks to, or if they can occupy a man-in-the-middle position on the client-to-Redis path; neither user interaction nor prior client authentication is required, which is why the assessed vector is AV:N/PR:N but AC:H, and impact is availability-only (no confidentiality or integrity loss). No public exploit code or confirmed active exploitation was identified at time of analysis, and this is a genuine but conditional DoS issue rather than a top-tier emergency.
Denial of service in Eclipse Vert.x HTTP proxy (io.vertx:vertx-http-proxy) affects versions 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, allowing remote unauthenticated attackers to cause indefinite heap allocation. Exploitation requires the application to explicitly configure an intercepting body transformer-a non-default, developer-enabled feature-and the flaw lies in the transformer interceptor's reliance on a max buffered bytes limit that fails to keep per-request buffers bounded. No public exploit code has been identified at time of analysis; the CVSS 4.0 score is 8.7 with high availability impact.
Denial-of-service in Eclipse Vert.x allows unauthenticated remote attackers to exhaust server memory by sending compressed WebSocket frames that decompress to massive sizes (a zip bomb), because the WebSocket implementation lacks a maximum byte-allocation limit during decompression. Affected versions include 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, and exploitation requires WebSocket compression (permessage-deflate) to be negotiated. No public exploit code has been identified at time of analysis, but a vendor advisory (GHSA-h722-h6c2-6j3c) is available; the impact is limited to availability loss.
Eclipse NetX Duo's NetX Secure DTLS server can be driven into completing handshakes with forged source addresses because the cookie it issues in a HelloVerifyRequest is never actually validated: the ClientHello parser copies the client-supplied cookie bytes over the value the server generated, and the server then treats the peer as verified based on the cookie's length alone, so a single arbitrary cookie byte in the first ClientHello skips the return-routability exchange entirely. The defect is remotely reachable with no authentication and no user interaction (CVSS 4.0 base 8.7, High; the independent assessment confirms AV:N/AC:L/PR:N/UI:N with an availability-only impact), and the practical harm is anti-spoofing and availability abuse - spoofed-source handshakes, amplification potential, and handshake state/resource exhaustion - not data compromise or code execution. No public exploit code has been identified at time of analysis, and CVE-2026-106465 is not listed in CISA KEV.
Out-of-bounds read in Eclipse NetX Duo's X.509 certificate parser (routine `_nx_secure_x509_parse_signature_data`) lets a peer that supplies a certificate with an empty ASN.1 BIT STRING signature corrupt the parser's internal signature length to 0xFFFFFFFF and drive a signature pointer one byte past the end of the buffer, producing a crash or destabilization of the device. Because certificates are parsed from the remote peer during the TLS handshake, the issue is network-reachable and unauthenticated - affected devices are those acting as a TLS client toward an attacker-influenced server, or as a TLS server that requests client certificates; the independent assessment rates it AV:N/AC:L/PR:N/UI:N with availability-only impact (A:H). Neither CISA KEV active exploitation nor public exploit code is associated with this CVE at time of analysis, and the principal limiting factor is reachability: only systems that negotiate TLS with untrusted peers are exposed.
Out-of-bounds write in the Eclipse NetX Duo TLS 1.3 client lets a malicious or compromised server corrupt memory past the caller-supplied TLS packet buffer by returning a HelloRetryRequest containing an oversized cookie; the copy happens before certificate authentication completes, so no valid certificate is required. It is remotely triggerable without authentication (CVSS:4.0 base 9.3; independently assessed as CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) and affects only devices acting as TLS 1.3 clients that initiate an outbound handshake to an attacker-controlled or MITM-positioned server. No public exploit code or CISA KEV entry was identified at time of analysis.
Heap out-of-bounds write in Eclipse ThreadX GUIX's binary theme resource loader (gx_binres_theme_load) lets a crafted binary resource (theme) file overwrite memory past the end of the loader's own arena with bytes taken verbatim from the file, producing high confidentiality, integrity, and availability impact on the affected process. The vector is local rather than network-reachable: an attacker must get the malformed theme file onto the device and the target application must actively load it (CVSS 4.0 AV:L/UI:A; assessed CVSS 3.1 AV:L/UI:R, PR:N, so no privileges are needed once the file is loaded), and deployments that only load theme resources compiled into firmware, or that never accept externally sourced theme files, are not exposed. GX_BINARY_RESOURCE_SUPPORT is enabled in the shipped default configuration, so no special build option is required for the flaw to be reachable; no public exploit code was identified at time of analysis, and no caller-side workaround is possible because the public API takes no buffer-size parameter.
Out-of-band XML External Entity (XXE) injection in Eclipse JAXB RI (jaxb-ri) lets an unauthenticated remote attacker read local files when an application unmarshals attacker-influenced XML through the affected JAXB factory helpers (XmlFactory in the core and xsom modules). The pre-patch code relied solely on XMLConstants.FEATURE_SECURE_PROCESSING, so on JAXP/SAX/DocumentBuilder implementations where that single feature does not disable DOCTYPE declarations, external general entities, external parameter entities, or external DTD loading, external entity resolution remains possible and file content can be exfiltrated out-of-band. Exploitation requires both conditions to hold - untrusted XML reaching JAXB unmarshalling, plus a parser stack where secure processing alone is insufficient - which is why the vector carries AC:H and the score is 8.3 (High) on both the supplied CVSS 4.0 vector and the independently assessed CVSS 3.1 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:L). No confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis.
Out-of-bounds write in the TLS 1.3 client of Eclipse ThreadX NetX Duo 6.5.1.202602 allows a malicious or compromised server to corrupt memory in the session control block by sending an oversized handshake message before certificate authentication completes, potentially achieving code execution or causing denial of service. The flaw is client-side and unauthenticated from the network perspective, requiring the victim device to initiate a TLS 1.3 handshake to an attacker-controlled server; no valid server certificate is needed and certificate pinning does not prevent exploitation. No public exploit code was identified at time of analysis, but the CVSS 9.3 base score and the pre-authentication nature make this a high-priority memory-corruption issue for affected embedded deployments.
Server-side request forgery in Eclipse Che 7.29.0 and later allows any authenticated low-privilege user to make the workspace server fetch attacker-chosen URLs through the GET /api/scm/resolve and POST /api/factory/resolver endpoints, which pass the URL to URLFetcher.fetch() without any scheme or host allow-list. Successful abuse yields high confidentiality loss: arbitrary local file reads inside the Che pod (notably the Kubernetes service-account token at file:///var/run/secrets/kubernetes.io/serviceaccount/token), access to internal HTTP services and cloud instance metadata at 169.254.169.254, and delivery of the victim's stored SCM personal access token as an Authorization header to a host of the attacker's choosing; integrity impact is more limited, largely the unauthorized use of forwarded credentials. No vendor-released patch was identified at time of analysis and no public exploit code was identified at time of analysis, though the affected code paths are reachable by any authenticated user. A second, interaction-dependent variant triggers the credential forwarding when a victim opens a workspace from a malicious devfile whose parent.uri points at an attacker-controlled server.
An out-of-bounds heap write in Eclipse ThreadX LevelX's NAND flash-translation-layer metadata parser can give a local attacker control-flow hijack when the device mounts a crafted NAND flash image through lx_nand_flash_open(), overwriting a driver function pointer with an attacker-chosen 8-byte value; two accompanying out-of-bounds reads were also demonstrated. The bug (CWE-787) is rated 8.6 under CVSS 4.0 and independently assessed as CVSS 3.1 AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, meaning no authentication or user interaction is needed but the attacker must first supply or tamper with the flash image (removable or attached NAND media, modified firmware or OTA image, or supply-chain/provisioning substitution). No public exploit code was identified at time of analysis, though the issue was reproduced verbatim under ASan at HEAD 9f1cfdc; devices that only mount internally trusted flash images are not realistically reachable, while those accepting field-swappable or externally sourced NAND are directly exposed, with the worst impact on bare-metal or non-memory-protected targets where the hijacked pointer yields code execution.
The SNMP agent addon in Eclipse ThreadX NetX Duo can be driven into an out-of-bounds read by a single unauthenticated remote SNMP packet whose object identifier uses BER multibyte length encoding to claim a length larger than the receive buffer, causing `_nx_snmp_utility_object_id_get` to decode adjacent heap bytes as OID components. On memory-protected (MMU/MPU) builds this faults into a crash of the SNMP agent thread, producing denial of service, while on bare-metal no-MMU targets the out-of-bounds read succeeds silently and instead corrupts the agent's internal OID state with neighboring heap data. Exposure is conditional: the NetX Duo SNMP addon must be compiled into the firmware and actively listening (typically UDP/161), so builds without an SNMP-enabled agent are unaffected; no public exploit code has been identified at time of analysis (no CISA KEV listing).
Unauthenticated remote clients can exhaust the packet pool of the Eclipse ThreadX NetX Duo RTSP server addon, causing a denial of service: roughly two dozen RTSP requests carrying a Session header value that the parser cannot convert (empty or non-numeric) leak one packet block each until the pool hits zero and the server can no longer serve any client. The leak occurs because the Session branch of _nx_rtsp_server_error_response_send's caller returns the raw NetX error code instead of mapping it to an RTSP status, and the error-response path then drops the already-allocated response packet on that unrecognized code. No public exploit identified at time of analysis, and no CISA KEV entry was provided; the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) confirms remote, unauthenticated, availability-only impact, with blast radius worst when the RTSP server shares its packet pool with the rest of the application, as in the shipped sample (22-block pool exhausted by ~26 requests).
Heap out-of-bounds write in the mDNS responder of Eclipse ThreadX NetX Duo allows an unauthenticated attacker on the same local network segment to corrupt packet memory by sending two ordinary mDNS PTR records in response to a _http._tcp service query. The flaw arises from a string-table bucket collision: owner names of 12-15 characters round to the same slot size, causing the responder to reuse a shorter stored entry and write 1-3 bytes past the transmit packet's data end. With the mDNS addon active and adjacency to the target, the realistic impact is denial of service through corrupted neighboring packets or pool free lists, though code execution is not demonstrated; no public exploit code or active exploitation has been identified at time of analysis.
Malformed ICMPv6 Neighbor Discovery option parsing in Eclipse NetX Duo can stall the IP thread or read past packet buffers, causing denial of service on devices reachable from the same local link. The affected product is NetX Duo with IPv6/ICMPv6 ND enabled; an adjacent-network attacker with no authentication or user interaction can send crafted Router Advertisement, Router/Neighbor Solicitation, Neighbor Advertisement, or Redirect messages so that a one- or two-byte residue bypasses option validation and later processing loops indefinitely or underflows its counters. The vendor's CVSS 4.0 score is 7.1 (availability-only), the referenced advisory is GHSA-39p4-p83c-58hr, no public exploit identified at time of analysis, and no CISA KEV confirmation is provided.
Memory disclosure and denial of service in the Eclipse NetX Duo TFTP server addon (nxd_tftp_server) are reachable by an unauthenticated remote attacker sending a single oversized DATA datagram over the network, because the DATA branch enforces only a four-byte minimum (nxd_tftp_server.c:1037) and never validates an upper bound against the protocol maximum of 4 + NX_TFTP_FILE_TRANSFER_MAX. The oversized length is passed as nx_packet_length - 4 into FileX via fx_file_write, and since nx_packet_length measures the whole packet chain rather than the first contiguous buffer, FileX reads past the end of that buffer and the leaked heap contents are written into the file the attacker is uploading, which a subsequent TFTP read request returns to the attacker; the same datagram also wedges the server permanently because nx_packet_copy with NX_WAIT_FOREVER suspends the server thread once the request exceeds the packet pool capacity. Rated CVSS 4.0 base 8.8 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:H), consistent with an independent assessment of CVSS 3.1 AV:N/AC:L/PR:N/UI:N/C:H/I:N/A:H, and no public exploit code was identified at time of analysis, though the attack path is trivially scriptable and requires only that the optional TFTP addon be compiled in and reachable.
Unauthenticated remote attackers can exploit an out-of-bounds read in Eclipse NetX Duo's DTLS ClientHello parser to disclose up to 255 bytes of adjacent process memory over the network, or to crash the device. The flaw triggers on the very first ClientHello and requires no prior session, credentials, or user interaction, affecting default DTLS-enabled deployments with a reachable DTLS/UDP listener. No public exploit code has been identified at time of analysis, but the issue is rated CVSS 8.8 and is considered a high-priority risk among the NetX Secure DTLS/TLS advisory cluster.
User-mode-to-kernel privilege escalation in Eclipse ThreadX lets a loaded, memory-protected TXM module register an arbitrary function pointer as the global trace-full callback, which privileged kernel code then invokes directly with no pointer validation and no privilege-dropping trampoline when the trace buffer wraps. Affected builds are those compiled with the non-default TX_ENABLE_EVENT_TRACE option and running modules in TXM_MODULE_USER_MODE with TXM_MODULE_MEMORY_PROTECTION; an invalid pointer crashes the kernel (denial of service), while a pointer into the module's own code has been observed executing with kernel privilege (CONTROL.nPRIV = 0), producing a scope-crossing compromise of the RTOS kernel by a local, low-privileged attacker. Exploitation requires the attacker to already control executing code inside a loaded module plus the non-default trace build flag, and no public exploit code has been identified at time of analysis.
Secure memory disclosure in Eclipse ThreadX occurs because multiple TrustZone-M non-secure callable (NSC) entry functions fail to validate caller-supplied pointers, allowing code already executing in the non-secure world to hand the secure firmware pointers into secure memory that are then dereferenced without an NS-region check. Only builds that enable Arm TrustZone-M secure/non-secure separation and expose NSC entry points taking raw pointer arguments are exposed; a single-world ThreadX build without TrustZone-M NSC surfaces is not affected. Exploitation requires a local, already-established non-secure foothold (AV:L, PR:L) with no user interaction and no network vector, making this an access-gated trust-boundary flaw rather than an internet-facing critical, and no public exploit code has been identified at time of analysis.
Malformed MQTT PUBLISH frames leak packet buffers in the Eclipse ThreadX NetX Duo MQTT client, letting a peer that can deliver a few dozen such messages exhaust the network driver's receive pool and halt all inbound traffic on the device until it is rebooted. Only builds including the NetX Duo MQTT client are exposed, and delivery requires broker control, a man-in-the-middle position on the MQTT session, or publish rights on a topic the client subscribes to, which is why the impact is availability-only (CVSS 4.0 base 8.2; assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) despite a network attack vector. No public exploit code and no confirmed active exploitation have been identified at time of analysis.
An out-of-bounds write in Eclipse NetX Duo's WebSocket client allows unauthenticated remote attackers to corrupt NX_PACKET control block structures via a maliciously crafted masked WebSocket frame, potentially leading to code execution or denial of service. The vulnerability, tracked as CVE-2026-102761 with a CVSS 4.0 score of 9.3, affects all versions of NetX Duo per the CPE. No public exploit code has been identified at time of analysis, and no KEV status is reported.
Memory corruption in the Eclipse ThreadX NetX Duo NetX Secure TLS stack can overrun the packet pool and crash a device, because each outbound TLS record is zeroed after the TCP layer has already taken ownership of - and may have freed and recycled - the underlying packet chain. The defect is a CWE-416 use-after-free write with a length underflow on reused packets, reachable from the network without authentication (CVSSv3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H, with the published CVSS 4.0 score of 8.3 reflecting the availability impact). It is not present in default builds: exploitation requires the non-default NX_SECURE_KEY_CLEAR compile-time option plus packet-pool free/reuse timing an attacker cannot deterministically force, so practical risk is lower than the headline score; no public exploit identified at time of analysis and no confirmed active exploitation.
Privilege escalation in Eclipse ThreadX allows an unprivileged, memory-protected ThreadX module to break out of its MPU isolation boundary and obtain privileged (kernel-mode) read and write access to arbitrary memory, including the ability to clear the MPU enable bit and remove its own protection. The attack is local and low-complexity and requires the attacker to already be able to execute code as a loaded, unprivileged module (PR:L), for example by supplying or subverting a loadable module in a deployment that uses the ThreadX Module feature with MPU-based memory protection; systems that do not use isolated modules are not affected. No public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV, but the high integrity and confidentiality impact on isolated-module deployments makes it significant.
Credentialed cross-origin reads and namespace takeover were possible against the hosted open-vsx.org registry because its CDN/edge layer reflected the requesting Origin back in Access-Control-Allow-Origin while simultaneously emitting Access-Control-Allow-Credentials: true on authenticated /user/ endpoints. A page on any origin could then issue credentialed requests in a logged-in user's browser and read the responses, exposing /user (login name, avatar, homepage, tokens URL), /user/tokens, /user/namespaces, /user/extensions, /user/search/{name}, /user/namespace/{name}/members and - critically - /user/csrf; with the CSRF token readable, the write-endpoint protection collapsed, and chaining /user/csrf with /user/token/create let the attacker page mint and exfiltrate a personal access token carrying publish and delete rights over the victim's namespaces. Attackers need no authentication of their own (CVSS 4.0 PR:N) and only passive victim interaction - the victim must be logged in to open-vsx.org and visit the attacker's page - while no public exploit code has been identified at time of analysis.
A local unprivileged user can hijack the Control Interface of another workload in Eclipse Ankaios 0.1.0 through 1.0.2 by pre-creating the agent's predictable run-folder path hierarchy and Control Interface FIFOs under the shared default location `$TMPDIR/ankaios`. Because the agent reuses an existing directory or FIFO based only on an existence/file-type check — without verifying ownership or permissions — it treats the attacker-owned pipes as the legitimate Control Interface and executes requests under that workload's configured `controlInterfaceAccess` permissions, enabling workload impersonation and unauthorized reading or modification of the cluster's desired state. The flaw is CWE-379 (insecure temporary file/permissions), carries a CVSS 4.0 base score of 8.4 (AV:L/PR:L/AT:P, high confidentiality and integrity impact), and has no public exploit code or CISA KEV listing at time of analysis; EPSS is 0.09%, consistent with a local, non-automatable attack. The vendor released v1.0.3 with an ownership/permission validation check (PR #799).
HTTP/2 thread-exhaustion denial-of-service in Eclipse Jetty allows unauthenticated remote clients to permanently block all server threads by exploiting a race condition in RST_STREAM and GOAWAY frame handling. The race incorrectly resets the `HTTP2Flusher.terminated` field from a non-null terminal state back to null, allowing new write-queue entries to be enqueued in a flusher that will never drain them; the write-blocked threads waiting on those entries hang indefinitely. Across five affected Jetty major branches (9.4, 10.0, 11.0, 12.0, 12.1), any internet-exposed HTTP/2 endpoint is reachable without authentication. No public exploit has been identified at time of analysis.
HTTP/1.1 request smuggling in Eclipse Jetty allows unauthenticated remote attackers to desynchronize request boundary parsing between Jetty and an upstream proxy, enabling manipulation of other users' HTTP sessions. The root cause is Jetty's acceptance of a bare LF character (\n) as a line terminator during chunked transfer encoding parsing - specifically in chunk extensions, chunk data termination, or trailer termination - where RFC 7230 mandates CRLF (\r\n). Depending on the Jetty version and configured HTTP compliance mode, a crafted request can cause the proxy and Jetty to disagree on where one request ends and the next begins, enabling request injection against co-located tenants. No public exploit has been identified at time of analysis.
Unauthenticated remote denial-of-service in Eclipse Jetty's WebSocket implementation allows any network-accessible client to exhaust the JVM heap by sending a single WebSocket frame with an unknown opcode and an arbitrarily large declared payload length. When auto-fragmentation is enabled, unknown opcodes bypass the normal maximum frame size check, causing Jetty to attempt heap allocation for the declared payload size before the opcode is ever validated - a logic-ordering flaw classified under CWE-770. The CVSS 4.0 score of 8.7 (AV:N/AC:L/PR:N/UI:N/VA:H) reflects high impact and low attack barrier; no public exploit has been identified at time of analysis.
Incorrect authorization in Eclipse Ankaios v0.5.1-v1.0.1 allows an authenticated workload to bypass its scoped access restrictions on the agent-side Control Interface. When the cluster is configured with multi-segment allow rules whose first path segment is a wildcard (e.g., `*.workloads.some_workload`), submitting a CompleteStateRequest or UpdateStateRequest with an empty field mask is incorrectly evaluated as matching the scoped rule, granting the workload full read or write access beyond its authorized state subtree. No public exploit is identified at time of analysis; a patched release (v1.0.2) is available.
TLS certificate validation is disabled by default in the Federator component of Eclipse aeriOS, enabling man-in-the-middle interception of all outbound HTTPS connections made by the component. Any attacker who can position themselves on the network path between the Federator and external services - including OAuth authorization servers - can impersonate those services and harvest OAuth client credentials and bearer tokens. This affects only the current pre-release development codebase; a source-level fix is confirmed in commit 9c63b60, but no official tagged release exists. No public exploit or CISA KEV listing has been identified at time of analysis.
Path traversal in Eclipse aeriOS Self-orchestrator prior to version 1.2.1 allows unauthenticated remote attackers to write or delete arbitrary JSON files on the host filesystem by embedding path separator sequences (e.g., '../') in resource identifiers submitted to the REST API. The vulnerability stems from direct string concatenation of user-supplied names into `fs.writeFileSync()` paths without sanitization, confirmed by the upstream commit diff. Real-world impact is amplified by the complete absence of API authentication (PR:N) and by the container running with elevated privileges in the affected deployment, extending the writable filesystem scope beyond the intended `./facts/` directory. No public exploit code has been identified at time of analysis.
Authorization bypass in Eclipse Arrowhead 5.0.0-5.2.1 allows any authenticated system - regardless of privilege level - to reach every protected management API endpoint by submitting percent-encoded paths that defeat the raw-URL substring check while still being routed by Spring MVC's decoded dispatcher. Exploiting the flaw is trivial: encoding a single character in '/mgmt/' (e.g. 'm' → '%6D') causes the filter to fall through without authorizing the request, yet Tomcat decodes and dispatches it normally. The highest-impact target is POST /authentication/mgmt/identities, which creates new sysop-level accounts, yielding full administrative takeover of the Arrowhead local cloud. No public exploit has been identified at time of analysis.
Authentication bypass in Eclipse Arrowhead 5.0.0 through 5.2.1 lets an unauthenticated attacker who can publish to the MQTT broker impersonate the cloud's system operator. When the MQTT API runs with the certificate authentication policy, CertificateMqttFilter reads an X.509 certificate straight from the MQTT message payload and trusts its Subject DN without ever verifying the signature or issuer chain, reducing authorization to two string comparisons on public, attacker-controlled values. By minting a self-signed certificate with CN=Sysop.<cloud>.<org>.arrowhead.eu and dnQualifier=op, the attacker gains isSysOp==true and full management access. No public exploit is identified at time of analysis, but the technique is described in full detail in the advisory.
Improper certificate validation in the KrakenD-based API Gateway of Eclipse aeriOS allows a network man-in-the-middle to compromise bearer-token validation. The bundled KrakenD configuration hard-codes disable_jwk_security to true with no Helm override, so KrakenD skips TLS certificate verification (and in the shipped config fetched the JWKS over plaintext HTTP) when retrieving the JSON Web Key Set used to validate JWTs. Only pre-release development builds are affected; there is no public exploit identified at time of analysis and the flaw is not in CISA KEV.
Template injection in Eclipse Ditto's ImplicitThingCreationMessageMapper (versions 1.3.0 through 3.9.6) allows authenticated connection publishers to override the administrator-configured access policy of a newly provisioned digital twin by embedding JSON-breaking characters in attacker-controlled inbound message headers. The mapper substitutes header placeholder values as raw, unescaped strings into a pre-configured JSON thing-template before parsing, enabling a crafted header value containing a double-quote to escape its string context and inject an inline _policy object - effectively granting the attacker full read/write access to the twin while permanently revoking the legitimate owner's access. Exploitation requires a non-default mapper configuration and a template that reflects attacker-controllable headers; no public exploit code or active exploitation (CISA KEV) has been identified.
Path traversal in Eclipse Theia 1.73.0-1.74.x AI Agent Mode allows arbitrary file writes outside the workspace with backend OS user privileges through model-supplied paths that bypass workspace-containment checks. The affected tools - writeFileContent, suggestFileContent, and associated replacement and state helpers - accept relative paths such as ../.bashrc, absolute paths, or tilde-expanded paths like ~/.ssh/authorized_keys without boundary validation. Because path arguments derive from LLM output, an indirect prompt injection attack embedded in developer-loaded content can steer writes to host-executed files and escalate to backend code execution; Agent Mode applies writes silently with no confirmation dialog. No public exploit code or CISA KEV listing exists at time of analysis, though the prompt-injection attack surface is realistic in cloud IDE deployments.
Authorization bypass in Eclipse Lyo 2.0.0 through 7.0.0 lets remote attackers abuse the 2-legged OAuth flow to promote a self-registered 'provisional' trusted client into a fully trusted one without the required administrator approval. Applications that build their authorization filters on Lyo's AbstractAdapterCredentialsFilter are affected, allowing an attacker to act as a trusted OAuth client and access protected OSLC resources. No public exploit identified at time of analysis, and it is not listed in CISA KEV; fixes shipped in 6.0.1.Final and 7.0.0.Beta3.
Remote code execution in Eclipse Theia 1.69.0 and earlier allows an attacker to execute arbitrary commands with the victim's user privileges by embedding a malicious git repository configuration inside a cloned repository. Any Theia-based IDE or application including the @theia/git extension or the bundled VS Code git extension is affected, because both automatically invoke git commands such as git status upon folder open without first presenting a workspace trust prompt. This vendor-confirmed issue is fixed in version 1.70.0 via workspace trust enforcement; no public exploit code has been identified at time of analysis and it does not appear in the CISA KEV catalog.
XXE injection in Eclipse RDF4J exposes applications to local file disclosure and server-side request forgery when parsing untrusted XML-based RDF data or SPARQL query results. The root cause is an incomplete remediation of CVE-2018-1000644: while that earlier fix hardened some parser entry points, several XML parser interfaces remained unprotected against DOCTYPE declarations, external entity references, and external DTD loading. No public exploit has been identified at time of analysis, and no CISA KEV listing exists, but the unauthenticated network vector (CVSS 4.0: 8.7, PR:N) means any application exposing RDF ingestion endpoints is at risk without upgrading to RDF4J 5.3.2.
Server-Side Request Forgery combined with CSRF in Eclipse GlassFish's DownloadServlet ContentSources handler allows a remote attacker to exfiltrate the administrative `gfresttoken` to an attacker-controlled host when an authenticated administrator visits a malicious page. Affecting Eclipse GlassFish 8.0.x prior to 8.0.4, successful token theft yields full control of the GlassFish administrative domain until the token expires, effectively an unauthenticated takeover of the management plane. No public exploit identified at time of analysis, and the issue is not in CISA KEV, but the CVSS 9.6 rating and low attack complexity make it high priority.
Remote file inclusion and path traversal in Eclipse Mojarra 2.3 through 5.0 allows unauthenticated network attackers to force server-side Facelet resolution of attacker-controlled URLs via the `DefaultFaceletFactory` component, exposing restricted files with the privileges of the application server. The attack targets the JSF template resolution pipeline and can leak sensitive configuration data from `WEB-INF/web.xml` (which typically contains database credentials and security settings) or OS-level files such as `/etc/passwd`. SSVC rates the attack as automatable with no confirmed active exploitation at time of analysis, but the CVSS:3.1 AV:N/AC:L/PR:N/UI:N vector means no barriers exist between a remote attacker and a vulnerable endpoint.
Unauthenticated arbitrary file read in Eclipse Theia browser-mode deployments (versions ≤1.73.1) allows any network client to exfiltrate files accessible to the backend process, including paths outside the opened workspace such as SSH keys, cloud credential tokens, and system configuration files. The vulnerability combines two compounding flaws: the `@theia/filesystem` HTTP endpoints perform no workspace confinement when resolving client-supplied URIs to filesystem paths, and a middleware defect in `@theia/core` re-issues the session cookie and calls `next()` without validating the connection token on HTTP requests - token enforcement applies only to WebSocket upgrades, leaving all HTTP file endpoints fully exposed. Electron deployments are explicitly not affected via this path. No public exploit is identified at time of analysis.
Silent authorization bypass in Eclipse Milo OPC UA server SDK versions 1.0.0-1.1.4 allows anonymous network clients to invoke protected methods, read role-permission metadata, and delete protected nodes. The defect is a missing field copy in `OpcUaServerConfig.copy()`: when servers construct their running configuration via this method, the configured `RoleMapper` is silently dropped, causing the `DefaultAccessController` to receive empty role ID lists for every session and skip all role-permission enforcement. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV.
Unauthenticated remote denial-of-service in Eclipse Milo 0.6.0-1.1.4 allows any network-accessible client to exhaust the OPC UA server's off-heap direct memory pool by repeatedly sending incomplete UASC message chunks and disconnecting before message assembly completes. The UASC server-side asymmetric handler and ChunkDecoder fail to invoke ReferenceCountUtil.safeRelease() on retained Netty ByteBuf objects when the channel lifecycle ends, causing unbounded off-heap memory accumulation. No authentication is required and no special server configuration is necessary; the fix commit is publicly available on GitHub, serving as an effective blueprint for exploitation, though no standalone POC tool or CISA KEV listing has been identified at time of analysis.
Authorization bypass in Eclipse Milo's OPC UA Call service (versions 1.0.0-1.1.4) permits unauthenticated or low-privileged OPC UA clients to invoke server-side methods they are explicitly denied access to. The server correctly computes per-method authorization for a mixed batch CallRequest but then dispatches the original unfiltered batch - including denied methods - to address-space handlers, rendering the authorization check effectively inert. No active exploitation is confirmed and no public exploit code has been identified, but the attack requires only standard OPC UA client tooling and zero authentication, making exploitation trivially accessible to any network-reachable client.
Password recovery in Eclipse Milo (the open-source OPC UA SDK for Java) versions 0.6.0 through 1.1.4 allows an on-path attacker to break username-token confidentiality via a Bleichenbacher-style padding oracle. The server returns distinguishable error responses for invalid RSA PKCS#1 v1.5 padding versus other authentication failures during username-token processing, so an attacker who captures a victim's Basic128Rsa15-encrypted username token can send repeated unauthenticated ActivateSession requests to recover the cleartext password and then authenticate as the victim. No public exploit identified at time of analysis and it is not listed in CISA KEV; the weakness and its upstream fix are confirmed by the Eclipse Foundation.
Server-side request forgery in the Eclipse CSI PIA `POST /v1/upload/sbom` endpoint lets remote attackers coerce the server into connecting to an arbitrary host, port, and scheme of their choosing. By exploiting a parser-differential between Python's `urlparse` (used for the issuer allowlist check) and `requests`/`urllib3`/`urllib` (used for OIDC discovery and JWKS retrieval), an attacker crafts a JWT `iss` claim containing a backslash that passes validation but resolves to a different host during the actual fetch. The `iss` claim is only checked in its unverified form, so no legitimate token is needed; no public exploit has been identified at time of analysis and the issue is not listed in CISA KEV.
Authorization bypass in Eclipse BaSyx Go Components through 1.0.0 lets unauthenticated network attackers reach ABAC-protected API handlers by appending a trailing slash to a route (e.g. GET /shells/ instead of GET /shells). The ABAC middleware evaluates the slashed path, finds no matching policy route, and passes the request onward, after which Chi's middleware.StripSlashes normalizes the path and executes the protected handler with no ABAC decision and none of the expected ABAC query filters. Publicly available upstream fix exists (PR #442, v1.0.1) and SSVC rates technical impact as total, though EPSS is low (0.35%) and no active exploitation is confirmed.
Cross-origin credential leakage in Eclipse Vert.x vertx-core (4.x through 4.5.29 and 5.x through 5.1.4) occurs because DefaultRedirectHandler copies all original request headers verbatim when the HttpClient follows an HTTP 30x redirect, stripping only Content-Length and never comparing the origin (scheme/host/port). An application that lets untrusted input influence a request URL - webhook dispatchers, image proxies, SSRF-style URL fetchers - can be steered to an attacker-controlled redirect target that then receives Authorization, Cookie, Proxy-Authorization, and custom headers like X-API-Token. No public exploit has been identified at time of analysis, and the flaw is not in CISA KEV.
Cross-domain cookie injection in Eclipse Vert.x Web Client (WebClientSession) lets any server a victim application contacts set a cookie scoped to an unrelated third-party domain, which the client later replays to that domain. Versions up to 4.5.29 (4.x) and 5.1.4 (5.x) fail to enforce the RFC 6265 Domain-attribute ownership check, so an attacker can bind their own session cookie into the victim's WebClientSession and have the victim's later requests to a target service execute under the attacker's account, exposing sensitive request payloads. No public exploit identified at time of analysis and it is not listed in CISA KEV; scored CVSS 4.0 8.2 (High) by Eclipse.
Log integrity spoofing in Eclipse Kura before 5.6.2 lets an unauthenticated remote attacker forge the client IP recorded in audit logs by supplying a crafted X-Forwarded-For header, because the Jetty ForwardedRequestCustomizer is installed unconditionally on every connector and getRemoteAddr() reflects the header value. This enables bypass of IP-based brute-force defenses like fail2ban (spoofing a non-routable source to evade bans) or a denial of service against a third party by injecting a victim IP so their address is banned. No public exploit is identified at time of analysis and it is not on CISA KEV; CVSS 4.0 base score is 8.8.
Unauthenticated arbitrary file write in Eclipse BaSyx Java Server SDK (2.0.0-milestone-05 through 2.0.0-milestone-12) lets remote attackers plant files anywhere the Java process can write when the server is deployed with the MongoDB file backend, potentially escalating to remote code execution. The AAS thumbnail API trusts a client-supplied fileName that is later reused as a filesystem path, so a traversal or absolute-path filename lands attacker-controlled bytes outside the intended directory. There is no public exploit identified at time of analysis and the issue is not in CISA KEV, but the vendor-fixed release (2.0.0-milestone-13) is available.
Server-side request forgery in Eclipse Theia (version 1.26.0 and later) lets a low-privileged user connected to the /services messaging endpoint coerce the backend into fetching an attacker-supplied URL and returning the full response body, exposing localhost admin interfaces and cloud instance metadata that sit behind the browser network boundary. The flaw is exploitable by any client with access to the Theia service connection, making multi-tenant and publicly-reachable deployments the primary concern. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV.
Cross-site WebSocket hijacking in Eclipse Theia's browser backend (versions 1.8.1 and later) lets a foreign-origin web page reach the unauthenticated /services shell-terminal RPC namespace and execute arbitrary OS commands on the victim's host. The flaw stems from fail-open Origin validation in @theia/core combined with a client-controllable fix-origin header, so simply luring a developer running Theia to a malicious site yields remote code execution. There is no public exploit identified at time of analysis, and CVSS is rated 8.8 (High) driven by the user-interaction-only barrier.
Server-side request forgery and OIDC token forgery in Eclipse CSI PIA lets an unauthenticated attacker abuse a flawed Jenkins issuer allowlist (a bare `startswith('https://ci.eclipse.org')` check in `is_issuer_known`, pia/models.py:139) to redirect OIDC discovery and JWKS fetches to an attacker-controlled host. By posting a crafted issuer such as `https://ci.eclipse.org@evil.host` or `https://ci.eclipse.org.evil.host` to `POST /v1/upload/sbom`, an attacker forces PIA to make outbound requests to arbitrary hosts and to accept a JWT signed with the attacker's own key, effectively bypassing token verification. No public exploit identified at time of analysis, but the flaw is unauthenticated and network-reachable, and the CVSS 3.1 base score is 8.2.
Denial of service in Eclipse Parsson before 1.1.8 lets remote unauthenticated attackers exhaust CPU and memory on any application that parses attacker-controlled JSON. Because the parser enforced no default cap on characters consumed per document, a single oversized payload - large arrays, strings, numbers, deep nesting, or whitespace - can hang or crash the service. No public exploit is identified at time of analysis; the fix (1.1.8) adds a configurable default limit of 15 million parser-consumed characters.
Stored cross-site scripting in Eclipse Open VSX Registry (versions 0.1.0 through before 1.0.2) allows an attacker who self-registers a publisher account to upload a VSIX containing malicious HTML that the /vscode/unpkg/ endpoint serves inline as text/html within the open-vsx.org origin, with no Content-Security-Policy or Content-Disposition: attachment header. When a logged-in victim is lured to the resulting URL, the script runs in the registry's origin and can steal session tokens, mint Personal Access Tokens, and publish trojanized extension versions - turning a single XSS into a supply-chain compromise of VS Code, VSCodium, Cursor, and Windsurf users. No public exploit is identified at time of analysis and EPSS risk is low (0.17%), but the downstream blast radius is severe.
Denial of service in Eclipse ThreadX NetX Duo HTTP server arises from a flawed remediation of CVE-2025-0728, where the refactored shared cleanup label invokes fx_file_close() on an uninitialized file handle whenever an error occurs before file open. Remote attackers can reach the vulnerable PUT path over the network without authentication, triggering undefined behavior, double-close conditions, or memory corruption that can crash the embedded HTTP service. No public exploit identified at time of analysis, and the issue is not listed in CISA KEV.
Arbitrary command execution in Eclipse Theia versions prior to 1.69.0 allows a malicious repository to run host commands with the user's privileges when its workspace is opened, because custom task definitions in .theia/tasks.json or .vscode/tasks.json bypass the workspace trust gate. When the victim has also enabled AI chat with tool confirmation disabled via a workspace .theia/settings.json, the chain triggers automatically on the first chat message. No public exploit identified at time of analysis, but the attack pattern mirrors well-known VS Code workspace-trust bypass classes.
Indirect prompt injection in Eclipse Theia before 1.71.0 allows a malicious repository to automatically override the AI agent's system prompts when a victim opens the workspace, by placing files under .prompts/*.prompttemplate that Theia auto-loads. Combined with built-in AI chat features, the hijacked prompt can chain to data exfiltration via Markdown image rendering or arbitrary command execution via task definitions. No public exploit identified at time of analysis and the vulnerability is not listed in CISA KEV.
Indirect prompt injection in Eclipse Theia versions prior to 1.71.0 allows attackers who control a workspace's filesystem layout to coerce the built-in AI chat agent into executing attacker-supplied instructions, enabling data exfiltration through Markdown image rendering or arbitrary command execution through task definitions. No public exploit identified at time of analysis, but the CVSS 4.0 base score of 8.4 reflects high impact across confidentiality, integrity and availability once a developer opens an untrusted repository. The flaw is reported by the Eclipse Foundation and fixed in version 1.71.0.
Remote code execution in Eclipse GlassFish allows attackers with administrative access to the Administration Console to execute arbitrary operating system commands as the application service user. The flaw stems from improper input handling in admin panel requests (CWE-94), and while CVSS rates it 9.1 due to scope change and full CIA impact, exploitation requires high privileges (PR:H). No public exploit identified at time of analysis and the issue is not listed in CISA KEV.