Java4Shell a examen: 62 bytes fuera del búfer, un parche de cuatro líneas y un disparador que solo funciona una vez por compilación JIT

En CPU con AVX-512, JDK 21.0.13.0.3 escribe 62 bytes fuera del búfer y aun así lanza excepción. El parche son cuatro líneas y el disparo exige C2.

Durante veinte años, el argumento de venta de Java ha sido que no se puede escribir más allá del final de un arreglo. El 17 de noviembre de 2026, una llamada normal a un decodificador Base64 hizo exactamente eso en un JDK de serie.

CVE-2026-114938 —bautizada Java4Shell por Calif.io— es un desbordamiento de búfer en el montón dentro del intrínseco Base64 de HotSpot para x86-64. Oracle la corrigió en una actualización crítica fuera de ciclo y la puntuó con 8,1; la investigadora la puntúa con 9,2. En cuatro horas, el hilo de Hacker News acumuló 461 puntos y 120 comentarios, la mayoría con la misma pregunta: ¿esto es real y me afecta?

La pregunta se responde con una descarga y un archivo Java de veinte líneas. Este servidor tiene la CPU necesaria —un AMD EPYC 9354P, Zen 4, con avx512vbmi presente—, así que descargué seis runtimes, ejecuté la prueba de concepto publicada y luego escribí sondas que el informe no incluye. Resumen corto: el fallo es real, las descripciones del fabricante y de la investigadora apuntan al mismo camino de código, y la prueba publicada se queda corta —decodifica en un arreglo de 4.096 bytes para que el desbordamiento caiga dentro del arreglo que está midiendo—. Con el destino en su tamaño natural, la misma llamada reescribe en silencio la cabecera del objeto siguiente.

Esto es lo que hacen seis compilaciones de la JVM con la misma entrada hostil de 65 bytes.

Seis compilaciones, una entrada de 65 bytes

La entrada son 64 caracteres A seguidos de un solo =. Nada más.

RuntimeCompilación (fecha)¿Lanza excepción?Bytes escritos más allá de la salida decodificada
Azul Zulu 21.0.13.0.3zulu21.54+109-CA, 24-10-2026sí62 (desplazamientos 50–111)
Azul Zulu 21.0.13.1zulu21.54+201-CA, 17-11-2026sí0
Amazon Corretto 21.0.13.1.221.0.13.1+2-LTS, 17-11-2026sí0
Azul Zulu 17.0.21.0.3zulu17.70+113-CA, 24-10-2026sí0 con 65 bytes; 62 con 129 bytes
Azul Zulu 11.0.33zulu11.92+113-CA, 20-10-2026sí0 en todas las longitudes probadas
Azul Zulu 8.94 (1.8.0_492)8.94.0.17-CAsí0 en todas las longitudes probadas

Las dos compilaciones de Zulu 21 están a seis niveles de parche de distancia en el nombre y a cuatro semanas en el tiempo: 21.0.13.0.3 era la actualización de octubre, 21.0.13.1 salió el día de la divulgación. Mismo fabricante, misma versión de funcionalidad, misma imagen base de contenedor, resultados opuestos. Es el mejor A/B que va a tener esta vulnerabilidad, y demuestra por qué la cadena de versión no dice nada por sí sola: hace falta el número de compilación.

La excepción no es un consuelo. Ambas columnas dicen «sí» porque el decodificador rechaza la entrada en los dos casos. La corrupción ocurre primero; la IllegalArgumentException es lo que llega después de que el montón ya cambió.

El fallo está a una instrucción de la corrección

El stub de decodificación vive en src/hotspot/cpu/x86/stubGenerator_x86_64.cpp y se genera al arrancar la JVM como stubgen_base64_decodeBlock_id. Recorre la entrada en bloques de 256 bytes, luego de 64, y finalmente llega a una etiqueta que el comentario del código describe como // Now have 1 to 63 bytes left to decode.

El camino de cola construye dos máscaras: una de entrada a partir de la longitud de la cola y una de salida a partir de la longitud calculada. Los caracteres de relleno se eliminan decrementando esa longitud:

// vulnerable (jdk-21+35 hasta 21.0.13.0.x), simplificado
__ BIND(L_donePadding);
__ kmovql(input_mask, rax);
__ movq(output_mask, -1);
__ bzhiq(output_mask, output_mask, output_size);   // <-- output_size puede ser negativo

