Una tarjeta de título generada que dice 'Java4Shell' con el subtítulo 'CVE-2026-114938: 65 bytes de entrada, 62 bytes escritos más allá del final', un aviso que dice 'búfer de 50 bytes', y tres chips que dicen 'OpenJDK 17.0.6+', 'solo x86-64 AVX-512' y 'Parcheado el 17 nov 2026'.
Guides & Insights

Java4Shell: 65 bytes de Base64, una asignación de 50 bytes y 62 bytes escritos más allá de su final

Autor

jinhao.song

Fecha de publicación

Últimos modelos · 20Ver todos los modelos →
Benchmarks: Artificial Analysis · actualizado a diario
Volver a todas las publicaciones

Tiene 65 bytes de longitud: 64 letras A mayúsculas y un único signo igual. OpenJDK lo decodifica en un búfer que dimensiona en 50 bytes, y luego el intrínseco Base64 de HotSpot escribe 64 bytes, comenzando en el desplazamiento 48. Sesenta y dos de ellos acaban en el heap, fuera del array al que estaban destinados, en un lenguaje cuya promesa central es que esto no puede ocurrirte. Calif publicó la cadena el 17 de noviembre de 2026 como Java4Shell, registrada como CVE-2026-114938, y OpenJDK y Oracle lanzaron las correcciones esa misma tarde. El hallazgo se está reportando como asistido por IA; el modelo específico nombrado en la cobertura es GPT-6 Cyber, el modelo de OpenAI ajustado para seguridad lanzado el 5 de noviembre de 2026. Esa atribución es la parte más interesante y menos esclarecida de la historia, y conviene mantenerla separada del fallo, que está confirmado y es grave.

En qué se equivocó lo intrínseco

Java es seguro para la memoria a nivel del lenguaje y no al nivel que importaba aquí. HotSpot acelera Base64 con ensamblador x86-64 escrito a mano, porque el Java compilado ordinario no es lo suficientemente rápido para la única carga de trabajo en la que el rendimiento de decodificación es el cuello de botella. La rutina procesa la entrada en bloques de 256 bytes, recurre a bloques de 64 bytes y, para colas de menos de 64 bytes, usa evmovdqub —la forma AVX-512 de VMOVDQU8— con una máscara de escritura de 64 bits que decide cuáles de los 64 bytes del registro vectorial llegan realmente a la memoria.

Esa máscara se construye a partir de las longitudes de entrada y salida, y luego se ajusta para el relleno de Base64. La explicación recorre la aritmética: la longitud de salida es (input_length / 4) * 3, luego se decrementa una vez por un = final y una vez más por un segundo. Para las colas de relleno =, ==, X=, X==, XY= y ===, la longitud decodificada es cero, y el ajuste de relleno resta desde cero. El valor se subdesborda a -1 o -2. El cálculo de la máscara no lo limita, así que la máscara se convierte en todo unos y se escriben los 64 bytes.

El búfer se dimensionó de forma honesta. La asignación en tiempo de ejecución para una entrada de 65 bytes es (ceil(65 / 4) * 3) - 1, que son 50 bytes. El derrame comienza en el desplazamiento 48 —la posición a la que habrían ido los bytes decodificados finales—, por lo que se sobrescriben 62 bytes del heap vecino. Los bytes 48 a 63 de ese derrame siempre son 0x9a. Solo los dos primeros bytes llevan control del atacante, y solo parcialmente. El decodificador sigue rechazando la entrada y Java sigue lanzando IllegalArgumentException. La escritura ocurre antes del rechazo. En OpenJDK 17, el umbral para alcanzar la ruta de código afectada es más alto, por lo que el desencadenante publicado allí son 128 A más el signo igual.

Una escritura fija de 62 bytes de datos mayormente constantes no suena como una primitiva de ejecución remota de código, y por sí sola no lo es. Lo que Calif construyó es una cadena:

