Подробные статьи о технологиях, определяющих будущее.

Java4Shell: баг в Base64 OpenJDK превращает 65 байт в RCE

Java4Shell — уязвимость порчи памяти в AVX-512 декодере Base64 в OpenJDK. Как 65 байт вызывают порчу кучи и RCE и что сделать уже сегодня.

Иллюстрация крошечного светящегося дефекта на конвейерной ленте, портящего огромную промышленную машину
Самый маленький компонент стека, быстрый путь для Base64, оказался тем, что прожигает всё насквозь.

Шестьдесят четыре буквы A и один знак равенства. Этого достаточно, чтобы повредить кучу непропатченного сервера OpenJDK: строка Base64 из 65 символов проходит мимо знаменитой безопасности памяти Java и записывает на 62 байта дальше конца массива. Уязвимость, раскрытая компанией Calif под названием Java4Shell (CVE-2026-114938, CVSS 9.2), сидит не в коде приложения, а в рукописном ассемблере внутри декодера Base64 в JVM. Удалённое выполнение кода без аутентификации продемонстрировали против Keycloak, Jenkins, Jira, Confluence, Artifactory и PingFederate. Если ваша организация запускает Java на серверах x86-64, а статистически это так, эта проблема касается и вас.

Я профессионально занимаюсь уязвимостями, и большинство из них сливаются в одно: очередной баг десериализации, очередной обход аутентификации, очередной path traversal. Java4Shell отличается, и дело не в оценке. Она отличается тем, где находится. Баг сидит в оптимизации, в ускорении декодирования Base64 с помощью векторных инструкций AVX-512, которая почти никакому приложению на свете на самом деле не нужна. История о том, как его нашли, как эксплуатировали и почему ваши прокси, возможно, уже вас спасают, многое говорит о том, куда движется безопасность софта.

Проблема: JIT-интринсик со сломанной маской

Чтобы понять баг, нужно знать, как OpenJDK делает Base64 быстрым. JVM HotSpot отслеживает, какие методы выполняются часто, и позволяет своему компилятору C2 превращать их в нативный код. Для некоторых операций он идёт дальше: подставляет вручную настроенные ассемблерные процедуры, называемые интринсиками, которые используют специализированные инструкции процессора. На чипах x86-64 с поддержкой AVX-512 VBMI декодирование Base64 получает именно такую обработку: интринсик перемалывает входные данные блоками по 256 или 64 байта, используя инструкцию VMOVDQU8 с 64-битной маской, которая определяет, какие байты записываются в целевой буфер.

Ошибка в том, как вычисляется эта маска для дополненного хвоста входных данных. Base64 дополняет вывод символами =, и ассемблер уменьшает длину вывода на каждый встреченный байт заполнения. Для некоторых некорректных входных данных, например одиночного = в конце блока, вычисленная длина вывода уходит в минус, до -1 или -2. Это отрицательное значение попадает в инструкцию битовых манипуляций (bzhiq), которая для входных данных длиной 64 и больше оставляет маску нетронутой: все 64 бита установлены. Все биты установлены, значит, записывается каждый байт.

Разберём конкретный триггер. Вы отправляете 64 буквы A, за которыми идёт =, всего 65 символов. JVM вычисляет длину декодированных данных как 50 байт и выделяет массив на 50 байт. Интринсик корректно декодирует первые 64 символа, натыкается на лишний знак равенства, уходит в минус по длине, выставляет полную маску и выполняет 64-байтную векторную запись, которая начинается почти в конце 50-байтного буфера. 62 байта соседних объектов кучи затираются константными данными, на которые может влиять злоумышленник. Проверка в Java в итоге замечает, что входные данные некорректны, и выбрасывает IllegalArgumentException, но к этому моменту ущерб уже нанесён. Обработчик исключений вытирает пол, когда дом уже горит.

// Pseudocode of the mask calculation (after Calif's write-up)
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
// For a lone '=' tail, output_len was already 0
// -> now it's -1, and bzhiq(-1, 255) leaves all bits set
output_mask := bzhiq(-1, output_len)   // == -1u64, all 64 bits 1
// evmovdqub then writes all 64 bytes where ~50 were allocated

