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

Regex en Ruby: vulnerabilidades del case folding Unicode

Siete fallos de regex y conversión de mayúsculas en Ruby demuestran que el case folding Unicode es un riesgo de memoria. Cómo auditar tu código.

Un bloque de tipo de imprenta que se divide en dos bloques más pequeños sobre una bandeja de impresor
Que un carácter se convierta en dos es todo el problema: la eszett alemana en mayúscula pasa a SS y la aritmética del búfer se va al traste.

Una aplicación Rails normaliza las direcciones de correo llamando a upcase antes de guardarlas, tal como recomiendan mil tutoriales. Un usuario se registra con mueller@straße.example en un formulario que, en algún punto del pipeline, decidió que Windows-1252 era una codificación perfectamente válida. La llamada a upcase convierte la ß final en SS, dos bytes donde antes había uno, y escribe uno de esos bytes más allá del final de un búfer en el heap. Esto no es hipotético. Es una reconstrucción plausible de una de las siete vulnerabilidades de conversión de mayúsculas y regex en Ruby que el equipo core acaba de parchear, varias de ellas con pruebas de concepto de ejecución remota de código.

El aviso salió junto con tres versiones de emergencia (Ruby 4.0.10, 3.4.13 y 3.3.14) y es un caso de estudio útil sobre una verdad más profunda: la conversión de mayúsculas parece la operación más simple de una librería de strings y, en realidad, es una de las más peligrosas. Ahí es donde la extensa especificación de Unicode se encuentra con código C de décadas de antigüedad, y justo en esa costura es donde crecen los desbordamientos de heap.

Siete fallos, dos subsistemas, una sola causa raíz

Los siete avisos (rastreados por identificadores GHSA mientras los números CVE avanzan por un proceso de asignación atrasado) se agrupan en dos familias. Dos afectan a la conversión de mayúsculas de String: un desbordamiento de heap de un byte y un desbordamiento de entero que deriva en un desbordamiento de heap. Cinco afectan al motor de expresiones regulares de Ruby: un double free durante la compilación del patrón, un desbordamiento de entero durante la compilación, una lectura fuera de límites en la coincidencia sin distinción de mayúsculas, una lectura fuera de límites en la coincidencia de referencias hacia atrás sin distinción de mayúsculas, y un desbordamiento de búfer en el heap en Regexp#to_s.

Fíjate en lo que tienen en común. No es programación descuidada en el sentido habitual: el núcleo en C de Ruby es antiguo, probado en batalla y fuzzeado a fondo. Lo que pasa es que ambos subsistemas implementan la semántica de mayúsculas de Unicode, y esa semántica es una trampa. La coincidencia de regex sin distinción de mayúsculas requiere plegar tanto el patrón como la entrada, lo que significa que el motor usa las mismas tablas de mapeo traicioneras que String#upcase, solo que en una ruta más caliente y con más influencia del atacante sobre las entradas. Las referencias hacia atrás en modo sin distinción de mayúsculas deben comparar subcadenas plegadas. Regexp#to_s tiene que volver a emitir el texto fuente de un patrón con sus opciones, dimensionando un búfer para una reconstrucción que en sí misma involucra lógica sensible a mayúsculas. Cada una de estas rutas de código tiene que responder a la misma pregunta engañosamente difícil: ¿cuánto mide esta cadena después de cambiar sus mayúsculas?

Ruby 3.3 recibe el parche porque sigue en mantenimiento de seguridad. Ruby 3.2 y anteriores están al final de su vida útil y no reciben nada: si estás en alguna de esas versiones, este aviso es tu fecha límite de migración, no una advertencia.

Breve historia de la conversión de mayúsculas cuando sale mal

En ASCII, cambiar la capitalización es un simple cambio de bit. Veintiséis pares de letras, uno a uno, sin alterar la longitud e independientes de la configuración regional. toupper() del C de la era K&R encarna toda la idea en una sola tabla de búsqueda. Es el modelo mental que la mayoría de nosotros arrastramos desde la juventud, y es el modelo incrustado en la lógica de dimensionamiento de búferes de medio mundo del código C. También es incorrecto para prácticamente cualquier sistema de escritura más allá del latín básico.

