您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 教學 >> iOS 相關教學

ARM 彙編逆向實戰:讀懂 iOS 函式呼叫與堆疊變化

編輯:iOS 相關教學

想讀懂逆向工具反編譯出來的 Pseudo Code,得先看得懂背後的 ARM 彙編。本文以 ARMv7 為例(iPhone 5s 之後的 64 位暫不討論),從暫存器與堆疊框架講起,再透過兩個實際編譯出來的 C 範例,逐行拆解函式呼叫時堆疊上到底發生了什麼事。

一、基礎知識

暫存器

  • R0–R3:傳遞函式參數與回傳值
  • R4–R6、R8、R10–R11:無特殊約定,一般通用暫存器
  • R7:堆疊框架指標(Frame Pointer, FP),指向前一個已保存的堆疊框架與連結暫存器(LR)在堆疊上的位置
  • R9:作業系統保留
  • R12:又稱 IP(intra-procedure scratch),後文再說明
  • R13:又稱 SP(Stack Pointer),堆疊頂端指標
  • R14:又稱 LR(Link Register),存放函式的返回位址
  • R15:又稱 PC(Program Counter),指向目前指令的位置
  • CPSR:目前程式狀態暫存器,在使用者狀態下存放 condition 標記、中斷停用等標記。其他系統狀態下另有對應的 SPSR,此處不展開

此外還有 VFP(向量浮點運算)相關暫存器,有興趣可另行參考 ARM 官方文件。

常用指令

  • add 加法、sub 減法
  • str 把暫存器內容存進堆疊、ldr 把堆疊內容載入暫存器
  • .w 是可選的指令寬度描述符,不影響指令行為,只用來確保產生 32 位元指令
  • bl 執行函式呼叫,並讓 LR 指向呼叫者的下一條指令(即返回位址)
  • blx 同上,但會在 ARM 與 Thumb 指令集之間切換
  • bx lr 返回呼叫者

函式呼叫的規則

  1. 在 iOS 中必須使用 BLX、BX 這類指令呼叫函式,不能用 MOV 指令去改 PC。
  2. ARM 用一個堆疊來維護函式的呼叫與返回,且堆疊是向下生長的(由高位址往低位址)。

函式呼叫前後堆疊的佈局如下(引自 Apple iOS ABI Reference):

SP 指向堆疊頂端(堆疊底部位於高位址)。所謂堆疊框架(stack frame),就是透過 R7 與堆疊上保存的舊 R7 所標識出的一塊塊儲存空間,包含:

  • 參數區域(parameter area):存放呼叫函式傳遞的參數。32 位 ARM 下前 4 個參數用 R0–R3 傳遞,多餘的參數透過堆疊傳遞,就放在這裡。
  • 連結區域(linkage area):存放呼叫者的下一條指令位址。
  • 框架指標存放區(saved frame pointer):存放被呼叫函式框架的底部,標示呼叫者框架的結束與被呼叫者框架的開始。
  • 區域變數儲存區(local storage area):存放被呼叫函式的區域變數,以及返回呼叫者之前需要恢復的暫存器內容。
  • 暫存器儲存區(saved registers area):Apple 文件將它獨立列出。由於它與區域變數儲存區相鄰、用途也都是保存待恢復的暫存器,概念上是否切分只是描述角度的差異,實質並無不同。

序言與結語(Prologue / Epilogue)

呼叫開始時:

  1. LR 入堆疊
  2. R7 入堆疊
  3. 把 SP 的值賦給 R7,標誌呼叫者框架結束、被呼叫者框架開始
  4. 把那些會被修改、且返回時必須恢復的暫存器入堆疊
  5. 為子程式配置堆疊空間。因為堆疊由高往低生長,通常用 sub sp, #size

呼叫結束時:

  1. 用 add sp, #size 釋放堆疊空間
  2. 恢復先前保存的暫存器
  3. 恢復 R7
  4. 把堆疊上保存的 LR 彈出到 PC,函式即返回

二、實戰(一):拆解一個簡單的加法函式

