Search: java.exe
675 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Medium | 4.0 | EPSS <0.1% | CVE-2026-91380Oracle Java SE · Improper Access Control Medium4.0EPSS <0.1%CVE Database V5CVE-2026-91380 Vulnerability in the Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition product of Oracle Java SE (component: Utility). Supported versions that are affected are Oracle Java SE: 8u503, 8u503-perf, 11.0.32.1, 17.0.20.1, 21.0.12.1, 25.0.4.1, 27; Oracle GraalVM for JDK: 17.0.20.1 and 21.0.12.1; Oracle GraalVM Enterprise Edition: 21.3.19.1.1. Difficult to exploit vulnerability allows unauthenticated attacker with logon to the infrastructure where Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition executes to compromise Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition. Successful attacks of this vulnerability can result in unauthorized update, insert or delete access to some of Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition accessible data as well as unauthorized read access to a subset of Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition accessible data. Note: This vulnerability can be exploited by using APIs in the specified Component, e.g., through a web service which supplies data to the APIs. This vulnerability also applies to Java deployments, typically in clients running sandboxed Java Web Start applications or sandboxed Java applets, that load and run untrusted code (e.g., code that comes from the internet) and rely on the Java sandbox for security. CVSS 3.1 Base Score 4.0 (Confidentiality and Integrity impacts). CVSS Vector: (CVSS:3.1/AV:L/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N). | CVE Database V5 | ||
| Medium | 4.7 | EPSS 0.1% | CVE-2026-91379Oracle Java SE · Use After Free Medium4.7EPSS 0.1%CVE Database V5CVE-2026-91379 Vulnerability in the Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition product of Oracle Java SE (component: JDK tools). Supported versions that are affected are Oracle Java SE: 8u503-perf, 11.0.32.1, 17.0.20.1, 21.0.12.1, 25.0.4.1, 27; Oracle GraalVM for JDK: 17.0.20.1 and 21.0.12.1; Oracle GraalVM Enterprise Edition: 21.3.19.1.1. Difficult to exploit vulnerability allows unauthenticated attacker with logon to the infrastructure where Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition executes to compromise Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition. Successful attacks require human interaction from a person other than the attacker. Successful attacks of this vulnerability can result in unauthorized creation, deletion or modification access to critical data or all Oracle Java SE, Oracle GraalVM for JDK, Oracle GraalVM Enterprise Edition accessible data. Note: This vulnerability applies to Java deployments, typically in clients running sandboxed Java Web Start applications or sandboxed Java applets, that load and run untrusted code (e.g., code that comes from the internet) and rely on the Java sandbox for security. This vulnerability does not apply to Java deployments, typically in servers, that load and run only trusted code (e.g., code installed by an administrator). CVSS 3.1 Base Score 4.7 (Integrity impacts). CVSS Vector: (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:N). | CVE Database V5 | ||
| Medium | 4.7 | EPSS <0.1% | CVE-2026-91375Oracle Java SE · Incorrect Authorization Medium4.7EPSS <0.1%CVE Database V5CVE-2026-91375 Vulnerability in Oracle Java SE (component: Libraries). Supported versions that are affected are Oracle Java SE: 8u503-perf, 11.0.32.1, 17.0.20.1, 21.0.12.1, 25.0.4.1, 27; Oracle GraalVM for JDK: 17.0.20.1 and 21.0.12.1; Oracle GraalVM Enterprise Edition: 21.3.19.1.1. Difficult to exploit vulnerability allows unauthenticated attacker with logon to the infrastructure where Oracle Java SE executes to compromise Oracle Java SE. Successful attacks require human interaction from a person other than the attacker. Successful attacks of this vulnerability can result in unauthorized creation, deletion or modification access to critical data or all Oracle Java SE accessible data. Note: This vulnerability can be exploited by using APIs in the specified Component, e.g., through a web service which supplies data to the APIs. This vulnerability also applies to Java deployments, typically in clients running sandboxed Java Web Start applications or sandboxed Java applets, that load and run untrusted code (e.g., code that comes from the internet) and rely on the Java sandbox for security. CVSS 3.1 Base Score 4.7 (Integrity impacts). CVSS Vector: (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:N). | CVE Database V5 | ||
| Medium | 5.6 | EPSS 0.4% | CVE-2026-113730orphan-oss ognl · Protection Mechanism Failure Medium5.6EPSS 0.4%CVE Database V5CVE-2026-113730 ### Summary OGNL's optional *stricter invocation* mode maintains a block list that prevents expressions from directly calling methods on dangerous classes such as `Runtime`, `ProcessBuilder`, and `ClassLoader`. The block list filters on the **declaring class of the method OGNL invokes**. Because `java.lang.reflect.Method` (and `Constructor`/`Field`) are not on the list, an expression can use reflection as a proxy — `someMethod.invoke(target, args)` — to reach a blocked method. The real call (e.g. `ProcessBuilder.start()`) then executes inside the JDK reflection machinery and never passes back through OGNL's `invokeMethod`, so the block list never sees it. ### Proof of concept Under the default OGNL context (public-only access, stricter invocation enabled), the following expression creates a file even though a direct `new ProcessBuilder(...).start()` is blocked: ``` (#pb=new java.lang.ProcessBuilder({"/usr/bin/touch","rce-proof.txt"}), #methods=@java.lang.ProcessBuilder@class.getMethods(), #names=#methods.{ #this.getName() }, #startIdx=#names.indexOf("start"), #methods[#startIdx].invoke(#pb, null)) ``` ### Impact and scope — please read carefully **This is hardening of a defense-in-depth secondary layer, not a break of OGNL's primary security boundary.** In OGNL the stricter-invocation block list is a *secondary* mitigation. The **primary** access-control gate is the `MemberAccess` implementation supplied by the integrating framework or application, which OGNL consults on every constructor and method call. Frameworks that evaluate untrusted expressions are expected to install a restrictive `MemberAccess` — for example, Apache Struts' `SecurityMemberAccess`, which excludes dangerous classes and the `java.lang.reflect` package. Against such a `MemberAccess` this PoC is blocked at the very first step (the `new ProcessBuilder(...)` constructor), before reflection is ever reachable. The default context that ships with OGNL intentionally allows all public members and is **not** designed to sandbox untrusted input. An application that evaluates attacker-controlled expressions with that permissive default already has many paths to code execution, and this technique is not required to achieve it. **You are affected only if all of the following hold:** (1) your application evaluates untrusted/attacker-controlled OGNL expressions, (2) it uses OGNL's default permissive `MemberAccess` (or an equivalently permissive one that allows `java.lang.reflect`), and (3) it relies on the stricter-invocation block list as its sandbox. **Properly configured consumers — including Apache Struts with its `SecurityMemberAccess` — are not affected.** The actual protection for untrusted-expression scenarios remains a correctly configured `MemberAccess`; the block list should not be treated as a sandbox. ### Fix `java.lang.reflect.Method`, `java.lang.reflect.Constructor`, and `java.lang.reflect.Field` are added to the stricter-invocation block list, so reflection objects can no longer be used as invocation proxies in stricter mode. The `java.lang.invoke.MethodHandle` path was verified not to be exploitable (its signature-polymorphic `invoke`/`invokeExact` fail through OGNL's reflection-based invocation), so no additional classes are required. ### Credit Reported responsibly through Tidelift by 毛锐 (youyi.mr@alibaba-inc.com). | CVE Database V5 | ||
| High | 8.6 | EPSS 0.7% | CVE-2026-113605Stirling-PDF · Incomplete List of Disallowed Inputs High8.6EPSS 0.7%CVE Database V5CVE-2026-113605 CVE-2026-113605 affects Stirling-PDF versions 2.13.2 through 3.2.0 and involves an incomplete denylist in the DatabaseService.validateSqlContent() function. This flaw allows authenticated administrators to bypass H2 database import restrictions by using the CREATE OR REPLACE ALIAS command. By uploading a crafted SQL backup to the import-database endpoint, attackers can define Java function aliases via RUNSCRIPT, enabling execution of arbitrary Java methods. | CVE Database V5 | ||
| High | – | EPSS 0.7% | CVE-2026-14265CVE-2026-14265- Deserialization of Untrusted Data in AWS Advanced JDBC Wrapper RemoteQueryCachePlugin HighEPSS 0.7%AWS Security BulletinsCVE-2026-14265 Bulletin ID: 2026-051-AWS Scope: AWS Content Type: Important (requires attention) Publication Date: 07/01/2026 12:45 PM PDT Description: The AWS Advanced JDBC Wrapper is an open-source JDBC driver wrapper that extends a JDBC driver to enable Amazon Aurora and AWS Cloud features such as failover handling and caching. We identified CVE-2026-14265, an issue in the RemoteQueryCachePlugin of the AWS Advanced JDBC Wrapper. When this plugin is enabled, query results read from the shared Redis/Valkey cache are deserialized without class filtering. An actor with write access to the shared cache infrastructure could insert a crafted serialized Java object that, when read by an application, results in execution of arbitrary code on the application server. Impacted versions: >=3.3.0 AND <=4.0.0 Please refer to the article below for the most up-to-date and complete information related to this AWS Security Bulletin. | AWS Security Bulletins | ||
| High | 7.5 | EPSS 0.4% | CVE-2026-12148IBM MQ Operator · Deserialization of Untrusted Data High7.5EPSS 0.4%CVE Database V5CVE-2026-12148 CVE-2026-12148 is a high-severity vulnerability in IBM MQ Operator caused by unrestricted Java deserialization in the MQ Classes for Java. This flaw allows an authenticated attacker to cause denial of service or potentially execute arbitrary code. The vulnerability affects multiple versions of IBM MQ Operator prior to version 3.4.0, which contains the fix. The CVSS 3.1 base score is 7.5, indicating significant impact on confidentiality, integrity, and availability. | CVE Database V5 | ||
| Critical | 9.3 | EPSS 0.6% | CVE-2026-109432Camunda 7 · Improper Neutralization of Special Elements used in an Expression Language Statement ('Expression Critical9.3EPSS 0.6%CVE Database V5CVE-2026-109432 Camunda 7.24.0 before 7.24.14 and 7.23.0 before 7.23.17 contains an expression injection vulnerability where AdhocQueryValidator.validate() fails to check sub-query expression maps within the orQueries field exposed by TaskQueryDto, allowing authenticated users to bypass the enableExpressionsInAdhocQueries restriction. Attackers can supply a malicious JUEL expression such as dueAfterExpression inside an orQueries entry to achieve arbitrary Java reflection and invoke java.lang.Runtime.exec, resulting in operating-system command execution as the engine service user. EPSS 0.6%Vulnerability | CVE Database V5 | ||
| Medium | 5.9 | EPSS 0.4% | CVE-2026-85248Apache Camel · Race Condition Medium5.9EPSS 0.4%CVE Database V5CVE-2026-85248 Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition') vulnerability in Apache Camel PQC component. This issue affects Apache Camel: from 4.12.0 before 4.18.5, from 4.19.0 before 4.22.1. The producer held a single java.security.Signature instance and used it for every exchange without synchronizing access. Signature is stateful and is not thread safe: update() accumulates the data to be signed or verified, and verify() consumes that accumulated state. With concurrent exchanges sharing one instance the update and verify calls of different messages interleave, so a verification can complete against data that belongs to another exchange, or against a partially accumulated buffer. The outcome is non-deterministic and includes a verification reporting success for a message whose signature was never actually checked, which defeats the guarantee the component exists to provide. Reaching it requires concurrent traffic through the same endpoint, which is the ordinary condition for a Camel route under load. Upgrade to Apache Camel 4.23.0, which fixes the issue. Users on the 4.18.x LTS releases stream should upgrade to 4.18.5. Users on the 4.22.x LTS releases stream should upgrade to 4.22.1. The Signature instance is no longer shared across concurrent exchanges. For deployments that cannot upgrade immediately, restrict the affected route to a single concurrent consumer so that no two exchanges use the instance at once. | CVE Database V5 | ||
| High | 8.8 | EPSS 0.7% | CVE-2026-78165Apache Camel · Deserialization of Untrusted Data High8.8EPSS 0.7%CVE Database V5CVE-2026-78165 CVE-2026-78165 is a deserialization of untrusted data vulnerability in the Apache Camel Spring Redis component affecting versions from 2.11.0 before 4.18.5 and from 4.19.0 before 4.22.1. The vulnerability arises because the component uses a default Java serialization mechanism without applying any object input filtering, allowing arbitrary serialized objects to be deserialized and their readObject methods executed. This occurs before any route logic can inspect the message, exposing the system to potential remote code execution if an attacker can publish messages to subscribed Redis channels. The issue is fixed in Apache Camel versions 4.18.5, 4.22.1, and later 4.23.0. Mitigations include upgrading to fixed versions, setting JVM-wide serialization filters, configuring non-Java serializers, and restricting Redis access. | CVE Database V5 | ||
| Critical | 10.0 | EPSS 1.1% | CVE-2026-78162Apache Camel · Deserialization of Untrusted Data Critical10.0EPSS 1.1%CVE Database V5CVE-2026-78162 CVE-2026-78162 is a critical deserialization of untrusted data vulnerability in Apache Camel affecting versions from 4.0.0 before 4.18.5 and from 4.19.0 before 4.22.1. The issue arises from incomplete application of JavaSerializationFilterConfig in certain Hazelcast component configurations, allowing unrestricted Java deserialization. An attacker able to publish data to the connected Hazelcast cluster can cause arbitrary Java objects to be deserialized, potentially leading to remote code execution. The vulnerability is fixed in Apache Camel versions 4.18.5 and 4.22.1. | CVE Database V5 | ||
| Critical | 9.8 | EPSS 0.4% | CVE-2026-64610Apache Kylin · Deserialization of Untrusted Data Critical9.8EPSS 0.4%CVE Database V5CVE-2026-64610 Apache Kylin versions 4.0.0 through 5.0.4 contain a critical deserialization of untrusted data vulnerability (CWE-502) that arises from unsafe Java deserialization via a broken external cache service. This vulnerability allows remote attackers to execute arbitrary code without authentication. The issue is fixed in Apache Kylin version 5.0.5. | CVE Database V5 | ||
| –Not rated | – | AlienVault OTX General Suo5 is an HTTP/HTTPS-based tunneling tool exploited for pivoting attacks via compromised web servers to access internal networks. It supports multiple environments including Java, PHP, IIS/.NET, and Nginx, and relays TCP traffic enabling SOCKS5 proxy access. Deployment methods include file upload exploitation on IIS servers using renamed ASPX files and memory injection via Jenkins Script Console with Groovy scripts. Indicators of compromise include repeated POST requests in web logs, DLL files in Temporary ASP.NET Files directories, and PluginServletFilter chains in Java logs. Detection involves monitoring web request patterns, server-side behaviors, abnormal User-Agent headers, unauthorized URI access, and file modifications. Mitigations include restricting script execution capabilities and implementing network segmentation controls. | AlienVault OTX General | |||
| Medium | 5.8 | EPSS 0.1% | Medium5.8EPSS 0.1%CVE Database V5CVE-2026-102740 The AsyncHttpClient library allows Java applications to execute HTTP requests and asynchronously process HTTP responses. From 2.0.0 until 2.16.1 and 3.0.12, PropertiesBasedResumableProcessor stores resumable download state at the predictable shared path $java.io.tmpdir/ahc/ResumableAsyncHandler.properties with default permissions and link-following file operations. A local user who can read the shared store can see download URLs, including embedded user information or query tokens. A local user who can write within or pre-create the affected shared store directory can plant a symbolic link that the client follows when saving state, truncating and overwriting a target file writable by the client process. The filesystem path is used when ResumableAsyncHandler decorates another AsyncHandler, while the no-argument constructors use a no-op processor and are unaffected. This issue is fixed in versions 2.16.1 and 3.0.12. | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.6% | CVE-2026-97666Sonatype Nexus Repository 3 · Unsafe Reflection Medium6.9EPSS 0.6%CVE Database V5CVE-2026-97666 Sonatype Nexus Repository 3 contains a vulnerability where an unauthenticated remote attacker can supply attacker-controlled input to a Java class loading call via an ExtDirect endpoint. This allows the attacker to determine the presence of specific classes in the application but does not enable code execution by itself. The issue affects versions from 3.0.0 up to but not including 3.97.0. The vulnerability has a medium severity rating with a CVSS 4.0 score of 6.9. | CVE Database V5 | ||
| Critical | 9.2 | EPSS 0.5% | CVE-2026-102469Eclipse Vert.x · Deserialization of Untrusted Data Critical9.2EPSS 0.5%CVE Database V5CVE-2026-102469 CVE-2026-102469 is a critical vulnerability in Eclipse Vert.x's DB2 client component (vertx-db2-client) affecting versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and version 5.2.0. The vulnerability arises from unsafe deserialization of User Defined Type (UDT) column data using Java's ObjectInputStream.readObject() without any filtering or class allowlisting. This unsafe deserialization can be triggered by a malicious or man-in-the-middle DRDA server sending a crafted response with a 0x50-tagged column, which legitimate DB2 servers do not send. Exploitation can lead to remote code execution if a suitable Java deserialization gadget chain is present, or denial of service otherwise. TLS is disabled by default, increasing the risk of man-in-the-middle attacks. | CVE Database V5 | ||
| High | 8.8 | EPSS 0.2% | High8.8EPSS 0.2%CVE Database V5CVE-2026-104795 The insights-runtime-extractor runs as a privileged DaemonSet (`hostPID: true`) that scans container processes for runtime fingerprinting. When scanning a container, the coordinator: 1. **fork()s** a child process 2. **setns()** into the target container's PID and mount namespaces 3. **fchdir()** back to an orphaned FD pointing at the extractor's own root filesystem (where `/crio.sock` is hostPath-mounted) 4. Calls **only `seteuid(target_uid)`** — changing the effective UID but leaving the **real UID and saved-set-UID at 0** and **retaining the permitted capability set** 5. The `check_no_privileged_perms()` guard inspects only the Effective capability set (so it passes), and is **skipped entirely when the target runs as uid 0** 6. The `VersionExecutable` fingerprint invokes `fpr_kind_executable` with `process.command_line[0]` — the target's argv[0], read from `/proc/<pid>/cmdline` and **fully controlled by the workload** 7. `fpr_kind_executable` calls `exec.Command(executable, "--version").Output()` — executing the **workload's own binary** inside the workload's mount namespace while **ruid=0 in the host user namespace** The executed process can call `setuid(0)` to restore full root with `CAP_SYS_ADMIN`, and inherits the orphaned cwd which resolves into the extractor container's filesystem containing the host CRI-O socket. ## Affected Code ### 1. Insufficient privilege drop (Rust — extractor coordinator) **File:** `extractor/src/insights_runtime_extractor.rs` ```rust // Lines 139-146 — seteuid-only drop, guard skipped for root containers join_process_namespaces(process.pid)?; change_dir(current_dir); switch_user(*process.uid)?; if *process.uid != 0 { perms::check_no_privileged_perms() .expect("Must not have privileged permissions to run fingerprints"); } fingerprint::run_fingerprints(&config, out_dir, &process); ``` ```rust // Lines 182-185 — only effective UID changed; ruid/suid stay 0 fn switch_user(uid: u32) -> Result<(), ScannerError> { debug!("... Becoming user: {uid}"); seteuid(uid.into()).map_err(|e| ScannerError::Errno(e)) } ``` ### 2. Execution of untrusted binary (Go — fingerprint) **File:** `fingerprints/pkg/utils/file.go` ```go // Lines 75-80 — executes a path taken verbatim from workload's argv[0] func GetExecutableVersionOutput(executable string) (string, error) { out, err := exec.Command(executable, "--version").Output() if err != nil { return "", err } return string(out), nil } ``` ### 3. Workload-controlled path forwarded (Rust — version_executable) **File:** `version_executable.rs` ```rust // Lines 29-34 — workload-controlled command_line[0] forwarded to fingerprint return Some(vec![ fpr_kind_executable, out_dir.to_string(), String::from(&process.command_line[0]), String::from(&version_executable.runtime_kind_name), ]); ``` ## Attack Pattern **Attacker:** Any tenant able to schedule a pod (unprivileged, any namespace) **Victim:** The node running the insights-runtime-extractor DaemonSet **Trigger:** Automatic — the DaemonSet scans all container processes on the node **Attack sequence:** 1. Attacker creates a pod whose process name matches a configured versioned-executable pattern (`node`, `python`, `python3`, `MainThread`, or contains `java`) 2. The pod's main binary (at the path matching argv[0]) is a malicious executable that calls `setuid(0)` to restore root 3. When the insights operator triggers a scan, the DaemonSet forks, enters the attacker's mount namespace, and executes the attacker's binary with ruid=0 4. The attacker's code regains full root with `CAP_SYS_ADMIN` in the host user namespace 5. The inherited cwd contains the host CRI-O socket → full node compromise EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Medium | 5.4 | EPSS 0.2% | CVE-2026-63274Red Hat Security Advisory: libreoffice security update Medium5.4EPSS 0.2%GCVE DatabaseCVE-2026-63274 Multiple security vulnerabilities have been identified in LibreOffice, an open source office productivity suite. These include heap and stack buffer overflows in PDF import stream handling and font processing, as well as an arbitrary code execution vulnerability via a remote Java database driver. Red Hat has issued an important security update for LibreOffice in Red Hat Enterprise Linux 9 to address these issues. | GCVE Database |
Page 8 of 40 · 2 duplicate CVE records merged