mach0_classes.h File Reference

#include <rz_bin.h>
#include "mach0/mach0_specs.h"
#include "mach0/mach0.h"

Go to the source code of this file.

Macros
#define	mach0_ut   ut32
#define	rz_bin_plugin_mach   rz_bin_plugin_mach0

Functions
RZ_API RzList *MACH0_()	parse_classes (RzBinFile *bf, objc_cache_opt_info *oi)
RZ_API void MACH0_()	get_class_t (mach0_ut p, RzBinFile *bf, RzBuffer *buf, RzBinClass *klass, bool dupe, RzSkipList *relocs, objc_cache_opt_info *oi)
RZ_API void MACH0_()	get_category_t (mach0_ut p, RzBinFile *bf, RzBuffer *buf, RzBinClass *klass, RzSkipList *relocs, objc_cache_opt_info *oi)

Macro Definition Documentation

mach0_ut

#define mach0_ut   ut32

Definition at line 17 of file mach0_classes.h.

rz_bin_plugin_mach

#define rz_bin_plugin_mach   rz_bin_plugin_mach0

Definition at line 18 of file mach0_classes.h.

Function Documentation

get_category_t()

RZ_API void MACH0_() get_category_t	(	mach0_ut	p,
		RzBinFile *	bf,
		RzBuffer *	buf,
		RzBinClass *	klass,
		RzSkipList *	relocs,
		objc_cache_opt_info *	oi
	)

Definition at line 1445 of file mach0_classes.c.

                                                                                                                                             {
    rz_return_if_fail(bf && bf->o && bf->o->info);
 
    struct MACH0_(SCategory) c = { 0 };
    const int size = sizeof(struct MACH0_(SCategory));
    mach0_ut r = 0;
    ut32 offset = 0, left = 0;
    int len;
    bool bigendian = bf->o->info->big_endian;
    ut8 sc[sizeof(struct MACH0_(SCategory))] = { 0 };
    ut32 i;
 
    if (!(r = va2pa(p, &offset, &left, bf))) {
        return;
    }
    if ((r + left) < r || (r + size) < r) {
        return;
    }
    if (r > bf->size || r + left > bf->size) {
        return;
    }
    if (r + size > bf->size) {
        return;
    }
    if (left < size) {
        RZ_LOG_ERROR("Cannot parse obj category info out of bounds\n");
        return;
    }
    len = rz_buf_read_at(buf, r, sc, size);
    if (len != size) {
        return;
    }
 
    ut32 ptr_size = sizeof(mach0_ut);
    ut32 bits = 8 * ptr_size;
 
    i = 0;
    c.name = rz_read_ble(&sc[i], bigendian, bits);
    i += ptr_size;
    c.targetClass = rz_read_ble(&sc[i], bigendian, bits);
    i += ptr_size;
    c.instanceMethods = rz_read_ble(&sc[i], bigendian, bits);
    i += ptr_size;
    c.classMethods = rz_read_ble(&sc[i], bigendian, bits);
    i += ptr_size;
    c.protocols = rz_read_ble(&sc[i], bigendian, bits);
    i += ptr_size;
    c.properties = rz_read_ble(&sc[i], bigendian, bits);
 
    char *category_name = read_str(bf, buf, c.name, &offset, &left);
    if (!category_name) {
        return;
    }
 
    char *target_class_name = NULL;
    if (c.targetClass == 0) {
        if (!relocs) {
            RZ_FREE(category_name);
            return;
        }
        struct reloc_t reloc_at_class_addr;
        reloc_at_class_addr.addr = p + ptr_size;
        RzSkipListNode *found = rz_skiplist_find(relocs, &reloc_at_class_addr);
        if (!found) {
            RZ_FREE(category_name);
            return;
        }
 
        const char *_objc_class = "_OBJC_CLASS_$_";
        const int _objc_class_len = strlen(_objc_class);
        target_class_name = (char *)((struct reloc_t *)found->data)->name;
        if (!rz_str_startswith(target_class_name, _objc_class)) {
            RZ_FREE(category_name);
            return;
        }
        target_class_name += _objc_class_len;
        klass->name = rz_str_newf("%s(%s)", target_class_name, category_name);
    } else {
        mach0_ut ro_data_field = c.targetClass + 4 * ptr_size;
        mach0_ut ro_data;
        if (!read_ptr_va(bf, buf, ro_data_field, &ro_data)) {
            RZ_FREE(category_name);
            return;
        }
        mach0_ut name_field = RO_DATA_PTR(ro_data) + 3 * 4 + ptr_size;
#ifdef RZ_BIN_MACH064
        name_field += 4;
#endif
        mach0_ut name_at;
        if (!read_ptr_va(bf, buf, name_field & ~1, &name_at)) {
            RZ_FREE(category_name);
            return;
        }
 
        target_class_name = read_str(bf, buf, name_at, &offset, &left);
        char *demangled = NULL;
        if (target_class_name) {
            demangled = demangle_classname(target_class_name);
        }
        klass->name = rz_str_newf("%s(%s)", rz_str_get_null(demangled), category_name);
        RZ_FREE(target_class_name);
        RZ_FREE(demangled);
    }
 
    klass->addr = p;
 
    RZ_FREE(category_name);
 
    if (c.instanceMethods > 0) {
        get_method_list_t(c.instanceMethods, bf, buf, klass->name, klass, false, oi);
    }
 
    if (c.classMethods > 0) {
        get_method_list_t(c.classMethods, bf, buf, klass->name, klass, true, oi);
    }
 
    if (c.protocols > 0) {
        get_protocol_list_t(c.protocols, bf, buf, klass, oi);
    }
 
    if (c.properties > 0) {
        get_objc_property_list(c.properties, bf, buf, klass);
    }
}

