dex.h File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_bin.h>

Go to the source code of this file.

Classes
struct	dex_map_item_t
struct	dex_string_t
struct	dex_proto_id_t
struct	dex_field_id_t
struct	dex_method_id_t
struct	dex_encoded_field_t
struct	dex_encoded_method_t
struct	dex_class_def_t
struct	dex_t

Macros
#define	RZ_DEX_RELOC_TARGETS   "reloc-targets"
#define	RZ_DEX_VIRT_ADDRESS   0x0100000000
#define	RZ_DEX_RELOC_ADDRESS   0x8000000000
#define	DEX_MAP_ITEM_SIZE   (12)
#define	DEX_TYPE_ID_SIZE   (sizeof(DexTypeId))
#define	DEX_PROTO_ID_SIZE   (0xC)
#define	DEX_FIELD_ID_SIZE   (8)
#define	DEX_METHOD_ID_SIZE   (8)
#define	DEX_CLASS_DEF_SIZE   (0x20)

Typedefs
typedef struct dex_map_item_t	DexMapItem
typedef struct dex_string_t	DexString
typedef ut32	DexTypeId
typedef struct dex_proto_id_t	DexProtoId
typedef struct dex_field_id_t	DexFieldId
typedef struct dex_method_id_t	DexMethodId
typedef struct dex_encoded_field_t	DexEncodedField
typedef struct dex_encoded_method_t	DexEncodedMethod
typedef struct dex_class_def_t	DexClassDef
typedef struct dex_t	RzBinDex

Enumerations
enum	DexMapItemType {   DEX_MAP_ITEM_TYPE_HEADER_ITEM = 0x0000 , DEX_MAP_ITEM_TYPE_STRING_ID_ITEM = 0x0001 , DEX_MAP_ITEM_TYPE_TYPE_ID_ITEM = 0x0002 , DEX_MAP_ITEM_TYPE_PROTO_ID_ITEM = 0x0003 ,   DEX_MAP_ITEM_TYPE_FIELD_ID_ITEM = 0x0004 , DEX_MAP_ITEM_TYPE_METHOD_ID_ITEM = 0x0005 , DEX_MAP_ITEM_TYPE_CLASS_DEF_ITEM = 0x0006 , DEX_MAP_ITEM_TYPE_CALL_SITE_ID_ITEM = 0x0007 ,   DEX_MAP_ITEM_TYPE_METHOD_HANDLE_ITEM = 0x0008 , DEX_MAP_ITEM_TYPE_MAP_LIST = 0x1000 , DEX_MAP_ITEM_TYPE_TYPE_LIST = 0x1001 , DEX_MAP_ITEM_TYPE_ANNOTATION_SET_REF_LIST = 0x1002 ,   DEX_MAP_ITEM_TYPE_ANNOTATION_SET_ITEM = 0x1003 , DEX_MAP_ITEM_TYPE_CLASS_DATA_ITEM = 0x2000 , DEX_MAP_ITEM_TYPE_CODE_ITEM = 0x2001 , DEX_MAP_ITEM_TYPE_STRING_DATA_ITEM = 0x2002 ,   DEX_MAP_ITEM_TYPE_DEBUG_INFO_ITEM = 0x2003 , DEX_MAP_ITEM_TYPE_ANNOTATION_ITEM = 0x2004 , DEX_MAP_ITEM_TYPE_ENCODED_ARRAY_ITEM = 0x2005 , DEX_MAP_ITEM_TYPE_ANNOTATIONS_DIRECTORY_ITEM = 0x2006 ,   DEX_MAP_ITEM_TYPE_HIDDENAPI_CLASS_DATA_ITEM = 0xF000 }
enum	DexAccessFlag {   ACCESS_FLAG_PUBLIC = 0x00001 , ACCESS_FLAG_PRIVATE = 0x00002 , ACCESS_FLAG_PROTECTED = 0x00004 , ACCESS_FLAG_STATIC = 0x00008 ,   ACCESS_FLAG_FINAL = 0x00010 , ACCESS_FLAG_SYNCHRONIZED = 0x00020 , ACCESS_FLAG_BRIDGE = 0x00040 , ACCESS_FLAG_VARARGS = 0x00080 ,   ACCESS_FLAG_NATIVE = 0x00100 , ACCESS_FLAG_INTERFACE = 0x00200 , ACCESS_FLAG_ABSTRACT = 0x00400 , ACCESS_FLAG_STRICT = 0x00800 ,   ACCESS_FLAG_SYNTHETIC = 0x01000 , ACCESS_FLAG_ANNOTATION = 0x02000 , ACCESS_FLAG_ENUM = 0x04000 , ACCESS_FLAG_MODULE = 0x08000 ,   ACCESS_FLAG_CONSTRUCTOR = 0x10000 , ACCESS_FLAG_DECLARED_SYNCHRONIZED = 0x20000 }

Functions
RZ_API RZ_OWN RzBinDex *	rz_bin_dex_new (RZ_NONNULL RzBuffer *buf, ut64 base, RZ_NONNULL Sdb *kv)
	Parses the dex file and returns a RzBinDex struct. More...
RZ_API void	rz_bin_dex_free (RZ_NULLABLE RzBinDex *dex)
	Frees a RzBinDex struct. More...
RZ_API RZ_OWN char *	rz_bin_dex_version (RZ_NONNULL RzBinDex *dex)
	Returns the dex version (string format) More...
