Fundierte Artikel über Technologien, die das Kommende formen.

Java4Shell: OpenJDK-Base64-Bug macht 65 Bytes zu RCE

Java4Shell: ein Speicherfehler im AVX-512-Base64-Decoder von OpenJDK. Wie 65 Bytes Heap-Korruption und RCE auslösen und was du jetzt dagegen tun kannst.

Illustration eines winzigen leuchtenden Defekts auf einem Förderband, der eine riesige Industriemaschine zum Erliegen bringt
Die kleinste Komponente im Stack, ein Base64-Fast-Path, erweist sich als die, die durchbricht.

Sechsundsechzig Zeichen reichen aus: 64 Buchstaben A und ein einzelnes Gleichheitszeichen. Mehr braucht es nicht, um den Heap eines ungepatchten OpenJDK-Servers zu korrumpieren. Ein 65 Zeichen langer Base64-String umgeht Javas berühmte Speichersicherheit und schreibt 62 Bytes hinter das Ende eines Arrays. Die Schwachstelle, von der Sicherheitsfirma Calif als Java4Shell (CVE-2026-114938, CVSS 9.2) veröffentlicht, steckt nicht im Anwendungscode, sondern in handgeschriebenem Assembler tief im Base64-Decoder der JVM. Remote Code Execution ohne Authentifizierung wurde gegen Keycloak, Jenkins, Jira, Confluence, Artifactory und PingFederate demonstriert. Wenn deine Organisation Java auf x86-64-Servern betreibt, und statistisch gesehen tut sie das, ist das dein Problem.

Ich beschäftige mich beruflich mit Schwachstellen, und die meisten verschwimmen irgendwann ineinander: noch ein Deserialisierungsfehler, noch ein Auth-Bypass, noch ein Path Traversal. Java4Shell ist anders, und das liegt nicht am Score. Es liegt daran, wo der Fehler sitzt. Die Lücke steckt in einer Optimierung, einem Beschleuniger zum Dekodieren von Base64 mit AVX-512-Vektorbefehlen, den praktisch keine Anwendung wirklich braucht. Wie der Fehler gefunden wurde, wie er ausgenutzt wird und warum deine Proxies dich vielleicht schon schützen, sagt viel darüber, wohin sich Software-Sicherheit entwickelt.

Das Problem: Ein JIT-Intrinsic mit kaputter Maske

Um den Bug zu verstehen, muss man wissen, wie OpenJDK Base64 schnell macht. Die HotSpot-JVM beobachtet, welche Methoden häufig laufen, und lässt ihren C2-Compiler sie in nativen Code übersetzen. Für bestimmte Operationen geht sie weiter und tauscht sie gegen handoptimierte Assembler-Routinen aus, sogenannte Intrinsics, die spezielle CPU-Befehle nutzen. Auf x86-64-Prozessoren mit AVX-512-VBMI-Unterstützung bekommt das Base64-Dekodieren genau diese Behandlung: Das Intrinsic arbeitet die Eingabe in Blöcken von 256 oder 64 Bytes ab, nutzt den Befehl VMOVDQU8 mit einer 64-Bit-Maske und entscheidet so, welche Bytes in den Zielpuffer geschrieben werden.

Der Fehler liegt darin, wie diese Maske für den aufgefüllten Endbereich einer Eingabe berechnet wird. Base64 füllt die Ausgabe mit =-Zeichen auf, und der Assembler verkürzt die Ausgabelänge für jedes Padding-Byte, das er sieht. Bei bestimmten fehlerhaften Eingaben, zum Beispiel einem einzelnen = am Ende eines Blocks, läuft die berechnete Ausgabelänge in einen Wert von -1 oder -2 über. Dieser negative Wert fließt in einen Bit-Manipulationsbefehl (bzhiq), der bei Eingaben ab 64 Zeichen die Maske unverändert lässt: alle 64 Bits gesetzt. Alle Bits gesetzt bedeutet, dass jedes Byte geschrieben wird.

