Java4Shell (CVE-2026-114938): cuando el decodificador Base64 de Java se convierte en una puerta de entrada a RCE

Una corrupción de memoria en el código ensamblador optimizado de HotSpot permite pasar de un simple error de decodificación Base64 a una primitiva de lectura y escritura del heap y, bajo determinadas condiciones, a ejecución remota de código.

Java lleva décadas vendiéndose como una plataforma donde la gestión automática de memoria y la ausencia de acceso directo a punteros ofrecen una ventaja de seguridad frente a lenguajes como C o C++. Sin embargo, esa abstracción tiene límites. La propia máquina virtual, sus compiladores JIT y las optimizaciones implementadas en código nativo siguen dependiendo de componentes donde los errores clásicos de corrupción de memoria pueden aparecer.

Eso es precisamente lo que acaba de demostrar Java4Shell (CVE-2026-114938), una vulnerabilidad crítica descubierta por investigadores de Calif Research en el decodificador Base64 de OpenJDK HotSpot.

El problema resulta especialmente llamativo porque no se encuentra en una biblioteca de terceros ni en una aplicación concreta, sino en una optimización interna de la JVM diseñada para acelerar una operación aparentemente inocua: decodificar cadenas Base64.

Calif atribuye a la vulnerabilidad una puntuación de 9.2 sobre 10 en CVSS 4.0 y asegura haber conseguido ejecución remota de código, incluso sin autenticación, en varias aplicaciones empresariales ampliamente utilizadas. Entre ellas se encuentran Jenkins, Keycloak, Jira, Confluence, JFrog Artifactory y PingFederate.

La investigación también destaca por su metodología: el investigador Quang Luong utilizó Codex para ayudar en la auditoría del código de OpenJDK y afirma que encontró el problema en aproximadamente una hora, desarrollando el primer exploit funcional durante las dos horas siguientes.

Pero vayamos a lo realmente interesante: ¿cómo puede un carácter = al final de una cadena Base64 terminar provocando una escritura fuera de los límites de un array Java?

1. El origen: una optimización de Base64 en HotSpot

Para entender Java4Shell hay que bajar un nivel respecto al código Java convencional.

La API java.util.Base64 proporciona los mecanismos habituales para codificar y decodificar datos. Su utilización es extremadamente frecuente en aplicaciones web, sistemas de autenticación, APIs REST, procesamiento de archivos y protocolos de comunicación.

Por ejemplo:

byte[] decoded = Base64.getDecoder().decode(input);

En condiciones normales, el desarrollador no necesita preocuparse por cómo se realiza internamente la operación. La JVM administra la memoria y garantiza que las operaciones sobre arrays respeten sus límites.

Sin embargo, HotSpot incorpora optimizaciones específicas para determinadas operaciones frecuentes. Una de ellas es el uso de intrinsics: implementaciones especializadas que permiten sustituir determinadas operaciones Java por código nativo altamente optimizado.

En este caso intervienen tres componentes:

  • C2 JIT Compiler: el compilador optimizador de HotSpot que genera código máquina a partir del bytecode.
  • Base64 intrinsic: implementación especializada del decodificador para acelerar el procesamiento.
  • AVX-512 VBMI: conjunto de instrucciones SIMD de determinados procesadores x86-64 que permite procesar grandes bloques de datos en paralelo.

La vulnerabilidad está precisamente en el código ensamblador utilizado por este último mecanismo.

El problema no afecta a la implementación Java convencional del decodificador, sino a una ruta optimizada que procesa bloques de datos utilizando instrucciones vectoriales.

2. CVE-2026-114938: un cálculo incorrecto termina corrompiendo el heap

El fallo se encuentra en el tratamiento de los últimos caracteres de una entrada Base64, especialmente cuando existe padding (=).

El algoritmo necesita calcular cuántos bytes producirá la decodificación y generar una máscara que determine qué posiciones de un registro vectorial deben escribirse en memoria.

Simplificando el comportamiento descrito por Calif, el cálculo es similar al siguiente:

input_mask := bzhiq(-1, input_length);
output_len := (input_length / 4) * 3;

// Handle Base64 padding
if (input[input_length - 1] == '=') {
    output_len -= 1;
    input_mask >>= 1;

    if (input[input_length - 2] == '=') {
        output_len -= 1;
        input_mask >>= 1;
    }
}

