Java4Shell: 65 bytes en OpenJDK bastan para ejecutar código
Java4Shell es un fallo de corrupción de memoria en el decodificador Base64 AVX-512 de OpenJDK. Cómo 65 bytes provocan RCE y cómo mitigarlo ya.

Sesenta y cuatro letras A y un signo igual. Es todo lo necesario para corromper el heap de un servidor OpenJDK sin parchear: una cadena Base64 de 65 caracteres que se salta la famosa seguridad de memoria de Java y escribe 62 bytes más allá del final de un array. La vulnerabilidad, revelada por la firma de seguridad Calif como Java4Shell (CVE-2026-114938, CVSS 9.2), no está en el código de la aplicación sino en ensamblador hecho a mano, escondido dentro del decodificador Base64 de la JVM. Se demostró ejecución remota de código sin autenticación contra Keycloak, Jenkins, Jira, Confluence, Artifactory y PingFederate. Si tu organización ejecuta Java en servidores x86-64 —y estadísticamente, la tiene— este problema es tuyo.
Me dedico a cubrir vulnerabilidades, y la mayoría se parecen entre sí: otro fallo de deserialización, otro bypass de autenticación, otro path traversal. Java4Shell es distinto, y no por la puntuación. Es distinto por dónde vive. El fallo está en una optimización —una aceleración para decodificar Base64 con instrucciones vectoriales AVX-512— que casi ninguna aplicación del mundo necesita de verdad. La historia de cómo se encontró, cómo se explotó y por qué tus proxies quizá ya te están salvando dice mucho sobre hacia dónde va la seguridad del software.
El problema: un intrínseco JIT con una máscara rota
Para entender el bug, hay que saber cómo OpenJDK hace rápido el Base64. La JVM HotSpot vigila qué métodos se ejecutan con más frecuencia y deja que su compilador C2 los convierta en código nativo. Para ciertas operaciones va más allá: sustituye por rutinas de ensamblador afinadas a mano, llamadas intrínsecos, que usan instrucciones especializadas de la CPU. En procesadores x86-64 con soporte AVX-512 VBMI, la decodificación Base64 recibe exactamente este tratamiento: el intrínseco procesa la entrada en bloques de 256 o 64 bytes, usando la instrucción VMOVDQU8 con una máscara de 64 bits que decide qué bytes se escriben en el buffer de destino.
El fallo está en cómo se calcula esa máscara para la cola con relleno de la entrada. Base64 rellena su salida con caracteres =, y el ensamblador reduce la longitud de salida por cada byte de relleno que encuentra. Para ciertas entradas malformadas —un único = al final de un bloque, por ejemplo— la longitud calculada desborda hacia -1 o -2. Ese valor negativo pasa a una instrucción de manipulación de bits (bzhiq) que, para entradas de 64 o más, deja la máscara sin cambios: los 64 bits activados. Todos los bits activados significan que se escribe cada byte.
Veamos el disparador concreto. Envías 64 letras A seguidas de =, 65 caracteres en total. La JVM calcula que la longitud decodificada es de 50 bytes y reserva un array de 50 bytes. El intrínseco decodifica bien los primeros 64 caracteres, luego llega al signo igual suelto, la longitud se desborda, la máscara queda completa y lanza una escritura vectorizada de 64 bytes que empieza cerca del final del buffer de 50. Sesenta y dos bytes de objetos vecinos del heap quedan pisados con datos constantes influenciables por el atacante. La validación propia de Java acaba notando que la entrada no es válida y lanza IllegalArgumentException, pero para entonces el daño ya está hecho. El manejador de excepciones está fregando el suelo mientras la casa ya arde.
// 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 detalle importa para tu triaje: esto solo se ejecuta en hosts x86-64 cuyas CPU soportan AVX-512 VBMI. Los servidores ARM como AWS Graviton nunca ejecutan el stub vulnerable, y tampoco los Xeon más antiguos. La ruta de código vulnerable además solo aparece en JVM basadas en HotSpot: OpenJDK, Oracle JDK, GraalVM. OpenJ9 y Azul Prime, que usan arquitecturas JIT distintas, no están afectadas. En OpenJDK 17, por cierto, el disparador son 128 letras A más = en lugar de 64, porque el umbral para entrar en la ruta rápida es más alto. Son diferencias pequeñas, pero importan si estás escribiendo reglas de detección.
Primer intento fallido: «Java es seguro en memoria»
La primera reacción en los canales de Slack de ingeniería cuando salió la noticia fue incredulidad. ¿Corrupción de memoria, en Java? ¿Para eso no está precisamente la seguridad de memoria? Esta intuición —que el runtime es una fortaleza y solo el código de aplicación puede traicionarte— es el primer modelo fallido, y merece examinarse porque condiciona cómo los equipos auditan sus propias pilas.
Java, como lenguaje, comprueba cada acceso a array y gestiona cada asignación. Pero Java como runtime es un enorme cuerpo de C, C++ y ensamblador. Los compiladores JIT, los recolectores de basura, los intrínsecos, el código de native image: todo se ejecuta con el poder completo y sin mediación del proceso, y ninguno disfruta de las garantías que ofrece a tu bytecode. Cada intrínseco es un pequeño agujero abierto en la muralla de seguridad en nombre de la velocidad, y esos agujeros los mantiene un puñado de ingenieros de VM. Es la misma lección estructural que el bug de asteriscos en SSH de Alpine Linux, de hace una década: los defectos más aterradores viven en código del que todos dependen y que casi nadie lee.
Aquí hay un punto ciego de auditoría que veo constantemente. Los equipos hacen fuzzing de sus propios parsers JSON, pentestean sus handlers REST y pasan análisis estático por cada línea que escribieron, y luego tratan el JDK como una caja negra porque es maduro, muy desplegado y lo mantienen personas listas. La madurez no es una defensa. Suele ser lo contrario: décadas de optimizaciones acumuladas, cada una sensata en su momento, cada una añadiendo superficie de ataque que llega a todo el mundo, lo necesiten o no. El intrínseco AVX-512 de Base64 existe para acelerar aplicaciones que decodifican enormes volúmenes de datos. Tu API REST que decodifica una cabecera de autenticación de 200 bytes hereda el riesgo y casi no recibe nada de la recompensa. Calif lo llama la tragedia de los comunes, y tienen razón: los que necesitaban la función obtuvieron el beneficio, y todos los demás solo obtuvieron el bug.
Segundo intento fallido: «La escritura es demasiado limitada para explotarla»
El segundo modelo fallido vino de gente que leyó los detalles técnicos y se relajó. ¿Una sobrescritura de valor constante, en un offset fijo, sin control sobre los bytes escritos? Muchos bugs así se archivan como «solo caídas» y se deprioritizan. Ese descarte es comprensible y equivocado, y la razón por la que es equivocado es la parte más instructiva de todo este episodio.
La explotación moderna no trata de lo que puede hacer una sola primitiva, sino de lo que el sistema que la rodea puede llegar a colocar alrededor de ella. La técnica de Calif fue el heap grooming: moldear remotamente el comportamiento del asignador para que un objeto predecible y útil caiga justo detrás del buffer desbordado. Lo hicieron a través de la red, usando el timing de las peticiones para controlar cuándo ocurren las asignaciones y liberaciones en el objetivo. La escritura puede ser de valor constante, pero si controlas qué objeto queda en la zona de impacto, controlas qué se corrompe. A partir de ahí construyeron una filtración de memoria al estilo Heartbleed, filtraron lo suficiente para derrotar ASLR y encadenaron hasta ejecución remota de código completa.

