Nginx HTTP/2 RCE: сложность протокола и поверхность атаки
Уязвимости RCE в HTTP/2 Nginx доказывают: критичные баги прячутся в stateful-парсерах протоколов. Разбираем почему и что проверить в своём стеке.

Самый опасный код в интернете — это не ваше приложение. Это stateful-парсер протокола, стоящий перед ним и написанный на C, которому все доверяют как закалённому в боях. Новые RCE-уязвимости в HTTP/2 Nginx — CVE-2026-123633 и CVE-2026-123007, обе без аутентификации, обе с оценкой 9.2 — лучшее подтверждение этой мысли за многие годы. Одна из них позволяла исследователям получить шелл на стандартном Nginx, который отдавал только статические файлы. Ни бэкенда, ни сторонних модулей, ни ошибок в приложении. Только Nginx, HTTP/2 и целочисленный underflow, который висел в кодовой базе с версии 1.9.5 из 2015 года.
Вот в чём парадокс: мы тратим огромные силы на аудит собственного кода и почти не думаем о входной двери. А ведь именно через неё старый баг работы с памятью может дать незнакомцу без аутентификации выполнение кода на машине, которая терминирует ваш TLS и видит весь трафик.
Почему HTTP/2 в Nginx всегда был рискованной ставкой
HTTP/1.1 — текстовый протокол. Он простой, многословный, а его модель парсинга довольно естественно ложится на схему «читай байты до разделителя, проверяй, передавай дальше». Баги в парсерах HTTP/1 находили — контрабанда запросов (request smuggling) целый отдельный жанр, — но конечный автомат достаточно мал, чтобы аккуратный инженер мог удержать его в голове.
HTTP/2 — совсем другой зверь. Он бинарный, с фреймами, мультиплексированный и stateful таким образом, что состояние пронизывает всё соединение. Одно TCP-соединение несёт десятки параллельных стримов. Управление потоком ведётся по стримам и по соединению через скользящие окна кредитов. Стримы можно открывать, полузакрывать, сбрасывать и переприоритизировать в любом порядке, какой захочет клиент. Сжатие заголовков HPACK означает, что парсер поддерживает общую динамическую таблицу, которая меняется по мере прихода фреймов. Каждая из этих возможностей — это кусок изменяемого состояния, который должен оставаться согласованным под враждебным вводом, а ввод полностью контролирует клиент.
Nginx унаследовал всю эту машинерию состояния, когда добавлял модуль HTTP/2, и сделал это на C, в событийной архитектуре, где соединения и стримы — это объекты в куче, время жизни которых управляется вручную. Такое сочетание — богатое перекрёстное состояние плюс ручное управление памятью — идеальная среда для use-after-free и целочисленных underflow. Обе CVE здесь почти карикатуры на жанр: в одном случае объект соединения остаётся в списке «безопасно закрыть», пока запрос активно им пользуется; в другом учёт управления потоком уходит ниже нуля и приводит к некорректному копированию памяти.
Раньше я писал в контексте разрыва между спецификацией и реализацией, что баги концентрируются там, где неявные инварианты спецификации встречаются с кодом, который их не enforce'ит. HTTP/2 — отличный пример. RFC 7540 (и теперь 9113) описывает, как выглядят корректные потоки. Опасная зона — всё, что спецификация не запрещает явно, но что реализация никогда не тестировала: частичные фреймы, переходы состояний в странном порядке, окна, которые крутят на граничных значениях.
Use-after-free: переиспользование занятого объекта
CVE-2026-123633 — более изящный из двух багов, и он вознаграждает внимательное чтение. Nginx ведёт список соединений, которые считает «переиспользуемыми» — безопасными для закрытия, когда нужны слоты под новые подключения. HTTP/2-соединение попадает в этот список, когда у него нет активных стримов с запросами. Пока всё разумно.
Ошибка в том, как соединение покидает список — точнее, как оно туда не попадает обратно. Отправьте только часть фрейма HEADERS. Nginx увидит неполный фрейм, пометит соединение как переиспользуемое и будет ждать. Теперь отправьте остаток фрейма. Обработчик создаёт новый стрим запроса и увеличивает счётчик обрабатываемых запросов соединения, но не удаляет соединение из списка переиспользуемых. Получается соединение, которое одновременно обрабатывает живой запрос и помечено как одноразовое. Если слотов соединений начинает не хватать, Nginx лезет в этот список, освобождает соединение, а запрос в полёте остаётся указывать на освобождённую память. Классический use-after-free, достижимый любым неаутентифицированным клиентом, который умеет говорить по HTTP/2 с обратным прокси.
Обратите внимание, что нужно, чтобы найти это чтением кода: надо отслеживать принадлежность объекта одной структуре данных через два разных перехода состояния, которые запускаются сетевым вводом, разбитым на несколько пакетов. Это не тот баг, который найдёт линтер. Его даже фаззеры не всегда находят, потому что нужно конкретное двухшаговое взаимодействие — частичный фрейм, пауза, полный фрейм — плюс давление на память, чтобы спровоцировать закрытие. Такое жило почти шесть лет, несмотря на то что Nginx — одна из самых читаемых кодовых баз на планете.
Целочисленный underflow: десять лет на виду
CVE-2026-123007 старше и в каком-то смысле хуже. Управление потоком в HTTP/2 работает так: каждому стриму и соединению выдаётся окно отправки — баланс кредитов, который отправитель уменьшает по мере передачи, а получатель пополняет фреймами WINDOW_UPDATE. Если учёт этого окна пойдёт не так, размер копирования может вычисляться из переполнившегося значения, и вы внезапно начинаете memcpy из памяти или в память, которой трогать не должны.
Исследователи продемонстрировали удалённое выполнение кода на этом примитиве в почти стандартной конфигурации — Nginx, отдающий статику по HTTPS на 64-битной системе. ASLR не спас, потому что обе уязвимости работают как примитивы чтения памяти ещё до эскалации до выполнения кода. Вы утекаете указатели, обходите рандомизацию, а потом пишете. Это стандартная современная техника эксплуатации, но полезно её усвоить: такие меры, как ASLR, повышают цену эксплуатации, но не предотвращают её, а любой баг, который даёт чтение плюс порчу памяти, фактически означает конец игры.
Underflow попал в Nginx 1.9.5 в 2015 году. Одиннадцать лет. За это время код просматривали тысячи инженеров, его развёртывали миллионы администраторов, его сканировал каждый коммерческий статический анализатор на рынке, и его фаззили — Nginx действительно фаззят. Он пережил всё это. Если это не пересмотрит вашу веру в то, что «зрелый open source безопасен, потому что глаз много», то ничто не пересмотрит.

