Java4Shell : 65 octets Base64 pour un RCE dans OpenJDK
Java4Shell est une corruption mémoire dans le décodeur Base64 AVX-512 d'OpenJDK. Comment 65 octets déclenchent un RCE, et comment atténuer le risque dès maintenant.

Soixante-quatre lettres A et un seul signe égal. C'est tout ce qu'il faut pour corrompre le tas d'un serveur OpenJDK non patché : une chaîne Base64 de 65 caractères qui contourne la sécurité mémoire réputée de Java et écrit 62 octets au-delà de la fin d'un tableau. La vulnérabilité, divulguée par la société de sécurité Calif sous le nom de Java4Shell (CVE-2026-114938, CVSS 9,2), ne se trouve pas dans le code applicatif mais dans de l'assembleur écrit à la main, enfoui dans le décodeur Base64 de la JVM. Une exécution de code à distance sans authentification a été démontrée contre Keycloak, Jenkins, Jira, Confluence, Artifactory et PingFederate. Si votre organisation fait tourner Java sur des serveurs x86-64 — et statistiquement, c'est le cas — ce problème vous concerne.
Je couvre les vulnérabilités à plein temps, et la plupart se ressemblent : encore une faille de désérialisation, encore un contournement d'authentification, encore une traversée de répertoires. Java4Shell est différente, et pas à cause de son score. Elle est différente à cause de l'endroit où elle se cache. Le bug se trouve dans une optimisation — un accélérateur de décodage Base64 utilisant les instructions vectorielles AVX-512 — dont presque aucune application au monde n'a réellement besoin. L'histoire de sa découverte, de son exploitation et de la raison pour laquelle vos proxys vous protègent peut-être déjà en dit long sur la direction que prend la sécurité logicielle.
Le problème : un intrinsèque JIT avec un masque cassé
Pour comprendre le bug, il faut savoir comment OpenJDK rend Base64 rapide. La JVM HotSpot surveille les méthodes les plus sollicitées et laisse son compilateur C2 les transformer en code natif. Pour certaines opérations, elle va plus loin et substitue des routines d'assembleur optimisées à la main, appelées intrinsèques, qui utilisent des instructions CPU spécialisées. Sur les processeurs x86-64 compatibles AVX-512 VBMI, le décodage Base64 bénéficie précisément de ce traitement : l'intrinsèque traite l'entrée par blocs de 256 ou 64 octets, en utilisant l'instruction VMOVDQU8 avec un masque de 64 bits qui décide quels octets sont écrits dans le tampon de destination.
La faille réside dans le calcul de ce masque pour la queue remplie d'une entrée. Base64 complète sa sortie avec des caractères =, et l'assembleur réduit la longueur de sortie pour chaque octet de remplissage rencontré. Pour certaines entrées malformées — un = isolé en fin de bloc, par exemple — la longueur calculée passe en dessous de zéro, à -1 ou -2. Cette valeur négative atteint une instruction de manipulation de bits (bzhiq) qui, pour des entrées de 64 caractères ou plus, laisse le masque inchangé : les 64 bits sont à 1. Tous les bits à 1 signifient que chaque octet est écrit.
Voici le déclencheur concret. Vous envoyez 64 A suivis de =, soit 65 caractères au total. La JVM calcule une longueur décodée de 50 octets et alloue un tableau de 50 octets. L'intrinsèque décode correctement les 64 premiers caractères, rencontre le signe égal parasite, fait passer la longueur en négatif, active le masque complet — et déclenche une écriture vectorisée de 64 octets commençant près de la fin du tampon de 50 octets. Soixante-deux octets des objets voisins du tas sont écrasés avec des données constantes influencées par l'attaquant. La validation Java finit bien par détecter que l'entrée est invalide et lève une IllegalArgumentException, mais il est déjà trop tard. Le gestionnaire d'exceptions essuie le sol alors que la maison brûle déjà.
// 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
Un détail compte pour votre triage : ce code ne s'exécute que sur les hôtes x86-64 dont le CPU prend en charge AVX-512 VBMI. Les serveurs ARM comme AWS Graviton n'exécutent jamais le stub vulnérable, pas plus que les anciens Xeon. Le chemin de code vulnérable n'existe que dans les JVM basées sur HotSpot — OpenJDK, Oracle JDK, GraalVM. OpenJ9 et Azul Prime, qui utilisent des architectures JIT différentes, ne sont pas touchés. Sur OpenJDK 17, d'ailleurs, le déclencheur est de 128 A suivis de = au lieu de 64, car le seuil d'entrée dans le chemin rapide est plus élevé. Petites différences, mais elles comptent si vous écrivez des règles de détection.
Première tentative échouée : « Java est sûr en mémoire »
La première réaction, dans les canaux Slack des équipes d'ingénierie, quand la nouvelle est tombée, a été l'incrédulité. Une corruption mémoire, en Java ? La sécurité mémoire n'est-elle pas tout l'intérêt du langage ? Cette intuition — le runtime est une forteresse et seul le code applicatif peut vous trahir — constitue le premier modèle erroné. Il vaut la peine de l'examiner, car il influence la façon dont les équipes auditent leur propre pile.
Java, le langage, vérifie chaque accès à un tableau et gère chaque allocation. Mais le runtime Java est un immense corps de code C, C++ et assembleur. Les compilateurs JIT, les ramasse-miettes, les intrinsèques, le code des images natives — tout cela s'exécute avec la pleine puissance non médiatisée du processus, sans bénéficier des garanties qu'il offre à votre bytecode. Chaque intrinsèque est un petit trou percé dans le mur de sécurité au nom de la performance, et ces trous sont entretenus par une poignée d'ingénieurs de la VM. C'est la même leçon structurelle que le bug vieux de dix ans de l'astérisque SSH d'Alpine Linux : les défauts les plus effrayants vivent dans le code dont tout le monde dépend et que presque personne ne lit.
Il y a un angle mort d'audit de sécurité que je constate constamment. Les équipes fuzzent leurs propres parseurs JSON, testent leurs handlers REST et passent l'analyse statique sur chaque ligne qu'elles ont écrite — puis traitent le JDK comme une boîte noire, parce qu'il est mature, largement déployé et maintenu par des gens compétents. La maturité n'est pas une défense. C'est souvent l'inverse : des décennies d'optimisations accumulées, chacune raisonnable à l'époque, chacune ajoutant une surface d'attaque livrée à tout le monde, qu'on en profite ou non. L'intrinsèque AVX-512 de Base64 existe pour accélérer les applications qui décodent d'énormes volumes de données. Votre API REST qui décode un en-tête d'authentification de 200 octets hérite du risque et ne reçoit pratiquement aucun gain. Calif appelle cela la tragédie des biens communs, et ils ont raison : tous ceux qui avaient besoin de la fonctionnalité en ont profité, et tous les autres ont simplement hérité du bug.
Deuxième tentative échouée : « L'écriture est trop contrainte pour être exploitée »
Le deuxième modèle erroné venait de personnes qui ont lu les détails techniques et se sont détendues. Une écriture d'une valeur constante, à un décalage fixe, sans contrôle sur les octets écrits ? Beaucoup de bugs de ce type sont classés « crash seulement » et déprioritisés. Ce rejet est compréhensible mais erroné, et la raison de cette erreur est la partie la plus instructive de toute cette affaire.
L'exploitation moderne ne porte pas sur ce qu'une seule primitive peut faire, mais sur ce que le système environnant peut être amené à disposer autour d'elle. La technique de Calif est le « heap grooming » : façonner à distance le comportement de l'allocateur pour qu'un objet prévisible et utile se retrouve juste derrière le tampon débordé. Ils l'ont fait à travers le réseau, en utilisant le timing des requêtes pour contrôler le moment des allocations et libérations sur la cible. L'écriture peut avoir une valeur constante, mais si vous contrôlez l'objet placé dans la zone d'impact, vous contrôlez ce qui sera corrompu. À partir de là, ils ont construit une fuite mémoire de type Heartbleed, extrait assez d'informations pour contourner l'ASLR, et enchaîné jusqu'à une exécution de code à distance complète.

