Artículos en profundidad sobre la tecnología que da forma al futuro.

Desbordamiento en OpenSSL EVP_EncodeBlock: 5 mitos

Desbordamiento en EVP_EncodeBlock de OpenSSL (CVSS 9.8): cinco mitos sobre la seguridad de los codificadores base64, puestos a prueba.

Un enorme embudo vierte cubos brillantes en un vaso pequeño que se desborda.
EVP_EncodeBlock confía en que el llamador dimensionó bien el vaso; nunca lo comprueba.

Una función que solo convierte bytes en texto base64 acaba de recibir una puntuación CVSS de 9.8. El desbordamiento de búfer en EVP_EncodeBlock de OpenSSL, catalogado como CVE-2026-121481, es el tipo de fallo que suena aburrido hasta que te das cuenta de que la codificación base64 está debajo del manejo de certificados, los clientes HTTP, la autenticación en proxies y la mitad del código de pegamento de tu infraestructura. La corrección en sí tomó cuatro commits y una discusión bastante acalorada entre los mantenedores sobre cómo debería ser, en realidad, un valor de retorno de error.

La discusión en torno a este CVE es un regalo para cualquiera que se preocupe por el diseño de APIs, porque deja al descubierto un montón de suposiciones que los ingenieros hacen sobre las funciones de codificación, suposiciones que siguen produciendo la misma clase de fallo durante décadas y en distintas bibliotecas. Tomemos cinco de las creencias más comunes y comparémoslas con lo que pasó realmente.

Cómo funciona realmente el desbordamiento en EVP_EncodeBlock

La codificación base64 infla los datos: cada tres bytes de entrada se convierten en cuatro caracteres de salida. Por tanto, el tamaño de salida es 4 * ((n + 2) / 3), más uno para el terminador NUL si quieres una cadena C. EVP_EncodeBlock() de OpenSSL obliga al llamador a calcular ese tamaño y reservar el búfer de destino. La función recibe el puntero de entrada, el puntero de salida y la longitud de entrada, como int. Nunca sabe lo grande que es el búfer de salida, así que no puede validar nada. Simplemente escribe.

Ahora hagamos la aritmética. El int más grande es 2.147.483.647. Cuando la longitud de entrada supera (INT_MAX / 4) * 3, es decir, 1.610.612.733 bytes, unos 1,6 GB, el cálculo interno del tamaño desborda un entero con signo de 32 bits. La aritmética de longitudes da la vuelta, la idea que tiene la función de dónde termina la salida deja de coincidir con la realidad y acabas escribiendo más allá del final de cualquier búfer que haya reservado el llamador. El llamador, siguiendo la fórmula documentada, hizo la misma aritmética desbordada, así que ambos lados pueden discrepar de forma catastrófica sobre cuánto espacio existe.

La corrección upstream añadió una guarda: rechazar entradas donde dlen > (INT_MAX / 4) * 3, además de búferes NULL y longitudes negativas. Si envuelves esta API, y deberías hacerlo, la comprobación también debe ir en tu frontera:

#include <limits.h>
#include <stddef.h>
#include <openssl/evp.h>
/*
* Mirrors the upstream guard: refuse inputs whose encoded size
* cannot be represented in an int, and verify the destination
* capacity ourselves since the API never sees it.
*/
int b64_encode_checked(const unsigned char *in, size_t n,
unsigned char *out, size_t out_cap)
{
size_t need;
if (in == NULL || n > ((size_t)INT_MAX / 4) * 3)
return -1;
need = ((n + 2) / 3) * 4 + 1;   /* +1 for the NUL terminator */
if (out == NULL || out_cap < need)
return -1;
if (EVP_EncodeBlock(out, in, (int)n) < 0)
return -1;
return 0;
}

Fíjate en lo que te obliga a hacer esta API: reimplementar la fórmula interna de tamaño de la biblioteca, en el llamador, correctamente y para siempre. Ese contrato es la verdadera vulnerabilidad. El desbordamiento es solo el punto donde el contrato finalmente se rompió.

Mito 1: «Los decodificadores son la superficie de ataque, los codificadores son aburridos»

