mach0.h File Reference

#include <rz_bin.h>
#include <rz_types.h>
#include "mach0_specs.h"

Go to the source code of this file.

Classes
struct	section_t
struct	symbol_t
struct	import_t
struct	reloc_t
struct	addr_t
struct	lib_t
struct	blob_index_t
struct	blob_t
struct	super_blob_t

Macros
#define	FEATURE_SYMLIST   0
#define	RZ_BIN_MACH0_STRING_LENGTH   256
#define	CSMAGIC_CODEDIRECTORY   0xfade0c02
#define	CSMAGIC_EMBEDDED_SIGNATURE   0xfade0cc0
#define	CSMAGIC_DETACHED_SIGNATURE   0xfade0cc1 /* multi-arch collection of embedded signatures */
#define	CSMAGIC_ENTITLEMENTS   0xfade7171
#define	CSMAGIC_REQUIREMENT   0xfade0c00 /* single Requirement blob */
#define	CSMAGIC_REQUIREMENTS   0xfade0c01 /* Requirements vector (internal requirements) */
#define	CS_PAGE_SIZE   4096
#define	CS_HASHTYPE_SHA1   1
#define	CS_HASHTYPE_SHA256   2
#define	CS_HASHTYPE_SHA256_TRUNCATED   3
#define	CS_HASH_SIZE_SHA1   20
#define	CS_HASH_SIZE_SHA256   32
#define	CS_HASH_SIZE_SHA256_TRUNCATED   20
#define	CSSLOT_CODEDIRECTORY   0
#define	CSSLOT_INFOSLOT   1
#define	CSSLOT_REQUIREMENTS   2
#define	CSSLOT_RESOURCEDIR   3
#define	CSSLOT_APPLICATION   4
#define	CSSLOT_ENTITLEMENTS   5
#define	CSSLOT_CMS_SIGNATURE   0x10000
#define	MACH0_VFILE_NAME_REBASED_STRIPPED   "rebased_stripped"
#define	MACH0_VFILE_NAME_RELOC_TARGETS   "reloc-targets"
#define	MACH0_VFILE_NAME_PATCHED   "patched"

Functions
struct	MACH0_ (opts_t)
struct	MACH0_ (obj_t)
void MACH0_()	opts_set_default (struct MACH0_(opts_t) *options, RzBinFile *bf)
void *MACH0_()	mach0_free (struct MACH0_(obj_t) *bin)
struct section_t *MACH0_()	get_sections (struct MACH0_(obj_t) *bin)
char *MACH0_()	section_type_to_string (ut64 type)
RzList *MACH0_()	section_flag_to_rzlist (ut64 flag)
RzList *MACH0_()	get_virtual_files (RzBinFile *bf)
RzList *MACH0_()	get_maps_unpatched (RzBinFile *bf)
RzList *MACH0_()	get_maps (RzBinFile *bf)
RzList *MACH0_()	get_segments (RzBinFile *bf)
const struct symbol_t *MACH0_()	get_symbols (struct MACH0_(obj_t) *bin)
const RzList *MACH0_()	get_symbols_list (struct MACH0_(obj_t) *bin)
void MACH0_()	pull_symbols (struct MACH0_(obj_t) *mo, RzBinSymbolCallback cb, void *user)
struct import_t *MACH0_()	get_imports (struct MACH0_(obj_t) *bin)
RZ_BORROW RzSkipList *MACH0_()	get_relocs (struct MACH0_(obj_t) *bin)
struct addr_t *MACH0_()	get_entrypoint (struct MACH0_(obj_t) *bin)
struct lib_t *MACH0_()	get_libs (struct MACH0_(obj_t) *bin)
ut64 MACH0_()	get_baddr (struct MACH0_(obj_t) *bin)
char *MACH0_()	get_class (struct MACH0_(obj_t) *bin)
int MACH0_()	get_bits (struct MACH0_(obj_t) *bin)
bool MACH0_()	is_big_endian (struct MACH0_(obj_t) *bin)
bool MACH0_()	is_pie (struct MACH0_(obj_t) *bin)
bool MACH0_()	has_nx (struct MACH0_(obj_t) *bin)
const char *MACH0_()	get_intrp (struct MACH0_(obj_t) *bin)
const char *MACH0_()	get_os (struct MACH0_(obj_t) *bin)
const char *MACH0_()	get_cputype (struct MACH0_(obj_t) *bin)
char *MACH0_()	get_cpusubtype (struct MACH0_(obj_t) *bin)
char *MACH0_()	get_cpusubtype_from_hdr (struct MACH0_(mach_header) *hdr)
char *MACH0_()	get_filetype (struct MACH0_(obj_t) *bin)
char *MACH0_()	get_filetype_from_hdr (struct MACH0_(mach_header) *hdr)
ut64 MACH0_()	get_main (struct MACH0_(obj_t) *bin)
const char *MACH0_()	get_cputype_from_hdr (struct MACH0_(mach_header) *hdr)
int MACH0_()	get_bits_from_hdr (struct MACH0_(mach_header) *hdr)
struct	MACH0_ (mach_header) *MACH0_(get_hdr)(RzBuffer *buf)
void MACH0_()	mach_headerfields (RzBinFile *bf)
RzList *MACH0_()	mach_fields (RzBinFile *bf)
RZ_API RZ_OWN char *MACH0_()	get_name (struct MACH0_(obj_t) *mo, ut32 stridx, bool filter)
	Get a string from the string table referenced by the LC_SYMTAB command. More...
RZ_API ut64 MACH0_()	paddr_to_vaddr (struct MACH0_(obj_t) *bin, ut64 offset)
RZ_API ut64 MACH0_()	vaddr_to_paddr (struct MACH0_(obj_t) *bin, ut64 addr)
RZ_API void MACH0_()	rebase_buffer (struct MACH0_(obj_t) *obj, ut64 off, ut8 *buf, ut64 count)
RZ_API RzBuffer *MACH0_()	new_rebasing_and_stripping_buf (struct MACH0_(obj_t) *obj)
RZ_API bool MACH0_()	needs_rebasing_and_stripping (struct MACH0_(obj_t) *obj)
RZ_API bool MACH0_()	segment_needs_rebasing_and_stripping (struct MACH0_(obj_t) *obj, size_t seg_index)
RZ_API bool MACH0_()	needs_reloc_patching (struct MACH0_(obj_t) *obj)
RZ_API ut64 MACH0_()	reloc_targets_vfile_size (struct MACH0_(obj_t) *obj)
	size of the artificial reloc target vfile More...
RZ_API ut64 MACH0_()	reloc_targets_map_base (RzBinFile *bf, struct MACH0_(obj_t) *obj)
	base vaddr where to map the artificial reloc target vfile More...
RZ_API void MACH0_()	patch_relocs (RzBinFile *bf, struct MACH0_(obj_t) *obj)
	Patching of external relocs in a sparse overlay buffer. More...

Macro Definition Documentation

CS_HASH_SIZE_SHA1

#define CS_HASH_SIZE_SHA1   20

Definition at line 30 of file mach0.h.

CS_HASH_SIZE_SHA256

#define CS_HASH_SIZE_SHA256   32

Definition at line 31 of file mach0.h.

CS_HASH_SIZE_SHA256_TRUNCATED

#define CS_HASH_SIZE_SHA256_TRUNCATED   20

Definition at line 32 of file mach0.h.

CS_HASHTYPE_SHA1

#define CS_HASHTYPE_SHA1   1

Definition at line 26 of file mach0.h.

CS_HASHTYPE_SHA256

#define CS_HASHTYPE_SHA256   2

Definition at line 27 of file mach0.h.

CS_HASHTYPE_SHA256_TRUNCATED

#define CS_HASHTYPE_SHA256_TRUNCATED   3

Definition at line 28 of file mach0.h.

CS_PAGE_SIZE

#define CS_PAGE_SIZE   4096

Definition at line 24 of file mach0.h.

CSMAGIC_CODEDIRECTORY

#define CSMAGIC_CODEDIRECTORY   0xfade0c02

Definition at line 17 of file mach0.h.

CSMAGIC_DETACHED_SIGNATURE

#define CSMAGIC_DETACHED_SIGNATURE   0xfade0cc1 /* multi-arch collection of embedded signatures */

Definition at line 19 of file mach0.h.

CSMAGIC_EMBEDDED_SIGNATURE

#define CSMAGIC_EMBEDDED_SIGNATURE   0xfade0cc0

Definition at line 18 of file mach0.h.

CSMAGIC_ENTITLEMENTS

#define CSMAGIC_ENTITLEMENTS   0xfade7171

Definition at line 20 of file mach0.h.

CSMAGIC_REQUIREMENT

#define CSMAGIC_REQUIREMENT   0xfade0c00 /* single Requirement blob */

Definition at line 21 of file mach0.h.

CSMAGIC_REQUIREMENTS

#define CSMAGIC_REQUIREMENTS   0xfade0c01 /* Requirements vector (internal requirements) */

Definition at line 22 of file mach0.h.

CSSLOT_APPLICATION

#define CSSLOT_APPLICATION   4

Definition at line 38 of file mach0.h.

CSSLOT_CMS_SIGNATURE

#define CSSLOT_CMS_SIGNATURE   0x10000

Definition at line 40 of file mach0.h.

CSSLOT_CODEDIRECTORY

#define CSSLOT_CODEDIRECTORY   0

Definition at line 34 of file mach0.h.

CSSLOT_ENTITLEMENTS

#define CSSLOT_ENTITLEMENTS   5

Definition at line 39 of file mach0.h.

CSSLOT_INFOSLOT

#define CSSLOT_INFOSLOT   1

Definition at line 35 of file mach0.h.

CSSLOT_REQUIREMENTS

#define CSSLOT_REQUIREMENTS   2

Definition at line 36 of file mach0.h.

CSSLOT_RESOURCEDIR

#define CSSLOT_RESOURCEDIR   3

Definition at line 37 of file mach0.h.

FEATURE_SYMLIST

#define FEATURE_SYMLIST   0

Definition at line 13 of file mach0.h.

MACH0_VFILE_NAME_PATCHED

#define MACH0_VFILE_NAME_PATCHED   "patched"

Definition at line 197 of file mach0.h.

MACH0_VFILE_NAME_REBASED_STRIPPED

#define MACH0_VFILE_NAME_REBASED_STRIPPED   "rebased_stripped"

Definition at line 195 of file mach0.h.

MACH0_VFILE_NAME_RELOC_TARGETS

#define MACH0_VFILE_NAME_RELOC_TARGETS   "reloc-targets"

Definition at line 196 of file mach0.h.

RZ_BIN_MACH0_STRING_LENGTH

#define RZ_BIN_MACH0_STRING_LENGTH   256

Definition at line 15 of file mach0.h.

Function Documentation

get_baddr()

ut64 MACH0_() get_baddr

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3262 of file mach0.c.

                                                   {
    int i;
 
    if (bin->hdr.filetype != MH_EXECUTE && bin->hdr.filetype != MH_DYLINKER &&
        bin->hdr.filetype != MH_FILESET) {
        return 0;
    }
    for (i = 0; i < bin->nsegs; i++) {
        if (bin->segs[i].fileoff == 0 && bin->segs[i].filesize != 0) {
            return bin->segs[i].vmaddr;
        }
    }
    return 0;
}

References i, MH_DYLINKER, MH_EXECUTE, and MH_FILESET.

Referenced by baddr(), and init().

get_bits()

int MACH0_() get_bits

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3288 of file mach0.c.

                                                 {
    if (bin) {
        int bits = MACH0_(get_bits_from_hdr)(&bin->hdr);
        if (bin->hdr.cputype == CPU_TYPE_ARM && bin->entry & 1) {
            return 16;
        }
        return bits;
    }
    return 32;
}

References bits(), CPU_TYPE_ARM, get_bits_from_hdr(), and MACH0_().

get_bits_from_hdr()

int MACH0_() get_bits_from_hdr

(

struct MACH0_(mach_header) *

hdr

)

Definition at line 3299 of file mach0.c.

                                                                {
    if (hdr->magic == MH_MAGIC_64 || hdr->magic == MH_CIGAM_64) {
        return 64;
    }
    if (hdr->cputype == CPU_TYPE_ARM64_32) { // new apple watch aka arm64_32
        return 64;
    }
    if ((hdr->cpusubtype & CPU_SUBTYPE_MASK) == (CPU_SUBTYPE_ARM_V7K << 24)) {
        return 16;
    }
    return 32;
}

References CPU_SUBTYPE_ARM_V7K, CPU_SUBTYPE_MASK, CPU_TYPE_ARM64_32, MH_CIGAM_64, and MH_MAGIC_64.

Referenced by fill_metadata_info_from_hdr(), get_bits(), get_symbols(), get_symbols_list(), and reloc_target_size().

get_class()

char* MACH0_() get_class

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3277 of file mach0.c.

                                                    {
#if RZ_BIN_MACH064
    return rz_str_new("MACH064");
#else
    return rz_str_new("MACH0");
#endif
}

References rz_str_new().

Referenced by info().

get_cpusubtype()

char* MACH0_() get_cpusubtype

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3546 of file mach0.c.

                                                         {
    return bin ? MACH0_(get_cpusubtype_from_hdr)(&bin->hdr) : strdup("Unknown");
}

References get_cpusubtype_from_hdr(), MACH0_(), and strdup().

Referenced by info().

get_cpusubtype_from_hdr()

char* MACH0_() get_cpusubtype_from_hdr

(

struct MACH0_(mach_header) *

hdr

)

Definition at line 3541 of file mach0.c.

                                                                        {
    rz_return_val_if_fail(hdr, NULL);
    return strdup(cpusubtype_tostring(hdr->cputype, hdr->cpusubtype));
}

References cpusubtype_tostring(), NULL, rz_return_val_if_fail, and strdup().

Referenced by fill_metadata_info_from_hdr(), and get_cpusubtype().

get_cputype()

const char* MACH0_() get_cputype

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3383 of file mach0.c.

                                                            {
    return bin ? MACH0_(get_cputype_from_hdr)(&bin->hdr) : "unknown";
}

References get_cputype_from_hdr(), and MACH0_().

Referenced by info().

get_cputype_from_hdr()

const char* MACH0_() get_cputype_from_hdr

(

struct MACH0_(mach_header) *

hdr

)

