Ruby Regexp RCE: siete fallos corregidos en 4.0.10 (CVE-2026-132825)
Siete fallos de memoria en el motor de expresiones regulares y la conversión de mayúsculas de Ruby pueden permitir ejecutar código. Corregidos en 4.0.10.
Resumen
- Siete fallos de memoria afectan al motor de expresiones regulares y la conversión de mayúsculas de Ruby. El proyecto Ruby dice tener conocimiento de una prueba de concepto que alcanza la ejecución de código en algunos escenarios, y publicó el aviso el 2026-11-19.
- Ruby 3.3.13 y anteriores, 3.4.0 a 3.4.12 y 4.0.0 a 4.0.9 están afectados. Las aplicaciones que convierten cadenas no confiables o compilan patrones no confiables son la exposición principal.
- Tres avisos son Críticos para GitHub; CVE-2026-132825 tiene CVSS v3.1 7.4 Alta. No se conoce explotación en entornos reales y ninguno de los siete está en el catálogo KEV de CISA al 2026-11-19.
- Actualice a Ruby 4.0.10, 3.4.13 o 3.3.14. Ruby 3.2 y anteriores no recibirán estas correcciones; consulte "¿Cómo lo corrijo?" para los comandos de actualización y las medidas parciales.
¿Estoy afectado?
Está expuesto cuando se cumplen todas estas condiciones:
- Ejecuta Ruby 3.3.13 o anterior, Ruby 3.4.0 a 3.4.12 o Ruby 4.0.0 a 4.0.9.
- Su aplicación pasa datos influidos por un atacante a la conversión de mayúsculas y minúsculas, o construye una expresión regular a partir de datos influidos por un atacante.
- La ruta de código afectada usa una codificación que activa el fallo. El desbordamiento de la sharp s necesita una codificación de un solo byte, como ISO-8859-1 o Windows-1252. Los fallos del motor de coincidencia necesitan UTF-16, UTF-32 o Emacs-Mule.
Los fallos de conversión de mayúsculas y minúsculas también afectan al código que llama a String#upcase, String#downcase, String#capitalize, String#swapcase o String#casecmp?. Estos métodos son peligrosos sobre entradas no confiables. Los fallos de expresiones regulares afectan a Regexp.new y a los literales de expresión regular construidos en tiempo de ejecución. Un literal con un patrón fijo solo se ve afectado si la cadena de destino activa el fallo del motor de coincidencia.
Ruby 3.2 y anteriores han alcanzado el fin de su vida útil. El aviso indica que no recibirán estas correcciones.
| Rama | Versiones afectadas | Versión corregida |
|---|---|---|
| Ruby 3.3 | 3.3.0 a 3.3.13 | 3.3.14 |
| Ruby 3.4 | 3.4.0 a 3.4.12 | 3.4.13 |
| Ruby 4.0 | 4.0.0 a 4.0.9 | 4.0.10 |
| Ruby 3.2 y anteriores | Todas las versiones | Sin corrección (fin de vida útil) |
Compruebe el intérprete que su aplicación usa realmente:
ruby -v
ruby -e 'puts RUBY_VERSION'
Para un contenedor en ejecución, compruebe dentro del contenedor, no en la imagen en disco:
docker exec <container> ruby -v
Compruebe también cualquier fijación de versión en el directorio de la aplicación:
cat .ruby-version
grep -A1 'RUBY VERSION' Gemfile.lock
¿Cómo lo corrijo?
Actualice a Ruby 4.0.10, 3.4.13 o 3.3.14. El proyecto Ruby publicó las tres versiones el 2026-11-18 y recomienda actualizar de inmediato.
- Con
rbenv, instale la versión corregida y selecciónela para la aplicación:bash rbenv install 4.0.10 rbenv global 4.0.10 rbenv rehash - Con RVM, instale y seleccione la versión corregida:
bash rvm install 4.0.10 --binary rvm use 4.0.10 --default - Con
asdfomise, instale la versión corregida y fíjela en el proyecto:bash asdf install ruby 4.0.10 asdf set -u ruby 4.0.10 - En un contenedor, use una etiqueta de imagen base actualizada y vuelva a crear el contenedor. Descargar una imagen nueva no cambia un contenedor en ejecución:
bash docker pull ruby:4.0.10 docker rm -f <container> docker run --name <container> ... ruby:4.0.10 - Reinicie todos los procesos Ruby después de la actualización. Puma, Unicorn, Sidekiq y cualquier trabajador de larga duración mantienen el intérprete antiguo en memoria hasta que se reinician.
- Si instala Ruby desde un paquete de distribución, compruebe si la distribución ha reconstruido el paquete. Una versión de paquete anterior al 2026-11-18 no contiene estas correcciones.
Si aún no puede actualizar, reduzca la exposición con estas medidas parciales:
- Fuerce las cadenas no confiables a UTF-8 antes de la conversión de mayúsculas y minúsculas. Esto evita la ruta de la sharp s de un solo byte, pero no cubre el desbordamiento de entero en
rb_str_casemapni los fallos de expresiones regulares. - No compile expresiones regulares a partir de patrones no confiables. Use un conjunto fijo de patrones y rechace la entrada que esté destinada a convertirse en un patrón. Esto reduce la exposición a los fallos de compilación y coincidencia, pero no es una corrección completa para un servicio que acepta patrones de forma legítima.
- Limite el tamaño de los patrones y de las cadenas de destino en el límite de la aplicación. Esto dificulta alcanzar la ruta del desbordamiento de compilación, pero no corrige la doble liberación ni las lecturas fuera de límites.
Ninguna de estas medidas sustituye la actualización.
¿Cuál es la causa raíz?
Ruby implementa la conversión de mayúsculas y minúsculas de cadenas y su motor de expresiones regulares en C. La conversión llama a una función case_map específica de cada codificación. El motor de expresiones regulares es Onigmo, que analiza un patrón, lo compila en un programa de bytecode y luego lo ejecuta. Los siete avisos cubren errores de seguridad de memoria en ese código. Incluyen un desbordamiento de un byte en la conversión de mayúsculas y minúsculas y un desbordamiento de entero en la contabilidad de los búferes de conversión. También incluyen una doble liberación durante el análisis de expresiones regulares y lecturas o escrituras fuera de límites en el compilador y el motor de coincidencia.
El desbordamiento de un byte está en los codificadores de un solo byte. Este es case_map en enc/iso_8859_1.c en la etiqueta 3.4.12:
while (*pp < end && to < to_end) {
code = *(*pp)++;
if (code == SHARP_s) {
if (flags & ONIGENC_CASE_UPCASE) {
flags |= ONIGENC_CASE_MODIFIED;
*to++ = 'S';
code = (flags & ONIGENC_CASE_TITLECASE) ? 's' : 'S';
}
else if (flags & ONIGENC_CASE_FOLD) {
flags |= ONIGENC_CASE_MODIFIED;
*to++ = 's';
code = 's';
}
}
/* ... */
*to++ = code;
La condición del bucle solo garantiza que haya un byte libre en el búfer de salida. La sharp s (0xDF) se expande a dos bytes, SS o ss, y ambas ramas escriben un byte antes de que el *to++ = code común escriba el segundo. Cuando el búfer de salida termina exactamente en el último carácter de entrada, la segunda escritura cae un byte más allá del búfer. Catorce codificadores tenían la misma comprobación: ISO-8859-1, -2, -3, -4, -9, -10, -13, -14, -15 y -16, además de Windows-1250, -1252, -1254 y -1257.
El desbordamiento de entero está en rb_str_casemap en string.c, que dimensiona y acumula los búferes de salida de una conversión. En 3.4.12 almacena el total acumulado en un int:
int target_length = 0;
/* ... */
size_t capa = (size_t)(source_end-source_current)*++buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH;
/* ... */
target_length += current_buffer->used = buffer_length_or_invalid;
Una cadena de origen muy grande hace que la aritmética de asignación y la longitud total se desborden. El aviso describe el resultado como un desbordamiento de búfer en el montón que puede llevar a la ejecución de código.
El compilador de expresiones regulares tiene un problema distinto de contabilidad de tamaño. En 3.4.12, add_opcode comprueba el tamaño del programa compilado antes de escribir un opcode:
static int
add_opcode(regex_t* reg, int opcode)
{
if (reg->used > MAX_COMPILED_PROGRAM_SIZE)
return ONIGERR_TOO_BIG_COMPILED_PROGRAM;
BBUF_ADD1(reg, opcode);
return 0;
}
Las escrituras en bloque no pasan por esa comprobación. add_bytes, add_bitset y add_multi_byte_cclass escriben directamente en el búfer del programa. add_compile_string, compile_cclass_node y compile_quantifier_node también ignoraban el valor de retorno de esas llamadas. Una concatenación larga de clases de propiedades multibyte puede empujar el programa más allá de su límite de tamaño. La contabilidad se desborda antes de que se alcance el add_opcode(OP_END) final. compile_length_tree sumaba longitudes por separado en un int, así que un patrón grande podía hacer que la suma fuera negativa y devolverla como código de error.
Los otros cuatro fallos tienen correcciones más pequeñas:
- GHSA-7x2q es una doble liberación en
parse_char_class. El manejador&&liberacc->mbufpero deja el puntero encc, y la ruta de error lo libera de nuevo. - GHSA-wpqw es una lectura fuera de límites en
OP_EXACT1_ICyOP_EXACTN_IC. El motor de coincidencia avanza según la longitud del plegado de mayúsculas de un carácter sin comprobarla contra el operando. Un plegado de longitud distinta le hace ejecutar los bytes siguientes del patrón como instrucciones. - GHSA-7whj es un desbordamiento de búfer en
Regexp#to_s. Compilaba la fuente sin procesar dentro de(?opts:...), mientras queRegexp.newcompila la fuente preprocesada. Un comentario(?#...)dentro de una clase de caracteres puede significar un patrón distinto y producir una escritura fuera de límites. - GHSA-pvgc es una lectura fuera de límites en
string_cmp_ic. La comparación de referencia inversa sin distinción de mayúsculas pliega el carácter al final del sujeto sin comprobar que el puntero del sujeto siga dentro del sujeto.
Los siete avisos, sus clasificaciones y sus commits de corrección son:
| Aviso | Clase de fallo | Clasificación | Commit de corrección principal |
|---|---|---|---|
| GHSA-34m4-m9fh-gqp5 | Desbordamiento de búfer en la conversión de mayúsculas y minúsculas | Crítica | b841d6f4f1 |
| GHSA-7x2q-68qv-6p8x | Doble liberación en la compilación de expresiones regulares | Crítica | 28aad344e1 |
| GHSA-3p8q-wmhx-vm2w | Desbordamiento de búfer en la compilación de expresiones regulares | Crítica | 6c6e6c9273, 57c24699fe, 65b71a8844 |
| GHSA-87fm-7w84-j2px | Desbordamiento de entero en la conversión de mayúsculas y minúsculas | Alta | f2e5063748 |
| GHSA-wpqw-5qxg-m68r | Lectura fuera de límites en la coincidencia sin distinción de mayúsculas | Alta | e12e722695 |
| GHSA-7whj-cfh7-xgm4 | Desbordamiento de búfer en Regexp#to_s |
Alta | cdd499eccd |
| GHSA-pvgc-g7gj-pv6h | Lectura fuera de límites en la coincidencia de referencia inversa | Moderada | b469749b37 |
¿Cómo se explota?
- El atacante proporciona una cadena diseñada a una llamada de conversión de mayúsculas y minúsculas, o un patrón o sujeto diseñado al motor de expresiones regulares. La aplicación debe pasar esos datos a Ruby sin reemplazar la codificación ni rechazar el patrón.
- Para el desbordamiento de la sharp s, el atacante elige una codificación de un solo byte afectada. Coloca bytes 0xDF de modo que el búfer de salida termine en una expansión de dos bytes. La escritura siguiente cae un byte más allá de la asignación.
- Para el desbordamiento de entero, el atacante proporciona una cadena muy grande. El tamaño del búfer y el total acumulado se desbordan, y la escritura de conversión se sale de la asignación.
- Para el compilador de expresiones regulares, el atacante proporciona un patrón grande construido con clases multibyte o cadenas exactas largas. El programa compilado supera el límite de tamaño, la contabilidad se desborda y una escritura posterior se sale del búfer del programa.
- Un patrón o sujeto malformado lleva al analizador o al motor de coincidencia a una ruta de error. Esa ruta libera dos veces el mismo búfer o lee más allá del operando o del sujeto.
- La preparación del montón convierte la corrupción en una escritura controlada o en una fuga de puntero. El proyecto Ruby dice conocer código de prueba de concepto que alcanza la ejecución de código en algunos escenarios, pero no lo ha publicado.
El disparador varía según el fallo. El desbordamiento de la sharp s necesita la codificación afectada y una cadena cuya conversión se expanda en el límite del búfer. El desbordamiento del compilador necesita un patrón lo bastante grande para superar el límite. Las lecturas del motor de coincidencia necesitan un plegado de mayúsculas que cambie de longitud, lo que es más fácil en UTF-16 y UTF-32. Una aplicación que solo maneja UTF-8 y patrones fijos está expuesta a menos de los siete.
¿Cómo se desarrolla el ataque?
Una cadena o un patrón diseñado llega a una rutina en C que confía en su propio cálculo de longitud. La memoria se corrompe y el ataque puede convertirse en ejecución de código en el proceso Ruby.
¿Qué puede hacer un atacante?
Una explotación exitosa ejecuta código como el usuario que ejecuta el proceso Ruby. Ese usuario puede leer variables de entorno y archivos a los que la aplicación tiene acceso. También puede modificar datos que la aplicación puede escribir y usar sus credenciales para llegar a otros sistemas.
Todas las condiciones deben cumplirse:
- La aplicación ejecuta una versión de Ruby afectada.
- La aplicación pasa datos influidos por un atacante a la conversión de mayúsculas y minúsculas o a
Regexp.new. - Los datos alcanzan la codificación y la ruta de código concretas que necesita el fallo elegido.
- El atacante puede preparar el montón lo suficiente para convertir el error de memoria en ejecución de código.
El aviso de Ruby dice que el código de prueba de concepto alcanza la ejecución de código "en algunos escenarios". No afirma tener un exploit universal. El registro CVE del desbordamiento de conversión lo puntúa CVSS v3.1 7.4 con un vector AV:L y complejidad de ataque alta. Considere la explotación remota dependiente de la aplicación. Un servicio que convierte datos de solicitudes en ISO-8859-1 o Windows-1252 es una ruta remota plausible, pero las fuentes no demuestran ninguna.
¿Por qué funciona la corrección?
La corrección de la conversión cambia la condición del bucle en los catorce codificadores de un solo byte. El bucle solo se ejecuta mientras haya al menos dos bytes libres. Este es el cambio de b841d6f4f1:
- while (*pp < end && to < to_end) {
+ while (*pp < end && to_end - to > 1) {
code = *(*pp)++;
La rama de la sharp s ahora puede escribir sus dos bytes. La corrección también añade una prueba de regresión que ejecuta upcase, downcase(:fold), swapcase, capitalize y casecmp? sobre cadenas repetidas de 0xDF en cada codificación afectada.
La corrección de la contabilidad cambia target_length a long. Rechaza una fuente mayor que INT_MAX - CASE_MAPPING_ADDITIONAL_LENGTH y calcula la capacidad del búfer con una comprobación de desbordamiento. Lanza ArgumentError en lugar de desbordarse. Está en f2e5063748.
La corrección del compilador añade check_compiled_program_size() y la llama antes de cada escritura en bloque, no solo antes de un opcode. También propaga los códigos de retorno por las funciones que los ignoraban. Este es el núcleo de 6c6e6c9273:
+static int
+check_compiled_program_size(regex_t* reg, OnigDistance add_len)
+{
+ if (reg->used > MAX_COMPILED_PROGRAM_SIZE ||
+ add_len > (OnigDistance )(MAX_COMPILED_PROGRAM_SIZE - reg->used))
+ return ONIGERR_TOO_BIG_COMPILED_PROGRAM;
+ return 0;
+}
57c24699fe pasa la aritmética de tamaño de BBuf a size_t y la limita a ONIG_MAX_BBUF_SIZE. Las macros de búfer tampoco pueden desbordarse. 65b71a8844 añade la comprobación de límite a compile_length_tree para que la pasada de longitud no se desborde antes de que empiece la compilación.
Las cuatro correcciones más pequeñas son específicas. La de la doble liberación pone cc->mbuf = NULL después de liberarlo. La de la coincidencia exacta comprueba la longitud del plegado contra el operando. La de Regexp#to_s preprocesa la fuente antes de compilar el grupo. La de la referencia inversa se detiene cuando el puntero del sujeto llega al final. Juntas cierran las siete rutas notificadas. La misma versión también incluye otros commits de refuerzo de expresiones regulares. No forman parte de los siete avisos y tratan con más rigor los escapes de bytes, los comentarios, los plegados Emacs-Mule y los puntos de código sustitutos. Son defensa en profundidad.
¿Cómo compruebo si estuve comprometido?
El proyecto Ruby no ha publicado indicadores de compromiso para estos fallos. Informa de código de prueba de concepto, pero no de explotación en entornos reales. El catálogo KEV de CISA no incluye ninguno de los siete al 2026-11-19. Las fuentes no ofrecen una ruta de archivo, un dominio ni una firma de solicitud fiables que buscar.
Estas comprobaciones pueden revelar un fallo o un patrón inusual:
# Ruby crashes recorded by the kernel
dmesg | grep -i -E 'ruby|segfault'
journalctl -k --since '30 days ago' | grep -i -E 'ruby|segfault'
# Very large regexp patterns or case-conversion inputs in application logs
grep -R -i -E 'RegexpError|too big compiled program|string size too big' /var/log/<app>/
Un fallo en un trabajador Ruby es una pista, no una prueba. Un intento que falla limpiamente puede no dejar rastro. Si encuentra un fallo que coincide con una de estas rutas de código, conserve la imagen del proceso y la entrada antes de reiniciar el servicio.
Cronología
- 2026-10-28: se escriben los primeros commits de corrección de los fallos de conversión y de seguridad de memoria de expresiones regulares.
- 2026-11-18: se publican Ruby 4.0.10, 3.4.13 y 3.3.14.
- 2026-11-19 00:00 UTC: se publica el aviso de seguridad de Ruby.
- 2026-11-19 06:34 UTC: se publica CVE-2026-132825 para el desbordamiento de conversión.
- No se ha notificado explotación en entornos reales.
La primera corrección del desbordamiento de conversión se escribió el 2026-10-28, y el aviso público llegó 22 días después.
Preguntas frecuentes
¿Mi aplicación está afectada si solo usa UTF-8? Todavía puede verse afectada por los fallos de expresiones regulares. El desbordamiento de la sharp s necesita una codificación de un solo byte, pero el desbordamiento del compilador, la doble liberación y las lecturas sin distinción de mayúsculas no. Compruebe primero la versión y después las rutas de código.
¿Es explotable de forma remota?
Depende de la aplicación. La CVE de conversión tiene una puntuación AV:L con complejidad alta. El aviso de Ruby dice, sin embargo, que su código de prueba de concepto alcanza la ejecución de código en algunos escenarios. Un servicio de red que pasa datos del atacante a los métodos afectados es la ruta remota realista.
¿Existe un exploit público? No hay código de explotación funcional público. El proyecto Ruby dice conocer código de prueba de concepto que demuestra la ejecución de código en algunos escenarios, y no lo ha publicado.
¿Actualizar Ruby exige reconstruir mis gems nativas? No. Las correcciones están en el intérprete de Ruby y en su motor de expresiones regulares integrado. Reinstalar el intérprete es suficiente. Reinicie después la aplicación y los procesos de extensiones nativas.
¿Ruby 3.2 está corregido? No. Ruby 3.2 y anteriores están en fin de vida útil y no recibirán estas correcciones. Actualice a una rama con soporte.
¿Se explotó en entornos reales? No se ha notificado explotación. Ninguno de los siete avisos está en el catálogo KEV de CISA al 2026-11-19.
Encuentre runtimes de Ruby con Ostorlab
El análisis de composición de software de Ostorlab inventaría los runtimes, las imágenes base y las gems que sus aplicaciones despliegan. Así puede encontrar las versiones de Ruby y las dependencias que necesitan esta actualización. Vea cómo funcionan Ostorlab SCA y SBOM.
Referencias
- Aviso de seguridad de Ruby, "Security advisories: multiple vulnerabilities in Regexp and String case conversion" (2026-11-19). https://www.ruby-lang.org/en/news/2026/11/18/multiple-vulnerabilities-in-regexp-and-string/ (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-34m4-m9fh-gqp5, "Heap buffer overflow in case conversion of strings". https://github.com/ruby/ruby/security/advisories/GHSA-34m4-m9fh-gqp5 (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-7x2q-68qv-6p8x, "Double free in regular expression compilation". https://github.com/ruby/ruby/security/advisories/GHSA-7x2q-68qv-6p8x (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-87fm-7w84-j2px, "Integer overflow in case conversion of strings". https://github.com/ruby/ruby/security/advisories/GHSA-87fm-7w84-j2px (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-wpqw-5qxg-m68r, "Out-of-bounds read in case-insensitive regular expression matching". https://github.com/ruby/ruby/security/advisories/GHSA-wpqw-5qxg-m68r (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-3p8q-wmhx-vm2w, "Heap buffer overflow in regular expression compilation". https://github.com/ruby/ruby/security/advisories/GHSA-3p8q-wmhx-vm2w (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-7whj-cfh7-xgm4, "Heap buffer overflow in Regexp#to_s". https://github.com/ruby/ruby/security/advisories/GHSA-7whj-cfh7-xgm4 (comprobado el 2026-11-19)
- Aviso de GitHub GHSA-pvgc-g7gj-pv6h, "Out-of-bounds read in case-insensitive backreference matching". https://github.com/ruby/ruby/security/advisories/GHSA-pvgc-g7gj-pv6h (comprobado el 2026-11-19)
- Registro CVE CVE-2026-132825. https://www.cve.org/CVERecord?id=CVE-2026-132825 (comprobado el 2026-11-19)
- Anuncio de Ruby 4.0.10. https://www.ruby-lang.org/en/news/2026/11/18/ruby-4-0-10-released/ (comprobado el 2026-11-19)
- Anuncio de Ruby 3.4.13. https://www.ruby-lang.org/en/news/2026/11/18/ruby-3-4-13-released/ (comprobado el 2026-11-19)
- Anuncio de Ruby 3.3.14. https://www.ruby-lang.org/en/news/2026/11/18/ruby-3-3-14-released/ (comprobado el 2026-11-19)
- Commit de corrección b841d6f4f1, "Fix a heap buffer overflow in case mapping of the sharp s". https://github.com/ruby/ruby/commit/b841d6f4f1b442ac9cc8de590b43f9e4ba6d3603 (comprobado el 2026-11-19)
- Commit de corrección f2e5063748, "Check the lengths in rb_str_casemap". https://github.com/ruby/ruby/commit/f2e5063748b9b2c9dc93733b9989f9fce03abcf2 (comprobado el 2026-11-19)
- Commit de corrección 28aad344e1, "Fix a double free in the && handler of parse_char_class". https://github.com/ruby/ruby/commit/28aad344e14f288cdb0fea452a2570e9efc1c923 (comprobado el 2026-11-19)
- Commit de corrección e12e722695, "Fix an out-of-bounds read in the case-insensitive exact match". https://github.com/ruby/ruby/commit/e12e722695e017a67078cb52c37658e886e1f710 (comprobado el 2026-11-19)
- Commit de corrección 6c6e6c9273, "Bound compiled program writes against size accounting". https://github.com/ruby/ruby/commit/6c6e6c9273cec3ba8679dbb825a7c10fa9b36bfe (comprobado el 2026-11-19)
- Commit de corrección 57c24699fe, "Harden BBuf size arithmetic against 32-bit overflow". https://github.com/ruby/ruby/commit/57c24699fe45ef74052b277ffdc2f366a21d6395 (comprobado el 2026-11-19)
- Commit de corrección 65b71a8844, "Check the compiled program size while computing the length". https://github.com/ruby/ruby/commit/65b71a8844e09f23c7177f3ba64dae055785f165 (comprobado el 2026-11-19)
- Commit de corrección cdd499eccd, "Preprocess the source before Regexp#to_s checks it with Onigmo". https://github.com/ruby/ruby/commit/cdd499eccd1a8ec60021e5f7cec02a22d4c0b790 (comprobado el 2026-11-19)
- Commit de corrección b469749b37, "Check the end of the subject in string_cmp_ic". https://github.com/ruby/ruby/commit/b469749b37d57d2cb293918a895c5bec562d7eb2 (comprobado el 2026-11-19)
- Docker Hub, imagen oficial
ruby, 1,595,151,215 descargas. https://hub.docker.com/_/ruby (comprobado el 2026-11-19) - RubyGems, gema
rails, 818,979,335 descargas. https://rubygems.org/gems/rails (comprobado el 2026-11-19) - Catálogo de vulnerabilidades explotadas conocidas de CISA. https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (comprobado el 2026-11-19)