Неприятная часть: ИИ нашёл то, что не нашёл фаззинг
Вот деталь, из-за которой командам безопасности стоит не спать по ночам. Wiz нашла оба бага с помощью обвязки для сканирования кода на базе ИИ, а затем использовала frontier-модели, чтобы подтвердить эксплуатируемость. И они были не одни: Ikotas Labs, Metnir, Rapid7 и Xint независимо сообщили о тех же проблемах в F5 в одном и том же окне раскрытия. Пять команд, два десятилетних бага, и все сошлись в один момент.
Это не совпадение, а фазовый переход. Практический барьер, который раньше защищал старые баги с памятью, был не в том, что их нельзя найти в принципе, а в том, что прослеживание состояния через десятки путей кода стоило дорогого человеческого внимания. Модели теперь достаточно хороши именно в таком многошаговом рассуждении, и стоимость рухнула. Похожую картину недавно мы видели с Java4Shell, где 65 байт превратились в RCE — ещё одна долгоживущая уязвимость, которую подняли инструменты, умеющие отслеживать тонкие взаимодействия лучше уставших людей.
Отсюда следуют два вывода, и скажу прямо о каждом. Во-первых, у каждой защитной команды теперь есть та же способность к поиску, так что прогоните её по своему стеку, пока это не сделал кто-то другой. Во-вторых — и здесь я признаю границы своего вступления — атакующие тоже её имеют, и окно между «баг стал находимым» и «баг эксплуатируют» сжимается. В обсуждении на Hacker News всплыла неприятная деталь: исправление одной CVE неделю лежало в публичном репозитории до раскрытия, а сообщение коммита называло фирму, которая сообщила об уязвимости. Любой, кто сравнивает коммиты в поиске security-фиксов — известная чёрная техника, — получил фору. Процессы координированного раскрытия задумывались для мира, где поиск уязвимостей был редкостью. Того мира больше нет.
Уроки для фаззинга протокольных парсеров
Если вы поддерживаете любой сетевой парсер — а многие из нас поддерживают, в прокси, API-шлюзах, service mesh и собственных протоколах — эти баги можно использовать как чеклист того, где ваше тестирование, скорее всего, слабое.
- Фаззите последовательности, а не только сообщения. Обе CVE требуют многошаговых взаимодействий: частичных фреймов, приостановленных соединений, обновлений окна на граничных значениях. Фаззер, который мутирует отдельные фреймы, никогда не найдёт баг, для которого нужны фрейм A, пауза, затем фрейм B. Используйте stateful или grammar-aware фаззинг, который моделирует жизненный цикл соединения.
- Тестируйте время жизни объектов под давлением ресурсов. UAF срабатывает только тогда, когда Nginx нужно освободить слоты соединений. Ваши тесты должны запускаться с искусственно низкими лимитами ресурсов, чтобы выполнялись пути вытеснения.
- Проверяйте инварианты на каждом переходе состояния. «Если обработка > 0, соединение не должно находиться в списке переиспользуемых» проверяется одним assert. Дешёвые инварианты ловят баги, которые пропускает код-ревью.
- Ловите целочисленное переполнение в отладочных сборках. Знаковое и беззнаковое переполнение в арифметике управления потоком — ровно то, что породило CVE-2026-123007. Санитайзеры (UBSan) вместе с фаззингом подняли бы тревогу о нём много лет назад.
- Сравнивайте коммиты апстрима на предмет тихих security-фиксов. Защитники могут играть в ту же игру, что и атакующие. Слежение за коммитами, похожими на фиксы, даёт вам дни форы.
И процессуальное замечание, вынесенное из множества материалов о раскрытиях: сокращающиеся сроки раскрытия существуют потому, что разрыв между патчем и эксплойтом продолжает схлопываться. Ваш процесс реагирования — инвентаризация, приоритизация, поэтапное развёртывание — важнее любого отдельного исправления.
Что делать с вашими развёртываниями Nginx прямо сейчас
Исправление скучное, и это хорошая новость. Обновите Nginx OSS до стабильной 1.30.7 или mainline 1.31.9; клиентам Nginx Plus нужны исправленные релизы R33/R37. Если на этой неделе обновиться не получится, отключите HTTP/2: на версии 1.25.1 и новее это http2 off; в затронутых блоках server, а на старых версиях уберите параметр http2 из директив listen. Затем перезагрузите конфиг и убедитесь, что старые воркеры завершились. Это грубая мера: вы теряете мультиплексирование и сжатие заголовков, и латентно-чувствительные приложения это почувствуют. Но обе уязвимости закрываются полностью, и это изменение конфигурации, а не кода.
С обнаружением честный ответ такой: эти атаки трудно заметить в логах. Эксплуатация выглядит как странные последовательности фреймов HTTP/2 и, в итоге, неожиданные падения воркеров или ситуации, когда Nginx порождает процессы, которых не должен порождать. Воркеры, которые постоянно падают и перезапускаются на доступном из интернета Nginx с включённым HTTP/2, заслуживают расследования, а не просто перезапуска супервизором.
И одно уточнение области: HTTP/2 в Nginx по умолчанию не включён, а по опросам его используют около 12% серверов. В масштабах интернета это всё равно миллионы экземпляров, но проверьте, прежде чем паниковать. И проверьте балансировщики нагрузки и origin-серверы CDN, потому что тот Nginx, о котором вы забыли за управляемым ingress, — как раз тот, который взломают.
Сложность никогда не была границей безопасности. Это была просто очередь — и теперь она движется быстрее.
Главный урок для критичной инфраструктуры
Если отойти подальше, картина ясна: самые важные баги сегодня живут в stateful протокольных реализациях с ручным управлением памятью, в инфраструктуре, которой пользуются все. Только это раскрытие принесло десять CVE в Nginx: UAF в HTTP/2, UAF в HTTP/3, UAF в DNS-резолвере, UAF в почтовом прокси. Общая черта здесь не халатность — кодовая база Nginx дисциплинирована по меркам C. Общая черта в том, что ручное управление временем жизни в асинхронных, управляемых атакующим state machine превышает то, что любая команда способна проверить глазами.
Так к чему мы приходим? Не к «перепишем всё на Rust», как бы ни соблазнял этот призыв, хотя переписывание самых открытых парсеров на безопасных по памяти языках — действительно хорошая идея, и индустрия потихоньку этим занимается. Ближе к делу: относитесь к своим периферийным прокси как к самой ценной цели для аудита в стеке, требуйте stateful-фаззинг и санитайзеры от проектов, от которых зависите, и выстраивайте операционную привычку патчить или смягчать проблемы за дни. Эпоха, когда одиннадцатилетний баг мог тихо ждать, пока человек его заметит, закончилась. Теперь очередь читают машины, и с обеих сторон.