En el write-up hay un detalle deliciosamente pragmático sobre cómo lograr que esto funcione por internet real. El heap grooming remoto es sensible al tiempo de ida y vuelta y al jitter: las peticiones tienen que llegar con un ritmo concreto para que el asignador esté en el estado que quieres. En lugar de hacer ingeniería inversa de la pila TCP, los investigadores alquilaron una VM en la misma región de nube que su objetivo. Resolvieron un problema de física con dinero. Llevo años viendo a desarrolladores de exploits de élite hacer versiones de esto, y es un buen recordatorio de que las restricciones del atacante son tanto económicas como técnicas. Un adversario con recursos trata el jitter de red como una partida presupuestaria.
También conviene señalar que no existe un exploit universal. Cada aplicación —Jira, Jenkins, Keycloak— usa Base64 de forma distinta, asigna memoria de forma distinta y expone superficies de grooming diferentes. Esa es la buena noticia. La mala es la enorme variedad de puntos de entrada. Cabeceras de autenticación, campos de subida de archivos, manejo de certificados de cliente, payloads de mensajes: cualquier lugar donde el texto Base64 cruza hacia la JVM es un posible disparador. Un contribuidor incluso demostró una variante del lado cliente: una aplicación Java que abre una conexión TLS a un servidor malicioso puede comprometerse sin exponer ningún servicio. Tus trabajos batch y herramientas internas están en el alcance, no solo tus pasarelas expuestas a internet.
El centauro en la sala: la IA encontró esto en una hora
Ahora viene la parte que debería recalibrar el modelo de amenazas de todos los equipos de seguridad. El investigador Quang Luong encontró la vulnerabilidad en una hora aproximadamente, y tenía un exploit funcional unas dos horas después. Coste total en tokens de IA: menos de 200 dólares. Su método fue apuntar un agente de programación con IA a las zonas de HotSpot donde la complejidad cruza fronteras —el JIT, los intrínsecos, las APIs de amplio alcance, la criptografía— y luego filtrar el ruido. La mayor parte de lo que el agente sacó eran hallazgos inalcanzables. Siguió insistiendo y, veinte minutos de persistencia después, apareció el hallazgo de Base64.
Calif lo plantea como el «hacker centauro»: el humano aporta la intuición sobre dónde fallan los sistemas complejos, la IA aporta la resistencia. Creo que es acertado, y creo que las implicaciones van en ambos sentidos. El mismo bucle que encontró Java4Shell está al alcance de cualquiera con una clave de API, y la fase de desarrollo del exploit —construir pipelines de grooming reutilizables y dejar que los agentes generen cadenas específicas para cada aplicación— es cada vez más automatizable. La economía de encontrar bugs en C y ensamblador maduros y muy desplegados acaba de hundirse. Los defensores deberían asumir que la próxima docena de bugs de la clase Java4Shell ya se está buscando, por gente que no presenta informes de divulgación. Esta es la presión detrás de debates como los plazos de divulgación cada vez más cortos de Project Zero: cuando descubrir se abarata, la ventana para parchear es todo el juego.
La contramedida propuesta por Calif es provocadora y en gran parte la comparto: usar el mismo apalancamiento de IA para eliminar código en lugar de añadirlo. Lo llaman «vibe-uncoding»: auditar una base de código en busca de funciones muertas, soporte de protocolos antiguos y optimizaciones innecesarias, y arrancarlas para reducir la superficie de ataque. La objeción honesta es que borrar es arriesgado: las funciones aparentemente sin uso tienen dependientes ocultos, y la eliminación necesita pruebas que los equipos financian crónicamente mal. Pero la dirección es la correcta. Si tu JDK incluye una ruta rápida en ensamblador hecha a mano para una carga de trabajo que nunca tendrás, la postura de seguridad óptima es no distribuir esa ruta en absoluto. Mientras tanto, la JVM al menos te da un interruptor para apagarla. Lo que nos lleva a lo que realmente funciona.
Lo que realmente funciona: parchear, desactivar, proxificar
Aquí está la parte que tu rotación de guardia necesita. Las soluciones se dividen en tres niveles, y yo diría que deberías aplicar al menos dos de ellas hoy, no después de la próxima ventana de cambios.
- Parchea a una build de OpenJDK corregida. La corrección upstream (commit 5177a70 del JDK) corrige el cálculo de la máscara. Es la única solución completa. Las versiones afectadas empiezan en 17.0.6 en la línea 17 y continúan hasta las versiones actuales de la 21 y posteriores; consulta la lista de versiones corregidas para tu rama concreta y trata cada JVM HotSpot —OpenJDK, Oracle JDK, GraalVM— como afectada hasta verificar lo contrario.
- Desactiva el intrínseco como control provisional. Arranca la JVM con
-XX:-UseBASE64Intrinsicspara desactivar por completo la aceleración de Base64 por hardware. El coste de rendimiento es despreciable a menos que decodifiques gigabytes de Base64, algo que casi nadie hace. Alternativamente,-XX:UseAVX=2desactiva AVX-512 en x86-64, pero no pongas ese flag en ARM, donde la JVM se negará a arrancar. Es la misma filosofía que el manual de CVEs de PHP: cuando el componente vulnerable es una ruta rápida estrecha y reemplazable, matar la ruta rápida gana a esperar. - Usa tus proxies para romper el timing del exploit. La propia sección de limitaciones de Calif indica que los perfiles actuales de grooming remoto dependen de que cuerpos de petición parciales lleguen a la aplicación con un timing preciso. Un reverse proxy que almacena en búfer el cuerpo completo de la petición —cosa que nginx hace por defecto— destruye ese timing. No es en absoluto una solución, pero degrada de forma notable la vía de ataque más práctica mientras parcheas.
La detección también merece una frase. Semgrep publicó scripts gratuitos que comprueban la conjunción de condiciones que hacen explotable a un host: una VM de la familia HotSpot, hardware x86-64 con el soporte de instrucciones relevante y una versión dentro del rango afectado. Ejecútalo en toda tu flota antes de asumir que estás expuesto: tus contenedores basados en ARM y los rezagados con OpenJ9 están bien, y saber eso rápido te ahorra un fin de semana. Al escanear, recuerda que las líneas de versión importan: la corrección llegó en versiones de parche concretas por cada rama, así que «estamos en la 21» no es una respuesta.