Schauen wir uns den konkreten Auslöser an. Du schickst 64 A gefolgt von =, also insgesamt 65 Zeichen. Die JVM berechnet die dekodierte Länge als 50 Bytes und alloziert ein Array mit 50 Bytes. Das Intrinsic dekodiert die ersten 64 Zeichen problemlos, stößt dann auf das überzählige Gleichheitszeichen, lässt die Länge unterlaufen, setzt die volle Maske und feuert einen vektorisierten 64-Byte-Schreibvorgang los, der kurz vor dem Ende des 50-Byte-Puffers beginnt. 62 Bytes benachbarter Heap-Objekte werden mit vom Angreifer beeinflussten konstanten Daten überschrieben. Javas eigene Validierung bemerkt zwar irgendwann, dass die Eingabe ungültig ist, und wirft eine IllegalArgumentException, aber dann ist der Schaden schon angerichtet. Der Exception-Handler wischt den Boden, während das Haus bereits brennt.

// Pseudocode of the mask calculation (after Calif's write-up)
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
// For a lone '=' tail, output_len was already 0
// -> now it's -1, and bzhiq(-1, 255) leaves all bits set
output_mask := bzhiq(-1, output_len)   // == -1u64, all 64 bits 1
// evmovdqub then writes all 64 bytes where ~50 were allocated

Für deine Triage ist ein Detail wichtig: Der Fehler wird nur auf x86-64-Hosts ausgeführt, deren CPUs AVX-512-VBMI unterstützen. ARM-Server wie AWS Graviton führen den fehlerhaften Stub nie aus, ältere Xeons ebenfalls nicht. Der verwundbare Codepfad existiert außerdem nur in HotSpot-basierten JVMs, also OpenJDK, Oracle JDK und GraalVM. OpenJ9 und Azul Prime, die andere JIT-Architekturen nutzen, sind nicht betroffen. Auf OpenJDK 17 liegt der Auslöser übrigens bei 128 A plus = statt 64, weil die Schwelle für den Fast Path höher liegt. Kleine Unterschiede, aber sie sind entscheidend, wenn du Erkennungsregeln schreibst.

Erster gescheiterter Ansatz: „Java ist speichersicher“

Die erste Reaktion in den Engineering-Channels, als das publik wurde, war Unglaube. Speicherkorruption in Java? Ist Speichersicherheit nicht genau der Sinn der Sache? Dieser Instinkt, dass die Laufzeitumgebung eine Festung ist und nur Anwendungscode dich verraten kann, ist das erste gescheiterte Modell. Es lohnt sich, es genauer anzusehen, weil es prägt, wie Teams ihren eigenen Stack prüfen.

Java als Sprache prüft jeden Array-Zugriff und verwaltet jede Allokation. Java als Laufzeitumgebung ist aber eine riesige Menge an C, C++ und Assembler. Die JIT-Compiler, die Garbage Collectors, die Intrinsics, der Code für Native Images, all das läuft mit der vollen, ungefilterten Macht des Prozesses, und nichts davon profitiert von den Garantien, die dein Bytecode genießt. Jedes Intrinsic ist ein kleines Loch in der Sicherheitsmauer, das im Namen der Geschwindigkeit gebohrt wurde, und diese Löcher werden von einer überschaubaren Handvoll VM-Entwickler gepflegt. Es ist dieselbe strukturelle Lehre wie beim zehn Jahre alten SSH-Asterisk-Bug in Alpine Linux: Die gefährlichsten Fehler stecken in Code, auf den alle angewiesen sind und den kaum jemand liest.

Hier gibt es einen blinden Fleck bei Sicherheitsaudits, den ich ständig sehe. Teams fuzzen ihre eigenen JSON-Parser, pentesten ihre REST-Handler und lassen statische Analysen über jede Zeile laufen, die sie geschrieben haben. Das JDK behandeln sie dann als Blackbox, weil es ausgereift, weit verbreitet und von klugen Leuten gepflegt wird. Reife ist aber keine Verteidigung. Oft ist es sogar das Gegenteil: Jahrzehnte angesammelter Optimierungen, jede für sich damals sinnvoll, jede mit zusätzlicher Angriffsfläche, die an alle ausgeliefert wird, ob sie davon profitieren oder nicht. Das AVX-512-Intrinsic für Base64 existiert, um Anwendungen zu beschleunigen, die enorme Datenmengen dekodieren. Deine REST-API, die einen 200-Byte-Auth-Header dekodiert, erbt das Risiko und bekommt praktisch keinen Nutzen. Calif nennt das die Tragödie der Allmende, und sie haben recht: Alle, die das Feature brauchten, hatten den Vorteil, alle anderen bekamen nur den Bug.

