Des articles approfondis sur les technologies qui façonnent l'avenir.

Failles regex Ruby : le piège du case folding Unicode

Sept failles regex et de conversion de casse dans Ruby : le case folding Unicode est un champ de mines mémoire. Comment auditer votre code.

Un bloc de caractères en plomb qui se scinde en deux blocs plus petits au-dessus d'un plateau d'imprimeur
Un caractère qui devient deux, c'est tout le bug : le s dur allemand mis en majuscules donne SS, et le calcul de la taille du tampon part de travers.

Une application Rails normalise les adresses e-mail en appelant upcase avant de les stocker, comme le recommandent des milliers de tutoriels. Un utilisateur s'inscrit avec mueller@straße.example via un formulaire qui, quelque part dans le pipeline, a décidé que Windows-1252 était un encodage tout à fait acceptable. L'appel à upcase transforme le ß final en SS — deux octets là où il n'y en avait qu'un — et écrit l'un de ces octets au-delà de la fin d'un tampon sur le tas. Ce n'est pas hypothétique. C'est une reconstruction plausible de l'une des sept failles de conversion de casse et d'expressions régulières dans Ruby que l'équipe cœur vient de corriger, dont plusieurs disposent de preuves de concept d'exécution de code à distance fonctionnelles.

L'avis de sécurité est sorti en même temps que trois versions d'urgence — Ruby 4.0.10, 3.4.13 et 3.3.14 — et c'est une bonne étude de cas d'une vérité plus profonde : la conversion de casse ressemble à l'opération la plus simple d'une bibliothèque de chaînes de caractères, alors qu'elle figure parmi les plus dangereuses. C'est là que la spécification tentaculaire d'Unicode rencontre du code C vieux de plusieurs décennies, et c'est précisément à cette jonction que poussent les dépassements de tas.

Sept bugs, deux sous-systèmes, une seule cause racine

