iOS逆向 03：循环选择指针（上）-阿里云开发者社区

本文的主要目的是理解汇编中全局变量、常量的存储，以及如何将if、while等汇编代码还原成高级代码

全局变量

在这之前首先需要了解内存的分区，对这块不是特别清晰的，建议看看这篇文章iOS-底层原理 24：内存五大区，下面进行一个简单的汇总说明

代码区：存放代码，可读、可执行
栈区：存放参数、局部变量、临时数据，可读写
堆区：开发人员动态申请，大小可变，可读写
全局变量：可读可写
常量：只读

案例分析

在main.m中定义一个函数和一个全局变量

int g = 12;
int func(int a, int b){
    printf("haha");
    int c = a + g;
    return c;
}
int main(int argc, char * argv[]) {
    func(1, 2);
}

func函数断点运行，以下是main函数的汇编代码

查看func的汇编代码，分析如下

查看x0是否为“haha”，通过调试得以验证，x0存的是haha的地址

查看其地址：x 0x000000010098bf9f，属于字符串的常量区（即左边是右边字符串的ASCII码）

其中重点分析adrp x0,1和add x0,x0,#0xf9f两句

adrp指令（address page 按页寻址）：

将1的值左移12位，此时的1是二进制
加上pc寄存器的值（先需要将pc的低12位清零）

<!--（按页寻址）-->
<!--adrp-->
0x10098a824 <+20>: adrp   x0, 1
- 1）1左移12位：0x1000
- 2）pc寄存器低12位清零：0x10098a000
- 3）加上pc寄存器的值：0x10098a000 + 0x1000 = 0x10098b000
===> 得到x0地址就是某一页数据的起始位置（即首地址）
<!--add-->
0x10098a828 <+24>: add    x0, x0, #0xf9f            ; =0xf9f 
- adrp得到的地址加上偏移：0x10098b000 + 0xf9f = 0x10098bf9f
===> 此时的x0就是某一页中某段代码的地址，即当前代码段的地址

通过这个计算结果可知与上面调试的x0地址是一致的

why？：一个页的大小是4096，而0xFFF为4095，加上1就是0x1000（即4096），所以是1左移12位即可得到一个页的首地址（注：macOS的pageSize是 4k（0x1000），而iPhone的pageSize是16k（0x4000），但是16仍是4的倍数，adrp兼容者mac和iPhone，所以此时定位的仍然是一页数据）

继续分析bl printf以下的汇编代码