Definition at line 3336 of file mach0.c.

                                                                           {
    const char *archstr = "unknown";
    switch (hdr->cputype) {
    case CPU_TYPE_VAX:
        archstr = "vax";
        break;
    case CPU_TYPE_MC680x0:
        archstr = "mc680x0";
        break;
    case CPU_TYPE_I386:
    case CPU_TYPE_X86_64:
        archstr = "x86";
        break;
    case CPU_TYPE_MC88000:
        archstr = "mc88000";
        break;
    case CPU_TYPE_MC98000:
        archstr = "mc98000";
        break;
    case CPU_TYPE_HPPA:
        archstr = "hppa";
        break;
    case CPU_TYPE_ARM:
    case CPU_TYPE_ARM64:
    case CPU_TYPE_ARM64_32:
        archstr = "arm";
        break;
    case CPU_TYPE_SPARC:
        archstr = "sparc";
        break;
    case CPU_TYPE_MIPS:
        archstr = "mips";
        break;
    case CPU_TYPE_I860:
        archstr = "i860";
        break;
    case CPU_TYPE_POWERPC:
    case CPU_TYPE_POWERPC64:
        archstr = "ppc";
        break;
    default:
        eprintf("Unknown arch %d\n", hdr->cputype);
        break;
    }
    return archstr;
}

References CPU_TYPE_ARM, CPU_TYPE_ARM64, CPU_TYPE_ARM64_32, CPU_TYPE_HPPA, CPU_TYPE_I386, CPU_TYPE_I860, CPU_TYPE_MC680x0, CPU_TYPE_MC88000, CPU_TYPE_MC98000, CPU_TYPE_MIPS, CPU_TYPE_POWERPC, CPU_TYPE_POWERPC64, CPU_TYPE_SPARC, CPU_TYPE_VAX, CPU_TYPE_X86_64, and eprintf.

Referenced by _patch_reloc(), fill_metadata_info_from_hdr(), and get_cputype().

get_entrypoint()

struct addr_t* MACH0_() get_entrypoint

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3196 of file mach0.c.

                                                                  {
    rz_return_val_if_fail(bin, NULL);
 
    ut64 ea = entry_to_vaddr(bin);
    if (ea == 0 || ea == UT64_MAX) {
        return NULL;
    }
    struct addr_t *entry = RZ_NEW0(struct addr_t);
    if (!entry) {
        return NULL;
    }
    entry->addr = ea;
    entry->offset = MACH0_(vaddr_to_paddr)(bin, entry->addr);
    entry->haddr = sdb_num_get(bin->kv, "mach0.entry.offset", 0);
    sdb_num_set(bin->kv, "mach0.entry.vaddr", entry->addr, 0);
    sdb_num_set(bin->kv, "mach0.entry.paddr", bin->entry, 0);
 
    if (entry->offset == 0 && !bin->sects) {
        int i;
        for (i = 0; i < bin->nsects; i++) {
            // XXX: section name shoudnt matter .. just check for exec flags
            if (!strncmp(bin->sects[i].sectname, "__text", 6)) {
                entry->offset = (ut64)bin->sects[i].offset;
                sdb_num_set(bin->kv, "mach0.entry", entry->offset, 0);
                entry->addr = (ut64)bin->sects[i].addr;
                if (!entry->addr) { // workaround for object files
                    eprintf("entrypoint is 0...\n");
                    // XXX(lowlyw) there's technically not really entrypoints
                    // for .o files, so ignore this...
                    // entry->addr = entry->offset;
                }
                break;
            }
        }
        bin->entry = entry->addr;
    }
    return entry;
}

References entry_to_vaddr(), eprintf, i, if(), MACH0_(), NULL, RZ_NEW0, rz_return_val_if_fail, sdb_num_get(), sdb_num_set(), ut64(), UT64_MAX, and vaddr_to_paddr().

Referenced by entries(), and get_main().

get_filetype()

char* MACH0_() get_filetype

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3578 of file mach0.c.

                                                       {
    return bin ? MACH0_(get_filetype_from_hdr)(&bin->hdr) : strdup("Unknown");
}

References get_filetype_from_hdr(), MACH0_(), and strdup().

Referenced by info().

get_filetype_from_hdr()

char* MACH0_() get_filetype_from_hdr

(

struct MACH0_(mach_header) *

hdr

)

Definition at line 3559 of file mach0.c.

                                                                      {
    const char *mhtype = "Unknown";
    switch (hdr->filetype) {
    case MH_OBJECT: mhtype = "Relocatable object"; break;
    case MH_EXECUTE: mhtype = "Executable file"; break;
    case MH_FVMLIB: mhtype = "Fixed VM shared library"; break;
    case MH_CORE: mhtype = "Core file"; break;
    case MH_PRELOAD: mhtype = "Preloaded executable file"; break;
    case MH_DYLIB: mhtype = "Dynamically bound shared library"; break;
    case MH_DYLINKER: mhtype = "Dynamic link editor"; break;
    case MH_BUNDLE: mhtype = "Dynamically bound bundle file"; break;
    case MH_DYLIB_STUB: mhtype = "Shared library stub for static linking (no sections)"; break;
    case MH_DSYM: mhtype = "Companion file with only debug sections"; break;
    case MH_KEXT_BUNDLE: mhtype = "Kernel extension bundle file"; break;
    case MH_FILESET: mhtype = "Kernel cache file"; break;
    }
    return strdup(mhtype);
}

References MH_BUNDLE, MH_CORE, MH_DSYM, MH_DYLIB, MH_DYLIB_STUB, MH_DYLINKER, MH_EXECUTE, MH_FILESET, MH_FVMLIB, MH_KEXT_BUNDLE, MH_OBJECT, MH_PRELOAD, and strdup().

Referenced by fill_metadata_info_from_hdr(), and get_filetype().

get_imports()

struct import_t* MACH0_() get_imports

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3146 of file mach0.c.

                                                                 {
    rz_return_val_if_fail(bin, NULL);
 
    int i, j, idx, stridx;
    if (!bin->sects || !bin->symtab || !bin->symstr || !bin->indirectsyms) {
        return NULL;
    }
 
    if (bin->dysymtab.nundefsym < 1 || bin->dysymtab.nundefsym > 0xfffff) {
        return NULL;
    }
 
    struct import_t *imports = calloc(bin->dysymtab.nundefsym + 1, sizeof(struct import_t));
    if (!imports) {
        return NULL;
    }
    for (i = j = 0; i < bin->dysymtab.nundefsym; i++) {
        idx = bin->dysymtab.iundefsym + i;
        if (idx < 0 || idx >= bin->nsymtab) {
            bprintf("WARNING: Imports index out of bounds. Ignoring relocs\n");
            free(imports);
            return NULL;
        }
        stridx = bin->symtab[idx].n_strx;
        char *imp_name = MACH0_(get_name)(bin, stridx, false);
        if (imp_name) {
            rz_str_ncpy(imports[j].name, imp_name, RZ_BIN_MACH0_STRING_LENGTH);
            free(imp_name);
        } else {
            // imports[j].name[0] = 0;
            continue;
        }
        imports[j].ord = i;
        imports[j++].last = 0;
    }
    imports[j].last = 1;
 
    if (!bin->imports_by_ord_size) {
        if (j > 0) {
            bin->imports_by_ord_size = j;
            bin->imports_by_ord = (RzBinImport **)calloc(j, sizeof(RzBinImport *));
        } else {
            bin->imports_by_ord_size = 0;
            bin->imports_by_ord = NULL;
        }
    }
 
    return imports;
}

References bprintf, calloc(), free(), get_name(), i, setup::idx, imports(), MACH0_(), NULL, RZ_BIN_MACH0_STRING_LENGTH, rz_return_val_if_fail, and rz_str_ncpy().

Referenced by imports().

get_intrp()

const char* MACH0_() get_intrp

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3320 of file mach0.c.

                                                          {
    return bin ? bin->intrp : NULL;
}

References NULL.

Referenced by info().

get_libs()

struct lib_t* MACH0_() get_libs

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3242 of file mach0.c.

                                                           {
    struct lib_t *libs;
    int i;
 
    if (!bin->nlibs) {
        return NULL;
    }
    if (!(libs = calloc((bin->nlibs + 1), sizeof(struct lib_t)))) {
        return NULL;
    }
    for (i = 0; i < bin->nlibs; i++) {
        sdb_set(bin->kv, sdb_fmt("libs.%d.name", i), bin->libs[i], 0);
        strncpy(libs[i].name, bin->libs[i], RZ_BIN_MACH0_STRING_LENGTH - 1);
        libs[i].name[RZ_BIN_MACH0_STRING_LENGTH - 1] = '\0';
        libs[i].last = 0;
    }
    libs[i].last = 1;
    return libs;
}

References calloc(), i, libs(), NULL, RZ_BIN_MACH0_STRING_LENGTH, sdb_fmt(), and sdb_set().

Referenced by libs().

get_main()

ut64 MACH0_() get_main

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3582 of file mach0.c.

                                                  {
    ut64 addr = UT64_MAX;
    int i;
 
    // 0 = sscanned but no main found
    // -1 = not scanned, so no main
    // other = valid main addr
    if (bin->main_addr == UT64_MAX) {
#if FEATURE_SYMLIST
        (void)MACH0_(get_symbols_list)(bin);
#else
        (void)MACH0_(get_symbols)(bin);
#endif
    }
    if (bin->main_addr != 0 && bin->main_addr != UT64_MAX) {
        return bin->main_addr;
    }
    // dummy call to initialize things
    free(MACH0_(get_entrypoint)(bin));
 
    bin->main_addr = 0;
 
    if (addr == UT64_MAX && bin->main_cmd.cmd == LC_MAIN) {
        addr = bin->entry + bin->baddr;
    }
 
    if (!addr) {
        ut8 b[128];
        ut64 entry = MACH0_(vaddr_to_paddr)(bin, bin->entry);
        // XXX: X86 only and hacky!
        if (entry > bin->size || entry + sizeof(b) > bin->size) {
            return UT64_MAX;
        }
        i = rz_buf_read_at(bin->b, entry, b, sizeof(b));
        if (i < 80) {
            return UT64_MAX;
        }
        for (i = 0; i < 64; i++) {
            if (b[i] == 0xe8 && !b[i + 3] && !b[i + 4]) {
                int delta = b[i + 1] | (b[i + 2] << 8) | (b[i + 3] << 16) | (b[i + 4] << 24);
                addr = bin->entry + i + 5 + delta;
                break;
            }
        }
        if (!addr) {
            addr = entry;
        }
    }
    return bin->main_addr = addr;
}

References addr, b, delta, free(), get_entrypoint(), get_symbols(), get_symbols_list(), i, LC_MAIN, MACH0_(), rz_buf_read_at(), ut64(), UT64_MAX, and vaddr_to_paddr().

Referenced by binsym().

get_maps()

RzList* MACH0_() get_maps

(

RzBinFile *

bf

)

Definition at line 2252 of file mach0.c.

                                        {
    RzList *ret = MACH0_(get_maps_unpatched)(bf);
    if (!ret) {
        return NULL;
    }
    struct MACH0_(obj_t) *obj = bf->o->bin_obj;
    // clang-format off
    MACH0_(patch_relocs)(bf, obj);
    // clang-format on
    rz_bin_relocs_patch_maps(ret, obj->buf_patched, bf->o->boffset,
        MACH0_(reloc_targets_map_base)(bf, obj), MACH0_(reloc_targets_vfile_size)(obj),
        MACH0_VFILE_NAME_PATCHED, MACH0_VFILE_NAME_RELOC_TARGETS);
    return ret;
}

References get_maps_unpatched(), MACH0_(), MACH0_VFILE_NAME_PATCHED, MACH0_VFILE_NAME_RELOC_TARGETS, NULL, patch_relocs(), reloc_targets_map_base(), reloc_targets_vfile_size(), and rz_bin_relocs_patch_maps().

Referenced by maps().

get_maps_unpatched()

RzList* MACH0_() get_maps_unpatched

(

RzBinFile *

bf

)

Definition at line 2217 of file mach0.c.

                                                  {
    rz_return_val_if_fail(bf, NULL);
    struct MACH0_(obj_t) *bin = bf->o->bin_obj;
    RzList *ret = rz_list_newf((RzListFree)rz_bin_map_free);
    if (!ret) {
        return NULL;
    }
    for (size_t i = 0; i < bin->nsegs; i++) {
        struct MACH0_(segment_command) *seg = &bin->segs[i];
        if (!seg->initprot) {
            continue;
        }
        RzBinMap *map = RZ_NEW0(RzBinMap);
        if (!map) {
            break;
        }
        map->psize = seg->vmsize;
        map->vaddr = seg->vmaddr;
        map->vsize = seg->vmsize;
        map->name = rz_str_ndup(seg->segname, 16);
        rz_str_filter(map->name);
        map->perm = prot2perm(seg->initprot);
        if (MACH0_(segment_needs_rebasing_and_stripping)(bin, i)) {
            map->vfile_name = strdup(MACH0_VFILE_NAME_REBASED_STRIPPED);
            map->paddr = seg->fileoff;
        } else {
            // boffset is relevant for fatmach0 where the mach0 is located boffset into the whole file
            // the rebasing vfile above however is based at the mach0 already
            map->paddr = seg->fileoff + bf->o->boffset;
        }
        rz_list_append(ret, map);
    }
    return ret;
}

