Уязвимости regex в Ruby: Unicode и смена регистра
Семь уязвимостей в регулярных выражениях Ruby и смене регистра строк: почему Unicode case folding опасен для памяти и как проверить свой код.

Rails-приложение нормализует email-адреса, вызывая upcase перед сохранением, как советуют тысячи туториалов. Пользователь регистрируется с адресом mueller@straße.example через форму, где где-то в конвейере решили, что Windows-1252 — нормальная кодировка. Вызов upcase превращает финальную ß в SS — два байта вместо одного — и один из них записывается за границу выделенного heap-буфера. Это не гипотеза. Это правдоподобная реконструкция одной из семи уязвимостей в регулярных выражениях Ruby и смене регистра строк, которые только что закрыла команда ядра; несколько из них имеют рабочие PoC для удалённого выполнения кода.
Advisory вышел одновременно с тремя экстренными релизами — Ruby 4.0.10, 3.4.13 и 3.3.14 — и это хороший кейс на более глубокую мысль: смена регистра выглядит самой простой операцией в строковой библиотеке, а на деле одна из самых опасных. Здесь спецификация Unicode с её огромным объёмом встречается с C-кодом, которому десятилетия, и именно на этом стыке растут heap-переполнения.
Семь багов, две подсистемы, одна первопричина
Семь advisory (отслеживаются по идентификаторам GHSA, пока номера CVE проходят затянувшийся процесс назначения) делятся на два семейства. Два относятся к смене регистра в String: одно однобайтовое переполнение heap-буфера и целочисленное переполнение, которое каскадом приводит к heap-переполнению. Пять — в движке регулярных выражений Ruby: двойное освобождение памяти при компиляции шаблона, целочисленное переполнение при компиляции, чтение за границами при регистронезависимом сопоставлении, чтение за границами при регистронезависимом сопоставлении обратных ссылок и heap-переполнение в Regexp#to_s.
Обратите внимание, что их объединяет. Дело не в небрежном коде в привычном смысле — C-ядро Ruby старое, проверенное временем и активно фаззится. Дело в том, что обе подсистемы реализуют семантику регистра Unicode, а она коварна. Регистронезависимое сопоставление с регулярками требует case folding и шаблона, и входных данных, то есть движок работает по тем же опасным таблицам преобразования, что и String#upcase, только на более горячем пути и с большим влиянием атакующего на входные данные. Обратные ссылки в регистронезависимом режиме должны сравнивать свёрнутые подстроки. Regexp#to_s должен заново выдать исходный текст шаблона с опциями, и размер буфера под эту реконструкцию тоже зависит от логики, учитывающей регистр. Каждому из этих путей приходится отвечать на один и тот же обманчиво сложный вопрос: насколько вырастет эта строка, если поменять её регистр?
Ruby 3.3 получает исправление, потому что находится на поддержке безопасности. Ruby 3.2 и более старые версии вышли из поддержки и не получат ничего — если вы на одной из них, этот advisory — ваш дедлайн на миграцию, а не предупреждение.
Краткая история того, как смена регистра ломалась
В ASCII смена регистра — это переворот одного бита. Двадцать шесть пар букв, взаимно однозначно, с сохранением длины, без привязки к локали. toupper() из C времён K&R воплощает всю идею в одной таблице поиска. Именно такой моделью большинство из нас пользуется всю жизнь, и именно она заложена в логику расчёта размера буфера во всём мировом C-коде. Для любой письменности, кроме базовой латиницы, она почти всегда неверна.
Unicode определяет тысячи отображений регистра, и заметная часть из них не взаимно однозначна. Немецкая ß (ß) в верхнем регистре превращается в SS. Лигатура ff становится FF. Армянские лигатуры расширяются. В греческом есть контекстно-зависимая сигма — σ против финального ς, так что корректный фолдинг зависит от соседних символов. В турецком и азербайджанском есть проблема точечной и беспунктирной I: i переходит в İ, а ı в I, и это знаменито ломало всё — от Java-приложений до strtoupper в PHP с турецкой локалью. А в Unicode 8.0 в 2015 году чероки задним числом получили строчные буквы, превратив бесregistровое письмо в письмо с регистром и инвалидировав допущения в софте по всему миру.
Устаревшие кодировки всё усложняют. В Windows-1252 есть байт для строчной ß (0xDF), но нет байта для гипотетической заглавной версии — потому что в немецком в живом тексте её исторически просто не использовали: писали SS. Поэтому когда процедура смены регистра для строки в Windows-1252 встречает ß и корректно подставляет SS, строка растёт на один байт. Разбор, который появился после advisory, предполагает, что это и есть однобайтовое переполнение: цикл преобразования, похоже, проверяет место в буфере по одному символу за раз, так что ß в самом конце плотно подобранной строки записывает лишний S за пределы выделенной памяти. Однобайтовое heap-переполнение с контролируемым атакующим S — неприятный, капризный примитив эксплуатации, но advisory подтверждает существование PoC с RCE, так что кто-то всё же проделал heap grooming.
Смена регистра не является биекцией, не сохраняет длину, не независима от локали и не всегда представима в каждой кодировке. Код, который считает иначе, — уязвимость, которая ждёт своего фаззера.
Почему движок регулярных выражений — более серьёзная проблема
Движок регулярок в Ruby — Onigmo, форк Oniguruma, и это по-настоящему впечатляющий софт: он работает с десятками кодировок, полным case folding Unicode, lookbehind, именованными группами и обратными ссылками, всё на C, со слоями, восходящими к концу 1990-х. Вот в этих слоях и проблема. Регистронезависимое сопоставление в Onigmo означает, что в каждой точке сравнения потенциально выполняется логика фолдинга, а фолдинг меняет длины, так что учёт соответствий между смещениями в шаблоне, смещениями в строке и границами совпадения получается действительно запутанным. Два из закрытых багов — чтения за границами именно в этом механизме: один — в регистронезависимом сопоставлении вообще, другой — конкретно в регистронезависимом сопоставлении обратных ссылок, где движок сравнивает ранее захваченную (свёрнутую) подстроку с текущей позицией.
Но модель эксплуатации важнее внутренностей. Три из пяти багов в регулярках срабатывают при компиляции шаблона, и advisory прямо говорит, кто под ударом: приложения, которые компилируют шаблоны, контролируемые атакующим. Можно подумать, что это редкость. Это не так. Каждое поле поиска, обёрнутое в Regexp.new(query), каждое настраиваемое правило валидации, загруженное из базы, каждый слой логирования или маршрутизации, который строит шаблоны из конфигов, контролируемых оператором (или скомпрометированным арендатором), — это путь компиляции, доступный для враждебного ввода. До этого advisory худшим исходом компиляции враждебного шаблона был ReDoS: катастрофический бэктрекинг, который забивает CPU. Неприятно, но восстановимо. Теперь худший случай — повреждение памяти с PoC для RCE. Это принципиально другой риск для той же строчки кода, что работает в продакшене уже много лет.
Здесь есть закономерность, которую стоит назвать: спецификация говорит одно, C делает другое, и разрыв между ними эксплуатируем. Мы уже касались этой динамики — разрыв между спецификацией и реализацией — это место, где живут баги, — а таблицы case folding Unicode — одна из самых насыщенных спецификаций, которую C-программисту могут поручить реализовать. Таблицы меняются от версии к версии Unicode, у правил special casing есть подпункты, а тот, кто писал код расчёта размера буфера в 2003 году, опирался на более маленький и простой Unicode, чем тот, в котором сегодня приходят ваши строки.
Целочисленное переполнение: четыре гигабайта превращаются в шесть байт
Второй строковый баг — отличная иллюстрация другого типа сбоя: арифметика длин в 32-битном типе в 64-битном мире. Этот PoC, который публично расходился после advisory, использует Shift_JIS и строку больше четырёх гигабайт:
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]
Строка в 4 294 967 302 байта на входе, а результат downcase сообщает размер 6. Где-то на пути преобразования длина была вычислена или усечена через 32-битный тип: 2³² + 6 обернулось в 6, и последующее выделение или копирование выполнялось с этим размером — классический конвейер «целочисленное переполнение → heap-переполнение». Четыре гигабайта звучат как абсурдный ввод, но помните: строки в работающем процессе не обязательно приходят по сети целиком. Их собирают из кусков, при распаковке, конкатенацией в задачах импорта и парсерах файлов. Атакующий, который может влиять на то, сколько данных накапливается в строке, а потом заставить вызвать на ней downcase, контролирует обе половины этого бага.
Оба строковых бага разделяют архитектурный урок с десятилетним багом со звёздочкой в Alpine: опасный код стоит на пути, который никто не считает поверхностью атаки. Никто не моделирует угрозы для upcase. Именно поэтому такие баги живут годами: они сидят на путях, которые люди не аудируют и до недавнего времени фаззеры не могли достаточно умно достичь, чтобы построить валидные многобайтовые строки.
Баги нашли машины, и это меняет арифметику
Посмотрите на благодарности. Четыре из семи advisory благодарят Стефана Липпа из Ada Logics — фирмы, стоящей за значительной частью разработки харнессов OSS-Fuzz — и Anthropic. Это эксперт по инфраструктуре фаззинга в паре с ИИ-моделью, и это не первый недавний advisory с такой подписью. Линия развития стоит оценить: фаззинг начался с того, что Бартон Миллер в 1990 году подавал случайный мусор на утилиты Unix; стал умнее с покрытием-ориентированной мутацией AFL в 2013-м; был индустриализирован OSS-Fuzz, который непрерывно бьёт по open source-проектам с 2016 года; и теперь получил слой, который может рассуждать о коде. Построить 4-гигабайтную строку Shift_JIS или буфер Windows-1252, заканчивающийся на ß, — значит понимать валидность кодировки и арифметику длин, а не просто мутировать байты.

