rtti_msvc.c File Reference

#include "rz_analysis.h"

Go to the source code of this file.

Classes
struct	rtti_complete_object_locator_t
struct	rtti_class_hierarchy_descriptor_t
struct	rtti_base_class_descriptor_t
struct	rtti_type_descriptor_t
struct	recovery_base_descriptor_t
struct	recovery_complete_object_locator_t
struct	recovery_type_descriptor_t
struct	rtti_msvc_analysis_context_t

Macros
#define	NAME_BUF_SIZE   64
#define	BASE_CLASSES_MAX   32

Typedefs
typedef struct rtti_complete_object_locator_t	rtti_complete_object_locator
typedef struct rtti_class_hierarchy_descriptor_t	rtti_class_hierarchy_descriptor
typedef struct rtti_base_class_descriptor_t	rtti_base_class_descriptor
typedef struct rtti_type_descriptor_t	rtti_type_descriptor
typedef struct recovery_type_descriptor_t	RecoveryTypeDescriptor
typedef struct recovery_base_descriptor_t	RecoveryBaseDescriptor
typedef struct recovery_complete_object_locator_t	RecoveryCompleteObjectLocator
typedef struct rtti_msvc_analysis_context_t	RRTTIMSVCAnalContext

Functions
static void	rtti_type_descriptor_fini (rtti_type_descriptor *td)
static ut64	rtti_msvc_addr (RVTableContext *context, ut64 col_addr, ut64 col_base, ut32 addr)
static bool	rtti_msvc_read_complete_object_locator (RVTableContext *context, ut64 addr, rtti_complete_object_locator *col)
static bool	rtti_msvc_read_class_hierarchy_descriptor (RVTableContext *context, ut64 addr, rtti_class_hierarchy_descriptor *chd)
static ut64	rtti_msvc_base_class_descriptor_size (RVTableContext *context)
static bool	rtti_msvc_read_base_class_descriptor (RVTableContext *context, ut64 addr, rtti_base_class_descriptor *bcd)
static RzList *	rtti_msvc_read_base_class_array (RVTableContext *context, ut32 num_base_classes, ut64 base, ut32 offset)
static bool	rtti_msvc_read_type_descriptor (RVTableContext *context, ut64 addr, rtti_type_descriptor *td)
static void	rtti_msvc_print_complete_object_locator (rtti_complete_object_locator *col, ut64 addr, const char *prefix)
static void	rtti_msvc_print_complete_object_locator_json (PJ *pj, rtti_complete_object_locator *col)
static void	rtti_msvc_print_type_descriptor (rtti_type_descriptor *td, ut64 addr, const char *prefix)
static void	rtti_msvc_print_type_descriptor_json (PJ *pj, rtti_type_descriptor *td)
static void	rtti_msvc_print_class_hierarchy_descriptor (rtti_class_hierarchy_descriptor *chd, ut64 addr, const char *prefix)
static void	rtti_msvc_print_class_hierarchy_descriptor_json (PJ *pj, rtti_class_hierarchy_descriptor *chd)
static void	rtti_msvc_print_base_class_descriptor (rtti_base_class_descriptor *bcd, const char *prefix)
static void	rtti_msvc_print_base_class_descriptor_json (PJ *pj, rtti_base_class_descriptor *bcd)
RZ_API char *	rz_analysis_rtti_msvc_demangle_class_name (RVTableContext *context, const char *name)
RZ_API void	rz_analysis_rtti_msvc_print_complete_object_locator (RVTableContext *context, ut64 addr, int mode)
RZ_API void	rz_analysis_rtti_msvc_print_type_descriptor (RVTableContext *context, ut64 addr, int mode)
RZ_API void	rz_analysis_rtti_msvc_print_class_hierarchy_descriptor (RVTableContext *context, ut64 addr, int mode)
RZ_API void	rz_analysis_rtti_msvc_print_base_class_descriptor (RVTableContext *context, ut64 addr, int mode)
static bool	rtti_msvc_print_complete_object_locator_recurse (RVTableContext *context, ut64 atAddress, RzOutputMode mode, bool strict)
RZ_API bool	rz_analysis_rtti_msvc_print_at_vtable (RVTableContext *context, ut64 addr, RzOutputMode mode, bool strict)
RecoveryCompleteObjectLocator *	recovery_complete_object_locator_new ()
void	recovery_complete_object_locator_free (RecoveryCompleteObjectLocator *col)
RecoveryTypeDescriptor *	recovery_type_descriptor_new ()
void	recovery_type_descriptor_free (RecoveryTypeDescriptor *td)
RecoveryTypeDescriptor *	recovery_analysis_type_descriptor (RRTTIMSVCAnalContext *context, ut64 addr, RecoveryCompleteObjectLocator *col)
RecoveryCompleteObjectLocator *	recovery_analysis_complete_object_locator (RRTTIMSVCAnalContext *context, ut64 addr, RVTableInfo *vtable)
static char *	unique_class_name (RzAnalysis *analysis, const char *original_name)
static void	recovery_apply_vtable (RVTableContext *context, const char *class_name, RVTableInfo *vtable_info)
static const char *	recovery_apply_complete_object_locator (RRTTIMSVCAnalContext *context, RecoveryCompleteObjectLocator *col)
static const char *	recovery_apply_type_descriptor (RRTTIMSVCAnalContext *context, RecoveryTypeDescriptor *td)
static void	recovery_apply_bases (RRTTIMSVCAnalContext *context, const char *class_name, RzVector *base_descs)
void	str_value_free (HtUPKv *kv)
RZ_API void	rz_analysis_rtti_msvc_recover_all (RVTableContext *vt_context, RzList *vtables)

Macro Definition Documentation

BASE_CLASSES_MAX

#define BASE_CLASSES_MAX   32

Definition at line 9 of file rtti_msvc.c.

NAME_BUF_SIZE

#define NAME_BUF_SIZE   64

Definition at line 8 of file rtti_msvc.c.

Typedef Documentation

RecoveryBaseDescriptor

typedef struct recovery_base_descriptor_t RecoveryBaseDescriptor

RecoveryCompleteObjectLocator

typedef struct recovery_complete_object_locator_t RecoveryCompleteObjectLocator

RecoveryTypeDescriptor

typedef struct recovery_type_descriptor_t RecoveryTypeDescriptor

Definition at line 617 of file rtti_msvc.c.

RRTTIMSVCAnalContext

typedef struct rtti_msvc_analysis_context_t RRTTIMSVCAnalContext

rtti_base_class_descriptor

typedef struct rtti_base_class_descriptor_t rtti_base_class_descriptor

rtti_class_hierarchy_descriptor

typedef struct rtti_class_hierarchy_descriptor_t rtti_class_hierarchy_descriptor

rtti_complete_object_locator

typedef struct rtti_complete_object_locator_t rtti_complete_object_locator

rtti_type_descriptor

typedef struct rtti_type_descriptor_t rtti_type_descriptor

Function Documentation

recovery_analysis_complete_object_locator()

RecoveryCompleteObjectLocator* recovery_analysis_complete_object_locator	(	RRTTIMSVCAnalContext *	context,
		ut64	addr,
		RVTableInfo *	vtable
	)