Les sept avis de sécurité (suivis par leurs identifiants GHSA, pendant que les numéros CVE suivent un processus d'attribution en retard) se regroupent en deux familles. Deux touchent la conversion de casse de String : un dépassement de tas d'un octet et un dépassement d'entier qui se propage en dépassement de tas. Cinq touchent le moteur d'expressions régulières de Ruby : une double libération pendant la compilation d'un motif, un dépassement d'entier pendant la compilation, une lecture hors limites en correspondance insensible à la casse, une lecture hors limites en correspondance insensible à la casse des références arrière, et un dépassement de tampon sur le tas dans Regexp#to_s.

Remarquez ce qui les unit. Ce n'est pas un code négligé au sens habituel : le cœur C de Ruby est ancien, éprouvé et abondamment fuzzé. C'est que les deux sous-systèmes implémentent la sémantique de casse Unicode, et cette sémantique est un piège. La correspondance insensible à la casse exige de replier à la fois le motif et l'entrée, ce qui signifie que le moteur utilise les mêmes tables de correspondance périlleuses que String#upcase, simplement sur un chemin plus sollicité et avec davantage d'influence de l'attaquant sur les entrées. Les références arrière en mode insensible à la casse doivent comparer des sous-chaînes repliées. Regexp#to_s doit réémettre le texte source d'un motif avec ses options, en dimensionnant un tampon pour une reconstruction qui implique elle-même de la logique sensible à la casse. Chacun de ces chemins de code doit répondre à la même question, trompeusement difficile : quelle sera la taille de cette chaîne après que je l'ai mise en majuscules ou en minuscules ?

Ruby 3.3 reçoit le correctif parce qu'elle est encore en maintenance de sécurité. Ruby 3.2 et les versions antérieures sont en fin de vie et ne reçoivent rien : si vous utilisez l'une d'elles, cet avis est votre date limite de migration, pas un simple avertissement.

Brève histoire des conversions de casse qui tournent mal

En ASCII, changer de casse revient à inverser un bit. Vingt-six paires de lettres, correspondance un-à-un, longueur préservée, indépendante de la locale. toupper() du C de l'époque de K&R incarne toute cette idée dans une seule table de correspondance. C'est le modèle mental que la plupart d'entre nous conservent à l'âge adulte, et c'est celui qui est intégré à la logique de dimensionnement des tampons dans une bonne partie du code C du monde entier. Il est aussi faux pour à peu près tous les systèmes d'écriture au-delà du latin de base.

Unicode définit des milliers de correspondances de casse, et une part non négligeable d'entre elles ne sont pas un-à-un. Le s dur allemand (ß) passe en majuscules en SS. La ligature ff devient FF. Les ligatures arméniennes se développent. Le grec possède le sigma dépendant du contexte — σ contre ς en fin de mot — si bien que le repliement correct dépend des caractères environnants. Le turc et l'azéri ont le problème du i pointé et non pointé : i se met en majuscules en İ et ı en I, ce qui a notoirement cassé tout, des applications Java à strtoupper de PHP dans les locales turques. Et le cherokee a reçu des lettres minuscules rétroactivement dans Unicode 8.0 en 2015, transformant une écriture sans casse en écriture à casse, et invalidant des hypothèses dans des logiciels partout.

Les encodages historiques aggravent le problème. Windows-1252 possède un octet pour le ß minuscule (0xDF), mais aucun pour une version majuscule hypothétique — parce que, historiquement, l'allemand n'en utilisait tout simplement jamais dans le texte courant : on écrivait SS. Ainsi, lorsqu'une routine de conversion de casse opérant sur une chaîne Windows-1252 rencontre un ß et le remplace correctement par SS, la chaîne grandit d'un octet. Les analyses pointues qui circulent après l'avis suggèrent que c'est exactement ce dépassement d'un octet : la boucle de conversion semble vérifier l'espace disponible caractère par caractère, de sorte qu'un ß placé en dernier caractère d'une chaîne dimensionnée au plus juste produit un S parasite écrit au-delà de l'allocation. Un dépassement d'un octet avec un S contrôlé par l'attaquant est une primitive d'exploitation pénible et délicate — mais l'avis confirme l'existence de preuves de concept d'exécution de code à distance, donc quelqu'un a bel et bien fait le travail de manipulation du tas.

La conversion de casse n'est ni une bijection, ni préservatrice de longueur, ni indépendante de la locale, et elle n'est pas représentable dans tous les encodages. Le code qui suppose le contraire est une vulnérabilité qui attend un fuzzer.

Pourquoi le moteur d'expressions régulières est la plus grande source d'inquiétude

Le moteur d'expressions régulières de Ruby est Onigmo, une bifurcation d'Oniguruma, et c'est un logiciel véritablement impressionnant : il gère des dizaines d'encodages, le repliement de casse Unicode complet, les assertions de lookbehind, les groupes nommés et les références arrière, le tout en C, avec une superposition de couches qui remonte à la fin des années 1990. Cette superposition est précisément le problème. En correspondance insensible à la casse dans Onigmo, chaque point de comparaison peut déclencher de la logique de repliement, et le repliement modifie les longueurs ; la comptabilité entre décalages du motif, décalages de la chaîne et bornes de correspondance est donc réellement complexe. Deux des bugs corrigés sont des lectures hors limites exactement dans cette mécanique — l'une dans la correspondance insensible à la casse en général, l'autre spécifiquement dans la correspondance insensible à la casse des références arrière, où le moteur compare une sous-chaîne capturée précédemment (et repliée) à la position courante.

Le modèle d'exploitation compte pourtant davantage que les détails internes. Trois des cinq bugs d'expressions régulières se déclenchent pendant la compilation du motif, et l'avis est sans détour sur les applications exposées : celles qui compilent des motifs contrôlés par un attaquant. On pourrait croire que c'est rare. Ce n'est pas le cas. Chaque champ de recherche enveloppé dans Regexp.new(query), chaque règle de validation configurable chargée depuis une base de données, chaque couche d'analyse de journaux ou de routage qui construit des motifs à partir de fichiers de configuration qu'un opérateur (ou un locataire compromis) contrôle — tout cela constitue un chemin de compilation accessible à une entrée hostile. Avant cet avis, le pire scénario pour la compilation d'un motif hostile était un ReDoS : un motif à retour arrière catastrophique qui monopolise un CPU. Agaçant, mais récupérable. Désormais, le pire scénario est une corruption mémoire avec des preuves de concept d'exécution de code à distance. C'est un risque d'une nature totalement différente pour la même ligne de code que vous avez en production depuis des années.

Il y a ici un schéma qui mérite d'être nommé : la spécification dit une chose, le C en dit une autre, et l'écart est exploitable. Nous avons déjà abordé cette dynamique — l'écart entre spécification et implémentation est là où vivent les bugs — et les tables de repliement de casse Unicode font partie des spécifications les plus riches qu'un programmeur C puisse être amené à implémenter. Les tables changent d'une version Unicode à l'autre, les règles de casse spéciales ont des sous-clauses, et la personne qui a écrit le code de dimensionnement des tampons en 2003 travaillait à partir d'un Unicode plus petit et plus simple que celui dans lequel vos chaînes arrivent aujourd'hui.

Le dépassement d'entier : quatre gigaoctets deviennent six octets

Le deuxième bug de chaîne illustre magnifiquement un autre mode de défaillance : une arithmétique de longueur sur 32 bits dans un monde 64 bits. Cette preuve de concept, diffusée publiquement après l'avis, utilise Shift_JIS et une chaîne de plus de quatre gigaoctets :

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]