References i, MACH0_(), MACH0_VFILE_NAME_REBASED_STRIPPED, map(), NULL, prot2perm(), rz_bin_map_free(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_return_val_if_fail, rz_str_filter(), rz_str_ndup(), segment_needs_rebasing_and_stripping(), and strdup().

Referenced by get_maps(), and reloc_targets_map_base().

get_name()

RZ_API RZ_OWN char* MACH0_() get_name	(	struct MACH0_(obj_t) *	mo,
		ut32	stridx,
		bool	filter
	)

Get a string from the string table referenced by the LC_SYMTAB command.

Parameters

stridx	the index into the string table, such as n_strx from a nlist symbol entry
filter	whether to call rz_str_filter() on the string before returning

Definition at line 2563 of file mach0.c.

                                                                                          {
    size_t i = 0;
    if (!mo->symstr || stridx >= mo->symstrlen) {
        return NULL;
    }
    int len = mo->symstrlen - stridx;
    const char *symstr = (const char *)mo->symstr + stridx;
    for (i = 0; i < len; i++) {
        if ((ut8)(symstr[i] & 0xff) == 0xff || !symstr[i]) {
            len = i;
            break;
        }
    }
    if (len > 0) {
        char *res = rz_str_ndup(symstr, len);
        if (filter) {
            rz_str_filter(res);
        }
        return res;
    }
    return NULL;
}

References i, len, NULL, rz_str_filter(), and rz_str_ndup().

Referenced by get_imports(), get_operator_code(), get_symbols(), get_symbols_list(), and parse_relocation_info().

get_os()

const char* MACH0_() get_os

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3324 of file mach0.c.

                                                       {
    if (bin) {
        switch (bin->os) {
        case 1: return "macos";
        case 2: return "ios";
        case 3: return "watchos";
        case 4: return "tvos";
        }
    }
    return "darwin";
}

Referenced by info().

get_relocs()

RZ_BORROW RzSkipList* MACH0_() get_relocs

(

struct MACH0_(obj_t) *

bin

)

Definition at line 120 of file mach0_relocs.c.

                                                                     {
    rz_return_val_if_fail(bin, NULL);
    if (bin->relocs_parsed) {
        return bin->relocs;
    }
    bin->relocs_parsed = true;
    RzSkipList *relocs = NULL;
    RzPVector *threaded_binds = NULL;
    size_t wordsize = get_word_size(bin);
    if (bin->dyld_info) {
        ut8 *opcodes, rel_type = 0;
        size_t bind_size, lazy_size, weak_size;
 
#define CASE(T) \
    case ((T) / 8): rel_type = RZ_BIN_RELOC_##T; break
        switch (wordsize) {
            CASE(8);
            CASE(16);
            CASE(32);
            CASE(64);
        default: return NULL;
        }
#undef CASE
        bind_size = bin->dyld_info->bind_size;
        lazy_size = bin->dyld_info->lazy_bind_size;
        weak_size = bin->dyld_info->weak_bind_size;
 
        if (!bind_size && !lazy_size) {
            return NULL;
        }
 
        if ((bind_size + lazy_size) < 1) {
            return NULL;
        }
        if (bin->dyld_info->bind_off > bin->size || bin->dyld_info->bind_off + bind_size > bin->size) {
            return NULL;
        }
        if (bin->dyld_info->lazy_bind_off > bin->size ||
            bin->dyld_info->lazy_bind_off + lazy_size > bin->size) {
            return NULL;
        }
        if (bin->dyld_info->bind_off + bind_size + lazy_size > bin->size) {
            return NULL;
        }
        if (bin->dyld_info->weak_bind_off + weak_size > bin->size) {
            return NULL;
        }
        ut64 amount = bind_size + lazy_size + weak_size;
        if (amount == 0 || amount > UT32_MAX) {
            return NULL;
        }
        if (!bin->segs) {
            return NULL;
        }
        relocs = rz_skiplist_new((RzListFree)&free, (RzListComparator)&reloc_comparator);
        if (!relocs) {
            return NULL;
        }
        opcodes = calloc(1, amount + 1);
        if (!opcodes) {
            rz_skiplist_free(relocs);
            return NULL;
        }
 
        int len = rz_buf_read_at(bin->b, bin->dyld_info->bind_off, opcodes, bind_size);
        len += rz_buf_read_at(bin->b, bin->dyld_info->lazy_bind_off, opcodes + bind_size, lazy_size);
        len += rz_buf_read_at(bin->b, bin->dyld_info->weak_bind_off, opcodes + bind_size + lazy_size, weak_size);
        if (len < amount) {
            RZ_LOG_ERROR("Error: read (dyld_info bind) at 0x%08" PFMT64x "\n", (ut64)(size_t)bin->dyld_info->bind_off);
            RZ_FREE(opcodes);
            rz_skiplist_free(relocs);
            return NULL;
        }
 
        size_t partition_sizes[] = { bind_size, lazy_size, weak_size };
        size_t pidx;
        int opcodes_offset = 0;
        for (pidx = 0; pidx < RZ_ARRAY_SIZE(partition_sizes); pidx++) {
            size_t partition_size = partition_sizes[pidx];
 
            ut8 type = 0;
            int lib_ord = 0, seg_idx = -1, sym_ord = -1;
            char *sym_name = NULL;
            size_t j, count, skip;
            st64 addend = 0;
            ut64 addr = bin->segs[0].vmaddr;
            ut64 segment_end_addr = addr + bin->segs[0].vmsize;
 
            ut8 *p = opcodes + opcodes_offset;
            ut8 *end = p + partition_size;
            bool done = false;
            while (!done && p < end) {
                ut8 imm = *p & BIND_IMMEDIATE_MASK;
                ut8 op = *p & BIND_OPCODE_MASK;
                p++;
                switch (op) {
                case BIND_OPCODE_DONE: {
                    bool in_lazy_binds = pidx == 1;
                    if (!in_lazy_binds) {
                        done = true;
                    }
                    break;
                }
                case BIND_OPCODE_THREADED: {
                    switch (imm) {
                    case BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB: {
                        ut64 table_size = read_uleb128(&p, end);
                        if (!is_valid_ordinal_table_size(table_size)) {
                            RZ_LOG_ERROR("Error: BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB size is wrong\n");
                            break;
                        }
                        if (threaded_binds) {
                            rz_pvector_free(threaded_binds);
                        }
                        threaded_binds = rz_pvector_new_with_len((RzPVectorFree)&free, table_size);
                        if (threaded_binds) {
                            sym_ord = 0;
                        }
                        break;
                    }
                    case BIND_SUBOPCODE_THREADED_APPLY:
                        if (threaded_binds) {
                            int cur_seg_idx = (seg_idx != -1) ? seg_idx : 0;
                            size_t n_threaded_binds = rz_pvector_len(threaded_binds);
                            while (addr < segment_end_addr) {
                                ut8 tmp[8];
                                ut64 paddr = addr - bin->segs[cur_seg_idx].vmaddr + bin->segs[cur_seg_idx].fileoff;
                                if (rz_buf_read_at(bin->b, paddr, tmp, 8) != 8) {
                                    break;
                                }
                                ut64 raw_ptr = rz_read_le64(tmp);
                                bool is_auth = (raw_ptr & (1ULL << 63)) != 0;
                                bool is_bind = (raw_ptr & (1ULL << 62)) != 0;
                                int ordinal = -1;
                                int addend = -1;
                                ut64 delta;
                                if (is_auth && is_bind) {
                                    struct dyld_chained_ptr_arm64e_auth_bind *p =
                                        (struct dyld_chained_ptr_arm64e_auth_bind *)&raw_ptr;
                                    delta = p->next;
                                    ordinal = p->ordinal;
                                } else if (!is_auth && is_bind) {
                                    struct dyld_chained_ptr_arm64e_bind *p =
                                        (struct dyld_chained_ptr_arm64e_bind *)&raw_ptr;
                                    delta = p->next;
                                    ordinal = p->ordinal;
                                    addend = p->addend;
                                } else if (is_auth && !is_bind) {
                                    struct dyld_chained_ptr_arm64e_auth_rebase *p =
                                        (struct dyld_chained_ptr_arm64e_auth_rebase *)&raw_ptr;
                                    delta = p->next;
                                } else {
                                    struct dyld_chained_ptr_arm64e_rebase *p =
                                        (struct dyld_chained_ptr_arm64e_rebase *)&raw_ptr;
                                    delta = p->next;
                                }
                                if (ordinal != -1) {
                                    if (ordinal >= n_threaded_binds) {
                                        RZ_LOG_ERROR("Error: Malformed bind chain\n");
                                        break;
                                    }
                                    struct reloc_t *ref = rz_pvector_at(threaded_binds, ordinal);
                                    if (!ref) {
                                        RZ_LOG_ERROR("Error: Inconsistent bind opcodes\n");
                                        break;
                                    }
                                    struct reloc_t *reloc = RZ_NEW0(struct reloc_t);
                                    if (!reloc) {
                                        break;
                                    }
                                    *reloc = *ref;
                                    reloc->addr = addr;
                                    reloc->offset = paddr;
                                    if (addend != -1) {
                                        reloc->addend = addend;
                                    }
                                    rz_skiplist_insert(relocs, reloc);
                                }
                                addr += delta * wordsize;
                                if (!delta) {
                                    break;
                                }
                            }
                        }
                        break;
                    default:
                        RZ_LOG_ERROR("Error: Unexpected BIND_OPCODE_THREADED sub-opcode: 0x%x\n", imm);
                    }
                    break;
                }
                case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
                    lib_ord = imm;
                    break;
                case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
                    lib_ord = read_uleb128(&p, end);
                    break;
                case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
                    lib_ord = imm ? (st8)(BIND_OPCODE_MASK | imm) : 0;
                    break;
                case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: {
                    sym_name = (char *)p;
                    while (*p++ && p < end) {
                        /* empty loop */
                    }
                    if (threaded_binds) {
                        break;
                    }
                    sym_ord = -1;
                    if (bin->symtab && bin->dysymtab.nundefsym < UT16_MAX) {
                        for (j = 0; j < bin->dysymtab.nundefsym; j++) {
                            size_t stridx = 0;
                            bool found = false;
                            int iundefsym = bin->dysymtab.iundefsym;
                            if (iundefsym >= 0 && iundefsym < bin->nsymtab) {
                                int sidx = iundefsym + j;
                                if (sidx < 0 || sidx >= bin->nsymtab) {
                                    continue;
                                }
                                stridx = bin->symtab[sidx].n_strx;
                                if (stridx >= bin->symstrlen) {
                                    continue;
                                }
                                found = true;
                            }
                            if (found && !strcmp((const char *)bin->symstr + stridx, sym_name)) {
                                sym_ord = j;
                                break;
                            }
                        }
                    }
                    break;
                }
                case BIND_OPCODE_SET_TYPE_IMM:
                    type = imm;
                    break;
                case BIND_OPCODE_SET_ADDEND_SLEB:
                    addend = rz_sleb128((const ut8 **)&p, end);
                    break;
                case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
                    seg_idx = imm;
                    if (seg_idx >= bin->nsegs) {
                        RZ_LOG_ERROR("Error: BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB"
                                 " has unexistent segment %d\n",
                            seg_idx);
                        free(opcodes);
                        rz_skiplist_free(relocs);
                        rz_pvector_free(threaded_binds);
                        return NULL; // early exit to avoid future mayhem
                    }
                    addr = bin->segs[seg_idx].vmaddr + read_uleb128(&p, end);
                    segment_end_addr = bin->segs[seg_idx].vmaddr + bin->segs[seg_idx].vmsize;
                    break;
                case BIND_OPCODE_ADD_ADDR_ULEB:
                    addr += read_uleb128(&p, end);
                    break;
#define DO_BIND() \
    do { \
        if (sym_ord < 0 && !sym_name) \
            break; \
        if (!threaded_binds) { \
            if (seg_idx < 0) \
                break; \
            if (!addr) \
                break; \
        } \
        struct reloc_t *reloc = RZ_NEW0(struct reloc_t); \
        reloc->addr = addr; \
        if (seg_idx >= 0) { \
            reloc->offset = addr - bin->segs[seg_idx].vmaddr + bin->segs[seg_idx].fileoff; \
            if (type == BIND_TYPE_TEXT_PCREL32) \
                reloc->addend = addend - (bin->baddr + addr); \
            else \
                reloc->addend = addend; \
        } else { \
            reloc->addend = addend; \
        } \
        /* library ordinal ??? */ \
        reloc->ord = lib_ord; \
        reloc->ord = sym_ord; \
        reloc->type = rel_type; \
        if (sym_name) \
            rz_str_ncpy(reloc->name, sym_name, 256); \
        if (threaded_binds) \
            rz_pvector_set(threaded_binds, sym_ord, reloc); \
        else \
            rz_skiplist_insert(relocs, reloc); \
    } while (0)
                case BIND_OPCODE_DO_BIND:
                    if (!threaded_binds && addr >= segment_end_addr) {
                        RZ_LOG_ERROR("Error: Malformed DO bind opcode 0x%" PFMT64x "\n", addr);
                        goto beach;
                    }
                    DO_BIND();
                    if (!threaded_binds) {
                        addr += wordsize;
                    } else {
                        sym_ord++;
                    }
                    break;
                case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
                    if (addr >= segment_end_addr) {
                        RZ_LOG_ERROR("Error: Malformed ADDR ULEB bind opcode\n");
                        goto beach;
                    }
                    DO_BIND();
                    addr += read_uleb128(&p, end) + wordsize;
                    break;
                case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
                    if (addr >= segment_end_addr) {
                        RZ_LOG_ERROR("Error: Malformed IMM SCALED bind opcode\n");
                        goto beach;
                    }
                    DO_BIND();
                    addr += (ut64)imm * (ut64)wordsize + wordsize;
                    break;
                case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
                    count = read_uleb128(&p, end);
                    skip = read_uleb128(&p, end);
                    for (j = 0; j < count; j++) {
                        if (addr >= segment_end_addr) {
                            RZ_LOG_ERROR("Error: Malformed ULEB TIMES bind opcode\n");
                            goto beach;
                        }
                        DO_BIND();
                        addr += skip + wordsize;
                    }
                    break;
#undef DO_BIND
                default:
                    RZ_LOG_ERROR("Error: unknown bind opcode 0x%02x in dyld_info\n", *p);
                    RZ_FREE(opcodes);
                    goto beach;
                }
            }
 
            opcodes_offset += partition_size;
        }
 
        RZ_FREE(opcodes);
        rz_pvector_free(threaded_binds);
        threaded_binds = NULL;
    }
 
    if (bin->symtab && bin->symstr && bin->sects && bin->indirectsyms) {
        int j;
        int amount = bin->dysymtab.nundefsym;
        if (amount < 0) {
            amount = 0;
        }
        if (!relocs) {
            relocs = rz_skiplist_new((RzListFree)&free, (RzListComparator)&reloc_comparator);
            if (!relocs) {
                return NULL;
            }
        }
        for (j = 0; j < amount; j++) {
            struct reloc_t *reloc = RZ_NEW0(struct reloc_t);
            if (!reloc) {
                break;
            }
            if (parse_import_ptr(bin, reloc, bin->dysymtab.iundefsym + j)) {
                reloc->ord = j;
                rz_skiplist_insert(relocs, reloc);
            } else {
                RZ_FREE(reloc);
            }
        }
    }
 
    if (bin->symtab && bin->dysymtab.extreloff && bin->dysymtab.nextrel) {
        if (!relocs) {
            relocs = rz_skiplist_new((RzListFree)&free, (RzListComparator)&reloc_comparator);
            if (!relocs) {
                return NULL;
            }
        }
        parse_relocation_info(bin, relocs, bin->dysymtab.extreloff, bin->dysymtab.nextrel);
    }
beach:
    rz_pvector_free(threaded_binds);
    bin->relocs = relocs;
    return relocs;
}

References reloc_t::addend, dyld_chained_ptr_arm64e_bind::addend, addr, reloc_t::addr, BIND_IMMEDIATE_MASK, BIND_OPCODE_ADD_ADDR_ULEB, BIND_OPCODE_DO_BIND, BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED, BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB, BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB, BIND_OPCODE_DONE, BIND_OPCODE_MASK, BIND_OPCODE_SET_ADDEND_SLEB, BIND_OPCODE_SET_DYLIB_ORDINAL_IMM, BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB, BIND_OPCODE_SET_DYLIB_SPECIAL_IMM, BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB, BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM, BIND_OPCODE_SET_TYPE_IMM, BIND_OPCODE_THREADED, BIND_SUBOPCODE_THREADED_APPLY, BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB, calloc(), CASE, count, delta, DO_BIND, done, test_evm::end, found, free(), imm, is_valid_ordinal_table_size(), len, NULL, reloc_t::offset, opcodes, reloc_t::ord, dyld_chained_ptr_arm64e_bind::ordinal, dyld_chained_ptr_arm64e_auth_bind::ordinal, p, parse_import_ptr(), parse_relocation_info(), PFMT64x, reloc_comparator(), relocs(), RZ_ARRAY_SIZE, rz_buf_read_at(), RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_pvector_at(), rz_pvector_free(), rz_pvector_len(), rz_pvector_new_with_len(), rz_read_le64(), rz_return_val_if_fail, rz_skiplist_free(), rz_skiplist_insert(), rz_skiplist_new(), rz_sleb128(), skip(), st64, st8, autogen_x86imm::tmp, type, UT16_MAX, UT32_MAX, and ut64().

Referenced by get_patchable_relocs(), parse_classes(), and relocs().

get_sections()

struct section_t* MACH0_() get_sections

(

struct MACH0_(obj_t) *

bin

)

Definition at line 2411 of file mach0.c.

                                                                   {
    rz_return_val_if_fail(bin, NULL);
    struct section_t *sections;
    char sectname[64], raw_segname[17];
    size_t i, j, to;
 
    /* for core files */
    if (bin->nsects < 1 && bin->nsegs > 0) {
        struct MACH0_(segment_command) * seg;
        if (!(sections = calloc((bin->nsegs + 1), sizeof(struct section_t)))) {
            return NULL;
        }
        for (i = 0; i < bin->nsegs; i++) {
            seg = &bin->segs[i];
            sections[i].addr = seg->vmaddr;
            sections[i].offset = seg->fileoff;
            sections[i].size = seg->vmsize;
            sections[i].vsize = seg->vmsize;
            sections[i].align = 4096;
            sections[i].flags = seg->flags;
            rz_strf(sectname, "%.16s", seg->segname);
            sectname[16] = 0;
            rz_str_filter(sectname);
            // hack to support multiple sections with same name
            sections[i].perm = prot2perm(seg->initprot);
            sections[i].last = 0;
        }
        sections[i].last = 1;
        return sections;
    }
 
    if (!bin->sects) {
        return NULL;
    }
    to = RZ_MIN(bin->nsects, 128); // limit number of sections here to avoid fuzzed bins
    if (to < 1) {
        return NULL;
    }
    if (!(sections = calloc(bin->nsects + 1, sizeof(struct section_t)))) {
        return NULL;
    }
    for (i = 0; i < to; i++) {
        sections[i].offset = (ut64)bin->sects[i].offset;
        sections[i].addr = (ut64)bin->sects[i].addr;
        sections[i].size = (bin->sects[i].flags == S_ZEROFILL) ? 0 : (ut64)bin->sects[i].size;
        sections[i].vsize = (ut64)bin->sects[i].size;
        sections[i].align = bin->sects[i].align;
        sections[i].flags = bin->sects[i].flags;
        rz_strf(sectname, "%.16s", bin->sects[i].sectname);
        rz_str_filter(sectname);
        rz_strf(raw_segname, "%.16s", bin->sects[i].segname);
        for (j = 0; j < bin->nsegs; j++) {
            if (sections[i].addr >= bin->segs[j].vmaddr &&
                sections[i].addr < (bin->segs[j].vmaddr + bin->segs[j].vmsize)) {
                sections[i].perm = prot2perm(bin->segs[j].initprot);
                break;
            }
        }
        snprintf(sections[i].name, sizeof(sections[i].name),
            "%d.%s.%s", (int)i, raw_segname, sectname);
        sections[i].last = 0;
    }
    sections[i].last = 1;
    return sections;
}

References addr, calloc(), i, NULL, prot2perm(), RZ_MIN, rz_return_val_if_fail, rz_str_filter(), rz_strf, S_ZEROFILL, sections(), snprintf, to, and ut64().

Referenced by carve_kexts(), classes(), estimate_slide(), get_prelink_info_range_from_mach0(), get_stubs_info(), parse_categories(), parse_classes(), process_constructors(), process_kmod_init_term(), rebase_info_populate(), resolve_mig_subsystem(), resolve_syscalls(), rz_dyldcache_get_objc_opt_info(), rz_kext_fill_text_range(), rz_rebase_info_new_from_mach0(), sections_from_bin(), and sections_from_mach0().

get_segments()

RzList* MACH0_() get_segments

(

RzBinFile *

bf

)

Definition at line 2267 of file mach0.c.

                                            {
    struct MACH0_(obj_t) *bin = bf->o->bin_obj;
    if (bin->sections_cache) {
        return bin->sections_cache;
    }
    RzList *list = rz_list_newf((RzListFree)rz_bin_section_free);
    size_t i, j;
 
    if (bin->nsegs > 0) {
        struct MACH0_(segment_command) * seg;
        for (i = 0; i < bin->nsegs; i++) {
            seg = &bin->segs[i];
            if (!seg->initprot) {
                continue;
            }
            RzBinSection *s = rz_bin_section_new(NULL);
            if (!s) {
                break;
            }
            s->vaddr = seg->vmaddr;
            s->vsize = seg->vmsize;
            s->size = seg->vmsize;
            s->paddr = seg->fileoff;
            s->paddr += bf->o->boffset;
            // TODO s->flags = seg->flags;
            s->name = rz_str_ndup(seg->segname, 16);
            s->is_segment = true;
            rz_str_filter(s->name);
            s->perm = prot2perm(seg->initprot);
            rz_list_append(list, s);
        }
    }
    if (bin->nsects > 0) {
        int last_section = RZ_MIN(bin->nsects, 128); // maybe drop this limit?
        for (i = 0; i < last_section; i++) {
            RzBinSection *s = RZ_NEW0(RzBinSection);
            if (!s) {
                break;
            }
            s->vaddr = (ut64)bin->sects[i].addr;
            s->vsize = (ut64)bin->sects[i].size;
            s->align = (ut64)(1ULL << (bin->sects[i].align & 63));
            s->is_segment = false;
            s->size = (bin->sects[i].flags == S_ZEROFILL) ? 0 : (ut64)bin->sects[i].size;
            // The bottom byte of flags is the section type
            s->type = bin->sects[i].flags & 0xFF;
            s->flags = bin->sects[i].flags & 0xFFFFFF00;
            // XXX flags
            s->paddr = (ut64)bin->sects[i].offset;
            int segment_index = 0;
            // s->perm =prot2perm (bin->segs[j].initprot);
            for (j = 0; j < bin->nsegs; j++) {
                if (s->vaddr >= bin->segs[j].vmaddr &&
                    s->vaddr < (bin->segs[j].vmaddr + bin->segs[j].vmsize)) {
                    s->perm = prot2perm(bin->segs[j].initprot);
                    segment_index = j;
                    break;
                }
            }
            char *section_name = rz_str_ndup(bin->sects[i].sectname, 16);
            char *segment_name = rz_str_newf("%zu.%s", i, bin->segs[segment_index].segname);
            s->name = rz_str_newf("%s.%s", segment_name, section_name);
            s->is_data = __isDataSection(s);
            if (strstr(section_name, "interpos") || strstr(section_name, "__mod_")) {
#if RZ_BIN_MACH064
                const int ws = 8;
#else
                const int ws = 4;
#endif
                s->format = rz_str_newf("Cd %d[%" PFMT64d "]", ws, s->vsize / ws);
            }
            rz_list_append(list, s);
            free(segment_name);
            free(section_name);
        }
    }
    bin->sections_cache = list;
    return list;
}

References __isDataSection(), free(), i, list(), NULL, PFMT64d, prot2perm(), rz_bin_section_free(), rz_bin_section_new(), rz_list_append(), rz_list_newf(), RZ_MIN, RZ_NEW0, rz_str_filter(), rz_str_ndup(), rz_str_newf(), s, S_ZEROFILL, and ut64().

Referenced by sections().

get_symbols()

const struct symbol_t* MACH0_() get_symbols

(

struct MACH0_(obj_t) *

bin

)

Definition at line 2959 of file mach0.c.

                                                                       {
    struct symbol_t *symbols;
    int j, s, stridx, symbols_size, symbols_count;
    ut32 to, from, i;
 
    if (bin->symbols) {
        return bin->symbols;
    }
 
    HtPP *hash = ht_pp_new0();
    if (!hash) {
        return NULL;
    }
 
    rz_return_val_if_fail(bin, NULL);
    int n_exports = walk_exports(bin, NULL, NULL);
 
    symbols_count = n_exports;
    j = 0; // symbol_idx
 
    int bits = MACH0_(get_bits_from_hdr)(&bin->hdr);
    if (bin->symtab && bin->symstr) {
        /* parse dynamic symbol table */
        symbols_count = (bin->dysymtab.nextdefsym +
            bin->dysymtab.nlocalsym +
            bin->dysymtab.nundefsym);
        symbols_count += bin->nsymtab;
        if (symbols_count < 0 || ((st64)symbols_count * 2) > ST32_MAX) {
            eprintf("Symbols count overflow\n");
            ht_pp_free(hash);
            return NULL;
        }
        symbols_size = (symbols_count + 1) * 2 * sizeof(struct symbol_t);
 
        if (symbols_size < 1) {
            ht_pp_free(hash);
            return NULL;
        }
        if (!(symbols = calloc(1, symbols_size))) {
            ht_pp_free(hash);
            return NULL;
        }
        bin->main_addr = 0;
        for (s = 0; s < 2; s++) {
            switch (s) {
            case 0:
                from = bin->dysymtab.iextdefsym;
                to = from + bin->dysymtab.nextdefsym;
                break;
            case 1:
                from = bin->dysymtab.ilocalsym;
                to = from + bin->dysymtab.nlocalsym;
                break;
#if NOT_USED
            case 2:
                from = bin->dysymtab.iundefsym;
                to = from + bin->dysymtab.nundefsym;
                break;
#endif
            }
            if (from == to) {
                continue;
            }
 
            from = RZ_MIN(RZ_MAX(0, from), symbols_size / sizeof(struct symbol_t));
            to = RZ_MIN(RZ_MIN(to, bin->nsymtab), symbols_size / sizeof(struct symbol_t));
 
            ut32 maxsymbols = symbols_size / sizeof(struct symbol_t);
            if (symbols_count >= maxsymbols) {
                symbols_count = maxsymbols - 1;
                eprintf("macho warning: Symbol table truncated\n");
            }
            for (i = from; i < to && j < symbols_count; i++, j++) {
                symbols[j].offset = MACH0_(vaddr_to_paddr)(bin, bin->symtab[i].n_value);
                symbols[j].addr = bin->symtab[i].n_value;
                symbols[j].size = 0; /* TODO: Is it anywhere? */
                symbols[j].bits = bin->symtab[i].n_desc & N_ARM_THUMB_DEF ? 16 : bits;
                symbols[j].is_imported = false;
                symbols[j].type = (bin->symtab[i].n_type & N_EXT)
                    ? RZ_BIN_MACH0_SYMBOL_TYPE_EXT
                    : RZ_BIN_MACH0_SYMBOL_TYPE_LOCAL;
                stridx = bin->symtab[i].n_strx;
                symbols[j].name = MACH0_(get_name)(bin, stridx, false);
                symbols[j].last = false;
 
                const char *name = symbols[j].name;
                if (bin->main_addr == 0 && name) {
                    if (!strcmp(name, "__Dmain")) {
                        bin->main_addr = symbols[j].addr;
                    } else if (strstr(name, "4main") && !strstr(name, "STATIC")) {
                        bin->main_addr = symbols[j].addr;
                    } else if (!strcmp(name, "_main")) {
                        bin->main_addr = symbols[j].addr;
                    } else if (!strcmp(name, "main")) {
                        bin->main_addr = symbols[j].addr;
                    }
                }
                if (inSymtab(hash, symbols[j].name, symbols[j].addr)) {
                    free(symbols[j].name);
                    symbols[j].name = NULL;
                    j--;
                }
            }
        }
        to = RZ_MIN((ut32)bin->nsymtab, bin->dysymtab.iundefsym + bin->dysymtab.nundefsym);
        for (i = bin->dysymtab.iundefsym; i < to; i++) {
            if (j > symbols_count) {
                bprintf("mach0-get-symbols: error\n");
                break;
            }
            if (parse_import_stub(bin, &symbols[j], i)) {
                symbols[j++].last = false;
            }
        }
 
        for (i = 0; i < bin->nsymtab && i < symbols_count; i++) {
            struct MACH0_(nlist) *st = &bin->symtab[i];
            if (st->n_type & N_STAB) {
                continue;
            }
            // 0 is for imports
            // 1 is for symbols
            // 2 is for func.eh (exception handlers?)
            int section = st->n_sect;
            if (section == 1 && j < symbols_count) {
                // check if symbol exists already
                /* is symbol */
                symbols[j].addr = st->n_value;
                symbols[j].offset = MACH0_(vaddr_to_paddr)(bin, symbols[j].addr);
                symbols[j].size = 0; /* find next symbol and crop */
                symbols[j].type = (st->n_type & N_EXT)
                    ? RZ_BIN_MACH0_SYMBOL_TYPE_EXT
                    : RZ_BIN_MACH0_SYMBOL_TYPE_LOCAL;
                char *sym_name = MACH0_(get_name)(bin, st->n_strx, false);
                if (sym_name) {
                    symbols[j].name = sym_name;
                } else {
                    symbols[j].name = rz_str_newf("entry%d", i);
                }
                symbols[j].last = 0;
                if (inSymtab(hash, symbols[j].name, symbols[j].addr)) {
                    RZ_FREE(symbols[j].name);
                } else {
                    j++;
                }
 
                const char *name = symbols[i].name;
                if (bin->main_addr == 0 && name) {
                    if (name && !strcmp(name, "__Dmain")) {
                        bin->main_addr = symbols[i].addr;
                    } else if (name && strstr(name, "4main") && !strstr(name, "STATIC")) {
                        bin->main_addr = symbols[i].addr;
                    } else if (symbols[i].name && !strcmp(symbols[i].name, "_main")) {
                        bin->main_addr = symbols[i].addr;
                    }
                }
            }
        }
    } else if (!n_exports) {
        ht_pp_free(hash);
        return NULL;
    } else {
        symbols_size = (symbols_count + 1) * sizeof(struct symbol_t);
        if (symbols_size < 1) {
            ht_pp_free(hash);
            return NULL;
        }
        if (!(symbols = calloc(1, symbols_size))) {
            ht_pp_free(hash);
            return NULL;
        }
    }
    if (n_exports && (symbols_count - j) >= n_exports) {
        RSymCtx sym_ctx;
        sym_ctx.symbols = symbols;
        sym_ctx.j = j;
        sym_ctx.symbols_count = symbols_count;
        sym_ctx.hash = hash;
        walk_exports(bin, assign_export_symbol_t, &sym_ctx);
        j = sym_ctx.j;
    }
    ht_pp_free(hash);
    symbols[j].last = true;
    bin->symbols = symbols;
    return symbols;
}

References addr, assign_export_symbol_t(), bits(), bprintf, calloc(), eprintf, free(), from, get_bits_from_hdr(), get_name(), RSymCtx::hash, i, inSymtab(), RSymCtx::j, MACH0_(), N_ARM_THUMB_DEF, N_EXT, N_STAB, NULL, parse_import_stub(), RZ_BIN_MACH0_SYMBOL_TYPE_EXT, RZ_BIN_MACH0_SYMBOL_TYPE_LOCAL, RZ_FREE, RZ_MAX, RZ_MIN, rz_return_val_if_fail, rz_str_newf(), s, ST32_MAX, st64, RSymCtx::symbols, symbols(), RSymCtx::symbols_count, to, vaddr_to_paddr(), and walk_exports().

Referenced by get_main(), symbols(), symbols_from_bin(), and symbols_from_mach0().

get_symbols_list()

const RzList* MACH0_() get_symbols_list

(

struct MACH0_(obj_t) *

bin

)

Definition at line 2761 of file mach0.c.

                                                                   {
    static RzList *cache = NULL; // XXX DONT COMMIT WITH THIS
    struct symbol_t *symbols;
    size_t j, s, symbols_size, symbols_count;
    ut32 to, from;
    size_t i;
 
    rz_return_val_if_fail(bin, NULL);
    if (cache) {
        return cache;
    }
    RzList *list = rz_list_newf((RzListFree)rz_bin_symbol_free);
    cache = list;
 
    HtPP *hash = ht_pp_new0();
    if (!hash) {
        return NULL;
    }
 
    walk_exports(bin, fill_exports_list, list);
    if (rz_list_length(list)) {
        RzListIter *it;
        RzBinSymbol *s;
        rz_list_foreach (list, it, s) {
            inSymtab(hash, s->name, s->vaddr);
        }
    }
 
    if (!bin->symtab || !bin->symstr) {
        ht_pp_free(hash);
        return list;
    }
    /* parse dynamic symbol table */
    symbols_count = (bin->dysymtab.nextdefsym +
        bin->dysymtab.nlocalsym +
        bin->dysymtab.nundefsym);
    symbols_count += bin->nsymtab;
    symbols_size = (symbols_count + 1) * 2 * sizeof(struct symbol_t);
 
    if (symbols_size < 1) {
        return NULL;
    }
    if (!(symbols = calloc(1, symbols_size))) {
        return NULL;
    }
    j = 0; // symbol_idx
    bin->main_addr = 0;
    int bits = MACH0_(get_bits_from_hdr)(&bin->hdr);
    for (s = 0; s < 2; s++) {
        switch (s) {
        case 0:
            from = bin->dysymtab.iextdefsym;
            to = from + bin->dysymtab.nextdefsym;
            break;
        case 1:
            from = bin->dysymtab.ilocalsym;
            to = from + bin->dysymtab.nlocalsym;
            break;
#if NOT_USED
        case 2:
            from = bin->dysymtab.iundefsym;
            to = from + bin->dysymtab.nundefsym;
            break;
#endif
        }
        if (from == to) {
            continue;
        }
 
        from = RZ_MIN(RZ_MAX(0, from), symbols_size / sizeof(struct symbol_t));
        to = RZ_MIN(RZ_MIN(to, bin->nsymtab), symbols_size / sizeof(struct symbol_t));
 
        ut32 maxsymbols = symbols_size / sizeof(struct symbol_t);
        if (symbols_count >= maxsymbols) {
            symbols_count = maxsymbols - 1;
            eprintf("macho warning: Symbol table truncated\n");
        }
        for (i = from; i < to && j < symbols_count; i++, j++) {
            RzBinSymbol *sym = RZ_NEW0(RzBinSymbol);
            sym->vaddr = bin->symtab[i].n_value;
            sym->paddr = MACH0_(vaddr_to_paddr)(bin, sym->vaddr);
            symbols[j].size = 0; /* TODO: Is it anywhere? */
            sym->bits = bin->symtab[i].n_desc & N_ARM_THUMB_DEF ? 16 : bits;
 
            if (bin->symtab[i].n_type & N_EXT) {
                sym->type = "EXT";
            } else {
                sym->type = "LOCAL";
            }
            int stridx = bin->symtab[i].n_strx;
            char *sym_name = MACH0_(get_name)(bin, stridx, false);
            if (sym_name) {
                sym->name = sym_name;
                if (!bin->main_addr || bin->main_addr == UT64_MAX) {
                    const char *name = sym->name;
                    if (!strcmp(name, "__Dmain")) {
                        bin->main_addr = symbols[j].addr;
                    } else if (strstr(name, "4main") && !strstr(name, "STATIC")) {
                        bin->main_addr = symbols[j].addr;
                    } else if (!strcmp(name, "_main")) {
                        bin->main_addr = symbols[j].addr;
                    } else if (!strcmp(name, "main")) {
                        bin->main_addr = symbols[j].addr;
                    }
                }
            } else {
                sym->name = rz_str_newf("unk%zu", i);
            }
            if (!inSymtab(hash, sym->name, sym->vaddr)) {
                rz_list_append(list, sym);
            } else {
                rz_bin_symbol_free(sym);
            }
        }
    }
    to = RZ_MIN((ut32)bin->nsymtab, bin->dysymtab.iundefsym + bin->dysymtab.nundefsym);
    for (i = bin->dysymtab.iundefsym; i < to; i++) {
        struct symbol_t symbol;
        if (j > symbols_count) {
            bprintf("mach0-get-symbols: error\n");
            break;
        }
        if (parse_import_stub(bin, &symbol, i)) {
            j++;
            RzBinSymbol *sym = RZ_NEW0(RzBinSymbol);
            sym->vaddr = symbol.addr;
            sym->paddr = symbol.offset;
            sym->name = symbol.name;
            if (!sym->name) {
                sym->name = rz_str_newf("unk%zu", i);
            }
            sym->is_imported = symbol.is_imported;
            rz_list_append(list, sym);
        }
    }
 
    for (i = 0; i < bin->nsymtab; i++) {
        struct MACH0_(nlist) *st = &bin->symtab[i];
        // 0 is for imports
        // 1 is for symbols
        // 2 is for func.eh (exception handlers?)
        int section = st->n_sect;
        if (section == 1 && j < symbols_count) { // text ??st->n_type == 1) maybe wrong
            RzBinSymbol *sym = RZ_NEW0(RzBinSymbol);
            /* is symbol */
            sym->vaddr = st->n_value;
            sym->paddr = MACH0_(vaddr_to_paddr)(bin, symbols[j].addr);
            sym->is_imported = symbols[j].is_imported;
            if (st->n_type & N_EXT) {
                sym->type = "EXT";
            } else {
                sym->type = "LOCAL";
            }
            char *sym_name = MACH0_(get_name)(bin, st->n_strx, false);
            if (sym_name) {
                sym->name = sym_name;
                if (inSymtab(hash, sym->name, sym->vaddr)) {
                    rz_bin_symbol_free(sym);
                    continue;
                }
                if (!bin->main_addr || bin->main_addr == UT64_MAX) {
                    const char *name = sym->name;
                    if (!strcmp(name, "__Dmain")) {
                        bin->main_addr = symbols[i].addr;
                    } else if (strstr(name, "4main") && !strstr(name, "STATIC")) {
                        bin->main_addr = symbols[i].addr;
                    } else if (!strcmp(symbols[i].name, "_main")) {
                        bin->main_addr = symbols[i].addr;
                    }
                }
            } else {
                sym->name = rz_str_newf("unk%zu", i);
            }
            rz_list_append(list, sym);
            j++;
        }
    }
    ht_pp_free(hash);
    free(symbols);
    return list;
}

References symbol_t::addr, rz_bin_symbol_t::bits, bits(), bprintf, calloc(), eprintf, fill_exports_list(), free(), from, get_bits_from_hdr(), get_name(), i, inSymtab(), symbol_t::is_imported, rz_bin_symbol_t::is_imported, list(), MACH0_(), N_ARM_THUMB_DEF, N_EXT, symbol_t::name, rz_bin_symbol_t::name, NULL, symbol_t::offset, rz_bin_symbol_t::paddr, parse_import_stub(), rz_bin_symbol_free(), rz_list_append(), rz_list_length(), rz_list_newf(), RZ_MAX, RZ_MIN, RZ_NEW0, rz_return_val_if_fail, rz_str_newf(), s, symbols(), to, rz_bin_symbol_t::type, UT64_MAX, rz_bin_symbol_t::vaddr, vaddr_to_paddr(), and walk_exports().

Referenced by get_main().

get_virtual_files()

RzList* MACH0_() get_virtual_files

(

RzBinFile *

bf

)

Definition at line 2162 of file mach0.c.

                                                 {
    rz_return_val_if_fail(bf, NULL);
    RzList *ret = rz_list_newf((RzListFree)rz_bin_virtual_file_free);
    if (!ret) {
        return NULL;
    }
 
    // rebasing+stripping for arm64e
    struct MACH0_(obj_t) *obj = bf->o->bin_obj;
    if (MACH0_(needs_rebasing_and_stripping)(obj)) {
        RzBinVirtualFile *vf = RZ_NEW0(RzBinVirtualFile);
        if (!vf) {
            return ret;
        }
        vf->buf = MACH0_(new_rebasing_and_stripping_buf)(obj);
        vf->buf_owned = true;
        vf->name = strdup(MACH0_VFILE_NAME_REBASED_STRIPPED);
        rz_list_push(ret, vf);
    }
 
    // clang-format off
    // relocs
    MACH0_(patch_relocs)(bf, obj);
    // clang-format: on
    // virtual file for reloc targets (where the relocs will point into)
    ut64 rtmsz = MACH0_(reloc_targets_vfile_size)(obj);
    if (rtmsz) {
        RzBuffer *buf = rz_buf_new_empty(rtmsz);
        if (!buf) {
            return ret;
        }
        RzBinVirtualFile *vf = RZ_NEW0(RzBinVirtualFile);
        if (!vf) {
            rz_buf_free(buf);
            return ret;
        }
        vf->buf = buf;
        vf->buf_owned = true;
        vf->name = strdup(MACH0_VFILE_NAME_RELOC_TARGETS);
        rz_list_push(ret, vf);
    }
    // virtual file mirroring the raw file, but with relocs patched
    if (obj->buf_patched) {
        RzBinVirtualFile *vf = RZ_NEW0(RzBinVirtualFile);
        if (!vf) {
            return ret;
        }
        vf->buf = obj->buf_patched;
        vf->buf_owned = false;
        vf->name = strdup(MACH0_VFILE_NAME_PATCHED);
        rz_list_push(ret, vf);
    }
    return ret;
}

References rz_bin_virtual_file_t::buf, rz_bin_virtual_file_t::buf_owned, MACH0_(), MACH0_VFILE_NAME_PATCHED, MACH0_VFILE_NAME_REBASED_STRIPPED, MACH0_VFILE_NAME_RELOC_TARGETS, rz_bin_virtual_file_t::name, needs_rebasing_and_stripping(), new_rebasing_and_stripping_buf(), NULL, patch_relocs(), reloc_targets_vfile_size(), rz_bin_virtual_file_free(), rz_buf_free(), rz_buf_new_empty(), rz_list_newf(), rz_list_push(), RZ_NEW0, rz_return_val_if_fail, strdup(), and ut64().

Referenced by virtual_files().

has_nx()

bool MACH0_() has_nx

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3554 of file mach0.c.

                                                {
    return (bin && bin->hdr.filetype == MH_EXECUTE &&
        bin->hdr.flags & MH_NO_HEAP_EXECUTION);
}

References MH_EXECUTE, and MH_NO_HEAP_EXECUTION.

Referenced by info().

is_big_endian()

bool MACH0_() is_big_endian

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3312 of file mach0.c.

                                                       {
    if (bin) {
        const int cpu = bin->hdr.cputype;
        return cpu == CPU_TYPE_POWERPC || cpu == CPU_TYPE_POWERPC64;
    }
    return false;
}

References cpu, CPU_TYPE_POWERPC, and CPU_TYPE_POWERPC64.

Referenced by info(), and rz_debruijn_offset().

is_pie()

bool MACH0_() is_pie

(

struct MACH0_(obj_t) *

bin

)

Definition at line 3550 of file mach0.c.

                                                {
    return (bin && bin->hdr.filetype == MH_EXECUTE && bin->hdr.flags & MH_PIE);
}

References MH_EXECUTE, and MH_PIE.

Referenced by info().

MACH0_() [1/3]

struct MACH0_

(

mach_header

)

Definition at line 3969 of file mach0.c.

                                                            {
    ut8 magicbytes[sizeof(ut32)] = { 0 };
    ut8 machohdrbytes[sizeof(struct MACH0_(mach_header))] = { 0 };
    int len;
    struct MACH0_(mach_header) *macho_hdr = RZ_NEW0(struct MACH0_(mach_header));
    bool big_endian = false;
    if (!macho_hdr) {
        return NULL;
    }
    if (rz_buf_read_at(buf, 0, magicbytes, 4) < 1) {
        free(macho_hdr);
        return false;
    }
 
    if (rz_read_le32(magicbytes) == 0xfeedface) {
        big_endian = false;
    } else if (rz_read_be32(magicbytes) == 0xfeedface) {
        big_endian = true;
    } else if (rz_read_le32(magicbytes) == FAT_MAGIC) {
        big_endian = false;
    } else if (rz_read_be32(magicbytes) == FAT_MAGIC) {
        big_endian = true;
    } else if (rz_read_le32(magicbytes) == 0xfeedfacf) {
        big_endian = false;
    } else if (rz_read_be32(magicbytes) == 0xfeedfacf) {
        big_endian = true;
    } else {
        /* also extract non-mach0s */
#if 0
        free (macho_hdr);
        return NULL;
#endif
    }
    len = rz_buf_read_at(buf, 0, machohdrbytes, sizeof(machohdrbytes));
    if (len != sizeof(struct MACH0_(mach_header))) {
        free(macho_hdr);
        return NULL;
    }
    macho_hdr->magic = rz_read_ble(&machohdrbytes[0], big_endian, 32);
    macho_hdr->cputype = rz_read_ble(&machohdrbytes[4], big_endian, 32);
    macho_hdr->cpusubtype = rz_read_ble(&machohdrbytes[8], big_endian, 32);
    macho_hdr->filetype = rz_read_ble(&machohdrbytes[12], big_endian, 32);
    macho_hdr->ncmds = rz_read_ble(&machohdrbytes[16], big_endian, 32);
    macho_hdr->sizeofcmds = rz_read_ble(&machohdrbytes[20], big_endian, 32);
    macho_hdr->flags = rz_read_ble(&machohdrbytes[24], big_endian, 32);
#if RZ_BIN_MACH064
    macho_hdr->reserved = rz_read_ble(&machohdrbytes[28], big_endian, 32);
#endif
    return macho_hdr;
}

References addr, cmd_to_pf_definition(), cmd_to_string(), CPU_TYPE_POWERPC, CPU_TYPE_POWERPC64, eprintf, f, free(), i, LC_BUILD_VERSION, LC_SEGMENT, LC_SEGMENT_64, length, MACH0_(), n, NULL, off, pa2va(), rz_bin_field_free(), rz_bin_field_new(), rz_buf_read_le32_at, rz_buf_size(), rz_list_append(), rz_list_newf(), sdb_fmt(), and ut64().

MACH0_() [2/3]

struct MACH0_

(

obj_t

)

< lazily loaded, use only MACH0_(get_relocs)() to access this

< whether relocs have already been parsed and relocs is filled (or NULL on error)

< weak pointers to relocs in relocs which should be patched

Definition at line 1 of file mach0.h.

                     {
    struct MACH0_(opts_t) options;
    struct MACH0_(mach_header) hdr;
    struct MACH0_(segment_command) * segs;
    char *intrp;
    char *compiler;
    int nsegs;
    struct rz_dyld_chained_starts_in_segment **chained_starts;
    ut32 nchained_starts;
    struct MACH0_(section) * sects;
    int nsects;
    struct MACH0_(nlist) * symtab;
    ut8 *symstr;
    ut8 *func_start; // buffer that hold the data from LC_FUNCTION_STARTS
    int symstrlen;
    int nsymtab;
    ut32 *indirectsyms;
    int nindirectsyms;
 
    RzBinImport **imports_by_ord;
    size_t imports_by_ord_size;
    HtPP *imports_by_name;
 
    struct dysymtab_command dysymtab;
    struct load_command main_cmd;
    struct dyld_info_command *dyld_info;
    struct dylib_table_of_contents *toc;
    int ntoc;
    struct MACH0_(dylib_module) * modtab;
    int nmodtab;
    struct thread_command thread;
    ut8 *signature;
    union {
        struct x86_thread_state32 x86_32;
        struct x86_thread_state64 x86_64;
        struct ppc_thread_state32 ppc_32;
        struct ppc_thread_state64 ppc_64;
        struct arm_thread_state32 arm_32;
        struct arm_thread_state64 arm_64;
    } thread_state;
    char (*libs)[RZ_BIN_MACH0_STRING_LENGTH];
    int nlibs;
    int size;
    ut64 baddr;
    ut64 entry;
    bool big_endian;
    const char *file;
    RzBuffer *b;
    int os;
    Sdb *kv;
    int has_crypto;
    int has_canary;
    int has_retguard;
    int has_sanitizers;
    int has_blocks_ext;
    int dbg_info;
    const char *lang;
    int uuidn;
    int func_size;
    void *user;
    ut64 (*va2pa)(ut64 p, ut32 *offset, ut32 *left, RzBinFile *bf);
    struct symbol_t *symbols;
    ut64 main_addr;
 
    RzList *sections_cache;
    RzSkipList *relocs; 
    bool relocs_parsed; 
    bool reloc_targets_map_base_calculated;
    bool relocs_patched;
    RzBuffer *buf_patched;
    ut64 reloc_targets_map_base;
    RzPVector /* <struct reloc_t> */ *patchable_relocs; 
    RzHash *hash;
};

MACH0_() [3/3]

struct struct MACH0_

(

opts_t

)

Definition at line 1 of file mach0.h.

                      {
    bool verbose;
    ut64 header_at;
    ut64 symbols_off;
    bool patch_relocs;
};

mach0_free()

void* MACH0_() mach0_free

(

struct MACH0_(obj_t) *

bin

)

Definition at line 2057 of file mach0.c.

                                                    {
    if (!mo) {
        return NULL;
    }
 
    size_t i;
    if (mo->symbols) {
        for (i = 0; !mo->symbols[i].last; i++) {
            free(mo->symbols[i].name);
        }
        free(mo->symbols);
    }
    free(mo->segs);
    free(mo->sects);
    free(mo->symtab);
    free(mo->symstr);
    free(mo->indirectsyms);
    free(mo->imports_by_ord);
    if (mo->imports_by_name) {
        ht_pp_free(mo->imports_by_name);
    }
    free(mo->dyld_info);
    free(mo->toc);
    free(mo->modtab);
    free(mo->libs);
    free(mo->func_start);
    free(mo->signature);
    free(mo->intrp);
    free(mo->compiler);
    if (mo->chained_starts) {
        for (i = 0; i < mo->nchained_starts; i++) {
            if (mo->chained_starts[i]) {
                free(mo->chained_starts[i]->page_start);
                free(mo->chained_starts[i]);
            }
        }
        free(mo->chained_starts);
    }
    rz_pvector_free(mo->patchable_relocs);
    rz_skiplist_free(mo->relocs);
    rz_hash_free(mo->hash);
    rz_buf_free(mo->b);
    free(mo);
    return NULL;
}

References free(), i, NULL, rz_buf_free(), rz_hash_free(), rz_pvector_free(), and rz_skiplist_free().

Referenced by classes(), destroy(), estimate_slide(), rz_dyldcache_get_objc_opt_info(), rz_kernel_cache_free(), rz_kext_free(), sections_from_bin(), and symbols_from_bin().

mach_fields()

RzList* MACH0_() mach_fields

(

RzBinFile *

bf

)

Definition at line 3969 of file mach0.c.

                                           {
    RzBuffer *buf = bf->buf;
    ut64 length = rz_buf_size(buf);
    struct MACH0_(mach_header) *mh = MACH0_(get_hdr)(buf);
    if (!mh) {
        return NULL;
    }
    RzList *ret = rz_list_newf((RzListFree)rz_bin_field_free);
    if (!ret) {
        free(mh);
        return NULL;
    }
    ut64 addr = pa2va(bf, 0);
    ut64 paddr = 0;
 
    rz_list_append(ret, rz_bin_field_new(addr, addr, 1, "header", "mach0_header", "mach0_header", true));
    addr += 0x20 - 4;
    paddr += 0x20 - 4;
    bool is64 = mh->cputype >> 16;
    if (is64) {
        addr += 4;
        paddr += 4;
    }
 
    bool isBe = false;
    switch (mh->cputype) {
    case CPU_TYPE_POWERPC:
    case CPU_TYPE_POWERPC64:
        isBe = true;
        break;
    }
 
    int n;
    for (n = 0; n < mh->ncmds; n++) {
        ut32 lcType;
        if (!rz_buf_read_ble32_at(buf, paddr, &lcType, isBe)) {
            break;
        }
        ut32 word;
        if (!rz_buf_read_ble32_at(buf, paddr + 4, &word, isBe)) {
            break;
        }
        if (paddr + 8 > length) {
            break;
        }
        ut32 lcSize = word;
        word &= 0xFFFFFF;
        if (lcSize < 1) {
            eprintf("Invalid size for a load command\n");
            break;
        }
        if (word == 0) {
            break;
        }
        const char *pf_definition = cmd_to_pf_definition(lcType);
        if (pf_definition) {
            rz_list_append(ret, rz_bin_field_new(addr, addr, 1, sdb_fmt("load_command_%d_%s", n, cmd_to_string(lcType)), pf_definition, pf_definition, true));
        }
        switch (lcType) {
        case LC_BUILD_VERSION: {
            ut32 ntools;
            if (!rz_buf_read_le32_at(buf, paddr + 20, &ntools)) {
                break;
            }
            ut64 off = 24;
            int j = 0;
            while (off < lcSize && ntools--) {
                rz_list_append(ret, rz_bin_field_new(addr + off, addr + off, 1, sdb_fmt("tool_%d", j++), "mach0_build_version_tool", "mach0_build_version_tool", true));
                off += 8;
            }
            break;
        }
        case LC_SEGMENT:
        case LC_SEGMENT_64: {
            ut32 nsects;
            if (!rz_buf_read_le32_at(buf, addr + (is64 ? 64 : 48), &nsects)) {
                break;
            }
            ut64 off = is64 ? 72 : 56;
            size_t i, j = 0;
            for (i = 0; i < nsects && (addr + off) < length && off < lcSize; i++) {
                const char *sname = is64 ? "mach0_section64" : "mach0_section";
                RzBinField *f = rz_bin_field_new(addr + off, addr + off, 1,
                    sdb_fmt("section_%zu", j++), sname, sname, true);
                rz_list_append(ret, f);
                off += is64 ? 80 : 68;
            }
            break;
        default:
            // TODO
            break;
        }
        }
        addr += word;
        paddr += word;
    }
    free(mh);
    return ret;
}

mach_headerfields()

void MACH0_() mach_headerfields

(

RzBinFile *

bf

)

Definition at line 3633 of file mach0.c.

                                              {
    PrintfCallback cb_printf = bf->rbin->cb_printf;
    if (!cb_printf) {
        cb_printf = printf;
    }
    RzBuffer *buf = bf->buf;
    ut64 length = rz_buf_size(buf);
    int n = 0;
    struct MACH0_(mach_header) *mh = MACH0_(get_hdr)(buf);
    if (!mh) {
        return;
    }
    ut64 pvaddr = pa2va(bf, 0);
    cb_printf("pf.mach0_header @ 0x%08" PFMT64x "\n", pvaddr);
    cb_printf("0x%08" PFMT64x "  Magic       0x%x\n", pvaddr, mh->magic);
    pvaddr += 4;
    cb_printf("0x%08" PFMT64x "  CpuType     0x%x\n", pvaddr, mh->cputype);
    pvaddr += 4;
    cb_printf("0x%08" PFMT64x "  CpuSubType  0x%x\n", pvaddr, mh->cpusubtype);
    pvaddr += 4;
    cb_printf("0x%08" PFMT64x "  FileType    0x%x\n", pvaddr, mh->filetype);
    pvaddr += 4;
    cb_printf("0x%08" PFMT64x "  nCmds       %d\n", pvaddr, mh->ncmds);
    pvaddr += 4;
    cb_printf("0x%08" PFMT64x "  sizeOfCmds  %d\n", pvaddr, mh->sizeofcmds);
    pvaddr += 4;
    cb_printf("0x%08" PFMT64x "  Flags       0x%x\n", pvaddr, mh->flags);
    pvaddr += 4;
    bool is64 = mh->cputype >> 16;
 
    ut64 addr = 0x20 - 4;
    ut32 word = 0;
    ut8 wordbuf[sizeof(word)];
    bool isBe = false;
    switch (mh->cputype) {
    case CPU_TYPE_POWERPC:
    case CPU_TYPE_POWERPC64:
        isBe = true;
        break;
    }
#define READWORD() \
    if (rz_buf_read_at(buf, addr, (ut8 *)wordbuf, 4) != 4) { \
        eprintf("Invalid address in buffer."); \
        break; \
    } \
    addr += 4; \
    pvaddr += 4; \
    word = isBe ? rz_read_be32(wordbuf) : rz_read_le32(wordbuf);
    if (is64) {
        addr += 4;
        pvaddr += 4;
    }
    for (n = 0; n < mh->ncmds; n++) {
        READWORD();
        ut32 lcType = word;
        const char *pf_definition = cmd_to_pf_definition(lcType);
        if (pf_definition) {
            cb_printf("pf.%s @ 0x%08" PFMT64x "\n", pf_definition, pvaddr - 4);
        }
        cb_printf("0x%08" PFMT64x "  cmd %7d 0x%x %s\n",
            pvaddr - 4, n, lcType, cmd_to_string(lcType));
        READWORD();
        if (addr > length) {
            break;
        }
        int lcSize = word;
        word &= 0xFFFFFF;
        cb_printf("0x%08" PFMT64x "  cmdsize     %d\n", pvaddr - 4, word);
        if (lcSize < 1) {
            eprintf("Invalid size for a load command\n");
            break;
        }
        switch (lcType) {
        case LC_BUILD_VERSION: {
            ut32 platform;
            if (!rz_buf_read_le32_at(buf, addr, &platform)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  platform    %s\n", pvaddr, build_version_platform_to_string(platform));
 
            ut16 minos1;
            if (!rz_buf_read_le16_at(buf, addr + 6, &minos1)) {
                break;
            }
            ut8 minos2;
            if (!rz_buf_read8_at(buf, addr + 5, &minos2)) {
                break;
            }
            ut8 minos3;
            if (!rz_buf_read8_at(buf, addr + 4, &minos3)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  minos       %d.%d.%d\n", pvaddr + 4, minos1, minos2, minos3);
 
            ut16 sdk1;
            if (!rz_buf_read_le16_at(buf, addr + 10, &sdk1)) {
                break;
            }
            ut8 sdk2;
            if (!rz_buf_read8_at(buf, addr + 9, &sdk2)) {
                break;
            }
            ut8 sdk3;
            if (!rz_buf_read8_at(buf, addr + 8, &sdk3)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  sdk         %d.%d.%d\n", pvaddr + 8, sdk1, sdk2, sdk3);
 
            ut32 ntools;
            if (!rz_buf_read_le32_at(buf, addr + 12, &ntools)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  ntools      %d\n", pvaddr + 12, ntools);
 
            ut64 off = 16;
            while (off < (lcSize - 8) && ntools--) {
                cb_printf("pf.mach0_build_version_tool @ 0x%08" PFMT64x "\n", pvaddr + off);
 
                ut32 tool;
                if (!rz_buf_read_le32_at(buf, addr + off, &tool)) {
                    break;
                }
                cb_printf("0x%08" PFMT64x "  tool        %s\n", pvaddr + off, build_version_tool_to_string(tool));
 
                off += 4;
                if (off >= (lcSize - 8)) {
                    break;
                }
 
                ut16 version1;
                if (!rz_buf_read_le16_at(buf, addr + off + 2, &version1)) {
                    break;
                }
                ut8 version2;
                if (!rz_buf_read8_at(buf, addr + off + 1, &version2)) {
                    break;
                }
                ut8 version3;
                if (!rz_buf_read8_at(buf, addr + off, &version3)) {
                    break;
                }
                cb_printf("0x%08" PFMT64x "  version     %d.%d.%d\n", pvaddr + off, version1, version2, version3);
 
                off += 4;
            }
            break;
        }
        case LC_MAIN: {
            ut8 data[64] = { 0 };
            rz_buf_read_at(buf, addr, data, sizeof(data));
#if RZ_BIN_MACH064
            ut64 ep = rz_read_ble64(&data, false); //  bin->big_endian);
            cb_printf("0x%08" PFMT64x "  entry0      0x%" PFMT64x "\n", pvaddr, ep);
            ut64 ss = rz_read_ble64(&data[8], false); //  bin->big_endian);
            cb_printf("0x%08" PFMT64x "  stacksize   0x%" PFMT64x "\n", pvaddr + 8, ss);
#else
            ut32 ep = rz_read_ble32(&data, false); //  bin->big_endian);
            cb_printf("0x%08" PFMT32x "  entry0      0x%" PFMT32x "\n", (ut32)pvaddr, ep);
            ut32 ss = rz_read_ble32(&data[4], false); //  bin->big_endian);
            cb_printf("0x%08" PFMT32x "  stacksize   0x%" PFMT32x "\n", (ut32)pvaddr + 4, ss);
#endif
        } break;
        case LC_SYMTAB:
#if 0
            {
            char *id = rz_buf_get_string (buf, addr + 20);
            cb_printf ("0x%08"PFMT64x"  id         0x%x\n", addr + 20, id? id: "");
            cb_printf ("0x%08"PFMT64x"  symooff    0x%x\n", addr + 20, id? id: "");
            cb_printf ("0x%08"PFMT64x"  nsyms      %d\n", addr + 20, id? id: "");
            cb_printf ("0x%08"PFMT64x"  stroff     0x%x\n", addr + 20, id? id: "");
            cb_printf ("0x%08"PFMT64x"  strsize    0x%x\n", addr + 20, id? id: "");
            free (id);
            }
#endif
            break;
        case LC_ID_DYLIB: { // install_name_tool
            ut32 str_off;
            if (!rz_buf_read_ble32_at(buf, addr, &str_off, isBe)) {
                break;
            }
 
            char *id = rz_buf_get_string(buf, addr + str_off - 8);
 
            ut16 current1;
            if (!rz_buf_read_le16_at(buf, addr + 10, &current1)) {
                free(id);
                break;
            }
            ut8 current2;
            if (!rz_buf_read8_at(buf, addr + 9, &current2)) {
                free(id);
                break;
            }
            ut8 current3;
            if (!rz_buf_read8_at(buf, addr + 8, &current3)) {
                free(id);
                break;
            }
            cb_printf("0x%08" PFMT64x "  current     %d.%d.%d\n", pvaddr + 8, current1, current2, current3);
 
            ut16 compat1;
            if (!rz_buf_read_le16_at(buf, addr + 14, &compat1)) {
                free(id);
                break;
            }
            ut8 compat2;
            if (!rz_buf_read8_at(buf, addr + 13, &compat2)) {
                free(id);
                break;
            }
            ut8 compat3;
            if (!rz_buf_read8_at(buf, addr + 12, &compat3)) {
                free(id);
                break;
            }
            cb_printf("0x%08" PFMT64x "  compat      %d.%d.%d\n", pvaddr + 12, compat1, compat2, compat3);
 
            cb_printf("0x%08" PFMT64x "  id          %s\n",
                pvaddr + str_off - 8, id ? id : "");
            free(id);
            break;
        }
        case LC_UUID: {
            ut8 i, uuid[16];
            rz_buf_read_at(buf, addr, uuid, sizeof(uuid));
            cb_printf("0x%08" PFMT64x "  uuid        ", pvaddr);
            for (i = 0; i < sizeof(uuid); i++) {
                cb_printf("%02x", uuid[i]);
            }
            cb_printf("\n");
        } break;
        case LC_SEGMENT:
        case LC_SEGMENT_64: {
            ut8 name[17] = { 0 };
            rz_buf_read_at(buf, addr, name, sizeof(name) - 1);
            cb_printf("0x%08" PFMT64x "  name        %s\n", pvaddr, name);
            ut32 nsects;
            if (!rz_buf_read_le32_at(buf, addr - 8 + (is64 ? 64 : 48), &nsects)) {
                break;
            }
            ut64 off = is64 ? 72 : 56;
            while (off < lcSize && nsects--) {
                if (is64) {
                    cb_printf("pf.mach0_section64 @ 0x%08" PFMT64x "\n", pvaddr - 8 + off);
                    off += 80;
                } else {
                    cb_printf("pf.mach0_section @ 0x%08" PFMT64x "\n", pvaddr - 8 + off);
                    off += 68;
                }
            }
        } break;
        case LC_LOAD_DYLIB:
        case LC_LOAD_WEAK_DYLIB: {
            ut32 str_off;
            if (!rz_buf_read_ble32_at(buf, addr, &str_off, isBe)) {
                break;
            }
            char *load_dylib = rz_buf_get_string(buf, addr + str_off - 8);
            ut16 current1;
            if (!rz_buf_read_le16_at(buf, addr + 10, &current1)) {
                free(load_dylib);
                break;
            }
            ut8 current2;
            if (!rz_buf_read8_at(buf, addr + 9, &current2)) {
                free(load_dylib);
                break;
            }
            ut8 current3;
            if (!rz_buf_read8_at(buf, addr + 8, &current3)) {
                free(load_dylib);
                break;
            }
            cb_printf("0x%08" PFMT64x "  current     %d.%d.%d\n", pvaddr + 8, current1, current2, current3);
            ut16 compat1;
            if (!rz_buf_read_le16_at(buf, addr + 14, &compat1)) {
                free(load_dylib);
                break;
            }
            ut8 compat2;
            if (!rz_buf_read8_at(buf, addr + 13, &compat2)) {
                free(load_dylib);
                break;
            }
            ut8 compat3;
            if (!rz_buf_read8_at(buf, addr + 12, &compat3)) {
                free(load_dylib);
                break;
            }
            cb_printf("0x%08" PFMT64x "  compat      %d.%d.%d\n", pvaddr + 12, compat1, compat2, compat3);
            cb_printf("0x%08" PFMT64x "  load_dylib  %s\n",
                pvaddr + str_off - 8, load_dylib ? load_dylib : "");
            free(load_dylib);
            break;
        }
        case LC_RPATH: {
            char *rpath = rz_buf_get_string(buf, addr + 4);
            cb_printf("0x%08" PFMT64x "  rpath       %s\n",
                pvaddr + 4, rpath ? rpath : "");
            free(rpath);
            break;
        }
        case LC_ENCRYPTION_INFO:
        case LC_ENCRYPTION_INFO_64: {
            ut32 word;
            if (!rz_buf_read_le32_at(buf, addr, &word)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  cryptoff   0x%08x\n", pvaddr, word);
 
            if (!rz_buf_read_le32_at(buf, addr + 4, &word)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  cryptsize  %d\n", pvaddr + 4, word);
 
            if (!rz_buf_read_le32_at(buf, addr + 8, &word)) {
                break;
            }
            cb_printf("0x%08" PFMT64x "  cryptid    %d\n", pvaddr + 8, word);
            break;
        }
        case LC_CODE_SIGNATURE: {
            ut32 words[2];
            rz_buf_read_at(buf, addr, (ut8 *)words, sizeof(words));
            cb_printf("0x%08" PFMT64x "  dataoff     0x%08x\n", pvaddr, words[0]);
            cb_printf("0x%08" PFMT64x "  datasize    %d\n", pvaddr + 4, words[1]);
            cb_printf("# wtf mach0.sign %d @ 0x%x\n", words[1], words[0]);
            break;
        }
        }
        addr += word - 8;
        pvaddr += word - 8;
    }
    free(mh);
}

References addr, build_version_platform_to_string(), build_version_tool_to_string(), cmd_to_pf_definition(), cmd_to_string(), CPU_TYPE_POWERPC, CPU_TYPE_POWERPC64, eprintf, free(), i, LC_BUILD_VERSION, LC_CODE_SIGNATURE, LC_ENCRYPTION_INFO, LC_ENCRYPTION_INFO_64, LC_ID_DYLIB, LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, LC_MAIN, LC_RPATH, LC_SEGMENT, LC_SEGMENT_64, LC_SYMTAB, LC_UUID, length, MACH0_(), n, off, pa2va(), PFMT32x, PFMT64x, printf(), READWORD, rz_buf_get_string(), rz_buf_read8_at(), rz_buf_read_at(), rz_buf_read_le16_at, rz_buf_read_le32_at, rz_buf_size(), rz_read_ble32(), rz_read_ble64(), and ut64().

needs_rebasing_and_stripping()

RZ_API bool MACH0_() needs_rebasing_and_stripping

(

struct MACH0_(obj_t) *

obj

)

Definition at line 228 of file mach0_rebase.c.

                                                                             {
    return !!obj->chained_starts;
}

Referenced by get_virtual_files(), and parse_classes().

needs_reloc_patching()

RZ_API bool MACH0_() needs_reloc_patching

(

struct MACH0_(obj_t) *

obj

)

Definition at line 532 of file mach0_relocs.c.

                                                                     {
    rz_return_val_if_fail(obj, false);
    RzPVector *patchable_relocs = get_patchable_relocs(obj);
    return patchable_relocs && rz_pvector_len(patchable_relocs);
}

References get_patchable_relocs(), rz_pvector_len(), and rz_return_val_if_fail.

Referenced by patch_relocs().

new_rebasing_and_stripping_buf()

RZ_API RzBuffer* MACH0_() new_rebasing_and_stripping_buf

(

struct MACH0_(obj_t) *

obj

)

Definition at line 224 of file mach0_rebase.c.

                                                                                    {
    return rz_buf_new_with_methods(&buf_methods, obj);
}

References buf_methods, and rz_buf_new_with_methods().

Referenced by get_virtual_files(), and parse_classes().

opts_set_default()

void MACH0_() opts_set_default	(	struct MACH0_(opts_t) *	options,
		RzBinFile *	bf
	)

Definition at line 2103 of file mach0.c.

                                                                              {
    rz_return_if_fail(options && bf && bf->rbin);
    options->header_at = 0;
    options->symbols_off = 0;
    options->verbose = bf->rbin->verbose;
    options->patch_relocs = true;
}

Referenced by load_buffer().

paddr_to_vaddr()

RZ_API ut64 MACH0_() paddr_to_vaddr	(	struct MACH0_(obj_t) *	bin,
		ut64	offset
	)

Definition at line 67 of file mach0.c.

                                                                            {
    if (bin->segs) {
        size_t i;
        for (i = 0; i < bin->nsegs; i++) {
            ut64 segment_base = (ut64)bin->segs[i].fileoff;
            ut64 segment_size = (ut64)bin->segs[i].filesize;
            if (offset >= segment_base && offset < segment_base + segment_size) {
                return bin->segs[i].vmaddr + (offset - segment_base);
            }
        }
    }
    return 0;
}

References i, and ut64().

Referenced by assign_export_symbol_t(), fill_exports_list(), init_items(), pa2va(), and parse_relocation_info().

patch_relocs()

RZ_API void MACH0_() patch_relocs	(	RzBinFile *	bf,
		struct MACH0_(obj_t) *	obj
	)

Patching of external relocs in a sparse overlay buffer.

see also mach0_rebase.c for additional modification of the data that might happen.

Definition at line 614 of file mach0_relocs.c.

                                                                            {
    rz_return_if_fail(obj);
    if (obj->relocs_patched || !MACH0_(needs_reloc_patching)(obj)) {
        return;
    }
    obj->relocs_patched = true; // run this function just once (lazy relocs patching)
    ut64 cdsz = reloc_target_size(obj);
    ut64 size = MACH0_(reloc_targets_vfile_size)(obj);
    if (!size) {
        return;
    }
    RzBinRelocTargetBuilder *targets = rz_bin_reloc_target_builder_new(cdsz, MACH0_(reloc_targets_map_base)(bf, obj));
    if (!targets) {
        return;
    }
    obj->buf_patched = rz_buf_new_sparse_overlay(obj->b, RZ_BUF_SPARSE_WRITE_MODE_SPARSE);
    if (!obj->buf_patched) {
        rz_bin_reloc_target_builder_free(targets);
        return;
    }
    RzPVector *patchable_relocs = get_patchable_relocs(obj);
    void **it;
    rz_pvector_foreach (patchable_relocs, it) {
        struct reloc_t *reloc = *it;
        ut64 sym_addr = rz_bin_reloc_target_builder_get_target(targets, reloc->ord);
        reloc->target = sym_addr;
        _patch_reloc(obj, reloc, sym_addr);
    }
    rz_bin_reloc_target_builder_free(targets);
    // from now on, all writes should propagate through to the actual file
    rz_buf_sparse_set_write_mode(obj->buf_patched, RZ_BUF_SPARSE_WRITE_MODE_THROUGH);
}

References _patch_reloc(), get_patchable_relocs(), MACH0_, needs_reloc_patching(), reloc_t::ord, reloc_target_size(), reloc_targets_map_base(), reloc_targets_vfile_size(), rz_bin_reloc_target_builder_free(), rz_bin_reloc_target_builder_get_target(), rz_bin_reloc_target_builder_new(), rz_buf_new_sparse_overlay(), rz_buf_sparse_set_write_mode(), RZ_BUF_SPARSE_WRITE_MODE_SPARSE, RZ_BUF_SPARSE_WRITE_MODE_THROUGH, rz_pvector_foreach, rz_return_if_fail, reloc_t::target, and ut64().

Referenced by get_maps(), get_virtual_files(), rz_bflt_init(), rz_bflt_new_buf(), rz_bin_options_init(), rz_bin_reload(), and rz_core_bin_options_init().

pull_symbols()

void MACH0_() pull_symbols	(	struct MACH0_(obj_t) *	mo,
		RzBinSymbolCallback	cb,
		void *	user
	)

rebase_buffer()

RZ_API void MACH0_() rebase_buffer	(	struct MACH0_(obj_t) *	obj,
		ut64	off,
		ut8 *	buf,
		ut64	count
	)

Definition at line 24 of file mach0_rebase.c.

                                                                                              {
    rz_return_if_fail(obj && buf);
    ut64 eob = off + count;
    int nsegs_to_rebase = RZ_MIN(obj->nchained_starts, obj->nsegs);
    for (int i = 0; i < nsegs_to_rebase; i++) {
        if (!obj->chained_starts[i]) {
            continue;
        }
        ut64 page_size = obj->chained_starts[i]->page_size;
        ut64 start = obj->segs[i].fileoff;
        ut64 end = start + obj->segs[i].filesize;
        if (end < off || start > eob) {
            continue;
        }
        ut64 page_idx = (RZ_MAX(start, off) - start) / page_size;
        ut64 page_end_idx = (RZ_MIN(eob, end) - start) / page_size;
        for (; page_idx <= page_end_idx; page_idx++) {
            if (page_idx >= obj->chained_starts[i]->page_count) {
                break;
            }
            ut16 page_start = obj->chained_starts[i]->page_start[page_idx];
            if (page_start == DYLD_CHAINED_PTR_START_NONE) {
                continue;
            }
            ut64 cursor = start + page_idx * page_size + page_start;
            while (cursor < eob && cursor < end) {
                ut8 tmp[8];
                if (rz_buf_read_at(obj->b, cursor, tmp, 8) != 8) {
                    break;
                }
                ut64 raw_ptr = rz_read_le64(tmp);
                bool is_auth = IS_PTR_AUTH(raw_ptr);
                ut64 ptr_value = raw_ptr;
                ut64 delta;
                ut64 stride = 8;
                switch (obj->chained_starts[i]->pointer_format) {
                case DYLD_CHAINED_PTR_ARM64E: {
                    bool is_bind = IS_PTR_BIND(raw_ptr);
                    if (is_auth && is_bind) {
                        struct dyld_chained_ptr_arm64e_auth_bind *p =
                            (struct dyld_chained_ptr_arm64e_auth_bind *)&raw_ptr;
                        delta = p->next;
                    } else if (!is_auth && is_bind) {
                        struct dyld_chained_ptr_arm64e_bind *p =
                            (struct dyld_chained_ptr_arm64e_bind *)&raw_ptr;
                        delta = p->next;
                    } else if (is_auth && !is_bind) {
                        struct dyld_chained_ptr_arm64e_auth_rebase *p =
                            (struct dyld_chained_ptr_arm64e_auth_rebase *)&raw_ptr;
                        delta = p->next;
                        ptr_value = p->target + obj->baddr;
                    } else {
                        struct dyld_chained_ptr_arm64e_rebase *p =
                            (struct dyld_chained_ptr_arm64e_rebase *)&raw_ptr;
                        delta = p->next;
                        ptr_value = ((ut64)p->high8 << 56) | p->target;
                    }
                    break;
                }
                case DYLD_CHAINED_PTR_64_KERNEL_CACHE:
                case DYLD_CHAINED_PTR_ARM64E_KERNEL: {
                    stride = 4;
                    if (is_auth) {
                        struct dyld_chained_ptr_arm64e_cache_auth_rebase *p =
                            (struct dyld_chained_ptr_arm64e_cache_auth_rebase *)&raw_ptr;
                        delta = p->next;
                        ptr_value = p->target + obj->baddr;
                    } else {
                        struct dyld_chained_ptr_arm64e_cache_rebase *p =
                            (struct dyld_chained_ptr_arm64e_cache_rebase *)&raw_ptr;
                        delta = p->next;
                        ptr_value = ((ut64)p->high8 << 56) | p->target;
                        ptr_value += obj->baddr;
                    }
                    break;
                }
                case DYLD_CHAINED_PTR_64_OFFSET: {
                    stride = 4;
                    struct dyld_chained_ptr_64_bind *bind =
                        (struct dyld_chained_ptr_64_bind *)&raw_ptr;
                    if (bind->bind) {
                        delta = bind->next;
                    } else {
                        struct dyld_chained_ptr_64_rebase *p =
                            (struct dyld_chained_ptr_64_rebase *)&raw_ptr;
                        delta = p->next;
                        ptr_value = obj->baddr + (((ut64)p->high8 << 56) | p->target);
                    }
                    break;
                }
                case DYLD_CHAINED_PTR_ARM64E_USERLAND24: {
                    stride = 8;
                    struct dyld_chained_ptr_arm64e_bind24 *bind =
                        (struct dyld_chained_ptr_arm64e_bind24 *)&raw_ptr;
                    if (bind->bind) {
                        delta = bind->next;
                    } else {
                        if (bind->auth) {
                            struct dyld_chained_ptr_arm64e_auth_rebase *p =
                                (struct dyld_chained_ptr_arm64e_auth_rebase *)&raw_ptr;
                            delta = p->next;
                            ptr_value = p->target + obj->baddr;
                        } else {
                            struct dyld_chained_ptr_arm64e_rebase *p =
                                (struct dyld_chained_ptr_arm64e_rebase *)&raw_ptr;
                            delta = p->next;
                            ptr_value = obj->baddr + (((ut64)p->high8 << 56) | p->target);
                        }
                    }
                    break;
                }
                default:
                    RZ_LOG_WARN("Unsupported Mach-O pointer format: %u at paddr 0x%" PFMT64x "\n",
                        obj->chained_starts[i]->pointer_format, cursor);
                    goto break_it_all;
                }
                ut64 in_buf = cursor - off;
                if (cursor >= off && cursor <= eob - 8) {
                    rz_write_le64(&buf[in_buf], ptr_value);
                }
                cursor += delta * stride;
                if (!delta) {
                    break;
                }
                continue;
            break_it_all:
                break;
            }
        }
    }
}

References bind, count, delta, DYLD_CHAINED_PTR_64_KERNEL_CACHE, DYLD_CHAINED_PTR_64_OFFSET, DYLD_CHAINED_PTR_ARM64E, DYLD_CHAINED_PTR_ARM64E_KERNEL, DYLD_CHAINED_PTR_ARM64E_USERLAND24, DYLD_CHAINED_PTR_START_NONE, test_evm::end, i, in_buf, IS_PTR_AUTH, IS_PTR_BIND, off, p, PFMT64x, rz_buf_read_at(), RZ_LOG_WARN, RZ_MAX, RZ_MIN, rz_read_le64(), rz_return_if_fail, rz_write_le64(), start, autogen_x86imm::tmp, and ut64().

Referenced by buf_read().

reloc_targets_map_base()

RZ_API ut64 MACH0_() reloc_targets_map_base	(	RzBinFile *	bf,
		struct MACH0_(obj_t) *	obj
	)

base vaddr where to map the artificial reloc target vfile

Definition at line 556 of file mach0_relocs.c.

                                                                                      {
    if (obj->reloc_targets_map_base_calculated) {
        return obj->reloc_targets_map_base;
    }
    RzList *maps = MACH0_(get_maps_unpatched)(bf);
    obj->reloc_targets_map_base = rz_bin_relocs_patch_find_targets_map_base(maps, reloc_target_size(obj));
    rz_list_free(maps);
    obj->reloc_targets_map_base_calculated = true;
    return obj->reloc_targets_map_base;
}

References get_maps_unpatched(), MACH0_, maps(), reloc_target_size(), rz_bin_relocs_patch_find_targets_map_base(), and rz_list_free().

Referenced by get_maps(), and patch_relocs().

reloc_targets_vfile_size()

RZ_API ut64 MACH0_() reloc_targets_vfile_size

(

struct MACH0_(obj_t) *

obj

)

size of the artificial reloc target vfile

Definition at line 547 of file mach0_relocs.c.

                                                                         {
    RzPVector *patchable_relocs = get_patchable_relocs(obj);
    if (!patchable_relocs) {
        return 0;
    }
    return rz_pvector_len(patchable_relocs) * reloc_target_size(obj);
}

References get_patchable_relocs(), reloc_target_size(), and rz_pvector_len().

Referenced by get_maps(), get_virtual_files(), and patch_relocs().

section_flag_to_rzlist()

RzList* MACH0_() section_flag_to_rzlist

(

ut64

flag

)

Definition at line 2378 of file mach0.c.

                                                  {
    RzList *flag_list = rz_list_new();
    if (flag & S_ATTR_PURE_INSTRUCTIONS) {
        rz_list_append(flag_list, "PURE_INSTRUCTIONS");
    }
    if (flag & S_ATTR_NO_TOC) {
        rz_list_append(flag_list, "NO_TOC");
    }
    if (flag & S_ATTR_SOME_INSTRUCTIONS) {
        rz_list_append(flag_list, "SOME_INSTRUCTIONS");
    }
    if (flag & S_ATTR_EXT_RELOC) {
        rz_list_append(flag_list, "EXT_RELOC");
    }
    if (flag & S_ATTR_SELF_MODIFYING_CODE) {
        rz_list_append(flag_list, "SELF_MODIFYING_CODE");
    }
    if (flag & S_ATTR_DEBUG) {
        rz_list_append(flag_list, "DEBUG");
    }
    if (flag & S_ATTR_LIVE_SUPPORT) {
        rz_list_append(flag_list, "LIVE_SUPPORT");
    }
    if (flag & S_ATTR_STRIP_STATIC_SYMS) {
        rz_list_append(flag_list, "STRIP_STATIC_SYMS");
    }
    if (flag & S_ATTR_NO_DEAD_STRIP) {
        rz_list_append(flag_list, "NO_DEAD_STRIP");
    }
    return flag_list;
}

section_type_to_string()

char* MACH0_() section_type_to_string

(

ut64

type

)

Definition at line 2347 of file mach0.c.

                                                {
    switch (type) {
    case S_REGULAR:
        return rz_str_new("REGULAR");
    case S_ZEROFILL:
        return rz_str_new("ZEROFILL");
    case S_CSTRING_LITERALS:
        return rz_str_new("CSTRING_LITERALS");
    case S_4BYTE_LITERALS:
        return rz_str_new("4BYTE_LITERALS");
    case S_LITERAL_POINTERS:
        return rz_str_new("LITERAL_POINTERS");
    case S_NON_LAZY_SYMBOL_POINTERS:
        return rz_str_new("NON_LAZY_SYMBOL_POINTERS");
    case S_LAZY_SYMBOL_POINTERS:
        return rz_str_new("LAZY_SYMBOL_POINTERS");
    case S_SYMBOL_STUBS:
        return rz_str_new("SYMBOL_STUBS");
    case S_MOD_INIT_FUNC_POINTERS:
        return rz_str_new("MOD_INIT_FUNC_POINTERS");
    case S_MOD_TERM_FUNC_POINTERS:
        return rz_str_new("MOD_TERM_FUNC_POINTERS");
    case S_COALESCED:
        return rz_str_new("COALESCED");
    case S_GB_ZEROFILL:
        return rz_str_new("GB_ZEROFILL");
    default:
        return rz_str_newf("0x%" PFMT64x, type);
    }
}

References PFMT64x, rz_str_new(), rz_str_newf(), S_4BYTE_LITERALS, S_COALESCED, S_CSTRING_LITERALS, S_GB_ZEROFILL, S_LAZY_SYMBOL_POINTERS, S_LITERAL_POINTERS, S_MOD_INIT_FUNC_POINTERS, S_MOD_TERM_FUNC_POINTERS, S_NON_LAZY_SYMBOL_POINTERS, S_REGULAR, S_SYMBOL_STUBS, S_ZEROFILL, and type.

segment_needs_rebasing_and_stripping()

RZ_API bool MACH0_() segment_needs_rebasing_and_stripping	(	struct MACH0_(obj_t) *	obj,
		size_t	seg_index
	)

Definition at line 232 of file mach0_rebase.c.

                                                                                                       {
    if (seg_index >= obj->nsegs || seg_index >= obj->nchained_starts) {
        return false;
    }
    return obj->chained_starts && obj->chained_starts[seg_index];
}

Referenced by get_maps_unpatched().

vaddr_to_paddr()

RZ_API ut64 MACH0_() vaddr_to_paddr	(	struct MACH0_(obj_t) *	bin,
		ut64	addr
	)

Definition at line 53 of file mach0.c.

                                                                          {
    if (bin->segs) {
        size_t i;
        for (i = 0; i < bin->nsegs; i++) {
            const ut64 segment_base = (ut64)bin->segs[i].vmaddr;
            const ut64 segment_size = (ut64)bin->segs[i].vmsize;
            if (addr >= segment_base && addr < segment_base + segment_size) {
                return bin->segs[i].fileoff + (addr - segment_base);
            }
        }
    }
    return 0;
}

References addr, i, and ut64().

Referenced by get_entrypoint(), get_main(), get_symbols(), and get_symbols_list().