ldur w8, [x29, #-0x4] ：拿出栈中的数据，即1

adrp + add + ldr :拿出0x10098ce98内存地址的数据，将x9的数据给w10。这样就拿到了全局变量g

反汇编分析

示例代码如下

int g = 12;
int func(int a, int b){
    printf("haha");
    int c = a + g + b;
    return c;
}
int main(int argc, char * argv[]) {
    func(10, 20);
}

通过hopper来进行反汇编分析

首先将工程编译：CMD+B
进入App的包

将第5步中的可执行文件拖入hopper中进行分析

在hopper中搜索func

拷贝func的汇编代码，将其还原成高级语言代码（即反汇编）

<!--1、将汇编初步还原为高级语言代码-->
int gl = 12;
int func2(int a, int b){
    /*
     //一个函数的开始
     0000000100006808         sub        sp, sp, #0x20
     000000010000680c         stp        x29, x30, [sp, #0x10]
     0000000100006810         add        x29, sp, #0x10
    */
    /*
     //调用bl printf
     0000000100006814         stur       w0, [x29, #-0x4]
     0000000100006818         str        w1, [sp, #0x8]
     //===>此时的获取的0x100007f9f地址的数据 是没有ASLR的值
     000000010000681c         adrp       x0, #0x100007000
     0000000100006820         add        x0, x0, #0xf9f                              ; "haha"
     0000000100006824         bl         imp___stubs__printf
     */
    printf("haha");
     /*
      0000000100006828         ldur       w8, [x29, #-0x4]
      */
    int w8 = a;
    /*
      //===>此时的获取0x100008e98的数据
      000000010000682c         adrp       x9, #0x100008000
      0000000100006830         add        x9, x9, #0xe98                              ; _g
     */
//    int gl = 12;//(需要写外面)
    /*
      0000000100006834         ldr        w10, x9
     */
    int w10 = gl;
    /*
      0000000100006838         add        w8, w8, w10
     */
    w8 += w10;
    /*
      000000010000683c         ldr        w10, [sp, #0x8]
     */
    w10 = b;
    /*
      0000000100006840         add        w8, w8, w10
     */
    w8 += w10;
    /*
      0000000100006844         str        w8, [sp, #0x4]
      0000000100006848         ldr        w8, [sp, #0x4]
      000000010000684c         mov        x0, x8
      */
    return w8;
    /*
     //一个函数的结束
     0000000100006850         ldp        x29, x30, [sp, #0x10]
     0000000100006854         add        sp, sp, #0x20
     0000000100006858         ret
     */
}
<!--2、去掉汇编-->
int gl = 12;
int func2(int a, int b){
    printf("haha");
    int w8 = a;
    int w10 = gl;
    w8 += w10;
    w10 = b;
    w8 += w10;
    return w8;
}
<!--3、简化代码-->
int gl = 12;
int func2(int a, int b){
    printf("haha");
    return a + b + gl;
}

简化过程如下图所示（注：是从下向上还原，而不是从上向下（业务逻辑是从上至下执行）：

其中

//===>此时的获取的0x100007f9f地址的数据 是没有ASLR的值
 000000010000681c         adrp       x0, #0x100007000      
 0000000100006820         add        x0, x0, #0xf9f

hopper中按G，查找0x100007f9f对应的数据

同理，获取全局变量g也是同样的原理

//===>此时的获取0x100008e98的数据
000000010000682c         adrp       x9, #0x100008000
0000000100006830         add        x9, x9, #0xe98                              ; _g
0000000100006834         ldr        w10, x9

总结

获取全局变量和常量时，会出现adrp和add两条指令获得一个地址的情况
ADRP（Address Page）

adrp x0，1

将PC寄存器的低12位清零
将1的值，左移12位，16进制就是0x1000
以上两个结果相加放入x0寄存器

通过ADD指令获取这页内存中的偏移值

条件

有如下代码，查看其汇编

int g = 12;
void func(int a, int b){
    if (a > b) {
        g = a;
    }else{
        g = b;
    }
}
int main(int argc, char * argv[]) { 
    func(1, 2);
}

通过hopper查看其汇编，代码如下

_func:
 ==>拉伸栈空间
 0000000100006828         sub        sp, sp, #0x10                               ; CODE XREF=_main+32
 ==>w0、w1数据入栈
 000000010000682c         str        w0, [sp, #0xc]
 0000000100006830         str        w1, [sp, #0x8]
 ==>从栈中读取数据到w8、w9
 0000000100006834         ldr        w8, [sp, #0xc]
 0000000100006838         ldr        w9, [sp, #0x8]
 ==>比较w8、w9，即比较w0、w1（cmp是减法，但不影响目标寄存器w8、w9，只看减法结果，修改标记寄存器）
 000000010000683c         cmp        w8, w9
 //如果是小于等于，就跳到到 loc_100006858 执行，如果是大于，则直接往下执行
 0000000100006840         b.le       loc_100006858
 0000000100006844         ldr        w8, [sp, #0xc]
 0000000100006848         adrp       x9, #0x100008000
 000000010000684c         add        x9, x9, #0xe90                              ; _g
 0000000100006850         str        w8, x9
 //硬跳，规避小于等于的代码，跳到loc_100006868
 0000000100006854         b          loc_100006868
                      loc_100006858:
 0000000100006858         ldr        w8, [sp, #0x8]                              ; CODE XREF=_func+24
 000000010000685c         adrp       x9, #0x100008000
 0000000100006860         add        x9, x9, #0xe90                              ; _g
 0000000100006864         str        w8, x9
                      loc_100006868:
 0000000100006868         add        sp, sp, #0x10                               ; CODE XREF=_func+44
 000000010000686c         ret

这是典型的if-else，通过hopper查看其汇编代码如下

将上述汇编代码进行还原

<!--1、还原-->
int cc = 12;
void func2(int a, int b){
//==>拉伸栈空间
//0000000100006828         sub        sp, sp, #0x10
//==>w0、w1数据入栈
//000000010000682c         str        w0, [sp, #0xc]
//0000000100006830         str        w1, [sp, #0x8]
//==>从栈中读取数据到w8、w9
//0000000100006834         ldr        w8, [sp, #0xc]
//0000000100006838         ldr        w9, [sp, #0x8]
    int w8 = a;
    int w9 = b;
//==>比较w8、w9，即比较w0、w1（cmp是减法，但不影响目标寄存器w8、w9，只看减法结果，修改标记寄存器）
//000000010000683c         cmp        w8, w9
////如果是小于等于，就跳到到 loc_100006858 执行，如果是大于，则直接往下执行
//0000000100006840         b.le       loc_100006858
    if (w8 > w9 ) {//大于
        //0000000100006844         ldr        w8, [sp, #0xc]
        //0000000100006848         adrp       x9, #0x100008000
        //000000010000684c         add        x9, x9, #0xe90                              ; _g
        //0000000100006850         str        w8, x9
        cc = w8;//此时的w8是a
        ////硬跳，规避小于等于的代码，跳到loc_100006868
        //0000000100006854         b          loc_100006868
    }else{//小于等于
        //                     loc_100006858:
        //0000000100006858         ldr        w8, [sp, #0x8]
        //000000010000685c         adrp       x9, #0x100008000
        //0000000100006860         add        x9, x9, #0xe90                              ; _g
        //0000000100006864         str        w8, x9
        cc = w8;//此时的w8是b
    }
//                     loc_100006868:
//0000000100006868         add        sp, sp, #0x10
//000000010000686c         ret
}
<!--2、简化-->
int cc = 12;
void func2(int a, int b){
    if (a > b ) {//大于
        cc = a; 
    }else{//小于等于
        cc = b;
    }
}

cmp（Compare）比较指令

CMP把一个寄存器的内容和另一个寄存器的内容或立即数进行比较，但不存储结果，只是正确的更改标志(CMP后面跟的是B.LE，即else的条件)
一般CMP做完判断后会进行跳转，后面通常会跟上B指令

BL 标号：跳转到标号处执行
B.LT 标号：比较结果是小于（less than ），执行标号，否则不跳转
B.LE 标号：比较结果是小于等于（less than or equal to），执行标号，否则不跳转
B.GT 标号：比较结果是大于（greater than），执行标号，否则不跳转
B.GE 标号：比较结果是大于等于（greater than or equal to），执行标号，否则不跳转

- `B.EQ 标号`：比较结果是`等于`，执行标号，否则不跳转
- `B.NE 标号`：比较结果是不等于（not equal）,执行标号，否则不跳转
- `B.HI 标号`：比较结果是`无符号大于`，执行标号，否则不跳转
- `B.HS 标号`：比较结果是`无符号大于等于`，执行标号，否则不跳转

循环

循环常用的主要有for、while、do-while，下面来一一进行分析

do-while分析

分析以下do-while的代码

int main(int argc, char * argv[]) {
    int sum = 0;
    int i = 0;
    do{
        sum += 1;
        i++;
    }while (i<100);
}

通过hopper查看其汇编

汇编结束如下所示

结论：do-while循环：判断条件在后面，满足条件往外跳

while循环分析

int main(int argc, char * argv[]) {
    int sum = 0;
    int i = 0;
    while (i<100){
        sum += 1;
        i++;
    }
}

汇编如图所示

结论：while循环：判断条件在里面，不满足就往外跳

for循环分析

int main(int argc, char * argv[]) { 
    int sum = 0;
    for (int i = 0; i < 100; i++) {
        sum += 1;
    }
}

此时和while的汇编是一样的

结论：for循环很像：判断条件在里面，不满足就往外跳

总结

全局变量和常量

获取全局变量和常量时，会出现adrp和add两条指令获得一个地址的情况
ADRP（Address Page）

adrp x0，1

将PC寄存器的低12位清零
将1的值，左移12位
以上两个结果相加放入x0寄存器

通过ADD指令获取这页内存中的偏移值

条件判断

CMP把一个寄存器的内容和另一个寄存器的内容或立即数进行比较，但不存储结果，只是正确的更改标志(CMP后面跟的是B.LE，即else的条件)
一般CMP做完判断后会进行跳转，后面通常会跟上B指令

BL 标号：跳转到标号处执行
B.LT 标号：比较结果是小于（less than ），执行标号，否则不跳转
B.LE 标号：比较结果是小于等于（less than or equal to），执行标号，否则不跳转
B.GT 标号：比较结果是大于（greater than），执行标号，否则不跳转
B.GE 标号：比较结果是大于等于（greater than or equal to），执行标号，否则不跳转
B.EQ 标号：比较结果是等于，执行标号，否则不跳转
B.NE 标号：比较结果是不等于（not equal）,执行标号，否则不跳转
B.HI 标号：比较结果是无符号大于，执行标号，否则不跳转
B.HS 标号：比较结果是无符号大于等于，执行标号，否则不跳转

循环

do-while循环：判断条件在后面，满足条件往外跳
for循环和while循环很像：判断条件在里面，不满足就往外跳

iOS逆向 03：循环选择指针（上）