Une chaîne de 4 294 967 302 octets entre, et le résultat de la conversion en minuscules annonce une taille de 6. Quelque part dans le chemin de conversion, une longueur a été calculée ou tronquée via un type 32 bits : 2³² + 6 a été ramené à 6, et l'allocation ou la copie suivante a été dimensionnée en conséquence — un pipeline classique de dépassement d'entier menant à un dépassement de tas. Quatre gigaoctets semblent une entrée absurde, mais rappelez-vous que les chaînes d'un processus en cours d'exécution n'arrivent pas forcément d'un seul bloc par le réseau : elles se construisent par morceaux, à partir de décompressions, de concaténations dans des tâches d'import et des analyseurs de fichiers. Un attaquant capable d'influencer la quantité de données qui s'accumule dans une chaîne, puis de faire appeler downcase dessus, contrôle les deux moitiés de ce bug.

Les deux bugs de chaîne partagent une leçon d'architecture avec le bug de l'astérisque d'Alpine, vieux de dix ans : le code dangereux se trouve sur un chemin que personne ne considère comme une surface d'attaque. Personne ne modélise les menaces autour de upcase. C'est précisément pourquoi ces bugs survivent des années : ils se cachent dans des chemins que les humains n'auditent pas et que, jusqu'à récemment, les fuzzers n'atteignaient pas avec assez d'intelligence pour construire des chaînes multi-octets encodées valides.

Des machines ont trouvé ces bugs, et cela change le calcul

Regardez les remerciements. Quatre des sept avis remercient Stephan Lipp d'Ada Logics — la société derrière une bonne partie du développement des harness d'OSS-Fuzz — et Anthropic. Un expert de l'infrastructure de fuzzing associé à un modèle d'IA, et ce n'est pas le premier avis récent portant cette signature. La généalogie mérite d'être appréciée : le fuzzing a commencé avec Barton Miller, qui envoyait du bruit aléatoire à des utilitaires Unix en 1990, il est devenu plus intelligent avec la mutation guidée par la couverture d'AFL en 2013, il s'est industrialisé avec OSS-Fuzz, qui bombarde en continu les projets open source depuis 2016, et il a désormais acquis une couche capable de raisonner sur le code — construire une chaîne Shift_JIS de 4 Gio ou un tampon Windows-1252 se terminant par ß exige de comprendre la validité des encodages et l'arithmétique des longueurs, pas seulement de muter des octets.

Un bras de balayage mécanique inspectant des cartes perforées sur un convoyeur, l'une d'elles brillant
Le fuzzing guidé par la couverture combiné au raisonnement d'un modèle de langage audite du vieux code C plus vite que ne le feraient jamais des humains.

L'implication stratégique joue dans les deux sens. Les défenseurs gagnent un audit continu et infatigable de bases de code qu'aucune équipe ne pourrait se permettre de relire à la main. Mais la même capacité est accessible à quiconque dispose d'un modèle et de puissance de calcul, et tout le monde ne publie pas d'avis de sécurité. L'époque confortable où un bug de corruption mémoire dans un chemin de code obscur pouvait compter sur des années de tranquillité touche à sa fin : l'économie de la découverte de ces bugs s'est effondrée. J'ai déjà soutenu que les scanners IA réclament notre dette technique, et voici la preuve : un environnement d'exécution de langage utilisé par des millions de personnes, jugé défaillant non pas par un chercheur ennuyé avec un week-end devant lui, mais par un pipeline automatisé qui continuera simplement de tourner.

Ma position : cela renforce l'argumentaire en faveur des langages à mémoire sûre, mais pas de la façon simpliste dont le débat le présente habituellement. Réécrire Onigmo en Rust n'aurait pas corrigé la logique — un repliement de casse qui modifie la longueur d'une chaîne reste un risque au niveau de la spécification, et la question de la taille du tampon doit toujours recevoir une réponse correcte. Ce que la sécurité mémoire supprime, c'est le gradient de conséquences. Le bug de logique devient une panique, un résultat erroné, une requête échouée — pas une exécution de code à distance. Ce n'est pas un détail : c'est la différence entre un incident et un avis de panne.