References reloc_t::addr, bits(), c, demangle_classname(), found, get_method_list_t(), get_objc_property_list(), get_protocol_list_t(), i, len, mach0_ut, NULL, p, r, read_ptr_va(), read_str(), relocs(), RO_DATA_PTR, rz_buf_read_at(), RZ_FREE, RZ_LOG_ERROR, rz_read_ble(), rz_return_if_fail, rz_skiplist_find(), rz_str_get_null(), rz_str_newf(), rz_str_startswith(), sc, and va2pa().

Referenced by classes(), and parse_categories().

get_class_t()

RZ_API void MACH0_() get_class_t	(	mach0_ut	p,
		RzBinFile *	bf,
		RzBuffer *	buf,
		RzBinClass *	klass,
		bool	dupe,
		RzSkipList *	relocs,
		objc_cache_opt_info *	oi
	)

Definition at line 1127 of file mach0_classes.c.

                                                                                                                                                     {
    struct MACH0_(SClass) c = { 0 };
    const int size = sizeof(struct MACH0_(SClass));
    mach0_ut r = 0;
    ut32 offset = 0, left = 0;
    ut32 is_meta_class = 0;
    int len;
    bool bigendian;
    ut8 sc[sizeof(struct MACH0_(SClass))] = { 0 };
    ut32 i;
 
    if (!bf || !bf->o || !bf->o->info) {
        return;
    }
    bigendian = bf->o->info->big_endian;
    if (!(r = va2pa(p, &offset, &left, bf))) {
        return;
    }
    if ((r + left) < r || (r + size) < r) {
        return;
    }
    if (r > bf->size) {
        return;
    }
    if (r + size > bf->size) {
        return;
    }
    if (left < size) {
        RZ_LOG_ERROR("Cannot parse obj class info (out of bounds)\n");
        return;
    }
    len = rz_buf_read_at(buf, r, sc, size);
    if (len != size) {
        return;
    }
 
    i = 0;
    c.isa = rz_read_ble(&sc[i], bigendian, 8 * sizeof(mach0_ut));
    i += sizeof(mach0_ut);
    c.superclass = rz_read_ble(&sc[i], bigendian, 8 * sizeof(mach0_ut));
    i += sizeof(mach0_ut);
    c.cache = rz_read_ble(&sc[i], bigendian, 8 * sizeof(mach0_ut));
    i += sizeof(mach0_ut);
    c.vtable = rz_read_ble(&sc[i], bigendian, 8 * sizeof(mach0_ut));
    i += sizeof(mach0_ut);
    c.data = rz_read_ble(&sc[i], bigendian, 8 * sizeof(mach0_ut));
 
    klass->addr = c.isa;
    if (c.superclass) {
        klass->super = get_class_name(c.superclass, bf, buf);
    } else if (relocs) {
        struct reloc_t reloc_at_class_addr;
        reloc_at_class_addr.addr = p + sizeof(mach0_ut);
        RzSkipListNode *found = rz_skiplist_find(relocs, &reloc_at_class_addr);
        if (found) {
            const char *_objc_class = "_OBJC_CLASS_$_";
            const int _objc_class_len = strlen(_objc_class);
            char *target_class_name = (char *)((struct reloc_t *)found->data)->name;
            if (rz_str_startswith(target_class_name, _objc_class)) {
                target_class_name += _objc_class_len;
                klass->super = strdup(target_class_name);
            }
        }
    }
    get_class_ro_t(RO_DATA_PTR(c.data), bf, buf, &is_meta_class, klass, oi);
 
#if SWIFT_SUPPORT
    if (q(c.data + n_value) & 7) {
        RZ_LOG_INFO("This is a Swift class");
    }
#endif
    if (!is_meta_class && !dupe) {
        mach0_ut isa_n_value = get_isa_value();
        ut64 tmp = klass->addr;
        MACH0_(get_class_t)
        (c.isa + isa_n_value, bf, buf, klass, true, relocs, oi);
        klass->addr = tmp;
    }
}

References reloc_t::addr, c, found, get_class_name(), get_class_ro_t(), get_isa_value(), i, len, MACH0_(), mach0_ut, p, r, relocs(), RO_DATA_PTR, rz_buf_read_at(), RZ_LOG_ERROR, RZ_LOG_INFO, rz_read_ble(), rz_skiplist_find(), rz_str_startswith(), sc, strdup(), autogen_x86imm::tmp, ut64(), and va2pa().

