Глава 2. Язык ассемблера

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

Язык ассемблера (часто сокращаемый до asm) делает возможным напрямую взаимодействовать с процессором компьютера. Поскольку язык ассемблера это язык программирования очень нижнего уровня, обычно он применяется для особых вариантов применения, например, написания драйверов и шеллкода. Попытка написания полноценной программы на языке ассемблера практически невозможна, поэтому они пишутся на языках верхнего уровня.

Понимание языка ассемблера способствует вашей осведомлённости о массе вещей, в частности, относящихся к самому шеллкоду. Например, вы будете способны разбираться со следующим:

Язык ассемблера составляется из:

Имеющиеся инструкции сообщают своему процессору что делать. В каждой инструкции содержится некий код операции (opcode). Для всякой исполняемой инструкции вырабатывается одна инструкция машинного языка.

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

Макросы это некий вид техники замены текста.

Операторы языка ассемблера вводятся построчно. В следующем формате: [label] mnemonic [operands] [;comment]. Вот образец такого оператора:

mov RX, 13 ; Перемещает значение 13 в регистр RX
 	   

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

Например, давайте рассмотрим следующую строку ассемблера:

mov ecx, msg

Здесь кодом операции выступает mov, ecx (регистр) и msg. Это все операнды, и данная инструкция ассемблера перемещает некое сообщение в регистр ecx.

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

В своей предыдущей главе те примеры, которые вы наблюдали, были написаны на языке программирования верхнего уровня. При использовании языка программирования верхнего уровня вы определяете необходимые переменные, а ваш компилятор заботится обо всех внутренностях. Давайте рассмотрим пример написанного на C Hello World:

#include <stdio.h>
char s[] = "Hello World";
int main ()
{
    int x = 2000, z =21;
    printf("%s %d /n", s, x+z);
}
 	   

Вы можете исполнить это в своей собственной среде Kali, добавив приведённый выше текст в некий файл.

Затем вы сохраняете этот файл в hello.c. Далее вы пользуетесь компилятором с названием GCC для компиляции этого в язык ассемблера при помощи такой команды:

gcc –S hello.c
		

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

.file "hello.c"
.text
.globl s
.data
.align 8
.type s, @object
.size s, 13
s:
.string "Hello World"
.section .rodata
.LC0:
.string "%s %d \n"
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
Pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
Movq %rsp, %rbp
.cfi_def_cfa_register 6
Subq $16, %rsp
Movl $2000, -4(%rbp)
Movl $21, -8(%rbp)
Movl -4(%rbp), %edx
Movl -8(%rbp), %eax
Addl %edx, %eax
Movl %eax, %edx
Leaq s(%rip), %rsi
Leaq .LC0(%rip), %rdi
Movl $0, %eax
Call printf@PLT
Movl $0, %eax
leave
.cfi_def_cfa 7, 8
ret
.cfi_endproc
 	   

Как вы можете наблюдать, если вы целиком скомпилируете этот фрагмент кода и исполните его, его результатом будет представленный вам на экране текст Hello World 2021

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

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

Архитектура языка ассемблера охватывает сборки (ассемблеры) x86, x64, ARM и много иное.

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

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

В вычислительной архитектуре устройство центрального процессора (central processing unit, CPU, ЦПУ) отвечает за обработку данных. Поэтому давайте сделаем шаг назад и визуализируем компьютер простыми блоками построения. Приводимая ниже схема сосредоточена на трёх основных компонентах вычислительной системы:

Тремя простейшими компонентами выступают ЦПУ, память и ввод/ вывод. Будучи основным мозгом всего, ЦПУ нуждается в данных. Итак, давайте взглянем на те компоненты, которые конкретно относятся к самому ЦПУ и тому как они применяются.

Мы начнём с управляющего блока (control unit). Такое управляющее устройство отвечает за направление памяти компьютера, арифметическо- логического блока и различных устройств ввода/ вывода в отношении того, как реагировать на инструкции, полученные ЦПУ. Оно также будет получать инструкции из различных мест, таких как память и регистры, а в конечном итоге контролировать их исполнение.

Следующий компонент это исполнительный блок (execution unit). Это именно тот компонент, в котором происходит выполнение инструкций.

Следующие два компонента это регистры и флаги. Глубже мы сосредоточимся на регистрах и флагах позднее в этой главе.