output_mask := bzhiq(-1, output_len);

El problema aparece cuando el fragmento final de la entrada contiene padding, pero no dispone de suficientes caracteres para formar un bloque Base64 completo.

En esas circunstancias, output_len puede terminar siendo negativo debido a un underflow.

La instrucción bzhiq se utiliza para construir una máscara de bits. Cuando el valor calculado se encuentra fuera del rango esperado, la máscara termina habilitando las 64 posiciones de escritura.

Posteriormente, la instrucción vectorial VMOVDQU8, a través de la abstracción evmovdqub de HotSpot, utiliza esa máscara para escribir los datos en memoria.

El resultado es una escritura de 64 bytes cuando el buffer de destino no dispone de espacio suficiente.

Y aquí está el detalle importante: la JVM termina rechazando la entrada Base64 y lanzando una IllegalArgumentException, pero la corrupción de memoria ya se ha producido.

Es decir, capturar la excepción no evita el problema.

3. El payload que desencadena la corrupción

La demostración publicada por Calif es sorprendentemente sencilla.

En las versiones afectadas de OpenJDK 21, 25 y 27, el investigador muestra como entrada desencadenante una cadena compuesta por 64 caracteres A seguidos de un signo igual:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=

En OpenJDK 17, el umbral es diferente y se necesitan 128 caracteres A seguidos de =.

La explicación está en los umbrales de entrada necesarios para alcanzar la ruta vectorial de cada implementación.

Según el análisis de Endor Labs, el tamaño mínimo de entrada es de 65 caracteres en las versiones 21, 25 y 27, mientras que en Java 17 es de 129 caracteres.

Lo preocupante es que el error no depende de que el contenido Base64 represente un archivo especialmente construido o una estructura compleja. Basta con alcanzar la ruta vulnerable con una entrada malformada.

4. Del buffer overflow a JavaBleed

Encontrar una escritura fuera de límites no significa automáticamente disponer de ejecución de código.

De hecho, la primitiva inicial de Java4Shell tiene una limitación importante: los bytes escritos fuera del array contienen valores esencialmente fijos. El atacante puede influir en la posición donde se produce la escritura, pero no controla libremente todo su contenido.

Esto complica bastante la explotación.

La investigación de Calif resuelve el problema mediante una técnica conocida como Heap Feng Shui, combinada con manipulación de objetos Java.

La idea consiste en preparar el heap para que la escritura fuera de límites afecte a objetos que puedan resultar útiles para construir primitivas de explotación más potentes.

La cadena descrita por los investigadores puede dividirse en varias fases.

1. Construcción del writer

El atacante prepara un array que se encuentra próximo al buffer vulnerable. Mediante la corrupción de sus metadatos, consigue modificar su longitud.

A partir de ese momento, las operaciones de escritura legítimas sobre ese array pueden terminar sobrescribiendo memoria adyacente con datos controlados por el atacante.

2. Construcción del reader

Posteriormente, se manipula un segundo array cuyo contenido puede terminar reflejándose en una respuesta de la aplicación.

Si se consigue alterar su longitud, el atacante puede provocar que la aplicación devuelva datos que se encuentran fuera de los límites originales del objeto.

3. JavaBleed

Esta primitiva permite obtener información del heap de Java.

Entre los datos potencialmente expuestos pueden encontrarse tokens de autenticación, información personal, claves privadas y otros secretos presentes en memoria.

La similitud conceptual con Heartbleed es evidente: en ambos casos, un error de límites permite acceder a información que no debería formar parte de la respuesta.

4. Heap repair

La corrupción de objetos Java puede provocar que la máquina virtual termine fallando durante la ejecución del recolector de basura.

Por eso, la investigación incorpora mecanismos para recuperar determinados metadatos originales y mantener la JVM en funcionamiento.

5. Escalada a ejecución de código

Finalmente, los investigadores utilizan las primitivas de lectura y escritura obtenidas para alcanzar estructuras internas de la JVM, incluyendo el Code Cache y determinados hooks de ejecución.

El objetivo es pasar de una corrupción limitada del heap a una primitiva que permita ejecutar código.