Unicode define miles de mapeos de mayúsculas, y una porción significativa de ellos no son uno a uno. La eszett alemana (ß) pasa a mayúsculas como SS. La ligadura ff pasa a FF. Las ligaduras armenias se expanden. El griego tiene la sigma sensible al contexto (σ frente a ς al final de palabra), así que el plegado correcto depende de los caracteres que la rodean. El turco y el azerí tienen el problema de la I con y sin punto: i pasa a İ y ı pasa a I, lo que rompió de forma célebre desde aplicaciones Java hasta el strtoupper de PHP en configuraciones regionales turcas. Y al cherokee se le añadieron minúsculas retroactivamente en Unicode 8.0, en 2015, convirtiendo en escritura con mayúsculas y minúsculas lo que era una escritura sin caja, e invalidando suposiciones en software de todo el mundo.

Las codificaciones heredadas empeoran las cosas. Windows-1252 tiene un byte para la ß minúscula (0xDF), pero ningún byte para una versión mayúscula hipotética, porque históricamente el alemán nunca usó una en el texto corrido: se escribía SS. Así que cuando una rutina de conversión que opera sobre una cadena Windows-1252 se encuentra con ß y sustituye correctamente por SS, la cadena crece un byte. El análisis detallado que circula tras el aviso sugiere que este es exactamente el desbordamiento de un byte: el bucle de conversión parece comprobar el espacio disponible en el búfer carácter a carácter, de modo que una ß situada como último carácter de una cadena con tamaño muy ajustado produce una S extra escrita más allá de la asignación. Un desbordamiento de un byte con una S controlada por el atacante es una primitiva de explotación bastante incómoda y delicada, pero el aviso confirma que existen PoC que logran RCE, así que alguien hizo el trabajo de preparar el heap.

La conversión de mayúsculas no es biyectiva, no conserva la longitud, no es independiente de la configuración regional y no es representable en todas las codificaciones. El código que asume lo contrario es una vulnerabilidad esperando a un fuzzer.

Por qué el motor de regex es la preocupación mayor

El motor de regex de Ruby es Onigmo, una bifurcación de Oniguruma, y es una pieza de software realmente impresionante: maneja decenas de codificaciones, plegado completo de mayúsculas Unicode, lookbehind, grupos con nombre y referencias hacia atrás, todo en C, con capas que se remontan a finales de los noventa. Esas capas son el problema. En Onigmo, la coincidencia sin distinción de mayúsculas significa que cada punto de comparación puede ejecutar lógica de plegado, y el plegado cambia longitudes, así que la contabilidad entre los desplazamientos del patrón, los de la cadena y los límites de coincidencia es realmente intrincada. Dos de los errores corregidos son lecturas fuera de límites justo en esa maquinaria: una en la coincidencia sin distinción de mayúsculas en general, y otra específicamente en la coincidencia de referencias hacia atrás sin distinción de mayúsculas, donde el motor compara una subcadena capturada previamente (y plegada) con la posición actual.

Sin embargo, el modelo de explotación importa más que los detalles internos. Tres de los cinco fallos de regex se activan durante la compilación del patrón, y el aviso es tajante sobre quién está expuesto: aplicaciones que compilan patrones controlados por el atacante. Te parecerá raro. No lo es. Cada cuadro de búsqueda envuelto en Regexp.new(query), cada regla de validación configurable cargada desde una base de datos, cada capa de análisis de logs o de enrutamiento que construye patrones a partir de archivos de configuración que controla un operador (o un tenant comprometido): todo eso es una ruta de compilación alcanzable con entrada hostil. Antes de este aviso, el peor caso al compilar un patrón hostil era un ReDoS: un patrón de backtracking catastrófico que deja una CPU al 100 %. Molesto, pero recuperable. Ahora el peor caso es corrupción de memoria con PoC de RCE. Es un riesgo categóricamente distinto para la misma línea de código que llevas años en producción.

Hay un patrón aquí que merece nombrarse: la especificación dice una cosa, el C dice otra, y la brecha es explotable. Ya hemos tratado esta dinámica antes (la brecha entre especificación e implementación es donde viven los bugs) y las tablas de plegado de mayúsculas de Unicode son una de las especificaciones más ricas que se le pueden pedir a un programador en C. Las tablas cambian entre versiones de Unicode, las reglas de casos especiales tienen subcláusulas, y la persona que escribió el código de dimensionamiento de búferes en 2003 trabajaba con un Unicode más pequeño y sencillo que el que llega hoy a tus cadenas.

El desbordamiento de entero: cuatro gigabytes se convierten en seis bytes

El segundo error en cadenas es una gran ilustración de un modo de fallo diferente: aritmética de longitudes de 32 bits en un mundo de 64 bits. Esta prueba de concepto, que circula públicamente tras el aviso, usa Shift_JIS y una cadena de más de cuatro gigabytes:

str = ("\x82\xA0" + ("A" * (2**32 + 4))).force_encoding(Encoding::Shift_JIS)
puts "str.bytesize: #{str.bytesize}"   # 4294967302
new_str = str.downcase
puts new_str.bytesize   # 6 on unpatched builds (!)
puts new_str.bytes      # [130, 160, 97, 97, 97, 97]

Entra una cadena de 4.294.967.302 bytes y el resultado en minúsculas informa un tamaño de 6. En algún punto de la ruta de conversión, una longitud se calculó o se truncó mediante un tipo de 32 bits: 2³² + 6 se envolvió a 6, y la asignación o copia posterior se dimensionó en consecuencia. Es una cadena clásica de desbordamiento de entero que deriva en desbordamiento de heap. Cuatro gigabytes suena a entrada absurda, pero recuerda que las cadenas en un proceso en ejecución no tienen que llegar por la red de una sola vez: se construyen a partir de fragmentos, de descompresión, de concatenaciones en trabajos de importación y analizadores de archivos. Un atacante que pueda influir en cuántos datos se acumulan en una cadena, y luego lograr que se llame a downcase sobre ella, controla ambas mitades de este error.

Ambos errores de cadenas comparten una lección arquitectónica con el error de asterisco de Alpine, de hace una década: el código peligroso está en una ruta que nadie considera superficie de ataque. Nadie hace modelado de amenazas de upcase. Por eso estos errores sobreviven años: han estado en caminos que los humanos no auditan y que, hasta hace poco, los fuzzers no alcanzaban con suficiente inteligencia como para construir cadenas multibyte válidas.

Las máquinas encontraron estos errores, y eso cambia las cuentas

Mira los créditos. Cuatro de los siete avisos agradecen a Stephan Lipp de Ada Logics (la firma detrás de gran parte del desarrollo de los arneses de OSS-Fuzz) y a Anthropic. Es un experto en infraestructura de fuzzing emparejado con un modelo de IA, y no es el primer aviso reciente con esa firma. La genealogía merece reconocerse: el fuzzing empezó con Barton Miller alimentando utilidades de Unix con basura aleatoria en 1990, se volvió más listo con la mutación guiada por cobertura de AFL en 2013, se industrializó con OSS-Fuzz martillando proyectos de código abierto de forma continua desde 2016, y ahora ha ganado una capa capaz de razonar sobre el código: construir una cadena Shift_JIS de 4 GiB o un búfer Windows-1252 que termina en ß requiere entender la validez de las codificaciones y la aritmética de longitudes, no solo mutar bytes.

Un brazo mecánico de escaneo inspeccionando tarjetas perforadas en una cinta transportadora, con una tarjeta brillando
El fuzzing guiado por cobertura combinado con razonamiento de modelos de lenguaje está auditando código C antiguo más rápido de lo que nunca podrían hacerlo los humanos.

La implicación estratégica corta en ambos sentidos. Los defensores ganan una auditoría continua e incansable de bases de código que ningún equipo podría permitirse revisar a mano. Pero esa misma capacidad está al alcance de cualquiera con un modelo y cómputo, y no todo el mundo presenta avisos. Se acabó la época cómoda en la que un error de corrupción de memoria en una ruta de código oscura podía esperar años de vida tranquila; la economía de encontrarlos se ha desplomado. Ya he defendido que los escáneres de seguridad con IA están cobrando nuestra deuda técnica, y esto es el recibo: un runtime de lenguaje usado por millones, puesto en evidencia no por un investigador aburrido con un fin de semana libre, sino por un pipeline automatizado que simplemente seguirá ejecutándose.

Mi postura: esto refuerza el argumento a favor de los lenguajes con seguridad de memoria, pero no de la manera superficial en que suele enmarcarlo el debate. Reescribir Onigmo en Rust no habría arreglado la lógica: el plegado de mayúsculas que cambia la longitud de una cadena sigue siendo un peligro a nivel de especificación, y la pregunta del tamaño del búfer aún debe responderse correctamente. Lo que la seguridad de memoria elimina es el gradiente de consecuencias. El error de lógica se convierte en un pánico, un resultado incorrecto, una petición fallida, no en RCE. Eso no es poca cosa: es la diferencia entre un incidente y un aviso de caída.

Cómo auditar tu propia exposición

