×
单片机 > 单片机程序设计 > 详情

iOS 逆向之ARM汇编

发布时间:2020-06-06 发布时间:
|

最近对iOS逆向工程很感兴趣。

目前iOS逆向的书籍有: 《Hacking and Securing IOS Applications》, 《iOS Hacker's Handbook》中文书籍有《iOS应用逆向工程:分析与实战》

中文博客有: 程序员念茜的《iOS安全攻防系列》 英文博客有:Prateek Gianchandani的iOS 安全系列博客

这些资料中都涉及到有ARM汇编,但都只是很泛地用到,并没有对iOS上的ARM汇编进行比较详细的讲解。因此,经过一系列的学习对iOS下的ARM有了一定的理解。在此打算用几篇博文记录下来,备忘之,分享之, 限于本人水平有限,如有错误请不吝赐教。

 

我们先讲一些ARM汇编的基础知识。(我们以ARMV7为例,最新iPhone5s上的64位暂不讨论)

基础知识部分:

 

首先你介绍一下寄存器:

R0-R3:用于函数参数及返回值的传递

R4-R6, R8, R10-R11:没有特殊规定,就是普通的通用寄存器

R7:栈帧指针(Frame Pointer).指向前一个保存的栈帧(stack frame)和链接寄存器(link register, lr)在栈上的地址。

R9:操作系统保留

R12:又叫IP(intra-procedure scratch ), 要说清楚要费点笔墨,参见http://blog.csdn.net/gooogleman/article/details/3529413

R13:又叫SP(stack pointer),是栈顶指针

R14:又叫LR(link register),存放函数的返回地址。

R15:又叫PC(program counter),指向当前指令地址。

CPSR:当前程序状态寄存器(Current Program State Register),在用户状态下存放像condition标志中断禁用等标志的。

     在其它系统状态中断状等状态下与CPSR对应还有一个SPSR,在这里不详述了。

另外还有VFP(向量浮点运算)相关的寄存器,在此我们略过,感兴趣的可以从后面的参考链接去查看。

 

基本的指令:

add 加指令

sub 减指令

str 把寄存器内容存到栈上去

ldr  把栈上内容载入一寄存器中

.w是一个可选的指令宽度说明符。它不会影响为此指令的行为,它只是确保生成 32 位指令。Infocenter.arm.com的详细信息

bl 执行函数调用,并把使lr指向调用者(caller)的下一条指令,即函数的返回地址

blx 同上,但是在ARM和thumb指令集间切换。

bx  bx lr返回调用函数(caller)。

 

接下来是函数调用的一些规则。

一. 在iOS中你需要使用BLX,BX这些指令来调用函数,不能使用MOV指令(具体意义下面会说)

二. ARM使用一个栈来来维护函数的调用及返回。ARM中栈是向下生长(由高地址向低地址生长的)。

函数调用前后栈的布局如图一(引用的苹果iOS ABI Reference):

              图(一)

SP(stack pointer)指向栈顶(栈低在高地址)。栈帧(stack frame)其实就是通过R7及存在栈上的旧R7来标识的栈上的一块一块的存储空间。栈帧包括:

  1. 参数区域(parameter area),存放调用函数传递的参数。对于32位ARM,前4个参数通过r0-r3传递,多余的参数通过栈来传递,就是存放在这个区域的。

  2. 链接区域(linkage area),存放调用者(caller)的下一条指令。

  3. 栈帧指针存放区域(saved frame pointer),存放调用函数的栈帧的底部,标识着调用者(caller)栈帧的结束及被调用函数(callee)的栈帧开始。

  4. 局部变量存储区(local storage area)。用于存被调函数(callee)的局部变量及在被调用函数(callee)结束后反回调用函数(call)之前需要恢复的寄存器内容。

  5. 寄存器存储区(saved registers area)。Apple的文档中是这样说的。但我认为这个区域和local storage area相邻且干的事也是存放需要恢复的寄存器内容,因此我觉得要不就把这个区域在概念上不区分出来,要不就把存放需要恢复的寄存器这项功能从local storage area中分出来。 当然这些都只是概念上的,其实实质上是没有区别的。

接下来看看在调用子函数开始及结尾时所要做的事情。(官方叫序言和结语, prologs and epilogs)

调用开始:

  1. LR入栈

  2. R7入栈

  3. R7 = SP地址。在经过前面两条入栈指令后,SP指向的地址向下移动,再把SP赋值给R7, 标志着caller栈帧的结束及callee的栈帧的开始

  4. 将callee会修改且在返回caller时需要恢复的寄存器入栈。

  5. 分配栈空间给子程序使用。由于栈是从高地址向低地址生长,所以通常使用sub sp, #size来分配。

调用结尾:

  1. 释放栈空间。add sp, #size指令。

  2. 恢复所保存的寄存器。

  3. 恢复R7

  4. 将之前存放的LR从栈上弹出到PC,这样函数就返回了。

-----------------------------------------------------------华丽的分割线-------------------------------------------------------------

实战部分(一):

用XCode创建一个Test工程,新建一个.c文件,添加如下函数:

1
2
3
4
5
6
7
#include
 
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左上角选中targe 在真机下编译,这样产生的才是ARM汇编,不然在模拟器下生成的是x86汇编。

点击 XCode => Product => Perform Action => Assemble file.c 生成汇编代码。

代码很多,有很多"."开头的".section", ".loc"等,这些是汇编器需要的,我们不用去管。把这些"."开头的及注释增掉后,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
_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:"

下面来一行行代码解释:

  1. add r0, r1                 将参数a和参数b相加再把结果赋值给r0

  2. ldr.w r12, [sp]           把最的一个参数f从栈上装载到r12寄存器

  3. add r0, r2                 把参数c累加到r0上

  4. ldr.w r9, [sp, #4]       把参数e从栈上装载到r9寄存器

  5. add r0, r3                 累加d累加到r0

  6. add r0, r12               累加参数f到r0

  7. add r0, r9                 累加参数e到r0

至此,全部的a到f 共6个值全部累加到r0寄存器上。前面说了r0是存放返回值的。

bx lr: 返回调用函数。

-----------------------------------------------------------华丽的分割线-------------------------------------------------------------

实战部分(二):

为了让大家看清楚函数调用时栈上的变化,下面以一个有三个函数,两个调用的C代码的汇编代码为例讲解一下。

上代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include
 
__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))防止编译器把函数内联(如果你不懂内联,请google之)。

在XCode左上角选中targe 在真机下编译,这样产生的才是ARM汇编,不然在模拟器下生成的是x86汇编。

点击 XCode => Product => Perform Action => Assemble file.c 生成汇编代码, 如下:

为了能更符合我们人的思考方式,我们从调用函数讲起。

 initFunction:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
_initFunction:
    .cfi_startproc
Lfunc_begin2:
@ BB#0:
    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}                      就是前面基础知识部分说的函数调用的序言(prologs)部分的1, 2两条,将lr, r7 存到栈上去

  2. mov r7, sp                         序言(prolog)之3。

  3. sub sp, #4                         在栈上分配一个4字节空间用来存放局部变量, 即参数。前面我们说过,r0-r3可以传递4个参数,但超过的只能通过栈来传递。

  4. movs r0, #55                     把立即数55存入r0

  5. movs r1, #22                     把22存入r1

  6. str r0, [sp] 把r0的值存入栈指针sp指向的


『本文转载自网络,版权归原作者所有,如有侵权请联系删除』

热门文章 更多
单片机中高阻态的实质及意义