Фундаментальные основы хакерства. Практикуемся в поиске циклов при реверсе - «Новости» » Самоучитель CSS
Меню
Наши новости
Учебник CSS

Невозможно отучить людей изучать самые ненужные предметы.

Введение в CSS
Преимущества стилей
Добавления стилей
Типы носителей
Базовый синтаксис
Значения стилевых свойств
Селекторы тегов
Классы
CSS3

Надо знать обо всем понемножку, но все о немногом.

Идентификаторы
Контекстные селекторы
Соседние селекторы
Дочерние селекторы
Селекторы атрибутов
Универсальный селектор
Псевдоклассы
Псевдоэлементы

Кто умеет, тот делает. Кто не умеет, тот учит. Кто не умеет учить - становится деканом. (Т. Мартин)

Группирование
Наследование
Каскадирование
Валидация
Идентификаторы и классы
Написание эффективного кода

Самоучитель CSS

Вёрстка
Изображения
Текст
Цвет
Линии и рамки
Углы
Списки
Ссылки
Дизайны сайтов
Формы
Таблицы
CSS3
HTML5

Новости

Блог для вебмастеров
Новости мира Интернет
Сайтостроение
Ремонт и советы
Все новости

Справочник CSS

Справочник от А до Я
HTML, CSS, JavaScript

Афоризмы

Афоризмы о учёбе
Статьи об афоризмах
Все Афоризмы

Видео Уроки


Видео уроки
Популярные статьи
Наш опрос



Наши новости


РЕКЛАМА


ВАША РЕКЛАМА
ДОБАВИТЬ БАННЕР


9-07-2022, 00:02
Фундаментальные основы хакерства. Практикуемся в поиске циклов при реверсе - «Новости»
Рейтинг:
Категория: Новости

прош­лой стать­ей, где мы рас­смот­рели теорию устрой­ства раз­ных видов цик­лов на язы­ках высоко­го уров­ня и их отра­жение в дизас­сем­блер­ных лис­тингах. А сей­час нас­тало вре­мя прак­тики!

Фундаментальные основы хакерства


Пят­надцать лет назад эпи­чес­кий труд Кри­са Кас­пер­ски «Фун­дамен­таль­ные осно­вы хакерс­тва» был нас­толь­ной кни­гой каж­дого начина­юще­го иссле­дова­теля в области компь­ютер­ной безопас­ности. Одна­ко вре­мя идет, и зна­ния, опуб­ликован­ные Кри­сом, теря­ют акту­аль­ность. Редак­торы «Хакера» попыта­лись обно­вить этот объ­емный труд и перенес­ти его из вре­мен Windows 2000 и Visual Studio 6.0 во вре­мена Windows 10 и Visual Studio 2019.


Ссыл­ки на дру­гие статьи из это­го цик­ла ищи на стра­нице авто­ра.



 

Циклы while/do


 

Visual C++ 2022 с отключенной оптимизацией


Для зак­репле­ния прой­ден­ного в прош­лой статье матери­ала рас­смот­рим нес­коль­ко живых при­меров. Нач­нем с самого прос­того — иден­тифика­ции цик­лов while/do:


int main(){
int a = 0;
while (a++ < 10)printf("Оператор цикла whilen");
do {printf("Оператор цикла don");
} while (--a 0);}

От­компи­лиру­ем этот код с помощью Visual C++ 2022 с отклю­чен­ной опти­миза­цией.


Ре­зуль­тат выпол­нения при­мера while-do

Ре­зуль­тат ком­пиляции дол­жен выг­лядеть при­мер­но так:


; int __cdecl main(int argc, const char **argv, const char **envp)
mainproc near; CODE XREF: __scrt_common_main_seh+107↓p
; DATA XREF: .pdаta:0000000140004018↓o
var_18= dword ptr -18h
var_14= dword ptr -14h
; резервируем память для двух локальных переменных,
; только откуда взялась вторая?
sub rsp, 38h
; заносим в переменную var_18 значение 0
; следовательно, это переменная "a"
mov [rsp+38h+var_18], 0

Ни­же сле­дует перек­рес­тная ссыл­ка - loc_1400010EC, нап­равлен­ная вниз. Это говорит нам о том, что перед нами начало цик­ла. Пос­коль­ку перек­рес­тная ссыл­ка нап­равле­на вниз, то переход, ссы­лающий­ся на этот адрес, будет нап­равлен вверх!


