От Shell-код - последователност от машинни инструкции, с което вече се изпълнява програмата може да бъде принуден да прави нещо алтернатива. С този метод е възможно да се използват някои софтуер уязвимост (например, стека преливник, преливане куп уязвимост линии на срязване).
Един пример може да изглежда като черупка-код:
Това е, най-общо казано, е последователност от байтове в машинен език. Целта на този документ - да се разгледа най-разпространената развитието техники черупка-код за Linux и BSD * система работи на архитектурата x86.
Копаене в мрежата, можете лесно да намерите готови примери за обвивка-код, който могат да бъдат копирани и поставени на правилното място само. За какво да учи неговото развитие? За моя вкус, има поне няколко основателни причини:
- На второ място, следва да се има предвид, че черупката-кодът може да работи в напълно различни среди, като входно-изходни филтри части на низове, IDS, и е полезно да си представите как тя трябва да бъде променен в съответствие с условията,
- Нещо повече, идеята за използване на уязвимости ще ви помогне да напишете по-сигурен код.
Обява 1. Системни повиквания, определени в /usr/src/linux/include/asm-i386/unistd.h файл; оборудвани със собствен номер
Linux системни функции
Въпреки че черупка-кода, по принцип може да изпълнява всичко, но основната цел на старт му е да се кача на достъпа на целевата машина с черупка (черупка), за предпочитане в привилегирована режим, където, всъщност, дала името на черупка-код.
Най-простият и най-простият начин да изпълнява трудна задача на асемблер е използването на системни функции. Системни разговори предоставят интерфейса между потребителското пространство и ядрото пространство; с други думи, това е начин да се получи поддръжката на потребителските настройки на основните услуги. Например, има управление на файловата система са започнали, нови процеси, осигурява достъп до устройства, и така нататък.
Както е показано на Обява 1, призивите на системата, определени в /usr/src/linux/include/asmi386/unistd.h файл, като всеки от тях разполага с редица.
Има две общи начини за използване на системата за разговори:
- активация на софтуера прекъсват 0x80;
- извикване на функция обвивка от библшотеката.
Първият метод е по-поносим, тъй като консумира Линукс дистрибуция (определено код на ядрото). Вторият метод се понася по-малко, както е определено чрез кода на стандартната библиотека.
вътр 0x80
Погледнете внимателно в първия метод. Когато процесорът получава прекъсване 0x80, той е включен в режим на ядрото и изпълнява желаната функция за осигуряване на желаното манипулатор от прекъсвания дескриптори на маса (прекъсване ЕВРОВОК таблицата). брой система разговор трябва да се определя в EAX, което в крайна сметка ще съдържа стойността на замяна. На свой ред, аргументите на номера на функцията за шест, за да се съдържат в EBX, ECX, EDX, ESI, EDI, а ЕВР, в този ред, а само правото размер на регистрите и не всички. Ако функцията изисква повече от шест аргументи, трябва да ги пуснат в структурата и спаси указател към първия елемент в EBX.
Трябва да се помни, че ядрото Linux 2.4 ЕВР регистър не се използва, за да премине аргументи, и следователно може да предава само пет аргументи в регистрите.
След като запазите номера на система за повикване и параметрите в съответните регистри, за прекъсване 0x80: процесора влиза в режим на ядрото изпълнява система повикване и предава управлението на процеса на употреба. За да играете на този сценарий се нуждаете:
- запишете номера на система за повикване в EAX;
- да запази аргументите на система за обаждания в съответните регистри;
- създадат структура с памет, съдържаща система кол параметри А;
- съхраняват в EBX указател към първия аргумент;
- изпълнява софтуер прекъсване 0x80.
Най-простият пример ще съдържа класиката - излизане система повикване (2). ние знаем броя на /usr/src/linux/include/asm-i386/unistd.h файл: 1. ръководство страница ни казва, че само един задължителен аргумент (статус), както е показано на Обява 2.
Обява 2. човек наръчник страница показва, че е задължително да се един параметър
Ние ще го пазят в регистъра на EBX. По този начин, ние се нуждаем от следните указания:
библшотеката
Както бе посочено, друга стандартна техника е да се използва функция C. Нека да видим как това се прави с помощта на проста програма C:
Само трябва да го състави:
разглобявате с GDB, за да се уверете, че тя използва същата система за повикване (виж Обява 3).
Обява 3. Демонтирайте излизане на програмата с помощта на GDB дебъгер
Последната функция в главната () - е предизвикателство за изход (3). Освен това ние виждаме, че на изхода (3) от своя страна причинява _exit (2), който причинява система поканата, включително прекъсване 0x80, 4 Обява.
Обява 4. Изпълнение на поканата система
По този начин, черупки-код чрез библшотеката косвено причинява _exit системата повикване (2):
Обява 5. /usr/src/sys/kern/syscalls.master файл В началото на OpenBSD
Първият ред съдържа броя на системни функции, а вторият - от вида, третият - функция прототип. За разлика от Linux, призивите на системата не се ползва * BSD съгласие по един бърз разговор с стаята на аргументи в регистрите вместо стил От поставянето на аргументите в стека. Аргументите са поставени в обратен ред, започвайки от правото, така че те ще бъдат изтеглени в правилната последователност. Веднага след завръщането си от стека системно повикване, трябва да се почиства с поставяне на отклонение на брой байтове стека указател, което е дължината на всички аргументи (или по-просто казано, чрез добавяне на броя байтове в аргумента, умножена по 4). Ролята на регистър EAX е същата, както в Linux, тя се състои от редица системно повикване, и резултатът съдържа стойността на замяна.
По този начин, за системата повикване изисква четири стъпки:
- обадете спестяване в EAX номер;
- стая в обратен ред от аргументите на комина;
- изпълнение на софтуер за прекъсване 0x80;
- почистване комин.
Пример за Linux, BSD превръща в *, тя ще изглежда така:
Писане черупка-код
Следващите примери са предназначени за Linux, тя може лесно да се адаптира към света на * BSD. За крайния черупка-кода, той остава да се получи опкодове съответните инструкции асемблер. Стандартно използва три метода за получаване на операционни кодове:
- написването им на ръка (с документите Intel в ръцете!);
- писането на асемблер код, последван от отстраняване на Кодът;
- писането на код C с последващото му разглобяване.
Нека сега разгледаме останалите два метода.
асемблер
Първата стъпка - използването на монтаж код от Пример exit.asm използване _exit система повикване (2). За използване операционни кодове NASM разглобява и след това се събират чрез двоичен objdump, както е показано на Обявата 6.
Обява 6. Кодът за сглобяване от текста, в събранието, следван от разглобяване
Обявата 7. Тестване на опкод
Надявам се, че устата ви се отвори достатъчно широк. За да се провери изпълнението на черупка-код, просто стартирате приложението под strace, Обява 8.
Списъка 8. приложения Трейс скрининг
Последният ред - обажда _exit (2). Въпреки това, гледайки черупка-код, ние виждаме един малък проблем: тя съдържа много нулеви байтове. Тъй като черупка-кодът често се вмести в низ буфер, тези байтове заравят в съответствие сплитер и атаката ще се провали. Има два начина за решаване на проблема:
- напишете инструкции, които не съдържат нулеви байтове (което не винаги е възможно);
- напиши черупка-код, за да бъде променен ръчно отстраняване нулеви байтове, а след това да тече време код се добавят нулеви байтове, подравняване на линия, за да сепаратора.
Радвайки се на първия метод.
Първата инструкция (Mov EBX, 0) могат да бъдат променяни по upotrebimo (от съображения за изпълнение):
Второто твърдение съдържа всички тези нули, защото използва регистър на 32-битова (EAX), той генерира 0x01, което превърна 0x01000000 (нибли са обърнати като Intel® - малко къс процесор). По този начин ние можем да решим този проблем, просто чрез използване на осем-битов регистър (AL):
Сега нашата монтаж код е както следва:
и всички нулеви байтове (виж Обява 9).
Обява 9. черупка-Проверка на кода
C
Next: извличане на опкодовете чрез разглобяване на компилирана програма на В. Обърнете двоичен получен от exit.c и да го отворите с помощта на GDB, 10 Обява.
Обявата 10. двоични exit.c, отворен с GDB
Както може да се види, _exit (2) функция всъщност използва две системни функции: 0xfc (252), _exit_group (2), и по-нататък, _exit (2). _exit_group (2) е подобна _exit (2), но неговата цел е приключване на всички предавания в групата. За нашия код наистина само втората система повикването.
Също така, както в предишния пример, ще трябва да преодолее нулеви байтове.
Първи конзола
Време е да се напише черупка-кода, който ще позволи да се направи нещо по-полезно. Например, ние може да създаде код, за да получат достъп до конзолата, и че след конзола поколение е чисто завършена. Най-простият подход тук - използването на execve система повикване (2). Не забравяйте да проверите на страницата на човек Обява 11.
Обява 2 11. мъж execve
Ние трябва да мине три аргумента си:
- указател към името на програмата, за да се изпълни, в този случай, указател към низ / хамбар / ш;
- указател към масив от низове, преминали като аргументи в програмата, първият аргумент трябва да бъде argv [0], че е името на програмата, последният аргумент трябва да бъде нулев указател;
- указател към масив от линии за предаване на своите програми, като на околната среда; тези линии обикновено са разположени в ключови = формат стойност и последния елемент на масива трябва да е нулев указател. С е подобна на следното:
Съберете и да видим как става това:
Е, добре, ние имаме една черупка. Сега нека видим как тази система повикване прилича на асемблер (както ние използвахме три аргумента, може да се използва вместо регистри структура). Веднага намерени два проблема:
Нека да видим какво прави:
От този момент можете да използвате черупка-код структура, пълна с нещо полезно. Нека да анализираме стъпка по стъпка, нашите планирани дейности:
Получената монтаж код е показана на Обявата 13.
Обява 13. преработен монтаж код
Екстрахират се опкодовете, Обява 14:
Свързани статии