RZ_API ut64	rz_bin_dex_debug_info (RZ_NONNULL RzBinDex *dex)
	Returns the dex debug info RzBin values. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_strings (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinString*> containing the dex strings. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_classes (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinClass*> containing the dex classes. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_fields (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinField*> containing the dex fields. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_sections (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinSection*> containing the dex sections. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_symbols (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinSymbol*> containing the dex symbols. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_imports (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinImport*> containing the dex imports. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_libraries (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<char*> containing the dex libraries. More...
RZ_API RZ_OWN RzBinAddr *	rz_bin_dex_resolve_symbol (RZ_NONNULL RzBinDex *dex, RzBinSpecialSymbol resolve)
	Returns a RzBinAddr pointer containing the resolved RzBinSpecialSymbol. More...
RZ_API RZ_OWN RzList *	rz_bin_dex_entrypoints (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinAddr*> containing the dex entripoints. More...
RZ_API RZ_BORROW RzBuffer *	rz_bin_dex_relocations (RZ_NONNULL RzBinDex *dex)
RZ_API RZ_OWN char *	rz_bin_dex_resolve_method_by_idx (RZ_NONNULL RzBinDex *dex, ut32 method_idx)
	Returns the resolved string linked to the given method id. More...
RZ_API RZ_OWN char *	rz_bin_dex_resolve_field_by_idx (RZ_NONNULL RzBinDex *dex, ut32 field_idx)
	Returns the resolved string linked to the given field id. More...
RZ_API RZ_OWN char *	rz_bin_dex_resolve_class_by_idx (RZ_NONNULL RzBinDex *dex, ut32 class_idx)
	Returns the resolved string linked to the given class id. More...
RZ_API RZ_OWN char *	rz_bin_dex_resolve_string_by_idx (RZ_NONNULL RzBinDex *dex, ut32 string_idx)
	Returns the resolved string linked to the given string id. More...
RZ_API RZ_OWN char *	rz_bin_dex_resolve_proto_by_idx (RZ_NONNULL RzBinDex *dex, ut32 proto_idx)
	Returns the resolved string linked to the given prototype id. More...
RZ_API RZ_OWN char *	rz_bin_dex_resolve_type_id_by_idx (RZ_NONNULL RzBinDex *dex, ut32 type_idx)
	Returns the resolved string linked to the given type id. More...
RZ_API RZ_OWN char *	rz_bin_dex_access_flags_readable (ut32 access_flags)
RZ_API ut64	rz_bin_dex_resolve_string_offset_by_idx (RZ_NONNULL RzBinDex *dex, ut32 string_idx)
	Returns the resolved offset linked to the given string id. More...
RZ_API ut64	rz_bin_dex_resolve_type_id_offset_by_idx (RZ_NONNULL RzBinDex *dex, ut32 type_idx)
	Returns the resolved offset linked to the given type id. More...
RZ_API ut64	rz_bin_dex_resolve_method_offset_by_idx (RZ_NONNULL RzBinDex *dex, ut32 method_idx)
	Returns the resolved offset linked to the given method id. More...
RZ_API void	rz_bin_dex_checksum (RZ_NONNULL RzBinDex *dex, RZ_NONNULL RzBinHash *hash)
	Sets the RzBinHash dex checksum (adler32) More...
RZ_API void	rz_bin_dex_sha1 (RZ_NONNULL RzBinDex *dex, RZ_NONNULL RzBinHash *hash)
	Sets the RzBinHash dex digest (sha1) More...

Macro Definition Documentation

DEX_CLASS_DEF_SIZE

#define DEX_CLASS_DEF_SIZE   (0x20)

Definition at line 158 of file dex.h.

DEX_FIELD_ID_SIZE

#define DEX_FIELD_ID_SIZE   (8)

Definition at line 95 of file dex.h.

DEX_MAP_ITEM_SIZE

#define DEX_MAP_ITEM_SIZE   (12)

Definition at line 68 of file dex.h.

DEX_METHOD_ID_SIZE

#define DEX_METHOD_ID_SIZE   (8)

Definition at line 106 of file dex.h.

DEX_PROTO_ID_SIZE

#define DEX_PROTO_ID_SIZE   (0xC)

Definition at line 87 of file dex.h.

DEX_TYPE_ID_SIZE

#define DEX_TYPE_ID_SIZE   (sizeof(DexTypeId))

Definition at line 78 of file dex.h.

RZ_DEX_RELOC_ADDRESS

#define RZ_DEX_RELOC_ADDRESS   0x8000000000

Definition at line 14 of file dex.h.

RZ_DEX_RELOC_TARGETS

#define RZ_DEX_RELOC_TARGETS   "reloc-targets"

Definition at line 12 of file dex.h.

RZ_DEX_VIRT_ADDRESS

#define RZ_DEX_VIRT_ADDRESS   0x0100000000

Definition at line 13 of file dex.h.

Typedef Documentation

DexClassDef

typedef struct dex_class_def_t DexClassDef

DexEncodedField

typedef struct dex_encoded_field_t DexEncodedField

DexEncodedMethod

typedef struct dex_encoded_method_t DexEncodedMethod

DexFieldId

typedef struct dex_field_id_t DexFieldId

DexMapItem

typedef struct dex_map_item_t DexMapItem

DexMethodId

typedef struct dex_method_id_t DexMethodId

DexProtoId

typedef struct dex_proto_id_t DexProtoId

DexString

typedef struct dex_string_t DexString

DexTypeId

typedef ut32 DexTypeId

Definition at line 77 of file dex.h.

RzBinDex

typedef struct dex_t RzBinDex

Enumeration Type Documentation

DexAccessFlag

enum DexAccessFlag

Enumerator
ACCESS_FLAG_PUBLIC
ACCESS_FLAG_PRIVATE
ACCESS_FLAG_PROTECTED
ACCESS_FLAG_STATIC
ACCESS_FLAG_FINAL
ACCESS_FLAG_SYNCHRONIZED
ACCESS_FLAG_BRIDGE
ACCESS_FLAG_VARARGS
ACCESS_FLAG_NATIVE
ACCESS_FLAG_INTERFACE
ACCESS_FLAG_ABSTRACT
ACCESS_FLAG_STRICT
ACCESS_FLAG_SYNTHETIC
ACCESS_FLAG_ANNOTATION
ACCESS_FLAG_ENUM
ACCESS_FLAG_MODULE
ACCESS_FLAG_CONSTRUCTOR
ACCESS_FLAG_DECLARED_SYNCHRONIZED

Definition at line 40 of file dex.h.

             {
    ACCESS_FLAG_PUBLIC /*               */ = 0x00001,
    ACCESS_FLAG_PRIVATE /*              */ = 0x00002,
    ACCESS_FLAG_PROTECTED /*            */ = 0x00004,
    ACCESS_FLAG_STATIC /*               */ = 0x00008,
    ACCESS_FLAG_FINAL /*                */ = 0x00010,
    ACCESS_FLAG_SYNCHRONIZED /*         */ = 0x00020,
    ACCESS_FLAG_BRIDGE /*               */ = 0x00040,
    ACCESS_FLAG_VARARGS /*              */ = 0x00080,
    ACCESS_FLAG_NATIVE /*               */ = 0x00100,
    ACCESS_FLAG_INTERFACE /*            */ = 0x00200,
    ACCESS_FLAG_ABSTRACT /*             */ = 0x00400,
    ACCESS_FLAG_STRICT /*               */ = 0x00800,
    ACCESS_FLAG_SYNTHETIC /*            */ = 0x01000,
    ACCESS_FLAG_ANNOTATION /*           */ = 0x02000,
    ACCESS_FLAG_ENUM /*                 */ = 0x04000,
    ACCESS_FLAG_MODULE /*               */ = 0x08000,
    ACCESS_FLAG_CONSTRUCTOR /*          */ = 0x10000,
    ACCESS_FLAG_DECLARED_SYNCHRONIZED  = 0x20000
} DexAccessFlag;

DexMapItemType

enum DexMapItemType

Enumerator
DEX_MAP_ITEM_TYPE_HEADER_ITEM
DEX_MAP_ITEM_TYPE_STRING_ID_ITEM
DEX_MAP_ITEM_TYPE_TYPE_ID_ITEM
DEX_MAP_ITEM_TYPE_PROTO_ID_ITEM
DEX_MAP_ITEM_TYPE_FIELD_ID_ITEM
DEX_MAP_ITEM_TYPE_METHOD_ID_ITEM
DEX_MAP_ITEM_TYPE_CLASS_DEF_ITEM
DEX_MAP_ITEM_TYPE_CALL_SITE_ID_ITEM
DEX_MAP_ITEM_TYPE_METHOD_HANDLE_ITEM
DEX_MAP_ITEM_TYPE_MAP_LIST
DEX_MAP_ITEM_TYPE_TYPE_LIST
DEX_MAP_ITEM_TYPE_ANNOTATION_SET_REF_LIST
DEX_MAP_ITEM_TYPE_ANNOTATION_SET_ITEM
DEX_MAP_ITEM_TYPE_CLASS_DATA_ITEM
DEX_MAP_ITEM_TYPE_CODE_ITEM
DEX_MAP_ITEM_TYPE_STRING_DATA_ITEM
DEX_MAP_ITEM_TYPE_DEBUG_INFO_ITEM
DEX_MAP_ITEM_TYPE_ANNOTATION_ITEM
DEX_MAP_ITEM_TYPE_ENCODED_ARRAY_ITEM
DEX_MAP_ITEM_TYPE_ANNOTATIONS_DIRECTORY_ITEM
DEX_MAP_ITEM_TYPE_HIDDENAPI_CLASS_DATA_ITEM

Definition at line 16 of file dex.h.

             {
    DEX_MAP_ITEM_TYPE_HEADER_ITEM = 0x0000,
    DEX_MAP_ITEM_TYPE_STRING_ID_ITEM = 0x0001,
    DEX_MAP_ITEM_TYPE_TYPE_ID_ITEM = 0x0002,
    DEX_MAP_ITEM_TYPE_PROTO_ID_ITEM = 0x0003,
    DEX_MAP_ITEM_TYPE_FIELD_ID_ITEM = 0x0004,
    DEX_MAP_ITEM_TYPE_METHOD_ID_ITEM = 0x0005,
    DEX_MAP_ITEM_TYPE_CLASS_DEF_ITEM = 0x0006,
    DEX_MAP_ITEM_TYPE_CALL_SITE_ID_ITEM = 0x0007,
    DEX_MAP_ITEM_TYPE_METHOD_HANDLE_ITEM = 0x0008,
    DEX_MAP_ITEM_TYPE_MAP_LIST = 0x1000,
    DEX_MAP_ITEM_TYPE_TYPE_LIST = 0x1001,
    DEX_MAP_ITEM_TYPE_ANNOTATION_SET_REF_LIST = 0x1002,
    DEX_MAP_ITEM_TYPE_ANNOTATION_SET_ITEM = 0x1003,
    DEX_MAP_ITEM_TYPE_CLASS_DATA_ITEM = 0x2000,
    DEX_MAP_ITEM_TYPE_CODE_ITEM = 0x2001,
    DEX_MAP_ITEM_TYPE_STRING_DATA_ITEM = 0x2002,
    DEX_MAP_ITEM_TYPE_DEBUG_INFO_ITEM = 0x2003,
    DEX_MAP_ITEM_TYPE_ANNOTATION_ITEM = 0x2004,
    DEX_MAP_ITEM_TYPE_ENCODED_ARRAY_ITEM = 0x2005,
    DEX_MAP_ITEM_TYPE_ANNOTATIONS_DIRECTORY_ITEM = 0x2006,
    DEX_MAP_ITEM_TYPE_HIDDENAPI_CLASS_DATA_ITEM = 0xF000,
} DexMapItemType;

Function Documentation

rz_bin_dex_access_flags_readable()

RZ_API RZ_OWN char* rz_bin_dex_access_flags_readable

(

ut32

access_flags

)

Definition at line 710 of file dex.c.

                                                                        {
    RzStrBuf *sb = NULL;
    for (ut32 i = 0; i < CLASS_ACCESS_FLAGS_SIZE; ++i) {
        const DexAccessFlagsReadable *afr = &access_flags_list[i];
        if (afr->flag == ACCESS_FLAG_VARARGS) {
            continue;
        }
        if (access_flags & afr->flag) {
            if (!sb) {
                sb = rz_strbuf_new(afr->readable);
                if (!sb) {
                    return NULL;
                }
            } else {
                rz_strbuf_appendf(sb, " %s", afr->readable);
            }
        }
    }
 
    return sb ? rz_strbuf_drain(sb) : NULL;
}

References ACCESS_FLAG_VARARGS, access_flags_list, CLASS_ACCESS_FLAGS_SIZE, dex_access_flags_readable_t::flag, i, NULL, dex_access_flags_readable_t::readable, rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), and sb.

Referenced by decode_access_flags(), dex_field_to_bin_field(), dex_field_to_symbol(), dex_method_to_symbol(), and rz_bin_dex_classes().

rz_bin_dex_checksum()

RZ_API void rz_bin_dex_checksum	(	RZ_NONNULL RzBinDex *	dex,
		RZ_NONNULL RzBinHash *	hash
	)

Sets the RzBinHash dex checksum (adler32)

Definition at line 1990 of file dex.c.

                                                                                      {
    rz_return_if_fail(dex && hash);
    hash->type = "adler32";
    hash->len = sizeof(dex->checksum);
    hash->addr = dex->checksum_offset;
    hash->from = dex->checksum_offset + sizeof(dex->checksum);
    hash->to = dex->file_size - hash->from;
    rz_write_le32(hash->buf, dex->checksum);
}

References rz_return_if_fail, and rz_write_le32().

Referenced by info().

rz_bin_dex_classes()

RZ_API RZ_OWN RzList* rz_bin_dex_classes

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinClass*> containing the dex classes.

Definition at line 1131 of file dex.c.

                                                                     {
    rz_return_val_if_fail(dex, NULL);
 
    DexClassDef *class_def;
    RzBinClass *bclass = NULL;
    RzList *classes = NULL;
    void **it;
 
    ut32 n_methods = rz_pvector_len(dex->method_ids);
    ut32 n_fields = rz_pvector_len(dex->field_ids);
 
    ut8 *inserted_methods = RZ_NEWS0(ut8, n_methods);
    ut8 *inserted_fields = RZ_NEWS0(ut8, n_fields);
    if ((n_methods > 0 && !inserted_methods) || (n_fields > 0 && !inserted_fields)) {
        free(inserted_fields);
        free(inserted_methods);
        return NULL;
    }
 
    classes = rz_list_newf((RzListFree)free_rz_bin_class);
    if (!classes) {
        free(inserted_fields);
        free(inserted_methods);
        return NULL;
    }
 
    rz_pvector_foreach (dex->class_defs, it) {
        class_def = (DexClassDef *)*it;
        bclass = RZ_NEW0(RzBinClass);
        if (!bclass) {
            break;
        }
 
        bclass->name = dex_resolve_type_id(dex, class_def->class_idx);
        bclass->super = dex_resolve_type_id(dex, class_def->superclass_idx);
        bclass->visibility = class_def->access_flags;
        bclass->visibility_str = rz_bin_dex_access_flags_readable(class_def->access_flags);
        bclass->index = class_def->class_idx;
        bclass->addr = class_def->offset;
        bclass->methods = dex_resolve_methods_in_class(dex, class_def, inserted_methods);
        bclass->fields = dex_resolve_fields_in_class(dex, class_def, inserted_fields);
 
        if (!rz_list_append(classes, bclass)) {
            free_rz_bin_class(bclass);
            break;
        }
    }
    free(inserted_fields);
    free(inserted_methods);
 
    return classes;
}

References dex_class_def_t::access_flags, rz_bin_class_t::addr, dex_class_def_t::class_idx, classes(), dex_resolve_fields_in_class(), dex_resolve_methods_in_class(), dex_resolve_type_id(), rz_bin_class_t::fields, free(), free_rz_bin_class(), rz_bin_class_t::index, rz_bin_class_t::methods, rz_bin_class_t::name, NULL, dex_class_def_t::offset, rz_bin_dex_access_flags_readable(), rz_list_append(), rz_list_newf(), RZ_NEW0, RZ_NEWS0, rz_pvector_foreach, rz_pvector_len(), rz_return_val_if_fail, rz_bin_class_t::super, dex_class_def_t::superclass_idx, rz_bin_class_t::visibility, and rz_bin_class_t::visibility_str.

Referenced by classes().

rz_bin_dex_debug_info()

RZ_API ut64 rz_bin_dex_debug_info

(

RZ_NONNULL RzBinDex *

dex

)

Returns the dex debug info RzBin values.

Definition at line 2041 of file dex.c.

                                                            {
    rz_return_val_if_fail(dex, 0);
    // TODO
    return 0;
}

References rz_return_val_if_fail.

Referenced by info().

rz_bin_dex_entrypoints()

RZ_API RZ_OWN RzList* rz_bin_dex_entrypoints

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinAddr*> containing the dex entripoints.

Definition at line 1792 of file dex.c.

                                                                         {
    rz_return_val_if_fail(dex, NULL);
 
    DexClassDef *class_def;
    RzList *list = NULL;
    RzList *entrypoints = NULL;
    void **it;
 
    entrypoints = rz_list_newf((RzListFree)free);
    if (!entrypoints) {
        return NULL;
    }
 
    rz_pvector_foreach (dex->class_defs, it) {
        class_def = (DexClassDef *)*it;
        list = dex_resolve_entrypoints_in_class(dex, class_def);
        if (list) {
            rz_list_join(entrypoints, list);
            rz_list_free(list);
        }
    }
 
    return entrypoints;
}

References dex_resolve_entrypoints_in_class(), entrypoints(), free(), list(), NULL, rz_list_free(), rz_list_join(), rz_list_newf(), rz_pvector_foreach, and rz_return_val_if_fail.

Referenced by entrypoints().

rz_bin_dex_fields()

RZ_API RZ_OWN RzList* rz_bin_dex_fields

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinField*> containing the dex fields.

Definition at line 1232 of file dex.c.

                                                                    {
    rz_return_val_if_fail(dex, NULL);
 
    DexClassDef *class_def;
    RzList *fields = NULL;
    void **it;
    ut32 n_fields = rz_pvector_len(dex->field_ids);
    ut8 *inserted = RZ_NEWS0(ut8, n_fields);
    if (n_fields > 0 && !inserted) {
        free(inserted);
        return NULL;
    }
 
    fields = rz_list_newf((RzListFree)rz_bin_field_free);
    if (!fields) {
        free(inserted);
        return NULL;
    }
 
    rz_pvector_foreach (dex->class_defs, it) {
        class_def = (DexClassDef *)*it;
        RzList *class_fields = dex_resolve_fields_in_class(dex, class_def, inserted);
        if (class_fields) {
            rz_list_join(fields, class_fields);
            rz_list_free(class_fields);
        }
    }
    free(inserted);
 
    return fields;
}

References dex_resolve_fields_in_class(), fields, free(), NULL, rz_bin_field_free(), rz_list_free(), rz_list_join(), rz_list_newf(), RZ_NEWS0, rz_pvector_foreach, rz_pvector_len(), and rz_return_val_if_fail.

Referenced by fields().

rz_bin_dex_free()

RZ_API void rz_bin_dex_free

(

RZ_NULLABLE RzBinDex *

dex

)

Frees a RzBinDex struct.

Definition at line 649 of file dex.c.

                                                       {
    if (!dex) {
        return;
    }
 
    rz_pvector_free(dex->strings);
    rz_pvector_free(dex->proto_ids);
    rz_pvector_free(dex->field_ids);
    rz_pvector_free(dex->method_ids);
    rz_pvector_free(dex->class_defs);
    rz_buf_free(dex->relocs_buffer);
 
    free(dex->types);
    free(dex->relocs_code);
    free(dex);
}

References free(), rz_buf_free(), and rz_pvector_free().

Referenced by destroy(), dex_parse(), and rz_bin_dex_new().

rz_bin_dex_imports()

RZ_API RZ_OWN RzList* rz_bin_dex_imports

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinImport*> containing the dex imports.

Definition at line 1379 of file dex.c.

                                                                     {
    rz_return_val_if_fail(dex, NULL);
 
    DexFieldId *field_id;
    DexMethodId *method_id;
    DexClassDef *class_def;
    RzList *imports = NULL;
    ut32 *class_ids = NULL;
    void **vit;
 
    ut32 n_classes = rz_pvector_len(dex->class_defs);
    if (n_classes < 1) {
        return rz_list_newf((RzListFree)rz_bin_import_free);
    }
 
    class_ids = RZ_NEWS0(ut32, n_classes);
    if (!class_ids) {
        return NULL;
    }
 
    ut32 j = 0;
    rz_pvector_foreach (dex->class_defs, vit) {
        class_def = (DexClassDef *)*vit;
        class_ids[j] = class_def->class_idx;
        j++;
    }
 
    imports = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!imports) {
        free(class_ids);
        return NULL;
    }
 
    ut32 ordinal = 0;
    rz_pvector_foreach (dex->field_ids, vit) {
        field_id = (DexFieldId *)*vit;
        bool class_found = false;
        for (ut32 i = 0; i < n_classes; ++i) {
            if (field_id->class_idx == class_ids[i]) {
                class_found = true;
                break;
            }
        }
        if (class_found) {
            continue;
        }
 
        RzBinImport *import = RZ_NEW0(RzBinImport);
        if (!import) {
            break;
        }
 
        char *object = dex_resolve_type_id(dex, field_id->class_idx);
        if (!object) {
            free(import);
            break;
        }
        rz_str_replace_char(object, ';', 0);
 
        char *class_name = (char *)rz_str_rchr(object, NULL, '/');
        if (class_name) {
            class_name[0] = 0;
            class_name++;
        }
        rz_str_replace_ch(object, '/', '.', 1);
 
        import->name = dex_resolve_string_id(dex, field_id->name_idx);
        import->libname = class_name ? strdup(object + 1) : NULL;
        import->classname = strdup(class_name ? class_name : object + 1);
        import->bind = RZ_BIN_BIND_WEAK_STR;
        import->type = RZ_BIN_TYPE_FIELD_STR;
        import->ordinal = ordinal;
        free(object);
 
        if (!rz_list_append(imports, import)) {
            rz_bin_import_free(import);
            break;
        }
        ordinal++;
    }
 
    rz_pvector_foreach (dex->method_ids, vit) {
        method_id = (DexMethodId *)*vit;
        bool class_found = false;
        for (ut32 i = 0; i < n_classes; ++i) {
            if (method_id->class_idx == class_ids[i]) {
                class_found = true;
                break;
            }
        }
        if (class_found) {
            continue;
        }
 
        RzBinImport *import = RZ_NEW0(RzBinImport);
        if (!import) {
            break;
        }
 
        char *object = dex_resolve_type_id(dex, method_id->class_idx);
        if (!object) {
            rz_bin_import_free(import);
            break;
        }
        rz_str_replace_char(object, ';', 0);
 
        char *class_name = (char *)rz_str_rchr(object, NULL, '/');
        if (class_name) {
            class_name[0] = 0;
            class_name++;
        }
        rz_str_replace_ch(object, '/', '.', 1);
 
        char *name = dex_resolve_string_id(dex, method_id->name_idx);
        import->name = dex_resolve_proto_id(dex, name, method_id->proto_idx, false);
        import->libname = class_name ? strdup(object + 1) : NULL;
        import->classname = strdup(class_name ? class_name : object + 1);
        import->bind = RZ_BIN_BIND_WEAK_STR;
        import->type = RZ_BIN_TYPE_FUNC_STR;
        import->ordinal = ordinal;
        free(name);
        free(object);
 
        if (!rz_list_append(imports, import)) {
            rz_bin_import_free(import);
            break;
        }
        ordinal++;
    }
 
    free(class_ids);
    return imports;
}

References dex_method_id_t::class_idx, dex_class_def_t::class_idx, dex_resolve_proto_id(), dex_resolve_string_id(), dex_resolve_type_id(), field_id, free(), i, imports(), dex_method_id_t::name_idx, NULL, dex_method_id_t::proto_idx, RZ_BIN_BIND_WEAK_STR, rz_bin_import_free(), RZ_BIN_TYPE_FIELD_STR, RZ_BIN_TYPE_FUNC_STR, rz_list_append(), rz_list_newf(), RZ_NEW0, RZ_NEWS0, rz_pvector_foreach, rz_pvector_len(), rz_return_val_if_fail, rz_str_rchr(), rz_str_replace_ch(), rz_str_replace_char(), and strdup().

Referenced by imports().

rz_bin_dex_libraries()

RZ_API RZ_OWN RzList* rz_bin_dex_libraries

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<char*> containing the dex libraries.

Definition at line 1520 of file dex.c.

                                                                       {
    rz_return_val_if_fail(dex, NULL);
 
    DexMethodId *method_id;
    DexClassDef *class_def;
    RzList *libraries = NULL;
    ut32 *class_ids = NULL;
    void **vit;
 
    ut32 n_classes = rz_pvector_len(dex->class_defs);
    if (n_classes < 1) {
        return rz_list_newf((RzListFree)free);
    }
 
    class_ids = RZ_NEWS0(ut32, n_classes);
    if (!class_ids) {
        return NULL;
    }
 
    ut32 j = 0;
    rz_pvector_foreach (dex->class_defs, vit) {
        class_def = (DexClassDef *)*vit;
        class_ids[j] = class_def->class_idx;
        j++;
    }
 
    libraries = rz_list_newf((RzListFree)free);
    if (!libraries) {
        free(class_ids);
        return NULL;
    }
 
    rz_pvector_foreach (dex->method_ids, vit) {
        method_id = (DexMethodId *)*vit;
        bool class_found = false;
        for (ut32 i = 0; i < n_classes; ++i) {
            if (method_id->class_idx == class_ids[i]) {
                class_found = true;
                break;
            }
        }
        if (class_found) {
            continue;
        }
 
        char *object = dex_resolve_type_id(dex, method_id->class_idx);
        if (RZ_STR_ISEMPTY(object) || *object != 'L' || !strncmp(object, "Ljava/", strlen("Ljava/"))) {
            free(object);
            continue;
        }
 
        char *p = object;
        if ((p = strchr(p, '/')) && (p = strchr(p + 1, '/'))) {
            *p = 0;
            p = rz_str_newf("%s/*;", object);
            free(object);
            object = p;
        }
 
        if (rz_list_find(libraries, object, compare_strings)) {
            free(object);
            continue;
        }
 
        if (!rz_list_append(libraries, object)) {
            free(object);
            break;
        }
    }
 
    free(class_ids);
    return libraries;
}

References dex_method_id_t::class_idx, dex_class_def_t::class_idx, compare_strings(), dex_resolve_type_id(), free(), i, libraries(), NULL, p, rz_list_append(), rz_list_find(), rz_list_newf(), RZ_NEWS0, rz_pvector_foreach, rz_pvector_len(), rz_return_val_if_fail, RZ_STR_ISEMPTY, and rz_str_newf().

Referenced by libraries().

rz_bin_dex_new()

RZ_API RZ_OWN RzBinDex* rz_bin_dex_new	(	RZ_NONNULL RzBuffer *	buf,
		ut64	base,
		RZ_NONNULL Sdb *	kv
	)

Parses the dex file and returns a RzBinDex struct.

Definition at line 669 of file dex.c.

                                                                                                {
    rz_return_val_if_fail(buf, NULL);
 
    RzBinDex *dex = (RzBinDex *)RZ_NEW0(RzBinDex);
    if (!dex) {
        return NULL;
    }
 
    dex->strings = rz_pvector_new((RzPVectorFree)dex_string_free);
    if (!dex->strings) {
        rz_bin_dex_free(dex);
        return NULL;
    }
    dex->proto_ids = rz_pvector_new((RzPVectorFree)dex_proto_id_free);
    if (!dex->proto_ids) {
        rz_bin_dex_free(dex);
        return NULL;
    }
    dex->field_ids = rz_pvector_new((RzPVectorFree)dex_field_id_free);
    if (!dex->field_ids) {
        rz_bin_dex_free(dex);
        return NULL;
    }
    dex->method_ids = rz_pvector_new((RzPVectorFree)dex_method_id_free);
    if (!dex->method_ids) {
        rz_bin_dex_free(dex);
        return NULL;
    }
    dex->class_defs = rz_pvector_new((RzPVectorFree)dex_class_def_free);
    if (!dex->class_defs) {
        rz_bin_dex_free(dex);
        return NULL;
    }
 
    if (!dex_parse(dex, base, buf)) {
        return NULL;
    }
 
    return dex;
}

References dex_t::class_defs, dex_class_def_free(), dex_field_id_free, dex_method_id_free, dex_parse(), dex_proto_id_free(), dex_string_free(), dex_t::field_ids, dex_t::method_ids, NULL, dex_t::proto_ids, rz_bin_dex_free(), RZ_NEW0, rz_pvector_new(), rz_return_val_if_fail, and dex_t::strings.

Referenced by load_buffer().

rz_bin_dex_relocations()

RZ_API RZ_BORROW RzBuffer* rz_bin_dex_relocations

(

RZ_NONNULL RzBinDex *

dex

)

This method will create a buffer filled with return-void values to mapped to the imports and allow the code to generate xrefs pointing to the imports

Definition at line 1821 of file dex.c.

                                                                            {
    rz_return_val_if_fail(dex, NULL);
    return dex->relocs_buffer;
}

References NULL, and rz_return_val_if_fail.

Referenced by virtual_files().

rz_bin_dex_resolve_class_by_idx()

RZ_API RZ_OWN char* rz_bin_dex_resolve_class_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	class_idx
	)

Returns the resolved string linked to the given class id.

Definition at line 1972 of file dex.c.

                                                                                              {
    rz_return_val_if_fail(dex, NULL);
 
    return dex_resolve_type_id(dex, class_idx);
}

References dex_resolve_type_id(), NULL, and rz_return_val_if_fail.

Referenced by get_name().

rz_bin_dex_resolve_field_by_idx()

RZ_API RZ_OWN char* rz_bin_dex_resolve_field_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	field_idx
	)

Returns the resolved string linked to the given field id.

Definition at line 1863 of file dex.c.

                                                                                              {
    rz_return_val_if_fail(dex, NULL);
 
    if (field_idx >= rz_pvector_len(dex->field_ids)) {
        return NULL;
    }
 
    DexFieldId *field_id = (DexFieldId *)rz_pvector_at(dex->field_ids, field_idx);
    char *class_name = dex_resolve_type_id(dex, field_id->class_idx);
    if (!class_name) {
        return NULL;
    }
 
    char *name = dex_resolve_string_id(dex, field_id->name_idx);
    if (!name) {
        free(class_name);
        return NULL;
    }
 
    char *type = dex_resolve_type_id(dex, field_id->type_idx);
    if (!type) {
        free(class_name);
        free(name);
        return NULL;
    }
 
    char *method = rz_str_newf("%s->%s %s", class_name, name, type);
 
    free(type);
    free(class_name);
    free(name);
    return method;
}

References dex_resolve_string_id(), dex_resolve_type_id(), field_id, free(), NULL, rz_pvector_at(), rz_pvector_len(), rz_return_val_if_fail, rz_str_newf(), and type.

Referenced by get_name().

rz_bin_dex_resolve_method_by_idx()

RZ_API RZ_OWN char* rz_bin_dex_resolve_method_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	method_idx
	)

Returns the resolved string linked to the given method id.

Definition at line 1829 of file dex.c.

                                                                                                {
    rz_return_val_if_fail(dex, NULL);
 
    if (method_idx >= rz_pvector_len(dex->method_ids)) {
        return NULL;
    }
 
    DexMethodId *method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, method_idx);
    char *name = dex_resolve_string_id(dex, method_id->name_idx);
    if (!name) {
        return NULL;
    }
 
    char *proto = dex_resolve_proto_id(dex, name, method_id->proto_idx, false);
    RZ_FREE(name);
    if (!proto) {
        return NULL;
    }
 
    name = dex_resolve_type_id(dex, method_id->class_idx);
    if (!name) {
        free(proto);
        return NULL;
    }
 
    char *method = rz_str_newf("%s->%s", name, proto);
    free(name);
    free(proto);
    return method;
}

References dex_method_id_t::class_idx, dex_resolve_proto_id(), dex_resolve_string_id(), dex_resolve_type_id(), free(), dex_method_id_t::name_idx, NULL, dex_method_id_t::proto_idx, RZ_FREE, rz_pvector_at(), rz_pvector_len(), rz_return_val_if_fail, and rz_str_newf().

Referenced by get_name().

rz_bin_dex_resolve_method_offset_by_idx()

RZ_API ut64 rz_bin_dex_resolve_method_offset_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	method_idx
	)

Returns the resolved offset linked to the given method id.

Definition at line 1928 of file dex.c.

                                                                                               {
    rz_return_val_if_fail(dex, UT64_MAX);
 
    if (method_idx >= rz_pvector_len(dex->method_ids)) {
        RZ_LOG_INFO("cannot find method with index %u\n", method_idx);
        return UT64_MAX;
    }
 
    DexMethodId *method = (DexMethodId *)rz_pvector_at(dex->method_ids, method_idx);
    if (method->code_offset) {
        if (method->code_offset < RZ_DEX_RELOC_ADDRESS) {
            return RZ_DEX_VIRT_ADDRESS + method->code_offset;
        }
        return method->code_offset;
    }
    return UT64_MAX;
}

References dex_method_id_t::code_offset, RZ_DEX_RELOC_ADDRESS, RZ_DEX_VIRT_ADDRESS, RZ_LOG_INFO, rz_pvector_at(), rz_pvector_len(), rz_return_val_if_fail, and UT64_MAX.

Referenced by get_offset().

rz_bin_dex_resolve_proto_by_idx()

RZ_API RZ_OWN char* rz_bin_dex_resolve_proto_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	proto_idx
	)