loc_1400010EC:; CODE XREF: main+31↓j
; Загружаем в EAX значение переменной "a" (var_18)
mov eax, [rsp+38h+var_18]
; Загружаем в var_14 значение переменной "a", вот, мы нашли,
; где используется вторая переменная
mov [rsp+38h+var_14], eax
; Зачем-то снова загружаем то же значение в регистр EAX
mov eax, [rsp+38h+var_18]
; Увеличение значения в регистре EAX на 1
inc eax
; Загружаем значение из регистра EAX в переменную var_18 ("a")
mov [rsp+38h+var_18], eax
; Сравниваем старое (до обновления) значение переменной "a",
; ранее сохраненное в var_14, с числом 0xA
cmp [rsp+38h+var_14], 0Ah

Ес­ли (var_14 >= 0xA), дела­ем пры­жок «впе­ред», непос­редс­твен­но за инс­трук­цию безус­ловно­го перехо­да, нап­равлен­ного «назад». Если выпол­няет­ся пры­жок «назад», зна­чит это цикл, а пос­коль­ку усло­вие выхода из цик­ла про­веря­ется в его начале, то это цикл с пре­дус­лови­ем.


Для его отоб­ражения на цикл while необ­ходимо инверти­ровать усло­вие выхода из цик­ла на усло­вие про­дол­жения цик­ла, дру­гими сло­вами, заменить >= на <.


Сде­лав это, мы получа­ем: while (a++ < 0xA)....


; Начало тела цикла:; заносим ссылку на строку "Оператор цикла whilen"lea
rcx, _Format
; _Format; выводим на консольcall
printf; безусловный переход, направленный назад, на метку loc_1400010EC - в начало цикла,; в область подготовки переменных для проверкиjmp
short loc_1400010EC

Меж­ду loc_1400010EC и jmp short loc_1400010E есть толь­ко одно усло­вие выхода из цик­ла: jge short loc_140001113. Зна­чит, исходный код цик­ла выг­лядел так:


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


loc_140001113:; CODE XREF: main+23↑j
; main+4E↓j

Ага, никако­го усло­вия в начале цик­ла не при­сутс­тву­ет, зна­чит, это цикл с усло­вием в кон­це или в середи­не.


lea
rcx, byte_140002278 ; _Format; печатаем в консолиcall
printf; тело цикла; загружаем в EAX значение переменной var_18 ("a")mov
eax, [rsp+38h+var_18]; уменьшаем значение в EAX на 1dec
eax; возвращаем значение из EAX в переменную "a" - var_18mov
[rsp+38h+var_18], eax; сравниваем переменную "a" с нулемcmp
[rsp+38h+var_18], 0; Если (a 0), делаем переход в начало циклаjgshort loc_140001113

Пос­коль­ку усло­вие рас­положе­но в кон­це цик­ла, это цикл do:


while (--a 0);
; возвращаем 0
xor eax, eax
; восстанавливаем стек
add rsp, 38h
retn
mainendp
 

Visual C++ 2022 с включенной оптимизацией


Сов­сем дру­гой резуль­тат получит­ся, если вклю­чить опти­миза­цию. Откомпи­лиру­ем тот же самый при­мер с клю­чом /O2 (мак­сималь­ная опти­миза­ция: при­ори­тет ско­рос­ти) и пос­мотрим на резуль­тат, выдан­ный ком­пилято­ром:


mainproc near; CODE XREF: __scrt_common_main_seh+107↓p; DATA XREF: .pdаta:000000014000400C↓o; сохраняем регистр в стекеpush
rbx; подготавливаем стек, ни одной локальной переменной не объявленоsub
rsp, 20h; в EBX кладем число 0xA. Для чего, пока не ясно.mov
ebx, 0Ahnop
dword ptr [rax+rax+00h]; Судя по следующей перекрестной ссылке, направленной вниз, это цикл!loc_140001080:; CODE XREF: main+20↓j; заносим в регистр RCX ссылку на строку "Оператор цикла whilen"lea
rcx, _Format
; _Format; выводим строку на терминалcall
printf; Если это тело цикла, то где же предусловие?!; Вычитаем из RBX число 1.sub
rbx, 1; Получается, что число 0xA, помещенное в EBX ранее, являлось начальным значением