No se trata, por tanto, de un simple buffer overflow que proporciona directamente una shell. Es una cadena de explotación que depende de la disposición de los objetos, el comportamiento de la aplicación y las posibilidades de controlar las asignaciones de memoria.

5. Heap Feng Shui remoto: controlar el comportamiento de la aplicación

Uno de los aspectos más interesantes de Java4Shell es que los investigadores no se limitan a demostrar la corrupción en un programa local.

La explotación remota requiere influir en la distribución de objetos del heap desde las peticiones que recibe la aplicación.

HotSpot utiliza mecanismos como los Thread Local Allocation Buffers (TLAB), que permiten a cada hilo disponer de una región privada para realizar asignaciones de memoria.

Esto introduce una dificultad: dos peticiones procesadas por diferentes hilos no necesariamente generan los objetos en el orden que necesita el atacante.

Calif describe una estrategia basada en varias capas de preparación:

  • Controlar el tamaño de los objetos y las asignaciones que se realizan durante el procesamiento de las peticiones.
  • Conseguir que determinados objetos abandonen los TLAB y se asignen mediante otras rutas.
  • Preparar múltiples parejas de objetos writer/reader.
  • Utilizar técnicas de heap spraying para aumentar las posibilidades de conseguir la disposición deseada.
  • Repetir los intentos hasta conseguir que la escritura vulnerable afecte al objeto adecuado.

También se utiliza el comportamiento del transporte TCP para controlar mejor el momento en el que se producen determinadas asignaciones.

En concreto, el investigador describe el envío parcial de peticiones HTTP y la utilización de los ACK de TCP como mecanismo para sincronizar el momento en que se completa el procesamiento de la entrada.

La estabilidad de la conexión resulta importante: el RTT y el jitter pueden afectar a la fiabilidad de la preparación del heap.

Por tanto, no estamos ante un exploit universal que funcione simplemente enviando una cadena a cualquier servicio Java. Cada aplicación requiere estudiar su comportamiento interno y construir una estrategia de explotación adaptada.

6. Aplicaciones afectadas: del servidor de autenticación al pipeline CI/CD

La repercusión potencial es considerable porque la vulnerabilidad se encuentra en una implementación compartida por numerosos productos.

Calif afirma haber demostrado ejecución remota de código en las siguientes aplicaciones:

RCE sin autenticación (pre-auth):

  • Keycloak.
  • Atlassian Jira.
  • Atlassian Confluence.
  • JFrog Artifactory.
  • Jenkins.
  • PingFederate.

RCE después de autenticación (post-auth):

  • Apache Kafka Broker.
  • Apache Solr.
  • Elasticsearch.
  • Gerrit.
  • Spinnaker.

También se han probado aplicaciones construidas sobre frameworks como Spring Boot y Apache Struts.

El impacto depende de cómo cada aplicación procese los datos proporcionados por el usuario y de si estos terminan alcanzando la implementación vulnerable de java.util.Base64.

Esto resulta especialmente relevante en los sistemas de autenticación y gestión de identidades, donde los datos codificados en Base64 aparecen habitualmente en diferentes flujos de procesamiento.

En el caso de Jenkins, Artifactory o Gerrit, una explotación exitosa podría comprometer componentes especialmente sensibles de la infraestructura de desarrollo y distribución de software.

7. ¿Qué versiones están afectadas?

Según la investigación publicada, Java4Shell afecta a OpenJDK desde la versión 17.0.6 en adelante, siempre que se cumplan los requisitos de hardware y ejecución.

No basta con tener Java instalado.

La ruta vulnerable depende de la implementación x86-64 y de la disponibilidad de instrucciones AVX-512 VBMI.

Entre las familias de procesadores identificadas se encuentran:

  • Intel Xeon Ice Lake y generaciones posteriores.
  • Intel Sapphire Rapids, Emerald Rapids y Granite Rapids.
  • AMD EPYC y Ryzen basados en Zen 4 o posteriores.

Los sistemas ARM64 no están afectados por esta implementación concreta.

También hay que tener en cuenta que no todas las distribuciones Java utilizan exactamente las mismas versiones o incorporan las mismas correcciones.