Zweiter gescheiterter Ansatz: „Der Schreibvorgang ist zu eingeschränkt, um ihn auszunutzen“

Das zweite gescheiterte Modell kam von Leuten, die die technischen Details lasen und sich dann entspannten. Ein Überschreiben mit konstantem Wert, an einem festen Offset, ohne Kontrolle über die geschriebenen Bytes? Viele Bugs dieser Art landen unter „nur ein Crash“ und werden heruntergestuft. Diese Einschätzung ist verständlich, aber falsch, und warum sie falsch ist, ist der lehrreichste Teil dieser ganzen Geschichte.

Moderne Exploits drehen sich nicht darum, was eine einzelne Primitive kann, sondern darum, wie sich das umgebende System dazu bewegen lässt, sich um sie herum anzuordnen. Califs Technik war Heap Grooming: Das Allokationsverhalten wird aus der Ferne so geformt, dass ein vorhersehbares, nützliches Objekt direkt hinter dem überlaufenen Puffer landet. Sie taten das über das Netzwerk und steuerten über das Timing der Requests, wann auf dem Ziel allokiert und freigegeben wird. Der Schreibvorgang mag einen konstanten Wert haben, aber wer kontrolliert, welches Objekt im Wirkungsbereich liegt, kontrolliert, was beschädigt wird. Darauf aufbauend bauten sie eine Memory-Disclosure im Stil von Heartbleed, leakten genug, um ASLR auszuhebeln, und verketteten das zu vollwertiger Remote Code Execution.

Abstraktes Stadtraster aus Speicherblöcken, die zu einem gezielten Muster angeordnet sind, mit einem roten Block in der Mitte
Heap Grooming macht aus einem eingeschränkten Schreibvorgang mit konstantem Wert eine Waffe, indem es kontrolliert, worauf er trifft.

In dem Write-up steckt ein herrlich pragmatisches Detail dazu, wie das über das echte Internet funktioniert. Remote Heap Grooming reagiert empfindlich auf Round-Trip-Zeiten und Jitter. Die Requests müssen in einem bestimmten Rhythmus ankommen, damit der Allocator in dem gewünschten Zustand ist. Statt den TCP-Stack zu reverse-engineeren, mieteten die Forscher eine VM in derselben Cloud-Region wie ihr Ziel. Ein Physikproblem gelöst mit Geld. Ich habe Elite-Exploit-Entwickler das seit Jahren in verschiedenen Varianten machen sehen, und es erinnert daran, dass Einschränkungen von Angreifern ebenso wirtschaftlich wie technisch sind. Ein gut ausgestatteter Gegner betrachtet Netzwerk-Jitter als Posten im Budget.

Außerdem: Es gibt keinen universellen Exploit. Jede Anwendung, ob Jira, Jenkins oder Keycloak, nutzt Base64 anders, allokiert anders und bietet andere Angriffsflächen fürs Grooming. Das ist die gute Nachricht. Die schlechte ist die schiere Breite der Einstiegspunkte. Authentifizierungs-Header, Datei-Upload-Felder, Behandlung von Client-Zertifikaten, Nachrichten-Payloads: Überall dort, wo Base64-Text in die JVM gelangt, ist ein Auslöser denkbar. Ein Contributor zeigte sogar eine Client-seitige Variante: Eine Java-Anwendung, die eine TLS-Verbindung zu einem bösartigen Server öffnet, lässt sich kompromittieren, ohne dass irgendein Dienst exponiert wird. Deine Batch-Jobs und internen Tools gehören genauso zum Scope wie deine internetseitigen Gateways.

Der Centaur im Raum: KI hat das in einer Stunde gefunden

