# Глава 8

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

## Инструкции циклов

Для реализации циклов можно использовать инструкции, рассмотренные ранее. Например, можно назначить счётчиком какой-либо регистр общего назначения (обычно для этой цели используется ECX), проинициализировать его числом, равным количеству повторов, при каждом прохождении тела цикла уменьшать счётчик на 1, в конце цикла проверять счётчик на равенство нулю и выполнять условный переход в случае неравенства. Вот как это может выглядеть в коде:

```
MOV ECX, 15h
```

Инициализируем счётчик повторов значением 15h. Далее следует сам цикл:

```
метка_начала_цикла:
DEC ECX
```

Счётчик уменьшается на 1 при каждом повторе.

Далее следуют произвольные инструкции, которые мы пытаемся зациклить - это тело цикла.

В конце нужно добавить проверку на равенство нулю или любому другому условию завершения цикла:

```
CMP ECX, 0
JNE метка_начала_цикла
```

При первой проверке на равенство нулю, в счётчике будет значение 14h, ведь мы уже успели 1 раз выполнить DEC ECX. Т.к. 14h не равно 0, цикл повторится снова и снова, пока значение счётчика не достигнет значения 0.

Давайте перепишем наш цикл в более компактной форме с целью оптимизации по размеру:

```
XOR ECX,ECX
ADD ECX,15h
метка_начала_цикла:
DEC ECX
;тело цикла
TEST ECX,ECX
JNE метка_начала_цикл
```

Можно придумать ещё более компактные версии циклов, но пока ограничимся последней. Давайте впишем этот код в OllyDbg:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTve8_BFnM47ZM_kC%2F1.png?generation=1566513552485838\&alt=media)

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

Давайте потрассируем код цикла, чтобы воочию убедиться в его функциональности. Нажимаем на F7 - видим как обнуляется счётчик ECX.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTveL_WgAeaEenPIH%2F2.png?generation=1566513553767211\&alt=media)

Ещё раз F7 - прибавляем к счётчику 15h, чем и задаём желаемое количество повторов.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTveX2F-EIQkxExrQ%2F3.png?generation=1566513554169124\&alt=media)

Далее нажимаем на F7 пока не выполнится инструкция DEC ECX, которая сократит значение нашего счётчика до 14h.

Продолжаем трассировать до инструкции TEST ECX, ECX. Что делает эта инструкция в данном случае? - Правильно, проверяет значение счётчика на предмет равенства нулю.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTveiPUlI8wCk6cyJ%2F4.png?generation=1566513554513731\&alt=media)

Т.к. счётчик ещё не равен нулю, флаг Z не устанавливается и, следовательно, выполняется условный переход JNZ - он передаёт управление на адрес 401007. Далее счётчик снова уменьшается - на этот раз до 13h. Продолжаем трассировать пока он не достигнет значения 0.

При нулевом значении счётчика, сравнение на ноль устанавливает флаг Z. Поэтому JNZ более не выполняется.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTveqz2XjBP7xcCER%2F5.png?generation=1566513556848875\&alt=media)

Помните, раньше мы использовали инструкцию JZ, которая осуществляла переход при установленном флаге Z? JNZ работает с точностью до наоборот - переход осуществляется при сброшенном флаге Z.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvf1sFMA08fnTJZ9%2F6.png?generation=1566513553330110\&alt=media)

Видите серую стрелочку? - это значит, что переход не будет осуществлён. Повторное нажатие на F7 выводит нас из цикла.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvfCH2dAjqg19E_d%2F7.png?generation=1566513627877002\&alt=media)

Мы рассмотрели простейший пример цикла с использованием уже знакомых нам инструкций. Существуют ещё и специальные инструкции для реализации циклов. Давайте рассмотрим и их.

### LOOP

Инструкция LOOP берёт на себя уменьшение значения счётчика ECX, проверку на равенство нулю и переход по заданному адресу - всё в одном флаконе. (К сожалению, на большинстве современных процессоров данная инструкция отличается более низкой скоростью, чем аналог с DEC и JNZ - прим. пер.)

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvfQs1N-1GygxcKj%2F8.png?generation=1566513553649501\&alt=media)