在 Xcode 建立 Test 專案,新增一個 .c 檔並寫入:

#include <stdio.h>

int func(int a, int b, int c, int d, int e, int f)
{
    int g = a + b + c + d + e + f;
    return g;
}

怎麼看到 ARM 彙編:在 Xcode 左上角把 target 選為實機(Device),因為只有在真機下編譯才會產生 ARM 彙編;選模擬器產生的是 x86 彙編。接著執行 Product → Perform Action → Assemble 對該檔案組譯。

輸出會有很多以「.」開頭的 .section、.loc 等指示,那些是組譯器需要的,可以忽略。把這些以及註解移除後:

_func:
    .cfi_startproc
Lfunc_begin0:
    add   r0, r1
Ltmp0:
    ldr.w r12, [sp]
    add   r0, r2
    ldr.w r9, [sp, #4]
    add   r0, r3
    add   r0, r12
    add   r0, r9
    bx    lr
Ltmp2:
Lfunc_end0:

_func: 表示以下是 func 的內容;Lfunc_begin0 與 Lfunc_end0 標示函式的起訖(命名慣例通常是 xxx_beginx / xxx_endx)。

逐行解讀:

  • add r0, r1:a + b,結果放進 R0
  • ldr.w r12, [sp]:把堆疊頂的參數 f 載入 R12
  • add r0, r2:累加 c
  • ldr.w r9, [sp, #4]:把參數 e 載入 R9
  • add r0, r3:累加 d
  • add r0, r12:累加 f
  • add r0, r9:累加 e
  • bx lr:返回呼叫者

六個參數全部累加完畢,結果就在 R0——因為 R0 是回傳值暫存器。順序上,前四個參數(a、b、c、d)走 R0–R3,後兩個(e、f)從堆疊上取。

三、實戰(二):三個函式、兩次呼叫

為了看清楚堆疊變化,我們加上 __attribute__((noinline)) 禁止編譯器做函式內嵌(inline),否則編譯器可能直接把函式展開,就看不到呼叫的過程了。

#include <stdio.h>

__attribute__((noinline))
int addFunction(int a, int b, int c, int d, int e, int f)
{
    int r = a + b + c + d + e + f;
    return r;
}

__attribute__((noinline))
int fooFunction(int a, int b, int c, int d, int f)
{
    int r = addFunction(a, b, c, d, f, 66);
    return r;
}

int initFunction()
{
    int r = fooFunction(11, 22, 33, 44, 55);
    return r;
}

同樣以真機 target 組譯。為了配合人的思考方式,我們從最外層的呼叫者看起。

initFunction

_initFunction:
    .cfi_startproc
Lfunc_begin2:
    push  {r7, lr}
    mov   r7, sp
    sub   sp, #4
    movs  r0, #55
    movs  r1, #22
Ltmp6:
    str   r0, [sp]
    movs  r0, #11
    movs  r2, #33
    movs  r3, #44
    bl    _fooFunction
    add   sp, #4
    pop   {r7, pc}
Ltmp7:
Lfunc_end2:

逐行解讀:

  1. push {r7, lr}:序言的前兩步,把 LR 與 R7 存到堆疊上。
  2. mov r7, sp:序言第三步,建立新的框架指標。
  3. sub sp, #4:配置 4 個位元組存放區域變數(也就是要傳給下一層的參數)。前面提過 R0–R3 只能傳四個參數,超出的必須走堆疊。
  4. movs r0, #55:把 55 放進 R0。
  5. movs r1, #22:把 22 放進 R1。
  6. str r0, [sp]:把 R0 的值寫進 SP 指向的記憶體,此時 55 就躺在堆疊上了。
  7. 接著三條指令把 11、33、44 分別放進 R0、R2、R3。至此 R0–R3 依序是 11、22、33、44,堆疊上則是 55。
  8. bl _fooFunction:呼叫 fooFunction。
  9. add sp, #4:把 SP 往上移 4 個位元組,回收第 3 步配置的空間。
  10. pop {r7, pc}:還原第 1 步壓入的內容,把原本的 LR 值賦給 PC。因為進入 initFunction 時 LR 存的是「呼叫 initFunction 的那個函式的下一條指令」,把值寫回 PC 之後,程式就返回了。

指令 1~3 是序言,9~10 是結語。這是一個固定套路,看熟了不必再逐條分析。

指令 8 執行時的堆疊佈局:

fooFunction

_fooFunction:
    .cfi_startproc
Lfunc_begin1:
    push  {r4, r5, r7, lr}
    add   r7, sp, #8
    sub   sp, #8
    ldr   r4, [r7, #8]
    movs  r5, #66
    strd  r4, r5, [sp]
    bl    _addFunction
    add   sp, #8
    pop   {r4, r5, r7, pc}
Lfunc_end1:

逐行解讀:

  1. push {r4, r5, r7, lr}:這次除了 LR 與 R7,也把 R4、R5 一起壓入,因為後面會用到它們,返回前必須還原。壓入順序是 LR、R7、R4、R5。
  2. add r7, sp, #8:initFunction 沒有 push R4/R5,所以那裡 SP 的位置剛好就是新的 R7 值。但這裡多壓了兩個暫存器,SP 現在指向 R4 的位置;由於堆疊向下生長,SP 加 8 個位元組就是保存舊 R7 的地方。
  3. sub sp, #8:配置 8 個位元組。
  4. ldr r4, [r7, #8]:R7 加 8 個位元組的位置,正好是 initFunction 存放參數 55 的地方,因此這是「把 55 讀進 R4」。
  5. movs r5, #66:把 66 放進 R5。
  6. strd r4, r5, [sp]:把 R4、R5 的值寫到堆疊上。11、22、33、44 已經在 R0–R3,55 與 66 則放在堆疊。
  7. bl _addFunction:參數準備完成,呼叫 addFunction。
  8. add sp, #8:回收堆疊空間。
  9. pop {r4, r5, r7, pc}:與 initFunction 類似,只是多恢復了 R4、R5,同樣一條指令搞定。

進入 addFunction 時的堆疊佈局:

addFunction

_addFunction:
    .cfi_startproc
Lfunc_begin0:
    add   r0, r1
    ldr.w r12, [sp]
    add   r0, r2
    ldr.w r9, [sp, #4]
    add   r0, r3
    add   r0, r12
    add   r0, r9
    bx    lr
Lfunc_end0:

逐行對照堆疊圖:

add   r0, r1      ; r0 += r1        (11 + 22)
ldr.w r12, [sp]   ; r12 = [sp]      → 66
add   r0, r2      ; r0 += r2
ldr.w r9, [sp,#4] ; r9 = [sp+4]     → 55
add   r0, r3      ; r0 += r3
add   r0, r12     ; r0 += r12
add   r0, r9      ; r0 += r9
bx    lr          ; 返回

這裡有個值得注意的細節:addFunction 沒有呼叫其他函式,所以它的序言與結語跟前面兩個函式不同——沒有 bl/blx,也就不會改動 LR,因此不需要 push LR,直接 bx lr 返回即可。

關於 R9 與 R12 為何不必保存

iOS ABI Reference 的說法:

R9:在 iOS 2.x,R9 保留給作業系統使用,App 程式碼不得使用,否則可能造成崩潰或異常行為;不過在 iOS 3.0 之後,R9 可以當作 volatile 的暫用暫存器使用。這與 AAPCS 的一般性約定不同。

R12:是 intra-procedure scratch(又稱 IP),由動態連結器使用,且在所有函式呼叫之間都是 volatile;但在函式呼叫之間可以當暫用暫存器。

關鍵字是 volatile——這類暫存器不保證在函式呼叫後仍保有原值,因此呼叫者本來就沒有保存它們的義務。

下一步

本文談的是 C 函式產生的 ARM 彙編。Objective-C 的訊息派送(objc_msgSend)與 block 的 invoke 函式指標,在彙編層面還會多一層間接呼叫,下一篇再來拆解。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved