零时

最新推荐文章于 2021-03-31 18:15:35 发布
最新推荐文章于 2021-03-31 18:15:35 发布
阅读量605 收藏
点赞数
分类专栏： ios 文章标签： 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y138828/article/details/53766687
版权 
//
//  _OVWork.cpp
//  asm
//
//  Created by 罗何 on 16/12/20.
//  Copyright © 2016年 罗何. All rights reserved.
//

#import <UIKit/UIKit.h>


#include <string>
#include <vector>
#include <set>
#include <map>

#include <mach-o/arch.h>
#include <mach-o/loader.h>
#include <mach-o/fat.h>
#include <mach-o/nlist.h>
#include <mach-o/reloc.h>

#if !__x86_64__ || !__i386__
#include "x86_64_reloc.h"
#endif

#include <mach-o/arm/reloc.h>
#include <mach-o/arm64/reloc.h>
#include <mach-o/ranlib.h>
#include <mach-o/compact_unwind_encoding.h>
#include <mach-o/swap.h>

#import <objc/runtime.h>

#include <pthread.h>
#include <dlfcn.h>
#include <err.h>
#include <sys/mman.h>
#include <mach/mach_init.h>
#include <mach/mach_host.h>
#include <algorithm>

static int _get_main_cup_type(int *sub_type){
    *sub_type = -1;
    host_basic_info_data_t hostInfo;
    mach_msg_type_number_t infoCount = HOST_BASIC_INFO_COUNT;
    kern_return_t ret = host_info(mach_host_self(),HOST_BASIC_INFO,(host_info_t)&hostInfo,&infoCount);
    return ret == KERN_SUCCESS ?(*sub_type = hostInfo.cpu_subtype,hostInfo.cpu_type ): -1;
}

#define MY_MMAP         ((void * (*)(void *,size_t, int, int, int, off_t))dlsym(RTLD_DEFAULT, "mmap"))
#define MY_MPROTECT     ((int (*)(void *,size_t,int))dlsym(RTLD_DEFAULT, "mprotect"))
#define MY_MUNMAP       ((int (*)(void *,size_t))dlsym(RTLD_DEFAULT, "munmap"))

#define MATCH_STRUCT(obj,location) \
    struct obj const * obj = (struct obj *)(bytes + location);

static uint8_t read_uint8(NSRange &range,uint8_t *bytes){
    uint8_t buffer = *(uint8_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(uint8_t));
    return buffer;
}

static uint16_t read_uint16(NSRange &range,uint8_t *bytes){
    uint16_t buffer = *(uint16_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(uint16_t));
    return buffer;
}

static uint32_t read_uint32(NSRange &range,uint8_t *bytes){
    uint32_t buffer = *(uint32_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(uint32_t));
    return buffer;
}

static uint64_t read_uint64(NSRange &range,uint8_t *bytes){
    uint64_t buffer = *(uint64_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(uint64_t));
    return buffer;
}

static int8_t read_int8(NSRange &range,uint8_t *bytes){
    int8_t buffer = *(int8_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(int8_t));
    return buffer;
}

static int16_t read_int16(NSRange &range,uint8_t *bytes){
    int16_t buffer = *(int16_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(int16_t));
    return buffer;
}

static int32_t read_int32(NSRange &range,uint8_t *bytes){
    int32_t buffer = *(int32_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(int32_t));
    return buffer;
}

static int64_t read_int64(NSRange &range,uint8_t *bytes){
    int64_t buffer = *(int64_t *)(bytes + NSMaxRange(range));
    range = NSMakeRange(NSMaxRange(range),sizeof(int64_t));
    return buffer;
}

static uint64_t read_sleb128(NSRange &range,uint8_t *bytes){
    range.location = NSMaxRange(range);
    uint8_t * p = bytes + range.location, *start = p;
    
    int64_t result = 0;
    int bit = 0;
    uint8_t byte;
    
    do {
        byte = *p++;
        result |= ((byte & 0x7f) << bit);
        bit += 7;
    } while (byte & 0x80);
    
    // sign extend negative numbers
    if ( (byte & 0x40) != 0 )
    {
        result |= (-1LL) << bit;
    }
    
    range.length = (p - start);
    return result;
}

static uint64_t read_uleb128(NSRange &range,uint8_t *bytes){
    range.location = NSMaxRange(range);
    uint8_t * p = bytes + range.location, *start = p;
    
    uint64_t result = 0;
    int bit = 0;
    
    do {
        uint64_t slice = *p & 0x7f;
        
        if (bit >= 64 || slice << bit >> bit != slice)
            [NSException raise:@"uleb128 error" format:@"uleb128 too big"];
        else {
            result |= (slice << bit);
            bit += 7;
        }
    }
    while (*p++ & 0x80);
    
    range.length = (p - start);
    return result;
}

const char *read_string(NSRange &range,uint8_t *bytes){
    range.location = NSMaxRange(range);
    const char *string = (const char *)(bytes + range.location);
    range.length = strlen(string) + 1;
    return string;
}

