Переполнение EVP_EncodeBlock в OpenSSL: 5 мифов
Переполнение буфера в OpenSSL EVP_EncodeBlock (CVSS 9.8) показало, почему base64-кодировщики ускользают от проверки. Пять мифов, которые мы проверили на практике.

Функция, которая делает только одно, превращает байты в base64-текст, и только что получила оценку CVSS 9.8. Переполнение буфера в EVP_EncodeBlock в OpenSSL, отслеживаемое как CVE-2026-121481, из тех багов, которые кажутся скучными, пока не осознаешь, что base64 лежит в основе работы с сертификатами, HTTP-клиентов, аутентификации на прокси и половины клеевого кода в твоей инфраструктуре. Само исправление заняло четыре коммита и основательно горячий спор мейнтейнеров о том, каким вообще должен быть возвращаемый код ошибки.
Обсуждение этой CVE находка для всех, кому небезразличен дизайн API, потому что оно вскрывает кучу допущений, которые инженеры делают о функциях кодирования. Эти допущения десятилетиями и в разных библиотеках порождают один и тот же класс багов. Возьмём пять самых распространённых убеждений и сверим их с тем, что произошло на самом деле.
Как на самом деле работает переполнение буфера в EVP_EncodeBlock
Base64 раздувает данные: каждые три входных байта превращаются в четыре выходных символа. Поэтому размер вывода равен 4 * ((n + 2) / 3), плюс один байт для завершающего NUL, если нужна C-строка. EVP_EncodeBlock() в OpenSSL заставляет вызывающий код вычислить этот размер и выделить буфер назначения. Сама функция получает указатель на входные данные, указатель на выходной буфер и длину входа как int. Она никогда не узнаёт, насколько велик выходной буфер, поэтому ничего не может проверить. Она просто пишет.
Теперь арифметика. Максимальный int равен 2 147 483 647. Когда длина входа превышает (INT_MAX / 4) * 3, то есть 1 610 612 733 байта, примерно 1,6 ГБ, внутренний расчёт размера переполняет знаковое 32-битное целое. Арифметика длин заворачивается, представление функции о том, где заканчивается вывод, перестаёт соответствовать реальности, и происходит запись за пределы буфера, который выделил вызывающий код. Вызывающая сторона, следуя документированной формуле, выполнила ту же переполняющуюся арифметику, поэтому обе стороны могут катастрофически расходиться в оценке того, сколько места есть.
В апстрим-исправлении добавили проверку: отвергать входы, где dlen > (INT_MAX / 4) * 3, а также NULL-буферы и отрицательные длины. Если ты оборачиваешь этот API, а оборачивать его стоит, проверка должна быть и на твоей границе:
#include <limits.h>
#include <stddef.h>
#include <openssl/evp.h>
/*
* Mirrors the upstream guard: refuse inputs whose encoded size
* cannot be represented in an int, and verify the destination
* capacity ourselves since the API never sees it.
*/
int b64_encode_checked(const unsigned char *in, size_t n,
unsigned char *out, size_t out_cap)
{
size_t need;
if (in == NULL || n > ((size_t)INT_MAX / 4) * 3)
return -1;
need = ((n + 2) / 3) * 4 + 1; /* +1 for the NUL terminator */
if (out == NULL || out_cap < need)
return -1;
if (EVP_EncodeBlock(out, in, (int)n) < 0)
return -1;
return 0;
}
Обрати внимание, что этот API вынуждает делать: заново реализовать внутреннюю формулу размера библиотеки в вызывающем коде, правильно и навсегда. Именно этот контракт и есть настоящая уязвимость. Переполнение лишь место, где контракт наконец треснул.
Миф 1: «Декодеры — поверхность атаки, а энкодеры скучны»
В культуре security-ревью есть сильный перекос: парсинг опасен, а сериализация это бухгалтерия. Декодеры принимают враждебные байты, поэтому их фаззят, аудируют и переписывают на языках с безопасной памятью. Энкодеры производят вывод, а вывод кажется безопасным. Это убеждение ошибочно вполне конкретным, повторяемым образом: баги энкодеров живут в вычислении размера вывода, и этой арифметике доверяют обе стороны вызова.
Паттерн повторяется. В самой ветке PR отмечено, что CVE-2026-121481 напоминает CVE-2021-23840, более раннее переполнение в OpenSSL в функциях EVP update, где вычисление длины переполнялось на огромных входах. А в base64 это особенно заметно: когда декодер base64 из OpenJDK превратил 65 байт в удалённое выполнение кода, мы рассказывали о том, как «тривиальный» кодек стал примитивом RCE. Декодеры получают CVE за приём плохих данных, энкодеры за неверный расчёт корректных данных. Это один и тот же вид проблем: арифметика над длинами, на которые может влиять атакующий.
Вердикт: миф разрушен. Если твоя модель угроз заканчивается на парсере, ты оставил чёрный ход открытым, охраняя парадный.
Миф 2: «CVSS 9.8 означает бросить всё и сегодня же»
Здесь я немного встану на сторону скептиков. Оценка 9.8 для энкодера, которому нужен вход в 1,6 ГБ, это не Heartbleed. Нигде в TLS-рукопожатии нет base64-кодирования больших объёмов данных: сертификаты передаются как DER внутри TLS, а не как PEM. Чтобы это навредило тебе, недоверенные данные должны попасть в EVP_EncodeBlock() (или во внутренний вызов вроде base64encode() в HTTP-клиенте OpenSSL) в объёме больше 1,6 ГБ. Поле протокола с 16-битным префиксом длины туда никогда не доберётся.
Но назвать это «синтетикой» тоже было бы неверно. Автор репорта продемонстрировал реальный путь через командную строку: передать огромное значение -proxy_pass в openssl s_client, подав его через переменную окружения, чтобы обойти лимиты аргументов шелла. Определённые конфигурации (движки GOST, например, принимают слишком длинные пароли по умолчанию) послушно закодируют его в base64 для запроса CONNECT к прокси. Это не лабораторная диковинка, а стандартный инструмент, выполняющий стандартную аутентификацию на прокси через стандартную переменную окружения.
Моя позиция: рассматривай CVSS как меру функции, а граф вызовов как меру твоей реальной подверженности. Прежде чем планировать экстренное окно для патча, поищи в своём коде и зависимостях, кто и что на самом деле кодирует и насколько большим может быть вход. Потом всё равно накатывай патч, просто в правильном порядке. Вердикт: наполовину правда. Оценка реальна, но паника должна быть пропорциональна достижимости, а достижимость это вопрос, на который может ответить только твой код.
Миф 3: «Исправление простое, просто вернуть код ошибки»
Это моя любимая часть всей истории, потому что переполнение было самым простым элементом. Сложным было решить, что EVP_EncodeBlock() должна делать в такой ситуации, и мейнтейнеры не смогли договориться.
Первоначальный патч возвращал -1 для некорректных входов, как в слое совместимости wolfSSL и существующих путях ошибок в EVP_DecodeBlock(). Возражения появились сразу. Один мейнтейнер опасался, что сторонние вызывающие приводят возвращаемое значение к size_t без проверки, и тогда -1 становится SIZE_MAX, что, пожалуй, хуже переполнения, которое предотвращает патч. Может, вернуть 0? Но 0 уже законный успех: кодирование нуля байт возвращает ноль. Как сказал один мейнтейнер, его уже однажды обожгли, когда он поднял ошибку в успешном случае. Тогда используйте OPENSSL_assert(), предложил другой: падать при нарушении контракта и документировать предусловие. На это старший мейнтейнер ответил без обиняков: assert внутри библиотеки это «DoS, который только и ждёт случая».
Каждый вариант был плох, и каждый по своей причине: -1 ломает беззнаковые приведения, 0 совпадает с успехом, assert превращает логическую ошибку в падение, которым может управлять атакующий. Так бывает, когда семантика ошибок API никогда не проектировалась, а только унаследовалась. Это разрыв между спецификацией и реализацией в чистом виде: документация говорила «возвращает количество закодированных байт», и никто никогда не записывал, что происходит, когда кодирование невозможно.
Ещё две детали из обсуждения заслуживают внимания. Во-первых, ревьюер заметил, что исходный патч безусловно отвергал f == NULL, но кодирование пустого буфера с NULL-указателем на вход и dlen == 0 всегда работало, и реальные приложения на этом полагались. Даже «очевидно правильная» валидация сломала легитимный граничный случай. Во-вторых, ревьюер нашёл вызовы, которые не проверяют возвращаемое значение, и обнаружил их внутри самого OpenSSL: PEM_SignFinal() и NETSCAPE_SPKI_b64_encode(). Сделать функцию новой «способной к ошибке» бесполезно, если её вызывающие писались тогда, когда она не могла падать. Вердикт: миф разрушен полностью. Семантика ошибок это часть дизайна API, а её переделка операция на живом организме, а не патч.