Returns the resolved string linked to the given prototype id.

Definition at line 1981 of file dex.c.

                                                                                              {
    rz_return_val_if_fail(dex, NULL);
 
    return dex_resolve_proto_id(dex, "", proto_idx, false);
}

References dex_resolve_proto_id(), NULL, and rz_return_val_if_fail.

Referenced by dex_print_encoded_method(), and get_name().

rz_bin_dex_resolve_string_by_idx()

RZ_API RZ_OWN char* rz_bin_dex_resolve_string_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	string_idx
	)

Returns the resolved string linked to the given string id.

Definition at line 1963 of file dex.c.

                                                                                                {
    rz_return_val_if_fail(dex, NULL);
 
    return dex_resolve_string_id(dex, string_idx);
}

References dex_resolve_string_id(), NULL, and rz_return_val_if_fail.

Referenced by dex_print_encoded_field(), dex_print_encoded_method(), get_name(), and rz_bin_dex_resolve_type_id_by_idx().

rz_bin_dex_resolve_string_offset_by_idx()

RZ_API ut64 rz_bin_dex_resolve_string_offset_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	string_idx
	)

Returns the resolved offset linked to the given string id.

Definition at line 1900 of file dex.c.

                                                                                               {
    rz_return_val_if_fail(dex, UT64_MAX);
 
    DexString *string = dex_resolve_string_id_native(dex, string_idx);
    if (!string) {
        RZ_LOG_INFO("cannot find string with index %u\n", string_idx);
        return UT64_MAX;
    }
    return RZ_DEX_VIRT_ADDRESS + string->offset;
}