Definition at line 698 of file rtti_msvc.c.

                                                                                                                                        {
    RecoveryCompleteObjectLocator *col = ht_up_find(context->addr_col, addr, NULL);
    if (col) {
        return col;
    }
 
    col = recovery_complete_object_locator_new();
    if (!col) {
        return NULL;
    }
    rz_pvector_push(&context->complete_object_locators, col);
    ht_up_insert(context->addr_col, addr, col);
    col->addr = addr;
    col->valid = rtti_msvc_read_complete_object_locator(context->vt_context, addr, &col->col);
    if (!col->valid) {
        return col;
    }
    col->vtable = vtable;
 
    ut64 td_addr = rtti_msvc_addr(context->vt_context, col->addr, col->col.object_base, col->col.type_descriptor_addr);
    col->td = recovery_analysis_type_descriptor(context, td_addr, col);
    if (!col->td->valid) {
        col->valid = false;
        return col;
    }
    col->td->col = col;
 
    ut64 chd_addr = rtti_msvc_addr(context->vt_context, col->addr, col->col.object_base, col->col.class_descriptor_addr);
    col->valid &= rtti_msvc_read_class_hierarchy_descriptor(context->vt_context, chd_addr, &col->chd);
    if (!col->valid) {
        return col;
    }
 
    ut64 base = col->chd.base_class_array_addr;
    ut32 baseClassArrayOffset = 0;
    if (context->vt_context->word_size == 8) {
        base = col->addr - col->col.object_base;
        baseClassArrayOffset = col->chd.base_class_array_addr;
    }
 
    col->bcd = rtti_msvc_read_base_class_array(context->vt_context, col->chd.num_base_classes, base, baseClassArrayOffset);
    if (!col->bcd) {
        col->valid = false;
        return col;
    }
 
    rz_vector_reserve(&col->base_td, (size_t)col->bcd->length);
    RzListIter *bcdIter;
    rtti_base_class_descriptor *bcd;
    rz_list_foreach (col->bcd, bcdIter, bcd) {
        ut64 base_td_addr = rtti_msvc_addr(context->vt_context, col->addr, col->col.object_base, bcd->type_descriptor_addr);
        RecoveryTypeDescriptor *td = recovery_analysis_type_descriptor(context, base_td_addr, NULL);
        if (td == col->td) {
            continue;
        }
        if (!td->valid) {
            RZ_LOG_DEBUG("Type descriptor of base is invalid.\n");
            continue;
        }
        RecoveryBaseDescriptor *base_desc = rz_vector_push(&col->base_td, NULL);
        base_desc->bcd = bcd;
        base_desc->td = td;
    }
 
    return col;
}

References recovery_complete_object_locator_t::addr, addr, rtti_class_hierarchy_descriptor_t::base_class_array_addr, recovery_complete_object_locator_t::base_td, recovery_base_descriptor_t::bcd, recovery_complete_object_locator_t::bcd, recovery_complete_object_locator_t::chd, rtti_complete_object_locator_t::class_descriptor_addr, recovery_complete_object_locator_t::col, recovery_type_descriptor_t::col, rz_list_t::length, NULL, rtti_class_hierarchy_descriptor_t::num_base_classes, rtti_complete_object_locator_t::object_base, recovery_analysis_type_descriptor(), recovery_complete_object_locator_new(), rtti_msvc_addr(), rtti_msvc_read_base_class_array(), rtti_msvc_read_class_hierarchy_descriptor(), rtti_msvc_read_complete_object_locator(), RZ_LOG_DEBUG, rz_pvector_push(), rz_vector_push(), rz_vector_reserve(), recovery_base_descriptor_t::td, recovery_complete_object_locator_t::td, rtti_complete_object_locator_t::type_descriptor_addr, rtti_base_class_descriptor_t::type_descriptor_addr, ut64(), recovery_complete_object_locator_t::valid, recovery_type_descriptor_t::valid, and recovery_complete_object_locator_t::vtable.

Referenced by rz_analysis_rtti_msvc_recover_all().

recovery_analysis_type_descriptor()

RecoveryTypeDescriptor * recovery_analysis_type_descriptor	(	RRTTIMSVCAnalContext *	context,
		ut64	addr,
		RecoveryCompleteObjectLocator *	col
	)

Definition at line 765 of file rtti_msvc.c.

                                                                                                                                        {
    RecoveryTypeDescriptor *td = ht_up_find(context->addr_td, addr, NULL);
    if (td) {
        if (col != NULL) {
            td->col = col;
        }
        return td;
    }
 
    td = recovery_type_descriptor_new();
    if (!td) {
        return NULL;
    }
    rz_pvector_push(&context->type_descriptors, td);
    ht_up_insert(context->addr_td, addr, td);
    td->addr = addr;
    td->valid = rtti_msvc_read_type_descriptor(context->vt_context, addr, &td->td);
    if (!td->valid) {
        return td;
    }
 
    td->col = col;
 
    return td;
}

References recovery_type_descriptor_t::addr, addr, recovery_type_descriptor_t::col, NULL, recovery_type_descriptor_new(), rtti_msvc_read_type_descriptor(), rz_pvector_push(), recovery_type_descriptor_t::td, and recovery_type_descriptor_t::valid.

Referenced by recovery_analysis_complete_object_locator().

recovery_apply_bases()

static void recovery_apply_bases ( RRTTIMSVCAnalContext *  context, const char *  class_name, RzVector *  base_descs  )

static

Definition at line 855 of file rtti_msvc.c.

                                                                                                              {
    RecoveryBaseDescriptor *base_desc;
    rz_vector_foreach(base_descs, base_desc) {
        RecoveryTypeDescriptor *base_td = base_desc->td;
        if (!base_td->valid) {
            RZ_LOG_WARN("Base td is invalid!\n");
            continue;
        }
 
        const char *base_class_name;
        if (!base_td->col) {
            RZ_LOG_DEBUG("Base td %s has no col. Falling back to recovery from td only.\n", base_td->td.name);
            base_class_name = recovery_apply_type_descriptor(context, base_td);
        } else {
            base_class_name = recovery_apply_complete_object_locator(context, base_td->col);
        }
 
        if (!base_class_name) {
            RZ_LOG_DEBUG("Failed to convert !base td->col or td to a class\n");
            continue;
        }
 
        RzAnalysisBaseClass base;
        base.id = NULL;
        base.offset = (ut64)base_desc->bcd->where.mdisp;
        base.class_name = strdup(base_class_name);
        rz_analysis_class_base_set(context->vt_context->analysis, class_name, &base);
        rz_analysis_class_base_fini(&base);
    }
}

References recovery_base_descriptor_t::bcd, recovery_type_descriptor_t::col, rtti_base_class_descriptor_t::mdisp, rtti_type_descriptor_t::name, NULL, recovery_apply_complete_object_locator(), recovery_apply_type_descriptor(), rz_analysis_class_base_fini(), rz_analysis_class_base_set(), RZ_LOG_DEBUG, RZ_LOG_WARN, rz_vector_foreach, strdup(), recovery_base_descriptor_t::td, recovery_type_descriptor_t::td, ut64(), recovery_type_descriptor_t::valid, and rtti_base_class_descriptor_t::where.

Referenced by recovery_apply_complete_object_locator(), and recovery_apply_type_descriptor().

recovery_apply_complete_object_locator()

static const char * recovery_apply_complete_object_locator ( RRTTIMSVCAnalContext *  context, RecoveryCompleteObjectLocator *  col  )

static

Definition at line 886 of file rtti_msvc.c.

                                                                                                                             {
    if (!col->valid) {
        return NULL;
    }
 
    if (!col->td) {
        RZ_LOG_DEBUG("No recovery type descriptor for recovery object locator at 0x%" PFMT64x "\n", col->addr);
        return NULL;
    }
 
    RzAnalysis *analysis = context->vt_context->analysis;
 
    const char *existing = ht_up_find(context->col_td_classes, col->addr, NULL);
    if (existing != NULL) {
        return existing;
    }
 
    char *name = rz_analysis_rtti_msvc_demangle_class_name(context->vt_context, col->td->td.name);
    if (!name) {
        RZ_LOG_DEBUG("Failed to demangle a class name: \"%s\"\n", col->td->td.name);
        name = strdup(col->td->td.name);
        if (!name) {
            return NULL;
        }
    }
 
    char *tmp = name;
    name = unique_class_name(analysis, name);
    free(tmp);
    if (!name) {
        return NULL;
    }
 
    rz_analysis_class_create(analysis, name);
    ht_up_insert(context->col_td_classes, col->addr, name);
 
    recovery_apply_vtable(context->vt_context, name, col->vtable);
    recovery_apply_bases(context, name, &col->base_td);
 
    return name;
}