• Primero, organiza el montículo para que el derrame caiga sobre el campo de longitud de un arreglo adyacente. Ese arreglo se convierte en un escritor cuya longitud declarada ahora es mucho mayor que su contenido, lo que transforma la escritura fija en una escritura acotada de un valor elegido.

• En segundo lugar, corrompe la longitud de un segundo array cuyos datos se copian de vuelta en la respuesta HTTP. Ese array es un lector, y el contenido del heap que devuelve se convierte en la primitiva de divulgación. Calif denomina a la etapa previa a la ejecución de código de esto JavaBleed: memoria del heap que puede contener datos de identificación personal, claves privadas, tokens de sesión u otros secretos.

• En tercer lugar, repare los objetos que la escritura lineal dañó para que la JVM siga ejecutándose, use los originales divulgados para restaurar las cabeceras y los vecinos, y escale la escritura acotada a escrituras arbitrarias que alcancen la Code Cache y los hooks de la JVM.

• En cuarto lugar, realice el cambio específico de la aplicación y verifíquelo mediante una solicitud en vivo. El documento se detiene antes de ese último paso para productos individuales y afirma que las cadenas armadas permanecen privadas hasta que los usuarios hayan tenido la oportunidad de actualizar.

La capa de grooming es la parte que hace que esto sea remoto en lugar de local. G1 divide el heap en regiones fijas, HotSpot le entrega a cada hilo un búfer de asignación privado, y el atacante no puede ver nada de eso. La respuesta de Calif es la de siempre —hacer spray con pares de escritor y lector hasta que la salida del decodificador quede junto a uno— más un truco específico de HTTP: enviar el cuerpo de la solicitud hasta el punto en que ocurre la asignación crítica, esperar el acuse de recibo TCP y luego enviar el resto. Los paquetes pequeños son más estables que uno grande, lo que da tanto control de asignación como control de temporización. El ataque es sensible al tiempo de ida y vuelta y al jitter; en su entorno de pruebas lo resolvieron alquilando una VM en la misma región que el objetivo en lugar de ajustar una pila TCP.

Serio, y más limitado de lo que el nombre sugiere

Dos restricciones reducen la exposición drásticamente, y vale la pena enunciar ambas antes de que alguien abra un puente de incidentes.

Lo primero es la versión. Java4Shell afecta a OpenJDK 17.0.6 y posteriores y, por lo tanto, a todas las distribuciones construidas a partir de él: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE y Oracle GraalVM for JDK. La lista de compilaciones de Java SE afectadas de Oracle es 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3 y 27.0.1.0.3. Cualquier versión anterior a 17.0.6 en la línea de OpenJDK queda fuera de la ruta de código afectada.

El segundo es silicio. La rutina vulnerable está en ensamblador AVX-512 VBMI, por lo que solo existe en chips x86-64 que implementan esas instrucciones. ARM64 no se ve afectado en absoluto, lo que elimina de la población, en una sola línea, todas las implementaciones de Graviton, Ampere y Apple Silicon. Del lado de Intel, la lista es Xeon Ice Lake, Sapphire Rapids, Emerald Rapids y Granite Rapids; del lado de AMD, EPYC y Ryzen desde Zen 4 en adelante. Calif publica la comprobación:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

Deben aparecer las cuatro flags. Es una reducción real del alcance, pero los chips afectados son exactamente los que llenaron las flotas en la nube entre 2021 y 2025, así que «requiere Sapphire Rapids» no es la tranquilidad que parece. Un servicio Java en Graviton está a salvo. El mismo servicio en una instancia Intel de generación actual está dentro del alcance, y también lo está la instancia de Jira, Confluence, Keycloak, Jenkins, Artifactory o PingFederate que se encuentre detrás, porque Calif demostró RCE de preautenticación en la configuración predeterminada de cada una.