References dex_resolve_string_id_native(), RZ_DEX_VIRT_ADDRESS, RZ_LOG_INFO, rz_return_val_if_fail, and UT64_MAX.

Referenced by get_offset(), and rz_bin_dex_resolve_type_id_offset_by_idx().

rz_bin_dex_resolve_symbol()

RZ_API RZ_OWN RzBinAddr* rz_bin_dex_resolve_symbol	(	RZ_NONNULL RzBinDex *	dex,
		RzBinSpecialSymbol	resolve
	)

Returns a RzBinAddr pointer containing the resolved RzBinSpecialSymbol.

Definition at line 1670 of file dex.c.

                                                                                                         {
    rz_return_val_if_fail(dex, NULL);
 
    DexClassDef *class_def;
    void **it;
 
    RzBinAddr *ret = RZ_NEW0(RzBinAddr);
    if (!ret) {
        return NULL;
    }
    ret->paddr = UT64_MAX;
    ret->vaddr = UT64_MAX;
 
    rz_pvector_foreach (dex->class_defs, it) {
        class_def = (DexClassDef *)*it;
        if (dex_resolve_symbol_in_class_methods(dex, class_def, resolve, &ret->paddr, &ret->vaddr)) {
            break;
        }
    }
 
    return ret;
}

References dex_resolve_symbol_in_class_methods(), NULL, rz_bin_addr_t::paddr, resolve(), RZ_NEW0, rz_pvector_foreach, rz_return_val_if_fail, UT64_MAX, and rz_bin_addr_t::vaddr.

