iOS逆向之OC反汇编（上）

本文主要讲解编译器的优化以及指针的汇编

编译器优化

设置

可在项目的BuildSetting->Optimization Level中找到，一般的优化方案选择FS（Fastest，Smallest）

案例分析

有以下代码

int main(int argc, char * argv[]) {

    int a = 1;
    int b = 2;
}

• 在没有优化情况下的汇编如下

  image

• 将优化方案从None改成FS，汇编如下

  

修改1：main中调用

int sum(int a, int b){
    return a + b;
}

int main(int argc, char * argv[]) {

    sum(1, 2);
}

查看此时是否有1，2，发现也没有sum有关的汇编代码，其优化原则是这样的：去掉sum对程序运行的结果没有影响【原则1：对结果没有任何影响的代码会被编译器优化】

修改2：打印sum的结果

int sum(int a, int b){
    return a + b;
}

int main(int argc, char * argv[]) {
    int a = sum(1, 2);
    printf(@"%d", a);
}

首先作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS开发交流群：130595548，不管你是小白还是大牛都欢迎入驻 ，让我们一起进步，共同发展！（群内会免费提供一些群主收藏的免费学习书籍资料以及整理好的几百道面试题和答案文档！）

此时如果优化掉sum，对执行结果是有影响。可以发现sum函数被优化掉了，优化成了一个结果

指针

在OC中，无论参数还是返回值，如果传入/返回的是对象，这些对象都是指针，下面来看看指针的反汇编

void func(){
    int *a;
    printf("%lu", sizeof(a)); //sizeof不是函数，是一个符号
}

int main(int argc, char * argv[]) {
    func();
}

分析以上代码的汇编代码

指针常识

指针自增自减运算

void func(){
    int *a;
    a = (int *)100;
    a++;
    printf("%d", a); 
}
<!--打印结果-->
104

• 问题：a++之后，a是多少？

  • 是104，因为指针的自增自减和指向的数据类型宽度有关，即因为a指向的数据是int，int的宽度是4个字节

• 修改1、如果将int改成char，结果是多少呢？

  • 因为a指向的数据是char，char的宽度是1个字节

void func(){
    char *a;
    a = (char *)100;
    a++;
    printf("%d", a); 
}

<!--打印结果-->
101

• 修改2：如果int改成int呢，结果是多少？*
  • 因为a指向的数据是int*，是一个指针，指针的宽度是8个字节

void func(){
    int **a;
    a = (int **)100;
    a++;//指针的自增自减和执行的数据类型宽度有关
    printf("%d", a); 
}

<!--打印结果-->
108

• 修改3：如果将 a++ 改成 a = a + 1 呢？
  • 自增自减和编译器有关！
  • 注：这里的+1，加的是一个步长，而a的步长是（int*）即8个字节

void func(){
    int **a;
    a = (int **)100;
//    a++;//指针的自增自减和执行的数据类型宽度有关
    a = a + 1;
    printf("%d", a); 
}

<!--打印结果-->
108

指针和指针求差值

有以下代码，两个指针相减的结果是多少？

void func(){
    int *a;
    a = (int *)100;
    int *b;
    b = (int *)200;
    int x = a - b;
    printf("%d", x); 
}

<!--打印结果-->
-25

• 因为 （100-200）/int的宽度 = -100/4 = -25

• 注：指针的运算单位是执行的数据类型的宽度

• 问题：指针是否可以 if-else 比大小?

  • 可以的，我们知道类型是可以相互转换的，但是结构体和基本类型是不能相互转换的
  • 任何类型都可以使用&（取地址符号）取值

void func(){
    int *a;
    a = (int *)100;
    int *b;
    b = (int *)200;
    if (a > b) {
        printf("a > b");
    }else{
        printf("a <= b");
    }
}

<!--打印结果-->
a <= b

指针的反汇编

定义一个指针，并赋值，查看其汇编代码

void func(){
    int *a;
    int b = 10;
    a = &b;
}

以下是代码运行的汇编以及分析

指针数组

问题1：通过下面这种方式能否将数组中的数组正确取出？

void func(){
    int arr[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5 ; i++) {
//        printf("%d", arr[i]);
        printf("%d",*(arr + i));//这里使用arr++不可以，因为编译器不允许
    }
}

运行发现是可以的，所以有以下对等关系：