Подсвечиваем инструкцию DEC ECX - осуществляем правый клик мышью - Binary - Fill with NOPs. Аналогично поступаем с инструкциями TEST ECX,ECX и JNZ 401007. Все 3 инструкции можно заменить одной - LOOP 401007.

Подсвечиваем первую строчку (401000) - осуществляем правый клик мышью - New origin here. Теперь мы готовы опробовать наш новый цикл, использующий инструкцию LOOP.

Нажимаем F7 - снова видим как счётчик ECX сначала инициализируется значением 0, потом ему присваивается значение 15h. Продолжаем трассировать пока не достигнем инструкцию LOOP.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvfa7Cs6kx_FXKsV%2F9.png?generation=1566513554156964\&alt=media)

Также как и раньше, осуществляется переход на адрес 401007, т.к. счётчик ещё не равен нулю. Замечаем, что счётчик уменьшился на 1 - теперь в ECX хранится значение 14h.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvfoWtfGbUHPwNr1%2F10.png?generation=1566513551127774\&alt=media)

Продолжаем трассировать. Когда счётчик, наконец, достигает нуля, цикл более не будет повторяться.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvfyZEBAnXon0OA3%2F11.png?generation=1566513551416508\&alt=media)

Существуют некоторые вариации инструкции LOOP:

* LOOPZ, LOOPE Цикл повторяется пока флаг Z установлен
* LOOPNZ, LOOPNE Цикл повторяется пока флаг Z сброшен

Обе вариации работают как обычный LOOP, т.е. повторяют тело цикла пока счётчик не достигнет нуля, уменьшая на 1 значение счётчика при каждом повторе. В добавок, LOOPZ и LOOPNZ ещё проверяют значение флага Z и прерывают цикл если Z сброшен или установлен соответственно. Таким образом, цикл можно прервать досрочно (до того как ECX достигнет нуля), используя флаг Z.

Обратите внимание на поведение цикла в том случае, если счётчик изначально равен нулю. - прим. пер.

## Цепочечные инструкции

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

### MOVS

Данная инструкция копирует данные из одного адреса в другой. Адрес источника хранится в регистре ESI, адрес приёмника - в EDI. Инструкция не нуждается в явном указании параметров, но OllyDbg дизассемблирует её как `MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI]` для наглядности. Вот как это выглядит:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvg7kCneZkXieefD%2F12.png?generation=1566513557172492\&alt=media)

Предварительно инициализируем ESI адресом ячейки, содержимое которой нужно скопировать (источник), и EDI - адресом ячейки, в которую нужно осуществить копирование (проёмник).

Давайте посмотрим содержимое обоих ячеек в окне дампа непосредственно перед копированием.

В окне дампа можно задать Go to - Expression = 40366C. Есть более простой способ: Follow in dump - Immediate constant, как показано ниже:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvgHSXBuk1u6eqZo%2F13.png?generation=1566513553474022\&alt=media)

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvgOAETKTgBfPR8B%2F14.png?generation=1566513551992665\&alt=media)

В дампе выделено содержимое ячейки, адрес которой указан в источнике (ESI).

А теперь посмотрим куда указывает EDI:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvgXUuCTWlAFb_ym%2F15.png?generation=1566513559304731\&alt=media)

Это приёмник - сюда будет скопировано содержимое ячейки-источника.

Нажимаем F7 пока не выполнится MOVS - в приёмнике теперь находятся те самые 4 байта.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvggTyptyWGvLsi5%2F16.png?generation=1566513553506746\&alt=media)

MOVS копирует 4x-байтные значения, т.е. DWORD, из-за чего этой инструкции соответствует ещё одна мнемоника - MOVSD. Существуют ещё инструкции MOVSW и MOVSB, копирующие 2 байта (WORD) и 1 байт (BYTE) соответственно.

Обратите внимание как изменяются значения ESI и EDI при копировании, в зависимости от флага D - прим. пер.