Referenced by classes(), and parse_classes().

parse_classes()

RZ_API RzList* MACH0_() parse_classes	(	RzBinFile *	bf,
		objc_cache_opt_info *	oi
	)

Definition at line 1243 of file mach0_classes.c.

                                                                             {
    RzList /*<RzBinClass>*/ *ret = NULL;
    ut64 num_of_unnamed_class = 0;
    RzBinClass *klass = NULL;
    ut32 i = 0, size = 0;
    RzList *sctns = NULL;
    bool is_found = false;
    mach0_ut p = 0;
    ut32 left = 0;
    int len;
    ut64 paddr;
    ut64 s_size;
    bool bigendian;
    ut8 pp[sizeof(mach0_ut)] = { 0 };
 
    rz_return_val_if_fail(bf && bf->o, NULL);
 
    if (!bf->o->bin_obj || !bf->o->info) {
        return NULL;
    }
    bigendian = bf->o->info->big_endian;
 
    RzBuffer *buf = bf->buf;
    RzBuffer *owned_buf = NULL;
    if (MACH0_(needs_rebasing_and_stripping)(bf->o->bin_obj)) {
        owned_buf = MACH0_(new_rebasing_and_stripping_buf)(bf->o->bin_obj);
        if (!owned_buf) {
            return NULL;
        }
        buf = owned_buf;
    }
 
    RzSkipList *relocs = MACH0_(get_relocs)(bf->o->bin_obj);
 
    ret = MACH0_(parse_categories)(bf, buf, relocs, oi);
 
    /* check if it's Swift */
    // ret = parse_swift_classes (bf);
 
    // sebfing of section with name __objc_classlist
 
    struct section_t *sections = NULL;
    if (!(sections = MACH0_(get_sections)(bf->o->bin_obj))) {
        rz_buf_free(owned_buf);
        return ret;
    }
 
    for (i = 0; !sections[i].last; i++) {
        if (strstr(sections[i].name, "__objc_classlist")) {
            is_found = true;
            paddr = sections[i].offset;
            s_size = sections[i].size;
            break;
        }
    }
 
    RZ_FREE(sections);
 
    if (!is_found) {
        // retain just for debug
        // RZ_LOG_ERROR("there is no section __objc_classlist\n");
        goto get_classes_error;
    }
    // end of seaching of section with name __objc_classlist
 
    if (!ret && !(ret = rz_list_newf((RzListFree)rz_bin_class_free))) {
        // retain just for debug
        // RZ_LOG_ERROR("RzList<RzBinClass> allocation error\n");
        goto get_classes_error;
    }
    // start of getting information about each class in file
    for (i = 0; i < s_size; i += sizeof(mach0_ut)) {
        left = s_size - i;
        if (left < sizeof(mach0_ut)) {
            RZ_LOG_ERROR("Truncated classlist data\n");
            break;
        }
        if (!(klass = RZ_NEW0(RzBinClass))) {
            // retain just for debug
            // RZ_LOG_ERROR("RzBinClass allocation error\n");
            goto get_classes_error;
        }
        if (!(klass->methods = rz_list_new())) {
            // retain just for debug
            // RZ_LOG_ERROR("RzList<RzBinField> allocation error\n");
            goto get_classes_error;
        }
        if (!(klass->fields = rz_list_new())) {
            // retain just for debug
            // RZ_LOG_ERROR("RzList<RzBinSymbol> allocation error\n");
            goto get_classes_error;
        }
        size = sizeof(mach0_ut);
        if (paddr > bf->size || paddr + size > bf->size) {
            goto get_classes_error;
        }
        if (paddr + size < paddr) {
            goto get_classes_error;
        }
        len = rz_buf_read_at(buf, paddr + i, pp, sizeof(mach0_ut));
        if (len != sizeof(mach0_ut)) {
            goto get_classes_error;
        }
        p = rz_read_ble(&pp[0], bigendian, 8 * sizeof(mach0_ut));
        MACH0_(get_class_t)
        (p, bf, buf, klass, false, relocs, oi);
        if (!klass->name) {
            klass->name = rz_str_newf("UnnamedClass%" PFMT64d, num_of_unnamed_class);
            if (!klass->name) {
                goto get_classes_error;
            }
            num_of_unnamed_class++;
        }
        rz_list_append(ret, klass);
    }
    return ret;
 
get_classes_error:
    rz_list_free(sctns);
    rz_list_free(ret);
    rz_buf_free(owned_buf);
    // XXX DOUBLE FREE rz_bin_class_free (klass);
    return NULL;
}

References rz_bin_class_t::fields, get_class_t(), get_relocs(), get_sections(), i, len, MACH0_(), mach0_ut, rz_bin_class_t::methods, needs_rebasing_and_stripping(), new_rebasing_and_stripping_buf(), NULL, p, parse_categories(), PFMT64d, relocs(), rz_bin_class_free(), rz_buf_free(), rz_buf_read_at(), RZ_FREE, rz_list_append(), rz_list_free(), rz_list_new(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_read_ble(), rz_return_val_if_fail, rz_str_newf(), sections(), and ut64().

Referenced by classes().