Referenced by binsym().

rz_bin_dex_resolve_type_id_by_idx()

RZ_API RZ_OWN char* rz_bin_dex_resolve_type_id_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	type_idx
	)

Returns the resolved string linked to the given type id.

Definition at line 1949 of file dex.c.

                                                                                               {
    rz_return_val_if_fail(dex, NULL);
 
    if (type_idx >= dex->type_ids_size) {
        RZ_LOG_INFO("cannot find type_id with index %u\n", type_idx);
        return NULL;
    }
    DexTypeId type_id = dex->types[type_idx];
    return rz_bin_dex_resolve_string_by_idx(dex, type_id);
}

References NULL, rz_bin_dex_resolve_string_by_idx(), RZ_LOG_INFO, and rz_return_val_if_fail.

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

rz_bin_dex_resolve_type_id_offset_by_idx()

RZ_API ut64 rz_bin_dex_resolve_type_id_offset_by_idx	(	RZ_NONNULL RzBinDex *	dex,
		ut32	type_idx
	)

Returns the resolved offset linked to the given type id.

Definition at line 1914 of file dex.c.

                                                                                              {
    rz_return_val_if_fail(dex, UT64_MAX);
 
    if (type_idx >= dex->type_ids_size) {
        RZ_LOG_INFO("cannot find type_id with index %u\n", type_idx);
        return UT64_MAX;
    }
    DexTypeId type_id = dex->types[type_idx];
    return rz_bin_dex_resolve_string_offset_by_idx(dex, type_id);
}