Il y a un détail délicieusement pragmatique dans le compte rendu sur la manière de rendre cela possible sur l'internet réel. Le heap grooming à distance est sensible au temps aller-retour et à la gigue : il faut que les requêtes arrivent selon un rythme précis pour que l'allocateur se trouve dans l'état voulu. Plutôt que de faire de la rétro-ingénierie de la pile TCP, les chercheurs ont loué une VM dans la même région cloud que leur cible. Ils ont résolu un problème de physique avec de l'argent. J'ai vu des développeurs d'exploits d'élite faire des versions de cela pendant des années, et c'est un bon rappel que les contraintes de l'attaquant sont autant économiques que techniques. Un adversaire bien doté traite la gigue réseau comme une ligne budgétaire.
Notons aussi qu'il n'existe pas d'exploit universel. Chaque application — Jira, Jenkins, Keycloak — utilise Base64 différemment, alloue différemment, expose des surfaces de grooming différentes. C'est la bonne nouvelle. La mauvaise, c'est l'ampleur des points d'entrée. Les en-têtes d'authentification, les champs d'envoi de fichiers, la gestion des certificats clients, les charges utiles de messages — partout où du texte Base64 entre dans la JVM est un déclencheur potentiel. Un contributeur a même démontré une variante côté client : une application Java qui ouvre une connexion TLS vers un serveur malveillant peut être compromise sans qu'aucun service ne soit exposé. Vos tâches batch et vos outils internes sont concernés, pas seulement vos passerelles exposées sur internet.
Le centaure dans la pièce : l'IA a trouvé ce bug en une heure
Voici la partie qui devrait recalibrer le modèle de menace de chaque équipe de sécurité. Le chercheur Quang Luong a trouvé la vulnérabilité en une heure environ, et disposait d'un exploit fonctionnel environ deux heures plus tard. Coût total en jetons d'IA : moins de 200 dollars. Sa méthode consistait à diriger un agent de programmation IA vers les zones de HotSpot où la complexité traverse les frontières — le JIT, les intrinsèques, les API largement accessibles, la cryptographie — puis à filtrer le bruit. La plupart de ce que l'agent a remonté était du bruit inatteignable. Il a continué à le solliciter, et vingt minutes de persévérance plus tard, la faille Base64 est apparue.
Calif parle de « hacker centaure » : l'humain apporte l'intuition sur les endroits où les systèmes complexes déraillent, l'IA apporte l'endurance. Je pense que c'est juste, et que les implications vont dans les deux sens. La même boucle qui a trouvé Java4Shell est accessible à quiconque possède une clé API, et la phase de développement de l'exploit — construire des pipelines de grooming réutilisables, puis laisser les agents produire des chaînes spécifiques à chaque application — devient de plus en plus automatisable. L'économie de la recherche de bugs dans le C et l'assembleur des logiciels matures et largement déployés vient de s'effondrer. Les défenseurs doivent supposer que la prochaine douzaine de bugs de la classe Java4Shell sont déjà recherchés, par des personnes qui ne déposent aucun signalement. C'est la pression derrière des débats comme la réduction des délais de divulgation de Project Zero : quand la découverte devient bon marché, la fenêtre de correction est tout le jeu.
La contre-mesure proposée par Calif est provocante et je l'approuve en grande partie : utiliser le même levier d'IA pour supprimer du code plutôt que d'en ajouter. Ils appellent cela le « vibe-uncoding » : auditer une base de code pour y trouver des fonctionnalités mortes, un support de protocoles anciens et des optimisations inutiles, puis les arracher pour réduire la surface d'attaque. L'objection honnête est que la suppression est risquée : des fonctionnalités apparemment inutilisées ont des dépendances cachées, et la suppression demande des tests que les équipes sous-financent chroniquement. Mais la direction est la bonne. Si votre JDK embarque un chemin rapide en assembleur écrit à la main pour une charge de travail que vous n'aurez jamais, la posture de sécurité optimale est de ne pas livrer ce chemin du tout. À défaut, la JVM vous offre au moins un interrupteur pour le désactiver. Ce qui nous amène à ce qui fonctionne vraiment.
Ce qui fonctionne vraiment : corriger, désactiver, protéger par proxy
Voici la partie qui intéresse votre astreinte. Les correctifs se répartissent en trois niveaux, et je soutiens que vous devriez en appliquer au moins deux dès aujourd'hui, et non après la prochaine fenêtre de changement.
- Passez à une version corrigée d'OpenJDK. Le correctif en amont (commit JDK 5177a70) corrige le calcul du masque. C'est le seul correctif complet. Les versions concernées commencent à 17.0.6 sur la branche 17 et continuent jusqu'aux versions actuelles de la 21 et au-delà ; vérifiez la liste des versions corrigées pour votre branche précise, et considérez chaque JVM HotSpot — OpenJDK, Oracle JDK, GraalVM — comme concernée tant que ce n'est pas vérifié.
- Désactivez l'intrinsèque comme mesure provisoire. Démarrez la JVM avec
-XX:-UseBASE64Intrinsicspour désactiver entièrement le Base64 accéléré par le matériel. Le coût en performance est négligeable, sauf si vous décodez des gigaoctets de Base64, ce que presque personne ne fait. Autrement,-XX:UseAVX=2désactive AVX-512 sur x86-64 — mais ne définissez pas ce drapeau sur ARM, où la JVM refusera de démarrer. C'est la même philosophie que la méthode de gestion des CVE PHP : quand le composant vulnérable est un chemin rapide étroit et remplaçable, couper le chemin rapide vaut mieux que d'attendre. - Utilisez vos proxys pour casser le timing de l'exploit. La section des limitations de Calif indique que les profils actuels de grooming à distance reposent sur des corps de requêtes partiels qui atteignent l'application avec un timing précis. Un reverse proxy qui met en tampon le corps complet de la requête — ce que nginx fait par défaut — détruit ce timing. Ce n'est absolument pas un correctif, mais cela dégrade sensiblement la voie d'attaque la plus pratique pendant que vous corrigez.
La détection mérite aussi une phrase. Semgrep a publié des scripts gratuits qui vérifient la conjonction des conditions rendant un hôte exploitable : une VM de la famille HotSpot, un matériel x86-64 avec le support des instructions concernées, et une version dans la plage vulnérable. Lancez-les sur votre parc avant de supposer que vous êtes exposé — vos conteneurs ARM et vos traînards OpenJ9 sont en sécurité, et le savoir rapidement vous évite un week-end gâché. Lors du scan, gardez en tête que les lignes de version comptent : le correctif est arrivé dans des versions de patch précises selon chaque branche, donc « on est en 21 » n'est pas une réponse.