static uint64_t alignMem(uint64_t p, uint64_t a) {
    a--;
    return (p + a) & ~a;
}

static void undefinedFunction() {
    fprintf(stderr, "Undefined function called\n");
    abort();
}

//------------------------------------------------//

static void doRebase(uint64_t address,uint64_t slider,std::vector<uint64_t> &sel_ref){
    uint8_t **ptr = (uint8_t **)(slider + address);
    std::vector<uint64_t>::iterator iter = std::find(sel_ref.begin(), sel_ref.end(), (uint64_t)*ptr);
    if(iter != sel_ref.end()){
        const char *real_name = (const char *)(slider + *ptr);
        char * exisit_sel = (char *)sel_getUid(real_name);
        if(!exisit_sel){ exisit_sel = (char *)sel_registerName(real_name); }
        *ptr = (uint8_t *)exisit_sel;
    }else{
        *ptr += slider;
    }
}

static void doBind(uint64_t address,uint64_t addend,uint64_t slide,const char *symbolName){
    if(symbolName && symbolName[0]=='_'){
        const char *sym_string = symbolName + 1;
        
        int8_t **ptr = (int8_t **)(slide + address);
        int8_t*  sym = (int8_t*)dlsym(RTLD_DEFAULT, sym_string);
        if(!sym){
            sym = (int8_t*)&undefinedFunction;
        }
        sym += addend;
        *ptr = sym;
    }
}

enum BindNodeType {NodeTypeBind, NodeTypeWeakBind, NodeTypeLazyBind};

void createBinding(uint64_t slide,uint32_t location,uint32_t length,uint64_t baseAddress,bool is_64,uint8_t *bytes,uint32_t ncmds,uint64_t segmentOffset,BindNodeType nodeType,
                   std::map<uint64_t,std::pair<uint32_t,const char *> > &bind_64,
                   std::map<uint64_t,std::pair<uint32_t,const char *> > &bind){
    NSRange range = NSMakeRange(location,0);
    BOOL isDone = NO;
    int32_t libOrdinal = 0;
    uint32_t type = 0;
    int64_t addend = 0;
    const char * symbolName = nil;
    uint32_t symbolFlags = 0;
    uint32_t doBindLocation = location;
    uint64_t ptrSize = (!is_64 ? sizeof(uint32_t) : sizeof(uint64_t));
    uint64_t address = baseAddress;
    
    while (NSMaxRange(range) < location + length && isDone == NO) {
        uint8_t byte = *(bytes + NSMaxRange(range));
        range  = NSMakeRange(NSMaxRange(range), sizeof(uint8_t));
        uint8_t opcode = byte & BIND_OPCODE_MASK;
        uint8_t immediate = byte & BIND_IMMEDIATE_MASK;
        
        switch (opcode) {
            case BIND_OPCODE_DONE:
                if(nodeType != NodeTypeLazyBind){
                    isDone = YES;
                }
                doBindLocation = NSMaxRange(range);
                break;
            case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
                libOrdinal = immediate;
                break;
                
            case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
                libOrdinal = read_uleb128(range,bytes);
                break;
                
            case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: {
                if (immediate == 0) { libOrdinal = 0; }
                else {
                    int8_t signExtended = immediate | BIND_OPCODE_MASK; // This sign extends the value
                    libOrdinal = signExtended;
                }
            } break;
                
            case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
                symbolFlags = immediate;
                symbolName = read_string(range, bytes);
                break;
                
            case BIND_OPCODE_SET_TYPE_IMM:
                type = immediate;
                break;
                
            case BIND_OPCODE_SET_ADDEND_SLEB:
                addend = read_sleb128(range,bytes);
                break;
                
            case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: {
                uint32_t segmentIndex = immediate;
                uint64_t val = read_uleb128(range,bytes);
                if (segmentIndex >= ncmds){
                    [NSException raise:@"Segment" format:@"index is out of range %u", segmentIndex];
                }

                for(uint32_t i = 0;i < ncmds;i++){
                    MATCH_STRUCT(load_command,segmentOffset)
                    if(i == segmentIndex){
                        switch (load_command->cmd) {
                            case LC_SEGMENT:{
                                MATCH_STRUCT(segment_command, segmentOffset)
                                address = segment_command->vmaddr + val;
                            }break;
                            case LC_SEGMENT_64:{
                                MATCH_STRUCT(segment_command_64,segmentOffset)
                                address = segment_command_64->vmaddr + val;
                            }break;
                            default:break;
                        }
                    }
                    segmentOffset += load_command->cmdsize;
                }
            } break;
                
            case BIND_OPCODE_ADD_ADDR_ULEB: {
                uint64_t val = read_uleb128(range,bytes);
                address += val;
            } break;
                
            case BIND_OPCODE_DO_BIND: {
//                is_64 ? bind_64.insert(std::make_pair(address, std::make_pair(addend, symbolName))) : bind.insert(std::make_pair(address, std::make_pair(addend, symbolName)));
                doBind(address, addend, slide, symbolName);
                
                doBindLocation = NSMaxRange(range);
                address += ptrSize;
            } break;
                
            case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: {
                uint32_t startNextBind = NSMaxRange(range);
                uint64_t val = read_uleb128(range,bytes);
//                is_64 ? bind_64.insert(std::make_pair(address, std::make_pair(addend, symbolName))) : bind.insert(std::make_pair(address, std::make_pair(addend, symbolName)));
                doBind(address, addend, slide, symbolName);
                doBindLocation = startNextBind;
                address += ptrSize + val;
            } break;
                
            case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: {
                uint32_t scale = immediate;
//                is_64 ? bind_64.insert(std::make_pair(address, std::make_pair(addend, symbolName))) : bind.insert(std::make_pair(address, std::make_pair(addend, symbolName)));
                doBind(address, addend, slide, symbolName);
                doBindLocation = NSMaxRange(range);
                address += ptrSize + scale * ptrSize;
            } break;
                
            case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:  {
                uint32_t startNextBind = NSMaxRange(range);
                uint64_t count = read_uleb128(range,bytes);
                uint64_t skip = read_uleb128(range,bytes);
                
                for (uint64_t index = 0; index < count; index++) {
//                    is_64 ? bind_64.insert(std::make_pair(address, std::make_pair(addend, symbolName))) : bind.insert(std::make_pair(address, std::make_pair(addend, symbolName)));
                    doBind(address, addend, slide, symbolName);
                    doBindLocation = startNextBind;
                    address += ptrSize + skip;
                }
            } break;
            default:
                [NSException raise:@"Bind info" format:@"Unknown opcode (%u %u)",
                 ((uint32_t)-1 & opcode), ((uint32_t)-1 & immediate)];
        }
        
    }
}