La gran lección: las optimizaciones son pasivos que no auditaste
Si te alejas de la respuesta a incidentes, Java4Shell deja un residuo incómodo. El bug no estaba en un rincón oscuro y poco usado. Estaba en Base64: quizá la operación más aburrida, más omnipresente y más «seguro que eso ya está bien» de la computación. La vulnerabilidad existió precisamente porque alguien hizo rápida la parte aburrida, usando las instrucciones vectoriales más nuevas, en ensamblador, con un caso límite en el manejo de la cola que sobrevivió a la revisión de código. Todo runtime maduro está lleno de estos. Y cada uno de ellos ahora está siendo cazado por agentes incansables que cuestan menos que una buena cena.
Todo el mundo pregunta qué puede construir la IA. La mejor pregunta de seguridad quizá sea qué puede ayudarnos a eliminar.
Mi opinión: la industria está a punto de aprender la diferencia entre código auditado y código que se da por seguro, y la matrícula será cara. Las bibliotecas estándar, los intrínsecos de la VM, los códecs de compresión, los decodificadores de imágenes: las capas fundamentales que nunca cuestionamos son exactamente donde la atención humana es más escasa y donde la caza asistida por IA paga las recompensas más altas. El modelo centauro no solo encuentra bugs más rápido; los encuentra en lugares que los investigadores humanos saltaron porque el valor esperado de auditar código «resuelto» parecía demasiado bajo.
Así que parchea tus JVM, activa el flag del intrínseco donde no puedas parchear, y deja que nginx te compre tiempo. Pero ve también a revisar tu propio árbol de dependencias y hazte la pregunta de la desaparición: ¿cuáles de estas funciones heredamos en lugar de elegirlas? La cadena de 65 caracteres que te quemará el fin de semana probablemente ya está escrita. La única duda es si quien la tenga en la mano presentará un informe de divulgación o no.


