A critical Java (JDK) vulnerability affects Vaadin applications (Java4Shell, CVE-2026-114938)
Overview
A critical remote code execution vulnerability, CVE-2026-114938 and publicly known as "Java4Shell", was fixed in the Java (JDK) security updates of November 2026. The flaw is in the Java runtime itself, not in Vaadin. We are publishing this notice because the Java Virtual Machine is the runtime for every Vaadin application, so an application running on an unpatched JDK can be affected regardless of the Vaadin version. For what the flaw is, and which Java versions and processors are affected and fixed, read the write-ups at calif.io and Aikido.
The action is to update the JDK that your application runs on, and the JDK on your build and development machines, to a version that carries the November 2026 fix. If you cannot update immediately, the JVM flag -XX:-UseBASE64Intrinsics disables the affected code path as a temporary workaround. Only x86 processors with the AVX-512 VBMI instruction set are affected, which in practice means Intel Ice Lake and newer and AMD Zen 4 and newer; ARM is not affected.
Is Vaadin itself affected
Vaadin's own code is not the source of the vulnerability. The flaw is in the JDK, and the fix is to update the JDK.
- Vaadin Flow does not decode client supplied Base64 on its own request handling paths.
- Vaadin Hilla full stack signals in Vaadin 25.1 and newer decode client supplied data through the JDK Base64 decoder; earlier versions do not reach this path. Vaadin will not add a workaround in its own code: the fix is a patched JDK.
- The Vaadin license checker uses Base64 and JWT, but only on a developer supplied license key, never on attacker controlled input, so it is not an exposure path.
- Vaadin IDE plugins, Copilot and the Dev Loop CLI can download or use a JetBrains Runtime (JBR) for hot swap. A JBR is a JDK and is affected like any other, and no fixed JBR has been released yet; see the tooling section below. Local development only.
Affected products
| Product | Status |
| A deployed Vaadin application | Affected if it runs on an unpatched JDK on a processor with AVX-512 VBMI. The flaw is in the JDK, not in Vaadin |
| Vaadin Flow | Does not itself decode client supplied Base64. A patched JDK protects the application |
| Vaadin Hilla | Full stack signals (Vaadin 25.1 and newer) reach the JDK Base64 decoder. A patched JDK is the fix |
| Vaadin IDE plugins, Copilot and Dev Loop CLI | May download or use a JetBrains Runtime for hot swap. See the tooling section below |
| Vaadin license checker | Uses Base64 and JWT, but not with attacker controlled input. Not an exposure path |
The answer does not depend on the Vaadin version, because the vulnerable component is the JDK. Every supported and unsupported line is affected in the same way, and the response is the same: run on a patched JDK.
Customer guidance
Update the JDK that runs your application. Move to a patched build for your Java distribution; the exact version differs by provider and is listed in the sources below. This is the complete fix and it does not require a Vaadin upgrade.
If you cannot update the JDK immediately, start the JVM with -XX:-UseBASE64Intrinsics. This disables the hardware accelerated Base64 decoder and closes this specific issue, but it leaves the other vulnerabilities fixed in the same Java update unaddressed, so treat it as temporary.
Update your build and development machines too, not only production, because a Java client connecting over TLS to a malicious server is also exposed.
Vaadin tooling and the JetBrains Runtime
Hot swap during development works best on a JetBrains Runtime (JBR), and several Vaadin tools offer to download one. A JBR is a JDK and is affected like any other. At the time of writing the newest JBR release still carries the flaw, so downloading it again does not help yet. This concerns development machines only, and the attack surface for a JBR running on localhost is narrow.
Where each tool gets its JBR:
| Tool | JetBrains Runtime used |
| Vaadin extension for VS Code | Downloads it into ~/.vaadin/jdk |
| Vaadin Copilot, hot swap setup from the browser | Downloads it into ~/.vaadin/jdk |
| Vaadin plugin for Eclipse | Downloads it into ~/.vaadin/jdk or ~/.vaadin/eclipse-plugin/jbr |
| Vaadin plugin for IntelliJ IDEA | Uses the JBR bundled with IntelliJ IDEA, which is updated with the IDE |
| Dev Loop CLI (.vaadin/vaadin-dev) | Downloads none, but prefers a JBR found in ~/.vaadin/jdk or ~/.jdks |
Until a fixed JBR is released, use one of the two options below.
Option 1: disable the affected code path. Add -XX:-UseBASE64Intrinsics to the JVM options of whatever starts your application:
- IntelliJ IDEA: Run, Edit Configurations, select the configuration, Modify options, Add VM options.
- Eclipse: Run, Run Configurations, select the configuration, Arguments, VM arguments.
- VS Code: append it to the vmArgs entry of the configuration in .vscode/launch.json. The Vaadin extension writes that entry when it sets up hot swap.
- Dev Loop CLI: .vaadin/vaadin-dev restart --jvm-args "-XX:-UseBASE64Intrinsics". The daemon keeps the flag for later restarts until it shuts down.
Setting the environment variable JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics covers every JVM at once, but only JVMs started from an environment that has it, so restart the IDE from a shell where it is set. The JVM confirms it with a "Picked up JAVA_TOOL_OPTIONS" line at startup.
Option 2: remove the downloaded JBR, and decline the offer to download one again until JetBrains publishes a fixed release.
On macOS and Linux:
rm -rf ~/.vaadin/jdk ~/.vaadin/eclipse-plugin/jbr On Windows, in PowerShell:
Remove-Item -Recurse -Force "$env:USERPROFILE\.vaadin\jdk" -ErrorAction SilentlyContinue
Remove-Item -Recurse -Force "$env:USERPROFILE\.vaadin\eclipse-plugin\jbr" -ErrorAction SilentlyContinue Run configurations created for hot swap point at the deleted runtime and stop working until you switch them to your regular, patched JDK. A regular JDK can still hot swap method body changes in debug mode; structural changes then need a restart. For IntelliJ IDEA there is nothing to delete: update the IDE once JetBrains ships a fixed build, and use option 1 meanwhile.
How to verify
- Check the version of the JDK your application runs on against the authoritative lists linked below.
- Check whether your processor even uses the affected code path. Run java -Xlog:os+cpu=info -version and look for avx512_vbmi in the reported CPU flags. If it is absent, the affected decoder is not used on that machine.
- For Eclipse Temurin, the status of patched builds is tracked at adoptium/temurin issue 326.
References
History
- 2026-11-19: Initial vulnerability report published