Стратегические выводы работают в обе стороны. Защитники получают непрерывный, неутомимый аудит кодовых баз, которые ни одна команда не могла позволить себе проверить вручную. Но та же возможность доступна любому, у кого есть модель и вычисления, а не все заводят advisory. Спокойная эпоха, в которой баг повреждения памяти в обскурном пути кода мог годами жить без помех, заканчивается: экономика поиска таких багов рухнула. Я уже писал, что ИИ-сканеры взыскивают наш технический долг, и это квитанция: языковая среда, которой пользуются миллионы, оказалась не на высоте — нашёл её не скучающий исследователь с выходными, а автоматический конвейер, который просто продолжит работать.
Моя позиция: это усиливает аргумент в пользу memory-safe языков, но не в том глупом виде, в котором обычно подаётся эта дискуссия. Переписывание Onigmo на Rust не исправило бы логику — фолдинг, меняющий длину строки, остаётся проблемой на уровне спецификации, а вопрос размера буфера всё равно нужно решать правильно. Безопасность памяти убирает градиент последствий. Логический баг превращается в панику, неверный результат, упавший запрос — а не в RCE. Это не мелочь: разница между инцидентом и уведомлением о простое.
Как проверить собственную подверженность
Начните с очевидного и двигайтесь дальше. Обновитесь до 4.0.10, 3.4.13 или 3.3.14 — Onigmo встроен в сборку Ruby, так что отдельной библиотеки для патча нет: патч — это сам рантайм. Затем проверьте код приложения на две опасные конструкции: строки, на которые может влиять атакующий, попадающие в операции смены регистра, и шаблоны, на которые он может влиять, попадающие в Regexp.new или Regexp.compile.
- Перестаньте компилировать пользовательский ввод в шаблоны. Если пользователи передают поисковые запросы, экранируйте их через
Regexp.escape. Если им действительно нужна мощь регулярок, поставьте перед ними allowlist и жёсткий таймаут — и помните, что таймаут помогает от ReDoS, но не от повреждения памяти. - Нормализуйте кодировки на границе доверия. Оба строковых бага опираются на экзотические кодировки (Windows-1252, Shift_JIS). Если ваше приложение работает только с UTF-8, так и зафиксируйте на входе: принудительно приводите или транскодируйте кодировку при приёме и отклоняйте то, что не конвертируется чисто.
- Предпочитайте сравнение без учёта регистра смене регистра.
a.casecmp?(b)задаёт вопрос;a.upcase == b.upcaseвыделяет две новые строки в той кодировке, которую заявляет вход. У API сравнения гораздо меньше семантическая поверхность. - Ищите
upcase,downcase,swapcaseиcapitalizeв недоверенных данных. Каждое место вызова — это место, где живёт допущение о длине. То же касается любого C-расширения, которое вы написали и которое делает собственную логику регистра: они не получают ничего от исправлений команды ядра. - Фаззите то, что вам принадлежит. Сам Ruby фаззится OSS-Fuzz, а ваши C-расширения — нет. AFL++ или libFuzzer с ASan найдут в вашем коде те же классы багов, что машины только что нашли в Ruby.
- Знайте статус поддержки вашего рантайма. Ruby 3.2 вышел из поддержки и не получил этих исправлений. «Оно же работает» — не модель безопасности, когда поток патчей остановился.
Конкретное сравнение до и после для самого частого паттерна — нормализации имён пользователей или email для проверки уникальности:
# 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
Ничего из этого не сделает вас защищённым на непропатченном рантайме — для этого и нужно обновление. Но эти привычки сокращают класс багов, который ваше приложение может унаследовать от слоя под ним, и заставляют ваш собственный код честно признавать, что текст — это не байты.