La leçon de fond : les optimisations sont des passifs que vous n'avez pas audités
Prenez du recul par rapport à la gestion de l'incident, et Java4Shell laisse un goût désagréable. Le bug ne se trouvait pas dans un coin obscur. Il était dans Base64 — sans doute l'opération la plus ennuyeuse, la plus omniprésente, celle où l'on se dit « ça doit être bon depuis longtemps ». La vulnérabilité existait précisément parce que quelqu'un a rendu cette chose ennuyeuse rapide, en utilisant les instructions vectorielles les plus récentes, en assembleur, avec un cas limite de traitement de queue qui a survécu à la revue de code. Chaque runtime mature en est rempli. Et chacun de ces bugs est désormais traqué par des agents infatigables dont le coût est inférieur à un bon dîner.
Tout le monde se demande ce que l'IA peut construire. La meilleure question de sécurité est peut-être ce qu'elle peut nous aider à supprimer.
Mon avis : l'industrie est sur le point d'apprendre la différence entre du code audité et du code supposé sûr, et le coût de cette leçon sera élevé. Bibliothèques standard, intrinsèques de VM, codecs de compression, décodeurs d'images — les couches fondamentales que nous ne remettons jamais en question sont précisément là où l'attention humaine est la plus rare et où la recherche assistée par IA rapporte les plus gros bounties. Le modèle centaure ne fait pas seulement trouver les bugs plus vite ; il les trouve là où les chercheurs humains n'ont pas regardé, parce que la valeur attendue de l'audit de code « résolu » semblait trop faible.
Alors corrigez vos JVM, activez le drapeau de l'intrinsèque là où vous ne pouvez pas faire autrement, et laissez nginx vous acheter du temps. Mais allez aussi examiner votre propre arbre de dépendances et posez-vous la question de la suppression : lesquelles de ces fonctionnalités avons-nous héritées plutôt que choisies ? La chaîne de 65 caractères qui va gâcher votre week-end est probablement déjà écrite. La seule question est de savoir si la personne qui la détient dépose un signalement ou non.