Entre las distribuciones que deben revisarse se encuentran:

  • Amazon Corretto.
  • Eclipse Temurin.
  • Microsoft Build of OpenJDK.
  • Azul Zulu.
  • BellSoft Liberica.
  • Red Hat OpenJDK.
  • Oracle OpenJDK.
  • Oracle Java SE.
  • Oracle GraalVM.

Para comprobar si el procesador dispone de las instrucciones necesarias en Linux:

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

La salida debe incluir las cuatro características.

También es conveniente comprobar qué opciones está utilizando realmente la JVM:

java -XX:+PrintFlagsFinal -version 2>&1 | \
grep -E 'UseAVX|UseBASE64Intrinsics'

La presencia de AVX-512 VBMI no implica por sí sola que una aplicación sea explotable. Es necesario que la JVM utilice la ruta afectada y que exista una entrada controlable que alcance el decodificador.

8. Reproducir la corrupción de memoria

Los investigadores de Calif han publicado una demostración en vídeo donde muestran el impacto práctico de Java4Shell, incluyendo escenarios de ejecución remota de código contra diferentes aplicaciones empresariales como Keycloak, Jira, Confluence, Kafka y Elasticsearch.

El vídeo permite apreciar cómo una vulnerabilidad originada en una optimización interna de HotSpot puede convertirse en un compromiso de aplicaciones que utilizan Java en su infraestructura.

Demostración de Calif Research:

Calif ha publicado un PoC autónomo que permite comprobar la corrupción sin construir una cadena completa de explotación remota.

El ejemplo calienta el decodificador hasta conseguir que HotSpot utilice la implementación optimizada. Después inicializa un array de destino con un valor conocido y ejecuta la decodificación de una entrada malformada.

El objetivo es detectar si se han modificado posiciones que se encuentran fuera de los límites lógicos del buffer de salida.

El siguiente código mantiene la escritura dentro de un array físico de 4096 bytes, evitando que el ejemplo dependa de sobrescribir memoria arbitraria:

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Base64;

public final class Base64Trigger {

    private static volatile int sink;

    public static void main(String[] args) {

        Base64.Decoder decoder = Base64.getDecoder();

        byte[] valid = "A".repeat(64)
            .getBytes(StandardCharsets.US_ASCII);

        byte[] malformed = ("A".repeat(64) + "=")
            .getBytes(StandardCharsets.US_ASCII);

        byte[] target = new byte[4096];

        // Warm-up del decoder para activar la ruta JIT.
        for (int i = 0; i < 200_000; i++) {
            sink += decoder.decode(valid, target);
        }

        Arrays.fill(target, (byte) 0x5a);

        boolean rejected = false;

        try {
            decoder.decode(malformed, target);
        } catch (IllegalArgumentException expected) {
            rejected = true;
        }

        int changed = 0;
        int first = -1;
        int last = -1;

        for (int i = 50; i < target.length; i++) {

            if (target[i] != (byte) 0x5a) {

                changed++;

                if (first < 0) {
                    first = i;
                }

                last = i;
            }
        }

        System.out.println(
            "runtime=" + System.getProperty("java.runtime.version")
        );

        System.out.println(
            "vm=" + System.getProperty("java.vm.name")
        );

        System.out.printf(
            "rejected=%s changed=%d first=%d last=%d%n",
            rejected, changed, first, last
        );

        if (!rejected || changed != 62 ||
            first != 50 || last != 111) {

            System.err.println("NOT REPRODUCED");
            System.exit(1);
        }

        System.out.println("REPRODUCED");
    }
}

En las condiciones descritas por Calif, el resultado esperado es:

rejected=true changed=62 first=50 last=111
REPRODUCED

Lo interesante es que el decodificador rechaza la entrada, pero el array contiene modificaciones fuera del espacio lógico reservado para el resultado.

Este PoC demuestra la corrupción de memoria, no la explotación remota ni la ejecución de código.

Importante: debe utilizarse exclusivamente en un entorno de laboratorio, con una JVM vulnerable y un procesador compatible. No debe emplearse como prueba de seguridad en servicios de producción.

9. Mitigación y detección

La primera recomendación es actualizar OpenJDK y las distribuciones comerciales a las versiones corregidas publicadas por sus respectivos proveedores.