References recovery_complete_object_locator_t::addr, recovery_complete_object_locator_t::base_td, free(), name, rtti_type_descriptor_t::name, NULL, PFMT64x, recovery_apply_bases(), recovery_apply_vtable(), rz_analysis_class_create(), rz_analysis_rtti_msvc_demangle_class_name(), RZ_LOG_DEBUG, strdup(), recovery_complete_object_locator_t::td, recovery_type_descriptor_t::td, autogen_x86imm::tmp, unique_class_name(), recovery_complete_object_locator_t::valid, and recovery_complete_object_locator_t::vtable.

Referenced by recovery_apply_bases(), and rz_analysis_rtti_msvc_recover_all().

recovery_apply_type_descriptor()

static const char * recovery_apply_type_descriptor ( RRTTIMSVCAnalContext *  context, RecoveryTypeDescriptor *  td  )

static

Definition at line 928 of file rtti_msvc.c.

                                                                                                             {
    if (!td->valid) {
        return NULL;
    }
 
    RzAnalysis *analysis = context->vt_context->analysis;
 
    const char *existing = ht_up_find(context->col_td_classes, td->addr, NULL);
    if (existing != NULL) {
        return existing;
    }
 
    char *name = rz_analysis_rtti_msvc_demangle_class_name(context->vt_context, td->td.name);
    if (!name) {
        RZ_LOG_DEBUG("Failed to demangle a class name: \"%s\"\n", td->td.name);
        name = strdup(td->td.name);
        if (!name) {
            return NULL;
        }
    }
 
    rz_analysis_class_create(analysis, name);
    ht_up_insert(context->col_td_classes, td->addr, name);
 
    if (!td->col || !td->col->valid) {
        return name;
    }
 
    recovery_apply_vtable(context->vt_context, name, td->col->vtable);
    recovery_apply_bases(context, name, &td->col->base_td);
 
    return name;
}

References recovery_type_descriptor_t::addr, recovery_complete_object_locator_t::base_td, recovery_type_descriptor_t::col, name, rtti_type_descriptor_t::name, NULL, recovery_apply_bases(), recovery_apply_vtable(), rz_analysis_class_create(), rz_analysis_rtti_msvc_demangle_class_name(), RZ_LOG_DEBUG, strdup(), recovery_type_descriptor_t::td, recovery_complete_object_locator_t::valid, recovery_type_descriptor_t::valid, and recovery_complete_object_locator_t::vtable.

Referenced by recovery_apply_bases(), and rz_analysis_rtti_msvc_recover_all().

recovery_apply_vtable()

static void recovery_apply_vtable ( RVTableContext *  context, const char *  class_name, RVTableInfo *  vtable_info  )

static

Definition at line 810 of file rtti_msvc.c.

                                                                                                             {
    if (!vtable_info) {
        return;
    }
 
    ut64 size = rz_analysis_vtable_info_get_size(context, vtable_info);
 
    RzAnalysisVTable vtable;
    vtable.size = size;
    vtable.id = NULL;
    vtable.offset = 0;
    vtable.addr = vtable_info->saddr;
    rz_analysis_class_vtable_set(context->analysis, class_name, &vtable);
    rz_analysis_class_vtable_fini(&vtable);
 
    RVTableMethodInfo *vmeth;
    rz_vector_foreach(&vtable_info->methods, vmeth) {
        RzAnalysisMethod meth;
        if (!rz_analysis_class_method_exists_by_addr(context->analysis, class_name, vmeth->addr)) {
            meth.addr = vmeth->addr;
            meth.vtable_offset = vmeth->vtable_offset;
            RzAnalysisFunction *fcn = rz_analysis_get_function_at(context->analysis, vmeth->addr);
            meth.name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset);
            // Temporarily set as attr name
            meth.real_name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset);
            meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL;
        } else {
            RzAnalysisMethod exist_meth;
            if (rz_analysis_class_method_get_by_addr(context->analysis, class_name, vmeth->addr, &exist_meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
                meth.addr = vmeth->addr;
                meth.name = rz_str_new(exist_meth.name);
                meth.real_name = rz_str_new(exist_meth.real_name);
                meth.vtable_offset = vmeth->vtable_offset;
                meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL;
                rz_analysis_class_method_fini(&exist_meth);
            }
        }
        rz_analysis_class_method_set(context->analysis, class_name, &meth);
        rz_analysis_class_method_fini(&meth);
    }
}

References rz_analysis_function_t::name, NULL, PFMT64d, rz_analysis_class_method_exists_by_addr(), rz_analysis_class_method_fini(), rz_analysis_class_method_get_by_addr(), rz_analysis_class_method_set(), rz_analysis_class_vtable_fini(), rz_analysis_class_vtable_set(), rz_analysis_get_function_at(), rz_analysis_vtable_info_get_size(), rz_str_new(), rz_str_newf(), rz_vector_foreach, and ut64().

Referenced by recovery_apply_complete_object_locator(), and recovery_apply_type_descriptor().

recovery_complete_object_locator_free()

void recovery_complete_object_locator_free

(

RecoveryCompleteObjectLocator *

col

)

Definition at line 648 of file rtti_msvc.c.

                                                                               {
    if (!col) {
        return;
    }
    rz_list_free(col->bcd);
    rz_vector_clear(&col->base_td);
    free(col);
}

References recovery_complete_object_locator_t::base_td, recovery_complete_object_locator_t::bcd, free(), rz_list_free(), and rz_vector_clear().

Referenced by rz_analysis_rtti_msvc_recover_all().

recovery_complete_object_locator_new()

RecoveryCompleteObjectLocator* recovery_complete_object_locator_new

(

)

Definition at line 639 of file rtti_msvc.c.

                                                                      {
    RecoveryCompleteObjectLocator *col = RZ_NEW0(RecoveryCompleteObjectLocator);
    if (!col) {
        return NULL;
    }
    rz_vector_init(&col->base_td, sizeof(RecoveryBaseDescriptor), NULL, NULL);
    return col;
}

References recovery_complete_object_locator_t::base_td, NULL, RZ_NEW0, and rz_vector_init().

Referenced by recovery_analysis_complete_object_locator().

recovery_type_descriptor_free()

void recovery_type_descriptor_free

(

RecoveryTypeDescriptor *

td

)

Definition at line 678 of file rtti_msvc.c.

                                                               {
    if (!td) {
        return;
    }
    rtti_type_descriptor_fini(&td->td);
    free(td);
}

References free(), rtti_type_descriptor_fini(), and recovery_type_descriptor_t::td.

Referenced by rz_analysis_rtti_msvc_recover_all().

recovery_type_descriptor_new()

RecoveryTypeDescriptor* recovery_type_descriptor_new

(

)

Definition at line 664 of file rtti_msvc.c.

                                                       {
    RecoveryTypeDescriptor *td = RZ_NEW(RecoveryTypeDescriptor);
    if (!td) {
        return NULL;
    }
 
    td->addr = 0;
    td->valid = false;
    memset(&td->td, 0, sizeof(td->td));
    td->col = NULL;
    // td->vtable = NULL;
    return td;
}

References recovery_type_descriptor_t::addr, recovery_type_descriptor_t::col, memset(), NULL, RZ_NEW, recovery_type_descriptor_t::td, and recovery_type_descriptor_t::valid.