La lista de impactos demostrados se divide claramente. Antes de la autenticación: Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins y PingFederate. Después de la autenticación: Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit y Netflix Spinnaker. También se explotaron aplicaciones de muestra de Apache Struts y Spring Boot. Las listas son explícitamente no exhaustivas, y un detalle importa más que los nombres de los productos: una JVM vulnerable no tiene que exponer un servicio propio. El investigador samczsun compartió con Calif una cadena del lado del cliente en la que un programa Java que simplemente abre una conexión TLS a un servidor malicioso queda comprometido por la respuesta.

A generated summary card headed 'Java4Shell — what is in scope', listing six rows: affected OpenJDK 17.0.6 and later; silicon x86-64 with AVX-512 VBMI; not affected ARM64, Graviton and Apple silicon; pre-authentication impact on Keycloak, Jira, Confluence, Artifactory and Jenkins; authentication required for Kafka, Solr, Elasticsearch and Gerrit; and no public report of exploitation in the wild.

Patch, y las dos banderas que compran tiempo

OpenJDK publicó su aviso el 17 de noviembre de 2026 y Oracle lanzó su Critical Patch Update a la 1:00 p. m. PT del mismo día, con 11 nuevos parches de Java SE. Oracle atribuye el CVE-2026-114938 a Quang Luong, de Calif.io, y a Albert Yang. La corrección en la línea principal de OpenJDK es pequeña: una guarda de cuatro líneas que dirige una cola Base64 con relleno más corta que un bloque completo al controlador de Java en lugar de a la rutina optimizada. Esa es la forma del error en una frase: una optimización para aplicaciones que decodifican volúmenes enormes de datos se distribuyó a todos los entornos de ejecución y expuso a aplicaciones que no obtenían ningún beneficio de ella.

Hasta que se aplique la actualización, dos flags de la JVM desactivan los intrinsics:

• -XX:-UseBASE64Intrinsics desactiva la codificación y decodificación Base64 aceleradas por hardware. Esta es la más segura de las dos, ya que es independiente de la arquitectura.

• -XX:UseAVX=2 desactiva AVX-512. Solo funciona en x86-64: OpenJDK en ARM no reconoce la opción y se negará a arrancar, por lo que un parque que mezcla arquitecturas no puede aplicarla de forma generalizada.

Ninguna de las dos flags es una solución, y ambas reducen el throughput precisamente en las cargas de trabajo que hicieron que valiera la pena escribir el intrinsic. Lo útil que hay que señalar es que ninguna requiere volver a desplegar el código de la aplicación, que es la diferencia entre una mitigación que puedes ejecutar esta noche y una que no.

La cobertura de los días 17 y 18 de noviembre fue inusualmente amplia para un error de tiempo de ejecución: The New York Times lo publicó bajo el titular «La IA ayuda a encontrar un importante fallo de seguridad en Java, una plataforma de software vital para internet», la BBC y Politico lo cubrieron, la oficina federal de ciberseguridad de Alemania emitió un aviso y se informó que las directrices de CISA instaban a aplicar los parches de inmediato y señalaban que la falla no estaba en su lista Known Exploited Vulnerabilities. Esa última distinción es la que hay que retener. Una cobertura amplia no es evidencia de explotación y, en el momento de escribir esto, no hay ningún informe público de que Java4Shell se haya utilizado en entornos reales.

El crédito del modelo, y lo que dice y no dice

Aquí es donde la historia exige cuidado, porque la versión que circula es más limpia que el registro.

El propio informe de Calif no menciona GPT-6 Cyber. Dice que las áreas a auditar fueron elegidas por una persona y luego entregadas: «Le dije a Codex que examinara esas áreas como cualquier investigador de seguridad serio en 2026». Codex es el agente de programación de OpenAI, y se puede dirigir a distintos modelos subyacentes, así que un investigador que ejecutara Codex con GPT-6 Cyber seleccionado produciría exactamente esa frase. Pero el informe nunca dice qué modelo estaba detrás, y nunca indica un costo ni un recuento de tokens. Las cifras que se han repetido —aproximadamente una hora hasta el descubrimiento, dos horas hasta un exploit funcional y menos de 200 dólares en tokens— proceden de la cobertura informativa sobre la revelación, no del documento de Calif.