La cultura de revisión de seguridad tiene un sesgo fuerte: parsear es peligroso, serializar es contabilidad. Los decodificadores consumen bytes hostiles, así que se someten a fuzzing, auditorías y se reescriben en lenguajes seguros en memoria. Los codificadores producen salida, y la salida parece segura. Esta creencia es errónea de una forma concreta y repetible: los fallos de los codificadores viven en el cálculo del tamaño de salida, y esa aritmética es de confianza para ambos lados de la llamada.

El patrón se repite. El propio hilo del PR señala que CVE-2026-121481 se parece a CVE-2021-23840, un desbordamiento anterior de OpenSSL en las funciones EVP update, donde un cálculo de longitud desbordaba con entradas enormes. Y en base64 concretamente hay antecedentes: cuando el decodificador Base64 de OpenJDK convirtió 65 bytes en ejecución remota de código, escribimos sobre cómo un códec «trivial» se convirtió en una primitiva de RCE. Los decodificadores reciben CVE por aceptar entradas malas; los codificadores, por calcular mal entradas buenas. Ambos son la misma especie: aritmética sobre longitudes que influye un atacante.

Veredicto: mito desmontado. Si tu modelo de amenazas se detiene en el parser, has dejado la puerta trasera abierta mientras vigilabas la delantera.

Mito 2: «CVSS 9.8 significa dejarlo todo esta noche»

Aquí voy a defender un poco a los escépticos. Un 9.8 en un codificador que necesita una entrada de 1,6 GB no es Heartbleed. En ningún lugar del handshake TLS se codifica en base64 una gran cantidad de datos: los certificados viajan como DER dentro de TLS, no como PEM. Para que esto te afecte, datos no confiables tienen que llegar a EVP_EncodeBlock() (o a un llamador interno como base64encode() en el cliente HTTP de OpenSSL) a una escala superior a 1,6 GB. Un campo de protocolo con un prefijo de longitud de 16 bits nunca llegará allí.

Pero calificarlo de «sintético» también lo minimiza. El reportante demostró una ruta real desde la línea de comandos: pasar un valor enorme de -proxy_pass a openssl s_client, suministrado mediante una variable de entorno para esquivar los límites de argumentos del shell, y ciertas configuraciones (los motores GOST aceptan contraseñas sobredimensionadas de serie) lo codificarán en base64 sin problemas para una petición CONNECT a un proxy. Eso no es una curiosidad de laboratorio; es una herramienta estándar haciendo autenticación estándar en un proxy con una variable de entorno estándar.

Mi postura: trata CVSS como una medida de la función, y tu grafo de llamadas como la medida de tu exposición. Antes de programar una ventana de parche de emergencia, busca en tu código y en tus dependencias quién codifica qué y hasta qué tamaño puede llegar la entrada. Luego parchea igualmente, pero en el orden correcto. Veredicto: medio cierto. La puntuación es real, pero la alarma debe ser proporcional a la alcanzabilidad, y la alcanzabilidad es una pregunta que solo tu código puede responder.

Mito 3: «La solución es fácil: basta con devolver un código de error»

Esta es mi parte favorita de toda la historia, porque el desbordamiento era lo simple. Lo difícil fue decidir qué debía hacer EVP_EncodeBlock() al respecto, y los mantenedores no lograron ponerse de acuerdo.

El parche original devolvía -1 ante entradas inválidas, siguiendo la capa de compatibilidad de wolfSSL y las rutas de fallo existentes en EVP_DecodeBlock(). La oposición llegó enseguida. Un mantenedor temía que los llamadores de terceros convirtieran el valor de retorno a size_t sin comprobarlo, y con ese cast -1 se convierte en SIZE_MAX, lo cual es quizá peor que el desbordamiento que se pretende evitar. ¿Entonces devolver 0? Pero 0 ya es un éxito legítimo: codificar cero bytes devuelve cero. Como dijo un mantenedor, ya le había pasado antes levantar un error en un caso de éxito. Usa OPENSSL_assert(), propuso otro: aborta ante una violación del contrato y documenta la precondición. A lo que un mantenedor senior respondió, sin rodeos: un assert dentro de una biblioteca es «un DoS esperando a suceder».