### REP

Это префикс, который можно использовать перед некоторыми инструкциями, в частности MOVS. Данный префикс указывает, что текущую инструкцию нужно выполнить ECX количество раз. Фактически счётчик ECX уменьшается при каждом повторе, как и в обычном цикле. Таким образом, REP MOVS копирует уже не строго 4 байта, а массив размером 4 \* ECX байт, ведь каждый раз указатели ESI и EDI сами увеличиваются на 4 (или уменьшаются, в зависимости от флага D - прим. пер). Полезная фишка, не так ли?

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

Давайте немного подправим наш предыдущий пример: добавим префикс REP и проинициализируем ECX.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvgsdle0W6__SV7Q%2F17.png?generation=1566513554537755\&alt=media)

Адрес источника теперь будет 40365C (всего лишь для наглядности), а приёмника - тот же, что и раньше, т.е. 40369C. Возвращаемся к первой строчке кода дежурным New origin here и трассируем до REP MOVS.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvh3XD5vXDXwq85r%2F18.png?generation=1566513552578837\&alt=media)

Обратите внимание на подсказку в OllyDbg - там отображаются адреса источника и приёмника, содержимое начальных ячеек и другая полезная информация. Нажимаем F7.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvhEhzPQbePeW_c2%2F19.png?generation=1566513554182656\&alt=media)

Как видите, первые 4 байта были успешно скопированы, но мы всё ещё находимся на REP, ведь цикл должен выполняться пока ECX не достигнет нуля. На данном этапе в ECX уже хранится значение 3, а указатели ESI и EDI уже увеличились на 4, указывая таким образом на следующие 4 байта, которые будут скопированы как только мы снова нажмём F7.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvhTSyC43NsJxto4%2F20.png?generation=1566513553739662\&alt=media)

Нажимаем F7.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvhhJbN4-lpcF98A%2F21.png?generation=1566513555172475\&alt=media)

Вот и следующие 4 байта были удачно перемещены и счётчик ECX уже равен 2.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvhr3y-Z7NRGjxH7%2F22.png?generation=1566513554474888\&alt=media)

Ещё раз F7 - ECX равен 1.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvi1eBskb1Bo5D07%2F23.png?generation=1566513558573179\&alt=media)

И ещё раз.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTviCO40wn55hQLIo%2F24.png?generation=1566513557326200\&alt=media)

Всё, цикл завершился, т.к. счётчик достиг нуля.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTviMhVcTPgP3p5JO%2F25.png?generation=1566513554085156\&alt=media)

Подведём итог: инструкция MOVS выполнилась 4 раза, благодаря префиксу REP, тем самым переместив цепочку из 16 байт из одного массива в другой.

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

Кроме REP есть ещё 2 производных префикса REPE/REPZ и REPNE/REPNZ, которые позволяют прервать цикл досрочно по флагу Z. Т.к. MOVS никак не влияет на флаг Z, использовать REPE/REPZ или REPNE/REPNZ совместно с MOVS не имеет особого смысла, но есть и другие инструкции, которые также поддерживают префиксы повторения и, в добавок, влияют на флаги. Например, CMPS и SCAS являются таковыми. Одну из них мы рассмотрим чуть позже.

### LODS

Данная инструкция загружает (от англ. LOAD) данные из источника (куда, как обычно, указывает ESI) в аккумулятор.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTviXYN7he4RB7tWN%2F26.png?generation=1566513555055793\&alt=media)

OllyDbg в своём репертуаре: дизассемблирует `LODS как LODS DWORD PTR DS:[ESI]`.

Если кому-то лень посмотреть на значение ESI на панели регистров, OllyDbg заботливо дублирует его в окне подсказок.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvik6CcWdJThaHNh%2F27.png?generation=1566513550229839\&alt=media)

Что у нас в дампе?

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTviw2xxGGQkWsYSr%2F28.png?generation=1566513552666698\&alt=media)

Эти 4 байта будут загружены в аккумулятор (EAX). Нажимаем F7.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvj7_Qh0DTDlxItD%2F29.png?generation=1566513553678747\&alt=media)