Referenced by recovery_analysis_type_descriptor().

rtti_msvc_addr()

static ut64 rtti_msvc_addr ( RVTableContext *  context, ut64  col_addr, ut64  col_base, ut32  addr  )

inlinestatic

Definition at line 49 of file rtti_msvc.c.

                                                                                                    {
    if (context->word_size != 8) {
        return addr;
    }
    return addr + (col_addr - col_base);
}

References addr.

Referenced by recovery_analysis_complete_object_locator(), and rtti_msvc_print_complete_object_locator_recurse().

rtti_msvc_base_class_descriptor_size()

static ut64 rtti_msvc_base_class_descriptor_size ( RVTableContext *  context )

static

Definition at line 125 of file rtti_msvc.c.

                                                                          {
    return context->word_size + 5 * sizeof(ut32);
}

Referenced by rtti_msvc_read_base_class_descriptor().

rtti_msvc_print_base_class_descriptor()

static void rtti_msvc_print_base_class_descriptor ( rtti_base_class_descriptor *  bcd, const char *  prefix  )

static

Definition at line 352 of file rtti_msvc.c.

                                                                                                       {
    rz_cons_printf("%sBase Class Descriptor:\n"
               "%s\ttypeDescriptorAddr: 0x%08" PFMT32x "\n"
               "%s\tnumContainedBases: %#x\n"
               "%s\twhere:\n"
               "%s\t\tmdisp: %d\n"
               "%s\t\tpdisp: %d\n"
               "%s\t\tvdisp: %d\n"
               "%s\tattributes: %#x\n\n",
        prefix,
        prefix, bcd->type_descriptor_addr,
        prefix, bcd->num_contained_bases,
        prefix,
        prefix, bcd->where.mdisp,
        prefix, bcd->where.pdisp,
        prefix, bcd->where.vdisp,
        prefix, bcd->attributes);
}

References rtti_base_class_descriptor_t::attributes, rtti_base_class_descriptor_t::mdisp, rtti_base_class_descriptor_t::num_contained_bases, rtti_base_class_descriptor_t::pdisp, PFMT32x, prefix, rz_cons_printf(), rtti_base_class_descriptor_t::type_descriptor_addr, rtti_base_class_descriptor_t::vdisp, and rtti_base_class_descriptor_t::where.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_base_class_descriptor().

rtti_msvc_print_base_class_descriptor_json()

static void rtti_msvc_print_base_class_descriptor_json ( PJ *  pj, rtti_base_class_descriptor *  bcd  )

static

Definition at line 371 of file rtti_msvc.c.

                                                                                                {
    pj_o(pj);
    pj_kn(pj, "type_desc_addr", bcd->type_descriptor_addr);
    pj_kn(pj, "num_contained_bases", bcd->num_contained_bases);
    pj_ko(pj, "where");
    pj_ki(pj, "mdisp", bcd->where.mdisp);
    pj_ki(pj, "pdisp", bcd->where.pdisp);
    pj_ki(pj, "vdisp", bcd->where.vdisp);
    pj_end(pj);
    pj_kn(pj, "attributes", bcd->attributes);
    pj_end(pj);
}

References rtti_base_class_descriptor_t::attributes, rtti_base_class_descriptor_t::mdisp, rtti_base_class_descriptor_t::num_contained_bases, rtti_base_class_descriptor_t::pdisp, pj_end(), pj_ki(), pj_kn(), pj_ko(), pj_o(), rtti_base_class_descriptor_t::type_descriptor_addr, rtti_base_class_descriptor_t::vdisp, and rtti_base_class_descriptor_t::where.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_base_class_descriptor().

rtti_msvc_print_class_hierarchy_descriptor()

static void rtti_msvc_print_class_hierarchy_descriptor ( rtti_class_hierarchy_descriptor *  chd, ut64  addr, const char *  prefix  )

static

Definition at line 330 of file rtti_msvc.c.

                                                                                                                            {
    rz_cons_printf("%sClass Hierarchy Descriptor at 0x%08" PFMT64x ":\n"
               "%s\tsignature: %#x\n"
               "%s\tattributes: %#x\n"
               "%s\tnumBaseClasses: %#x\n"
               "%s\tbaseClassArrayAddr: 0x%08" PFMT32x "\n\n",
        prefix, addr,
        prefix, chd->signature,
        prefix, chd->attributes,
        prefix, chd->num_base_classes,
        prefix, chd->base_class_array_addr);
}

References addr, rtti_class_hierarchy_descriptor_t::attributes, rtti_class_hierarchy_descriptor_t::base_class_array_addr, rtti_class_hierarchy_descriptor_t::num_base_classes, PFMT32x, PFMT64x, prefix, rz_cons_printf(), and rtti_class_hierarchy_descriptor_t::signature.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_class_hierarchy_descriptor().

rtti_msvc_print_class_hierarchy_descriptor_json()

static void rtti_msvc_print_class_hierarchy_descriptor_json ( PJ *  pj, rtti_class_hierarchy_descriptor *  chd  )

static

Definition at line 343 of file rtti_msvc.c.

                                                                                                          {
    pj_o(pj);
    pj_kn(pj, "signature", chd->signature);
    pj_kn(pj, "attributes", chd->attributes);
    pj_kn(pj, "num_base_classes", chd->num_base_classes);
    pj_kn(pj, "base_class_array_addr", chd->base_class_array_addr);
    pj_end(pj);
}

References rtti_class_hierarchy_descriptor_t::attributes, rtti_class_hierarchy_descriptor_t::base_class_array_addr, rtti_class_hierarchy_descriptor_t::num_base_classes, pj_end(), pj_kn(), pj_o(), and rtti_class_hierarchy_descriptor_t::signature.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_class_hierarchy_descriptor().

rtti_msvc_print_complete_object_locator()

static void rtti_msvc_print_complete_object_locator ( rtti_complete_object_locator *  col, ut64  addr, const char *  prefix  )

static

Definition at line 283 of file rtti_msvc.c.

                                                                                                                      {
    rz_cons_printf("%sComplete Object Locator at 0x%08" PFMT64x ":\n"
               "%s\tsignature: %#x\n"
               "%s\tvftableOffset: %#x\n"
               "%s\tcdOffset: %#x\n"
               "%s\ttypeDescriptorAddr: 0x%08" PFMT32x "\n"
               "%s\tclassDescriptorAddr: 0x%08" PFMT32x "\n",
        prefix, addr,
        prefix, col->signature,
        prefix, col->vtable_offset,
        prefix, col->cd_offset,
        prefix, col->type_descriptor_addr,
        prefix, col->class_descriptor_addr);
    rz_cons_printf("%s\tobjectBase: 0x%08" PFMT32x "\n\n",
        prefix, col->object_base);
}

References addr, rtti_complete_object_locator_t::cd_offset, rtti_complete_object_locator_t::class_descriptor_addr, rtti_complete_object_locator_t::object_base, PFMT32x, PFMT64x, prefix, rz_cons_printf(), rtti_complete_object_locator_t::signature, rtti_complete_object_locator_t::type_descriptor_addr, and rtti_complete_object_locator_t::vtable_offset.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_complete_object_locator().

rtti_msvc_print_complete_object_locator_json()

static void rtti_msvc_print_complete_object_locator_json ( PJ *  pj, rtti_complete_object_locator *  col  )

static

Definition at line 300 of file rtti_msvc.c.

                                                                                                    {
    pj_o(pj);
    pj_kn(pj, "signature", col->signature);
    pj_kn(pj, "vftable_offset", col->vtable_offset);
    pj_kn(pj, "cd_offset", col->cd_offset);
    pj_kn(pj, "type_desc_addr", col->type_descriptor_addr);
    pj_kn(pj, "class_desc_addr", col->class_descriptor_addr);
    pj_kn(pj, "object_base", col->object_base);
    pj_end(pj);
}