__ BIND(L_padding);
__ decrementq(output_size, 1);     // 0 - 1 = -1
__ shrq(rax, 1);
__ cmpb(Address(source, length, Address::times_1, -2), '=');
__ jcc(Assembler::notEqual, L_donePadding);
__ decrementq(output_size, 1);     // -2 cuando la cola es "=="
__ shrq(rax, 1);
__ jmp(L_donePadding);

bzhiq(dst, src, index) pone a cero todos los bits por encima de index. Cuando index >= 64, por definición deja el origen intacto, y un output_size de −1 o −2 se interpreta como un índice sin signo muy superior a 63. La máscara queda en todos unos y el almacenamiento vectorial enmascarado escribe los 64 bytes del registro en lugar de los dos o tres que le correspondían a la cola:

__ kmovql(k1, output_mask);                        // k1 == -1ull
__ evmovdqub(Address(dest, dp), k1, tmp, true, Assembler::AVX_512bit);

Para una entrada de 65 bytes, el lado Java dimensiona el destino con decodedOutLength() en java/util/Base64.java, cuya última línea es:

return 3 * (int) ((len + 3L) / 4) - paddings;   // 3 * 17 - 1 == 50

Cincuenta bytes, de los cuales 48 son salida real. El almacenamiento empieza en el desplazamiento 48 y abarca 48–111. Todo lo que va del desplazamiento 50 en adelante está fuera del arreglo: 62 bytes.

L_padding solo es alcanzable cuando la cola es lo bastante corta como para que (length / 4) * 3 redondee a cero, y eso es lo que hace que la geometría del disparo sea tan específica —y tan fácil de equivocar en una prueba—.

El parche son cuatro líneas y ninguna prueba

La corrección en el tronco es el commit 5177a70b385c16f26ede191fdac7aaba0bed0f8b de openjdk/jdk, confirmado el 16-11-2026 a las 19:52 UTC, unas 25 horas antes de que saliera el aviso. Cambia un archivo, añade cuatro líneas, no borra ninguna y no añade pruebas:

@@ -3395,6 +3395,10 @@ address StubGenerator::generate_base64_decodeBlock() {
     __ BIND(L_finalBit);
     // Now have 1 to 63 bytes left to decode
 
+    // A padded Base64 tail shorter than one complete block is handled by Java.
+    __ cmpl(length, 4);
+    __ jcc(Assembler::less, L_bruteForce);
+
     // I was going to let Java take care of the final fragment
     // however it will repeatedly call this routine for every 4 bytes
     // of input data, so handle the rest here.

Una cola de menos de cuatro bytes nunca llega al camino vectorial, así que output_size ya no puede desbordarse: con length >= 4, (length / 4) * 3 >= 3, y quitar como mucho dos bytes de relleno deja al menos 1.

El mensaje del commit es 8393212: Base64 optimization improvements. Los revisores son rhalade, mschoene, chagedorn, rcastanedalo. Ni el título, ni la descripción, ni un archivo de pruebas dicen «seguridad»: si el flujo de trabajo de alguien busca CVE en los asuntos de los commits, este parche es invisible. Los revisores son las personas que revisan las correcciones de seguridad de Oracle, pero eso solo se sabe si se conocen los nombres.

El commit dice dos cosas más por omisión. Toca solo x86-64, coherente con que «las CPU ARM64 no se vean afectadas». Y corrige únicamente el camino de C2, coherente con lo que muestran las mediciones.

Lo que realmente escribe el almacenamiento de 64 bytes

El informe de Calif afirma que la región fuera de límites tiene contenido fijo: «escritura no controlada en los bytes [2, 63]. Para los bytes 48..63, el valor siempre será 0x9a». El hardware no hace eso.

Decodificando la misma entrada de 65 bytes en un arreglo de 200 bytes precargado con 0x5a, en Zulu 21.0.13.0.3:

DesplazamientosBytes
40–4700 00 00 00 00 00 00 00 (datos decodificados dentro de límites)
48–5569 a6 9a 69 a6 9a 69 a6
56–639a 69 a6 9a 69 a6 9a 69
64–95el mismo período de tres bytes 69 a6 9a repitiéndose
96–1039a 9a 9a 9a 9a 9a 9a 9a
104–1119a 9a 9a 9a 9a 9a 9a 9a
112+intacto (5a)

El almacenamiento no es un relleno constante. Los desplazamientos 48–95 llevan un patrón repetido 0x69 0xa6 0x9a producido por la permutación de empaquetado de Base64, y solo los últimos 16 bytes son 0x9a. Quien leyera el informe y modelara esos 16 bytes como 0x9a se equivocaría en los primeros 48.

En las compilaciones parcheadas el mismo volcado no muestra nada: dst[48..111] sigue en 5a y solo se escriben los primeros 48 bytes.

Es una corrección pequeña, pero cambia qué distribuciones de objetos sobreviven a la escritura. Una región uniforme de 0x9a corrompe campos con un valor veneno reconocible; un período de tres bytes con cola 0x9a da resultados distintos según dónde empiece la cabecera de cada objeto. Cualquiera que construya un paso de «reparación» dentro de una cadena de explotación, como describe el informe, trabaja con los bytes reales, no con la descripción publicada.

El disparador no es una longitud, es una clase de resto

Barriendo longitudes de entrada contra la compilación vulnerable, con el arreglo de destino precargado y el intrínseco recién calentado antes de cada intento, aparece un panorama mucho más estrecho y más regular que «64 A y un igual».

Longitud total de entradaRellenoBytes fuera del final¿Dispara?
64=0no
65=62sí
66==63sí
67–68=, ==0no
120, 124, 126, 127= o ==0no
129=62sí
130==63sí
193, 194=, ==62, 63sí
257, 258=, ==62, 63sí
321, 322=, ==62, 63sí

La regla es el resto módulo el bloque vectorial: el desbordamiento ocurre exactamente cuando longitud % 64 es 1 o 2. Sesenta y dos bytes cuando el resto es 1, sesenta y tres cuando es 2, porque en el segundo caso el almacenamiento empieza un byte antes —en el desplazamiento 97 en lugar de 98 en el caso de 129 bytes—.

Se siguen dos consecuencias.

Primera: un corpus de fuzzing con Base64 malformado aleatorio lo va a encontrar por accidente, pero rara vez de forma reproducible; un corpus de colas con tamaños concretos lo encuentra siempre. Segunda: el umbral de JDK 17 no es otro fallo, es otra condición de alcanzabilidad. En Zulu 17.0.21.0.3 la entrada de 65 bytes no hace nada y la de 129 desborda 62 bytes en los desplazamientos 98–159. El aviso lo comprime a «en OpenJDK 17 la entrada es 'A' * 128 + '='»; medido, la clase es la misma % 64 ∈ {1,2} y solo cambia la longitud mínima alcanzable.

Eso significa que un responsable de versiones que hubiera probado JDK 17 con la prueba de 65 bytes del informe habría concluido que no estaba afectado. Y se habría equivocado.

La puerta del JIT: 35.000 decodificaciones válidas antes de que exista

El desbordamiento necesita el intrínseco, y el intrínseco necesita C2. En una JVM recién arrancada el cambio ocurre bajo carga:

Llamadas válidas antes de la hostilBytes sobrescritos
0 a 35.0000
40.00062
45.00062
50.000 y más62

Entre 35.000 y 40.000 llamadas en este servidor de dos vCPU, el intrínseco se compila y el camino rápido pasa del bucle Java al stub en ensamblador. Por debajo de eso, la misma entrada hostil la decodifica —mal— el intérprete o C1, y el arreglo queda intacto.

La versión compilada además es de un solo uso. Después de una llamada hostil, la JVM la descarta:

IntentoBytes sobrescritos
1.ª llamada hostil tras el calentamiento62
2.ª, 3.ª … 12.ª, sin recalentar0
tras recalentar 200.000 decodificaciones válidas62 otra vez, de forma repetible

Cuatro rondas de calentar, disparar, calentar, disparar dieron cuatro aciertos. Doce disparos consecutivos tras un solo calentamiento dieron exactamente uno.

Esto importa más de lo que parece. La cronología de explotación del informe dice que, tras una colocación incorrecta en el montón, «podemos simplemente intentarlo otra vez». A nivel de JVM, un reintento dentro del mismo proceso no vuelve a entrar al stub vulnerable: hay que empujar suficiente tráfico válido por el decodificador para que C2 lo recompile, que es justo el «calentar, ensayar, reintentar» que el informe presenta como habilidad operativa y no como restricción de la JVM. Ni el aviso ni los documentos de los fabricantes mencionan que la primitiva se consume con el uso.

También rompe una prueba de regresión ingenua. Una prueba que caliente una vez y envíe la entrada hostil dos veces verá cómo el primer intento corrompe memoria y el segundo pasa, y un arnés que reutilice la JVM entre casos reportará la vulnerabilidad como ausente en todos los casos menos el primero.

Mitigaciones: cuatro que funcionan y lo que cuestan

Medido en la compilación vulnerable 21.0.13.0.3, cada combinación de banderas con el mismo calentamiento de 200.000 decodificaciones y tres intentos hostiles:

Configuración de la JVMBytes sobrescritos
por defecto62
-XX:-UseBASE64Intrinsics0
-XX:UseAVX=20
-XX:UseAVX=362
-XX:TieredStopAtLevel=1 (solo C1)0
-Xint0

Las dos banderas del aviso funcionan, y otras dos configuraciones que el aviso no menciona también. Las filas de solo-C1 y de intérprete sirven para diagnosticar —confirman que el defecto vive en el intrínseco de C2 y no en el decodificador Java—, pero no son consejo de despliegue: ejecutar una aplicación en C1 o interpretada es una decisión de rendimiento de dos órdenes de magnitud, no una mitigación.

Las dos banderas documentadas tienen costes que el aviso no cuantifica. -XX:-UseBASE64Intrinsics desactiva también el codificador acelerado, así que cada validación de JWT, cada subida multiparte y cada carga de Kafka vuelve al camino escalar. -XX:UseAVX=2 es peor de lo que suena: limita el soporte AVX para toda la máquina virtual, no solo para Base64, degradando todos los bucles vectorizados que usarían registros de 512 bits. El aviso sí dice que la bandera es solo para x86-64 y que las JVM de ARM no arrancan con ella; vale la pena repetirlo para quien tenga nodos Graviton y EPYC detrás de un mismo archivo de configuración.

Ninguna es verificable en un proceso en marcha como suele suponerse. jcmd <pid> VM.flags muestra lo que está configurado y /proc/cpuinfo dice si la CPU está expuesta, pero si C2 compiló el intrínseco para un hilo trabajador concreto no es una bandera que se pueda leer: solo se infiere de la carga.

La prueba es acotada; la primitiva no

El Base64Trigger publicado por Calif decodifica en un arreglo de 4.096 bytes y busca cambios desde el desplazamiento 50. Toda escritura cae dentro de un arreglo real, así que la prueba es segura de ejecutar: una decisión deliberada y sensata para una prueba de concepto pública.

También esconde la gravedad real. El código de producción no entrega al decodificador un destino cuatro kilobytes más grande de lo necesario: decode(byte[]) asigna exactamente decodedOutLength() bytes y pasa ese arreglo. Si se reproduce ese orden de asignación, el desbordamiento cae sobre el objeto siguiente.

Reservé byte[50] —la longitud calculada exacta— seguido inmediatamente de un byte[512] lleno de 0x5a, calenté el decodificador y envié la misma entrada de 65 bytes:

LecturaVulnerable 21.0.13.0.3Parcheada 21.0.13.1
excepciónsísí
victim.length−1700370022 (0x9A9A9A9A)512
victim[0]0x690x5a
salida del proceso0, sin caída0, sin caída

El campo de longitud del arreglo vecino desapareció, sustituido por la cola 0x9a del almacenamiento, y su primer byte de datos por 0x69. Ninguna excepción indica esto al llamador; el arreglo sigue siendo alcanzable, sigue tipado como byte[] y ahora declara una longitud negativa. La JVM no se cayó y no se registró nada.

Esa es la primitiva de «sobrescribir la longitud de un búfer» que el informe llama el writer, y es alcanzable con una sola petición HTTP de Base64 controlado por el atacante en cuanto el manejador está en el camino de C2, que es el estado normal de cualquier decodificador con tráfico real. Lo que sigue siendo difícil es todo lo demás: lograr que el objeto con la longitud corrupta quede junto a algo cuyos contenidos vuelvan al atacante. Eso es lo que el informe reconoce con honestidad al llamarlo «spray and pray» y admitir que es G1 quien elige las direcciones, no el atacante.

Así que la historia de explotabilidad no es la discrepancia entre 8,1 y 9,2. La discrepancia es sobre la parte difícil. La parte fácil —un búfer decodificado cuyo campo de longitud el atacante elige enviando el número correcto de A— ocurre en una sola llamada.

Tres puntuaciones para un mismo fallo

Nadie miente y los números no coinciden.

FuentePuntuaciónQué dice
Matriz de riesgo del CSPU de OracleCVSS 3.1 8,1 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H)componente Compiler, protocolo Multiple, «¿explotable en remoto sin autenticación? Sí»
Aviso de Calif.ioCVSS 4.0 9,2 crítica«escribe una vez, RCE en todas partes»
Registro del NVD (17-11-2026, 22:18 UTC)copia el vector 8,1, añade CWE-122 y el bloque SSVC de CISA: explotación none, automatizable no, impacto técnico totalpublicado después del fabricante, antes de cualquier exploit