Более глубокий урок для языковых рантаймов
Соблазн свести всё к «C опасен, подробности в следующей серии» велик, и поверхностные реакции на advisory именно так и поступили. Но я пошёл бы дальше. Эти семь багов на самом деле не про C — они про расхождение между развивающимся стандартом интернационализации и замороженными допущениями реализации. Unicode будет продолжать добавлять письменности и уточнять отображения. Каждый языковой рантайм на Земле содержит код смены регистра, написанный под какую-то прошлую версию этих таблиц и рассчитанный по какому-то прошлому представлению о том, насколько может вырасти строка. Ruby попал под раздачу в этом месяце; в следующий раз это будет чей-то другой движок регулярок, другой фолдер регистра или процедура нормализации.
Практический вывод: относиться к преобразованию текста как к границе безопасности, а не как к утилитарной функции. Всё, что перекодирует, меняет регистр, нормализует или фолдит текст, — это парсер, а в парсерах живут баги памяти. Исторический вывод — тот, что мне, как языковому зануде, особенно приятен: скромная немецкая ß, с которой типографы возились ещё со времён фрактуры, всё ещё может дотянуться через шесть веков typографической истории и записать байт за пределы heap-буфера. Язык никогда не был простым. Мы просто строили свои машины, исходя из обратного.