A screenshot of the Calif write-up titled 'Java4Shell: A case study in AI-assisted vulnerability discovery and exploitation', bylined 'Calif and OpenAI — November 17, 2026'. The visible text refers to directing Codex at chosen areas of the codebase and does not name a specific underlying model.

El nombre del modelo proviene del mismo lugar. La cobertura publicada el 17 y 18 de noviembre atribuye el descubrimiento específicamente a GPT-6 Cyber, y el enfoque del New York Times es el más amplio de «la IA ayudó». OpenAI no ha publicado, a 18 de noviembre, su propio relato del hallazgo. Sus dos publicaciones más recientes sobre ciberseguridad —la actualización sobre la OTAN del 17 de noviembre y la asociación con Cogent del 10 de noviembre— no mencionan Java. Así que la afirmación honesta es: el descubrimiento asistido por IA está confirmado por el propio informe del investigador, el modelo específico se reporta en lugar de documentarse, y las cifras de eficiencia son de segunda mano.

Esa brecha no disminuye el resultado. Cambia lo que puede inferirse de él. Un descubrimiento en una hora en un entorno de ejecución de 30 años es una afirmación sobre el coste de búsqueda, y la única parte que puede corroborarla es la que tiene los registros de facturación. Hasta que una de ellas los publique, la versión defendible es que una pequeña empresa dirigió un agente hacia una base de código madura y volvió con un error crítico de corrupción de memoria en una región —ensamblador escrito a mano dentro del JIT— con la que tanto la revisión de código como el fuzzing han tenido dificultades durante años.

La mitad del informe dedicada al desarrollo de exploits es más interesante que la mitad del descubrimiento, y también es más claramente humana. Calif describe cómo el agente se quedaba atascado en primitivas de heap grooming, y cómo la solución fue un trazador y visualizador de heap que el equipo escribió para que el agente pudiera ver el estado del heap. Esa es una división del trabajo que vale la pena nombrar: el modelo amplió la búsqueda, y las personas construyeron la instrumentación que convirtió un hallazgo en una cadena.

Patch the Planet es el marco, no el trámite.

La divulgación de Java4Shell se está describiendo como parte de Patch the Planet, la iniciativa Daybreak de OpenAI para apoyar a los mantenedores de código abierto, llevada a cabo con Trail of Bits. El programa es real y Calif figura como socio nombrado en él: la propia descripción de Patch the Planet dice que OpenAI se está "asociando con HackerOne y Calif, que nos están ayudando a llevar nuestros esfuerzos más lejos con el triaje de vulnerabilidades, la divulgación coordinada y esfuerzos adicionales de descubrimiento focalizado de vulnerabilidades". Así que la vía de coordinación es exactamente la que describe la iniciativa.

Lo que todavía no existe es la presentación. El sitio de Patch the Planet enumera actualmente dos divulgaciones: CVE-2026-111497 en Brotli, y CVE-2026-109618 y CVE-2026-109619, las vulnerabilidades de PHP conocidas como php2shell. Java4Shell no está entre ellas. La propia publicación de OpenAI en Patch the Planet del 21 de octubre describe la respuesta de PHP —y nombra el modelo que la encontró, que fue GPT-5.6 Sol, no GPT-6 Cyber. El primer bug destacado del programa se encontró con el predecesor.

A screenshot of the patchtheplanet.org homepage, headed 'Working with frontier AI and security experts to help secure open source software'. It shows the five-stage response framework and a 'Patch the Planet Disclosures' section listing only the Brotli and PHP (php2shell) disclosures — Java4Shell is not listed.

