# Java4Shell (CVE-2026-114938) and Oracle E-Business Suite: Not Affected, but Check Everything Around It

- URL: https://www.integrigy.com/oracle-security-blog/java4shell-cve-2026-114938-oracle-ebs
- Published: 2026-11-18
- Type: Blog Post
- Products: Oracle E-Business Suite, Oracle Database, Oracle Fusion Middleware
- Focus areas: Vulnerabilities, Oracle Critical Patch Updates
- Tags: Buffer Overflow
- CVE IDs: CVE-2026-114938, CVE-2026-114939, CVE-2026-114940

Oracle E-Business Suite (EBS) 12.2 and 12.1 are not affected by CVE-2026-114938 ("Java4Shell"), the Java JVM vulnerability fixed in the November 2026 [Critical Security Patch Update (CSPU)](https://www.oracle.com/security-alerts/cspunov2026.html). The vulnerability affects Java 17.0.6 and later, 21, 25, and 27 and the Oracle Java SE 8 Enterprise Performance Pack. Oracle EBS runs on JDK 7 and standard JDK 8, neither of which contains the vulnerable code. Even though Oracle EBS is not vulnerable, many of the products deployed around it run on Java 17 or 21 and must be inventoried and patched.

Do not apply in Oracle EBS environments the published workarounds, such as the `-XX:-UseBASE64Intrinsics` flag, as a precaution. JDK 7 and JDK 8 do not recognize these options, and the JVM will not start with them. In addition to CVE-2026-114938, the November 2026 CSPU has other Java security bugs that require patching with JDK 7 Update 523 on the application tier and JDK/JRE 8 Update 513 on the database tier and clients.

## What Java4Shell Is

CVE-2026-114938 is a heap out-of-bounds write in the hardware-accelerated Base64 decoder of the Java JVM. Oracle scores it 8.1 (CVSS 3.1), and the researchers who found it score it 9.2 (CVSS 4.0). Oracle rates the result as a full compromise of confidentiality, integrity, and availability, exploitable over the network without authentication, with high attack complexity. 

Java's standard `java.util.Base64` decoder is used almost everywhere Java handles untrusted input: HTTP Basic authentication headers, JSON Web Tokens, SAML messages, cookies, file uploads, and API payloads. On most platforms, the decoding is done by ordinary Java code. However, on x86-64 processors with AVX-512 VBMI, the HotSpot C2 just-in-time compiler replaces that code with a hand-written assembly routine (an "intrinsic") that decodes 64 characters at a time. The assembly routine mishandles the last, padded block of the input.

### Preconditions

A JVM is exposed only if all four of the following are true -

1. It is an affected Java release (see the table below).
2. It runs on an x86-64 processor with AVX-512 VBMI, which reports the CPU flags `avx512f`, `avx512bw`, `avx512vbmi`, and `bmi2`. That means Intel Xeon from Ice Lake onward and AMD EPYC and Ryzen from Zen 4 onward. ARM64 systems are not affected.
3. It is the HotSpot JVM with the C2 compiler and the Base64 intrinsic enabled, which is the default. The decoder must be called enough times to be compiled, which happens quickly on a busy service.
4. Most importantly, attacker-controlled data reaches a Base64 decode.

Exploitation beyond a crash cannot be generalized. Each target requires its own heap layout work, which is why Oracle rates the attack complexity as high.

### Affected and Fixed Versions

| Java line | Affected | Fixed in |
|---|---|---|
| Java SE 7 | Not affected | — |
| Java SE 8 (standard) | Not affected | — |
| Java SE 8 Enterprise Performance Pack | 8u511-perf | 8u513-perf |
| Java SE 11 | Not affected | — |
| Java SE 17 | 17.0.6 through 17.0.21.0.3 | 17.0.21.1 |
| Java SE 21 | through 21.0.13.0.3 | 21.0.13.1 |
| Java SE 25 | through 25.0.5.0.3 | 25.0.5.1 |
| Java SE 27 | through 27.0.1.0.3 | 27.0.1.1 |
| Oracle GraalVM for JDK 17 / 21 | 17.0.21.0.3 / 21.0.13.0.3 | 17.0.21.1 / 21.0.13.1 |
| Oracle GraalVM Enterprise Edition 21 | 21.3.20.0.3 | 21.3.20.1 |

The Oracle rows come from Oracle's November 2026 CSPU advisory. The 17.0.6 lower bound comes from the researchers and reflects when the optimization was backported to the Java 17 update line. The same code is in every HotSpot-based OpenJDK distribution: Amazon Corretto, Eclipse Temurin, Azul Zulu, Microsoft Build of OpenJDK, BellSoft Liberica, SAP SapMachine, and Red Hat OpenJDK.

**Carefully check versions when downloading updates as not all the JDK builds are updated immediately.** 

Not all JVM providers are members of the OpenJDK Vulnerability Group, therefore, JVM providers like Eclipse Temurin do not get advance notice of vulnerabilities.

## Why Oracle EBS Is Not Affected

The Java versions Oracle EBS runs on predate the vulnerable code.

| EBS component | Java | Affected? | Why |
|---|---|---|---|
| 12.2 application tier: WebLogic Server 10.3.6 (oacore, oafm, forms, forms-c4ws), concurrent processing, AD utilities | JDK 6 or 7       | No        | JDK 6 and 7 have no `java.util.Base64` class at all. It was added in Java 8.                                                        |
| 12.2 web tier (Oracle HTTP Server home) and Forms 10.1.2 home                                                        | JDK 6 or 7       | No        | Same.                                                                                                                              |
| 12.2 database tier: 12c or 19c `ORACLE_HOME` JDK and the `appsutil` JRE                                              | JDK 8 (standard) | No        | Java 8 has the class but no Base64 decode intrinsic. Oracle lists only the Enterprise Performance Pack build of Java 8 as affected. |
| Database OJVM (19c) | Java 8 level | No | OJVM is Oracle's in-database JVM, not HotSpot, and it is at the Java 8 level. |
| 12.1 application tier | JDK 5, 6, or 7| No | Same as 12.2. |
| End-user desktops: Java Web Start or the JRE plug-in for Oracle Forms | JRE 8 (standard) | No | Same as the database tier JDK 8. |

### What Integrigy Verified

Integrigy checked an Oracle EBS 12.2.15 instance with a 19c database. The server's processor reports `avx512f`, `avx512bw`, `avx512vbmi`, and `bmi2`, so the hardware precondition for Java4Shell is met on that host.

- Every Java process running on the application tier was started from a JDK 7 home.
- The JDK 7 runtime library (`rt.jar`) contains no `java/util/Base64` classes.
- Neither JDK 7 nor JDK 8 has a `UseBASE64Intrinsics` option. Both reject it as an unrecognized VM option.
- Both JDK 7 and JDK 8 report `UseAVX = 2`. Neither generates AVX-512 code on this hardware.
- The database tier JDK and `appsutil` JRE report a standard build string (`1.8.0_511-b33`), not the `-perf` build Oracle lists as affected.

Oracle's EBS Java checker (EJCPUC, Patch 37171025) on the same instance lists every Java installation the environment contains:

```text
## Checking Application Tier JDK 7 versions ... - Required Version 1.7.0_523
   2026.11    action  Your Version  bitness  Java Location
 1.7.0_523    UPDATE  1.7.0_521     32-bit   .../fs1/EBSapps/10.1.2/jdk/bin/java
 1.7.0_523    UPDATE  1.7.0_521     32-bit   .../fs1/EBSapps/comn/util/jdk32/bin/java
 1.7.0_523    UPDATE  1.7.0_521     64-bit   .../fs1/EBSapps/comn/util/jdk64/bin/java
 1.7.0_523    UPDATE  1.7.0_521     64-bit   .../fs1/FMW_Home/webtier/jdk/bin/java

## Checking Database Tier versions ... - Required Version: 1.8.0_513
 1.8.0_513    o)      1.8.0_511     64-bit   OJVM In database
 1.8.0_513    j)      1.8.0_511     64-bit   .../19.0.0/jdk/bin/java
 1.8.0_513    u)      1.8.0_511     64-bit   .../19.0.0/appsutil/jre/bin/java
```

In this test environment, the application tier has four JDK 7 homes, and the database tier has JDK 8 in three places. None is Java 17 or later.

### Do Not Apply the Workaround Flag to EBS

Most Java4Shell guidance recommends starting JVMs with `-XX:-UseBASE64Intrinsics` or similar settings to disable the intrinsics or CPU extensions, and some of it recommends setting the flag globally through `JAVA_TOOL_OPTIONS`. JDK 7 and JDK 8 do not have the option and will not start with it -

```text
Unrecognized VM option 'UseBASE64Intrinsics'
Error: Could not create the Java Virtual Machine.
```

## Where EBS Customers May Still Be Exposed

An Oracle EBS environment is rarely only EBS. The products below commonly run beside it, often on Java 17 or 21. Integrigy has not assessed each of them for a reachable attack vector. Each may be running an affected JVM and should be checked.

| Component | What to check |
|---|---|
| Oracle REST Data Services (ORDS) | Current ORDS releases require Java 17 or 21. ORDS is frequently deployed with EBS for Oracle APEX extensions and REST services, and it is often reachable from more of the network than EBS itself. |
| Oracle Enterprise Command Center (ECC) Framework | ECC runs on its own WebLogic Server with its own JDK, separate from the EBS application tier. As of V16, JDK 17.0.20+7-LTS-191 is installed. Check the JDK version on the ECC server.|
| Identity and access management | Oracle Access Manager, the EBS AccessGate, and third-party identity providers and SSO gateways in front of EBS. Keycloak and PingFederate are among the products that can be exploited before authentication. |
| Integration and reporting | Oracle SOA Suite, Oracle Integration agents, Oracle Analytics, GoldenGate, and any custom Java services that call EBS. |
| Management and monitoring | Oracle Enterprise Manager and its agents, and third-party monitoring, backup, and scheduling agents on the EBS servers. A third-party agent with a bundled Java 17 runtime on an EBS host is in scope even though EBS is not. |
| DBA and developer tools | SQLcl, SQL Developer, and build and source-control tooling. The researchers also describe a client-side attack in which a Java program that connects over TLS to a malicious server can be compromised. |
| Java SE 8 Enterprise Performance Pack | It is not part of EBS. Confirm that no `-perf` build has been installed on a server. |

Newer server hardware is more likely to have AVX-512 VBMI, so recently refreshed servers and current cloud compute shapes should be checked first.

## How to Check a Server

Find every running Java process and the binary behind it. Do not rely on `java -version` from the shell, since applications bundle their own runtimes:

```bash
ps -eo pid,args | grep '[j]ava'
```

```bash
readlink -f /proc/<PID>/exe
```

Check the exact build of each JDK home. Look for a major version of 17 or higher, or a Java 8 build string containing `-perf`:

```bash
/path/to/jdk/bin/java -version
```

Check whether the processor has the required features. The host is in scope only if all four flags are printed:

```bash
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' |
  grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
```

For an affected JVM (Java 17 and later only), confirm whether the intrinsic is enabled:

```bash
/path/to/jdk/bin/java -XX:+PrintFlagsFinal -version |
  grep -E 'UseAVX |UseBASE64Intrinsics'
```

On the EBS tiers, run EJCPUC, [My Oracle Support Patch 37171025](https://support.oracle.com/support/?patchId=37171025) (login required), to list every Java home EBS uses and compare each with the current CSPU level.

## EBS Still Needs the November 2026 Java Updates

Not being affected by Java4Shell does not mean there is no Java patching to do. The November 2026 CSPU fixes 11 Java SE vulnerabilities, and the November 2026 CSPU note, [My Oracle Support KA1855](https://support.oracle.com/support/?documentId=KA1855) (login required), raises the required Java levels for EBS -

| EBS tier | Required in November 2026 |
|---|---|
| Application tier (12.2 and 12.1) | JDK 7 Update 523 |
| Database tier JDK and `appsutil` JRE | JDK 8 Update 513 |
| Desktops running Oracle Forms (Java Web Start or JRE plug-in) | JRE 8 Update 513 |

Five of the eleven Java SE CVEs apply to standard Java 8, including CVE-2026-114940 (JSSE, CVSS 7.4) and CVE-2026-114939 (JGSS, CVSS 7.4). Follow KA1855 and the JDK update articles it references.

## Recommendations

1. Record Oracle EBS as not affected by CVE-2026-114938 for audit and vulnerability management purposes, with the EJCPUC output as the evidence.
2. Do not attempt to use `-XX:-UseBASE64Intrinsics` with EBS application and database tier hosts.
3. Inventory Java on every server that supports EBS, including runtimes bundled inside agents and third-party products, and identify anything on Java 17, 21, 25, or 27 or a Java 8 `-perf` build.
4. Patch affected runtimes to the fixed builds and restart every JVM. Replacing files on disk does not fix a running process, and container images must be rebuilt.
5. Where a fixed build is not yet available, restart affected Java 17 and later JVMs with `-XX:-UseBASE64Intrinsics` as a temporary measure.
6. Do not rely on a WAF or reverse proxy for this vulnerability. Base64 arrives in too many headers, bodies, and protocols for a network rule to be a dependable control.
7. Apply the November 2026 Java updates to EBS on the normal CSPU schedule: JDK 7u523 and JDK/JRE 8u513.
8. Investigate unexplained JVM crashes and new `hs_err_pid*.log` files on Java 17 and later services, and bursts of `IllegalArgumentException` from `java.util.Base64$Decoder`.

If you have any questions or need further assistance, please contact us at <info@integrigy.com>.

## References

- [Oracle Critical Security Patch Update Advisory, November 2026](https://www.oracle.com/security-alerts/cspunov2026.html)
- *Oracle E-Business Suite Release 12.2 Critical Security Patch Update Availability Document (November 2026)* [My Oracle Support KA1855](https://support.oracle.com/support/?documentId=KA1855) (login required)
- Oracle E-Business Suite Java Critical Patch Update Checker (EJCPUC) [My Oracle Support Patch 37171025](https://support.oracle.com/support/?patchId=37171025) (login required)
- *Using the Latest JDK 7.0 Update with Oracle E-Business Suite Release 12.2* [My Oracle Support KA1058](https://support.oracle.com/support/?documentId=KA1058) (login required)
