3.3 Теория атак переполнения стека

Особенности реализации языка C допускают возможность вмешательства в работу стека программы в случае, когда размеры передаваемого в стек массива и выделенной автоматически под него в стеке памяти не соответствуют друг другу. Результат работы программ, использующих эти особенности - передача управления участку кода с произвольным адресом внутри адресного пространства процесса.
Вступление:
В настоящее время использование ошибок связанных с переполнением буфера является одной из наиболее прогрессивных технологий проникновения в защищенные системы.В данной статье проводится наиболее развернутое исследование атак срыва стека. Это частный, наиболее распространенный случай, использования ошибок переполнения буфера. Начнем с некоторых базовых понятий: буфер - участок памяти, содержащий последовательно расположенные однотипные данные. Программисты С, как правило, ассоциируют с буфером массив. Массивы, как и все переменные в С, могут быть динамическими или статическими. Статические переменные во время загрузки программы располагаются в сегменте данных, динамические - в стеке. Мы будем рассматривать переполнение только динамических буферов.

Организация процессов в памяти

Чтобы понять, что такое буферы в стеке необходимо сначала представлять себе, как происходит организация процессов в памяти. Адресное пространства процесса можно разделить на 3 сегмента: сегмент кода(Text), сегмент данных(Data) и сегмент стека(Stack).Мы будем рассматривать в основном сегмент стека, но для начала сделаем небольшой обзор остальных сегментов. Сегмент кода является неизменной частью программы и содержит непосредственно инструкции машинного кода. Этот сегмент, как правило, доступен только для чтения, и попытка записи в его адресное пространство вызывает segmentation violation.

Сегмент данных содержит проинициализированные и не проинициализированные данные. Здесь хранятся статические переменные.Размер этого сегмента может быть изменен с помощью системного вызова brk(). Если размер пользовательских данных(data-bss) или стека, определенного пользователем, по мере работы процесса превышает объем первоначально выделенной процессу памяти, то он блокируется и возобновляет свою работу в новом пространстве, для которого ОС выделяет дополнительную память. Она распределяется между сегментами данных и стека.

Таб.4 Структура памяти процесса

исполнимый код

нижние адреса памяти

(проинициализированные)Данные(непроинициализированные)

Стек

верхние адреса памяти

Что такое стек?

Стек - это абстрактный тип данных, с определенными свойствами. Последний помещенный в стек объект извлекается из него первым. Такая схема называется LIFO (last in first out - последний вошел, первый вышел). Над данными в стеке определены операции Push и Pop.Push помещает элемент данных в вершину стека. Pop, наоборот, уменьшает размер стека на единицу, удаляя последний элемент из его вершины.

Для чего применяется стек?

В современных языках высокого уровня используется принцип структурного программирования - вся программа разбивается на процедуры и/или функции. С одной точки зрения вызов функции изменяет ход выполнения программы подобно оператору goto, но отличается от него тем, что, закончив свою работу, функция возвращает управление участку кода, расположенному сразу после своего вызова.Стек позволяет сделать прозрачным для разработчика особенности реализации вызова функций.Это дает новый уровень абстракции программирования.Стек применяется для динамического размещения локальных переменных в функциях, передачи параметров в функцию и получения результатов ее работы.

Сегмент стека

Регистр SP (stack pointer - указатель стека) указывает на вершину стека, адрес которой меняется. Основание стека - фиксированный адрес памяти.Размер стека динамически контролируется ядром.Операции push и pop непосредственно реализованы в процессоре.Стек логически подразделяется на фреймы, которые состоят из параметров, передающихся в функцию, локальных переменных функции и данных, необходимых для возврата в основную функцию. В зависимости от реализации, стек может расти либо вверх, либо вниз ( используя адреса памяти в сторону уменьшения ).В наших примерах будет подразумеваться, что стек растет вниз.Этот вариант используется в процессорах Intel, Motorola, SPARC и MIPS.На что указывает SP, также зависит от реализации.Это может быть либо на последний элемент стека либо на следующий свободный адрес.Мы будем использовать первый вариант.

Итак,SP будет указывать на вершину стека (наименьшее значение из адресов памяти, используемых под стек).Часто удобно иметь указатель на какой-либо адрес внутри фрейма(FP frаme pointer).Некоторые источники называют его LB(local base ponter). Вообще, абсолютный адрес в стеке локальных переменных может быть получен с помощью смещения относительно SP. Однако по мере записи и чтения из стека эти смещения изменяются. Несмотря на то, что компилятор следит за количеством данных в стеке и соответственно корректирует эти смещения, бывают ситуации, когда это становится невозможным, и требуется дополнительное вмешательство. К тому же для некоторых процессоров (например ,Intel) , доступ к переменной с известным смещением требует нескольких операций.

Поэтому многие компиляторы используют второй регистр ,FP, для ссылки на локальные переменные и параметры, так как их смещение относительно FP не изменяется по мере использования операций push и pop.В процессорах Intel для этой цели используется регистр BP( EBP ), в Motorola - для этого можно использовать любой адресный регистр,кроме А7.Поскольку в нашем случае стек растет вниз, то смещения для доступа к параметрам будут положительными,а для локальных переменных относительно FP отрицательными. Первое, что должна сделать функция, после своего вызова - сохранить предыдущее значение FP, иначе оно не сможет быть восстановлено после того, как она отработает. Затем происходит копирование SP в FP с целью создания нового FP и уменьшается значение SP для резервирования места под локальные переменные функции.Этот алгоритм называет входом в процедуру.После завершения работы функции стек должен иметь первоначальный вид.Рассмотрим, как он выглядит на простом примере:

код, в который была транслирована функция function(). Чтобы разобраться в том, что программа делает при вызове function(), мы скомпилируем ее gcc c опцией -S ,которая дает на выходе ассемблерный код.

Здесь три аргумента сначала заносятся в стек, затем происходит вызов функции (call), который также записывает значение IP(instruction pointer)в стек.Это значение мы будем называть адресом возврата(RET).Первое, что делает вызванная функция - реализует описанный алгоритм входа:

Здесь происходит запись EBP в стек, копирование SP в EBP (создается новый FP, который мы назовем SFP).Затем уменьшением значения SP, резервируется место под локальные переменные. Мы должны помнить, что память в стеке адресуется словами (в нашем случае слово - 32 бита), т.е. чтение и запись происходит блоками по 4 байта.Поэтому буфер из 5 байт потребует 8 байт (два слова) памяти, из 10 байт - соответственно 12 байт (три слова).Вот почему из SP вычитается 20.С учетом всего этого, стек при вызове function() выглядит следующим образом (каждый пробел обозначает байт):

верхушка стека основание стека

Переполнение буфера.

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

В этой программе присутствует типичная ошибка переполнения буфера. В функции происходит копирование переданную ей строку без проверки ее размера (используется strcpy() вместо strncpy()).В результате мы получаем segmentation violation. Давайте посмотрим на стек:

Что здесь происходит? Почему мы получаем segmentation violation? Объясняется все просто: strcpy() копирует содержимое *str(larger_string[]) в буфер buffer[], пока не встретится null byte (\'\0\').Размер buffer[] меньше, чем *str(16 байт против 256).Это значит, что 250 байт памяти ,идущие за буфером и не имеющих никакого к нему отношения, будут перезаписаны.В их число войдут SFP, RET и даже *str. Мы заполнили large_string символами \'А\'(шестнадцатеричное значение 0х41).Это значит, что адрес возврата теперь 0x41414141.Это значение выходит за пределы адресного пространства процесса.Вот почему, когда происходит возврат из функции ,то попытка выполнить очередную инструкцию по этому адресу приводит к segmentation violation.

Таким вот образом переполнение буфера позволяет изменить адрес возврата из функции и становится возможным изменить ход выполнения программы. Давайте попытаемся изменить нашу первую программу таким образом , чтобы она перезаписывала адрес возврата.Перед buffer1[] в стеке находится SFP , перед ним RET, т.е. он находится на расстоянии 4 байт от buffer1[].Мы изменим значение RET так, чтобы в результате присваивание "х=1;" было пропущено.Для этого прибавим к RET 8 байт:

Все что мы сделали - прибавили 12 к адресу массива buffer1[].Полученный новый адрес - адрес возврата(RET). Нам надо пропустить присваивание, чтобы по выходу из функции выполнение программы продолжилось с printf.Разъясним, как мы узнали, что этого необходимо прибавить к значению RET именно 8 байт? Для этого скомпилируем программу и запустим gdb:

Мы видим, что при вызове функции function() RET получает значение 0x8004a8.Мы хотим пропустить присваивание и передать управление сразу на адрес 0x8004b2.Разность этих значений дает 8 байт.
Шелкод

Теперь зная технологию получения нужного значения RET, какой свой код исполнить? В большинстве случаев это будет запуск shell, который позволит далее выполнять любые команды. Но что, если такого кода нет в программе, которую мы хотим заэксплойтить? Каким образом можно поместить произвольный код в ее адресное пространство? Необходимо записать его в буфер, подвергаемый переполнению и перезаписать RET таким образом, чтобы он указывал назад, на какой-то адрес в буфере.В предположении, что начало стека имеет адрес 0xFF , S - произвольный код, который мы хотим исполнить, стек выглядит так:

Чтобы узнать, как он выглядит на ассемблере, мы скомпилируем его и используем gdb. Обратите внимание, что gdb надо запускать с флагом -static ,иначе код, исполняющийся в результате системного вызова execve, не будет показан. На его месте будет ссылка на динамическую библиотеку С, подсоединяющуюся во время загрузки программы на выполнение.

Разберемся, как это работает. Начнем рассмотрение с main:

Это начало процедуры.Сначало сохраняется старое значение FP, текущее значение SP становится новым значением FP и резервируется место под локальные переменные.Теперь ими будут 2 указателя на char:

Теперь execve(). Напоминаю, что примеры рассчитаны на использование ОС Linux под процессоры Intel.Особенности системного вызова меняются от одной ОС к другой и от одного процессора к другому.Некоторые ОС передают аргументы через стек, другие через регистры.Одни используют для системных вызовов программные прерывания, другие - дальние переходы (far call).Linux передает аргументы системному вызову через регистры и использует программные прерывания для его вызова.

Таким образом, мы видим, что размер кода для вызова execve() не велик. Вот все что необходимо сделать:

a) расположить где-нибудь в адресном пространстве процесса строку "/bin/sh" ,за которой идет null b) расположить где-нибудь в адресном пространстве процесса адрес строки "/bin/sh" ,за которой идет long word null c) скопировать 0xb в регистр EAX d) скопировать адрес адреса строки "/bin/sh" в регистр EBX e) скопировать адрес строки "/bin/sh" регистр ECX f) скопировать адрес null long word в регистр EDX g) вызвать прерывание int $0x80

Но что, если вызов execve() по каким-либо причинам не сработает? В этом случае программа продолжит выбирать из стека инструкции, содержащие произвольные данные, что вызовет core dump.Мы хотим, чтобы программа завершалась корректно,даже если вызов execve() будет неудачным. Для этого надо добавить системный вызов exit после execve.Выглядит он так:

Системный вызов exit запишет в регистр EAX значение 0x1, поместит код возврата в EBX и вызовет прерывание "int 0x80". Большинство приложений, при нормальном завершении, на выходе возвращают 0. Мы поместим значение 0 в регистр EBX. Соответственно окончательный алгоритм:

a) расположить где-нибудь в адресном пространстве процесса строку "/bin/sh" ,за которой идет ull b) расположить где-нибуть в адресном пространстве процесса адрес строки "/bin/sh" ,за кторй идет long word null c) скопировать 0xb в регистр EAX d) скопировать адрес адреса строки "/bin/sh" в регистр EBX e) скопировать адрес строки "/bin/sh" регистр ECX f) скопировать адрес null long word в регистр EDX g) вызвать прерывание int $0x80 h) записать 0x1 в регистр EAX i) записать 0x0 в регистр EBX j) вызвать прерывание int $0x80

Переведем это в ассемблерный код, в его конец поместим строку /bin/sh , запомним, что на ее место потом встанет ее адрес и далее - null word.

Проблема в том, что неизвестно, в какое место адресного пространства процесса мы должны поместить наш код. Один из способов решения - использование команд JMP и СALL, для которых допускается относительная адресация, т.е можно передать управление, используя смещение от текущего значения IP, следовательно, нет необходимости знать абсолютный адрес перехода. Если мы поместим команду CALL перед строкой "/bin/sh" и затем команду JMP на нее, то когда выполнится CALL, адрес строки будет помешен в стек на место адреса возврата. Команда CALL может просто передать управление нашему коду.Пусть, J обозначает JMP, C соответственно CALL , s - cтроку. Схема шелкода теперь будет выглядеть следующим образом:

Учитывая изменения, схематично обозначая адресацию, указывая, сколько байт занимает каждая инструкция, получаем:

Вычисление смещений от jmp до call, от call до popl, от адреса строки до массива и от адреса строки до null long word дают следующее:

Результат выглядит неплохо. Чтобы убедиться в его работоспособности, необходимо скомпилировать программу и исполнить