Свершилось! EAX действительно содержит те самые 4 байта.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvjNZDXzOuaWoch8%2F30.png?generation=1566513554144793\&alt=media)

Префикс REP можно применить и перед инструкцией LODS для автоповтора, пока счётчик ECX не достигнет нуля.

При выполнении цикла REP LODS, в окне подсказки оказываются текущие значения ECX, ESI и содержимое ячеек памяти, которые будут загружены в аккумулятор при следующем повторе.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvjdASI6p60B6xLk%2F31.png?generation=1566513553924150\&alt=media)

Нажимаем F7.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvjsVCMQu-iVgYhE%2F32.png?generation=1566513552605512\&alt=media)

ECX теперь имеет значение 3 и адрес в ESI увеличился на 4 - теперь он указывает на следующие 4 байта, которые будут загружены в EAX.

Есть ещё инструкции LODSW и LODSB для загрузки 2-байтовых (WORD) и 1-байтных (BYTE) значений соответственно.

### STOS

Сохраняет (от англ. STORE) значение аккумулятора по адресу приёмника EDI.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvk4MT49AkQ4jQIq%2F33.png?generation=1566513553586395\&alt=media)

При трассировании данного примера, когда очередь доходит до инструкции STOS, в окне подсказки появляется текущее значение аккумулятора и адрес, по которому будет сохранено это значение.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvkIo9XBUiOCk7Tl%2F34.png?generation=1566513552709002\&alt=media)

Вот результат в дампе:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvkUY7h7Ki7v_wwO%2F35.png?generation=1566513557807494\&alt=media)

Также как и в предыдущем случае, можно использовать префикс REP для автоповторения и существуют 2-байтовая и 1-байтная версии: STOSW и STOSB.

### CMPS

Осуществляет сравнение ячеек, указанных в источнике (ESI) и приёмнике (EDI).

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvkd1CM-hn_80g6M%2F36.png?generation=1566513553007256\&alt=media)

OllyDbg дизассемблирует данную инструкцию как CMPS DWORD PTR DS:\[ESI],DWORD PTR ES:\[EDI].

В окне подсказки отображаются значения, подлежащие сравнению:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvkp3T6lVo980dG6%2F37.png?generation=1566513557762389\&alt=media)

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

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvl0hqXyGjYIKlCI%2F38.png?generation=1566513555270398\&alt=media)

Т.к. операция сравнения влияет на состояние флага Z, можно использовать префикс REPE или REPZ для цепочечного сравнения до тех пор пока не истощится счётчик ECX или флаг Z не окажется сброшен.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvlCOzF3DZxssMfx%2F39.png?generation=1566513595443473\&alt=media)

От предыдущих примеров по адресам 40365C и 40369C осталось то, что видим в дампе.

Инициализируем ECX = 10h. При использовании префикса REPE, цикл прервётся когда ECX станет равен нулю или же по состоянию флага Z - любое из этих условий приведёт к завершению цикла.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvlQ_eLHoVAPAS0m%2F40.png?generation=1566513554278973\&alt=media)

Трассируем до строчки с REPE. Значения в обоих ячейках оказываются равны, что приводит к установке флага Z.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvlgkXa0dVjc44QA%2F41.png?generation=1566513553923405\&alt=media)

Установленный флаг Z сигнализирует REPE, что пока не нужно прерывать цикл. Нажимаем F7.

Продолжаем нажимать F7 до тех пор, пока операнды не окажутся разными. В данном случае это должно произойти до того как истощится счётчик ECX. Ага, вот:

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvlxcWgbX0I_3CwN%2F42.png?generation=1566513555826683\&alt=media)

Последующее нажатие на F7 сбрасывает флаг Z и цикл прерывается.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvmFGj5EMbiA89-5%2F43.png?generation=1566513567410677\&alt=media)

Если бы все 16 двойных слов оказались равными в обоих цепочках, цикл завершился бы по условию ECX = 0, а не раньше.

