您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

ARM 彙編逆向 iOS 實戰入門

編輯:iOS 開發綜合

以下以 ARMv7 為例說明(iPhone 5s 之後的 64 位不在本文討論範圍)。

基礎知識

一、暫存器

R0-R3:用於傳遞函式參數與回傳值。
R4-R6、R8、R10-R11:無特殊規定,就是一般通用暫存器。
R7:棧幀指標(Frame Pointer),指向前一個保存的棧幀與連結暫存器在棧上的位置。
R9:作業系統保留。
R12:又稱 IP(intra-procedure scratch),後文再細說。
R13:又稱 SP(stack pointer),棧頂指標。
R14:又稱 LR(link register),存放函式的回傳位址。
R15:又稱 PC(program counter),指向目前指令位址。
CPSR:目前程式狀態暫存器,在使用者狀態下存放 condition 標記、中斷停用等旗標;其他系統狀態下另有對應的 SPSR,此處不細究。

另外還有 VFP(向量浮點運算)相關暫存器,這裡直接略過。

二、基本指令

add(加法)、sub(減法)、str(把暫存器內容存到棧上)、ldr(把棧上內容載入暫存器)。

.w 是可選的指令寬度修飾符,它不影響指令行為,只是確保產生 32 位元指令。

bl 執行函式呼叫,並讓 lr 指向呼叫者的下一條指令,也就是回傳位址。
blx 同上,但會在 ARM 與 Thumb 指令集之間切換。
bx lr 則是返回呼叫者。

三、函式呼叫的規則

一、在 iOS 中必須使用 BLX、BX 這類指令來呼叫函式,不能用 MOV。
二、ARM 用一個向下生長(由高位址往低位址)的棧來維護函式的呼叫與返回。

函式呼叫前後的棧布局如下(引自 Apple iOS ABI Reference):

圖(一)

SP 指向棧頂。所謂棧幀(stack frame),其實就是透過 R7 以及存在棧上的舊 R7 所標識出的一塊塊儲存空間。一個棧幀包含:

參數區域(parameter area):存放呼叫函式時傳遞的參數。對 32 位元 ARM 而言,前四個參數用 r0-r3 傳遞,多餘的參數透過棧傳遞,就放在這塊區域。
連結區域(linkage area):存放呼叫者的下一條指令。
棧幀指標存放區域(saved frame pointer):存放被呼叫函式棧幀的底部,標誌著呼叫者棧幀結束、被呼叫者棧幀開始。
區域變數儲存區(local storage area):存放被呼叫函式的區域變數,以及返回呼叫者之前必須還原的暫存器內容。
暫存器儲存區(saved registers area):Apple 文件中有列出,實際上它與 local storage area 相鄰、用途也都是存放待還原的暫存器,因此概念上要不要拆開就看個人習慣,本質上並無差別。

四、序言與結語(prologs and epilogs)

呼叫開始時:

LR 入棧 → R7 入棧 → R7 = SP。經過前兩條入棧指令後 SP 已往低位址移動,再把 SP 賦值給 R7,就標誌著呼叫者棧幀結束、被呼叫者棧幀開始。接著把會被修改、返回時需還原的暫存器入棧,最後配置棧空間給子程式使用(因為棧往低位址生長,通常用 sub sp, #size)。

呼叫結束時:

用 add sp, #size 釋放棧空間 → 還原先前保存的暫存器 → 還原 R7 → 把之前存放的 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;
}

接著在 Xcode 左上角選好 target,以真機編譯(模擬器產生的是 x86 彙編),再執行 Product => Perform Action => Assemble file.c 產生彙編碼。輸出裡大量以「.」開頭的 .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 標誌函式的起訖。逐行來看:

add r0, r1:把 a 與 b 相加,結果放進 r0。
ldr.w r12, [sp]:把第六個參數 f 從棧上載入 r12。
add r0, r2:把 c 累加到 r0。
ldr.w r9, [sp, #4]:把第五個參數 e 從棧上載入 r9。
add r0, r3:把 d 累加到 r0。
add r0, r12:把 f 累加進來。
add r0, r9:把 e 累加進來。

至此 a 到 f 六個值全部累加在 r0 上,而 r0 正是用來存放回傳值的暫存器。最後 bx lr 返回呼叫者。

實戰(二):觀察函式呼叫時棧的變化

這次用三個函式、兩層呼叫來說明:

#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;
}

加上 __attribute__((noinline)) 是為了避免編譯器把函式內聯,干擾我們觀察棧的變化。同樣以真機編譯並 Assemble 後,我們從最外層開始看:

_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. 接著三條 movs 分別把 11、33、44 放進 r0、r2、r3。目前 r0-r3 放了 11、22、33、44,棧上放了 55。
8. bl _fooFunction:呼叫 fooFunction。
9. add sp, #4:回收第 3 步配置的空間。
10. pop {r7, pc}:還原第一步 push 進棧的值,把先前的 lr 賦給 pc。由於進入 initFunction 時 lr 存的是呼叫者的下一條指令,這樣一來程式就跳回去繼續執行,函式返回完成。

指令 1、2、3 是序言,9、10 是結語,這基本是固定套路,看多了自然一眼就能認出來。

配合指令 8(bl _fooFunction)當時的棧布局來看:

圖(二)

跳進 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 也 push 進去,因為後面會用到它們,必須在返回 initFunction 前還原。入棧順序是 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。

執行到 bl _addFunction 時,棧的布局如下:

圖(三)

最後進入 addFunction:

_addFunction:
    .cfi_startproc
Lfunc_begin0:
    add    r0, r1        // r0 += r1
    ldr.w  r12, [sp]     // 把 SP 指向的內容載入 r12,由圖(三)可知是 66
    add    r0, r2        // r0 += r2
    ldr.w  r9, [sp, #4]  // SP + 4 處存的是 55
    add    r0, r3        // r0 += r3
    add    r0, r12       // r0 += r12
    add    r0, r9        // r0 += r9
    bx     lr            // 返回
Lfunc_end0:

六個參數(r0-r3 的 11、22、33、44,加上棧上的 55、66)全部累加進 r0 後返回。

值得注意的細節:addFunction 沒有呼叫其他函式,因此不會有 bl、blx,也就不會改動 lr,所以它的序言結語裡沒有 push lr,這是為什麼它跟 initFunction、fooFunction 看起來不一樣。

至於 r9 與 r12 為什麼不需要保存與還原,iOS ABI Reference 給了說明:

關於 R9:在 iOS 2.x 中 R9 保留給作業系統使用,App 不得使用,否則可能造成崩潰或異常行為;但從 iOS 3.0 起,R9 可以當作 volatile 的暫用暫存器,這點與 AAPCS 的一般性建議不同。

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

以上是 C 函式的彙編,下一篇再來看 Objective-C 函式(含 objc block)的彙編。

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