книги хакеры / Защита_от_взлома_сокеты,_эксплойты,_shell_код_Фостер_Дж_

16/* небольшой блок, поместить в нужное место связанного списка */

17if (SIZE(tp) < MINSIZE) {

18ASSERT(SIZE(tp) / WORDSIZE >= 1);

19ts = SIZE(tp) / WORDSIZE – 1;

20AFTER(tp) = List(ts);

21List[ts] = tp;

22return;

23}

24

25/* можно ли объединить со следующим блоком? */

26np = NEXT(tp);

27if (!ISBIT0(SIZE(np))) {

28if (np != Bottom)

29t_delete(np);

30SIZE(tp) += SIZE(np) + WORDSIZE;

31}

32

33/* можно ли объединить с предыдущим блоком? */

34if (ISBIT0(ts)) {

35np = LAST(tp);

36ASSERT(!ISBIT0(SIZE(np)));

37ASSERT(np != Bottom);

38t_delete(np);

39SIZE(np) += SIZE(tp) + WORDSIZE;

40tp = np;

41}

42}

Анализ

В строке 26 realfree смотрит, можно ли объединить текущий свободный блок со следующим. В строке 27 проверяется, что установлен флаг незанятости блока и что данный блок не является последним в списке. Если оба условия выполнены, то блок удаляется из связанного списка. Затем размеры обоих блоков складываются, и блок снова добавляется в дерево.

При написании эксплойта для этой реализации нужно иметь в виду, что мы не можем манипулировать заголовком нашего собственного блока, а лишь заголовком блока справа от него (см. строки 26-30). Если мы пишем данные за границей выделенного блока и создаем «подложный» заголовок, то можем заставить программу выполнить функцию t_delete, а значит сумеем произвольно манипулировать указателями. В примере 11.6 приведен текст функции, с помощью которой можно получить контроль над уязвимым приложением в случае затирания кучи. Она эквивалентна макросу UNLINK в реализации dlmalloc.

6/* если это не узел дерева */

7if (ISNOTREE(op)) {

8tp = LINKBAK(op);

9if ((sp = LINKFOR(op)) != NULL)

10LINKBAK(sp) = tp;

11LINKFOR(tp) = sp;

12return;

13}

14}

Анализ

Функция t_delete манипулирует указателями для удаления блока из дерева. Сначала выполняются некоторые проверки, которые должен пройти сконструированный «подложный» блок. В строке 7 проверяется, что в поле t_l óçëà op находится -1. Поэтому, организуя переполнение, мы должны будем позаботиться о том, чтобы в этом поле для «подложного» блока была –1. Далее расшифруем макросы LINKFOR и LINKBAK:

#define LINKFOR(b) (((b)->t_n).w_p) #define LINKBAK(b) (((b)->t_p).w_n)

Ïîëå t_p «подложного» блока должно в результате переполнения содержать адрес, по которому будет находиться адрес возврата, – 4 * sizeof(WORD). А в поле t_n надо записать сам адрес возврата. Следовательно, после переполнения блок должен выглядеть, как показано на рис. 11.11.

Рис. 11.11. Подложный блок

6unsigned int i, length1, length2;

7 char *buf;

8

9// максимальное 32-разрядное беззнаковое целое равно 4294967295

10length1 = 0xffffffff;

11length2 = 0x1;

12

13// выделить память для хранения length1 + 1 байтов

14buf = (char *) malloc(length1 + length2);

15

16// напечатать длину и содержимое буфера в 16-ричном виде

17printf("length1: %x\tlength2: %x\ttotal: %x\tbuf: %s\n",

length1, length2, length1 + length2, buf);

18

19// писать в буфер "A", пока не будет заполнено length1 байтов

20for (i=0; i<length1; i++) buf[i] = 0x41;

21

22// в последнюю позицию буфера записать 0

23buf[i] = 0x0;

24

25// напечатать длину и содержимое буфера в 16-ричном виде

26printf("length1: %x\tlength2: %x\ttotal: %x\tbuf: %s\n",

length1, length2, length1 + length2, buf);

27

28return 0;

29}

Анализ

В строках 10 и 11 инициализируются две переменные length1 è length2.

В строке 14 они складываются для получения полной длины буфера, но до выделения для него памяти. Переменная length1 равна 0xffffffff, то есть максимальному 32-разрядному беззнаковому целому. Когда к length1 прибавляется 1, хранящаяся в length2, вычисленный в строке 14 размер буфера оказывается равен 0, так как 0xffffffff + 1 = 0x100000000, но это число не представимо 32 битами, поэтому старший бит отбрасывается и остается 0x00000000, то есть 0. Это и называется переполнением целого.

Таким образом, размер буфера buf равен 0. В строке 20 производится попытка заполнить буфер символами 0x41 (буква 'A'). При этом length2 не учитывается, так как в последний байт мы собираемся записать ноль.

В строке 23 в последний байт буфера записывается 0.

18

19// заполнить буфер символами "A"

20for (i=0; i<(length1*length2); i++) buf[i] = 0x41;

22// в последнюю позицию буфера записать 0

23buf[i] = 0x0;

24

25// напечатать длину и содержимое буфера в 16-ричном виде

26printf("length1: %x\tlength2: %x\ttotal: %x\tbuf: %s\n",

length1, length2, length1*length2 + 1, buf);

27

28return 0;

29}

Анализ

Две переменные (length1 è length2) перемножаются для вычисления размера буфера, и к результату прибавляется 1 (для нулевого байта). Максимально возможное 32-разрядное беззнаковое число равно 0xffffffff. В данном случае следует рассматривать значение length2 (5) как «зашитое» в код приложения. Чтобы размер буфера обратился в 0, значение length1 должно быть равно 0x33333333, так как 0x33333333 * 5 = 0xffffffff. После прибавления 1 мы в результате переполнения получаем 0, то есть выделяется память для буфера нулевой длины. Когда в строке 20 мы пытается писать в этот буфер, программа аварийно завершается. Эта ошибка переполнения при умножении очень похожа на ту, что была обнаружена в пакете OpenSSH.

Обход проверки размера

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

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

переполнения

1 #include <stdio.h>

2

3 int main(void)

4 {

5 unsigned int num;

6

7num = 0xffffffff;

10if (num > 512)

11{

12printf("Слишком большое число, выходим\n");

13return -1;

14} else {

15printf("Тест на длину пройден.\n");

16}

17

18return 0;

19}

Анализ

Можете считать, что значение переменной num в строке 7 поступило из внешнего источника. В строке 8 производится некая манипуляция с этой переменной, являющаяся частью алгоритма, а в строке 10 выполняется собственно проверка, то есть указанное число (плюс 1) сравнивается с 512. В данном случае число равно 4294967925. Ясно, что оно больше 512, но стоило добавить к нему 1, как оно обратилось в нуль, и проверка дала отрицательный результат.

Чтобы обойти проверку размера, вовсе необязательно устраивать переполнение целого, да и число не обязано быть беззнаковым. В реальных программах часто обходятся проверки, в которых участвуют целые числа со знаком. Один такой случай продемонстрирован в примере 11.10.

Пример 11.10. Обход проверки, в которой участвует число со знаком, без переполнения

1#include <stdio.h>

2#include <stdlib.h>

3 #include <string.h>

4

5 #define BUFSIZE 1024

6

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

8{