指针&MachO文件

指针

• 指针自增、自减的结果，其实就是指针指向的数据类型宽度决定的！
• 指针加上或减去一个整数的结果，其实就是指针指向的数据类型宽度决定的！
• 指针求差，得到的结果是整形，其结果和指针指向的数据类型宽度有关！
• 这也就是指针的特点！ 它的运算单位 是数据类型的宽度！

指针源码的分析

//-------------------------------"  main.m  "-------------------------------
//  main.m
//  001--指针的宽度
//
//  Created by H on 2018/4/27.
//  Copyright © 2018年 H. All rights reserved.
/**
  *  指针 64位中 占8个(64Bit)字节!!
  *  指针运算!! 根据所指向的数据类型来的!
  *  编译器决定了指针不能做乘法和除法!
  *  指针 运算结果,由它所指向的数据类型的宽度 决定!!  永远都是去掉一个*(指针)
  */


#import <UIKit/UIKit.h>
#import "AppDelegate.h"

void func(){
    
    char * * p1;
//    char c = **p1;
    char c = *(*(p1 + 1) + 2);
    char c1 = p1[1][2];
    
   /*
    sub sp,sp,#0x10
    ldr x8,[sp,#0x8]    // x8 放入内存 
    ldr x?,[x8]
    ldr w?,[x?]
    */
}

• 多级指针

//---------------------- 多级指针 ----------------------
void func6(){
    
    char **p1;
    char c = **p1;  // ldr w9,[x8]    
    /*
     sub sp,sp,#0x10
     ldr x8,[sp,#0x8]    // x8 放入内存  即：address = x8 = **p1
     ldr x?,[x8]         // x? = [x8]  即：*p1 读取指针
     ldr w?,[x?]         // w? = [x?]  即：p1  读取最终变量
     */
    
    BOOL num = YES;
    if (num) {
        //char **cc = "ABCDE"; 
        char cc[5] = "ABCDE";
        char **p1 = *cc;
        char c = **p1;
        //char **p2= p1;
//        printf("---p2= %c\n",**p2);
//        printf("---p2= %c\n",*(*p2 +8));
//        printf("---p2= %c\n",*(*p2 +16));
        
        printf("---p2= %c\n",p1[1][2] );
        
    }else {
        char **p1;
        char c = *(*(p1 + 1) + 2);     
        char c1= p1[1][2];
    }
    
}

• 单级指针

//---------------------- 单级指针 ----------------------
void func5(){
    char *p1;
                        // ldr x8, [sp,#0x8], 每次都拉伸8个字节
    char c = *p1;       // ldr w9,[x8]    
    char c1= p1[0];     // ldr w9,[x8]
    char d = *(p1 + 1); // ldr w9,[x8,#0x1]    
    char d1= p1[1];     // ldr w9,[x8,#0x1]
}

void func4(){
    char *p1;
    char c1 = *p1;       //[x8]会崩，没有初始化p1,空指针，取不出地址
    char d1 = *(p1+1);   //[x8,#x01] char 占一个字节
    
    int *p2;
    int c2 = *p2;       //[x8]会崩，没有初始化p2,空指针，取不出地址
    int d2 = *(p2+1);   //[x8,#x04]
    
    
    // 拉伸空间-1
    int **p3;
    int *c3 = *p3;       //[x8]会崩，没有初始化p3,空指针，取不出地址
    int *d3 = *(p3+1);   //[x8,#x08]
    // sub sp,sp #0x20   --->   int*、int*、int*：3个指针* 24个字节，拉伸32个字节，
    // 够用了（#0x20 = 2*16+0 = 32）
    
    
    // 拉伸空间-2
    char char4;
    int **p4;
    int **p4_2;
    int *c4 = *p4;       //[x8]会崩，没有初始化p4,空指针，取不出地址
    int *d4 = *(p4+1);   //[x8,#x08]
    // sub sp,sp #0x30   --->   char4、int*、int*、int*、int*：4个指针* 33(32+1)个字节，拉伸48个字节，
    // 够用了（#0x30 = 3*16+0 = 48）
    
    /*
     * 注意: sp是16个字节对齐的,即使多一个字节，也要拉伸 16个字节
     */    
}

• 指针字节

---------------------- 指针字节 ----------------------
void func3(){
    int arr[5]= {1,2,3,4,5};
    int *a = arr; // a 指针，指向 arr 的首地址
    // int *a == &arr[0] == arr;

    for (int i=0; i<5; i++) {
        // printf("---p= %d \n",*(arr+i)); // 取值
        // 同上
        printf("---p= %d \n",*(a++)); // 取值        
    }
}

void func2(){
    int a= 10;
    int *b = &a;
}
void func1(){
    
    int *p;
    p = (int*)100;
    p++; //p = 104;
    printf("---p= %lu \n",sizeof(p)); //p是指针：8个字节
    printf("---p= %d \n\n",p);
    
    char *p1;
    p1 = (char*)100;
    p1++; //p1 = 101;
    printf("---p1= %d \n",p1);

    
    char** p2;
    p2 = (char**)100;
    p2++; //p2 = 108; 
    printf("---p2= %d \n\n ",p2);

    
    int *a;
    a = (int*)100;
    
    int *b;
    b = (int*)200;
    
    int x = a- b;  //x = (100-200)/4 = -25
    printf("---x= %d \n ",x);
    
    int *y = b- 199;  //y
    printf("---y= %d \n\n",y);
    

    if (a > b) {
        printf("a > b \n");
    }else {
    }
}

int main(int argc, char * argv[]) {
//    func();
//    func1();
//    func3();
    func6();
    
}

• 指针：内存分析

  //多级指针
  char **p1;
  char c = *(*(p1 + 1) + 2);     
  char c1= p1[1][2];

多级指针内存分析

//单级指针
void func5(){
    char *p1;
                        // ldr x8, [sp,#0x8], 每次都拉伸8个字节
    char c = *p1;       // ldr w9,[x8]    
    char c1= p1[0];     // ldr w9,[x8]
    char d = *(p1 + 1); // ldr w9,[x8,#0x1]    
    char d1= p1[1];     // ldr w9,[x8,#0x1] 
}

单级指针内存分析

关于汇编,重点.只能是带大家入门.

逆向原理

动态调试 通过界面调试Cycript\Xcode LLDB!
静态分析 利用我们之前学习的汇编代码,分析三方APP的源码!
代码注入 注入的其实是动态库!HOOK代码 改变原来程序的执行流程!
重签名 安装在非越狱手机上面

class-dump

$ class-dump -H MachO文件Path -o 头文件路径
链接：class-dump官网

MachO文件

官方介绍总共有11种格式! 是 Mach Object的缩写,是Mac\iOS 上用于存储程序,库的标准格式!
常见的格式:

• 1.可执行文件
• 2.objcet
  • .o 文件(目标文件)
  • .a 静态库文件.其实就是N个.o文件的集合
• 3.DYLIB: 动态库文件
  • dylib
  • framework
• 4.动态连接器
• 5.DSYM

动态库共享缓存

为了提高性能,系统的动态库文件都存在了动态库共享缓存里面!

动态加载器(dyld)

• dynamic linker
• dynamic loadel

拆分二进制文件

经常用于整合静态库

瘦身

$ lipo 002--可执行文件 -thin armv7 -output macho_armv7
$ lipo 002--可执行文件 -thin armv64 -output macho_armv64

整合

$ lipo -create macho_armv7 macho_arm64 -output machO_v7_64