void printSymbols(const char *symbolName, uint32_t location,uint32_t skip,uint64_t baseAddress,uint8_t *bytes){
    NSRange range = NSMakeRange(location + skip,0);
    uint8_t terminalSize =  *(bytes + NSMaxRange(range));
    range  = NSMakeRange(NSMaxRange(range), sizeof(uint8_t));
    if (terminalSize != 0) {
        uint32_t terminalLocation = NSMaxRange(range);
        uint64_t flags = read_uleb128(range,bytes);
        uint64_t offset = read_uleb128(range,bytes);
        printf("address:%lld symbolName:%s\n",baseAddress + offset,symbolName);
        range = NSMakeRange(terminalLocation, terminalSize);
    }
    uint8_t childCount = read_uint8(range,bytes);
    while (childCount-- > 0) {
        const char *label = read_string(range, bytes);
        uint64_t skip = read_uleb128(range, bytes);
        printSymbols(label, location, skip, baseAddress, bytes);
    }
}

void parserSymbol_total(NSURL *absoluteURL,NSString *typeName, NSError **outError){
    if(!absoluteURL) return;
    
    int cpu_type = -1,cpu_sub_type = -1;
    cpu_type = _get_main_cup_type(&cpu_sub_type);
    
    if(cpu_type == -1){ return; }
    
    bool is_64 = sizeof(void *) == 8 ? true : false;
    if(is_64){cpu_type |= CPU_ARCH_ABI64;}
    
    NSMutableData *map_data = [NSMutableData dataWithContentsOfURL:absoluteURL options:NSDataReadingMappedAlways error:outError];
    uint8_t *bytes = (uint8_t *)[map_data bytes];
    
    uint32_t imageOffset = 0;
    uint32_t      ncmds = 0;
    
    uint32_t magic = *(uint32_t*)(bytes);
    switch (magic){
        case FAT_MAGIC:
        case FAT_CIGAM:{
            struct fat_header fat_header = *(struct fat_header *)bytes;
            if(magic == FAT_CIGAM){swap_fat_header(&fat_header, NX_LittleEndian);}
            for(uint32_t nimg = 0;nimg < fat_header.nfat_arch;nimg++){
                struct fat_arch fat_arch = *(struct fat_arch *)(bytes + sizeof(struct fat_header) + nimg * sizeof(struct fat_arch));
                swap_fat_arch(&fat_arch, 1, NX_LittleEndian);
                imageOffset = fat_arch.offset;
                uint32_t inline_magic = *(uint32_t*)(bytes + fat_arch.offset);
                switch (inline_magic) {
                    case MH_MAGIC:
                    case MH_CIGAM:{
                        struct mach_header mach_header = *(struct mach_header *)(bytes + fat_arch.offset);
                        if (inline_magic == MH_CIGAM){swap_mach_header(&mach_header, NX_LittleEndian);}
                        if(mach_header.cputype == cpu_type){
                            ncmds = mach_header.ncmds;
                        }
                    }break;
                    case MH_MAGIC_64:
                    case MH_CIGAM_64:{
                        struct mach_header_64 mach_header_64 = *(struct mach_header_64 *)(bytes + fat_arch.offset);
                        if (inline_magic == MH_CIGAM_64){swap_mach_header_64(&mach_header_64, NX_LittleEndian);}
                        if(mach_header_64.cputype == cpu_type){
                            ncmds = mach_header_64.ncmds;
                        }
                    }break;
                    default:{ break;}
                }
            }
        } break;
            
        case MH_MAGIC:
        case MH_CIGAM: {
            struct mach_header mach_header = *(struct mach_header *)bytes;
            if (magic == MH_CIGAM){swap_mach_header(&mach_header, NX_LittleEndian);}
            if(mach_header.cputype == cpu_type){ ncmds = mach_header.ncmds; }
        } break;
            
        case MH_MAGIC_64:
        case MH_CIGAM_64: {
            struct mach_header_64 mach_header_64 = *(struct mach_header_64 *)bytes;
            if (magic == MH_CIGAM_64){swap_mach_header_64(&mach_header_64, NX_LittleEndian);}
            if(mach_header_64.cputype == cpu_type){ ncmds = mach_header_64.ncmds; }
        } break;
        default:{break;}
    }
    
    if(!ncmds) return;
    
    //----------------------------------------------------------------------------------------//
    uint64_t vmsize_total = 0;
    uint32_t fileOffset = imageOffset + (!is_64 ? sizeof(struct mach_header) : sizeof(struct mach_header_64));
    for (uint32_t ncmd = 0; ncmd < ncmds; ++ncmd){
        MATCH_STRUCT(load_command,fileOffset)
        switch (load_command->cmd) {
            case LC_SEGMENT:{
                MATCH_STRUCT(segment_command, fileOffset)
                if (!strcmp(segment_command->segname, SEG_PAGEZERO)) {  continue; }
                vmsize_total += alignMem(segment_command->vmsize, 0x1000);
            }break;
            case LC_SEGMENT_64:{
                MATCH_STRUCT(segment_command_64,fileOffset)
                if (!strcmp(segment_command_64->segname, SEG_PAGEZERO)) {  continue; }
                vmsize_total += alignMem(segment_command_64->vmsize, 0x1000);
            }break;
            default:break;
        }
        fileOffset += load_command->cmdsize;
    }
    
    if(vmsize_total == 0) return;
    void *mapped = MY_MMAP(NULL, vmsize_total, VM_PROT_READ | VM_PROT_WRITE, MAP_SHARED | MAP_ANON, 0, 0);
    if (mapped == MAP_FAILED) { err(1, "mmap(file) failed"); }
    uint64_t slide = (uint64_t)mapped;
    //----------------------------------------------------------------------------------------//
    
//    std::vector<uint64_t> rebases_64;
//    std::vector<uint64_t> rebases;
    
    std::map<uint64_t,std::pair<uint32_t,const char *> > bind_64;
    std::map<uint64_t,std::pair<uint32_t,const char *> > bind;
    
    std::vector<uint64_t> sel_ref_64;
    std::vector<uint64_t> sel_ref;
    
    std::vector<uint64_t>   dylibs_name_offset;
    
    struct section_64  const * __class_list_64 = nullptr,*__category_list_64 = nullptr;
    struct section  const * __class_list = nullptr,*__category_list = nullptr;
    
    struct dyld_info_command const * dyld_info_command = nullptr;
    uint64_t base_addr = 0;
    fileOffset = imageOffset + (!is_64 ? sizeof(struct mach_header) : sizeof(struct mach_header_64));
    for (uint32_t ncmd = 0; ncmd < ncmds; ++ncmd){
        MATCH_STRUCT(load_command,fileOffset)
        switch (load_command->cmd) {
            case LC_SEGMENT:{
                MATCH_STRUCT(segment_command, fileOffset)
                if (!strcmp(segment_command->segname, SEG_PAGEZERO)) {  continue; }
                int prot = 0;
                if (segment_command->initprot & VM_PROT_READ) { prot |= PROT_READ; }
                if (segment_command->initprot & VM_PROT_WRITE) { prot |= PROT_WRITE; }
                if (segment_command->initprot & VM_PROT_EXECUTE) { prot |= PROT_EXEC; }
                
                uint64_t filesize = segment_command->filesize;// alignMem(seg->filesize, 0x1000);
                if(filesize <= 0)continue;
                
                uint64_t vmaddr = segment_command->vmaddr + slide;
                
                void *ret = memcpy((void *)vmaddr, bytes + segment_command->fileoff + imageOffset, filesize);
                if(!ret){err(1, "memcpy fail\n");}
                
                if(MY_MPROTECT((void*)vmaddr, alignMem(segment_command->vmsize, 0x1000), prot) != 0){
                    printf("*********warning:********* change protect  fail:%d\n",errno);
                }
                
                if (segment_command->fileoff == 0 && segment_command->filesize != 0){
                    base_addr = segment_command->vmaddr;
                }
                
                for (uint32_t nsect = 0; nsect < segment_command->nsects; ++nsect){
                    uint32_t sectionloc = fileOffset + sizeof(struct segment_command) + nsect * sizeof(struct section);
                    MATCH_STRUCT(section,sectionloc)
                    
                    if(!strcmp(section->segname, "__OBJC2") ||
                       !strcmp(section->segname, "__DATA")){
                        if(!strcmp(section->sectname, "__class_list") ||
                           !strcmp(section->sectname, "__objc_classlist")){
                            __class_list = section;
                        }
                        else if (!strcmp(section->sectname, "__category_list") ||
                                 !strcmp(section->sectname, "__objc_catlist")){
                            __category_list = section;
                        }
                    }
                    
                    switch (section->flags & SECTION_TYPE) {
                        case S_LITERAL_POINTERS:{
                            NSRange range = NSMakeRange(section->offset + imageOffset,0);
                            while (NSMaxRange(range) < section->offset + imageOffset + section->size) {
                                uint64_t ptr = read_uint32(range,bytes);
                                sel_ref.push_back(ptr);
                            }
                        } break;
                        case S_MOD_INIT_FUNC_POINTERS:
                        case S_MOD_TERM_FUNC_POINTERS:
                        case S_LAZY_SYMBOL_POINTERS:
                        case S_NON_LAZY_SYMBOL_POINTERS:
                        case S_LAZY_DYLIB_SYMBOL_POINTERS:
                        case S_SYMBOL_STUBS:
                            break;
                        default:
                            break;
                    }
                    
                }
            }break;
            case LC_SEGMENT_64:{
                MATCH_STRUCT(segment_command_64,fileOffset)
                if (!strcmp(segment_command_64->segname, SEG_PAGEZERO)) {  continue; }
                int prot = 0;
                if (segment_command_64->initprot & VM_PROT_READ) { prot |= PROT_READ; }
                if (segment_command_64->initprot & VM_PROT_WRITE) { prot |= PROT_WRITE; }
                if (segment_command_64->initprot & VM_PROT_EXECUTE) { prot |= PROT_EXEC; }
                
                uint64_t filesize = segment_command_64->filesize;// alignMem(seg->filesize, 0x1000);
                if(filesize <= 0)continue;
                
                uint64_t vmaddr = segment_command_64->vmaddr + slide;
                
                void *ret = memcpy((void *)vmaddr, bytes + segment_command_64->fileoff + imageOffset, filesize);
                if(!ret){err(1, "memcpy fail\n");}
                
                if(MY_MPROTECT((void*)vmaddr, alignMem(segment_command_64->vmsize, 0x1000), prot) != 0){
                    printf("*********warning:********* change protect  fail:%d\n",errno);
                }
                
                if (segment_command_64->fileoff == 0 && segment_command_64->filesize != 0){
                    base_addr = segment_command_64->vmaddr;
                }
                
                for (uint32_t nsect = 0; nsect < segment_command_64->nsects; ++nsect){
                    uint32_t sectionloc = fileOffset + sizeof(struct segment_command_64) + nsect * sizeof(struct section_64);
                    MATCH_STRUCT(section_64,sectionloc)
                    
                    if(!strcmp(section_64->segname, "__OBJC2") ||
                       !strcmp(section_64->segname, "__DATA")){
                        if(!strcmp(section_64->sectname, "__class_list") ||
                           !strcmp(section_64->sectname, "__objc_classlist__DATA")){
                            __class_list_64 = section_64;
                        }
                        else if (!strcmp(section_64->sectname, "__category_list__DATA") ||
                                 !strcmp(section_64->sectname, "__objc_catlist")){
                            __category_list_64 = section_64;
                        }
                    }
                    
                    switch (section_64->flags & SECTION_TYPE) {
                        case S_LITERAL_POINTERS:{
                            NSRange range = NSMakeRange(section_64->offset + imageOffset,0);
                            while (NSMaxRange(range) < section_64->offset + imageOffset + section_64->size) {
                                uint64_t ptr = read_uint64(range,bytes);
                                sel_ref_64.push_back(ptr);
                            }
                        } break;
                        case S_MOD_INIT_FUNC_POINTERS:
                        case S_MOD_TERM_FUNC_POINTERS:
                        case S_LAZY_SYMBOL_POINTERS:
                        case S_NON_LAZY_SYMBOL_POINTERS:
                        case S_LAZY_DYLIB_SYMBOL_POINTERS:
                        case S_SYMBOL_STUBS:
                            break;
                        default:
                            break;
                    }
                    
                }
            }break;
            case LC_ID_DYLIB:
            case LC_LOAD_DYLIB:
            case LC_LOAD_WEAK_DYLIB:
            case LC_REEXPORT_DYLIB:
            case LC_LAZY_LOAD_DYLIB:
            case LC_LOAD_UPWARD_DYLIB:{
                MATCH_STRUCT(dylib_command,fileOffset)
                if (load_command->cmd != LC_ID_DYLIB) {
//                    dylibs_name_offset.push_back(fileOffset + dylib_command->dylib.name.offset);
                    NSRange range = NSMakeRange(fileOffset + dylib_command->dylib.name.offset, 0);
                    const char *dllName = read_string(range, bytes);
                    void *handle = dlopen(dllName, RTLD_LAZY | RTLD_GLOBAL);
                    if(!handle){
                        printf("warning: open dll fail ==> %s\n",dllName);
                    }
                }
            }break;
            case LC_DYLD_INFO:
            case LC_DYLD_INFO_ONLY: dyld_info_command = (struct dyld_info_command const *)load_command; break;
            default:
                break;
        }
        fileOffset += load_command->cmdsize;
    }
    
    if(!dyld_info_command){return;}
    
    if (dyld_info_command->rebase_off * dyld_info_command->rebase_size > 0){
        uint64_t ptrSize = (!is_64 ? sizeof(uint32_t) : sizeof(uint64_t));
        uint64_t address = base_addr;
        uint32_t type = 0;
        bool isDone = false;
        uint32_t doRebaseLocation = dyld_info_command->rebase_off + imageOffset;
        NSRange range = NSMakeRange(doRebaseLocation,0);
        while (NSMaxRange(range) < dyld_info_command->rebase_off + imageOffset + dyld_info_command->rebase_size && !isDone) {
            uint8_t byte = *(bytes + NSMaxRange(range));
            range  = NSMakeRange(NSMaxRange(range), sizeof(uint8_t));
            uint8_t opcode = byte & REBASE_OPCODE_MASK;
            uint8_t immediate = byte & REBASE_IMMEDIATE_MASK;
            
            switch (opcode) {
                case REBASE_OPCODE_DONE:
                    isDone = YES;
                    break;
                case REBASE_OPCODE_SET_TYPE_IMM:
                    type = immediate;
                    break;
                case REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:{
                    uint32_t segmentIndex = immediate;
                    uint64_t offset = read_uleb128(range, bytes);
                    if (segmentIndex >= ncmds){
                        [NSException raise:@"Segment" format:@"index is out of range %u", segmentIndex];
                    }
                    
                    fileOffset = imageOffset + (!is_64 ? sizeof(struct mach_header) : sizeof(struct mach_header_64));
                    for(uint32_t i = 0;i < ncmds;i++){
                        MATCH_STRUCT(load_command,fileOffset)
                        if(i == segmentIndex){
                            switch (load_command->cmd) {
                                case LC_SEGMENT:{
                                    MATCH_STRUCT(segment_command, fileOffset)
                                    address = segment_command->vmaddr + offset;
                                }break;
                                case LC_SEGMENT_64:{
                                    MATCH_STRUCT(segment_command_64,fileOffset)
                                    address = segment_command_64->vmaddr + offset;
                                }break;
                                default:break;
                            }
                        }
                        fileOffset += load_command->cmdsize;
                    }
                } break;
                    
                case REBASE_OPCODE_ADD_ADDR_ULEB:{
                    uint64_t offset = read_uleb128(range, bytes);
                    address += offset;
                } break;
                    
                case REBASE_OPCODE_ADD_ADDR_IMM_SCALED:{
                    uint32_t scale = immediate;
                    address += scale * ptrSize;
                } break;
                    
                case REBASE_OPCODE_DO_REBASE_IMM_TIMES:{
                    uint32_t count = immediate;
                    for (uint32_t index = 0; index < count; index++){
//                        is_64 ? rebases_64.push_back(address) : rebases.push_back(address);
                        doRebase(address, slide, is_64 ? sel_ref_64 : sel_ref);
                        address += ptrSize;
                    }
                    doRebaseLocation = NSMaxRange(range);
                } break;
                    
                case REBASE_OPCODE_DO_REBASE_ULEB_TIMES:{
                    uint32_t startNextRebase = NSMaxRange(range);
                    uint64_t count = read_uleb128(range, bytes);
                    for (uint64_t index = 0; index < count; index++) {
//                        is_64 ? rebases_64.push_back(address) : rebases.push_back(address);
                        doRebase(address, slide, is_64 ? sel_ref_64 : sel_ref);
                        address += ptrSize;
                    }
                    doRebaseLocation = startNextRebase;
                    
                } break;
                    
                case REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:{
                    uint32_t startNextRebase = NSMaxRange(range);
                    uint64_t offset = read_uleb128(range,bytes);
//                    is_64 ? rebases_64.push_back(address) : rebases.push_back(address);
                    doRebase(address, slide, is_64 ? sel_ref_64 : sel_ref);
                    address += ptrSize + offset;
                    doRebaseLocation = startNextRebase;
                } break;
                    
                case REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: {
                    uint32_t startNextRebase = NSMaxRange(range);
                    uint64_t count = read_uleb128(range,bytes);
                    uint64_t skip = read_uleb128(range,bytes);
                    for (uint64_t index = 0; index < count; index++)  {
//                        is_64 ? rebases_64.push_back(address) : rebases.push_back(address);
                        doRebase(address, slide, is_64 ? sel_ref_64 : sel_ref);
                        address += ptrSize + skip;
                    }
                    doRebaseLocation = startNextRebase;
                    
                } break;
                    
                default:
                    [NSException raise:@"Rebase info" format:@"Unknown opcode (%u %u)", 
                     ((uint32_t)-1 & opcode), ((uint32_t)-1 & immediate)];
            }
        }
    }
    
    if (dyld_info_command->bind_off * dyld_info_command->bind_size > 0){
        createBinding(slide,dyld_info_command->bind_off + imageOffset, dyld_info_command->bind_size, base_addr, is_64, bytes, ncmds, imageOffset + (!is_64 ? sizeof(struct mach_header) : sizeof(struct mach_header_64)),NodeTypeBind, bind_64, bind);
    }
    
    if (dyld_info_command->weak_bind_off * dyld_info_command->weak_bind_size > 0){
        createBinding(slide,dyld_info_command->weak_bind_off + imageOffset, dyld_info_command->weak_bind_size, base_addr, is_64, bytes, ncmds, imageOffset + (!is_64 ? sizeof(struct mach_header) : sizeof(struct mach_header_64)),NodeTypeWeakBind, bind_64, bind);
    }
    
    if (dyld_info_command->lazy_bind_off * dyld_info_command->lazy_bind_size > 0){
         createBinding(slide,dyld_info_command->lazy_bind_off + imageOffset, dyld_info_command->lazy_bind_size, base_addr, is_64, bytes, ncmds, imageOffset + (!is_64 ? sizeof(struct mach_header) : sizeof(struct mach_header_64)),NodeTypeLazyBind, bind_64, bind);
    }
    
    if (dyld_info_command->export_off * dyld_info_command->export_size > 0){
        printSymbols("",dyld_info_command->export_off + imageOffset, 0, base_addr, bytes);
    }
    
    if(is_64){
        if(__class_list_64){
            
        }
        if(__category_list_64){
            
        }
    }
    else{
        if(__class_list){
        
        }
        if(__category_list){
            
        }
    }
    
    
}