References rz_bin_dex_resolve_string_offset_by_idx(), RZ_LOG_INFO, rz_return_val_if_fail, and UT64_MAX.

Referenced by get_offset().

rz_bin_dex_sections()

RZ_API RZ_OWN RzList* rz_bin_dex_sections

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinSection*> containing the dex sections.

Definition at line 1200 of file dex.c.

                                                                      {
    rz_return_val_if_fail(dex, NULL);
 
    RzBinSection *section;
    RzList *sections = NULL;
 
    sections = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!sections) {
        return NULL;
    }
    section = section_new("data", RZ_PERM_RWX, dex->data_size, dex->data_offset, RZ_DEX_VIRT_ADDRESS + dex->data_offset);
    if (section && !rz_list_append(sections, section)) {
        rz_bin_section_free(section);
    }
    section = section_new("file", RZ_PERM_R, dex->file_size, dex->header_offset, 0);
    if (section && !rz_list_append(sections, section)) {
        rz_bin_section_free(section);
    }
 
    if (dex->relocs_code) {
        section = section_new(RZ_DEX_RELOC_TARGETS, RZ_PERM_RWX, dex->relocs_size, 0, dex->relocs_offset);
        if (section && !rz_list_append(sections, section)) {
            rz_bin_section_free(section);
        }
    }
 
    return sections;
}