Jetzt kommt der Teil, der das Bedrohungsmodell jedes Security-Teams neu kalibrieren sollte. Forscher Quang Luong fand die Schwachstelle in etwa einer Stunde und hatte etwa zwei Stunden später einen funktionierenden Exploit. Die gesamten KI-Token-Kosten lagen unter 200 Dollar. Seine Methode: Er richtete einen KI-Coding-Agenten auf die Bereiche von HotSpot, in denen Komplexität Grenzen überschreitet, also JIT, Intrinsics, weit erreichbare APIs und Krypto, und filterte dann das Rauschen. Das meiste, was der Agent ausspuckte, war unerreichbarer Schrott. Er blieb dran, und zwanzig Minuten Hartnäckigkeit später tauchte der Base64-Fund auf.

Calif beschreibt das als „Centaur-Hacker“: Der Mensch liefert die Intuition darüber, wo komplexe Systeme versagen, die KI liefert die Ausdauer. Ich halte das für zutreffend, und die Implikationen wirken in beide Richtungen. Dieselbe Schleife, die Java4Shell gefunden hat, steht jedem mit einem API-Key zur Verfügung, und die Exploit-Entwicklung, also das Bauen wiederverwendbarer Grooming-Pipelines und das anschließende Ausrollen von Agenten für anwendungsspezifische Ketten, wird zunehmend automatisiert. Die Ökonomie der Bug-Suche in ausgereiftem, weit verbreitetem C- und Assembler-Code ist gerade zusammengebrochen. Verteidiger sollten davon ausgehen, dass nach den nächsten Java4Shell-artigen Bugs schon gesucht wird, von Leuten, die keine Disclosures einreichen. Dahinter stehen Debatten wie die über die schrumpfenden Disclosure-Fristen von Project Zero: Wenn Entdeckung billig wird, ist das Patch-Fenster das ganze Spiel.

Califs vorgeschlagener Gegenzug ist provokant, und ich stimme ihm größtenteils zu: Dieselbe KI-Hebelwirkung nutzen, um Code zu löschen statt hinzuzufügen. Sie nennen es „Vibe-Uncoding“: eine Codebasis auf tote Features, veraltete Protokollunterstützung und unnötige Optimierungen prüfen und dann herausreißen, um die Angriffsfläche zu verkleinern. Der ehrliche Einwand ist, dass Löschen riskant ist. Scheinbar ungenutzte Features haben versteckte Abhängigkeiten, und die nötigen Tests werden von Teams chronisch unterfinanziert. Aber die Richtung stimmt. Wenn dein JDK einen handgeschriebenen Assembler-Fast-Path für eine Workload mitschleppt, die du nie haben wirst, ist die optimale Sicherheitslage, diesen Pfad gar nicht erst auszuliefern. Wenn das nicht geht, bietet dir die JVM immerhin einen Schalter, um ihn abzuschalten. Damit kommen wir zu dem, was tatsächlich funktioniert.

Was tatsächlich funktioniert: Patchen, Flaggen, Proxy

Hier ist der Teil, für den sich deine Bereitschaft interessiert. Die Gegenmaßnahmen fallen in drei Stufen, und ich würde dafür argumentieren, dass du mindestens zwei davon schon heute umsetzt, nicht erst beim nächsten Änderungsfenster.

  1. Auf einen gefixten OpenJDK-Build patchen. Der Upstream-Fix (JDK-Commit 5177a70) korrigiert die Berechnung der Maske. Das ist die einzige vollständige Lösung. Betroffen sind Versionen ab 17.0.6 auf der 17er-Linie und alle aktuellen Releases auf 21 und höher. Prüfe die Liste der Fixed-in-Versionen für deinen konkreten Release-Zweig und behandle jede HotSpot-JVM, also OpenJDK, Oracle JDK und GraalVM, so lange als betroffen, bis du das Gegenteil verifiziert hast.
  2. Das Intrinsic als Übergangsmaßnahme deaktivieren. Starte die JVM mit -XX:-UseBASE64Intrinsics, um die hardwarebeschleunigte Base64-Verarbeitung komplett abzuschalten. Der Performance-Verlust ist vernachlässigbar, außer du dekodierst Gigabytes an Base64, und das macht praktisch niemand. Alternativ deaktiviert -XX:UseAVX=2 AVX-512 auf x86-64. Setze dieses Flag aber nicht auf ARM, dort verweigert die JVM den Start. Das ist dieselbe Philosophie wie bei dem PHP-CVE-Playbook: Wenn die verwundbare Komponente ein schmaler, austauschbarer Fast Path ist, ist es besser, den Fast Path abzuschalten, als zu warten.
  3. Proxies nutzen, um das Exploit-Timing zu brechen. Im Abschnitt zu den Limitierungen merkt Calif an, dass aktuelle Remote-Grooming-Profile darauf angewiesen sind, dass Teile des Request-Bodys mit präzisem Timing bei der Anwendung ankommen. Ein Reverse-Proxy, der den vollständigen Request-Body puffert, was nginx standardmäßig tut, zerstört dieses Timing. Das ist ausdrücklich kein Fix, aber es erschwert den praktikabelsten Angriffspfad spürbar, während du patchst.