Инс­трук­ция SUB подоб­но CMP изме­няет сос­тояние фла­га нуля. Если в резуль­тате вычита­ния получа­ется 0, флаг нуля воз­водит­ся в еди­ницу. Сле­дующая инс­трук­ция совер­шает пры­жок назад, ког­да флаг не воз­веден, то есть в резуль­тате вычита­ния регистр RBX не стал равен нулю.


jnz short loc_140001080

Ком­пилятор в порыве опти­миза­ции прев­ратил неэф­фектив­ный цикл с пре­дус­лови­ем в более ком­пак­тный и быс­трый цикл с пос­тусло­вием. Имел ли он на это пра­во? А почему нет?! Про­ана­лизи­ровав код, ком­пилятор понял, что этот цикл выпол­няет­ся, по край­ней мере, один раз. Сле­дова­тель­но, скор­ректи­ровав усло­вие про­дол­жения, его про­вер­ку мож­но вынес­ти в конец цик­ла.


Так­же в исходном тек­сте был инкре­мент счет­чика цик­ла от нуля до 0xA, а в под­готов­ленном тран­сля­тором коде мы видим обратный эффект: дек­ремент счет­чика от 0xA до нуля. Таким обра­зом, ком­пилятор заменил: while ((int a=0)+1) < 10) printf(...) на do printf(...) while ((int a=10)-1) > 0).


При­чем, что инте­рес­но, он не срав­нивал перемен­ную цик­ла с кон­стан­той, а помес­тил кон­стан­ту в регистр и умень­шал его до тех пор, пока тот не стал равен нулю! Зачем? А затем, что так короче, да и работа­ет быс­трее.


Хо­рошо, но как нам деком­пилиро­вать этот цикл? Непос­редс­твен­ное отоб­ражение на язык C/C++ дает сле­дующую инс­трук­цию:


do {
printf("Оператор цикла whilen");
var_RBX--;} while (var_RBX 0);

Впол­не кра­сивый и опти­маль­ный цикл с одной перемен­ной.


; Этот код выполняется после завершения предыдущего цикла.mov
ebx, 0Bhnop
word ptr [rax+rax+00000000h]; Перекрестная ссылка, направленная вниз, говорит нам о том, что это начало циклаloc_1400010A0:; CODE XREF: main+40↓j; Предусловия нет, значит, это цикл do; заносим в регистр RCX ссылку на строку "Оператор цикла don"lea
rcx, byte_140002278 ; _Format; выводим строку на терминалcall
printf; уменьшаем значение, загруженное в EBX, на единицуdec
ebx; проверяем EBX на равенство нулюtest
ebx, ebx; Продолжаем выполнение цикла, пока EBX 0jgshort loc_1400010A0

Этот цикл пря­миком отоб­ража­ется в конс­трук­цию язы­ка C/C++:


do { printf("Оператор цикла don"); }while (--var_EBX 0);
; возвращаем ноль
xor eax, eax
; восстанавливаем стек
add rsp, 20h
; восстанавливаем регистр
pop rbx
retn
mainendp
 

C++ Builder 10 без оптимизации


Нес­коль­ко ина­че обра­баты­вает цик­лы ком­пилятор Embarcadero C++ Builder 10.4. Смот­ри при­мер while-do_cb:


public mainmainproc near; DATA XREF: __acrtused+29↑o; объявляем шесть переменныхvar_1C= dword ptr -1Chvar_18= dword ptr -18hvar_14= dword ptr -14hvar_10= qword ptr -10hvar_8= dword ptr -8var_4= dword ptr -4; сохраняем в стеке RBPpush
rbp; резервируем память для локальных переменныхsub
rsp, 40h; помещаем в RBP указатель на дно стекаlea
rbp, [rsp+40h]; инициализируем переменные:; в var_4 записывает 0, вероятно это переменная a из исходного кодаmov
[rbp+var_4], 0mov
[rbp+var_8], ecxmov
[rbp+var_10], rdx; еще одна переменная, изначально равная нулю, возьмем на заметкуmov
[rbp+var_14], 0; Ниже перекрестная ссылка, направленная вниз, значит, это начало какого-то циклаloc_40141F:; CODE XREF: main+3E↓j; в начале цикла условие не обнаружено, видимо, цикл с постусловием,; хотя не будем спешить с выводами; в регистр EAX копируем значение из переменной var_14mov
eax, [rbp+var_14]; копирование EAX в ECXmov
ecx, eax; увеличиваем значение в регистре ECX на 1add
ecx, 1; увеличенное значение из регистра ECX копируем в переменную var_14,; из которой берется значение для счетчика в начале итерацииmov
[rbp+var_14], ecx; сравнение не увеличенного значения с 0хАcmp
eax, 0Ah; если это значение больше или равно константе,; тогда выполняем прыжок за пределы цикла в область старших адресовjge
short loc_401440; в случае продолжения выполнения помещаем ссылку на строку в регистр; и выводим ее на консольlea
rcx, aOperatorIklaWh ; "Оператор цикла whilen"call
printf; зачем-то сохраняем текущее значение регистра EAX в переменной var_18...mov
[rbp+var_18], eax; ... и выполняем безусловный переход в начало циклаjmp
short loc_40141F