La diferencia está en el término de complejidad de ataque: Oracle puntúa AC:H, que es lo que baja un impacto C/I/A completo de la franja 9,8 a 8,1. Una cadena de grooming de montón que depende de la colocación de regiones de G1, de los rellenos de TLAB y del tiempo de TCP no es AC:L en ninguna lectura normal, así que la puntuación del fabricante es más defendible que el número de titular. Nada de esto cambia el consejo de parchear primero.

La línea del SSVC de CISA es la frase más útil del registro del NVD: technicalImpact: total con exploitation: none y automatable: no describe con precisión un fallo devastador si alguien construye la cadena y poco interesante hasta entonces. A la fecha de este artículo no hay exploit público y el informe retiene las cadenas específicas de producto.

Donde las listas de versiones dejan de coincidir con el runtime

Las tablas de versiones divergen de una forma que ningún lector puede resolver con documentación.

AfirmaciónFuenteMedición
OpenJDK 17.0.6 y posteriores están afectadosAviso de Calif17.0.21.0.3 desborda con 129 bytes — coherente
Java SE 8 8u511b33-perf y GraalVM EE 21.3.20.0.3 están afectadosMatriz de Oracleno verificable directamente; sí los caminos de 8u y 11
Java 11.0.33 está afectadoMatriz de Oracle, según el resumen de AikidoZulu 11.0.33: cero desbordamiento con 65, 66, 129, 130, 193, 194, 257 y 258 bytes, con UseBASE64Intrinsics = true
JDK 8 está afectadoMatriz de OracleZulu 8u492: cero desbordamiento en todas las longitudes probadas