Auch die Erkennung verdient einen Satz. Semgrep hat kostenlose Skripte veröffentlicht, die auf die Kombination der Bedingungen prüfen, die einen Host ausnutzbar machen: eine VM der HotSpot-Familie, x86-64-Hardware mit der passenden Befehlsunterstützung und eine Version im betroffenen Bereich. Führe das über deine Flotte aus, bevor du annimmst, dass du verwundbar bist. Deine ARM-basierten Container und OpenJ9-Nachzügler sind in Ordnung, und das schnell zu wissen spart ein ganzes Wochenende. Beim Scannen gilt: Die Versionslinien sind entscheidend. Der Fix kam in bestimmten Patch-Releases pro Zweig, daher ist „wir sind auf 21“ keine Antwort.

Drei konzentrische Verteidigungsschichten, die einen leuchtenden Kern schützen, mit einer Hand, die einen Schalter im innersten Ring umlegt
Verteidigung in Schichten: im Kern patchen, den Fast Path abschalten und den Proxy das Timing des Angreifers brechen lassen.

Die größere Lehre: Optimierungen sind Risiken, die du nie geprüft hast

Tritt man einen Schritt von der Incident Response zurück, bleibt bei Java4Shell ein unbequemer Nachgeschmack. Der Bug steckte nicht in einer obskuren Nebenfunktion. Er steckte in Base64, vermutlich der langweiligsten, allgegenwärtigsten Operation der Informatik, bei der man denkt: „Das ist doch inzwischen sicher.“ Die Schwachstelle existierte genau deshalb, weil jemand das Langweilige schnell machen wollte, mit den neuesten Vektorbefehlen, in Assembler und mit einem Edge Case bei der Tail-Behandlung, der das Code-Review überlebt hat. Jede ausgereifte Laufzeitumgebung ist voll davon. Und jeden einzelnen davon jagen heute unermüdliche Agenten, die weniger kosten als ein gutes Abendessen.

Alle fragen, was KI bauen kann. Die bessere Sicherheitsfrage könnte sein, was sie uns helfen kann zu löschen.

Meine Meinung: Die Branche wird gerade den Unterschied zwischen Code, der auditiert wurde, und Code, von dem man annimmt, dass er sicher ist, auf die harte Tour lernen, und das Lehrgeld wird teuer. Standardbibliotheken, VM-Intrinsics, Kompressions-Codecs, Bild-Decoder: genau die Grundschichten, die wir nie hinterfragen, sind dort, wo menschliche Aufmerksamkeit am knappsten ist und KI-gestützte Suche die höchsten Bounties einbringt. Das Centaur-Modell findet Bugs nicht nur schneller, es findet sie an Stellen, die menschliche Forscher übersprungen haben, weil der erwartete Nutzen, „gelösten“ Code zu auditieren, zu gering schien.

Also: Patche deine JVMs, schalte das Intrinsic-Flag überall dort um, wo du nicht patchen kannst, und lass nginx dir Zeit verschaffen. Schau dir aber auch deinen eigenen Dependency-Baum an und stelle die Uncoding-Frage: Welche dieser Features haben wir geerbt, statt sie bewusst gewählt zu haben? Die 65 Zeichen, die dein Wochenende ruinieren, sind wahrscheinlich schon geschrieben. Die einzige offene Frage ist, ob die Person, die sie hält, eine Disclosure einreicht oder nicht.