Вот так‑то C++ Builder опти­мизи­ровал код! Началь­ный цикл с пре­дус­лови­ем выпол­нения он прев­ратил в бес­конеч­ный цикл с усло­вием выхода посере­дине (за под­робнос­тями обра­тись к прош­лой статье)! Как мы можем деком­пилиро­вать этот цикл? Нап­рашива­ется такой вари­ант:



do {
int var_EAX = var_14;
int var_ECX = var_EAX;
var_ECX++;
var_14 = var_ECX;
if (var_EAX = 0xA) break;
printf("Оператор цикла whilen");} while (TRUE);

Этот вари­ант кар­диналь­но отли­чает­ся от пер­воначаль­ного, и я очень сом­нева­юсь, что в луч­шую сто­рону! Что ж, издер­жки про­изводс­тва...


loc_401440:; CODE XREF: main+2D↑j; сюда происходит переход при выходе из предыдущего цикла; как мы знаем, эта инструкция только переводит управление через себяjmp
short $+2; --------------------------------loc_401442:; CODE XREF: main:loc_401440↑j; main+5D↓j; Новый цикл!; Как видим, он начинается с вывода строки, нет условия, значит цикл с постусловием.lea
rcx, aOperatorIklaDo ; "Оператор цикла don"call
printf

Про­маты­ваем дизас­сем­блер­ный лис­тинг вверх, что­бы вспом­нить, какое зна­чение находит­ся в регис­тре EAX. Зна­чит, в этом мес­те прог­раммы зна­чение в регис­тре EAX рав­но 0хА. Записы­ваем это зна­чение в перемен­ную var_1C (непонят­но для каких целей, ведь в будущем она не исполь­зует­ся). Выходит, локаль­ную перемен­ную a исходной прог­раммы пред­став­ляет регис­тро­вая перемен­ная EAX.


mov [rbp+var_1C], eax
; Записываем в регистр EAX значение переменной var_14.
; А в ней содержится значение на 1 больше, чем в EAX! То есть, 0xB.
mov eax, [rbp+var_14]
; Какой хитрый C++ Builder!
; Вместо реального вычитания он прибавляет к значению в EAX -1
add eax, 0FFFFFFFFh
; Присваивает результат переменной var_14
mov [rbp+var_14], eax
; И сравнивает уменьшенное значение с нулем
cmp eax, 0
; Если (EAX > 0), то мы прыгаем назад к началу "нового цикла"
; и осуществлению очередной итерации
jgshort loc_401442

Во что C++ Builder прев­ратил изна­чаль­ный цикл с пос­тусло­вием? В целом, никаких изме­нений он не внес, оста­вив все на сво­их мес­тах. И деком­пилиро­ван­ный лис­тинг это­го цик­ла дол­жен выг­лядеть при­мер­но так:


do{
int var_EAX = var_14;
var_EAX--;
var_14 = var_EAX;
printf("Оператор цикла whilen");} while (var_EAX 0);
; В ином случае, когда (EAX <= 0), пропускаем переход
; и продолжаем выполнение кода программы
mov [rbp+var_4], 0
; Возвращаем ноль
mov eax, [rbp+var_4]
; Восстанавливаем стек
add rsp, 40h
; Восстанавливаем регистр
pop rbp
retn
mainendp

Теги: CSS

Просмотров: 83
Комментариев: 0:   9-07-2022, 00:02
Уважаемый посетитель, Вы зашли на сайт как незарегистрированный пользователь. Мы рекомендуем Вам зарегистрироваться либо войти на сайт под своим именем.

 
Еще новости по теме:



Другие новости по теме:
Комментарии для сайта Cackle