References NULL, rz_bin_section_free(), RZ_DEX_RELOC_TARGETS, RZ_DEX_VIRT_ADDRESS, rz_list_append(), rz_list_newf(), RZ_PERM_R, RZ_PERM_RWX, rz_return_val_if_fail, section_new(), and sections().

Referenced by sections().

rz_bin_dex_sha1()

RZ_API void rz_bin_dex_sha1	(	RZ_NONNULL RzBinDex *	dex,
		RZ_NONNULL RzBinHash *	hash
	)

Sets the RzBinHash dex digest (sha1)

Definition at line 2003 of file dex.c.

                                                                                  {
    rz_return_if_fail(dex && hash);
    hash->type = "sha1";
    hash->len = 20;
    hash->addr = dex->signature_offset;
    hash->from = dex->signature_offset + sizeof(dex->signature);
    hash->to = dex->file_size - hash->from;
    memcpy(hash->buf, dex->signature, sizeof(dex->signature));
}

References memcpy(), and rz_return_if_fail.

Referenced by info().

rz_bin_dex_strings()

RZ_API RZ_OWN RzList* rz_bin_dex_strings

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinString*> containing the dex strings.

Definition at line 735 of file dex.c.

                                                                     {
    rz_return_val_if_fail(dex, NULL);
 
    DexString *string;
    void **it;
    RzList *strings = rz_list_newf(rz_bin_string_free);
    if (!strings) {
        return NULL;
    }
 
    ut32 ordinal = 0;
    rz_pvector_foreach (dex->strings, it) {
        string = (DexString *)*it;
        RzBinString *bstr = RZ_NEW0(RzBinString);
        if (!bstr) {
            continue;
        }
        bstr->paddr = string->offset;
        bstr->vaddr = RZ_DEX_VIRT_ADDRESS + string->offset;
        bstr->ordinal = ordinal;
        bstr->length = string->size;
        bstr->size = string->size;
        bstr->string = rz_str_ndup(string->data, string->size);
        bstr->type = RZ_STRING_ENC_UTF8;
        if (!rz_list_append(strings, bstr)) {
            free(bstr);
        }
        ordinal++;
    }
    return strings;
}

References dex_string_t::data, free(), rz_bin_string_t::length, NULL, rz_bin_string_t::ordinal, rz_bin_string_t::paddr, rz_bin_string_free(), RZ_DEX_VIRT_ADDRESS, rz_list_append(), rz_list_newf(), RZ_NEW0, rz_pvector_foreach, rz_return_val_if_fail, rz_str_ndup(), RZ_STRING_ENC_UTF8, dex_string_t::size, rz_bin_string_t::size, rz_bin_string_t::string, strings(), rz_bin_string_t::type, and rz_bin_string_t::vaddr.