References rtti_complete_object_locator_t::cd_offset, rtti_complete_object_locator_t::class_descriptor_addr, rtti_complete_object_locator_t::object_base, pj_end(), pj_kn(), pj_o(), rtti_complete_object_locator_t::signature, rtti_complete_object_locator_t::type_descriptor_addr, and rtti_complete_object_locator_t::vtable_offset.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_complete_object_locator().

rtti_msvc_print_complete_object_locator_recurse()

static bool rtti_msvc_print_complete_object_locator_recurse ( RVTableContext *  context, ut64  atAddress, RzOutputMode  mode, bool  strict  )

static

Definition at line 499 of file rtti_msvc.c.

                                                                                                                                     {
    ut64 colRefAddr = atAddress - context->word_size;
    ut64 colAddr;
    if (!context->read_addr(context->analysis, colRefAddr, &colAddr)) {
        return false;
    }
 
    // complete object locator
    rtti_complete_object_locator col;
    if (!rtti_msvc_read_complete_object_locator(context, colAddr, &col)) {
        if (!strict) {
            RZ_LOG_ERROR("Failed to parse complete object locator at 0x%08" PFMT64x " (referenced from 0x%08" PFMT64x ")\n", colAddr, colRefAddr);
        }
        return false;
    }
 
    // type descriptor
    ut64 typeDescriptorAddr = rtti_msvc_addr(context, colAddr, col.object_base, col.type_descriptor_addr);
    rtti_type_descriptor td = { 0 };
    if (!rtti_msvc_read_type_descriptor(context, typeDescriptorAddr, &td)) {
        if (!strict) {
            RZ_LOG_ERROR("Failed to parse type descriptor at 0x%08" PFMT64x "\n", typeDescriptorAddr);
        }
        return false;
    }
 
    // class hierarchy descriptor
    ut64 classHierarchyDescriptorAddr = rtti_msvc_addr(context, colAddr, col.object_base, col.class_descriptor_addr);
    rtti_class_hierarchy_descriptor chd;
    if (!rtti_msvc_read_class_hierarchy_descriptor(context, classHierarchyDescriptorAddr, &chd)) {
        if (!strict) {
            RZ_LOG_ERROR("Failed to parse class hierarchy descriptor at 0x%08" PFMT64x "\n", classHierarchyDescriptorAddr);
        }
        rtti_type_descriptor_fini(&td);
        return false;
    }
 
    ut64 base = chd.base_class_array_addr;
    ut32 baseClassArrayOffset = 0;
    if (context->word_size == 8) {
        base = colAddr - col.object_base;
        baseClassArrayOffset = chd.base_class_array_addr;
    }
 
    RzList *baseClassArray = rtti_msvc_read_base_class_array(context, chd.num_base_classes, base, baseClassArrayOffset);
    if (!baseClassArray) {
        if (!strict) {
            RZ_LOG_ERROR("Failed to parse base class array starting at 0x%08" PFMT64x "\n", base + baseClassArrayOffset);
        }
        rtti_type_descriptor_fini(&td);
        return false;
    }
 
    // print
    bool use_json = mode == RZ_OUTPUT_MODE_JSON;
    PJ *pj = NULL;
    if (use_json) {
        pj = pj_new();
        if (!pj) {
            return false;
        }
        pj_o(pj);
        pj_k(pj, "complete_object_locator");
        rtti_msvc_print_complete_object_locator_json(pj, &col);
        pj_k(pj, "type_desc");
        rtti_msvc_print_type_descriptor_json(pj, &td);
        pj_k(pj, "class_hierarchy_desc");
        rtti_msvc_print_class_hierarchy_descriptor_json(pj, &chd);
        pj_ka(pj, "base_classes");
    } else {
        rtti_msvc_print_complete_object_locator(&col, colAddr, "");
        rtti_msvc_print_type_descriptor(&td, typeDescriptorAddr, "\t");
        rtti_msvc_print_class_hierarchy_descriptor(&chd, classHierarchyDescriptorAddr, "\t");
    }
 
    // base classes
    RzListIter *bcdIter;
    rtti_base_class_descriptor *bcd;
    rz_list_foreach (baseClassArray, bcdIter, bcd) {
        if (use_json) {
            pj_o(pj);
            pj_k(pj, "desc");
            rtti_msvc_print_base_class_descriptor_json(pj, bcd);
        } else {
            rtti_msvc_print_base_class_descriptor(bcd, "\t\t");
        }
 
        ut64 baseTypeDescriptorAddr = rtti_msvc_addr(context, colAddr, col.object_base, bcd->type_descriptor_addr);
        rtti_type_descriptor btd = { 0 };
        if (rtti_msvc_read_type_descriptor(context, baseTypeDescriptorAddr, &btd)) {
            if (use_json) {
                pj_k(pj, "type_desc");
                rtti_msvc_print_type_descriptor_json(pj, &btd);
            } else {
                rtti_msvc_print_type_descriptor(&btd, baseTypeDescriptorAddr, "\t\t\t");
            }
            rtti_type_descriptor_fini(&btd);
        } else {
            if (!strict) {
                RZ_LOG_ERROR("Failed to parse type descriptor at 0x%08" PFMT64x "\n", baseTypeDescriptorAddr);
            }
        }
 
        if (use_json) {
            pj_end(pj);
        }
    }
    if (use_json) {
        pj_end(pj);
        pj_end(pj);
        rz_cons_print(pj_string(pj));
        pj_free(pj);
    }
 
    rtti_type_descriptor_fini(&td);
    return true;
}

References rtti_class_hierarchy_descriptor_t::base_class_array_addr, rtti_complete_object_locator_t::class_descriptor_addr, NULL, rtti_class_hierarchy_descriptor_t::num_base_classes, rtti_complete_object_locator_t::object_base, PFMT64x, pj_end(), pj_free(), pj_k(), pj_ka(), pj_new(), pj_o(), pj_string(), rtti_msvc_addr(), rtti_msvc_print_base_class_descriptor(), rtti_msvc_print_base_class_descriptor_json(), rtti_msvc_print_class_hierarchy_descriptor(), rtti_msvc_print_class_hierarchy_descriptor_json(), rtti_msvc_print_complete_object_locator(), rtti_msvc_print_complete_object_locator_json(), rtti_msvc_print_type_descriptor(), rtti_msvc_print_type_descriptor_json(), rtti_msvc_read_base_class_array(), rtti_msvc_read_class_hierarchy_descriptor(), rtti_msvc_read_complete_object_locator(), rtti_msvc_read_type_descriptor(), rtti_type_descriptor_fini(), RZ_LOG_ERROR, RZ_OUTPUT_MODE_JSON, rtti_complete_object_locator_t::type_descriptor_addr, rtti_base_class_descriptor_t::type_descriptor_addr, and ut64().

rtti_msvc_print_type_descriptor()

static void rtti_msvc_print_type_descriptor ( rtti_type_descriptor *  td, ut64  addr, const char *  prefix  )

static

Definition at line 311 of file rtti_msvc.c.

                                                                                                     {
    rz_cons_printf("%sType Descriptor at 0x%08" PFMT64x ":\n"
               "%s\tvtableAddr: 0x%08" PFMT64x "\n"
               "%s\tspare: 0x%08" PFMT64x "\n"
               "%s\tname: %s\n\n",
        prefix, addr,
        prefix, td->vtable_addr,
        prefix, td->spare,
        prefix, td->name);
}

References addr, rtti_type_descriptor_t::name, PFMT64x, prefix, rz_cons_printf(), rtti_type_descriptor_t::spare, and rtti_type_descriptor_t::vtable_addr.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_type_descriptor().