JDK 11 informa UseBASE64Intrinsics = true y aun así no se puede hacer desbordar, porque la bandera habilita el método, no el stub AVX-512 de x86; ese stub no existe en 11. JDK 8 no tiene ese intrínseco en absoluto.

Esto no significa que Oracle esté equivocada: un registro CVE puede cubrir una familia de correcciones que salen en un mismo conjunto de parches. Significa que «la versión X figura como afectada» y «la versión X contiene el defecto descrito» son afirmaciones distintas, y solo la segunda dice si hay que actuar esta noche. ART de Android, IBM Semeru, GraalVM EE 21.3 y cada fabricante derivado heredan la misma ambigüedad. No encontré ninguna fuente que concilie la lista con el código: la lectura honesta es que el fabricante parchea la familia y la investigadora describe un componente.

Dónde vive el parche y cuándo se puede ver

La corrección en el tronco se publicó el 16 de noviembre. El repositorio de actualización contra el que audita la mayoría no:

ArtefactoEstado el 18-11-2026
openjdk/jdk mastercommit 5177a70b con la guarda de cuatro líneas
historial público de openjdk/jdk21uningún commit que toque stubGenerator_x86_64.cpp entre el 20 de octubre y el 18 de noviembre
binario Zulu 21.0.13.1corregido
binario Corretto 21.0.13.1.2corregido
Oracle JDK 21.0.13.0.3 (según matriz)la matriz lista la compilación previa como afectada

Los repositorios de actualización de OpenJDK suelen publicar los backports de seguridad después de que salgan los binarios, así que no es una sorpresa para quien haya trabajado con jdk8u/jdk11u/jdk17u durante una ventana de CPU. Significa dos cosas para la verificación. Quien compile su propio JDK desde un árbol LTS público no puede confirmar el parche con el historial público, y quien audite «¿aplicamos el parche de upstream?» buscando el número de CVE en los mensajes de commit no encontrará nada en ninguna de las dos ramas.