Ранее упоминался префикс REPNZ, который тоже применим к CMPS и позволяет прервать цикл досрочно, но условие в этом случае противоположно только что рассмотренному REPE/REPZ.

Мы уже изучили основную массу наиболее полезных инструкций, за исключением, пожалуй, только инструкций FPU (для операций над дробными числами), которые мы рассмотрим позже. Не лишним будет повторить пройденный материал, если у Вас остались какие-то пробелы.

## СПОСОБЫ АДРЕСАЦИИ

### Прямая адресация

Это самый простой способ - адрес явно указывается в одном из операндов инструкции. Например:

```
MOV dword ptr [00513450], ecx
MOV ax, word ptr [00510A25]
MOV al, byte ptr [00402811]
CALL 452200
JMP 421000
```

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

### Косвенная адресация

```
MOV dword ptr [eax], ecx
CALL EAX
JMP [ebx + 4]
```

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

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

Чтобы было нагляднее, давайте снова воспользуемся крэкми Cruehead'а [\[ссылка\]](https://github.com/yutewiyof/intro-cracking-with-ollydbg/tree/3679d233f4d394747f712e9b6b09bc9c2a3cad80/.gitbook/assets/files/1/ollydbg01-Crackme.7z). Загружаем его в отладчик.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvmZtixvMCQE51TN%2F44.png?generation=1566513553806993\&alt=media)

Подмечаем пример косвенной адресации: `PUSH [ebp+8]`

Т.к. мы всё ещё находимся на точке входа (Entry Point), мы не можем заранее узнать значение регистра EBP к моменту выполнения того самого PUSH'а. Поэтому, нам не известно пока ещё что именно попадёт в стек. Давайте выделим данный PUSH (он находится по адресу 401009) и нажмём F2, чтобы повесить на него точку останова (бряк).

Потом нажимаем F9 (RUN) - крэкми запускается и вскоре останавливается там, где мы установили бряк.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvmh6ls7991VLHeo%2F45.png?generation=1566513557313333\&alt=media)

В окне подсказки высвечивается настоящий адрес EBP+8 = 12FFF8. Кстати, у Вас адрес может отличаться - это свойственно стековым адресам! Значение EBP в данный момент у меня равно 12FFF0, на основании чего и получилось, что EBP+8 = 12FFF8.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvmsaOSdY7PNHNCy%2F46.png?generation=1566513555889181\&alt=media)

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvmycgTp9fnA8iLJ%2F47.png?generation=1566513555510054\&alt=media)

Теперь давайте посмотрим, что хранится в дампе по адресу EBP+8 : Go to - Expression = EBP+8

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvn5n8zVjSllF6Yq%2F48.png?generation=1566513556078346\&alt=media)

И что мы там видим?

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvnGJ6rR81shRVRk%2F49.png?generation=1566513552864992\&alt=media)

Это значение будет помещено в стек. Нажимаем F7 - так и есть.

![](https://416819976-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LjyqT34OedPJiOdIrDw%2F-LmvTfhKwMHzvDz9duQT%2F-LmvTvnUKeWjgI-qTaUw%2F50.png?generation=1566513553441929\&alt=media)

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

Существуют другие способы адресации, но мы их частично уже рассмотрели в примерах. На данном этапе мне нечего добавить.

Кто смог осилить весь материал (включая, наверное, и переводчика :) - прим. пер.) имеет неплохие шансы познать захватывающий мир крэкинга, но для этого понадобится ещё очень много практики и чтения серьёзной литературы. В 9й главе мы, наконец, окунёмся в азы прикладного крэкинга.

Перевод последнего абзаца получился немного вольным, но смысл сохранился. Особенно хочется подчеркнуть, что автор не спроста упоминает о серьёзных книгах - учебниках по ассемблеру, архитектуре ПК, операционных систем и т.д. Многие теоретические основы, касающиеся ассемблера вообще и крэкинга в частности, не попадают в туториалы и только лишь книги помогают до конца разобраться в тех или иных темах.

\[C] Рикардо Нарваха, пер. Quantum
