DEV Community

Cover image for Java4Shell: RCE crítico en Base64 de OpenJDK
lu1tr0n
lu1tr0n

Posted on Originally published at elsolitario.org

Java4Shell: RCE crítico en Base64 de OpenJDK

Java4Shell: un bug de memoria en el decodificador Base64 de OpenJDK

Con 64 caracteres "A" seguidos de un signo igual como único insumo, un atacante remoto sin usuario ni contraseña puede corromper memoria dentro de la máquina virtual de Java más usada del planeta. Así lo documentó la firma de seguridad Calif al publicar Java4Shell, identificado como CVE-2026-114938, una falla de corrupción de memoria en el decodificador Base64 de OpenJDK (fuente). Bajo CVSS 4.0 la vulnerabilidad anota 9,2 sobre 10, nivel crítico (fuente).

OpenJDK es el runtime de Java más popular y corre en el 90% de las empresas del ranking Fortune 500, según Calif (fuente). Java ocupa el tercer puesto entre los lenguajes de programación más usados del mundo y sostiene bancos, aerolíneas, telecomunicaciones y hasta sistemas de seguridad nacional (fuente). Base64 es la codificación que convierte datos binarios en texto: aparece en protocolos de autenticación, en la subida de archivos y en mensajes de red, así que casi cualquier aplicación Java la usa en algún punto (fuente).

Por qué importa: el radio de explosión alcanza a medio ecosistema Java

El alcance no es teórico. Calif confirmó ejecución remota de código previa a cualquier autenticación en Keycloak, Atlassian Jira y Confluence, JFrog Artifactory, Jenkins y PingFederate, todo en configuración por defecto (fuente). Tras autenticarse, la lista crece con Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit y Spinnaker (fuente). El equipo también reprodujo el fallo en apps de muestra construidas sobre Apache Struts y Spring Boot, lo que sugiere que cualquier endpoint que reciba, autentique o suba archivos codificados en Base64 puede terminar expuesto (fuente).

El investigador samczsun aportó además un exploit del lado cliente: un programa Java que simplemente abre una conexión TLS contra un servidor malicioso puede comprometerse, aunque no exponga ningún servicio propio (fuente).

⚠️ Ojo: Keycloak, Jira, Confluence, Artifactory, Jenkins y PingFederate son vulnerables sin que el atacante necesite una cuenta previa, según Calif.

Cómo se corrompe la memoria: la optimización que salió cara

La causa está en una optimización. Para decodificar Base64 más rápido, OpenJDK usa instrucciones AVX-512 VBMI, específicas de procesadores x86-64, dentro de una rutina de ensamblador escrita a mano (fuente). El bug vive en cómo esa rutina trata los últimos caracteres de la entrada. Con una cadena de 65 caracteres (64 "A" más un "="), OpenJDK reserva un arreglo de salida de 50 bytes; tras decodificar los primeros 64 caracteres, la rutina maneja mal el "=" sobrante y calcula una longitud de salida negativa, que termina convertida en una escritura de 64 bytes, 62 bytes más allá del arreglo (fuente). Java eventualmente rechaza la entrada, pero para entonces los objetos vecinos en el heap ya pueden estar corruptos (fuente). En builds más viejos de OpenJDK 17 el disparador cambia: hacen falta 128 caracteres "A" antes del "=" (fuente).
CVSS 4.0 de la falla: 9,2 sobre 10, nivel crítico según Calif.

flowchart TD
A["Entrada Base64"] --> B{"CPU con AVX-512 VBMI?"}
B -- "Si" --> C["Decodificador vectorizado en ensamblador"]
B -- "No" --> D["Decodificador escalar en Java"]
C --> E["Calculo de longitud de salida"]
E --> F{"Padding final mal gestionado?"}
F -- "Si" --> G["Longitud negativa: escritura 62 bytes fuera del buffer"]
F -- "No" --> H["Decodificacion correcta"]
Enter fullscreen mode Exit fullscreen mode

Sin pruebas propias: qué mirar antes de confiar en un parche

Para este artículo no corrimos Java4Shell en un laboratorio propio ni reprodujimos el exploit: todo lo descrito sale del reporte técnico de Calif y de la ficha oficial del CVE (fuente, NVD). Si administrás alguno de los productos listados arriba, el primer paso es confirmar la versión exacta de OpenJDK y del build que corre en producción (Temurin, Corretto, Zulu u otro) y revisar el changelog de seguridad del proyecto, no solo la nota de prensa de tu proveedor. Calif publicó además una sección de "Recommendations" dedicada en su propio sitio, pensada justo para ese chequeo (fuente).

