core_dex.c File Reference

#include <rz_types.h>
#include <rz_lib.h>
#include <rz_demangler.h>
#include <rz_cmd.h>
#include <rz_core.h>
#include <rz_cons.h>
#include <string.h>
#include <rz_analysis.h>
#include "../format/dex/dex.h"

Go to the source code of this file.

Macros
#define	name_args(name)   (cmd_##name##_args)
#define	name_help(name)   (cmd_##name##_help)
#define	name_handler(name)   (rz_cmd_##name##_handler)
#define	static_description_without_args(command, summ)
#define	rz_cmd_desc_argv_modes_new_warn(rcmd, root, cmd, flags)    rz_warn_if_fail(rz_cmd_desc_argv_state_new(rcmd, root, #cmd, flags, name_handler(cmd), &name_help(cmd)))

Functions
static RzBinDex *	core_dex_get_class (RzCore *core)
static char *	decode_access_flags (ut32 access_flags)
static void	dex_print_encoded_field (RzBinDex *dex, ut32 index, DexEncodedField *encoded_field)
static void	dex_print_encoded_method (RzBinDex *dex, ut32 index, DexEncodedMethod *encoded_method)
static void	dex_print_class_def (RzBinDex *dex, ut32 index, DexClassDef *class_def)
RZ_IPI RzCmdStatus	rz_cmd_dexs_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
static void	dex_print_class_def_exports (RzBinDex *dex, ut32 index, DexClassDef *class_def)
RZ_IPI RzCmdStatus	rz_cmd_dexe_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
	static_description_without_args (dexs, "prints the dex structure")
	static_description_without_args (dexe, "prints the dex exported methods")
static bool	rz_cmd_dex_init_handler (RzCore *core)

Variables
static const RzCmdDescHelp	dex_usage
RzCorePlugin	rz_core_plugin_dex
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

name_args

#define name_args

(

name

)

(cmd_##name##_args)

Definition at line 15 of file core_dex.c.

name_handler

#define name_handler

(

name

)

(rz_cmd_##name##_handler)

Definition at line 17 of file core_dex.c.

name_help

#define name_help

(

name

)

(cmd_##name##_help)

Definition at line 16 of file core_dex.c.

rz_cmd_desc_argv_modes_new_warn

#define rz_cmd_desc_argv_modes_new_warn	(		rcmd,
			root,
			cmd,
			flags
	)		rz_warn_if_fail(rz_cmd_desc_argv_state_new(rcmd, root, #cmd, flags, name_handler(cmd), &name_help(cmd)))

Definition at line 26 of file core_dex.c.

static_description_without_args

#define static_description_without_args	(		command,
			summ
	)

Value:

    static const RzCmdDescArg name_args(command)[] = { \
        { 0 }, \
    }; \
    static const RzCmdDescHelp name_help(command) = { \
        .summary = summ, \
        .args = name_args(command), \
    }

Definition at line 18 of file core_dex.c.

Function Documentation

core_dex_get_class()

static RzBinDex* core_dex_get_class ( RzCore *  core )

static

Definition at line 29 of file core_dex.c.

                                                  {
    if (!core) {
        return NULL;
    }
    RzAnalysis *analysis = core->analysis;
    if (!analysis || !analysis->binb.bin) {
        return NULL;
    }
    RzBin *b = analysis->binb.bin;
    if (!b->cur || !b->cur->o) {
        return NULL;
    }
    RzBinPlugin *plugin = b->cur->o->plugin;
    return plugin && !strcmp(plugin->name, "dex") ? (RzBinDex *)b->cur->o->bin_obj : NULL;
}

References rz_core_t::analysis, b, rz_bin_bind_t::bin, rz_analysis_t::binb, rz_bin_plugin_t::name, and NULL.

Referenced by rz_cmd_dexe_handler(), and rz_cmd_dexs_handler().

decode_access_flags()

static char* decode_access_flags ( ut32  access_flags )

static

Definition at line 45 of file core_dex.c.

                                                    {
    char *str = rz_bin_dex_access_flags_readable(access_flags);
    if (!str) {
        return strdup("");
    }
    for (size_t i = 0; i < strlen(str); ++i) {
        str[i] = toupper(str[i]);
    }
    return str;
}

References i, rz_bin_dex_access_flags_readable(), cmd_descs_generate::str, strdup(), and toupper.

Referenced by dex_print_class_def(), dex_print_class_def_exports(), dex_print_encoded_field(), and dex_print_encoded_method().

dex_print_class_def()

static void dex_print_class_def ( RzBinDex *  dex, ut32  index, DexClassDef *  class_def  )

static

Definition at line 100 of file core_dex.c.

                                                                                   {
    ut32 j;
    RzListIter *it;
    DexEncodedField *encoded_field;
    DexEncodedMethod *encoded_method;
    rz_cons_printf("Class #%u header:\n", index);
    rz_cons_printf("offset              : 0x%" PFMT64x "\n", class_def->offset);
    rz_cons_printf("class_idx           : %u\n", class_def->class_idx);
    rz_cons_printf("access_flags        : %u (0x%04x)\n", class_def->access_flags, class_def->access_flags);
    rz_cons_printf("superclass_idx      : %u\n", class_def->superclass_idx);
    rz_cons_printf("interfaces_off      : %u (0x%06x)\n", class_def->interfaces_offset, class_def->interfaces_offset);
    rz_cons_printf("source_file_idx     : %u\n", class_def->source_file_idx);
    rz_cons_printf("annotations_off     : %u (0x%06x)\n", class_def->annotations_offset, class_def->annotations_offset);
    rz_cons_printf("class_data_off      : %u (0x%06x)\n", class_def->class_data_offset, class_def->class_data_offset);
    rz_cons_printf("static_values_offset: %u (0x%06x)\n", class_def->static_values_offset, class_def->static_values_offset);
    j = rz_list_length(class_def->static_fields);
    rz_cons_printf("static_fields_size  : %u\n", j);
    j = rz_list_length(class_def->instance_fields);
    rz_cons_printf("instance_fields_size: %u\n", j);
    j = rz_list_length(class_def->direct_methods);
    rz_cons_printf("direct_methods_size : %u\n", j);
    j = rz_list_length(class_def->virtual_methods);
    rz_cons_printf("virtual_methods_size: %u\n\n", j);
 
    rz_cons_printf("Class #%-13u-\n", index);
    char *tmp = rz_bin_dex_resolve_type_id_by_idx(dex, class_def->class_idx);
    rz_cons_printf("  Class descriptor  : '%s'\n", tmp);
    free(tmp);
    tmp = decode_access_flags(class_def->access_flags);
    rz_cons_printf("  Access flags      : 0x%04x (%s)\n", class_def->access_flags, tmp ? tmp : "");
    free(tmp);
    tmp = rz_bin_dex_resolve_type_id_by_idx(dex, class_def->superclass_idx);
    rz_cons_printf("  Superclass        : '%s'\n", tmp);
    free(tmp);
    rz_cons_printf("  Interfaces        -\n");
    for (j = 0; j < class_def->n_interfaces; ++j) {
        tmp = rz_bin_dex_resolve_type_id_by_idx(dex, class_def->interfaces[j]);
        rz_cons_printf("    #%-15u: '%s'\n", j, tmp);
        free(tmp);
    }
    rz_cons_printf("  Static fields     -\n");
    j = 0;
    rz_list_foreach (class_def->static_fields, it, encoded_field) {
        dex_print_encoded_field(dex, j, encoded_field);
        j++;
    }
    rz_cons_printf("  Instance fields   -\n");
    j = 0;
    rz_list_foreach (class_def->instance_fields, it, encoded_field) {
        dex_print_encoded_field(dex, j, encoded_field);
        j++;
    }
    rz_cons_printf("  Direct methods    -\n");
    j = 0;
    rz_list_foreach (class_def->direct_methods, it, encoded_method) {
        dex_print_encoded_method(dex, j, encoded_method);
        j++;
    }
    rz_cons_printf("  Virtual methods   -\n");
    j = 0;
    rz_list_foreach (class_def->virtual_methods, it, encoded_method) {
        dex_print_encoded_method(dex, j, encoded_method);
        j++;
    }
}

References dex_class_def_t::access_flags, dex_class_def_t::annotations_offset, dex_class_def_t::class_data_offset, dex_class_def_t::class_idx, decode_access_flags(), dex_print_encoded_field(), dex_print_encoded_method(), dex_class_def_t::direct_methods, free(), dex_class_def_t::instance_fields, dex_class_def_t::interfaces, dex_class_def_t::interfaces_offset, dex_class_def_t::n_interfaces, dex_class_def_t::offset, PFMT64x, rz_bin_dex_resolve_type_id_by_idx(), rz_cons_printf(), rz_list_length(), dex_class_def_t::source_file_idx, dex_class_def_t::static_fields, dex_class_def_t::static_values_offset, dex_class_def_t::superclass_idx, autogen_x86imm::tmp, and dex_class_def_t::virtual_methods.

Referenced by rz_cmd_dexs_handler().

dex_print_class_def_exports()

static void dex_print_class_def_exports ( RzBinDex *  dex, ut32  index, DexClassDef *  class_def  )

static

Definition at line 211 of file core_dex.c.

                                                                                           {
    ut32 j;
    RzListIter *it;
    DexEncodedField *encoded_field;
    DexEncodedMethod *encoded_method;
    rz_cons_printf("Class #%-13u-\n", index);
    char *tmp = rz_bin_dex_resolve_type_id_by_idx(dex, class_def->class_idx);
    rz_cons_printf("  Class descriptor  : '%s'\n", tmp);
    free(tmp);
    tmp = decode_access_flags(class_def->access_flags);
    rz_cons_printf("  Access flags      : 0x%04x (%s)\n", class_def->access_flags, tmp ? tmp : "");
    free(tmp);
    tmp = rz_bin_dex_resolve_type_id_by_idx(dex, class_def->superclass_idx);
    rz_cons_printf("  Superclass        : '%s'\n", tmp);
    free(tmp);
    rz_cons_printf("  Interfaces        -\n");
    for (j = 0; j < class_def->n_interfaces; ++j) {
        tmp = rz_bin_dex_resolve_type_id_by_idx(dex, class_def->interfaces[j]);
        rz_cons_printf("    #%-15u: '%s'\n", j, tmp);
        free(tmp);
    }
    rz_cons_printf("  Static fields     -\n");
    j = 0;
    rz_list_foreach (class_def->static_fields, it, encoded_field) {
        if ((encoded_field->access_flags & (ACCESS_FLAG_PUBLIC | ACCESS_FLAG_PROTECTED)) != 0) {
            dex_print_encoded_field(dex, j, encoded_field);
        }
        j++;
    }
    rz_cons_printf("  Instance fields   -\n");
    j = 0;
    rz_list_foreach (class_def->instance_fields, it, encoded_field) {
        if ((encoded_field->access_flags & (ACCESS_FLAG_PUBLIC | ACCESS_FLAG_PROTECTED)) != 0) {
            dex_print_encoded_field(dex, j, encoded_field);
        }
        j++;
    }
    rz_cons_printf("  Direct methods    -\n");
    j = 0;
    rz_list_foreach (class_def->direct_methods, it, encoded_method) {
        if ((encoded_method->access_flags & (ACCESS_FLAG_PUBLIC | ACCESS_FLAG_PROTECTED)) != 0) {
            dex_print_encoded_method(dex, j, encoded_method);
        }
        j++;
    }
    rz_cons_printf("  Virtual methods   -\n");
    j = 0;
    rz_list_foreach (class_def->virtual_methods, it, encoded_method) {
        if ((encoded_method->access_flags & (ACCESS_FLAG_PUBLIC | ACCESS_FLAG_PROTECTED)) != 0) {
            dex_print_encoded_method(dex, j, encoded_method);
        }
        j++;
    }
}

References ACCESS_FLAG_PROTECTED, ACCESS_FLAG_PUBLIC, dex_encoded_field_t::access_flags, dex_encoded_method_t::access_flags, dex_class_def_t::access_flags, dex_class_def_t::class_idx, decode_access_flags(), dex_print_encoded_field(), dex_print_encoded_method(), dex_class_def_t::direct_methods, free(), dex_class_def_t::instance_fields, dex_class_def_t::interfaces, dex_class_def_t::n_interfaces, rz_bin_dex_resolve_type_id_by_idx(), rz_cons_printf(), dex_class_def_t::static_fields, dex_class_def_t::superclass_idx, autogen_x86imm::tmp, and dex_class_def_t::virtual_methods.

Referenced by rz_cmd_dexe_handler().

dex_print_encoded_field()

static void dex_print_encoded_field ( RzBinDex *  dex, ut32  index, DexEncodedField *  encoded_field  )

static

Definition at line 56 of file core_dex.c.

                                                                                               {
    if (dex->field_ids_size < encoded_field->field_idx) {
        rz_cons_printf("    #%-14u: unknown id %" PFMT64u "\n", index, encoded_field->field_idx);
        return;
    }
    DexFieldId *field_id = (DexFieldId *)rz_pvector_at(dex->field_ids, encoded_field->field_idx);
 
    char *tmp = rz_bin_dex_resolve_type_id_by_idx(dex, field_id->class_idx);
    rz_cons_printf("    #%-14u: (in %s)\n", index, tmp);
    free(tmp);
    tmp = rz_bin_dex_resolve_string_by_idx(dex, field_id->name_idx);
    rz_cons_printf("      name          : '%s'\n", tmp);
    free(tmp);
    tmp = rz_bin_dex_resolve_type_id_by_idx(dex, field_id->type_idx);
    rz_cons_printf("      type          : '%s'\n", tmp);
    free(tmp);
    tmp = decode_access_flags(encoded_field->access_flags);
    rz_cons_printf("      access        : 0x%04" PFMT64x " (%s)\n", encoded_field->access_flags, tmp ? tmp : "");
    free(tmp);
}

References dex_encoded_field_t::access_flags, decode_access_flags(), field_id, dex_t::field_ids, dex_t::field_ids_size, dex_encoded_field_t::field_idx, free(), PFMT64u, PFMT64x, rz_bin_dex_resolve_string_by_idx(), rz_bin_dex_resolve_type_id_by_idx(), rz_cons_printf(), rz_pvector_at(), and autogen_x86imm::tmp.

Referenced by dex_print_class_def(), and dex_print_class_def_exports().

dex_print_encoded_method()

static void dex_print_encoded_method ( RzBinDex *  dex, ut32  index, DexEncodedMethod *  encoded_method  )

static

Definition at line 77 of file core_dex.c.

                                                                                                  {
    if (dex->method_ids_size < encoded_method->method_idx) {
        rz_cons_printf("    #%-14u: unknown id %" PFMT64u "\n", index, encoded_method->method_idx);
        return;
    }
    DexMethodId *method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
 
    char *tmp = rz_bin_dex_resolve_type_id_by_idx(dex, method_id->class_idx);
    rz_cons_printf("    #%-14u: (in %s)\n", index, tmp);
    free(tmp);
    tmp = rz_bin_dex_resolve_string_by_idx(dex, method_id->name_idx);
    rz_cons_printf("      name          : '%s'\n", tmp);
    free(tmp);
    tmp = rz_bin_dex_resolve_proto_by_idx(dex, method_id->proto_idx);
    rz_cons_printf("      type          : '%s'\n", tmp);
    free(tmp);
    tmp = decode_access_flags(encoded_method->access_flags);
    rz_cons_printf("      access        : 0x%04" PFMT64x " (%s)\n", encoded_method->access_flags, tmp ? tmp : "");
    free(tmp);
    rz_cons_printf("      method_idx    : %" PFMT64u "\n", encoded_method->method_idx);
    rz_cons_printf("      code          : (%s)\n", encoded_method->code_offset >= RZ_DEX_RELOC_ADDRESS ? "none" : "available");
}

References dex_encoded_method_t::access_flags, dex_method_id_t::class_idx, dex_encoded_method_t::code_offset, decode_access_flags(), free(), dex_t::method_ids, dex_t::method_ids_size, dex_encoded_method_t::method_idx, dex_method_id_t::name_idx, PFMT64u, PFMT64x, dex_method_id_t::proto_idx, rz_bin_dex_resolve_proto_by_idx(), rz_bin_dex_resolve_string_by_idx(), rz_bin_dex_resolve_type_id_by_idx(), rz_cons_printf(), RZ_DEX_RELOC_ADDRESS, rz_pvector_at(), and autogen_x86imm::tmp.

Referenced by dex_print_class_def(), and dex_print_class_def_exports().

rz_cmd_dex_init_handler()

static bool rz_cmd_dex_init_handler ( RzCore *  core )

static

Definition at line 293 of file core_dex.c.

                                                  {
    RzCmd *rcmd = core->rcmd;
    RzCmdDesc *root_cd = rz_cmd_get_root(rcmd);
    if (!root_cd) {
        return false;
    }
 
    RzCmdDesc *dex = rz_cmd_desc_group_new(rcmd, root_cd, "dex", NULL, NULL, &dex_usage);
    if (!dex) {
        rz_warn_if_reached();
        return false;
    }
 
    rz_cmd_desc_argv_modes_new_warn(rcmd, dex, dexs, RZ_OUTPUT_MODE_STANDARD);
    rz_cmd_desc_argv_modes_new_warn(rcmd, dex, dexe, RZ_OUTPUT_MODE_STANDARD);
 
    return true;
}

References dex_usage, NULL, rz_core_t::rcmd, cmd_descs_generate::root_cd, rz_cmd_desc_argv_modes_new_warn, rz_cmd_desc_group_new(), rz_cmd_get_root(), RZ_OUTPUT_MODE_STANDARD, and rz_warn_if_reached.

rz_cmd_dexe_handler()

RZ_IPI RzCmdStatus rz_cmd_dexe_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 266 of file core_dex.c.

                                                                                                           {
    if (argc != 1) {
        return RZ_CMD_STATUS_WRONG_ARGS;
    }
 
    RzBinDex *dex = core_dex_get_class(core);
    if (!dex) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    for (ut32 i = 0; i < rz_pvector_len(dex->class_defs); ++i) {
        DexClassDef *class_def = rz_pvector_at(dex->class_defs, i);
        if ((class_def->access_flags & ACCESS_FLAG_PUBLIC) != 0) {
            dex_print_class_def_exports(dex, i, class_def);
        }
    }
 
    return RZ_CMD_STATUS_OK;
}

References ACCESS_FLAG_PUBLIC, dex_class_def_t::access_flags, dex_t::class_defs, core_dex_get_class(), dex_print_class_def_exports(), i, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_pvector_at(), and rz_pvector_len().

rz_cmd_dexs_handler()

RZ_IPI RzCmdStatus rz_cmd_dexs_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 166 of file core_dex.c.

                                                                                                           {
    if (argc != 1) {
        return RZ_CMD_STATUS_WRONG_ARGS;
    }
 
    RzBinDex *dex = core_dex_get_class(core);
    if (!dex) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    // mimic dexdump output
    char *tmp = NULL;
    rz_cons_printf("DEX file header:\n");
    tmp = rz_bin_dex_version(dex);
    rz_cons_printf("version             : %s\n", tmp);
    free(tmp);
    rz_cons_printf("checksum            : %08x\n", dex->checksum);
    rz_cons_printf("signature           : %02x%02x...%02x%02x\n", dex->signature[0], dex->signature[1], dex->signature[18], dex->signature[19]);
    rz_cons_printf("file_size           : %u\n", dex->file_size);
    rz_cons_printf("header_size         : %u\n", dex->header_size);
    rz_cons_printf("link_size           : %u\n", dex->link_size);
    rz_cons_printf("link_off            : %u (0x%06x)\n", dex->link_offset, dex->link_offset);
    rz_cons_printf("string_ids_size     : %u\n", dex->string_ids_size);
    rz_cons_printf("string_ids_off      : %u (0x%06x)\n", dex->string_ids_offset, dex->string_ids_offset);
    rz_cons_printf("type_ids_size       : %u\n", dex->type_ids_size);
    rz_cons_printf("type_ids_off        : %u (0x%06x)\n", dex->type_ids_offset, dex->type_ids_offset);
    rz_cons_printf("proto_ids_size      : %u\n", dex->proto_ids_size);
    rz_cons_printf("proto_ids_off       : %u (0x%06x)\n", dex->proto_ids_offset, dex->proto_ids_offset);
    rz_cons_printf("field_ids_size      : %u\n", dex->field_ids_size);
    rz_cons_printf("field_ids_off       : %u (0x%06x)\n", dex->field_ids_offset, dex->field_ids_offset);
    rz_cons_printf("method_ids_size     : %u\n", dex->method_ids_size);
    rz_cons_printf("method_ids_off      : %u (0x%06x)\n", dex->method_ids_offset, dex->method_ids_offset);
    rz_cons_printf("class_defs_size     : %u\n", dex->class_defs_size);
    rz_cons_printf("class_defs_off      : %u (0x%06x)\n", dex->class_defs_offset, dex->class_defs_offset);
    rz_cons_printf("data_size           : %u\n", dex->data_size);
    rz_cons_printf("data_off            : %u (0x%06x)\n\n", dex->data_offset, dex->data_offset);
 
    for (ut32 i = 0; i < rz_pvector_len(dex->class_defs); ++i) {
        DexClassDef *class_def = rz_pvector_at(dex->class_defs, i);
        dex_print_class_def(dex, i, class_def);
    }
 
    return RZ_CMD_STATUS_OK;
}

References dex_t::checksum, dex_t::class_defs, dex_t::class_defs_offset, dex_t::class_defs_size, core_dex_get_class(), dex_t::data_offset, dex_t::data_size, dex_print_class_def(), dex_t::field_ids_offset, dex_t::field_ids_size, dex_t::file_size, free(), dex_t::header_size, i, dex_t::link_offset, dex_t::link_size, dex_t::method_ids_offset, dex_t::method_ids_size, NULL, dex_t::proto_ids_offset, dex_t::proto_ids_size, rz_bin_dex_version(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_cons_printf(), rz_pvector_at(), rz_pvector_len(), dex_t::signature, dex_t::string_ids_offset, dex_t::string_ids_size, autogen_x86imm::tmp, dex_t::type_ids_offset, and dex_t::type_ids_size.

static_description_without_args() [1/2]

static_description_without_args	(	dexe	,
		"prints the dex exported methods"
	)

static_description_without_args() [2/2]

static_description_without_args	(	dexs	,
		"prints the dex structure"
	)

Variable Documentation

dex_usage

const RzCmdDescHelp dex_usage

static

Initial value:

= {
    .summary = "Core plugin to visualize dex class information",
}

Definition at line 286 of file core_dex.c.

Referenced by rz_cmd_dex_init_handler().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_CORE,
    .data = &rz_core_plugin_dex,
    .version = RZ_VERSION
}

Definition at line 322 of file core_dex.c.

rz_core_plugin_dex

RzCorePlugin rz_core_plugin_dex

Initial value:

= {
    .name = "dex",
    .desc = "Suite of dex commands, type `dex` for more info",
    .license = "LGPL-3.0-only",
    .author = "deroad",
    .version = "1.0",
    .init = rz_cmd_dex_init_handler,
}

Definition at line 312 of file core_dex.c.