农夫三拳遭不住
关注
专栏目录
iPhone7.0.sdk include 文件列表
扯淡
10-31 1549
include include/_locale.h include/_structs.h include/_types include/_types/_intmax_t.h include/_types/_nl_item.h include/_types/_uint16_t.h include/_types/_uint32_t.h include/_types/_uint64_t.
【iOS】class-dump源码学习（三）
CROW的博客
03-19 497
上一篇：【iOS】class-dump源码学习（二） 续上一篇讲完CDObjectiveCProcessor的process方法中加载符号表的两个方法，今天继续process方法学习 回到CDObjectiveCProcessor的process方法继续，紧接着加载符号表的是 [self loadProtocols]; [self.protocolUniquer createUniqued...
Mach-O文件格式和程序从载入到运行过程
weixin_34378969的博客
08-04 461
&gt; 之前深入了解过。过去了一年多的时间。如今花些时间好好总结下，毕竟好记性不如烂笔头。其次另一个目的,对于mach-o文件结构。关于动态载入信息那个数据区中，命令含义没有深刻掰扯清除，希望有同学能够指点下。 摘要：对于mach-o是Mac和iOS能够运行文件的格式。进程就是系统依据该格式将运行文件载入到内存后得到的结果。系统通过解析文件，建立依赖(动态库)，初始化运行...
iOS - 底层知识学习之路-Mach-o 、lldb、 dyld
zhonggaorong的专栏
03-31 487
MACHO与重定位符号表认识。 命令回顾 1. 将源代码编译成可执行文件命令 Clang 文件名 -o 输出的可执行文件名称 如： Clang test.m - o test 2. 查看可执行文件的代码段命令 objdump --macho -d 可执行文件名称 如： objdump --macho -d test 3. 将文件编译生.o文件命令 clang -c 文件名 -o .o文件名 如： clang -c test.m -o test.o 4. 分析.o文件的代码段命令.
Mach-O文件格式和程序从加载到执行过程
bjtufang的专栏
04-08 1万+
> 之前深入了解过，过去了一年多的时间。现在花些时间好好总结下，毕竟好记性不如烂笔头。其次还有一个目的,对于mach-o文件结构，关于动态加载信息那个数据区中，命令含义没有深刻掰扯清除，希望有同学能够指点下。摘要：对于mach-o是Mac和iOS可以执行文件的格式。进程就是系统根据该格式将执行文件加载到内存后得到的结果。系统通过解析文件，建立依赖(动态库)，初始化运行时环境，才能真正开始执行该Ap
GeneralsRankedMaps：将军零时排名地图
02-13
将军零时排名地图 该存储库包含所有将军零时排名地图。 对于Git初学者 如何作为地图创建者做出贡献 请使用可识别的社区昵称创建GitHub帐户，然后分叉此存储库。 然后，您可以在候选文件夹中添加或更改地图。 完成后...
输入一些整数，编程计算并输出其中所有正数的和，输入负数时不累加，继续输入下一个数 输入零时，表示输入数据结束 要求最后统计出累加的项数
05-13
输入一些整数，编程计算并输出其中所有正数的和，输入负数时不累加，继续输入下一个数。输入零时，表示输入数据结束。要求最后统计出累加的项数
零时工标准聘用劳动合同.docx
10-28
零时工标准聘用劳动合同是企业和个人之间达成的一种临时性劳动关系协议，旨在规范双方的权利、义务和责任。以下是对这份合同中的关键知识点的详细说明： 1. **聘任期与续聘**：合同规定了首次聘任的期限，通常为...
一键删除零时垃圾
03-14
一键删除零时垃圾
零时科技：2022年全球Web3行业安全研究报告 (1).pdf
最新发布
09-01
《零时科技：2022年全球Web3行业安全研究报告》揭示了当前Web3领域在安全性方面面临的挑战和解决方案。Web3，也被称为去中心化网络，是互联网的下一阶段，它基于区块链技术，旨在打造一个用户拥有数据主权、隐私得到...
动态库连接器–动态库链接信息（Mach-O文件格式和程序从加载到执行过程）
weixin_34111790的博客
01-10 613
section cmd说明举例 __text 主程序代码   __stubs 用于动态库链接的桩   __stub_helper 用于动态库链接的桩   __cstring 常亮字符串符号表描述信息，通过该区信息，可以获得常亮字符串符号表地址   __unwind_info 这里字段不是太理解啥意思，希望大家指点下   动态库连接器–动态库链接信息 总结了mach-...
SResigner的实现：一款集动态库注入与删除、ipa重签名、ipa元数据修改为一体的MacOS App
永不止步
12-18 4102
1而乏味
html代码生成器_LLVM 目标无关代码生成器（第五章）
weixin_34792546的博客
12-17 821
本文是一篇译文，翻译自：https://llvm.org/docs/CodeGenerator.html​llvm.org如有问题，敬请指出。转载需注明出处，若需相关专业翻译服务，可联系我。本文目录第一章 介绍P2Tree：LLVM 目标无关代码生成器（第一章）​zhuanlan.zhihu.com第二章：目标描述类P2Tree：LLVM 目标无关代码生成器（第二章）​zhuanlan.zhihu...
分析字节跳动解决OOM的在线Memory Graph技术实现
原来是泽镜的博客
01-06 2663
之前看到字节团队分享的 “iOS性能优化实践：头条抖音如何实现OOM崩溃率下降50%+”这篇文章，对其实现比较感兴趣，但是没有开源，所以觉得自己花时间探索一下具体实现。 什么是OOM，为什么会发生OOM以及其原因分析，大家去看原文就好了，本文主要分析APP内存使用到达阈值后，如何采集Memory Graph信息并分析。 什么是Memory Graph？ 这个时候就进入了断点模式，可以查看issue面板，注意选择右边Runtime： 有很多叹号说明就有问题了。看内存中object的名字，有.
OPCode详解及汇编与反汇编原理
热门推荐
sqzxwq的博客
08-19 2万+
1. 何为OPCode 在计算机科学领域中，操作码(Operation Code, OPCode)被用于描述机器语言指令中，指定要执行某种操作的那部分机器码，构成OPCode的指令格式和规范由处理器的指令规范指定。除了指令本身以外通常还有指令所需要的操作数，可能有的指令不需要显示的操作数。这些操作数可能是寄存器中的值，堆栈中的值，某块内存的值或者IO端口中的值等等。 OPCod
MachO文件格式
qq_39153421的博客
07-30 2563
目录 0x1 前言 0x2 例子程序 0x3 MachO文件格式分析 0xx1 Mach Header-可执行文件头 0xx2 Load Commands-加载命令 segment_command结构体定义： dyld_info_command结构体 LC_SYMTAB结构体 LC_LOAD_DYLINKER结构体 LC_UUID结构体 LC_LOAD_DYLIB结构...
ffmpeg + ios 移植ffmpeg 到ios 平台上
y138828的专栏
04-27 1501
声明：本文章原创，禁止转载。分享出来，主要是在csdn上收获了这么多，该贡献点了 说实话移植ffmpeg  到mac ox 和 模拟器  上基本没啥难度，基本就是config && make && make install,也没有遇到啥难度，在模拟器上 运行没啥问题，问题的重点在移植到ios 平台上。 以前也知道交叉编译是怎么一回事，但是没有实战过，ide 用多了，对gcc 那一套选项根本就动
告一段落
y138828的专栏
11-29 354
这段时间以来，拼命专研一个技术，当看到这个log 的时候 ，也就意味着结束了 该好好放空下，实现了ios 代码的动态加载
MYSQL 建立零时表
04-05
例如，创建一个包含id和name两个字段的零时表，可以使用以下语句： ``` CREATE TEMPORARY TABLE temp_table ( id INT, name VARCHAR(50) ); ``` 可以向临时表中插入数据，例如： ``` INSERT INTO temp_table ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值