rtti_msvc_print_type_descriptor_json()

static void rtti_msvc_print_type_descriptor_json ( PJ *  pj, rtti_type_descriptor *  td  )

static

Definition at line 322 of file rtti_msvc.c.

                                                                                   {
    pj_o(pj);
    pj_kn(pj, "vtable_addr", td->vtable_addr);
    pj_kn(pj, "spare", td->spare);
    pj_ks(pj, "name", td->name);
    pj_end(pj);
}

References rtti_type_descriptor_t::name, pj_end(), pj_kn(), pj_ks(), pj_o(), rtti_type_descriptor_t::spare, and rtti_type_descriptor_t::vtable_addr.

Referenced by rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_type_descriptor().

rtti_msvc_read_base_class_array()

static RzList* rtti_msvc_read_base_class_array ( RVTableContext *  context, ut32  num_base_classes, ut64  base, ut32  offset  )

static

Definition at line 156 of file rtti_msvc.c.

                                                                                                                       {
    if (base == UT64_MAX || offset == UT32_MAX || num_base_classes == UT32_MAX) {
        return NULL;
    }
 
    RzList *ret = rz_list_newf(free);
    if (!ret) {
        return NULL;
    }
 
    ut64 addr = base + offset;
    ut64 stride = RZ_MIN(context->word_size, 4);
 
    if (num_base_classes > BASE_CLASSES_MAX) {
        RZ_LOG_DEBUG("Length of base class array at 0x%08" PFMT64x " exceeds %d.\n", addr, BASE_CLASSES_MAX);
        num_base_classes = BASE_CLASSES_MAX;
    }
 
    rz_cons_break_push(NULL, NULL);
    while (num_base_classes > 0) {
        if (rz_cons_is_breaked()) {
            break;
        }
 
        ut64 bcdAddr;
        if (context->word_size <= 4) {
            if (!context->read_addr(context->analysis, addr, &bcdAddr)) {
                break;
            }
            if (bcdAddr == UT32_MAX) {
                break;
            }
        } else {
            // special offset calculation for 64bit
            ut8 tmp[4] = { 0 };
            if (!context->analysis->iob.read_at(context->analysis->iob.io, addr, tmp, 4)) {
                rz_list_free(ret);
                return NULL;
            }
            ut32 (*read_32)(const void *src) = context->analysis->big_endian ? rz_read_be32 : rz_read_le32;
            ut32 bcdOffset = read_32(tmp);
            if (bcdOffset == UT32_MAX) {
                break;
            }
            bcdAddr = base + bcdOffset;
        }
 
        rtti_base_class_descriptor *bcd = malloc(sizeof(rtti_base_class_descriptor));
        if (!bcd) {
            break;
        }
        if (!rtti_msvc_read_base_class_descriptor(context, bcdAddr, bcd)) {
            free(bcd);
            break;
        }
        rz_list_append(ret, bcd);
        addr += stride;
        num_base_classes--;
    }
    rz_cons_break_pop();
 
    if (num_base_classes > 0) {
        // there was an error in the loop above
        rz_list_free(ret);
        return NULL;
    }
 
    return ret;
}

References addr, BASE_CLASSES_MAX, free(), malloc(), NULL, PFMT64x, rtti_msvc_read_base_class_descriptor(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_DEBUG, RZ_MIN, rz_read_be32(), rz_read_le32(), src, autogen_x86imm::tmp, UT32_MAX, ut64(), and UT64_MAX.

Referenced by recovery_analysis_complete_object_locator(), and rtti_msvc_print_complete_object_locator_recurse().

rtti_msvc_read_base_class_descriptor()

static bool rtti_msvc_read_base_class_descriptor ( RVTableContext *  context, ut64  addr, rtti_base_class_descriptor *  bcd  )

static

Definition at line 129 of file rtti_msvc.c.

                                                                                                                      {
    if (addr == UT64_MAX) {
        return false;
    }
 
    ut8 buf[sizeof(ut64) + 5 * sizeof(ut32)];
    int bcdSize = (int)rtti_msvc_base_class_descriptor_size(context);
    if (bcdSize > sizeof(buf)) {
        return false;
    }
 
    if (!context->analysis->iob.read_at(context->analysis->iob.io, addr, buf, bcdSize)) {
        return false;
    }
 
    ut32 (*read_at_32)(const void *src, size_t offset) = context->analysis->big_endian ? rz_read_at_be32 : rz_read_at_le32;
    int typeDescriptorAddrSize = RZ_MIN(context->word_size, 4);
    bcd->type_descriptor_addr = (ut32)rz_read_ble(buf, (bool)context->analysis->big_endian, typeDescriptorAddrSize * 8);
    size_t offset = (size_t)typeDescriptorAddrSize;
    bcd->num_contained_bases = read_at_32(buf, offset);
    bcd->where.mdisp = read_at_32(buf, offset + sizeof(ut32));
    bcd->where.pdisp = read_at_32(buf, offset + 2 * sizeof(ut32));
    bcd->where.vdisp = read_at_32(buf, offset + 3 * sizeof(ut32));
    bcd->attributes = read_at_32(buf, offset + 4 * sizeof(ut32));
    return true;
}

References addr, rtti_base_class_descriptor_t::attributes, int, rtti_base_class_descriptor_t::mdisp, rtti_base_class_descriptor_t::num_contained_bases, rtti_base_class_descriptor_t::pdisp, rtti_msvc_base_class_descriptor_size(), RZ_MIN, rz_read_at_be32(), rz_read_at_le32(), rz_read_ble(), src, rtti_base_class_descriptor_t::type_descriptor_addr, ut64(), UT64_MAX, rtti_base_class_descriptor_t::vdisp, and rtti_base_class_descriptor_t::where.

Referenced by rtti_msvc_read_base_class_array(), and rz_analysis_rtti_msvc_print_base_class_descriptor().

rtti_msvc_read_class_hierarchy_descriptor()

static bool rtti_msvc_read_class_hierarchy_descriptor ( RVTableContext *  context, ut64  addr, rtti_class_hierarchy_descriptor *  chd  )

static

Definition at line 95 of file rtti_msvc.c.

                                                                                                                                {
    if (addr == UT64_MAX) {
        return false;
    }
 
    ut8 buf[4 * sizeof(ut32)];
    int chdSize = 3 * sizeof(ut32) + RZ_MIN(4, context->word_size);
    if (chdSize > sizeof(buf)) {
        return false;
    }
 
    if (!context->analysis->iob.read_at(context->analysis->iob.io, addr, buf, chdSize)) {
        return false;
    }
 
    ut32 (*read_at_32)(const void *src, size_t offset) = context->analysis->big_endian ? rz_read_at_be32 : rz_read_at_le32;
    chd->signature = read_at_32(buf, 0);
    chd->attributes = read_at_32(buf, 4);
    chd->num_base_classes = read_at_32(buf, 8);
    if (context->word_size <= 4) {
        chd->base_class_array_addr = (ut32)rz_read_ble(buf + 12, (bool)context->analysis->big_endian, context->word_size * 8);
    } else {
        // 64bit is special, like in Complete Object Locator.
        // Only the offset from the base from Complete Object Locator
        // is contained in Class Hierarchy Descriptor
        chd->base_class_array_addr = read_at_32(buf, 12);
    }
    return true;
}

References addr, rtti_class_hierarchy_descriptor_t::attributes, rtti_class_hierarchy_descriptor_t::base_class_array_addr, rtti_class_hierarchy_descriptor_t::num_base_classes, RZ_MIN, rz_read_at_be32(), rz_read_at_le32(), rz_read_ble(), rtti_class_hierarchy_descriptor_t::signature, src, and UT64_MAX.

Referenced by recovery_analysis_complete_object_locator(), rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_class_hierarchy_descriptor().

rtti_msvc_read_complete_object_locator()

static bool rtti_msvc_read_complete_object_locator ( RVTableContext *  context, ut64  addr, rtti_complete_object_locator *  col  )

static

Definition at line 56 of file rtti_msvc.c.

                                                                                                                          {
    if (addr == UT64_MAX) {
        return false;
    }
 
    ut8 buf[6 * sizeof(ut32)];
    int colSize = 5 * sizeof(ut32);
    if (context->word_size == 8) {
        colSize += sizeof(ut32);
    }
    if (colSize > sizeof(buf)) {
        return false;
    }
 
    if (!context->analysis->iob.read_at(context->analysis->iob.io, addr, buf, colSize)) {
        return false;
    }
 
    ut32 (*read_at_32)(const void *src, size_t offset) = context->analysis->big_endian ? rz_read_at_be32 : rz_read_at_le32;
    col->signature = read_at_32(buf, 0);
    col->vtable_offset = read_at_32(buf, 4);
    col->cd_offset = read_at_32(buf, 8);
 
    int offsetSize = RZ_MIN(context->word_size, 4);
    col->type_descriptor_addr = (ut32)rz_read_ble(buf + 12, (bool)context->analysis->big_endian, offsetSize * 8);
    col->class_descriptor_addr = (ut32)rz_read_ble(buf + 12 + offsetSize, (bool)context->analysis->big_endian, offsetSize * 8);
    if (context->word_size == 8) {
        // 64bit is special:
        // Type Descriptor and Class Hierarchy Descriptor addresses are computed
        // by 32 bit values *(col+12) + *(col+0x14)
        // and *(col+16) + *(col+0x14) respectively
        col->object_base = read_at_32(buf, 20);
    } else {
        col->object_base = 0;
    }
 
    return true;
}

References addr, rtti_complete_object_locator_t::cd_offset, rtti_complete_object_locator_t::class_descriptor_addr, rtti_complete_object_locator_t::object_base, RZ_MIN, rz_read_at_be32(), rz_read_at_le32(), rz_read_ble(), rtti_complete_object_locator_t::signature, src, rtti_complete_object_locator_t::type_descriptor_addr, UT64_MAX, and rtti_complete_object_locator_t::vtable_offset.

Referenced by recovery_analysis_complete_object_locator(), rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_complete_object_locator().

rtti_msvc_read_type_descriptor()

static bool rtti_msvc_read_type_descriptor ( RVTableContext *  context, ut64  addr, rtti_type_descriptor *  td  )

static

Definition at line 226 of file rtti_msvc.c.

                                                                                                         {
    if (addr == UT64_MAX) {
        return false;
    }
 
    if (!context->read_addr(context->analysis, addr, &td->vtable_addr)) {
        return false;
    }
    if (!context->read_addr(context->analysis, addr + context->word_size, &td->spare)) {
        return false;
    }
 
    ut64 nameAddr = addr + 2 * context->word_size;
    ut8 buf[NAME_BUF_SIZE];
    ut64 bufOffset = 0;
    size_t nameLen = 0;
    bool endFound = false;
    bool endInvalid = false;
    while (1) {
        context->analysis->iob.read_at(context->analysis->iob.io, nameAddr + bufOffset, buf, sizeof(buf));
        int i;
        for (i = 0; i < sizeof(buf); i++) {
            if (buf[i] == '\0') {
                endFound = true;
                break;
            }
            if (buf[i] == 0xff) {
                endInvalid = true;
                break;
            }
            nameLen++;
        }
        if (endFound || endInvalid) {
            break;
        }
        bufOffset += sizeof(buf);
    }
 
    if (endInvalid) {
        return false;
    }
 
    td->name = malloc(nameLen + 1);
    if (!td->name) {
        return false;
    }
 
    if (bufOffset == 0) {
        memcpy(td->name, buf, nameLen + 1);
    } else {
        context->analysis->iob.read_at(context->analysis->iob.io, nameAddr,
            (ut8 *)td->name, (int)(nameLen + 1));
    }
 
    return true;
}

References addr, i, malloc(), memcpy(), rtti_type_descriptor_t::name, NAME_BUF_SIZE, rtti_type_descriptor_t::spare, ut64(), UT64_MAX, and rtti_type_descriptor_t::vtable_addr.

Referenced by recovery_analysis_type_descriptor(), rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_type_descriptor().

rtti_type_descriptor_fini()

static void rtti_type_descriptor_fini ( rtti_type_descriptor *  td )

static

Definition at line 44 of file rtti_msvc.c.

                                                                {
    free(td->name);
    td->name = NULL;
}

References free(), rtti_type_descriptor_t::name, and NULL.

Referenced by recovery_type_descriptor_free(), rtti_msvc_print_complete_object_locator_recurse(), and rz_analysis_rtti_msvc_print_type_descriptor().

rz_analysis_rtti_msvc_demangle_class_name()

RZ_API char* rz_analysis_rtti_msvc_demangle_class_name	(	RVTableContext *	context,
		const char *	name
	)

Demangle a class name as found in MSVC RTTI type descriptors.

Examples: .?AVClassA@ => ClassA .?AVClassInInnerNamespace@InnerNamespace@OuterNamespace@ => OuterNamespace::InnerNamespace::AVClassInInnerNamespace

Definition at line 393 of file rtti_msvc.c.

                                                                                                  {
    if (!name) {
        return NULL;
    }
    size_t original_len = strlen(name);
    if (original_len < 7 || (strncmp(name, ".?AV", 4) != 0 && strncmp(name, ".?AU", 4) != 0) || strncmp(name + original_len - 2, "@@", 2) != 0) {
        return NULL;
    }
    char *ret = context->analysis->binb.demangle(NULL, "msvc", name, 0, false);
    if (ret && *ret) {
        char *n = strchr(ret, ' ');
        if (n && *(++n)) {
            char *tmp = strdup(n);
            free(ret);
            ret = tmp;
        } else {
            RZ_FREE(ret);
        }
    } else {
        RZ_FREE(ret);
    }
    return ret;
}

References free(), n, NULL, RZ_FREE, strdup(), and autogen_x86imm::tmp.

Referenced by recovery_apply_complete_object_locator(), recovery_apply_type_descriptor(), and rz_analysis_rtti_demangle_class_name().

rz_analysis_rtti_msvc_print_at_vtable()

RZ_API bool rz_analysis_rtti_msvc_print_at_vtable	(	RVTableContext *	context,
		ut64	addr,
		RzOutputMode	mode,
		bool	strict
	)

Definition at line 617 of file rtti_msvc.c.

                                                                                                                      {
    return rtti_msvc_print_complete_object_locator_recurse(context, addr, mode, strict);
}

Referenced by rz_analysis_rtti_print_all(), and rz_analysis_rtti_print_at_vtable().

rz_analysis_rtti_msvc_print_base_class_descriptor()

RZ_API void rz_analysis_rtti_msvc_print_base_class_descriptor	(	RVTableContext *	context,
		ut64	addr,
		int	mode
	)

Definition at line 479 of file rtti_msvc.c.

                                                                                                            {
    rtti_base_class_descriptor bcd;
    if (!rtti_msvc_read_base_class_descriptor(context, addr, &bcd)) {
        RZ_LOG_ERROR("Failed to parse base class descriptor at 0x%08" PFMT64x "\n", addr);
        return;
    }
 
    if (mode == 'j') {
        PJ *pj = pj_new();
        if (!pj) {
            return;
        }
        rtti_msvc_print_base_class_descriptor_json(pj, &bcd);
        rz_cons_print(pj_string(pj));
        pj_free(pj);
    } else {
        rtti_msvc_print_base_class_descriptor(&bcd, "");
    }
}

References addr, PFMT64x, pj_free(), pj_new(), pj_string(), rtti_msvc_print_base_class_descriptor(), rtti_msvc_print_base_class_descriptor_json(), rtti_msvc_read_base_class_descriptor(), and RZ_LOG_ERROR.

rz_analysis_rtti_msvc_print_class_hierarchy_descriptor()

RZ_API void rz_analysis_rtti_msvc_print_class_hierarchy_descriptor	(	RVTableContext *	context,
		ut64	addr,
		int	mode
	)

Definition at line 459 of file rtti_msvc.c.

                                                                                                                 {
    rtti_class_hierarchy_descriptor chd;
    if (!rtti_msvc_read_class_hierarchy_descriptor(context, addr, &chd)) {
        RZ_LOG_ERROR("Failed to parse class hierarchy descriptor at 0x%08" PFMT64x "\n", addr);
        return;
    }
 
    if (mode == 'j') {
        PJ *pj = pj_new();
        if (!pj) {
            return;
        }
        rtti_msvc_print_class_hierarchy_descriptor_json(pj, &chd);
        rz_cons_print(pj_string(pj));
        pj_free(pj);
    } else {
        rtti_msvc_print_class_hierarchy_descriptor(&chd, addr, "");
    }
}

References addr, PFMT64x, pj_free(), pj_new(), pj_string(), rtti_msvc_print_class_hierarchy_descriptor(), rtti_msvc_print_class_hierarchy_descriptor_json(), rtti_msvc_read_class_hierarchy_descriptor(), and RZ_LOG_ERROR.

rz_analysis_rtti_msvc_print_complete_object_locator()

RZ_API void rz_analysis_rtti_msvc_print_complete_object_locator	(	RVTableContext *	context,
		ut64	addr,
		int	mode
	)

Definition at line 417 of file rtti_msvc.c.

                                                                                                              {
    rtti_complete_object_locator col;
    if (!rtti_msvc_read_complete_object_locator(context, addr, &col)) {
        RZ_LOG_ERROR("Failed to parse complete object locator at 0x%08" PFMT64x "\n", addr);
        return;
    }
 
    if (mode == 'j') {
        PJ *pj = pj_new();
        if (!pj) {
            return;
        }
        rtti_msvc_print_complete_object_locator_json(pj, &col);
        rz_cons_print(pj_string(pj));
        pj_free(pj);
    } else {
        rtti_msvc_print_complete_object_locator(&col, addr, "");
    }
}

References addr, PFMT64x, pj_free(), pj_new(), pj_string(), rtti_msvc_print_complete_object_locator(), rtti_msvc_print_complete_object_locator_json(), rtti_msvc_read_complete_object_locator(), and RZ_LOG_ERROR.

rz_analysis_rtti_msvc_print_type_descriptor()

RZ_API void rz_analysis_rtti_msvc_print_type_descriptor	(	RVTableContext *	context,
		ut64	addr,
		int	mode
	)

Definition at line 437 of file rtti_msvc.c.

                                                                                                      {
    rtti_type_descriptor td = { 0 };
    if (!rtti_msvc_read_type_descriptor(context, addr, &td)) {
        RZ_LOG_ERROR("Failed to parse type descriptor at 0x%08" PFMT64x "\n", addr);
        return;
    }
 
    if (mode == 'j') {
        PJ *pj = pj_new();
        if (!pj) {
            return;
        }
        rtti_msvc_print_type_descriptor_json(pj, &td);
        rz_cons_print(pj_string(pj));
        pj_free(pj);
    } else {
        rtti_msvc_print_type_descriptor(&td, addr, "");
    }
 
    rtti_type_descriptor_fini(&td);
}

References addr, PFMT64x, pj_free(), pj_new(), pj_string(), rtti_msvc_print_type_descriptor(), rtti_msvc_print_type_descriptor_json(), rtti_msvc_read_type_descriptor(), rtti_type_descriptor_fini(), and RZ_LOG_ERROR.

rz_analysis_rtti_msvc_recover_all()

RZ_API void rz_analysis_rtti_msvc_recover_all	(	RVTableContext *	vt_context,
		RzList *	vtables
	)

Definition at line 966 of file rtti_msvc.c.

                                                                                             {
    RRTTIMSVCAnalContext context;
    context.vt_context = vt_context;
    rz_pvector_init(&context.vtables, (RzPVectorFree)rz_analysis_vtable_info_free);
 
    rz_pvector_init(&context.complete_object_locators, (RzPVectorFree)recovery_complete_object_locator_free);
    context.addr_col = ht_up_new0();
    rz_pvector_init(&context.type_descriptors, (RzPVectorFree)recovery_type_descriptor_free);
    context.addr_td = ht_up_new0();
 
    context.col_td_classes = ht_up_new(NULL, (HtUPKvFreeFunc)str_value_free, (HtUPCalcSizeV)strlen);
 
    RzListIter *vtableIter;
    RVTableInfo *table;
    rz_list_foreach (vtables, vtableIter, table) {
        ut64 colRefAddr = table->saddr - vt_context->word_size;
        ut64 colAddr;
        if (!vt_context->read_addr(vt_context->analysis, colRefAddr, &colAddr)) {
            continue;
        }
        recovery_analysis_complete_object_locator(&context, colAddr, table);
    }
 
    void **it;
#if USE_TD_RECOVERY
    rz_pvector_foreach (&context.type_descriptors, it) {
        RecoveryTypeDescriptor *td = *it;
        if (!td->valid) {
            continue;
        }
        recovery_apply_type_descriptor(&context, td);
    }
#else
    rz_pvector_foreach (&context.complete_object_locators, it) {
        RecoveryCompleteObjectLocator *col = *it;
        if (!col->valid) {
            continue;
        }
        recovery_apply_complete_object_locator(&context, col);
    }
#endif
 
    rz_pvector_clear(&context.vtables);
    rz_pvector_clear(&context.complete_object_locators);
    ht_up_free(context.addr_col);
    rz_pvector_clear(&context.type_descriptors);
    ht_up_free(context.addr_td);
    ht_up_free(context.col_td_classes);
}

References NULL, recovery_analysis_complete_object_locator(), recovery_apply_complete_object_locator(), recovery_apply_type_descriptor(), recovery_complete_object_locator_free(), recovery_type_descriptor_free(), rz_analysis_vtable_info_free(), rz_pvector_clear(), rz_pvector_foreach, rz_pvector_init(), str_value_free(), ut64(), recovery_complete_object_locator_t::valid, and recovery_type_descriptor_t::valid.

Referenced by rz_analysis_rtti_recover_all().

str_value_free()

void str_value_free

(

HtUPKv *

kv

)

Definition at line 962 of file rtti_msvc.c.

                                {
    free(kv->value);
}

References free().

Referenced by rz_analysis_rtti_msvc_recover_all().

unique_class_name()

static char* unique_class_name ( RzAnalysis *  analysis, const char *  original_name  )

static

Definition at line 791 of file rtti_msvc.c.

                                                                                {
    if (!rz_analysis_class_exists(analysis, original_name)) {
        return strdup(original_name);
    }
 
    char *name = NULL;
    RZ_LOG_DEBUG("Class name '%s' was already taken!\n", original_name);
    int i = 1;
    do {
        free(name);
        name = rz_str_newf("%s.%d", original_name, i++);
        if (!name) {
            return NULL;
        }
    } while (rz_analysis_class_exists(analysis, name));
 
    return name;
}

References free(), i, name, NULL, rz_analysis_class_exists(), RZ_LOG_DEBUG, rz_str_newf(), and strdup().

Referenced by recovery_apply_complete_object_locator().