Referenced by strings().

rz_bin_dex_symbols()

RZ_API RZ_OWN RzList* rz_bin_dex_symbols

(

RZ_NONNULL RzBinDex *

dex

)

Returns a RzList<RzBinSymbol*> containing the dex symbols.

Definition at line 1267 of file dex.c.

                                                                     {
    rz_return_val_if_fail(dex, NULL);
 
    DexClassDef *class_def;
    DexFieldId *field_id;
    DexMethodId *method_id;
    RzList *class_symbols = NULL;
    RzList *symbols = NULL;
    void **vit;
    ut8 *inserted_methods = NULL;
    ut8 *inserted_fields = NULL;
    ut32 n_methods = rz_pvector_len(dex->method_ids);
    ut32 n_fields = rz_pvector_len(dex->field_ids);
 
    inserted_methods = RZ_NEWS0(ut8, n_methods);
    inserted_fields = RZ_NEWS0(ut8, n_fields);
    if ((n_methods > 0 && !inserted_methods) || (n_fields > 0 && !inserted_fields)) {
        free(inserted_fields);
        free(inserted_methods);
        return NULL;
    }
 
    symbols = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!symbols) {
        free(inserted_fields);
        free(inserted_methods);
        return NULL;
    }
 
    rz_pvector_foreach (dex->class_defs, vit) {
        class_def = (DexClassDef *)*vit;
 
        class_symbols = dex_resolve_fields_in_class_as_symbols(dex, class_def, inserted_fields);
        if (class_symbols) {
            rz_list_join(symbols, class_symbols);
            rz_list_free(class_symbols);
        }
 
        class_symbols = dex_resolve_methods_in_class(dex, class_def, inserted_methods);
        if (class_symbols) {
            rz_list_join(symbols, class_symbols);
            rz_list_free(class_symbols);
        }
    }
 
    ut32 j = 0;
    rz_pvector_foreach (dex->field_ids, vit) {
        field_id = (DexFieldId *)*vit;
        if (inserted_fields[j++]) {
            continue;
        }
 
        RzBinSymbol *field = RZ_NEW0(RzBinSymbol);
        if (!field) {
            break;
        }
 
        field->name = dex_resolve_string_id(dex, field_id->name_idx);
        field->classname = dex_resolve_type_id(dex, field_id->class_idx);
        field->libname = dex_resolve_library(field->classname);
        field->bind = RZ_BIN_BIND_WEAK_STR;
        field->type = RZ_BIN_TYPE_FIELD_STR;
        field->is_imported = true;
 
        if (!rz_list_append(symbols, field)) {
            rz_bin_symbol_free(field);
            break;
        }
    }
 
    j = 0;
    rz_pvector_foreach (dex->method_ids, vit) {
        method_id = (DexMethodId *)*vit;
        if (inserted_methods[j++]) {
            continue;
        }
 
        RzBinSymbol *method = RZ_NEW0(RzBinSymbol);
        if (!method) {
            break;
        }
 
        method->name = dex_resolve_string_id(dex, method_id->name_idx);
        method->classname = dex_resolve_type_id(dex, method_id->class_idx);
        method->libname = dex_resolve_library(method->classname);
        method->dname = dex_resolve_proto_id(dex, method->name, method_id->proto_idx, false);
        method->bind = RZ_BIN_BIND_WEAK_STR;
        method->is_imported = true;
        method->type = RZ_BIN_TYPE_METH_STR;
        if (method_id->code_offset < RZ_DEX_RELOC_ADDRESS) {
            method->vaddr = RZ_DEX_VIRT_ADDRESS + method_id->code_offset;
            method->paddr = method_id->code_offset;
        } else {
            method->vaddr = method_id->code_offset;
            method->paddr = 0;
        }
        method->size = method_id->code_size;
 
        if (!rz_list_append(symbols, method)) {
            rz_bin_symbol_free(method);
            break;
        }
    }
 
    free(inserted_fields);
    free(inserted_methods);
    return symbols;
}

References rz_bin_symbol_t::bind, dex_method_id_t::class_idx, rz_bin_symbol_t::classname, dex_method_id_t::code_offset, dex_method_id_t::code_size, dex_resolve_fields_in_class_as_symbols(), dex_resolve_library(), dex_resolve_methods_in_class(), dex_resolve_proto_id(), dex_resolve_string_id(), dex_resolve_type_id(), rz_bin_symbol_t::dname, field_id, free(), rz_bin_symbol_t::is_imported, rz_bin_symbol_t::libname, rz_bin_symbol_t::name, dex_method_id_t::name_idx, NULL, rz_bin_symbol_t::paddr, dex_method_id_t::proto_idx, RZ_BIN_BIND_WEAK_STR, rz_bin_symbol_free(), RZ_BIN_TYPE_FIELD_STR, RZ_BIN_TYPE_METH_STR, RZ_DEX_RELOC_ADDRESS, RZ_DEX_VIRT_ADDRESS, rz_list_append(), rz_list_free(), rz_list_join(), rz_list_newf(), RZ_NEW0, RZ_NEWS0, rz_pvector_foreach, rz_pvector_len(), rz_return_val_if_fail, rz_bin_symbol_t::size, symbols(), rz_bin_symbol_t::type, and rz_bin_symbol_t::vaddr.

Referenced by symbols().

rz_bin_dex_version()

RZ_API RZ_OWN char* rz_bin_dex_version

(

RZ_NONNULL RzBinDex *

dex

)

Returns the dex version (string format)

Definition at line 2016 of file dex.c.

                                                                 {
    rz_return_val_if_fail(dex, NULL);
    // https://cs.android.com/android/platform/superproject/+/master:dalvik/dx/src/com/android/dex/DexFormat.java;l=55;bpv=1;bpt=0
    // https://developer.android.com/studio/releases/platforms
    if (!strncmp((char *)dex->version, "009", 3)) {
        return strdup("Android M3 release (Nov-Dec 2007)");
    } else if (!strncmp((char *)dex->version, "013", 3)) {
        return strdup("Android M5 release (Feb-Mar 2008)");
    } else if (!strncmp((char *)dex->version, "035", 3)) {
        return strdup("Android 3.2 (API level 13 and earlier)");
    } else if (!strncmp((char *)dex->version, "037", 3)) {
        return strdup("Android 7 (API level 24 and earlier)");
    } else if (!strncmp((char *)dex->version, "038", 3)) {
        return strdup("Android 8 (API level 26 and earlier)");
    } else if (!strncmp((char *)dex->version, "039", 3)) {
        return strdup("Android 9 (API level 28 and earlier)");
    } else if (!strncmp((char *)dex->version, "040", 3)) {
        return strdup("Android 10+ (Aug 2019)");
    }
    return NULL;
}

References NULL, rz_return_val_if_fail, and strdup().

Referenced by info(), and rz_cmd_dexs_handler().