• 对等关系：int *a == arr[0] == arr

问题2：如果将arr赋值给指针a，for循环中 a++是否可以？

void func(){
    int arr[5] = {1, 2, 3, 4, 5};
    int *a = arr;
    for (int i = 0; i < 5 ; i++) {
//        printf("%d", arr[i]);
        printf("%d",*(a++));
    }
}

运行发现也是可以的

指针的基本用法

• 定义一个指针，并从指针中取值

void func(){
    char *p1;
    char c = *p1;//取p1的值
}

运行发现，崩溃报错：原因是以0作为地址取值，以下是对应的汇编分析

*如果修改成 (p1+0) 的形式呢？

void func(){
    char *p1;
    char c = *p1;//取p1的值
    char d = *(p1+0);
}

查看汇编代码：

• p1指针指向 sp+0x8栈区域里的值，相当于 p1 -> （X8)0x0

• c 相当于取X8的值，即 [X8]

• d 同样的是取X8的值，即 [X8]

  

*如果改成 (p1+1) 的形式呢？

void func(){
    char *p1;
    char c = *p1;//取p1的值
    char d = *(p1+1);
}

查看汇编：

• p1指针指向 sp+0x8栈区域里的值，相当于 p1 -> （X8)0x0

• c 相当于取X8的值，即 [X8]

• d 同样的是取X8的值，即 [X8+0x1]

  

如果将 char类型 改成 int类型 呢？

void func(){
    int *p1;
    int c = *p1;//取p1的值
    int d = *(p1+1);
}

以下是func函数的汇编，此时d是取[x8+0x4]地址的值，因为int是4个字节，0x4就是int类型的步长

如果将 int 类型改成 int 类型呢？*

void func(){
    int **p1;
    int *c = *p1;//取p1的值
    int *d = *(p1+1);
}

• 查看汇编，此时d是取[x8+0x8]地址的值，因为int*是一个指针，占8个字节，0x8就是int*类型的步长

  

• int** 需要拉伸多少个字节？
  实际需要3x8=24字节，由于是汇编是16字节对齐，所以需要sub减0x20

• 此时多增加一个int* p2 ，栈空间拉伸多少字节？
  发现仍然是0x20

  

• 再多增加一个char c1呢？
  此时超过了32，所以需要再多拉伸16字节

  

多级指针

1、二级指针

有以下代码

void func(){
    int **p1;
    int c = **p1;
}

运行崩溃，查看其汇编

• x8 取的是 *p1（即一级指针的地址）的值

• w9 取的是 **p1（即二级指针的地址） 的值

  

2、多级指针加法运算

void func(){
    char **p1;
//    char c = p1+2; //此时的+2是 +0x10（执行数据类型是char*）
    char c = *(*(p1 + 2) + 2);//最外层的+2，是加0x2（执行数据类型是char）
}

• 此时c中的 +2是 +0x10（执行数据类型是char*）

• 此时d中最外层的+2，是加0x2（执行数据类型是char）

如果是下面这种形式呢？

void func(){
    char **p1;
//    char c = p1+2; //此时的+2是 +0x10（执行数据类型是char*）
//    char c = *(*(p1 + 2) + 2);//最外层的+2，是加0x2（执行数据类型是char）
    char c2 = p1[1][2]; //与上面等价
}

• p1[1] 此时的1表示0x8（类型是char*）

• p1[1][2] 此时的2表示 0x2（类型是char）

  

  从汇编结果来看p1[1][2]与*(*(p1 + 2) + 2)是等价的

总结

首先作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS开发交流群：130595548，不管你是小白还是大牛都欢迎入驻 ，让我们一起进步，共同发展！（群内会免费提供一些群主收藏的免费学习书籍资料以及整理好的几百道面试题和答案文档！）

• 编译器优化：

  • 1、设置：BuildSetting->Optimization Level

  • 2、优化原则：对结果没有任何影响的代码会被编译器优化

  • 3、编译器优化，本质是LLVM的优化过程，实际上优化的是汇编代码（可以理解为汇编指令会减少）

• 指针：

  • 1、指针的自增自减和指向的数据类型宽度有关，是按照指向的数据类型来运算的（即指针的宽度 - 步长）

  • 2、指针的运算单位是指向的数据类型的宽度

  • 3、指针可以通过if-else比大小，因为类型是可以相互转换的