No todo el código Java decodifica Base64 igual

El bug vive específicamente en el intrínseco vectorizado de HotSpot, no en Base64 como concepto. Eso cambia según qué pieza de software decodifica el dato:
ImplementaciónDónde corre la decodificaciónExpuesta al mecanismo descritojava.util.Base64 en OpenJDK (HotSpot, x86-64 con AVX-512 VBMI)Ensamblador generado por el JITSí, según el mecanismo que documenta CalifApache Commons CodecJava puro, sin intrínsecos nativosNo por esta vía: no usa la rutina vectorizada que describe el reporteEclipse OpenJ9 / IBM SemeruJIT propio, distinto de HotSpotNo documentado por Calif; el intrínseco que falla es específico de HotSpot
La fila de en medio importa en la práctica: cualquier aplicación que decodifique Base64 con una librería pura en Java, en vez de confiar en la clase estándar del JDK, queda fuera del mecanismo de corrupción que describe Calif. Eso no la libra de otros bugs propios de esas librerías, pero sí de este en particular.

Lo que el reporte deja afuera: límites del hallazgo

Calif es explícito en un punto: no hay un exploit universal. Según cómo cada aplicación use Base64 y cómo esté armada, la explotación necesita pasos distintos; el equipo aceleró el trabajo construyendo primero un pipeline y dejando que agentes de IA armaran la mayoría de las cadenas de ataque después, de forma casi autónoma (fuente). Eso significa que la lista de productos confirmados (Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate, Kafka, Solr, Elasticsearch, Gerrit, Spinnaker) no es exhaustiva, pero tampoco cualquier servicio Java cae solo por usar Base64 en algún punto: hace falta que el runtime use la ruta vectorizada y que el dato llegue sin filtrar hasta el decodificador. El reporte publicado tampoco detalla el desglose completo del vector CVSS más allá del puntaje 9,2, así que para una evaluación de riesgo formal conviene revisar la ficha del CVE directamente (NVD).

Qué significa para vos si mantenés Java en producción

Si trabajás en el equipo de plataforma o SRE de una empresa que corre Keycloak para inicio de sesión único, o Jira y Confluence como suite interna, este hallazgo te toca directo porque son justamente los productos con RCE antes de autenticarse. La prioridad inmediata tiene dos pasos: confirmar la versión de OpenJDK (o del build que uses) en cada despliegue, y revisar si tu proveedor ya publicó una actualización para ese producto puntual, no solo para el JDK en sí.

Si en cambio corrés Kafka, Solr o Elasticsearch en una red interna sin exposición directa a internet, el riesgo baja porque Calif describe esos casos como post-autenticación. Igual conviene parchear, pero no con la misma urgencia que un endpoint público de Keycloak. Y si tu stack decodifica Base64 con Apache Commons Codec o una librería equivalente en vez de la clase estándar del JDK, este mecanismo puntual no te afecta, aunque vale la pena confirmarlo revisando qué parte del código realmente llama a java.util.Base64.
Keycloak, Jira y Jenkins figuran entre las apps con RCE sin autenticación previa.

El dato que no sale en el titular: cuánto cuesta hoy encontrar un RCE así

Calif describe el hallazgo como un trabajo de "centauro": ni la IA sola ni el humano solo, sino los dos combinados. Al investigador Quang Luong le tomó una hora encontrar el bug y dos horas más construir el primer exploit funcional; el costo total en tokens de IA fue menos de $200 (fuente). Es una cifra que cambia el cálculo de cualquier equipo de seguridad: antes, encontrar un RCE de este calibre en un runtime tan auditado como OpenJDK costaba semanas de trabajo especializado.

En el hilo de Hacker News sobre la noticia, la discusión no se centró solo en el parche. El usuario apolo64 argumentó que la seguridad por oscuridad deja de funcionar justo cuando las herramientas de IA bajan el costo de auditar código de bajo nivel que antes nadie miraba con cuidado (comentario en HN). Otro comentario, de jeffbee, apunta a una posible salida de diseño: compilar esa rutina de forma AOT (anticipada) directamente desde el código fuente en vez de mantenerla como ensamblador escrito a mano, lo que reduciría la superficie de este tipo de bugs en runtimes futuros (comentario en HN).

Referencias

Seguimos el tema en @programacion.

Top comments (0)