Comment auditer votre propre exposition

Commencez par l'évident et élargissez ensuite. Mettez à jour vers 4.0.10, 3.4.13 ou 3.3.14 — Onigmo est intégré au build de Ruby, il n'y a donc aucune bibliothèque distincte à corriger : le runtime est le correctif. Ensuite, auditez le code de votre application pour repérer les deux formes dangereuses : des chaînes influencées par un attaquant qui arrivent dans des opérations de casse, et des motifs influencés par un attaquant qui arrivent dans Regexp.new ou Regexp.compile.

  • Cessez de compiler des saisies utilisateur en motifs. Si les utilisateurs fournissent des termes de recherche, échappez-les avec Regexp.escape. S'ils ont réellement besoin de la puissance des expressions régulières, placez devant une liste blanche et un délai d'expiration strict — et sachez qu'un délai d'expiration aide contre le ReDoS, pas contre la corruption mémoire.
  • Normalisez les encodages à la frontière de confiance. Les deux bugs de chaîne reposent sur des encodages exotiques (Windows-1252, Shift_JIS). Si votre application ne parle qu'UTF-8, dites-le aux frontières : forcez ou transcodez l'encodage à l'entrée, et rejetez ce qui ne se convertit pas proprement.
  • Privilégiez la comparaison insensible à la casse plutôt que la conversion de casse. a.casecmp?(b) pose une question ; a.upcase == b.upcase alloue deux nouvelles chaînes dans l'encodage revendiqué par l'entrée. L'API de comparaison a une surface sémantique bien plus réduite.
  • Cherchez upcase, downcase, swapcase et capitalize sur les données non fiables. Chaque site d'appel est un endroit où une hypothèse de longueur se cache. Il en va de même pour toute extension C que vous avez écrite et qui gère sa propre logique de casse — celles-ci ne bénéficient d'aucun des correctifs de l'équipe cœur.
  • Fuzzez ce que vous possédez. Ruby lui-même est fuzzé par OSS-Fuzz, mais vos extensions C ne le sont pas. AFL++ ou libFuzzer avec ASan trouveront dans votre code les mêmes classes de bugs que les machines viennent de découvrir dans Ruby.
  • Connaissez le statut de maintenance de votre runtime. Ruby 3.2 est en fin de vie et n'a pas reçu ces correctifs. « Ça marche toujours » n'est pas une posture de sécurité lorsque le flux de correctifs s'est arrêté.

Un avant-après concret pour le motif le plus courant — normaliser des noms d'utilisateur ou des e-mails pour les vérifications d'unicité :

# 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

Rien de tout cela ne vous protège sur un runtime non corrigé — c'est à cela que sert la mise à jour. Mais ces habitudes réduisent la classe de bugs que votre application peut hériter de la couche inférieure, et elles obligent votre propre code à reconnaître honnêtement que le texte n'est pas de l'octet.

Cadenas sur un établi, dont un ouvert sous une loupe, entourés d'outils fins
Auditer votre exposition : les verrous que vous n'avez pas installés vous-même restent les vôtres.

La leçon de fond pour les runtimes de langages

On est tenté de ranger tout cela dans « le C est dangereux, et ce n'est que le début », et les réactions superficielles à l'avis ont fait exactement cela. Mais je irais plus loin. Ces sept bugs ne concernent pas vraiment le C — ils concernent le décalage entre une norme d'internationalisation en évolution et des hypothèses d'implémentation figées. Unicode continuera d'ajouter des écritures et d'affiner les correspondances. Chaque runtime de langage sur Terre possède du code de conversion de casse écrit selon une version passée de ces tables, dimensionné selon une compréhension passée de la croissance possible d'une chaîne. Ruby a été pris ce mois-ci ; ce sera le moteur d'expressions régulières, le repliement de casse ou la routine de normalisation de quelqu'un d'autre la prochaine fois.

La leçon pratique : traitez la transformation de texte comme une frontière de sécurité, et non comme une simple fonction utilitaire. Tout ce qui réencode, change la casse, normalise ou replie est un analyseur, et les analyseurs sont là où vivent les bugs mémoire. La leçon historique — celle que je trouve réellement satisfaisante en tant que passionné de langues — est que le modeste ß allemand, une lettre avec laquelle les imprimeurs se battent depuis l'époque de la fraktur, peut encore traverser six siècles d'histoire typographique et écrire un octet au-delà de la fin d'un tampon sur le tas. La langue n'a jamais été simple. Nous avons simplement construit nos machines en supposant qu'elle l'était.