Одна деталь важна для triage: это выполняется только на хостах x86-64, процессоры которых поддерживают AVX-512 VBMI. ARM-серверы вроде AWS Graviton никогда не запускают уязвимый стаб, как и более старые Xeon. Уязвимый путь выполнения также встречается только в JVM на базе HotSpot: OpenJDK, Oracle JDK, GraalVM. OpenJ9 и Azul Prime, которые используют другую архитектуру JIT, не затронуты. Кстати, в OpenJDK 17 триггер — 128 букв A плюс =, а не 64, потому что порог входа в быстрый путь выше. Мелочи, но они важны, если вы пишете правила детектирования.

Неудачная попытка первая: «Java безопасна по памяти»

Первая реакция в инженерных чатах, когда это появилось, была недоверием. Порча памяти в Java? Разве не ради безопасности памяти всё и затевалось? Этот инстинкт, что рантайм — это крепость и предать вас может только прикладной код, и есть первая неудачная модель. Стоит её разобрать, потому что она определяет, как команды аудитируют свой стек.

Язык Java проверяет каждое обращение к массиву и управляет каждым выделением памяти. Но рантайм Java — это огромный объём кода на C, C++ и ассемблере. JIT-компиляторы, сборщики мусора, интринсики, код нативных образов — всё это выполняется с полной, неконтролируемой мощью процесса, и ни один из них не получает гарантий, которые Java даёт вашему байт-коду. Каждый интринсик — это маленькая дыра в стене безопасности, пробитая ради скорости, и эти дыры поддерживает относительно небольшая горстка инженеров VM. Это тот же структурный урок, что и десятилетний баг со звёздочкой в SSH в Alpine Linux: самые страшные дефекты живут в коде, от которого все зависят, а читает его почти никто.

Здесь есть слепое пятно в аудите безопасности, которое я вижу постоянно. Команды фаззят свои JSON-парсеры, пентестят REST-обработчики и прогоняют статический анализ по каждой написанной строке, а потом считают JDK чёрным ящиком, потому что он зрелый, широко развёрнутый и его поддерживают умные люди. Зрелость — не защита. Часто всё наоборот: десятилетия накопленных оптимизаций, каждая из которых была разумна в своё время, и каждая добавляет поверхность атаки, которая поставляется всем, нравится им это или нет. Интринсик AVX-512 для Base64 существует, чтобы ускорять приложения, декодирующие огромные объёмы данных. Ваш REST API, декодирующий 200-байтный заголовок авторизации, получает весь риск и почти никакой выгоды. Calif называет это трагедией общих ресурсов, и они правы: все, кому нужна была функция, получили пользу, а все остальные получили только баг.

Неудачная попытка вторая: «Запись слишком ограничена, чтобы её эксплуатировать»

Вторая неудачная модель пришла от тех, кто прочитал технические детали и расслабился. Перезапись константным значением по фиксированному смещению без контроля над записываемыми байтами? Многие баги такого рода относят к категории «только падение» и понижают в приоритете. Это отклонение понятно, но неверно, и причина, по которой оно неверно, — самая поучительная часть всей истории.

Современная эксплуатация — это не о том, что может сделать один примитив, а о том, как окружающую систему можно убедить расставить объекты вокруг него. Техника Calif называется heap grooming: удалённое формирование поведения аллокатора так, чтобы предсказуемый и полезный объект оказался сразу за переполненным буфером. Они делали это по сети, используя тайминг запросов, чтобы управлять моментами выделения и освобождения памяти на цели. Запись может быть константной, но если вы контролируете, какой объект попадает в зону поражения, вы контролируете и то, что будет испорчено. Дальше они построили раскрытие памяти в стиле Heartbleed, вытекли достаточно данных, чтобы обойти ASLR, и выстроили цепочку до полноценного удалённого выполнения кода.

Абстрактная сетка городских блоков памяти, выстроенная в продуманный узор с одним красным блоком в центре
Heap grooming превращает ограниченную запись с константным значением в оружие, контролируя, куда эта запись попадает.

В разборе есть восхитительно прагматичная деталь о том, как заставить это работать через реальный интернет. Удалённый heap grooming чувствителен ко времени round-trip и джиттеру: запросы должны приходить в определённом ритме, чтобы аллокатор оказался в нужном состоянии. Вместо того чтобы реверсить стек TCP, исследователи арендовали VM в том же облачном регионе, что и цель. Они решили физическую задачу деньгами. Я годами видел, как элитные разработчики эксплойтов делают что-то подобное, и это хорошее напоминание: ограничения атакующего — это экономика не меньше, чем техника. Хорошо финансируемый противник считает сетевой джиттер статьёй бюджета.

Стоит отметить и то, что универсального эксплойта не существует. Каждое приложение, Jira, Jenkins, Keycloak, по-своему использует Base64, по-своему выделяет память и открывает разные поверхности для grooming. Это хорошая новость. Плохая — огромное количество точек входа. Заголовки авторизации, поля загрузки файлов, обработка клиентских сертификатов, полезная нагрузка сообщений: везде, где текст в Base64 попадает в JVM, может быть триггер. Один из участников даже продемонстрировал клиентский вариант: Java-приложение, которое открывает TLS-соединение с вредоносным сервером, можно скомпрометировать, не открывая вообще никакой службы. Ваши пакетные задания и внутренние утилиты входят в зону риска, а не только шлюзы, смотрящие в интернет.

Кентавр в комнате: ИИ нашёл это за час

Теперь часть, которая должна перекалибровать модель угроз каждой команды безопасности. Исследователь Куанг Луонг нашёл уязвимость примерно за час и получил работающий эксплойт примерно через два часа после этого. Общая стоимость токенов ИИ составила меньше 200 долларов. Его метод: натравить ИИ-агента для написания кода на участки HotSpot, где сложность пересекает границы, то есть на JIT, интринсики, широко доступные API и криптографию, а потом отфильтровывать шум. Большая часть того, что агент выдавал, была недостижимой халтурой. Он продолжал промптить, и через двадцать минут настойчивости нашлась находка с Base64.

Calif называет это «хакером-кентавром»: человек даёт интуицию о том, где сложные системы ломаются, а ИИ даёт выносливость. Мне кажется, это точно, и последствия работают в обе стороны. Тот же цикл, что нашёл Java4Shell, доступен любому, у кого есть API-ключ, а фаза разработки эксплойтов, то есть создание повторно используемых конвейеров grooming и последующий запуск агентов, которые перемалывают цепочки для каждого приложения, всё больше автоматизируется. Экономика поиска багов в зрелом, широко развёрнутом C и ассемблере только что обвалилась. Защитникам стоит исходить из того, что следующие десятки багов класса Java4Shell уже ищут люди, которые не подают отчёты о раскрытии. Это давление стоит за спорами вроде сокращающихся сроков раскрытия у Project Zero: когда обнаружение дешевеет, окно для патча становится всей игрой.

Предложенный Calif контрход провокационный, и я в основном с ним согласен: использовать то же ИИ-преимущество, чтобы удалять код, а не добавлять. Они называют это «vibe-uncoding»: аудит кодовой базы на предмет мёртвых функций, устаревшей поддержки протоколов и ненужных оптимизаций с последующим их вырезанием, чтобы уменьшить поверхность атаки. Честное возражение такое: удаление рискованно, ведь якобы неиспользуемые функции имеют скрытых потребителей, а удаление требует тестирования, которое команды хронически недофинансируют. Но направление верное. Если в вашем JDK есть рукописный ассемблерный быстрый путь для нагрузки, которой у вас никогда не будет, оптимальная позиция по безопасности — вообще не поставлять этот путь. Если же нельзя, JVM хотя бы даёт переключатель, чтобы его выключить. Это подводит нас к тому, что реально работает.

Что действительно работает: патч, флаг, прокси

Это то, что волнует вашу дежурную смену. Исправления делятся на три уровня, и я бы сказал, что вам стоит делать как минимум два из них уже сегодня, а не после следующего окна изменений.

  1. Установите исправленную сборку OpenJDK. Исправление в upstream (коммит JDK 5177a70) корректирует вычисление маски. Это единственное полное исправление. Уязвимые версии начинаются с 17.0.6 в линейке 17 и продолжаются до актуальных релизов на 21 и выше; сверьтесь со списком версий с исправлением для вашей конкретной ветки и считайте каждую JVM на базе HotSpot (OpenJDK, Oracle JDK, GraalVM) попадающей под риск, пока не доказано обратное.
  2. Отключите интринсик как временную меру. Запустите JVM с -XX:-UseBASE64Intrinsics, чтобы полностью выключить аппаратно ускоренный Base64. Цена производительности ничтожна, если только вы не декодируете гигабайты Base64, а этим почти никто не занимается. В качестве альтернативы -XX:UseAVX=2 отключает AVX-512 на x86-64, но не ставьте этот флаг на ARM, где JVM откажется запускаться. Это та же философия, что и в плейбуке по критическим CVE в PHP: когда уязвимый компонент является узким, заменяемым быстрым путём, убить быстрый путь лучше, чем ждать.
  3. Используйте прокси, чтобы сломать тайминг эксплуатации. В разделе об ограничениях самой Calif отмечено, что текущие профили удалённого grooming опираются на частичные тела запросов, которые доходят до приложения с точным таймингом. Обратный прокси, который буферизует полное тело запроса, как это по умолчанию делает nginx, разрушает такой тайминг. Это ни в коем случае не исправление, но оно заметно ослабляет самый практичный путь атаки, пока вы накатываете патч.

Обнаружению стоит уделить пару предложений. Semgrep опубликовал бесплатные скрипты, которые проверяют сочетание условий, делающих хост уязвимым: VM семейства HotSpot, аппаратное обеспечение x86-64 с нужной поддержкой инструкций и версия из уязвимого диапазона. Прогоните это по всему парку, прежде чем считать себя уязвимыми. Ваши контейнеры на ARM и отставшие OpenJ9 в порядке, и быстро это понять означает сэкономить выходные. При сканировании помните, что линейки версий важны: исправление вышло в конкретных патч-релизах для каждой ветки, поэтому «у нас 21» не является ответом.

Три концентрических защитных слоя, прикрывающих светящееся ядро, с рукой, переключающей тумблер на самом внутреннем кольце
Слоите защиту: патчите ядро, убивайте быстрый путь и пусть прокси ломает тайминг атакующего.

Главный урок: оптимизации — это обязательства, которые вы не аудировали

Отойдите от реагирования на инцидент, и Java4Shell оставляет неприятный осадок. Баг сидел не в каком-то обскурном углу. Он был в Base64, пожалуй, самой скучной, самой вездесущей и самой «ну уж это-то давно в порядке» операции в вычислениях. Уязвимость существовала именно потому, что кто-то сделал скучную вещь быстрой, используя новейшие векторные инструкции, на ассемблере, с граничным случаем обработки хвоста, который пережил код-ревью. Каждый зрелый рантайм набит такими штуками. И каждую из них теперь охотно ищут неутомимые агенты, которые стоят меньше хорошего ужина.

Все спрашивают, что ИИ может построить. Более правильный security-вопрос может звучать так: что он может помочь нам удалить.

Моё мнение: индустрия скоро узнает разницу между кодом, который аудирован, и кодом, который считается безопасным, и обучение обойдётся дорого. Стандартные библиотеки, интринсики VM, кодеки сжатия, декодеры изображений — фундаментальные слои, которые мы никогда не ставим под сомнение, именно там человеческое внимание наиболее дефицитно и где поиск с помощью ИИ приносит самые большие вознаграждения. Модель кентавра не просто находит баги быстрее; она находит их там, где человеческие исследователи проходили мимо, потому что ожидаемая отдача от аудита «решённого» кода казалась слишком низкой.

Так что патчьте JVM, переключайте флаг интринсика там, где не можете обновиться, и пусть nginx купит вам время. Но ещё сходите в собственное дерево зависимостей и задайте вопрос об «анкодинге»: какие из этих функций мы унаследовали, а не выбрали? 65-символьная строка, которая сожжёт ваши выходные, наверняка уже написана. Вопрос лишь в том, подаст ли тот, кто её держит, отчёт о раскрытии или нет.