Empieza por lo obvio y ve hacia fuera. Actualiza a 4.0.10, 3.4.13 o 3.3.14: Onigmo está incrustado en la compilación de Ruby, así que no hay una biblioteca separada que parchear; el runtime es el parche. Después audita el código de tu aplicación en busca de las dos formas peligrosas: cadenas influidas por el atacante que fluyen hacia operaciones de mayúsculas, y patrones influidos por el atacante que fluyen hacia Regexp.new o Regexp.compile.

  • Deja de compilar la entrada del usuario en patrones. Si los usuarios proporcionan términos de búsqueda, escápalos con Regexp.escape. Si de verdad necesitan el poder de las regex, pon delante una lista de permitidos y un timeout estricto, y ten en cuenta que un timeout ayuda con el ReDoS, no con la corrupción de memoria.
  • Normaliza las codificaciones en la frontera de confianza. Los dos errores de cadenas dependen de codificaciones exóticas (Windows-1252, Shift_JIS). Si tu app solo habla UTF-8, dilo en los bordes: fuerza o transcodifica la codificación en la entrada y rechaza lo que no convierta limpiamente.
  • Prefiere la comparación sin distinción de mayúsculas a la conversión de mayúsculas. a.casecmp?(b) hace una pregunta; a.upcase == b.upcase asigna dos cadenas nuevas en la codificación que declare la entrada. La API de comparación tiene una superficie semántica mucho más pequeña.
  • Busca upcase, downcase, swapcase y capitalize en datos no confiables. Cada llamada es un lugar donde vive una suposición sobre la longitud. Lo mismo vale para cualquier extensión en C que hayas escrito y que haga su propia lógica de mayúsculas: esas no se benefician en absoluto de las correcciones del equipo core.
  • Haz fuzzing de lo que es tuyo. Ruby en sí lo pasa OSS-Fuzz, pero tus extensiones en C no. AFL++ o libFuzzer con ASan encontrarán en tu código las mismas clases de error que las máquinas acaban de encontrar en Ruby.
  • Conoce el estado de mantenimiento de tu runtime. Ruby 3.2 está al final de su vida útil y no recibió estas correcciones. «Sigue funcionando» no es una postura de seguridad cuando el flujo de parches se ha detenido.

Un antes y un después para el patrón más común (normalizar nombres de usuario o correos para comprobar unicidad):

# Before: allocates a new string, trusting the input's claimed encoding
def normalize(username)
username.upcase
end
# After: pin the encoding at the boundary, fold for comparison only
def normalize(username)
utf8 = username.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
utf8.downcase(:fold)
end
# And for comparisons, skip allocation entirely:
def same_user?(a, b)
a.encode(Encoding::UTF_8).casecmp?(b.encode(Encoding::UTF_8))
end

Nada de esto te protege en un runtime sin parchear: para eso sirve la actualización. Pero estos hábitos reducen la clase de errores que tu aplicación puede heredar de la capa inferior y hacen que tu propio código sea honesto sobre un hecho: el texto no son bytes.

Candados sobre una mesa de trabajo, uno abierto bajo una lupa junto a herramientas finas
Auditar tu exposición: las cerraduras que no instalaste tú también son tuyas.

La lección más profunda para los runtimes de lenguajes

Hay la tentación de archivar esto bajo «C es peligroso, más en el próximo capítulo», y las respuestas superficiales al aviso hicieron exactamente eso. Pero yo iría más lejos. Estos siete errores no tratan realmente sobre C: tratan sobre la discrepancia entre un estándar de internacionalización en evolución y suposiciones de implementación congeladas. Unicode seguirá añadiendo escrituras y afinando mapeos. Cada runtime de lenguaje del planeta tiene código de conversión de mayúsculas escrito contra alguna versión pasada de esas tablas, dimensionado según alguna comprensión pasada de cuánto puede crecer una cadena. Ruby ha caído este mes; lo siguiente será el motor de regex, el plegador de mayúsculas o la rutina de normalización de otra persona.

La conclusión práctica es tratar la transformación de texto como una frontera de seguridad, no como una función utilitaria. Todo lo que recodifica, cambia mayúsculas, normaliza o pliega es un parser, y los parsers son donde viven los errores de memoria. La conclusión histórica (la que, como nerd de los lenguajes, encuentro genuinamente satisfactoria) es que la humilde ß alemana, una letra con la que los impresores batallan desde la época de la Fraktur, puede todavía atravesar seis siglos de historia tipográfica y escribir un byte más allá del final de un búfer en el heap. El lenguaje nunca fue simple. Solo que construimos nuestras máquinas suponiendo que sí lo era.