Eso no es una contradicción; es un hecho de secuenciación, y es relevante para cualquiera que lea la cobertura como una afirmación de capacidad sobre un solo modelo. Patch the Planet es un marco de coordinación con socios identificados y una respuesta publicada de cinco etapas —validar y corregir en upstream, dar tiempo a las organizaciones afectadas, coordinar con el gobierno, preparar actualizaciones en todos los productos y publicar orientación. Java4Shell recorrió las partes de ese marco que conciernen a un único upstream: OpenJDK y Oracle parchearon el día de la divulgación, y Calif retuvo las cadenas específicas de producto. Lo que falta es la publicación de OpenAI que dejaría constancia del hallazgo dentro del programa.

Cuánto cuesta ejecutar una búsqueda como esta

La economía es la parte sobre la que un defensor puede actuar realmente, e invierte la intuición que traen la mayoría de los equipos. Si las cifras reportadas se sostienen, el descubrimiento costó unos cientos de dólares y el exploit otras dos horas de lo mismo. La parte cara de la operación nunca fue la inferencia.

Eso es coherente con lo que OpenAI publicó sobre su propio escaneo del kernel de Linux quince días antes del lanzamiento de Cyber: 2.308 candidatos, 1.724 reproducidos, 948 exploits únicos de escalada de privilegios, $1.213.430 en créditos de API y 61 correcciones en el upstream diez días después. Encontrar es barato en comparación con corregir, y la restricción está en el triaje y la divulgación, no en la factura de tokens. Un equipo que presupueste este tipo de trabajo debería presupuestar la revisión humana en varias veces el gasto en modelos.

También es donde una capa de enrutamiento se gana su lugar en lugar de ser un eslogan. El pipeline tiene etapas con requisitos de modelo genuinamente diferentes: la generación de hipótesis quiere la búsqueda más amplia y económica que puedas permitirte; la validación quiere un modelo que pueda ejecutar y leer un crash; la generación de parches quiere contexto largo sobre un repositorio. Ejecutar las tres en un solo modelo significa pagar la tarifa de la etapa más cara por el trabajo de la etapa más barata. Dirigir cada etapa a un modelo diferente a través de una única clave de API para más de 200 modelos, al precio de lista del proveedor con 0 % de margen, mantiene el pipeline en una sola factura y una sola credencial en lugar de tres contratos.

Una cosa que debe quedar clara: GPT-6 Cyber no está en el catálogo de OrcaRouter, y no podrá estarlo hasta que exista una aprobación de Daybreak Red para la cuenta que lo invoque. Lo que sí ofrecemos es la escalera general de la que se derivó — GPT-6 Astra a $10/$50 por millón de tokens, entre otras — que es la parte de un pipeline de seguridad que se encarga del triaje, la generación de parches y la revisión de código en lugar del desarrollo de exploits. La conmutación automática por error importa sobre todo justo en la etapa en la que un modelo es nuevo y sus límites de velocidad son desconocidos, lo que describe la etapa de descubrimiento de un pipeline como este.

Qué ver

Tres cosas decidirán cómo se lee esto dentro de seis meses.

Lo primero es si las cadenas retenidas aparecen en la naturaleza antes de que aparezcan en un artículo. La decisión de Calif de publicar la vulnerabilidad y la técnica general pero retener los exploits específicos de cada producto es la versión responsable de la divulgación, y solo funciona si la tasa de parcheo supera la tasa de ingeniería inversa. La actualización de Oracle ya está disponible; la población de compilaciones 17.0.x sin parchear es la variable.

El segundo es si Java4Shell llega a la lista de Vulnerabilidades Explotadas Conocidas de la CISA. Ahora mismo no está ahí, y la brecha entre «crítico» y «explotado» es donde se producen la mayoría de los debates de priorización en las empresas.

El tercero es si OpenAI hace constar su propia versión. Un informe técnico que nombre el modelo, los prompts y el coste convertiría una afirmación reportada en una documentada, y sería la primera evidencia pública de lo que hace un modelo de clase Cyber sobre un objetivo que nadie eligió de antemano para él. Hasta entonces, el fallo es el hecho y la atribución es la historia.

Comparados en este artículo2

Detectado en este artículo · Benchmarks: Artificial Analysis · actualizado a diario