Теперь, когда у нас имеется обзор на верхнем уровне архитектуры ЦПУ, давайте сосредоточимся на том как хранятся и выполняются данные. Эти данные могут храниться либо в регистрах, либо в местоположениях памяти. Одним из основных отличий между регистрами и местоположениями в памяти является время доступа. Поскольку регистры ближе к самому процессору, их время доступа очень быстрое. Для иллюстрации разницы в скорости, рассмотрим действительно быстрые микросхемы оперативной памяти. Они будут обладать временем доступа около 10- 50 наносекунд, в то время как доступ к регистру происходит в районе 1 наносекунды.

Приводимая ниже таблица иллюстрирует значения скорости регистров в сопоставлении с прочими видами хранения.

Регистры формируют самые мелкие компоненты памяти и, хотя они и наименьшие, они самые быстрые. Хранимые в регистрах данные не стойкие. Далее следует кэш ЦПУ, который способен содержать больше чем регистр и применяется ЦПУ для снижения среднего времени доступа, которое требуется для доступа к данным. Регистры и кэш обладают высокой скоростью и они помещаются между самим ЦПУ и оперативной памятью для увеличения скорости и производительности. Оперативная память обладает намного более высокой ёмкостью и, по мере увеличения скорости оперативной памяти, она всё ещё не столь быстра как кэш или регистр. Наконец, у вас имеются самые большие, самые медленные и самые экономичные жёсткие диски или твердотельные накопители. Они предлагают большой объём памяти и относительно быстрое время чтения и записи, но не столь быстрое как у оперативной памяти, кэша или регистров.

Давайте рассмотрим различные типы регистров.

Регистры общего назначения

Мы начинаем с регистров общего назначения (GPR, general-purpose registers). Они применяются для временного хранения данных в самом ЦПУ. Имеется 16 GPR, причём каждый длиной в 64 бита. GPR приведены на Рисунке 2.3. Доступ к GPR может выполняться по всем 64 битам или по их подмножеству.

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

При применении элементов данных с размером менее 64 бит (32- бита, 16- бит или 8- бит), доступ к нижней части регистра можно получать применяя иное имя регистра, как это показано на Рисунке 2.3. Для иллюстрации давайте взглянем на регистр rax Рисунок 2.4 отображает подробности схемы доступа к нижним частям регистра rax:

Самые первые четыре регистра, rax, rbx, rcx и rdx предоставляют доступ к битам 8-15 при помощи имён регистров ah, bh, ch и dh, как это указано на Рисунке 2.3 и Рисунке 2.4. Это предоставляется для сопровождения преемственности, причём с исключением для ah.

Просмотр регистров bin/bash

Теперь я полностью понимаю, что чтение всего этого может отнимать много времени, а потому давайте рассмотрим это при помощи примера. Я воспользуюсь программой отладчика проекта GNU в своей машине Kali Linux для отладки /bin/bash в своём компьютере:

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

Регистры указателя

Регистр указателя это регистр, применяемый для хранения адреса памяти в вашей архитектуре процессора. Мы можете быть способны применять их также и для прочих нужд, но обычно они в инструкциях, которые интерпретируют их как адреса в памяти и выполняют выборку по хранимому в них адресу. Давайте рассмотрим некоторые регистры указателей и их функции:

Индексные регистры

Значение текущего смещения местоположения в памяти хранится в индексном регистре, а значение его базового адреса запоминается в другом регистре, что имеет результатом законченный адрес памяти. Например, на Рисунке 2.8 вы обнаружите что значения 32- битных индексных регистров, включающих в свой состав ESI и EDI, а также их 16- битные двойники, SI и DI, применяются для индексной адресации. Эти регистры порой применяются в таких арифметических функциях как сложение и вычитание.

Вот эти два типа индексных регистров:

Теперь, когда мы рассмотрели индексные регистры, давайте перейдём к управляющим регистрам.

Управляющие регистры

Управляющие регистры (Control registers) вступают в игру когда инструкции пользуются сопоставлениями и математическими операциями для изменения значения состояния флагов, в то время как прочие применяют условные инструкции для проверки соответствующего значения таких состояний флагов перед отклонением потока исполнения в иное место. Когда вы сочетаете регистры указателей и регистры флагов, они рассматриваются как регистры управления.