La ruta práctica es de comportamiento: ejecutar una sonda contra el binario exacto que se despliega. Es la misma lección de nuestra auditoría del Open Code Review de Alibaba, donde un documento que asignaba cada afirmación de seguridad a un archivo y una línea aun así incluía una primitiva de comentario que escapaba de su frontera de confianza declarada.

Una prueba de regresión que habría detectado esto

La razón por la que esta clase de fallo sobrevive a las pruebas ordinarias es que el decodificador lanza excepción en ambos casos, así que una prueba que afirme «una entrada inválida lanza IllegalArgumentException» pasa en las dos compilaciones. La prueba tiene que afirmar la ausencia de efectos secundarios, y tiene que vencer el comportamiento de un solo uso.

byte[] canary = new byte[4096];
Arrays.fill(canary, (byte) 0x5a);
byte[] src = (("A".repeat(64)) + "=").getBytes(StandardCharsets.US_ASCII);

for (int i = 0; i < 200_000; i++) {          // fuerza a C2 a compilar el intrínseco
    sink += decoder.decode(valid64, new byte[64]);
}

try { decoder.decode(src, canary); } catch (IllegalArgumentException expected) { }

for (int i = 50; i < canary.length; i++) {
    if (canary[i] != (byte) 0x5a) throw new AssertionError("escritura fuera de límites en " + i);
}

Tres detalles marcan la diferencia entre una prueba real y una que pasa sin probar nada. El bucle de calentamiento debe estar en la misma JVM y superar el umbral de C2: 200.000 no es arbitrario, está por encima de las 35.000–40.000 medidas en un servidor lento. La aserción debe recorrer el canario después de la región dentro de límites, no el valor devuelto, porque el valor devuelto es una excepción. Y la llamada hostil debe ser la primera tras el calentamiento, o ir precedida de otro calentamiento, porque el intrínseco se consume con el uso.

Merece la pena añadir dos comprobaciones más si se mantiene una compilación en lugar de consumirla:

  • afirmar que un arreglo de destino dimensionado exactamente a decodedOutLength() deja intacto a su vecino —es el caso que la prueba publicada no cubre—;
  • afirmar las dos longitudes de la clase % 64 ∈ {1,2} (65 y 129), para que una compilación de JDK 17 no pase por probarse con el corpus equivocado.

Si se consumen runtimes en lugar de compilarlos, la prueba equivalente es una verificación puntual contra cada etiqueta que se ponga en una imagen base, con el resultado registrado junto al digest de la imagen.

Qué hacer hoy

Para una flota en producción el árbol de decisión es corto.

  1. ¿Hay algún servidor expuesto? grep -m1 '^flags' /proc/cpuinfo y buscar las cuatro: avx512f, avx512bw, avx512vbmi, bmi2. EPYC/Ryzen Zen 4 o posterior, Xeon Ice Lake o posterior. Si las banderas no están, el stub vulnerable nunca se selecciona, diga lo que diga la versión.
  2. ¿Qué compilación se está usando? java -XshowSettings:properties -version y leer java.runtime.version, no java.version. 21.0.13.0.3 y 21.0.13.1 están a un carácter de distancia y en lados opuestos del parche; lo mismo pasa con 21.0.13.1.2 de Corretto.
  3. Verificar por comportamiento. Ejecutar la sonda anterior contra la imagen exacta que se despliega. Dos minutos, sin privilegios y sin reiniciar nada importante.
  4. Parchear y volver a verificar. Compilaciones corregidas que confirmé por medición: Zulu 21.0.13.1+2-LTS y Corretto 21.0.13.1+2-LTS, ambas del 17 de noviembre. Las dos lanzan excepción y no escriben nada.
  5. Usar las banderas solo como puente. -XX:-UseBASE64Intrinsics si no se puede parchear en días; evitar -XX:UseAVX=2 salvo que se haya medido el coste de rendimiento en la carga propia, y nunca ponerla en una configuración compartida con nodos ARM.
  6. No confiar en una prueba de 65 bytes en JDK 17. El corpus que encuentra esto en 21 no lo encuentra en 17.

