Обзор
Сегодня Rapid7 и F5 раскрывают CVE-2026-123007, критическую уязвимость целочисленного переполнения, затрагивающую nginx HTTP/2, которая может позволить неавторизованное удаленное выполнение кода (RCE) на затронутых серверах при определенных условиях.
nginx может неверно вычислять, сколько данных ответа клиент HTTP/2 разрешил ему отправить. Удаленный, неавторизованный клиент может воспользоваться этой ошибкой, отменяя очередные данные ответа, а затем заставить nginx использовать недопустимую длину при копировании более позднего ответа. В результате повреждение памяти может раскрыть данные, прервать сервис и выполнить код с правами процесса worker nginx.
Влияние
Rapid7 разработала proof-of-concept для демонстрации использования CVE-2026-123007 для неавторизованного RCE против уязвимого образа linux/amd64 Docker, работающего с nginx версии 1.31.8, как показано ниже на рисунке 1. Конфигурация целевого сервера nginx имела http2 on и TLS включены. Обратите внимание, что для краткости воспроизведение видео ускорено до 8x.
Рисунок 1: Видео, демонстрирующее неавторизованный RCE против NGINX 1.31.8 через CVE-2026-123007
Использование CVE-2026-123007 для RCE требует значительного объёма сетевого трафика, примерно 128 ГБ данных HTTP/2. Доступная пропускная способность сети и таймауты соединения ограничат практическую эксплуатацию в Интернете. В приведённом выше примере, показанном на рисунке 1, эксплуатация занимает два с половиной минуты. При передаче необходимых сетевых данных по сети 10 Gbit/s это занимает два минуты, а по сети 1 Gbit/s — семнадцать минут. Из‑за того, что nginx по умолчанию имеет срок жизни соединения один час, сеть медленнее примерно 300 Mbit/s превысит порог одного часового соединения и не сможет завершить эксплуатацию. Кроме того, если соединение HTTP/2 проксируется, точные кадры HTTP/2, контролируемые атакующим, вероятно, не будут повторно переданы таким образом, чтобы удовлетворить эксплуатацию уязвимости.
Наконец, разработанная стратегия эксплуатации зависит от конкретной реализации memcpy EVEX/YMM glibc x86-64, выбранной во время выполнения, на основе функций CPU avx512f и avx512vl. Альтернативные стратегии эксплуатации RCE могут быть жизнеспособными, но в настоящее время неизвестны.
Кредит
Эта уязвимость была обнаружена Стивеном Фьюером, старшим главным исследователем по безопасности в Rapid7, и раскрывается в соответствии с политикой раскрытия уязвимостей Rapid7.
Технический анализ
Версия nginx, протестированная, была образом linux/amd64 Docker для nginx версии 1.31.8 (nginx@sha256:5ab5b0b01097420873a3f3330f44248e34a3c2a3e8d5ee30658aeae8cb7435da), и работала с открытым HTTPS‑сервисом и включенным http2.
Как клиент управляет данными ответа HTTP/2
HTTP/2 передаёт сообщения, называемые кадрами, по соединению. Каждый запрос и ответ принадлежат нумерованному потоку, поэтому одно соединение может одновременно обслуживать несколько обменов. Байт‑тело ответа передаётся в кадрах DATA.
Для этой уязвимости nginx является отправителем, а удалённый клиент – получателем. Клиент предоставляет nginx разрешение, или кредит управления потоком, на отправку определённого количества байт DATA. nginx отслеживает оставшийся кредит двумя счётчиками: один для каждого потока и один общий для соединения. Отправка DATA разрешена только при наличии кредита обоих счётчиков. Эти счётчики HTTP/2 отделены от окна приёма TCP.
Клиент предоставляет больше кредита, отправляя кадр WINDOW_UPDATE, содержащий положительное увеличение. Идентификатор потока ноль увеличивает кредит отправки соединения. Ненулевой идентификатор потока увеличивает кредит отправки для конкретного потока с этим идентификатором. HTTP/2 ограничивает увеличение и результирующее окно до 2^31-1 байт, или 2 147 483 647 (0x7FFFFFFF). В этом отчёте это максимальное значение называется MAX.
Клиент также может отправить кадр SETTINGS, содержащий параметр SETTINGS_INITIAL_WINDOW_SIZE. Это изменяет начальный кредит для новых потоков. nginx также должен скорректировать оставшийся кредит каждого активного потока на разницу между старым и новым значением настройки. Он не меняет кредит соединения. Уменьшение может оставить активный поток с отрицательным кредитом до тех пор, пока клиент не предоставит больше. Окно соединения не имеет эквивалентного уменьшения: оно должно оставаться между нулём и MAX. RFC 9113, section 6.9 определяет эти пределы и требуемые ошибки.
nginx хранит счётчик соединения в h2c->send_window, где h2c – запись соединения HTTP/2. Его тип size_t – беззнаковое целое: в проверенной 64‑битовой сборке оно может хранить значения от нуля до 2^64-1. Тип size_t может, следовательно, хранить значения выше максимального окна соединения HTTP/2 2^31-1 байт (MAX). nginx должен применять этот протокольный предел в своей собственной логике.
Правило, что счётчик соединения в [2] никогда не должен превышать MAX в [1], является инвариантом окна соединения. Отдельный счётчик потока, stream->send_window, явно объявлен как ssize_t, знаковое 64‑битное целое в проверенной сборке. Это позволяет SETTINGS_INITIAL_WINDOW_SIZE сделать кредит потока временно отрицательным. Счётчик соединения остаётся беззнаковым. Позднее небезопасное преобразование происходит, когда выходной фильтр рассматривает избыточный кредит соединения как знаковую длину ответа 64‑бит off_t.
Использование уязвимости имеет четыре основные стадии:
- Замедляя чтение вывода сервера, клиент удерживает выбранные кадры DATA в очереди и не запускает их. Он повышает кредит соединения до MAX и кредит выбранных потоков чуть ниже MAX. Кадр SETTINGS, который увеличивает SETTINGS_INITIAL_WINDOW_SIZE достаточно, чтобы превысить предел потока, заставляет nginx закрыть эти потоки, оставив соединение пригодным. Очистка запроса затем восстанавливает зарезервированный кредит выше MAX.
Замедляя чтение вывода сервера, клиент удерживает выбранные кадры DATA в очереди и не запускает их. Он повышает кредит соединения до MAX и кредит выбранных потоков чуть ниже MAX. Кадр SETTINGS, который увеличивает SETTINGS_INITIAL_WINDOW_SIZE достаточно, чтобы превысить предел потока, заставляет nginx закрыть эти потоки, оставив соединение пригодным. Очистка запроса затем восстанавливает зарезервированный кредит выше MAX.
- Незнаковое вычитание в следующей проверке WINDOW_UPDATE соединения приводит к переполнению. Повторно принятые кадры WINDOW_UPDATE могут затем поднять счётчик в верхнюю половину диапазона 64‑бит без необходимости обёртывания сложения.
Незнаковое вычитание в следующей проверке WINDOW_UPDATE соединения приводит к переполнению. Повторно принятые кадры WINDOW_UPDATE могут затем поднять счётчик в верхнюю половину диапазона 64‑бит без необходимости обёртывания сложения.
- В проверенной 64‑битовой сборке nginx интерпретирует этот избыточный счётчик как отрицательную длину ответа и создаёт недопустимый буфер. Буферизованный TLS‑вывод затем передаёт огромный беззнаковый байтовый счёт в функцию копирования памяти memcpy, вызывая чтения и записи за пределами границ.
В проверенной 64‑битовой сборке nginx интерпретирует этот избыточный счётчик как отрицательную длину ответа и создаёт недопустимый буфер. Буферизованный TLS‑вывод затем передаёт огромный беззнаковый байтовый счёт в функцию копирования памяти memcpy, вызывая чтения и записи за пределами границ.
- Эти ограниченные обращения к памяти зависят от сборки и выбранной процедуры копирования. При подходящей компоновке памяти злоумышленник может использовать раскрытые адреса и контролируемую перезапись для выполнения кода с правами рабочего процесса nginx.
Эти ограниченные обращения к памяти зависят от сборки и выбранной процедуры копирования. При подходящей компоновке памяти злоумышленник может использовать раскрытые адреса и контролируемую перезапись для выполнения кода с правами рабочего процесса nginx.
Отмена поставленных в очередь DATA-фреймов восстанавливает слишком много кредита
Когда nginx ставит в очередь DATA-фрейм в [3], он вычитает длину данных этого фрейма из счетчика кредита соединения в [4], а затем из счетчика кредита потока. Это резервирует кредит до того, как байты достигнут клиента, и предотвращает использование того же кредита соединения другими потоками:
Злоумышленник может удерживать последующий ответ в очереди, замедляя или останавливая чтение предыдущих выходных данных сервера. Как только транспорт не может принимать больше данных, nginx вынужден ждать. Это состояние называется обратным давлением транспорта (backpressure). Злоумышленнику нужно достаточное его количество, чтобы выбранный DATA-фрейм оставался неначатым: ни один байт этого фрейма еще не попал в выходной поток TLS или сокет. Остановка чтения ответов не мешает клиенту отправлять управляющие фреймы в другом направлении.
Пока DATA-фрейм остается в очереди, клиент отправляет WINDOW_UPDATE соединения, который увеличивает уменьшенный счетчик nginx до MAX. Проблема возникает, когда запрос, которому принадлежит поставленный в очередь DATA-фрейм, закрывается. Его обработчик очистки запроса удаляет неначатый DATA-фрейм и возвращает зарезервированный кредит:
Проверка в [5] выбирает удаляемые, неначатые фреймы для этого запроса. Локальная переменная window суммирует их длины данных в [6]. Сложение в [7] не проверяет, превышает ли восстановление этих байтов счетчик соединения выше MAX.
Например, восстановление 1393 байт после того, как счетчик достиг 2 147 483 647 (0x7FFFFFFF), дает 2 147 485 040 (0x80000570). Это значение является недопустимым в HTTP/2, так как оно превышает MAX, хотя все еще помещается в 64-битный size_t; сложение еще не привело к переполнению. Непроверенное восстановление в [7] является первым недопустимым состоянием в данной уязвимости. Злоумышленнику все еще нужен способ закрыть выбранные запросы, сохранив соединение, чтобы избыточный счетчик можно было использовать снова.
Ошибка SETTINGS закрывает поток, но оставляет соединение работоспособным
Когда фрейм SETTINGS увеличивает SETTINGS_INITIAL_WINDOW_SIZE настолько, что кредит активного потока превышает MAX, nginx завершает этот поток, но оставляет HTTP/2-соединение работоспособным. Клиент может создать это условие, сначала отправив WINDOW_UPDATE потока, чтобы установить выбранный поток чуть ниже MAX. Затем он отправляет фрейм SETTINGS, который увеличивает начальный размер окна потока. Например, изменение настройки с 65 535 на 65 537 добавляет два байта к каждому активному потоку. Поток, который уже был на уровне MAX-1, станет MAX+1, даже если само значение новой настройки является допустимым.
RFC 9113 требует, чтобы это условие приводило к завершению соединения с ошибкой FLOW_CONTROL_ERROR. Вместо этого nginx вызывает ngx_http_v2_terminate_stream() для каждого затронутого потока. Эта функция отправляет RST_STREAM, который завершает отдельный поток и вызывает очистку запроса. Затем цикл продолжается, используя то же соединение:
Здесь delta — это разница между новым и старым значениями настроек. Очистка запроса выполняет шаги с [5] по [7], в то время как continue в [8] оставляет HTTP/2-соединение открытым. Теперь злоумышленник может отправлять дополнительные фреймы по соединению, кредит которого превысил MAX.
Следующий WINDOW_UPDATE вызывает целочисленное переполнение (underflow)
Когда приходит очередной WINDOW_UPDATE соединения, nginx пытается рассчитать, сколько дополнительного кредита все еще разрешено:
В этой функции window — это приращение, полученное от клиента. Вычитание в [9] безопасно только до тех пор, пока сохраненный счетчик не превышает MAX. Если очистка восстановила R избыточных байтов, предполагаемый лимит составляет MAX - (MAX + R), или -R. Беззнаковая арифметика не может представить этот отрицательный результат. В проверенной 64-битной сборке происходит перенос до 2^64 - R, очень большого положительного числа. Это и есть целочисленное переполнение, идентифицированное как CWE-191.
Некорректный лимит позволяет дальнейшим приращениям от клиента пройти проверку. Отправляя множество приращений, каждое из которых не превышает MAX, клиент может поднять счетчик до 2^63 или выше, не вызывая переполнения самого сложения, как показано в [10] выше. Такое значение имеет установленный старший бит в своем 64-битном представлении. Это все еще беззнаковое значение, но оно больше не помещается в знаковое 64-битное целое число. Это различие имеет значение, когда nginx подготавливает следующий ответ.
Это усиление объясняет необходимость большого объема трафика. WINDOW_UPDATE соединения занимает 13 байт HTTP/2: девятибайтовый заголовок фрейма и четырехбайтовую полезную нагрузку. Кредит, предоставляемый этим фреймом, не является данными, фактически передаваемыми по сети. Начиная с описанного выше состояния небольшого превышения кредита, достижение 2^63 с помощью приращений максимального размера занимает около 2^32 фреймов, или 52 ГБ. Достижение значений, близких к 2^64, используемых для подтвержденного пути чтения/записи, занимает около 2^33 приращений, или 104 ГБ. nginx также ограничивает трафик управляющих фреймов относительно других полученных данных. Текущая репродукция выполнения кода отправляет около 15 ГБ дополнительного трафика заголовков запросов, чтобы оставаться в пределах этого лимита, доводя общий объем открытого текста до примерно 119,02 ГБ. TLS и сетевые накладные расходы увеличивают фактический трафик в сети. Эти цифры описывают данный 64-битный путь усиления, а не универсальный минимум для каждого возможного эксплойта.
Избыточный кредит становится отрицательной длиной ответа
Клиент может заставить активный поток с доступным кредитом обработать обычное тело ответа. Фильтр вывода HTTP/2 в nginx решает, сколько байтов тела включить в DATA-фрейм. Прежде чем следовать этому расчету, полезно определить буфер, который он создаст.
Буфер nginx в памяти описывается записью ngx_buf_t. Его указатель pos — это адрес памяти следующего байта для отправки. Его указатель last — это адрес сразу после доступных данных. Для четырех доступных байтов last должен быть на четыре байта дальше pos; вычитание pos из last дает длину, равную четырем. Таким образом, допустимый буфер не может иметь last перед pos. nginx связывает эти записи буфера вместе в цепочку вывода, которая представляет собой список данных, ожидающих отправки.
В ngx_http_v2_send_chain() лимит байтов представляет собой off_t, знаковое 64-битное целое число в проверенной сборке. Избыточный беззнаковый счетчик соединения преобразуется в этот знаковый тип в [11]. В этой сборке значение 2^64 - d, где d — небольшое положительное количество байтов, становится -d:
Проверка окна потока не отклоняет отрицательный лимит: она только уменьшает лимит, который слишком велик. В [12] отрицательный лимит становится огромным беззнаковым frame_size. Приведение того же значения обратно к off_t снова делает его отрицательным, поэтому [13] пропускает цикл, который обычно потреблял бы и ограничивал доступные байты тела. В [14] nginx передает недопустимую длину вспомогательной функции, чей параметр размера также является знаковым off_t.
Этот вспомогательный элемент создает теневой буфер: новую запись метаданных, ссылающуюся на часть существующих данных ответа, без копирования самого тела ответа. Он устанавливает новый конечный указатель, используя предоставленную длину:
Поскольку размер отрицательный, в [15] метка last оказывается перед pos. Тело ответа не увеличилось в размере; метаданные его буфера теперь некорректны. Следующий этап вывода доверяет этим метаданным.
Буферизованный вывод TLS выполняет копирование за пределами буферов
Для буферизованного вывода TLS функция ngx_ssl_send_chain() собирает байты из выходной цепочки в промежуточный буфер перед шифрованием. Она вычисляет длину каждого входного буфера с помощью выражения last - pos. Некорректный буфер дает отрицательную знаковую длину в [16]:
Обе проверки лишь уменьшают слишком большие длины. Ни одна из них не отклоняет отрицательную длину. Функция memcpy принимает количество байтов без знака size_t, поэтому в [17] значение -d преобразуется обратно в огромное число 2^64-d. Фактические исходный буфер и буфер назначения гораздо меньше. Именно здесь неверный кредитный ресурс соединения впервые приводит к выходу за границы памяти (out-of-bounds) при доступе к нативной памяти.
Копирование, которое действительно охватывало бы столь огромный диапазон, обычно наталкивалось бы на недоступную память и приводило бы к аварийному завершению рабочего процесса (воркера). Однако в протестированной реализации glibc для x86-64 определенные значения длины чуть меньше 2^64 заставляют вычисления конечного адреса на уровне машины закольцовываться (подробнее об этом неожиданном поведении см. в Приложении А ниже). Для длины 2^64-d прибавление длины к начальному адресу может дать адрес, находящийся на d байт раньше него. Оптимизированная процедура копирования использует эти конечные адреса в условиях своих циклов, поэтому она может завершиться после ограниченного числа чтений и записей, выходящих за пределы предназначенных буферов. Копирование может завершиться успешно, если все фактически задействованные адреса доступны; другие значения длины, схемы размещения памяти или реализации копирования могут сразу вызвать сбой. Если функция возвращает управление, nginx также сдвигает обе позиции буфера назад на отрицательное знаковое значение длины.
Эксплуатация
Некорректное копирование позволяет как читать память воркера, так и перезаписывать ее. Оно не предоставляет клиенту поле HTTP/2, в котором можно было бы произвольно выбрать любой адрес памяти. Полезные адреса зависят от того, где nginx выделил буферы ответа и TLS, сколько данных уже буферизовано и какую процедуру копирования выбрала библиотека C. Это ограниченные возможности чтения и записи, а не безусловное произвольное чтение или запись.
После создания некорректного буфера DATA функция ngx_http_v2_send_chain() обновляет его позицию в исходном ответе и записывает байты, которые еще предстоит отправить:
Здесь offset — это позиция в исходном теле ответа, а size — его оставшаяся длина. Начиная с нулевого смещения, то же самое беззнаковое значение, представляющее -d, заставляет [18] сдвинуть смещение назад на d и увеличить оставшуюся длину на d в проверенной сборке. Таким образом, теневой буфер, созданный в [19], имеет положительную длину, но начинается на d байт раньше исходного ответа и заканчивается на его исходном конце. Если избыточное копирование и соединение переживут это, последующие обычные кадры DATA могут передать эти предшествующие байты клиенту через TLS. Они могут включать указатели в кучу (heap), где nginx динамически выделяет данные запросов, или в загруженные библиотеки. Эти указатели раскрывают адреса, которые в противном случае были бы скрыты рандомизацией размещения адресного пространства (ASLR).
Со своей стороны, в отношении записи nginx сохраняет предоставленные клиентом данные запроса в памяти кучи. При подходящей структуре выделения памяти избыточное копирование может захватить выбранные злоумышленником байты и заменить поля в находящемся поблизости активном объекте кучи. Одним из полезных полей является callback — сохраненный указатель на функцию, которую nginx собирается вызвать позже. Злоумышленник, который знает соответствующие адреса процесса и может перезаписать это поле, может перенаправить стандартную обработку nginx на существующий исполняемый код. Перезапись не обязательно должна содержать новый машинный код. Это объясняет общий путь от раскрытых адресов и контролируемых байтов к выполнению кода; при этом не утверждается, что каждая сборка раскрывает один и тот же объект или callback. Выполнение происходит с правами воркера; выполнение с правами главного процесса (master) или суперпользователя не доказано.
Сначала восстанавливает адреса кучи и указатели на nginx и Библиотеку C GNU (glibc) из памяти, предшествующей исходному телу ответа. Он использует эти адреса и перезапись для подделки объектов запроса и буфера ответа nginx, которые возвращают выбранные части загруженного образа glibc по протоколу HTTP/2. Возвращаемые метаданные ELF анализируются для вызова system() в обход ASLR, после чего callback-функция очистки пула запросов перенаправляется на запуск выбранной злоумышленником команды.
Приложение А: Почему избыточный вызов memcpy может завершиться успешно
Копирование TLS через ngx_memcpy (показанное в [17] выше) получает количество байтов 2^64-d, где d — небольшое положительное расстояние. Программа, которая действительно проходила бы весь этот диапазон, обычно вызывала бы сбой. В этом приложении объясняется, почему одна из оптимизированных реализаций glibc вместо этого может завершиться после ограниченного числа выходов за границы.
glibc выбирает среди оптимизированных процедур копирования в соответствии с возможностями процессора. Протестированная рутина для x86-64 использует инструкции EVEX/YMM, которые могут перемещать по 32 байта за раз. В исходном коде соответствующей glibc 2.41 обертка EVEX включает общую реализацию memcpy/memmove, а ее конфигурация векторов устанавливает VEC_SIZE равным 32. Вектор — это блок байтов, обрабатываемый одной такой инструкцией.
В следующем фрагменте используется синтаксис ассемблера AT&T, в котором исходный операнд стоит на первом месте. Регистр процессора %rdi содержит исходный адрес назначения, называемый ниже D; %rsi содержит исходный адрес, Q; а %rdx содержит количество байтов, n. Один из путей попадает в эту ветку обратного копирования, когда D и Q различаются и беззнаковая разность D-Q меньше n. Сюда относится обычный случай, когда D находится выше Q, а n близок к максимальному 64-битному значению без знака.
Полный ассемблерный исходный код glibc показывает опущенные операции загрузки и сохранения. В [20] инструкция leaq вычисляет адрес без чтения памяти. Ее 64-битный результат сохраняет только младшие 64 бита. В [21] иandq округляет этот адрес вниз до границы 32 байт. Называя полученный адрес назначения курсором (cursor), вычисление выглядит так:
Здесь align_down_32 означает округление вниз до ближайшего адреса, делящегося на 32; это поясняющее обозначение, а не функция glibc. Для обычного адреса кучи и небольшого d вычисленный курсор уже находится ниже D.
Цикл начинается с копирования одного 128-байтового блока. Затем инструкция [22] сдвигает курсор назад еще на 128 байт. Сравнение и безусловный переход в [23] повторяют цикл только до тех пор, пока D < cursor. Поскольку курсор уже ниже D, переход не выполняется. Процедура записывает оставшиеся начальные и конечные векторы, а затем возвращает управление в [24]. Она не скопировала огромный запрошенный диапазон: закольцованный адрес заставил цикл остановиться после небольшого набора обращений. Эти обращения все же могут читать и перезаписывать память за пределами фактических буферов.
Доступны следующие исправления, предоставленные производителем.
Продукт
Уязвимые версии
Исправленная версия
NGINX Plus
37.1.0 - 37.2.0.1
37.3.0.1
NGINX Plus
37.0.0 - 37.0.7.1
37.0.8.1
NGINX Plus
R34 - R36
Нет
NGINX Open Source
1.31.0 - 1.31.8
1.31.9
NGINX Open Source
1.9.5 - 1.30.6
1.30.7
Актуальную информацию об устранении уязвимостей см. на сайте производителя .
Хронология раскрытия информации
- 11 ноября 2026 г.: Rapid7 осуществляет первичный контакт с F5.
11 ноября 2026 г.: Rapid7 осуществляет первичный контакт с F5.
- 12 ноября 2026 г.: F5 подтверждает контакт, и Rapid7 сообщает об уязвимости. F5 подтверждает получение информации об уязвимости.
12 ноября 2026 г.: F5 подтверждает контакт, и Rapid7 сообщает об уязвимости. F5 подтверждает получение информации об уязвимости.
- 16 ноября 2026 г.: F5 подтверждает проверку уязвимости, присвоение CVE и дату раскрытия информации — 18 ноября 2026 г.
16 ноября 2026 г.: F5 подтверждает проверку уязвимости, присвоение CVE и дату раскрытия информации — 18 ноября 2026 г.
- 18 ноября 2026 г.: Настоящее раскрытие информации.
18 ноября 2026 г.: Настоящее раскрытие информации.