Вот наиболее распространённые флаги, которые работают с управляющими регистрами:

Далее нам потребуется разобраться с тем как в языке ассемблера обрабатываются местоположения в памяти. Именно тут вступают в действие сегментные регистры.

Сегментные регистры

Внутри своего ЦПУ сегментные регистры это в целом указатели памяти. Сегментные регистры указывают на месторасположение в памяти, в котором происходит одно из следующих событий: местоположение данных, подлежащая исполнению инструкция и тому подобное.

Когда речь заходит о сегментных регистрах, мы сосредоточимся на следующих:

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

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

Инструкции перемещения данных могут быть подразделены на следующие категории:

Инструкции перемещения для общих целей

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

Далее мы рассмотрим те инструкции, которые могут применяться для манипуляции стеком.

Инструкции манипуляции со стеком

Для непосредственного изменения стека применяются инструкции манипуляции стеком.

По мере того как мы завершаем этот раздел, может показаться, что нужно ещё много с чем разобраться. Однако, как только мы начнём работать с шеллкодом и просматривать программы в дизассемблере, все эти инструкции станут более понятными. Теперь перейдём к арифметическим инструкциям.

Внутри ЦПУ вы можете обнаружить компонент, который носит название Arithmetic Logical Unit (ALU, арифметического логического блока). Этот компонент отвечает за выполнение арифметических операций, таких как сложение, вычитание и умножение.

В языке ассемблера эти операции отображаются так:

Арифметические операции следуют тому же самому синтаксису, который мы наблюдали ранее:

operation destination, source
 	   

Вот пояснение этого синтаксиса:

Например, давайте ознакомимся со следующим фрагментом кода, который выполняет различные арифметические инструкции с определёнными в a и b значениями:

#!/bin/sh

a=100
b=50

val='expr $a + $b'  #Line 1
echo "a + b : $val" #Line 2

val='expr $a - $b'  #Line 4
echo "a - b : $val" #Line 5

val='expr $a \* $b'  #Line 7
echo "a * b : $val"  #Line 8

val='expr $a / $b'  #Line 10
echo "b / a : $val"  #Line 11
 	   

В строке 1 у нас имеется операция сложения, выполняющаяся с двумя объявленными в a и b значениями. Его результат здесь произведёт 150. Строка 4 выполняет операцию вычитания тех же значений, возвращающей значением результата 50. Строка выполняет умножение тех же значений и возвращает получаемым результатом 5000. И последняя, строка 10, осуществляет деление тех же значений, имея результатом 2.

Арифметические операции часто используются в шеллкоде. По мере того как мы пройдём по относящимся к шеллкоду Linux и Windows главам, вы обнаружите арифметические операции в различных примерах шеллкода.

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

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

Условный переход

Условные переходы используются для принятия решения на основе значений состояний соответствующих флагов или некого условия. Когда в Ассемблере должны применяться такие понятия как операторы if или loop, обычно используются условные переходы. Условные переходы применяются для определения того, следует ли осуществлять переход, поскольку язык ассемблера не поддерживает такие слова как операторы if.

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

Таблица 2-1. Разбивка инструкций перехода. Источник

Инструкция	Описание	Флаги
JE/JZ	Jump Equal или Jump Zero	ZF
JNE/JNZ	Jump Not Equal или Jump Not Zero	ZF
JG/JNLE	Jump Greater Equal или Jump Not Less/ Equal	OF, SF, ZF
JGE/JNL	Jump Greater/Equal или Jump Not Less/ Equal	OF, SF
JL/JNGE	Jump Less или Jump Not Greater/ Equal	OF, SF
JLE/JNG	Jump Less/ Equal или Jump Not Greater	OF, SF, ZF

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

Безусловный переход

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

Условные инструкции, в особенности разнообразные безусловные переходы, могут применяться когда вы желаете выполнить безусловный переход к своему шеллкоду. Если вы обладаете управлением над указателем инструкций и ваш шеллкод расположен где-то там, для ссылки на этот указатель может применяться безусловный переход. Когда вы берёте пример с простым переполнением буфера, включая в эксплойт либо безусловный, либо условный переход, вы, по сути, будете переходить к различным разделам буфера чтобы достичь свой шеллкод.

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

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

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

Intel 64 and IA-32 Sofware Developers Manual