Java2Shell: Wie ein Base64-String die JVM aushebelt

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Java2Shell, meist Java4Shell genannt (CVE-2026-114938), ist ein Heap-Überlauf im JIT-optimierten Base64-Decoder der HotSpot-JVM.
- Betroffen sind Java 17 ab 17.0.6 sowie 21, 25 und 27, aber nur auf x86-64-CPUs mit AVX-512 VBMI (Intel Ice Lake und neuer, AMD Zen 4 und neuer).
- Ein präparierter Base64-String mit Padding bringt die JVM dazu, 64 Byte zu schreiben, obwohl im Ziel-Array fast kein Platz ist.
- Die Entdecker haben daraus Codeausführung ohne Login gebaut, unter anderem gegen Jira, Confluence, Jenkins und Keycloak.
- Hilfe: Java-Update vom 17. November einspielen, JVM neu starten, Container neu bauen. Übergangsweise
-XX:-UseBASE64Intrinsics.
Seit gestern Abend taucht in den Security-Feeds ein Name auf, bei dem jeder, der im Dezember 2021 Log4Shell mitgemacht hat, kurz schlucken dürfte: Java4Shell, in manchen Meldungen auch Java2Shell. Der Unterschied zu damals: Diesmal steckt der Fehler nicht in einer Bibliothek, die man austauschen kann, sondern in der JVM selbst. Und er ist technisch so hübsch, dass ich ihn mir genauer angeschaut habe.
Kurz zum Namen: Die Entdecker vom Sicherheitsunternehmen Calif nennen die Lücke Java4Shell. „Java2Shell“ stammt vor allem aus Sekundärquellen. Gemeint ist in beiden Fällen dasselbe, nämlich CVE-2026-114938.
Warum die JVM eigenen Maschinencode für Base64 hat
java.util.Base64 ist ganz normaler Java-Code. Die HotSpot-JVM ersetzt aber besonders häufig genutzte Methoden durch sogenannte Intrinsics. Das sind handgeschriebene Assembler-Routinen, die die JVM beim Start passend zur CPU erzeugt. Für Base64 gibt es so einen Stub in stubGenerator_x86_64.cpp, und auf Prozessoren mit AVX-512 VBMI nutzt er 512-Bit-Register, um 64 Zeichen auf einmal zu dekodieren. Gesteuert wird das über das Flag UseBASE64Intrinsics, das standardmäßig aktiv ist.
Wichtig für das Verständnis: Der Stub greift erst, wenn der Code JIT-kompiliert ist. Im Interpreter läuft die normale Java-Implementierung. Auf einem Server, der in jedem Request irgendetwas Base64-dekodiert, ist dieser Punkt allerdings nach kurzer Zeit erreicht.
Der Fehler: Aus einer negativen Länge wird eine volle Maske
Der AVX-512-Decoder arbeitet in Blöcken zu 64 Zeichen. Was danach übrig bleibt, landet im Pfad für das letzte Fragment (L_finalBit). Laut den bisherigen Analysen läuft dort Folgendes schief, wenn der Rest nur 1 bis 3 Zeichen lang ist und mit = endet:
- Die Ausgabelänge wird als
(länge / 4) * 3berechnet. Bei einem Rest von 1 bis 3 Zeichen ergibt das 0. - Der Padding-Code zieht für die
=-Zeichen Bytes ab. Aus 0 wird damit -1 oder -2. - Aus dieser Länge baut die Instruktion
bzhiqeine Schreibmaske. BZHI wertet nur die unteren 8 Bit des Index aus, -1 ist dort 255. Ein Index jenseits von 64 löscht keine Bits, die Maske bleibt komplett gesetzt. - Der maskierte Speicherbefehl
evmovdqubschreibt deshalb alle 64 Byte aus dem Register in das Ausgabe-Array. Das ist aber nur für wenige Bytes ausgelegt.
// stark vereinfacht: Pfad für das letzte Fragment
out_len = (rest / 4) * 3; // rest = 1..3 -> 0
out_len -= padding; // "=" am Ende -> -1 bzw. -2
mask = bzhi(~0ULL, out_len); // Index 254/255 -> keine Bits gelöscht
store64(out, zmm, mask); // 64 Byte geschrieben, Array ist kleinerDas eigentlich Bittere: Java merkt sehr wohl, dass die Eingabe kaputt ist, und wirft eine IllegalArgumentException. Nur passiert das erst, nachdem der Stub schon über das Array hinaus geschrieben hat. Die Speichersicherheit von Java endet eben dort, wo handoptimierter Assembler anfängt. heise Security hat das in eine passende Zwischenüberschrift gepackt: „Java ist (nicht) speichersicher“. Unabhängig von Calif wurde inzwischen ein Überlauf um 62 Byte auf einem Intel-Ice-Lake-System nachgestellt.
Interessant ist auch, wie viel Eingabe nötig ist. Eine Analyse, die die Werte aus dem Quellcode ableitet, kommt bei Java 17 auf mehr als 128 Zeichen, bei Java 21 und 25 reichen schon gut 31. Das passt in praktisch jeden Header.
Der Fix im OpenJDK (JDK-8393212) ist entsprechend klein: Am Anfang von L_finalBit prüft der Stub jetzt, ob noch mindestens 4 Zeichen übrig sind. Ist der Rest kürzer, springt er in den langsamen Pfad, der Byte für Byte arbeitet.
Vom Überlauf zur Shell
Ein Überlauf allein ist noch keine Shell. Laut Calif überschreibt der Stub den Speicher hinter dem Array mit weitgehend festen Werten, beeinflussen kann man vor allem die Startposition. Daraus haben die Forscher zwei Werkzeuge gebaut: Lesezugriff auf fremde Heap-Daten, vergleichbar mit Heartbleed, und gezielte Schreibzugriffe. Beides zusammen reicht für Codeausführung mit den Rechten des Java-Prozesses. Einen universellen Exploit gibt es nach ihren Angaben nicht, jede Anwendung braucht ihr eigenes Profil.
Demonstriert haben sie das ohne Anmeldung gegen Jira, Confluence, Jenkins, JFrog Artifactory, Keycloak und PingFederate, jeweils in der Standardkonfiguration. Mit Login klappte es außerdem bei Kafka, Elasticsearch, Solr und Gerrit. Die Einfallstore sind unspektakulär: HTTP-Basic-Auth-Header, JWTs, SAML-Nachrichten, Uploads. Gerade Basic Auth finde ich unangenehm, weil ein Server den Header dekodieren muss, bevor er überhaupt prüfen kann, ob das Passwort stimmt.
Bei der Bewertung gehen die Meinungen auseinander. Oracle vergibt CVSS 3.1 mit 8.1 und stuft die Angriffskomplexität als hoch ein, Calif kommt mit CVSS 4.0 auf 9.2. Beides ist nachvollziehbar: Der Exploit ist Handarbeit, aber wer ihn einmal für ein Produkt hat, kann ihn gegen jede Instanz davon einsetzen.
Bin ich betroffen?
Gefährdet ist ein Dienst nur, wenn alle drei Bedingungen zutreffen:
- Java-Version: 17.0.6 oder neuer, oder eine Version der Linien 21, 25 oder 27, egal ob Oracle, Temurin, Corretto, Zulu, Red Hat oder Microsoft. Java 8, Java 11 und Java 17 vor 17.0.6 sind nicht betroffen.
- CPU: x86-64 mit AVX-512 VBMI, also laut heise Security Intel-Xeons der Generationen Ice Lake, Sapphire Rapids, Emerald Rapids und Granite Rapids sowie AMD EPYC und Ryzen ab Zen 4. Skylake-SP und Cascade Lake haben zwar AVX-512, aber kein VBMI. Reine AVX2-Systeme und ARM-Server wie AWS Graviton sind ebenfalls raus.
- Eingabe: Die Anwendung dekodiert Base64 aus nicht vertrauenswürdigen Quellen. Bei allem, was im Netz hängt, sollte man davon ausgehen.
Auf Linux lässt sich das schnell prüfen:
java -version # Version gegen die Liste abgleichen
grep -o avx512vbmi /proc/cpuinfo | sort -u # CPU mit VBMI?
java -XX:+PrintFlagsFinal -version | grep UseBASE64Intrinsics
jcmd <pid> VM.version # laufende JVM prüfen
jcmd <pid> VM.flagsEin Stolperstein, den man leicht übersieht: Viele Produkte bringen ihre eigene JRE mit, Jira und Jenkins zum Beispiel, und in Containern steckt das JDK im Basis-Image. Ein Update des System-Java hilft dort nichts.
Prüfskripte für Linux und Windows
Damit man nicht jede Installation einzeln abklappern muss, habe ich zwei kleine Skripte geschrieben. Beide suchen Java im PATH, unter JAVA_HOME, in den üblichen Installationsordnern und bei laufenden Prozessen. Für jede gefundene JVM prüfen sie die Version, ob die JVM AVX-512 VBMI nutzt und ob der Base64-Intrinsic aktiv ist. Den CPU-Check machen sie über die JVM selbst (-Xlog:os+cpu). Das funktioniert auf beiden Systemen gleich und berücksichtigt auch, wenn jemand AVX-512 per -XX:UseAVX abgeschaltet hat.
„ANGREIFBAR“ meldet das Skript nur, wenn alle drei Bedingungen erfüllt sind. Bei gepatchten Builds von Distributionen lohnt trotzdem ein Blick in die Release Notes. Und laufende Dienste können mit anderen Optionen gestartet worden sein als die Standard-JVM, das zeigt jcmd <pid> VM.flags.
Linux
Als java2shell-check.sh speichern und mit sudo bash java2shell-check.sh starten. Mit root-Rechten sieht das Skript auch Java-Prozesse anderer Benutzer.
#!/usr/bin/env bash
# java2shell-check.sh – prüft Java-Installationen auf CVE-2026-114938 (Java2Shell/Java4Shell)
# Aufruf: bash java2shell-check.sh (als root sieht das Skript auch fremde Java-Prozesse)
# Ohne Gewähr: Bei gepatchten Distributions-Builds immer auch die Release Notes (JDK-8393212) prüfen.
status() { # $1 = Versionsstring, z. B. 17.0.12 oder 21.0.13.1
local maj min pat ext rest last
IFS=. read -r maj min pat ext rest <<<"$1"
pat=${pat:-0}; ext=${ext:-0}
case "$maj" in
17) [ "$pat" -lt 6 ] && { echo "nicht betroffen"; return; }; last=21 ;;
21) last=13 ;;
25) last=5 ;;
27) last=1 ;;
18|19|20|22|23|24|26) echo "BETROFFEN (keine Updates mehr)"; return ;;
*) echo "nicht betroffen"; return ;;
esac
if [ "$pat" -lt "$last" ] || { [ "$pat" -eq "$last" ] && [ "$ext" -eq 0 ]; }; then
echo "BETROFFEN"
else
echo "gepatcht"
fi
}
# Java-Binaries einsammeln: PATH, JAVA_HOME, übliche Verzeichnisse, laufende Prozesse
kandidaten=$(
{ command -v java
[ -n "$JAVA_HOME" ] && echo "$JAVA_HOME/bin/java"
ls /usr/lib/jvm/*/bin/java /opt/*/bin/java /opt/*/*/bin/java 2>/dev/null
for pid in $(pgrep -x java 2>/dev/null); do readlink "/proc/$pid/exe"; done
} | while read -r j; do [ -x "$j" ] && readlink -f "$j"; done | sort -u
)
if grep -qw avx512vbmi /proc/cpuinfo; then cpu="ja"; else cpu="nein"; fi
echo "CPU mit AVX-512 VBMI: $cpu"
echo
[ -z "$kandidaten" ] && { echo "Keine Java-Installation gefunden."; exit 0; }
gesamt=0
while read -r j; do
ver=$("$j" -version 2>&1 | sed -nE 's/.*version "([0-9][0-9.]*)[^"]*".*/\1/p' | head -1)
st=$(status "$ver")
flags=$("$j" -XX:+PrintFlagsFinal -version 2>/dev/null)
intr=$(awk '$2=="UseBASE64Intrinsics"{print $4}' <<<"$flags")
grep -q '_base64_decodeBlock' <<<"$flags" && intr="false (DisableIntrinsic)"
vbmi=$("$j" -Xlog:os+cpu -version 2>&1 | grep -qw avx512_vbmi && echo ja || echo nein)
echo "$j"
echo " Version: ${ver:-unbekannt} -> $st"
echo " JVM nutzt VBMI: $vbmi"
echo " Base64-Intrinsic an: ${intr:-unbekannt}"
if [[ "$st" == BETROFFEN* && "$vbmi" == ja && "$intr" == true ]]; then
echo " ==> ANGREIFBAR: updaten oder mit -XX:-UseBASE64Intrinsics starten"
gesamt=1
elif [[ "$st" == BETROFFEN* ]]; then
echo " ==> Version betroffen, auf diesem System aktuell nicht ausnutzbar. Trotzdem updaten."
else
echo " ==> ok"
fi
echo
done <<<"$kandidaten"
echo "Hinweis: Laufende JVMs können andere Optionen haben. Prüfen mit: jcmd <pid> VM.flags"
exit $gesamtWindows
Als java2shell-check.ps1 speichern und in einer PowerShell als Administrator mit powershell -ExecutionPolicy Bypass -File .\java2shell-check.ps1 starten. Die Umlaute habe ich im Skript bewusst weggelassen, damit die alte Windows PowerShell beim Einlesen nicht über die Kodierung stolpert. Ehrlicherweise: Das Windows-Skript ist ungetestet. Seit meinem Umstieg auf Linux habe ich schlicht keinen Windows-Rechner mehr hier stehen. Wer es ausprobiert, darf mir gern Bescheid geben, ob es sauber durchläuft.
# java2shell-check.ps1 - prueft Java-Installationen auf CVE-2026-114938 (Java2Shell/Java4Shell)
# Aufruf: powershell -ExecutionPolicy Bypass -File .\java2shell-check.ps1
# Ohne Gewaehr: Bei gepatchten Distributions-Builds immer auch die Release Notes (JDK-8393212) pruefen.
function Get-Java2ShellStatus([string]$Version) {
$n = @($Version.Split('.') | ForEach-Object { [int]$_ }) + @(0, 0, 0, 0)
$maj = $n[0]; $pat = $n[2]; $ext = $n[3]
$last = @{ 17 = 21; 21 = 13; 25 = 5; 27 = 1 }
if ($maj -eq 17 -and $pat -lt 6) { return 'nicht betroffen' }
if ($last.ContainsKey($maj)) {
if ($pat -lt $last[$maj] -or ($pat -eq $last[$maj] -and $ext -eq 0)) { return 'BETROFFEN' }
return 'gepatcht'
}
if ($maj -ge 18 -and $maj -le 26) { return 'BETROFFEN (keine Updates mehr)' }
return 'nicht betroffen'
}
function Invoke-Java([string]$Exe, [string[]]$Arguments) {
# stderr und stdout als einfache Textzeilen zurueckgeben
$ErrorActionPreference = 'Continue'
& $Exe @Arguments 2>&1 | ForEach-Object { "$_" }
}
# Java-Binaries einsammeln: PATH, JAVA_HOME, uebliche Verzeichnisse, laufende Prozesse
$kandidaten = @()
$kandidaten += Get-Command java.exe -All -ErrorAction SilentlyContinue | ForEach-Object { $_.Source }
if ($env:JAVA_HOME) { $kandidaten += Join-Path $env:JAVA_HOME 'bin\java.exe' }
$ordner = @("$env:ProgramFiles\Java", "$env:ProgramFiles\Eclipse Adoptium", "$env:ProgramFiles\Amazon Corretto",
"$env:ProgramFiles\Zulu", "$env:ProgramFiles\Microsoft", "$env:ProgramFiles\BellSoft",
"$env:ProgramFiles\Atlassian", "$env:ProgramFiles\Jenkins")
foreach ($o in $ordner) {
if (Test-Path $o) {
$kandidaten += Get-ChildItem $o -Filter java.exe -Recurse -ErrorAction SilentlyContinue | ForEach-Object { $_.FullName }
}
}
$kandidaten += Get-Process java, javaw -ErrorAction SilentlyContinue |
Where-Object { $_.Path } | ForEach-Object { Join-Path (Split-Path $_.Path) 'java.exe' }
$kandidaten = $kandidaten | Where-Object { $_ -and (Test-Path $_) } |
ForEach-Object { (Resolve-Path $_).Path } | Sort-Object -Unique
if (-not $kandidaten) { Write-Host 'Keine Java-Installation gefunden.'; exit 0 }
$angreifbar = $false
foreach ($j in $kandidaten) {
$verZeile = Invoke-Java $j @('-version') | Select-String 'version "([0-9][0-9.]*)' | Select-Object -First 1
if ($verZeile) { $ver = $verZeile.Matches[0].Groups[1].Value.TrimEnd('.') } else { $ver = '' }
if ($ver) { $st = Get-Java2ShellStatus $ver } else { $st = 'unbekannt' }
$flags = Invoke-Java $j @('-XX:+PrintFlagsFinal', '-version')
$intr = 'unbekannt'
$zeile = $flags | Select-String '\sUseBASE64Intrinsics\s+:?=\s+(\w+)' | Select-Object -First 1
if ($zeile) { $intr = $zeile.Matches[0].Groups[1].Value }
if ($flags | Select-String '_base64_decodeBlock') { $intr = 'false (DisableIntrinsic)' }
if (Invoke-Java $j @('-Xlog:os+cpu', '-version') | Select-String '\bavx512_vbmi\b') { $vbmi = 'ja' } else { $vbmi = 'nein' }
Write-Host $j
Write-Host (" Version: {0} -> {1}" -f $ver, $st)
Write-Host (" CPU/JVM mit VBMI: {0}" -f $vbmi)
Write-Host (" Base64-Intrinsic an: {0}" -f $intr)
if ($st -like 'BETROFFEN*' -and $vbmi -eq 'ja' -and $intr -eq 'true') {
Write-Host ' ==> ANGREIFBAR: updaten oder mit -XX:-UseBASE64Intrinsics starten' -ForegroundColor Red
$angreifbar = $true
} elseif ($st -like 'BETROFFEN*') {
Write-Host ' ==> Version betroffen, auf diesem System aktuell nicht ausnutzbar. Trotzdem updaten.' -ForegroundColor Yellow
} else {
Write-Host ' ==> ok' -ForegroundColor Green
}
Write-Host ''
}
Write-Host 'Hinweis: Laufende JVMs koennen andere Optionen haben. Pruefen mit: jcmd <pid> VM.flags'
if ($angreifbar) { exit 1 } else { exit 0 }Beide Skripte geben am Ende den Exit-Code 1 zurück, wenn mindestens eine JVM angreifbar ist. Damit lassen sie sich auch in ein Monitoring oder eine CI-Pipeline einbauen.
Was jetzt hilft
- Patchen: Oracle hat am 17. November die Versionen 17.0.21.1, 21.0.13.1, 25.0.5.1 und 27.0.1.1 veröffentlicht. Bei den OpenJDK-Distributionen lohnt ein Blick in die Release Notes nach JDK-8393212.
- Neu starten: Ein Update auf der Platte bringt nichts, solange die alte JVM läuft. Container-Images müssen neu gebaut werden.
- Übergangsweise:
-XX:-UseBASE64Intrinsicsschaltet nur den betroffenen Stub ab, Base64 läuft dann wieder in Java und etwas langsamer.-XX:UseAVX=2geht auch, bremst aber alles aus, was von AVX-512 profitiert. Beides braucht einen Neustart und ist kein Ersatz für das Update. - Aufpassen: Unerwartete JVM-Abstürze mit
hs_err_pid-Dateien auf AVX-512-Servern sind ein Warnsignal. Eine WAF kann auf Base64-Werte achten, die mit=enden, deren Länge aber kein Vielfaches von 4 ist. Am besten erst nur protokollieren und dann blocken.
Zum Stand gestern war keine Ausnutzung in freier Wildbahn bekannt, und die Lücke steht auch noch nicht im KEV-Katalog der CISA. Ein Proof of Concept für die Speicherkorruption ist allerdings öffentlich, und die technischen Details liegen auf dem Tisch. Lange wird das nicht so bleiben.
Die eigentliche Nachricht steckt im Kleingedruckten
Zwei Details machen mir mehr Sorgen als die Lücke selbst. Erstens ist sie geleakt, bevor der Patch fertig war. Der südkoreanische Geheimdienst NIS hat öffentliche Einrichtungen gewarnt, bevor die meisten Sicherheitsteams überhaupt davon wussten.
Zweitens hat Calif nach eigenen Angaben etwa eine Stunde gebraucht, um den Fehler zu finden, und rund zwei weitere Stunden für einen funktionierenden Exploit. Die KI-Kosten lagen unter 200 US-Dollar. Ein Fehler in hochoptimiertem Assembler-Code der JVM, gefunden an einem Nachmittag. Das passt ziemlich genau zu meinem Beitrag über KI auf der Angreiferseite, der heute Abend hier erscheint. Die Zeit zwischen Entdeckung und Exploit schrumpft, und damit auch die Zeit, die uns zum Patchen bleibt.
Und noch etwas nehme ich mit: Intrinsics hatte ich bisher nie als Angriffsfläche auf dem Schirm. Die JVM tauscht da stillschweigend Java-Code gegen Assembler, und genau an dieser Stelle gelten die Garantien nicht mehr, für die man Java eigentlich nimmt.
Quellen: heise Security, Calif: Java4Shell, PentestIT, SecureLayer7, Sweet Security, SOC Austria / ACP
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.