El arreglo se encuentra asociado al cambio JDK-8393212, denominado Base64 optimization improvements. No obstante, hay que comprobar que la distribución concreta incorpora realmente la corrección: no basta con comparar números de versión entre fabricantes.

Mientras se completa la actualización, existen varias alternativas para desactivar la ruta vulnerable.

La opción más directa consiste en deshabilitar las intrinsics Base64:

-XX:-UseBASE64Intrinsics

Otra posibilidad es limitar el uso de AVX-512:

-XX:UseAVX=2

Esta última opción tiene un alcance mayor, ya que puede desactivar otras optimizaciones vectoriales y afectar al rendimiento. Debe utilizarse únicamente en sistemas x86-64.

Endor Labs también documenta una alternativa más específica para desactivar exclusivamente el intrinsic de decodificación:

-XX:+UnlockDiagnosticVMOptions \
-XX:DisableIntrinsic=_base64_decodeBlock

La disponibilidad de esta opción debe comprobarse en la distribución y versión concreta de HotSpot.

Para verificar la configuración efectiva:

java -XX:+PrintFlagsFinal -version 2>&1 | \
grep -E 'UseBASE64Intrinsics|UseAVX|DisableIntrinsic'

En entornos productivos conviene comprobar también los runtimes que vienen incluidos dentro de productos como Jenkins, Jira, Confluence o Elasticsearch. Consultar simplemente java -version desde una terminal puede mostrar una instalación distinta de la que utiliza el servicio.

En contenedores Docker, es necesario revisar tanto las imágenes actualmente desplegadas como las imágenes base de los Dockerfiles y pipelines de construcción.

Indicadores de detección

Además de actualizar, merece la pena buscar patrones compatibles con la explotación:

  • Entradas Base64 malformadas que terminan en = o == y cuya longitud no es múltiplo de cuatro.
  • Incrementos anómalos de excepciones IllegalArgumentException en rutas que procesan Base64.
  • Peticiones repetidas y fragmentadas desde un mismo origen, compatibles con intentos de preparación del heap.
  • Respuestas que contienen cantidades inesperadas de datos binarios o información de memoria.
  • Caídas de la JVM con SIGSEGV, especialmente cuando los registros muestran operaciones de copia del recolector de basura y frames asociados a Base64$Decoder.decode0.

Estos indicadores no son una firma definitiva de explotación, pero pueden ayudar a detectar comportamientos anómalos.

10. Conclusiones: cuando la optimización se convierte en superficie de ataque

Java4Shell es un buen ejemplo de cómo una optimización de rendimiento puede terminar introduciendo una vulnerabilidad de seguridad de gran impacto.

La abstracción de memoria de Java no elimina los riesgos de corrupción cuando la propia máquina virtual utiliza código nativo para acelerar operaciones. En este caso, una implementación ensamblador optimizada para procesar Base64 termina reproduciendo un problema clásico: una escritura fuera de los límites de un buffer.

También merece atención el papel de la inteligencia artificial en el descubrimiento. Calif afirma que Codex ayudó a localizar el problema durante una auditoría de HotSpot centrada en el JIT, los intrinsics, las APIs de uso frecuente y la criptografía.

Esto no significa que la IA haya descubierto y explotado autónomamente la vulnerabilidad. El propio investigador explica que fue necesario aportar contexto, desarrollar herramientas de análisis del heap, interpretar resultados y adaptar las estrategias a cada aplicación.

Pero sí demuestra que las herramientas de IA pueden acelerar considerablemente la auditoría de componentes complejos que tradicionalmente requieren conocimientos muy especializados.

Quizá la lección más importante sea otra: la seguridad de una plataforma no depende únicamente del lenguaje en el que escribimos nuestras aplicaciones, sino también de todas las capas de código nativo que hacen posible su ejecución.

Y, en este caso, una operación tan cotidiana como decodificar Base64 ha terminado poniendo en jaque a una parte importante del ecosistema Java.


Referencias y recursos

CVE: CVE-2026-114938
Severidad publicada por Calif: CVSS 4.0 – 9.2 (Critical)
Componente: OpenJDK HotSpot – Base64 intrinsic
Tipo: Heap buffer overflow / Memory corruption / RCE
Investigador: Quang Luong (Calif Research)

Comentarios