iOS逆向 04：OC反汇编（上）

这是我参与更文挑战的第5天，活动详情查看：更文挑战

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

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

编译器优化

设置

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

案例分析

有以下代码

int main(int argc, char * argv[]) {
    
    int a = 1;
    int b = 2;
}

在没有优化情况下的汇编如下
将优化方案从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：对结果没有任何影响的代码会被编译器优化】 修改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);
}

此时如果优化掉sum，对执行结果是有影响。可以发现sum函数被优化掉了，优化成了一个结果 修改2-汇编查看

指针

在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作为地址取值，以下是对应的汇编分析指针的基本用法-01

*如果修改成 (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类型的步长 指针的基本用法-04

如果将 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)是等价的

总结

编译器优化：
- 1、设置：BuildSetting->Optimization Level
- 2、优化原则：对结果没有任何影响的代码会被编译器优化
- 3、编译器优化，本质是LLVM的优化过程，实际上优化的是汇编代码（可以理解为汇编指令会减少）
指针：
- 1、指针的自增自减和指向的数据类型宽度有关，是按照指向的数据类型来运算的（即指针的宽度 - 步长）
- 2、指针的运算单位是指向的数据类型的宽度
- 3、指针可以通过if-else比大小，因为类型是可以相互转换的