Y un punto que no es urgente y conviene hacer igualmente: revisar si algún servicio decodifica Base64 controlado por el atacante en un búfer dimensionado por quien llama. Ese patrón es la diferencia entre un desbordamiento dentro de un arreglo de trabajo y un desbordamiento sobre la cabecera de un objeto vivo. Es el mismo tipo de problema que los valores por defecto de chrome-devtools-mcp que pasan la revisión de código y aun así leen /etc: nada en la superficie de la API dice qué comportamiento se está recibiendo.

Preguntas frecuentes

¿Está explotada mi aplicación si su JDK está afectado? Nada en el registro público muestra explotación en la naturaleza al 18 de noviembre de 2026, y el bloque SSVC del NVD registra exploitation: none y automatable: no. Las cadenas específicas de producto están retenidas, así que la ausencia de informes no es prueba de ausencia —pero no hay gusano, ni escáner, ni carga pública—.

¿Por qué lanza excepción si la memoria ya se corrompió? El stub devuelve el número de bytes que logró decodificar y se detiene en la cola inválida; la capa Java lanza IllegalArgumentException por la misma entrada. La escritura ocurre dentro del stub, antes de cualquier validación de la capa Java. El manejador de excepciones se ejecuta sobre un montón que puede estar ya modificado.

¿Afecta a la codificación en Base64? El código vulnerable es generate_base64_decodeBlock. La codificación tiene su propio stub; ni el aviso, ni el commit, ni mis mediciones implican al codificador.

¿Contenedores y runtimes gestionados se ven distintos? Solo por el número de compilación. El mismo servidor, las mismas banderas y la misma entrada de 65 bytes produjeron 62 bytes de corrupción en una compilación de Zulu y cero en la siguiente. Las etiquetas de nodo de Kubernetes, el java.version y los nombres comerciales del fabricante no los distinguen; la cadena de compilación del runtime y una sonda son las únicas comprobaciones fiables.

¿Y ARM? No afectado según la documentación, y el stub de C2 es solo x86-64. Ojo: -XX:UseAVX=2 no se reconoce en JVM de ARM y le impide arrancar, lo que importa en despliegues de arquitectura mixta bajo una misma configuración.

¿La diferencia entre 9,2 y 8,1 indica que la investigadora exageró? Indica que las dos puntuaciones usan sistemas distintos y supuestos distintos sobre la complejidad de ataque. El 9,2 asume CVSS 4.0 y un atacante que ya resolvió el grooming del montón; el 8,1 de Oracle mantiene AC:H, que es el término honesto para una cadena que depende de que G1 coloque las regiones donde se quiere. Ambas coinciden en el vector de impacto: confidencialidad, integridad y disponibilidad completas.

¿Una compilación corregida cambia el comportamiento de mis pruebas de entrada malformada? No. En todas las compilaciones —vulnerables o parcheadas— la entrada de 65 bytes lanza IllegalArgumentException. Lo único que cambia es si antes se escribe memoria. Por eso este fallo necesitó veinte años de «Java es seguro en memoria» para esconderse, y por eso las pruebas que parecen correctas son las que no lo detectan.

Conclusión

Lo interesante de Java4Shell no es que Java tuviera un fallo de seguridad de memoria. Es el tamaño de la brecha entre lo que significa publicar un runtime y lo que cualquiera puede verificar de él.

Cuatro líneas de ensamblador, un archivo, ninguna prueba, un commit titulado «Base64 optimization improvements», publicado un día antes de la divulgación. Dos compilaciones separadas por cuatro semanas cuya única diferencia visible es un .0.3 frente a un .1. Una tabla de versiones que lista Java 8 y 11 como afectadas por un defecto que sus runtimes no pueden alcanzar. Una prueba publicada cuyo búfer de 4.096 bytes convierte un desbordamiento de montón en una aserción ordenada dentro del arreglo. Y una primitiva de explotación que se consume con su primer uso, de modo que el reintento ingenuo de un arnés de pruebas informa «seguro».

Cada pieza es razonable por separado. Juntas describen una clase de fallo que la documentación no puede zanjar y que solo una sonda contra el binario exacto resuelve. Si hay que quedarse con una idea: la sonda son veinte líneas y dos minutos, y es la única afirmación de este artículo que no se puede obtener de segunda mano.

Parchear primero. Después ejecutar la sonda y guardar la salida junto al digest de la imagen.