Привет Хабр! В 2014 году автор под никнеймом xorpd опубликовал книгу, которая полностью состоит из ассемблерного листинга, в ней нет ни одного комментария а в поле "от автора" написаны несколько строк машинного кода. Его задумка в том что бы читатели сами поняли что означают все эти строки кода и для чего они вообще нужны. Я самостоятельно разобрал эту книгу и хочу поделиться с вами интересными трюками, которые автор оставил читателям.

Книга выложена в открытом доступе на одноименном сайте. (настоятельно рекомендую посетить, сайт очень интересный)

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

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

Для наглядонсти мы будем писать некоторые из примеров книги на fasm под LInux. Статья также подразумевает у читателя наличие базового понимания языка ассемблера для архитектуры х86 и базовых знаний битовой арифметики.

Стоит сказать так же пару слов о имени автора и названии книги, ведь они тоже являются ассемблерным кодом. xorpd это инструкция предназначенная для того что бы ксорить 128-битные регистры. Что-то вроде "страшего брата" обычного xor. А название книги xchg rax, raxэто ни что иное как "перефразированная" инструкция nop. Которая не делает ничего. Компиляторы часто вставляют вместо нее подобного рода строчки. Инструкция xchgпросто меняет местами значения регистров.

И так, начнем наверное вот с такого простого примера: (страница 0x01)

.loop:
			xadd   rax, rdx
      loop   .loop

Что-бы наглядно посмотреть работу этого кода, напишем простую функцию вывода десятичных чисел в терминал. Кладем в rax любое 64-битное число и вызываем нашу процедуру. Подробно ее работу я разбирать не буду, хоть в в ней и присутствеут определенная красота. Если очень кратко: мы тут просто рекурсивно делим число на 10, пока оно не будет равно нулю, а к остатку прибавляем символ нуля, что бы получить правильную ASCII кодировку цифры. Кидаем на стек значения символов и потом достаем их в rax. Далее просто выводим каждый из символов в терминал с помощью системного вызова write(). Инфы про нее в интернете достаточно, так что думаю что все смогут разобраться.

print_number:

   xor rdx, rdx
   mov rcx, 10
   div rcx
   add rdx, '0'
   push rdx
   or rax, rax
   jz short .output
   call print_number
 .output:
   pop rax
   call print_symbol
   
   ret
    
print_symbol:
  push rdx
  push rsi
  push rdi
  push rax

  mov rax, 1
  mov rdi, 1
  mov rsi, rsp
  mov rdx, 1
  syscall

  pop rax
  pop rdi
  pop rsi
  pop rdx

  ret

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

И так, начнем с того что регистр rcx в циклах выступает счетчиком, от чего и называется "re-extended counter", соответственно мы будем вычислять rcx-ый элемент последовательности чисел Фибоначчи. rdx вначале должен быть равен единице, а rax нулю. Протестируем на данном примере:

Создадим для удобства простенький makefile и соберем нашу программку.

default: build run
build:
	fasm test.asm && ld test.o -o test
 run:
 	./test

_start:
  		mov rcx, 9
  		mov rdx, 1
.loop:
  		xadd rax, rdx
  		loop  .loop
  		call print_number

После запуска мы увидим результат 34, все работает корректно, давайте теперь разберем как это работает.

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

Следущий в очереди вот такой код: (страница 0x15)

		mov      rdx,0xffffffff80000000
    add      rax,rdx
    xor      rax,rdx

Далее вот такая строчка: (страница 0x04)

xor		al, 0x20

Над ней я думал достаточно долго. Дело в том что разница в ascii кодировке заглавных и строчных символов везде равна 20. К примеру "А" = 41, а строчная "а" = 61 или "Z" = 5a, "z" = 7a. Эта строчка позволяет поменять строчный символ на заглавный, и наоборот всего за одну машинную инструкцию! Как именно происходит вычисление кодировки символа думаю можно не обьяснять. Красиво, неправда ли? Можем написать маленькую программку которая будет менять все символыстроки с использованием команды xlatb Эта инструкция возвращает байт по индексу, хранящемуся в al, из массива, на который указывает rbx

string db "hello world", 0

_start:
      mov rbx, string
_loop:
      cmp [rbx], byte 0
      je short exit
      xor al, al
      xlatb
      cmp al, 0x20
      jz short _space
      xor al, 0x20
      call print_symbol
      inc rbx
      jmp short _loop
exit:
      xor rbx, rbx
      mov rax, 1
      int 80h
_space:
      call print_symbol
      inc rbx
      jmp short _loop

Создаем директиву со строкой, передаем ее в rbx, а потом просто увеличиваем его в цикле пока не дойдем до нуль терминатора, попутно возвращая байты по нулевому индексу в al. Тут я использую jmp short вместо простого jmp т.к она занимает в разы меньше места, но передавать управление может только на 128(примерно) байт. Для вывода их на экран пользуемся процедурой print_symbol, реализованной выше. Так же проверяем строку на наличие пробелов и корректно обрабатываем их. Метка exit просто делает системный вызов exit() .Эта программа выведет "HELLO WORLD". Можете протестировать этот код самтостоятельно и проверить его работу.

Рассмотрим что-то более сложное: (страница 0x3a)

    mov      qword [rbx + 8*rcx],0
    mov      qword [rbx + 8*rdx],1
    mov      rax,qword [rbx + 8*rcx]

    mov      qword [rbx],rsi
    mov      qword [rbx + 8],rdi
    mov      rax,qword [rbx + 8*rax]

Вот тут уже начинаете что-то более интересное.

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

mov [ адресс начала массива + выравнивание * индекс ], значение

Под выравниваем очевидно имеется ввиду размер элементов в массиве, в данном случае размер элементов 8, значит массив выровнен по 8 байт.

И так в rbx у нас указывает на некую память, выровненную по 8 байт , далее rax и rcx должны содержать какие-то индексы, по котоым кладется единичка и ноль. Далее мы в rax возвращаем значение по индексу rcx

Кладем rsi и rdi по соседству в нашу память и возвращаем в rax что-то по индексу который мы вычеслили в первом блоке кода.

Можете так же подумать пару минут о том что же может происходить дальше :)

Не судите слишком строго, это моя первая статья.

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

Всем большое спасибо за внимание!