Todas las opciones eran malas, y cada una por una razón distinta: -1 rompe los casts sin signo, 0 choca con el éxito, y el assert convierte un error lógico en un crash controlado por el atacante. Esto es lo que pasa cuando los semánticos de error de una API nunca se diseñaron, solo se heredaron. Es la brecha entre especificación e implementación en estado puro: la documentación decía «devuelve el número de bytes codificados», y nadie había escrito nunca qué pasa cuando codificar es imposible.

Hay dos detalles más del hilo que merecen atención. Primero, un revisor detectó que el parche inicial rechazaba f == NULL sin condiciones, pero codificar un búfer vacío con puntero de entrada NULL y dlen == 0 siempre había funcionado, y aplicaciones reales dependían de ello. Incluso la validación «obviamente correcta» rompió un caso límite legítimo. Segundo, un revisor buscó llamadas que no comprobaran el valor de retorno y las encontró dentro del propio OpenSSL: PEM_SignFinal() y NETSCAPE_SPKI_b64_encode(). Hacer que una función pueda fallar no sirve de nada si sus llamadores se escribieron cuando no podía fallar. Veredicto: mito desmontado, a conciencia. Los semánticos de error son diseño de API, y retrofitarlos es cirugía, no un parche.

Una vía de tren se divide en tres caminos divergentes en la niebla del atardecer.
Devolver -1, devolver 0 o assert: cada rama del debate sobre la corrección tenía su propio peligro.

Mito 4: «Nadie le pasa un gigabyte a un codificador base64»

La intuición aquí es que base64 sirve para cosas pequeñas: certificados, claves, tokens cortos. Y en su mayoría es cierto. Pero los sistemas modernos han crecido en silencio hasta manejar blobs enormes que se codifican constantemente: documentos de attestation, respuestas SAML, manifiestos de imágenes de contenedor, credenciales de proxy, cargas de webhooks que algún middlebox decide volver a codificar. El reproductor de este CVE no era exótico: era una contraseña, entregada mediante una variable de entorno, en una ruta de código que codifica credenciales para un proxy HTTP. Nada de ese flujo se diseñó pensando en un techo de 1,6 GB, porque nadie escribió ese techo en ningún sitio.

También hay un hábito arquitectónico que lo empeora: las APIs de codificación de una sola llamada animan a leer el payload entero en memoria antes de transformarlo. OpenSSL tiene alternativas en streaming (EVP_EncodeInit(), EVP_EncodeUpdate(), EVP_EncodeFinal()) que procesan los datos por fragmentos y evitan el problema de «calcular el tamaño total de salida por adelantado». El streaming cuesta un objeto de contexto y un bucle. Lo que aporta es que ninguna longitud tiene que ser a la vez influenciable por el atacante y de confianza. Veredicto: mito desmontado. Las entradas crecen hasta chocar con un límite, y si ese límite es un desbordamiento de entero con signo, el límite acaba encontrándote a ti.

Mito 5: «Nuestros fuzzers lo habrían detectado»

No lo habrían hecho, y vale la pena entender por qué. Los fuzzers guiados por cobertura, como libFuzzer, usan por defecto longitudes máximas de entrada medidas en kilobytes: 4096 bytes de serie. Un fallo que necesita 1.600 millones de bytes de entrada no es simplemente improbable de encontrar; está fuera del espacio de búsqueda por completo. Podrías hacer fuzzing de EVP_EncodeBlock() durante un siglo sin rozar nunca el desbordamiento, porque el comportamiento interesante solo existe a una escala que el fuzzer nunca visitará.

La solución no son entradas de fuzzing más grandes; nadie quiere reservar 1,6 GB por iteración de fuzzing. La solución es probar la aritmética por separado de la codificación. Extrae el cálculo del tamaño y somete sus límites a pruebas unitarias sencillas:

#include <assert.h>
#include <limits.h>
/* Mirrors the upstream guard, computed in a wide type. */
static int encoded_len_fits_int(long long dlen)
{
return dlen >= 0 && dlen <= ((long long)INT_MAX / 4) * 3;
}
int main(void)
{
long long limit = ((long long)INT_MAX / 4) * 3; /* 1,610,612,733 */
assert(encoded_len_fits_int(0));
assert(encoded_len_fits_int(limit));
assert(!encoded_len_fits_int(limit + 1));
assert(!encoded_len_fits_int(-1));
/* The encoded size at the limit must itself fit in an int. */
assert(4 * ((limit + 2) / 3) <= INT_MAX);
return 0;
}

Después añade una comprobación diferencial con tamaños moderados: calcula la longitud de salida esperada con tu fórmula del lado del llamador, codifica y verifica que la función escribió exactamente esa cantidad de bytes y ni uno más. Ejecuta todo bajo AddressSanitizer con entradas de unos cientos de megabytes en CI: lo bastante grandes para ejercitar los bucles amplios, lo bastante pequeñas para terminar antes de comer. El fuzzing sigue siendo la herramienta adecuada para la lógica a nivel de bytes del códec; simplemente nunca fue la herramienta adecuada para el desbordamiento de enteros a gran escala, y confundir esos dos trabajos es lo que hace que fallos como este sobrevivan una década de fuzzing continuo. Veredicto: mito desmontado.

Cómo auditar una API de codificación antes de que te audite a ti

Tanto si revisas el uso de OpenSSL en tu propio código como si evalúas la ruta de codificación de cualquier biblioteca, el mismo puñado de preguntas detecta esta clase de fallo completa:

  • ¿Quién calcula el tamaño de salida? Si lo hace el llamador con una fórmula no trivial, ambos lados pueden desfasarse. Prefiere APIs que reciban la capacidad de salida como parámetro y que fallen limpiamente cuando sea insuficiente.
  • ¿Qué tipo entero transporta las longitudes? Un parámetro de longitud int es un techo de 2 GB con un bit de signo añadido. size_t no hace imposible el desbordamiento, pero desplaza el techo más allá del borde de cualquier búfer que realmente puedas reservar en una máquina de 64 bits.
  • ¿Qué pasa con cero, en el límite y uno más allá? Entrada vacía, exactamente (INT_MAX/4)*3 y ese valor más uno son los tres casos de prueba que importan.
  • ¿La función se volvió recientemente falible? Si un parche añadió retornos de error a algo que antes no podía fallar, busca en todos los sitios donde se llama. Los retornos sin comprobar convierten un fallo corregido en uno silencioso.
  • ¿Existe una variante en streaming? Las APIs fragmentadas encode/update/final eliminan la necesidad de confiar en una única longitud total.

Voy a ir más allá en el primer punto: cualquier API que obligue al llamador a replicar la fórmula interna de tamaño de la biblioteca es una fábrica de fallos, y la industria debería dejar de construirlas. El invocado conoce el factor de expansión, las reglas de relleno y la convención del terminador. Obligar a cada llamador a volver a derivar 4 * ((n + 2) / 3) + 1 garantiza que alguien, en algún sitio, lo haga mal, o que lo haga bien en un tipo demasiado pequeño.

Una lupa inspecciona bloques brillantes en una cinta transportadora; uno está agrietado.
Las auditorías de codificadores deben centrarse en la aritmética del tamaño, no solo en el trasiego de bytes.

Conclusión sobre base64 y más allá

CVE-2026-121481 desaparecerá de los feeds en una semana, pero la clase de fallo no. Las funciones de codificación viven en el punto ciego de la revisión de seguridad: se confía en ellas con longitudes, se las exime de fuzzing a gran escala y se envuelven en APIs cuyo comportamiento de error nunca se especificó. Los mantenedores de OpenSSL dedicaron más palabras a discutir si devolver -1, 0 o caer que al propio desbordamiento, y tuvieron razón, porque esa es la parte con la que vivirá cada consumidor durante años.

Así que sí, parchea, pero también revisa. Localiza tus llamadas de codificación, comprueba quién calcula el tamaño del búfer, verifica que los retornos se comprueben de verdad y pasa cualquier cosa que maneje datos masivos no confiables a una API de streaming. El próximo 9.8 en un codificador ya está en la fórmula de tamaño de alguien, esperando una entrada lo bastante grande para encontrarlo.