Переполнение буфера остаётся одним из самых старых и при этом самых живучих классов дефектов памяти в программах на C и C++. Компилятор не ловит каждый выход за границу массива, тесты не всегда добираются до редких веток, а объём унаследованного кода огромен. Поэтому индустрия выстроила эшелонированную оборону: механизмы не устраняют саму ошибку, но ломают её практическое применение. Ядро перемешивает раскладку адресного пространства, аппаратура запрещает исполнение страниц, не предназначенных для кода, компилятор вставляет контроль целостности стека, редактор связей закрывает таблицы перемещений. Ниже разбираются ASLR, DEP и NX бит, канарейки стека, PIE, RELRO и FORTIFY_SOURCE, а также утилиты, показывающие, какие из этих мер уже включены в конкретном бинарнике.

Механика переполнения буфера и цель защиты

Классическая картина разрушения стека описана десятилетия назад. Функция получает под локальный массив фиксированный участок кадра, копирует туда входные байты без сверки длины, и всё лишнее ложится поверх соседних ячеек. В непосредственной близости лежат сохранённый указатель кадра и адрес возврата, поэтому запись за границей массива способна подменить точку, в которую управление вернётся после выхода из функции. В куче дефекты того же рода портят внутренние структуры аллокатора, указатели на функции и поля объектов, участвующие в косвенных вызовах.

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

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

ASLR и параметр randomize_va_space в ядре

ASLR, Address Space Layout Randomization, перемешивает базовые адреса областей памяти при каждом запуске процесса. Случайными становятся положение стека, стартовые адреса разделяемых библиотек в области mmap, начало кучи, блок vDSO, а при сборке с PIE ещё и сам исполняемый образ. Программа продолжает работать как раньше, но адрес нужной функции или цепочки байтов меняется от запуска к запуску, и заранее подготовленные числовые значения перестают попадать в цель.

Степень рандомизации регулируется параметром kernel.randomize_va_space:

  1. 0 полностью отключает перемешивание, такой режим нужен для отладки и воспроизведения редких состояний;
  2. 1 включает консервативную схему, при которой случайными становятся стек, области mmap и vDSO;
  3. 2 добавляет к перечисленному начальное смещение кучи и используется по умолчанию в основных дистрибутивах.
cat /proc/sys/kernel/randomize_va_space
sudo sysctl -w kernel.randomize_va_space=2
setarch $(uname -m) -R ./app

Последняя команда запускает процесс с отключённой рандомизацией и пригождается при отладке, когда нужно стабильное содержимое памяти.

Запас энтропии зависит от разрядности. На x86-64 область mmap по умолчанию получает 28 бит случайности, стек около 30, и перебор вариантов на практике бессмыслен. На 32-битных системах тот же запас сжимается на порядок, поэтому переход на 64 бита сам по себе служит защитной мерой. Тонкая настройка доступна через параметры vm.mmap_rnd_bits и vm.mmap_rnd_compat_bits, которые уменьшают, если среда исполнения с JIT-компиляцией плохо переносит слишком широкий разброс адресов.

Рандомизация обновляется при каждом запуске образа, поэтому долгоживущий сервис, плодящий обработчики через fork, раздаёт всем потомкам одну и ту же раскладку, и перебор против него заметно упрощается. Средство против этого известное: перезапуск воркеров по таймеру или после фиксированного числа соединений, как делают крупные веб-серверы. Похожие механизмы работают и за пределами Linux: Windows перемешивает образ, кучу и стек по своим правилам, OpenBSD исторически агрессивнее всех, macOS рандомизирует даже ядро.

Слабое место ASLR в утечке информации. Один раскрытый указатель из нужной области снимает случайность со всей области, поэтому каналы раскрытия адресов, от форматных строк до побочных эффектов /proc, рассматриваются как самостоятельные уязвимости и закрываются параметрами ядра вроде kernel.kptr_restrict. Отсюда рабочее правило: ASLR применяется в связке с остальными слоями, а не вместо них.

DEP, NX бит и запрет исполнения стека

Второй слой опирается на аппаратный бит NX в таблицах страниц. Страница, помеченная этим битом, не исполняется, даже если управление на неё передано. На 32-битной архитектуре x86 бит стал доступен вместе с расширением PAE, на 64 битах он присутствует изначально. В терминах Microsoft тот же механизм носит имя DEP, Data Execution Prevention, а политика W^X в OpenBSD требует, чтобы страница была либо исполняемой, либо записываемой, но не одновременно. Дополнили картину проекты вроде PaX, которые ещё до массового появления аппаратной поддержки добивались неисполнимости страниц программными средствами и попутно ввели в обиход сам термин ASLR.

Ядро Linux включает запрет автоматически. Сегмент GNU_STACK в заголовке ELF задаёт права стека, и при отсутствии флага исполняемости стек работает только на чтение и запись, а куча и области содержимого по умолчанию не исполняемы. Проблемными остаются бинарники, собранные с явным запросом исполняемого стека, например из-за вложенных функций или старых ассемблерных вставок; загрузчик предупреждает о таком флаге, и сборку стоит чинить, а не заглушать предупреждение.

readelf -lW ./app | grep GNU_STACK
# RW  - stack is not executable, protection is active
# RWE - executable stack, fix the build

Запрет исполнения перечеркнул трюк с размещением байтов кода прямо в стеке, но не закрыл класс целиком: вместо внедрения собственного кода нарушитель начал переиспользовать фрагменты уже имеющихся библиотек, выстраивая цепочки коротких участков машинных команд. Ответом стали механизмы контроля потока управления: теневой стек Intel CET, включаемый флагом -fcf-protection, и похожие схемы в других архитектурах. Для сервисов дополнительным барьером служат фильтры seccomp, отсекающие вызов mprotect и не дающие сделать страницу исполняемой на ходу.

Stack canary и встроенные проверки компилятора

Канарейка стека, известная как Stack Smashing Protector, это секретное значение, которое компилятор кладёт в кадр между локальными буферами и служебными полями: сохранённым указателем кадра и адресом возврата. Перед выходом из функции сверяется канарейка с эталоном, и при расхождении процесс завершается через __stack_chk_fail, не передав управление подменённому адресу. Значение генерируется заново для каждого процесса из случайных байтов ядра, передаваемых через вспомогательный вектор AT_RANDOM, поэтому утечка канарейки в одном процессе не помогает в другом.

В GCC защита включается флагами -fstack-protector, -fstack-protector-strong и -fstack-protector-all с растущим охватом: от функций с массивами заметного размера до всех кадров подряд. Практичным компромиссом служит вариант strong, защищающий функции с локальными массивами, структурами, содержащими массивы, и адресами локальных переменных. Именно он много лет служит базовым в сборках Debian, Ubuntu и Fedora.

gcc -fstack-protector-strong -O2 app.c -o app
nm app | grep stack_chk_fail

У метода есть границы. Канарейка замечает линейное затирание, но не увидит порчу соседних локальных переменных, лежащих ближе к началу кадра, не защищает поля структур в куче и бессильна, если секретное значение утекло вместе с остальным содержимым стека. Дополняют её флаги вроде -ftrivial-auto-var-init=zero, обнуляющие неинициализированные переменные и устраняющие целый класс неопределённого поведения. В Windows аналогичная идея встроена в компилятор через ключ /GS. Логичное дополнение к канарейке это -fstack-clash-protection: контрольные записи в каждую страницу растущего стека не дают перепрыгнуть через защитную страницу и закрывают трюк с гигантским выделением на стеке.

PIE и сборка кода без фиксированных адресов

ASLR бессилен для главного образа программы, если тот собран без позиционной независимости: обычный исполняемый файл всегда загружается по одному и тому же базовому адресу, например 0x400000 на x86-64, и раскладка его функций известна заранее. Сборка с флагами -fPIE и -pie превращает исполняемый файл в позиционно независимый, его тип ELF меняется с EXEC на DYN, и ядро получает возможность выбирать базу случайным образом при каждом запуске.

gcc -fPIE -pie -o app app.c
readelf -h app | grep Type   # DYN for PIE, EXEC for fixed layout

Цена невелика. На x86-64 это редкие дополнительные косвенные обращения через GOT и PLT, на 32-битной x86 защита когда-то съедала один регистр и отпугивала, но давно перестала быть аргументом. Почти все дистрибутивы собирают пакеты с PIE по умолчанию, а для закрытых и встраиваемых сборок это первый пункт чек-листа. Дальнейшее развитие идеи называется static-PIE: самодостаточный исполняемый файл без динамического загрузчика, который сохраняет случайную базу.

Практический нюанс в том, что PIE без рандомизации на стороне ядра ничего не даёт, а рандомизация без PIE защищает лишь библиотеки и стек. Половины обязаны работать в паре, и самый частый пропуск в самосборных бинарниках это именно забытые флаги -fPIE и -pie.

RELRO, FORTIFY_SOURCE и дополнительные флаги сборки

Таблица глобальных смещений GOT хранит адреса внешних функций и по умолчанию остаётся записываемой на всё время жизни процесса: при отложенном связывании адрес дописывается при первом вызове. Записываемая таблица превращается в лакомую цель после утечки хотя бы одного адреса. Частичный RELRO помечает часть секций доступной только для чтения сразу после загрузки, полный, включаемый ключами -Wl,-z,relro,-z,now, разрешает все перемещения на старте и закрывает GOT от записи, оплачивая это чуть более долгим запуском.

FORTIFY_SOURCE работает иначе. Компилятор знает размер буфера-приёмника, а glibc предоставляет проверенные варианты функций с суффиксом _chk, в которые размер передаётся явно. Копирование, sprintf, snprintf и прочие операции получают контроль границ, и при заведомо невозможной записи программа аварийно завершается вместо тихой порчи памяти. Флаг требует оптимизации, поэтому пишется как -D_FORTIFY_SOURCE=2 вместе с -O2, а новые версии GCC и glibc добавили уровень 3 с более широким анализом. Современные архитектуры добавляют к перечисленному аппаратные метки ветвления: ARM предлагает BTI и PAC, ограничивающие косвенные переходы и подделку адресов возврата, а свежие версии GCC и clang включают их своими флагами сборки.

gcc -O2 -fstack-protector-strong -D_FORTIFY_SOURCE=2 -fPIE -pie \
    -Wl,-z,relro,-z,now -Wl,-z,noexecstack app.c -o app

К этой строке стоит добавить -Werror=format-security против форматных строк с записью через %n. Полный набор флагов не заменяет исправление исходного кода, но превращает целый пласт дефектов из тихих в громкие, а громкие дефекты находят тесты и фаззинг.

Аудит защиты утилитой checksec и настройка дистрибутива

Проверить собранный бинарник проще всего утилитой checksec, которая одной строкой показывает состояние всех перечисленных механизмов.

checksec --file=app
RELRO           STACK CANARY    NX          PIE         FORTIFY
Full RELRO      Canary found    NX enabled  PIE enabled Yes

Дистрибутивные сборки получают флаги автоматически: Debian и Ubuntu раздают их через dpkg-buildflags, Fedora через собственные макросы сборки, Gentoo держит отдельные hardened профили. Собственные проекты разумно подключать к тем же профилям, чтобы набор флагов не зависел от памяти разработчика. Удобно встроить такую проверку в непрерывную интеграцию: сборка падает, если свежий бинарник потерял хоть один флаг. Дополнением служит скрипт hardening-check из состава Debian-инструментария, прогоняющий те же проверки по готовым пакетам.

Вторая половина аудита относится к работающей системе и закрытию каналов утечки адресов:

sysctl -w kernel.kptr_restrict=2
sysctl -w kernel.dmesg_restrict=1
sysctl -w vm.mmap_min_addr=65536

Параметр kptr_restrict прячет адреса ядра из /proc и интерфейсов отладки, dmesg_restrict закрывает буфер журнала от непривилегированных пользователей, mmap_min_addr запрещает отображать страницы на нулевой адрес и отсекает известный приём с подменой нулевого указателя.

Ни один из перечисленных механизмов не делает программу безопасной сам по себе. ASLR сдувается от одной утечки указателя, канарейка не видит порчу соседних переменных, запрет исполнения не мешает цепочкам из легитимного кода. Ценность эшелона в сумме: каждая мера требует от нарушителя отдельного дефекта в системе или отдельной ошибки в конфигурации, и вместе они переводят переполнение буфера из категории надёжного инструмента в категорию дорогой и ненадёжной экзотики. Отдельная линия развития это безопасные языки: Rust и современный C++ проверяют владение буфером ещё на этапе компиляции, но их доля в существующем парке кода пока невелика, поэтому классические механизмы защиты будут востребованы ещё долго. Картину дополняют санитайзеры AddressSanitizer и UndefinedBehaviorSanitizer на этапе разработки, фаззинг и перспективные аппаратные механизмы контроля потока управления, от теневых стеков до разметки памяти в архитектуре ARM.