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

作者: Style_月月 | 来源:发表于2021-04-12 13:15 被阅读0次

iOS 底层原理 + 逆向文章汇总

本文的主要目的是理解汇编中全局变量、常量的存储，以及如何将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函数的汇编代码

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

image
- 查看x0是否为“haha”，通过调试得以验证，x0存的是haha的地址
  image
- 查看其地址：x 0x000000010098bf9f，属于字符串的常量区（即左边是右边字符串的ASCII码）
  image

其中重点分析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以下的汇编代码
image
- ldur w8, [x29, #-0x4] ：拿出栈中的数据，即1
  image
- adrp + add + ldr :拿出0x10098ce98内存地址的数据，将x9的数据给w10。这样就拿到了全局变量g
  image

反汇编分析

示例代码如下

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的包

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

image
在hopper中搜索func

image
拷贝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;
}

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

image

其中

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

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

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

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

image

总结

获取全局变量和常量时，会出现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查看其汇编代码如下

image

将上述汇编代码进行还原

<!--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查看其汇编

image
汇编结束如下所示

image

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

while循环分析

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

汇编如图所示

image

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

for循环分析

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

此时和while的汇编是一样的

image

结论：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：循环选择指针（上）

全局变量

案例分析

反汇编分析

总结

条件

cmp（Compare）比较指令

循环

do-while分析

while循环分析

for循环分析

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

逆向学习