Миф 4: «Никто не скормит гигабайт base64-кодировщику»
Интуиция такая: base64 нужен для мелочей, сертификатов, ключей, коротких токенов. И в основном это правда. Но современные системы незаметно обросли огромными блобами, которые постоянно кодируются: аттестационные документы, ответы SAML, манифесты образов контейнеров, учётные данные для прокси, полезные нагрузки вебхуков, которые какое-то промежуточное устройство решает перекодировать. Воспроизведение этой CVE не было экзотикой: это был пароль, переданный через переменную окружения, по пути кода, который кодирует учётные данные для HTTP-прокси. Ничто в этом конвейере не проектировалось с учётом потолка в 1,6 ГБ, потому что никто нигде этот потолок не записал.
Есть ещё архитектурная привычка, которая делает ситуацию хуже: однократные API кодирования подталкивают к тому, чтобы считать весь payload в память перед преобразованием. У OpenSSL есть потоковые альтернативы, EVP_EncodeInit(), EVP_EncodeUpdate(), EVP_EncodeFinal(), которые обрабатывают данные кусками и обходят проблему «вычислить общий размер вывода заранее». Потоковость стоит объекта контекста и цикла. Зато никакая отдельная длина уже не должна быть одновременно и подконтрольной атакующему, и доверенной. Вердикт: миф разрушен. Входы растут, пока не упрутся в лимит, а если лимит это переполнение знакового целого, лимит найдёт тебя.
Миф 5: «Наши фаззеры бы это поймали»
Не поймали бы, и стоит понять почему. Фаззеры с покрытием вроде libFuzzer по умолчанию ограничивают длину входа килобайтами: 4096 байт из коробки. Баг, для которого нужен входной объём в 1,6 миллиарда байт, не просто маловероятно найти, он полностью вне пространства поиска. Можно фаззить EVP_EncodeBlock() целый век и ни разу не задеть переполнение, потому что интересное поведение существует только в масштабе, который фаззер никогда не посетит.
Решение не в том, чтобы делать фаззинговые входы больше: никто не хочет выделять 1,6 ГБ на каждую итерацию фаззинга. Решение в том, чтобы тестировать арифметику отдельно от кодирования. Вынеси вычисление размера и основательно проверь его границы простыми юнит-тестами:
#include <assert.h>
#include <limits.h>
/* Mirrors the upstream guard, computed in a wide type. */
static int encoded_len_fits_int(long long dlen)
{
return dlen >= 0 && dlen <= ((long long)INT_MAX / 4) * 3;
}
int main(void)
{
long long limit = ((long long)INT_MAX / 4) * 3; /* 1,610,612,733 */
assert(encoded_len_fits_int(0));
assert(encoded_len_fits_int(limit));
assert(!encoded_len_fits_int(limit + 1));
assert(!encoded_len_fits_int(-1));
/* The encoded size at the limit must itself fit in an int. */
assert(4 * ((limit + 2) / 3) <= INT_MAX);
return 0;
}
Затем добавь дифференциальную проверку на умеренных размерах: вычисли ожидаемую длину вывода своей формулой на стороне вызова, закодируй и проверь, что функция записала ровно столько байт и ни одним больше. Прогоняй всё под AddressSanitizer в CI с входами в несколько сотен мегабайт: достаточно большими, чтобы задействовать широкие циклы, и достаточно маленькими, чтобы успеть до обеда. Фаззинг по-прежнему правильный инструмент для побайтовой логики кодека; он просто никогда не был правильным инструментом для переполнения целых на больших масштабах, и путаница этих двух задач причина, по которой такие баги переживают десятилетие непрерывного фаззинга. Вердикт: миф разрушен.
Как аудировать API энкодера, пока он не проаудировал тебя
Проверяешь ли ты использование OpenSSL в собственном коде или оцениваешь путь кодирования любой библиотеки, одни и те же несколько вопросов ловят весь этот класс багов:
- Кто вычисляет размер вывода? Если это делает вызывающая сторона нетривиальной формулой, обе стороны могут разойтись. Предпочитай API, которые принимают ёмкость вывода как параметр и чисто падают, когда её недостаточно.
- Каким целочисленным типом передаются длины? Параметр длины типа
intэто потолок в 2 ГБ со знаковым битом в придачу.size_tне делает переполнение невозможным, но выносит потолок за пределы любого буфера, который ты реально можешь выделить на 64-битной машине. - Что происходит при нуле, на границе и на единицу за ней? Пустой вход, ровно
(INT_MAX/4)*3и это значение плюс один: вот три тестовых случая, которые важны. - Не стала ли функция недавно способной к ошибке? Если патч добавил коды ошибок к тому, что раньше не могло падать, проверь каждый вызов. Непроверенные возвраты превращают исправленный баг в тихий.
- Есть ли потоковый вариант? Чанковые API encode/update/final убирают необходимость в какой-либо отдельной доверенной общей длине.
По первому пункту скажу сильнее: любой API, который заставляет вызывающую сторону воспроизводить внутреннюю формулу размера библиотеки, это фабрика багов, и индустрии пора перестать их строить. Вызываемая сторона знает коэффициент расширения, правила дополнения и соглашение о терминаторе. Заставлять каждого вызывающего заново выводить 4 * ((n + 2) / 3) + 1 значит гарантировать, что кто-то где-то ошибётся, или ошибётся правильно, но в слишком маленьком типе.

Выводы для Base64 и не только
CVE-2026-121481 исчезнет из лент новостей через неделю, но класс багов никуда не денется. Функции кодирования сидят в слепой зоне security-ревью: им доверяют длины, их освобождают от фаззинга в больших масштабах и оборачивают API, чья семантика ошибок никогда не была специфицирована. Мейнтейнеры OpenSSL потратили больше слов на спор о том, возвращать -1, 0 или падать, чем на само переполнение, и были правы, ведь именно эта часть будет годами жить с каждым нижестоящим вызывающим.
Итак: патчить да, но ещё и grep. Найди свои точки вызова кодирования, проверь, кто вычисляет размер буфера, убедись, что возвраты действительно проверяются, и перенеси всё, что обрабатывает недоверенные большие данные, на потоковый API. Следующий 9.8 в энкодере уже сидит в чьей-то формуле размера и ждёт входа достаточного размера, чтобы себя обнаружить.


