dex.c File Reference

#include "dex.h"
#include <rz_util.h>

Go to the source code of this file.

Classes
struct	dex_access_flags_readable_t

Macros
#define	DEX_INVALID_CLASS   "Lunknown_class;"
#define	DEX_INVALID_METHOD   "unknown_method"
#define	read_le_bits_or_fail(bits, buf, val, fail)
#define	read_le_at_bits_or_fail(bits, buf, val, offset, fail)
#define	read_le32_or_fail(buf, val, fail)   read_le_bits_or_fail(32, buf, val, fail)
#define	read_le16_or_fail(buf, val, fail)   read_le_bits_or_fail(16, buf, val, fail)
#define	read_le32_at_or_fail(buf, val, offset, fail)   read_le_at_bits_or_fail(32, buf, val, offset, fail)
#define	read_le16_at_or_fail(buf, val, offset, fail)   read_le_at_bits_or_fail(16, buf, val, offset, fail)
#define	dex_is_static(a)   (a & ACCESS_FLAG_STATIC)
#define	dex_is_varargs(a)   (a & ACCESS_FLAG_VARARGS)
#define	dex_fail_if_bad_ids(name, z, s, g)
#define	CLASS_ACCESS_FLAGS_SIZE   18
#define	dex_field_id_free   free
#define	dex_method_id_free   free

Typedefs
typedef struct dex_access_flags_readable_t	DexAccessFlagsReadable

Functions
static void	dex_string_free (DexString *string)
static DexString *	dex_string_new (RzBuffer *buf, ut64 offset, st64 *pread)
static void	dex_proto_id_free (DexProtoId *string)
static DexProtoId *	dex_proto_id_new (RzBuffer *buf, ut64 offset)
static DexFieldId *	dex_field_id_new (RzBuffer *buf, ut64 offset)
static DexMethodId *	dex_method_id_new (RzBuffer *buf, ut64 offset)
static void	dex_class_def_free (DexClassDef *class_def)
static DexEncodedField *	dex_new_encoded_field (RzBuffer *buf, ut64 base, ut64 *diff_value_prev, bool first)
static DexEncodedMethod *	dex_new_encoded_method (RzBuffer *buf, ut64 base, ut64 *diff_value_prev, bool first, RzPVector *method_ids)
static DexClassDef *	dex_class_def_new (RzBuffer *buf, ut64 offset, ut64 base, RzPVector *method_ids)
static void	dex_resolve_virtual_method_code (RzBinDex *dex, DexMethodId *to_resolve, ut32 superclass_idx)
static void	dex_resolve_all_virtual_methods (RzBinDex *dex)
static bool	dex_create_relocations (RzBinDex *dex)
static bool	dex_parse (RzBinDex *dex, ut64 base, RzBuffer *buf)
RZ_API void	rz_bin_dex_free (RZ_NULLABLE RzBinDex *dex)
	Frees a RzBinDex struct. More...
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 RZ_OWN char *	rz_bin_dex_access_flags_readable (ut32 access_flags)
RZ_API RZ_OWN RzList *	rz_bin_dex_strings (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinString*> containing the dex strings. More...
static DexString *	dex_resolve_string_id_native (RzBinDex *dex, ut32 string_idx)
static char *	dex_resolve_string_id (RzBinDex *dex, ut32 string_idx)
static char *	dex_resolve_type_id (RzBinDex *dex, ut32 type_idx)
static char *	dex_resolve_proto_id (RzBinDex *dex, const char *name, ut32 proto_idx, bool varargs)
static ut64	dex_access_flags_to_bin_flags (ut64 access_flags)
static char *	dex_resolve_library (const char *library)
static RzBinSymbol *	dex_method_to_symbol (RzBinDex *dex, DexEncodedMethod *encoded_method, DexMethodId *method_id, bool is_imported)
static RzList *	dex_resolve_methods_in_class (RzBinDex *dex, DexClassDef *class_def, ut8 *inserted)
static RzBinField *	dex_field_to_bin_field (RzBinDex *dex, DexEncodedField *encoded_field, DexFieldId *field_id, bool is_static)
static RzList *	dex_resolve_fields_in_class (RzBinDex *dex, DexClassDef *class_def, ut8 *inserted)
static RzBinSymbol *	dex_field_to_symbol (RzBinDex *dex, DexEncodedField *encoded_field, DexFieldId *field_id, bool is_imported)
static RzList *	dex_resolve_fields_in_class_as_symbols (RzBinDex *dex, DexClassDef *class_def, ut8 *inserted)
static void	free_rz_bin_class (RzBinClass *bclass)
RZ_API RZ_OWN RzList *	rz_bin_dex_classes (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinClass*> containing the dex classes. More...
static RzBinSection *	section_new (const char *name, ut32 perm, ut32 size, ut64 paddr, ut64 vaddr)
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_fields (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<RzBinField*> containing the dex fields. 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...
static int	compare_strings (const void *a, const void *b)
RZ_API RZ_OWN RzList *	rz_bin_dex_libraries (RZ_NONNULL RzBinDex *dex)
	Returns a RzList<char*> containing the dex libraries. More...
static bool	dex_resolve_symbol_in_class_methods (RzBinDex *dex, DexClassDef *class_def, RzBinSpecialSymbol resolve, ut64 *paddr, ut64 *vaddr)
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...
static RzList *	dex_resolve_entrypoints_in_class (RzBinDex *dex, DexClassDef *class_def)
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 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 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_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_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_proto_by_idx (RZ_NONNULL RzBinDex *dex, ut32 proto_idx)
	Returns the resolved string linked to the given prototype 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...
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...

Variables
static const DexAccessFlagsReadable	access_flags_list [CLASS_ACCESS_FLAGS_SIZE]

Macro Definition Documentation

CLASS_ACCESS_FLAGS_SIZE

#define CLASS_ACCESS_FLAGS_SIZE   18

Definition at line 47 of file dex.c.

dex_fail_if_bad_ids

#define dex_fail_if_bad_ids	(		name,
			z,
			s,
			g
	)

Value:

    do { \
        ut64 end = name##_offset; \
        end += name##_size * (z); \
        if (end >= (s)) { \
            goto g; \
        } \
    } while (0)

Definition at line 38 of file dex.c.

dex_field_id_free

#define dex_field_id_free   free

Definition at line 147 of file dex.c.

DEX_INVALID_CLASS

#define DEX_INVALID_CLASS   "Lunknown_class;"

Definition at line 8 of file dex.c.

DEX_INVALID_METHOD

#define DEX_INVALID_METHOD   "unknown_method"

Definition at line 9 of file dex.c.

dex_is_static

#define dex_is_static

(

a

)

(a & ACCESS_FLAG_STATIC)

Definition at line 35 of file dex.c.

dex_is_varargs

#define dex_is_varargs

(

a

)

(a & ACCESS_FLAG_VARARGS)

Definition at line 36 of file dex.c.

dex_method_id_free

#define dex_method_id_free   free

Definition at line 165 of file dex.c.

read_le16_at_or_fail

#define read_le16_at_or_fail	(		buf,
			val,
			offset,
			fail
	)		read_le_at_bits_or_fail(16, buf, val, offset, fail)

Definition at line 33 of file dex.c.

read_le16_or_fail

#define read_le16_or_fail	(		buf,
			val,
			fail
	)		read_le_bits_or_fail(16, buf, val, fail)

Definition at line 31 of file dex.c.

read_le32_at_or_fail

#define read_le32_at_or_fail	(		buf,
			val,
			offset,
			fail
	)		read_le_at_bits_or_fail(32, buf, val, offset, fail)

Definition at line 32 of file dex.c.

read_le32_or_fail

#define read_le32_or_fail	(		buf,
			val,
			fail
	)		read_le_bits_or_fail(32, buf, val, fail)

Definition at line 30 of file dex.c.

read_le_at_bits_or_fail

#define read_le_at_bits_or_fail	(		bits,
			buf,
			val,
			offset,
			fail
	)

Value:

    do { \
        if (!rz_buf_read_le##bits##_at(buf, offset, &val)) { \
            goto fail; \
        } \
    } while (0)

Definition at line 23 of file dex.c.

read_le_bits_or_fail

#define read_le_bits_or_fail	(		bits,
			buf,
			val,
			fail
	)

Value:

    do { \
        if (!rz_buf_read_le##bits(buf, &val)) { \
            goto fail; \
        } \
    } while (0)

Definition at line 16 of file dex.c.

Typedef Documentation

DexAccessFlagsReadable

typedef struct dex_access_flags_readable_t DexAccessFlagsReadable

Function Documentation

compare_strings()

static int compare_strings ( const void *  a, const void *  b  )

static

Definition at line 1513 of file dex.c.

                                                         {
    return strcmp((const char *)a, (const char *)b);
}

References a, and b.

Referenced by rz_bin_dex_libraries().

dex_access_flags_to_bin_flags()

static ut64 dex_access_flags_to_bin_flags ( ut64  access_flags )

static

Definition at line 836 of file dex.c.

                                                             {
    ut64 flags = 0;
    if (access_flags & ACCESS_FLAG_PUBLIC) {
        flags |= RZ_BIN_METH_PUBLIC;
    }
    if (access_flags & ACCESS_FLAG_PRIVATE) {
        flags |= RZ_BIN_METH_PRIVATE;
    }
    if (access_flags & ACCESS_FLAG_PROTECTED) {
        flags |= RZ_BIN_METH_PROTECTED;
    }
    if (access_flags & ACCESS_FLAG_STATIC) {
        flags |= RZ_BIN_METH_STATIC;
    }
    if (access_flags & ACCESS_FLAG_FINAL) {
        flags |= RZ_BIN_METH_FINAL;
    }
    if (access_flags & ACCESS_FLAG_SYNCHRONIZED) {
        flags |= RZ_BIN_METH_SYNCHRONIZED;
    }
    if (access_flags & ACCESS_FLAG_BRIDGE) {
        flags |= RZ_BIN_METH_BRIDGE;
    }
    if (access_flags & ACCESS_FLAG_VARARGS) {
        flags |= RZ_BIN_METH_VARARGS;
    }
    if (access_flags & ACCESS_FLAG_NATIVE) {
        flags |= RZ_BIN_METH_NATIVE;
    }
    // RZ_BIN_METH_INTERFACE does not exists
    // if (access_flags & ACCESS_FLAG_INTERFACE) {
    //  flags |= RZ_BIN_METH_INTERFACE;
    //}
    if (access_flags & ACCESS_FLAG_ABSTRACT) {
        flags |= RZ_BIN_METH_ABSTRACT;
    }
    if (access_flags & ACCESS_FLAG_STRICT) {
        flags |= RZ_BIN_METH_STRICT;
    }
    if (access_flags & ACCESS_FLAG_SYNTHETIC) {
        flags |= RZ_BIN_METH_SYNTHETIC;
    }
    // RZ_BIN_METH_ANNOTATION does not exists
    // if (access_flags & ACCESS_FLAG_ANNOTATION) {
    //  flags |= RZ_BIN_METH_ANNOTATION;
    //}
    // RZ_BIN_METH_ENUM does not exists
    // if (access_flags & ACCESS_FLAG_ENUM) {
    //  flags |= RZ_BIN_METH_ENUM;
    //}
    // RZ_BIN_METH_MODULE does not exists
    // if (access_flags & ACCESS_FLAG_MODULE) {
    //  flags |= RZ_BIN_METH_MODULE;
    //}
    if (access_flags & ACCESS_FLAG_CONSTRUCTOR) {
        flags |= RZ_BIN_METH_CONSTRUCTOR;
    }
    if (access_flags & ACCESS_FLAG_DECLARED_SYNCHRONIZED) {
        flags |= RZ_BIN_METH_DECLARED_SYNCHRONIZED;
    }
    return flags;
}

References ACCESS_FLAG_ABSTRACT, ACCESS_FLAG_BRIDGE, ACCESS_FLAG_CONSTRUCTOR, ACCESS_FLAG_DECLARED_SYNCHRONIZED, ACCESS_FLAG_FINAL, ACCESS_FLAG_NATIVE, ACCESS_FLAG_PRIVATE, ACCESS_FLAG_PROTECTED, ACCESS_FLAG_PUBLIC, ACCESS_FLAG_STATIC, ACCESS_FLAG_STRICT, ACCESS_FLAG_SYNCHRONIZED, ACCESS_FLAG_SYNTHETIC, ACCESS_FLAG_VARARGS, flags, RZ_BIN_METH_ABSTRACT, RZ_BIN_METH_BRIDGE, RZ_BIN_METH_CONSTRUCTOR, RZ_BIN_METH_DECLARED_SYNCHRONIZED, RZ_BIN_METH_FINAL, RZ_BIN_METH_NATIVE, RZ_BIN_METH_PRIVATE, RZ_BIN_METH_PROTECTED, RZ_BIN_METH_PUBLIC, RZ_BIN_METH_STATIC, RZ_BIN_METH_STRICT, RZ_BIN_METH_SYNCHRONIZED, RZ_BIN_METH_SYNTHETIC, RZ_BIN_METH_VARARGS, and ut64().

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

dex_class_def_free()

static void dex_class_def_free ( DexClassDef *  class_def )

static

Definition at line 183 of file dex.c.

                                                       {
    if (!class_def) {
        return;
    }
    rz_list_free(class_def->static_fields);
    rz_list_free(class_def->instance_fields);
    rz_list_free(class_def->direct_methods);
    rz_list_free(class_def->virtual_methods);
    free(class_def->interfaces);
    free(class_def);
}

References dex_class_def_t::direct_methods, free(), dex_class_def_t::instance_fields, dex_class_def_t::interfaces, rz_list_free(), dex_class_def_t::static_fields, and dex_class_def_t::virtual_methods.

Referenced by dex_class_def_new(), and rz_bin_dex_new().

dex_class_def_new()

static DexClassDef* dex_class_def_new ( RzBuffer *  buf, ut64  offset, ut64  base, RzPVector *  method_ids  )

static

Definition at line 262 of file dex.c.

                                                                                                    {
    DexClassDef *class_def = RZ_NEW0(DexClassDef);
    if (!class_def) {
        return NULL;
    }
 
    ut64 static_fields_size = 0;
    ut64 instance_fields_size = 0;
    ut64 direct_methods_size = 0;
    ut64 virtual_methods_size = 0;
    ut64 diff_value_prev;
 
    class_def->static_fields = /*  */ rz_list_newf((RzListFree)free);
    class_def->instance_fields =  rz_list_newf((RzListFree)free);
    class_def->direct_methods = /* */ rz_list_newf((RzListFree)free);
    class_def->virtual_methods =  rz_list_newf((RzListFree)free);
 
    read_le16_or_fail(buf, class_def->class_idx, dex_class_def_new_fail);
    read_le16_or_fail(buf, class_def->_padding1, dex_class_def_new_fail);
    read_le32_or_fail(buf, class_def->access_flags, dex_class_def_new_fail);
    read_le16_or_fail(buf, class_def->superclass_idx, dex_class_def_new_fail);
    read_le16_or_fail(buf, class_def->_padding2, dex_class_def_new_fail);
    read_le32_or_fail(buf, class_def->interfaces_offset, dex_class_def_new_fail);
    read_le32_or_fail(buf, class_def->source_file_idx, dex_class_def_new_fail);
    read_le32_or_fail(buf, class_def->annotations_offset, dex_class_def_new_fail);
    read_le32_or_fail(buf, class_def->class_data_offset, dex_class_def_new_fail);
    read_le32_or_fail(buf, class_def->static_values_offset, dex_class_def_new_fail);
    class_def->offset = offset;
 
    if (class_def->interfaces_offset > 0) {
        if (rz_buf_seek(buf, class_def->interfaces_offset, RZ_BUF_SET) < 0) {
            goto dex_class_def_new_fail;
        }
        read_le32_or_fail(buf, class_def->n_interfaces, dex_class_def_new_fail);
        if (class_def->n_interfaces > 0) {
            class_def->interfaces = RZ_NEWS0(ut16, class_def->n_interfaces);
            if (!class_def->interfaces) {
                goto dex_class_def_new_fail;
            }
            for (ut32 i = 0; i < class_def->n_interfaces; ++i) {
                read_le16_or_fail(buf, class_def->interfaces[i], dex_class_def_new_fail);
            }
        }
    }
 
    if (!class_def->class_data_offset) {
        return class_def;
    }
 
    if (rz_buf_seek(buf, class_def->class_data_offset, RZ_BUF_SET) < 0) {
        goto dex_class_def_new_fail;
    }
 
    rz_buf_uleb128(buf, &static_fields_size);
    rz_buf_uleb128(buf, &instance_fields_size);
    rz_buf_uleb128(buf, &direct_methods_size);
    rz_buf_uleb128(buf, &virtual_methods_size);
 
    for (ut64 i = 0; i < static_fields_size; ++i) {
        DexEncodedField *encoded_field = dex_new_encoded_field(buf, base, &diff_value_prev, i < 1);
        if (!encoded_field || !rz_list_append(class_def->static_fields, encoded_field)) {
            free(encoded_field);
            goto dex_class_def_new_fail;
        }
    }
 
    for (ut64 i = 0; i < instance_fields_size; ++i) {
        DexEncodedField *encoded_field = dex_new_encoded_field(buf, base, &diff_value_prev, i < 1);
        if (!encoded_field || !rz_list_append(class_def->instance_fields, encoded_field)) {
            free(encoded_field);
            goto dex_class_def_new_fail;
        }
    }
 
    for (ut64 i = 0; i < direct_methods_size; ++i) {
        DexEncodedMethod *encoded_method = dex_new_encoded_method(buf, base, &diff_value_prev, i < 1, method_ids);
        if (!encoded_method || !rz_list_append(class_def->direct_methods, encoded_method)) {
            free(encoded_method);
            goto dex_class_def_new_fail;
        }
    }
 
    for (ut64 i = 0; i < virtual_methods_size; ++i) {
        DexEncodedMethod *encoded_method = dex_new_encoded_method(buf, base, &diff_value_prev, i < 1, method_ids);
        if (!encoded_method || !rz_list_append(class_def->virtual_methods, encoded_method)) {
            free(encoded_method);
            goto dex_class_def_new_fail;
        }
    }
 
    return class_def;
 
dex_class_def_new_fail:
    dex_class_def_free(class_def);
    return NULL;
}

References dex_class_def_t::_padding1, dex_class_def_t::_padding2, 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, dex_class_def_free(), dex_new_encoded_field(), dex_new_encoded_method(), dex_class_def_t::direct_methods, free(), i, dex_class_def_t::instance_fields, dex_class_def_t::interfaces, dex_class_def_t::interfaces_offset, dex_class_def_t::n_interfaces, NULL, dex_class_def_t::offset, read_le16_or_fail, read_le32_or_fail, rz_buf_seek(), RZ_BUF_SET, rz_buf_uleb128(), rz_list_append(), rz_list_newf(), RZ_NEW0, RZ_NEWS0, 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, ut64(), and dex_class_def_t::virtual_methods.

Referenced by dex_parse().

dex_create_relocations()

static bool dex_create_relocations ( RzBinDex *  dex )

static

Definition at line 393 of file dex.c.

                                                  {
    void **iter_p0;
    RzListIter *iter_l;
    DexClassDef *class_def;
    DexEncodedMethod *encoded_method = NULL;
    DexMethodId *method_id = NULL;
 
    dex->relocs_size = 0;
    rz_pvector_foreach (dex->method_ids, iter_p0) {
        method_id = (DexMethodId *)*iter_p0;
        if (method_id->code_offset) {
            continue;
        }
        // patch the imported method.
        method_id->code_offset = dex->relocs_offset + dex->relocs_size;
        method_id->code_size = 2;
        dex->relocs_size += 2;
    }
 
    // sync classes with method_ids
    rz_pvector_foreach (dex->class_defs, iter_p0) {
        class_def = (DexClassDef *)*iter_p0;
        rz_list_foreach (class_def->direct_methods, iter_l, encoded_method) {
            if (encoded_method->code_offset) {
                continue;
            }
            method_id = NULL;
            if (encoded_method->method_idx < rz_pvector_len(dex->method_ids)) {
                method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
                if (method_id->code_offset) {
                    encoded_method->code_offset = method_id->code_offset;
                    encoded_method->code_size = method_id->code_size;
                    continue;
                }
            }
 
            // patch the imported method.
            encoded_method->code_offset = dex->relocs_offset + dex->relocs_size;
            encoded_method->code_size = 2;
            dex->relocs_size += 2;
            if (method_id) {
                method_id->code_offset = encoded_method->code_offset;
                method_id->code_size = encoded_method->code_size;
            }
        }
 
        rz_list_foreach (class_def->virtual_methods, iter_l, encoded_method) {
            if (encoded_method->code_offset) {
                continue;
            }
            method_id = NULL;
            if (encoded_method->method_idx < rz_pvector_len(dex->method_ids)) {
                method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
                if (method_id->code_offset) {
                    encoded_method->code_offset = method_id->code_offset;
                    encoded_method->code_size = method_id->code_size;
                    continue;
                }
            }
 
            // patch the imported method.
            encoded_method->code_offset = dex->relocs_offset + dex->relocs_size;
            encoded_method->code_size = 2;
            dex->relocs_size += 2;
            if (method_id) {
                method_id->code_offset = encoded_method->code_offset;
                method_id->code_size = encoded_method->code_size;
            }
        }
    }
 
    if (dex->relocs_size < 1) {
        return true;
    }
    dex->relocs_code = malloc(dex->relocs_size);
    if (!dex->relocs_code) {
        return false;
    }
    for (ut32 i = 0; i < dex->relocs_size; i += 2) {
        dex->relocs_code[i] = 0x0e;
        dex->relocs_code[i + 1] = 0x00;
    }
    dex->relocs_buffer = rz_buf_new_with_bytes(dex->relocs_code, dex->relocs_size);
    return dex->relocs_buffer;
}

References dex_t::class_defs, dex_method_id_t::code_offset, dex_encoded_method_t::code_offset, dex_method_id_t::code_size, dex_encoded_method_t::code_size, dex_class_def_t::direct_methods, i, malloc(), dex_t::method_ids, dex_encoded_method_t::method_idx, NULL, dex_t::relocs_buffer, dex_t::relocs_code, dex_t::relocs_offset, dex_t::relocs_size, rz_buf_new_with_bytes(), rz_pvector_at(), rz_pvector_foreach, rz_pvector_len(), and dex_class_def_t::virtual_methods.

Referenced by dex_parse().

dex_field_id_new()

static DexFieldId* dex_field_id_new ( RzBuffer *  buf, ut64  offset  )

static

Definition at line 148 of file dex.c.

                                                                {
    DexFieldId *field_id = RZ_NEW0(DexFieldId);
    if (!field_id) {
        return NULL;
    }
 
    read_le16_or_fail(buf, field_id->class_idx, dex_field_id_new_fail);
    read_le16_or_fail(buf, field_id->type_idx, dex_field_id_new_fail);
    read_le32_or_fail(buf, field_id->name_idx, dex_field_id_new_fail);
    field_id->offset = offset;
    return field_id;
 
dex_field_id_new_fail:
    free(field_id);
    return NULL;
}

References field_id, free(), NULL, read_le16_or_fail, read_le32_or_fail, and RZ_NEW0.

Referenced by dex_parse().

dex_field_to_bin_field()

static RzBinField* dex_field_to_bin_field ( RzBinDex *  dex, DexEncodedField *  encoded_field, DexFieldId *  field_id, bool  is_static  )

static

Definition at line 986 of file dex.c.

                                                                                                                               {
    RzBinField *field = RZ_NEW0(RzBinField);
    if (!field) {
        return NULL;
    }
 
    ut64 access_flags = encoded_field->access_flags;
    if (is_static) {
        access_flags |= ACCESS_FLAG_STATIC;
    }
 
    field->vaddr = RZ_DEX_VIRT_ADDRESS + encoded_field->offset;
    field->paddr = encoded_field->offset;
    field->visibility = encoded_field->access_flags & UT32_MAX;
    field->visibility_str = rz_bin_dex_access_flags_readable(access_flags);
    field->name = dex_resolve_string_id(dex, field_id->name_idx);
    field->type = dex_resolve_type_id(dex, field_id->type_idx);
    field->flags = dex_access_flags_to_bin_flags(access_flags);
 
    return field;
}

References ACCESS_FLAG_STATIC, dex_encoded_field_t::access_flags, dex_access_flags_to_bin_flags(), dex_resolve_string_id(), dex_resolve_type_id(), field_id, rz_bin_field_t::flags, rz_bin_field_t::name, NULL, dex_encoded_field_t::offset, rz_bin_field_t::paddr, rz_bin_dex_access_flags_readable(), RZ_DEX_VIRT_ADDRESS, RZ_NEW0, rz_bin_field_t::type, UT32_MAX, ut64(), rz_bin_field_t::vaddr, rz_bin_field_t::visibility, and rz_bin_field_t::visibility_str.

Referenced by dex_resolve_fields_in_class().

dex_field_to_symbol()

static RzBinSymbol* dex_field_to_symbol ( RzBinDex *  dex, DexEncodedField *  encoded_field, DexFieldId *  field_id, bool  is_imported  )

static

Definition at line 1053 of file dex.c.

                                                                                                                               {
    RzBinSymbol *field = RZ_NEW0(RzBinSymbol);
    if (!field) {
        return NULL;
    }
 
    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 = dex_is_static(encoded_field->access_flags) ? RZ_BIN_BIND_GLOBAL_STR : RZ_BIN_BIND_LOCAL_STR;
    field->is_imported = false;
    field->visibility = encoded_field->access_flags & UT32_MAX;
    field->visibility_str = rz_bin_dex_access_flags_readable(encoded_field->access_flags);
    field->vaddr = RZ_DEX_VIRT_ADDRESS + encoded_field->offset;
    field->paddr = encoded_field->offset;
    field->ordinal = encoded_field->field_idx;
    field->method_flags = dex_access_flags_to_bin_flags(encoded_field->access_flags);
    field->type = RZ_BIN_TYPE_FIELD_STR;
 
    return field;
}

References dex_encoded_field_t::access_flags, rz_bin_symbol_t::bind, rz_bin_symbol_t::classname, dex_access_flags_to_bin_flags(), dex_is_static, dex_resolve_library(), dex_resolve_string_id(), dex_resolve_type_id(), field_id, dex_encoded_field_t::field_idx, rz_bin_symbol_t::is_imported, rz_bin_symbol_t::libname, rz_bin_symbol_t::method_flags, rz_bin_symbol_t::name, NULL, dex_encoded_field_t::offset, rz_bin_symbol_t::ordinal, rz_bin_symbol_t::paddr, RZ_BIN_BIND_GLOBAL_STR, RZ_BIN_BIND_LOCAL_STR, rz_bin_dex_access_flags_readable(), RZ_BIN_TYPE_FIELD_STR, RZ_DEX_VIRT_ADDRESS, RZ_NEW0, rz_bin_symbol_t::type, UT32_MAX, rz_bin_symbol_t::vaddr, rz_bin_symbol_t::visibility, and rz_bin_symbol_t::visibility_str.

Referenced by dex_resolve_fields_in_class_as_symbols().

dex_method_id_new()

static DexMethodId* dex_method_id_new ( RzBuffer *  buf, ut64  offset  )

static

Definition at line 166 of file dex.c.

                                                                  {
    DexMethodId *method_id = RZ_NEW0(DexMethodId);
    if (!method_id) {
        return NULL;
    }
 
    read_le16_or_fail(buf, method_id->class_idx, dex_method_id_new_fail);
    read_le16_or_fail(buf, method_id->proto_idx, dex_method_id_new_fail);
    read_le32_or_fail(buf, method_id->name_idx, dex_method_id_new_fail);
    method_id->offset = offset;
    return method_id;
 
dex_method_id_new_fail:
    free(method_id);
    return NULL;
}

References dex_method_id_t::class_idx, free(), dex_method_id_t::name_idx, NULL, dex_method_id_t::offset, dex_method_id_t::proto_idx, read_le16_or_fail, read_le32_or_fail, and RZ_NEW0.

Referenced by dex_parse().

dex_method_to_symbol()

static RzBinSymbol* dex_method_to_symbol ( RzBinDex *  dex, DexEncodedMethod *  encoded_method, DexMethodId *  method_id, bool  is_imported  )

static

Definition at line 909 of file dex.c.

                                                                                                                                    {
    RzBinSymbol *symbol = RZ_NEW0(RzBinSymbol);
    if (!symbol) {
        return NULL;
    }
 
    bool varargs = dex_is_varargs(encoded_method->access_flags);
    symbol->name = dex_resolve_string_id(dex, method_id->name_idx);
    symbol->classname = dex_resolve_type_id(dex, method_id->class_idx);
    symbol->libname = dex_resolve_library(symbol->classname);
    symbol->dname = dex_resolve_proto_id(dex, symbol->name, method_id->proto_idx, varargs);
    symbol->bind = dex_is_static(encoded_method->access_flags) ? RZ_BIN_BIND_GLOBAL_STR : RZ_BIN_BIND_LOCAL_STR;
    symbol->is_imported = is_imported;
    symbol->visibility = encoded_method->access_flags & UT32_MAX;
    symbol->visibility_str = rz_bin_dex_access_flags_readable(symbol->visibility);
    symbol->size = encoded_method->code_size;
    if (encoded_method->code_offset < RZ_DEX_RELOC_ADDRESS) {
        symbol->vaddr = RZ_DEX_VIRT_ADDRESS + encoded_method->code_offset;
        symbol->paddr = encoded_method->code_offset;
    } else {
        symbol->vaddr = encoded_method->code_offset;
        symbol->paddr = 0;
    }
    symbol->ordinal = encoded_method->method_idx;
    symbol->method_flags = dex_access_flags_to_bin_flags(encoded_method->access_flags);
    symbol->type = RZ_BIN_TYPE_METH_STR;
 
    return symbol;
}

References dex_encoded_method_t::access_flags, rz_bin_symbol_t::bind, dex_method_id_t::class_idx, rz_bin_symbol_t::classname, dex_encoded_method_t::code_offset, dex_encoded_method_t::code_size, dex_access_flags_to_bin_flags(), dex_is_static, dex_is_varargs, dex_resolve_library(), dex_resolve_proto_id(), dex_resolve_string_id(), dex_resolve_type_id(), rz_bin_symbol_t::dname, rz_bin_symbol_t::is_imported, rz_bin_symbol_t::libname, rz_bin_symbol_t::method_flags, dex_encoded_method_t::method_idx, rz_bin_symbol_t::name, dex_method_id_t::name_idx, NULL, rz_bin_symbol_t::ordinal, rz_bin_symbol_t::paddr, dex_method_id_t::proto_idx, RZ_BIN_BIND_GLOBAL_STR, RZ_BIN_BIND_LOCAL_STR, rz_bin_dex_access_flags_readable(), RZ_BIN_TYPE_METH_STR, RZ_DEX_RELOC_ADDRESS, RZ_DEX_VIRT_ADDRESS, RZ_NEW0, rz_bin_symbol_t::size, rz_bin_symbol_t::type, UT32_MAX, rz_bin_symbol_t::vaddr, rz_bin_symbol_t::visibility, and rz_bin_symbol_t::visibility_str.

Referenced by dex_resolve_methods_in_class().

dex_new_encoded_field()

static DexEncodedField* dex_new_encoded_field ( RzBuffer *  buf, ut64  base, ut64 *  diff_value_prev, bool  first  )

static

Definition at line 195 of file dex.c.

                                                                                                           {
    DexEncodedField *encoded_field = RZ_NEW0(DexEncodedField);
    if (!encoded_field) {
        return NULL;
    }
    ut64 diff_value = 0;
 
    encoded_field->offset = rz_buf_tell(buf) + base;
    rz_buf_uleb128(buf, &diff_value);
    rz_buf_uleb128(buf, &encoded_field->access_flags);
 
    if (first) {
        encoded_field->field_idx = diff_value;
        *diff_value_prev = diff_value;
    } else {
        encoded_field->field_idx = *diff_value_prev + diff_value;
        *diff_value_prev = encoded_field->field_idx;
    }
    return encoded_field;
}

References dex_encoded_field_t::access_flags, dex_encoded_field_t::field_idx, NULL, dex_encoded_field_t::offset, rz_buf_tell(), rz_buf_uleb128(), RZ_NEW0, and ut64().

Referenced by dex_class_def_new().

dex_new_encoded_method()

static DexEncodedMethod* dex_new_encoded_method ( RzBuffer *  buf, ut64  base, ut64 *  diff_value_prev, bool  first, RzPVector *  method_ids  )

static

Definition at line 216 of file dex.c.

                                                                                                                                    {
    DexEncodedMethod *encoded_method = RZ_NEW0(DexEncodedMethod);
    if (!encoded_method) {
        return NULL;
    }
    ut64 diff_value = 0;
    ut64 code_offset = 0;
 
    encoded_method->offset = rz_buf_tell(buf) + base;
    rz_buf_uleb128(buf, &diff_value);
    rz_buf_uleb128(buf, &encoded_method->access_flags);
    rz_buf_uleb128(buf, &code_offset);
 
    if (first) {
        encoded_method->method_idx = diff_value;
        *diff_value_prev = diff_value;
    } else {
        encoded_method->method_idx = *diff_value_prev + diff_value;
        *diff_value_prev = encoded_method->method_idx;
    }
 
    if (code_offset > 0) {
        read_le16_at_or_fail(buf, encoded_method->registers_size, code_offset, dex_new_encoded_method_fail);
        read_le16_at_or_fail(buf, encoded_method->ins_size, code_offset + 2, dex_new_encoded_method_fail);
        read_le16_at_or_fail(buf, encoded_method->outs_size, code_offset + 4, dex_new_encoded_method_fail);
        read_le16_at_or_fail(buf, encoded_method->tries_size, code_offset + 6, dex_new_encoded_method_fail);
        read_le32_at_or_fail(buf, encoded_method->debug_info_offset, code_offset + 8, dex_new_encoded_method_fail);
        read_le32_at_or_fail(buf, encoded_method->code_size, code_offset + 12, dex_new_encoded_method_fail);
        encoded_method->code_size *= sizeof(ut16); // code ushort[insns_size]
        encoded_method->code_offset = code_offset + 16 + base;
 
        if (encoded_method->method_idx < rz_pvector_len(method_ids)) {
            DexMethodId *method_id = (DexMethodId *)rz_pvector_at(method_ids, encoded_method->method_idx);
            if (method_id) {
                method_id->code_offset = encoded_method->code_offset;
                method_id->code_size = encoded_method->code_size;
            }
        }
    }
    return encoded_method;
 
dex_new_encoded_method_fail:
    free(encoded_method);
    return NULL;
}

References dex_encoded_method_t::access_flags, dex_method_id_t::code_offset, dex_encoded_method_t::code_offset, dex_method_id_t::code_size, dex_encoded_method_t::code_size, dex_encoded_method_t::debug_info_offset, free(), dex_encoded_method_t::ins_size, dex_encoded_method_t::method_idx, NULL, dex_encoded_method_t::offset, dex_encoded_method_t::outs_size, read_le16_at_or_fail, read_le32_at_or_fail, dex_encoded_method_t::registers_size, rz_buf_tell(), rz_buf_uleb128(), RZ_NEW0, rz_pvector_at(), rz_pvector_len(), dex_encoded_method_t::tries_size, and ut64().

Referenced by dex_class_def_new().

dex_parse()

static bool dex_parse ( RzBinDex *  dex, ut64  base, RzBuffer *  buf  )

static

Definition at line 479 of file dex.c.

                                                               {
    ut64 offset = 0;
    st64 read = 0;
    st64 buffer_size = rz_buf_size(buf);
    if (buffer_size < 116) {
        // 116 bytes is the smalled dex that can be built.
        RZ_LOG_ERROR("dex bin: invalid buffer size (size < 116)\n");
        goto dex_parse_bad;
    }
 
    dex->header_offset = base;
    dex->relocs_offset = base + RZ_DEX_RELOC_ADDRESS;
    rz_buf_read(buf, dex->magic, sizeof(dex->magic));
    rz_buf_read(buf, dex->version, sizeof(dex->version));
    dex->checksum_offset = rz_buf_tell(buf) + base;
    read_le32_or_fail(buf, dex->checksum, dex_parse_bad);
    dex->signature_offset = rz_buf_tell(buf) + base;
    rz_buf_read(buf, dex->signature, sizeof(dex->signature));
    read_le32_or_fail(buf, dex->file_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->header_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->endian_tag, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->link_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->link_offset, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->map_offset, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->string_ids_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->string_ids_offset, dex_parse_bad);
    // string_ids points to an array of offsets.
    dex_fail_if_bad_ids(dex->string_ids, sizeof(ut32), buffer_size, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->type_ids_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->type_ids_offset, dex_parse_bad);
    dex_fail_if_bad_ids(dex->type_ids, DEX_TYPE_ID_SIZE, buffer_size, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->proto_ids_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->proto_ids_offset, dex_parse_bad);
    dex_fail_if_bad_ids(dex->proto_ids, DEX_PROTO_ID_SIZE, buffer_size, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->field_ids_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->field_ids_offset, dex_parse_bad);
    dex_fail_if_bad_ids(dex->field_ids, DEX_FIELD_ID_SIZE, buffer_size, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->method_ids_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->method_ids_offset, dex_parse_bad);
    dex_fail_if_bad_ids(dex->method_ids, DEX_METHOD_ID_SIZE, buffer_size, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->class_defs_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->class_defs_offset, dex_parse_bad);
 
    read_le32_or_fail(buf, dex->data_size, dex_parse_bad);
    read_le32_or_fail(buf, dex->data_offset, dex_parse_bad);
 
    /* Strings */
    offset = dex->string_ids_offset;
    if (!rz_pvector_reserve(dex->strings, dex->string_ids_size)) {
        goto dex_parse_bad;
    }
    for (ut32 i = 0; i < dex->string_ids_size; ++i, offset += sizeof(ut32)) {
        ut32 string_offset = 0;
        read_le32_at_or_fail(buf, string_offset, offset, dex_parse_bad);
 
        if (rz_buf_seek(buf, string_offset, RZ_BUF_SET) < 0) {
            goto dex_parse_bad;
        }
        DexString *string = dex_string_new(buf, base + string_offset, &read);
        if (!string) {
            goto dex_parse_bad;
        }
        rz_pvector_push(dex->strings, string);
    }
 
    /* Type Ids */
    dex->types = RZ_NEWS0(DexTypeId, dex->type_ids_size);
    if (!dex->types) {
        goto dex_parse_bad;
    }
    if (rz_buf_seek(buf, dex->type_ids_offset, RZ_BUF_SET) < 0) {
        goto dex_parse_bad;
    }
    for (ut32 i = 0; i < dex->type_ids_size; ++i) {
        read_le32_or_fail(buf, dex->types[i], dex_parse_bad);
    }
 
    /* Proto Ids */
    offset = dex->proto_ids_offset;
    if (!rz_pvector_reserve(dex->proto_ids, dex->proto_ids_size)) {
        goto dex_parse_bad;
    }
    for (ut32 i = 0; i < dex->proto_ids_size; ++i, offset += DEX_PROTO_ID_SIZE) {
        if (rz_buf_seek(buf, offset, RZ_BUF_SET) < 0) {
            goto dex_parse_bad;
        }
        DexProtoId *proto_id = dex_proto_id_new(buf, base + offset);
        if (!proto_id) {
            goto dex_parse_bad;
        }
        rz_pvector_push(dex->proto_ids, proto_id);
    }
 
    /* Field Ids */
    offset = dex->field_ids_offset;
    if (!rz_pvector_reserve(dex->field_ids, dex->field_ids_size)) {
        goto dex_parse_bad;
    }
    for (ut32 i = 0; i < dex->field_ids_size; ++i, offset += DEX_FIELD_ID_SIZE) {
        if (rz_buf_seek(buf, offset, RZ_BUF_SET) < 0) {
            goto dex_parse_bad;
        }
        DexFieldId *field_id = dex_field_id_new(buf, base + offset);
        if (!field_id) {
            goto dex_parse_bad;
        }
        rz_pvector_push(dex->field_ids, field_id);
    }
 
    /* Method Ids */
    offset = dex->method_ids_offset;
    if (!rz_pvector_reserve(dex->method_ids, dex->method_ids_size)) {
        goto dex_parse_bad;
    }
    for (ut32 i = 0; i < dex->method_ids_size; ++i, offset += DEX_METHOD_ID_SIZE) {
        if (rz_buf_seek(buf, offset, RZ_BUF_SET) < 0) {
            goto dex_parse_bad;
        }
        DexMethodId *method_id = dex_method_id_new(buf, base + offset);
        if (!method_id) {
            goto dex_parse_bad;
        }
        rz_pvector_push(dex->method_ids, method_id);
    }
 
    /* Class Defs */
    offset = dex->class_defs_offset;
    if (!rz_pvector_reserve(dex->class_defs, dex->class_defs_size)) {
        goto dex_parse_bad;
    }
    for (ut32 i = 0; i < dex->class_defs_size; ++i, offset += DEX_CLASS_DEF_SIZE) {
        if (rz_buf_seek(buf, offset, RZ_BUF_SET) < 0) {
            goto dex_parse_bad;
        }
        DexClassDef *class_def = dex_class_def_new(buf, base + offset, base, dex->method_ids);
        if (!class_def) {
            goto dex_parse_bad;
        }
        rz_pvector_push(dex->class_defs, class_def);
    }
 
    /* Resolve all virtual methods */
    dex_resolve_all_virtual_methods(dex);
 
    /* generate relocation code buffer this buffer will contain a
     * sequence of 0e00, i.e 'return-void', which will be used to
     * resolve imports for the xrefs.
     */
    if (!dex_create_relocations(dex)) {
        goto dex_parse_bad;
    }
 
    return true;
 
dex_parse_bad:
    rz_bin_dex_free(dex);
    return false;
}

References buffer_size, dex_t::checksum, dex_t::checksum_offset, dex_t::class_defs, dex_t::class_defs_offset, dex_t::class_defs_size, dex_t::data_offset, dex_t::data_size, dex_class_def_new(), DEX_CLASS_DEF_SIZE, dex_create_relocations(), dex_fail_if_bad_ids, dex_field_id_new(), DEX_FIELD_ID_SIZE, dex_method_id_new(), DEX_METHOD_ID_SIZE, dex_proto_id_new(), DEX_PROTO_ID_SIZE, dex_resolve_all_virtual_methods(), dex_string_new(), DEX_TYPE_ID_SIZE, dex_t::endian_tag, field_id, dex_t::field_ids, dex_t::field_ids_offset, dex_t::field_ids_size, dex_t::file_size, dex_t::header_offset, dex_t::header_size, i, dex_t::link_offset, dex_t::link_size, dex_t::magic, dex_t::map_offset, dex_t::method_ids, dex_t::method_ids_offset, dex_t::method_ids_size, dex_t::proto_ids, dex_t::proto_ids_offset, dex_t::proto_ids_size, read(), read_le32_at_or_fail, read_le32_or_fail, dex_t::relocs_offset, rz_bin_dex_free(), rz_buf_read(), rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), RZ_DEX_RELOC_ADDRESS, RZ_LOG_ERROR, RZ_NEWS0, rz_pvector_push(), rz_pvector_reserve(), dex_t::signature, dex_t::signature_offset, st64, dex_t::string_ids_offset, dex_t::string_ids_size, dex_t::strings, dex_t::type_ids_offset, dex_t::type_ids_size, dex_t::types, ut64(), and dex_t::version.

Referenced by rz_bin_dex_new().

dex_proto_id_free()

static void dex_proto_id_free ( DexProtoId *  string )

static

Definition at line 104 of file dex.c.

                                                  {
    if (!string) {
        return;
    }
    free(string->type_list);
    free(string);
}

References free(), and dex_proto_id_t::type_list.

Referenced by rz_bin_dex_new().

dex_proto_id_new()

static DexProtoId* dex_proto_id_new ( RzBuffer *  buf, ut64  offset  )

static

Definition at line 112 of file dex.c.

                                                                {
    DexProtoId *proto_id = RZ_NEW0(DexProtoId);
    if (!proto_id) {
        return NULL;
    }
 
    ut32 parameters_offset = 0;
    proto_id->offset = offset;
    read_le32_or_fail(buf, proto_id->shorty_idx, dex_proto_id_new_fail);
    read_le32_or_fail(buf, proto_id->return_type_idx, dex_proto_id_new_fail);
 
    read_le32_or_fail(buf, parameters_offset, dex_proto_id_new_fail);
    if (parameters_offset > 0) {
        ut32 count = 0;
        read_le32_at_or_fail(buf, count, parameters_offset, dex_proto_id_new_fail);
 
        proto_id->type_list_size = count;
        proto_id->type_list = RZ_NEWS(ut16, count);
        if (!proto_id->type_list) {
            goto dex_proto_id_new_fail;
        }
 
        parameters_offset += sizeof(ut32);
        for (ut32 i = 0; i < count; ++i, parameters_offset += sizeof(ut16)) {
            read_le16_at_or_fail(buf, proto_id->type_list[i], parameters_offset, dex_proto_id_new_fail);
        }
    }
 
    return proto_id;
 
dex_proto_id_new_fail:
    free(proto_id);
    return NULL;
}

References count, free(), i, NULL, dex_proto_id_t::offset, read_le16_at_or_fail, read_le32_at_or_fail, read_le32_or_fail, dex_proto_id_t::return_type_idx, RZ_NEW0, RZ_NEWS, dex_proto_id_t::shorty_idx, dex_proto_id_t::type_list, and dex_proto_id_t::type_list_size.

Referenced by dex_parse().

dex_resolve_all_virtual_methods()

static void dex_resolve_all_virtual_methods ( RzBinDex *  dex )

static

Definition at line 377 of file dex.c.

                                                           {
    DexClassDef *class_def;
    DexMethodId *method_id = NULL;
    void **it;
    dex->relocs_size = 0;
    rz_pvector_foreach (dex->method_ids, it) {
        method_id = (DexMethodId *)*it;
        if (method_id->code_offset ||
            method_id->class_idx >= rz_pvector_len(dex->class_defs)) {
            continue;
        }
        class_def = rz_pvector_at(dex->class_defs, method_id->class_idx);
        dex_resolve_virtual_method_code(dex, method_id, class_def->superclass_idx);
    }
}

References dex_t::class_defs, dex_method_id_t::class_idx, dex_method_id_t::code_offset, dex_resolve_virtual_method_code(), dex_t::method_ids, NULL, dex_t::relocs_size, rz_pvector_at(), rz_pvector_foreach, rz_pvector_len(), and dex_class_def_t::superclass_idx.

Referenced by dex_parse().

dex_resolve_entrypoints_in_class()

static RzList* dex_resolve_entrypoints_in_class ( RzBinDex *  dex, DexClassDef *  class_def  )

static

Definition at line 1693 of file dex.c.

                                                                                         {
    RzListIter *it;
    DexEncodedMethod *encoded_method = NULL;
    RzList *entrypoints = NULL;
 
    entrypoints = rz_list_newf((RzListFree)free);
    if (!entrypoints) {
        return NULL;
    }
 
    rz_list_foreach (class_def->direct_methods, it, encoded_method) {
        if (!dex_is_static(encoded_method->access_flags)) {
            // entrypoints are static
            continue;
        }
 
        if (encoded_method->method_idx >= rz_pvector_len(dex->method_ids)) {
            RZ_LOG_INFO("cannot find direct method with index %" PFMT64u "\n", encoded_method->method_idx);
            continue;
        }
        DexMethodId *method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
 
        char *name = dex_resolve_string_id(dex, method_id->name_idx);
        if (!name) {
            continue;
        }
 
        if (strcmp(name, "main") != 0 && strcmp(name, "<init>") != 0 && strcmp(name, "<clinit>") != 0) {
            free(name);
            continue;
        }
        free(name);
 
        RzBinAddr *entrypoint = RZ_NEW0(RzBinAddr);
        if (!entrypoint) {
            break;
        }
        if (encoded_method->code_offset < RZ_DEX_RELOC_ADDRESS) {
            entrypoint->vaddr = RZ_DEX_VIRT_ADDRESS + encoded_method->code_offset;
            entrypoint->paddr = encoded_method->code_offset;
        } else {
            entrypoint->vaddr = encoded_method->code_offset;
            entrypoint->paddr = 0;
        }
        if (entrypoint && !rz_list_append(entrypoints, entrypoint)) {
            free(entrypoint);
        }
    }
 
    rz_list_foreach (class_def->virtual_methods, it, encoded_method) {
        if (!dex_is_static(encoded_method->access_flags)) {
            // entrypoints are static
            continue;
        }
 
        if (encoded_method->method_idx >= rz_pvector_len(dex->method_ids)) {
            RZ_LOG_INFO("cannot find virtual method with index %" PFMT64u "\n", encoded_method->method_idx);
            continue;
        }
 
        DexMethodId *method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
        if (method_id->code_offset < 1) {
            // if there is no code, skip
            continue;
        }
 
        char *name = dex_resolve_string_id(dex, method_id->name_idx);
        if (!name) {
            continue;
        }
 
        if (strcmp(name, "main") != 0 && strcmp(name, "<init>") != 0 && strcmp(name, "<clinit>") != 0) {
            free(name);
            continue;
        }
        free(name);
 
        RzBinAddr *entrypoint = RZ_NEW0(RzBinAddr);
        if (!entrypoint) {
            break;
        }
        if (encoded_method->code_offset < RZ_DEX_RELOC_ADDRESS) {
            entrypoint->vaddr = RZ_DEX_VIRT_ADDRESS + encoded_method->code_offset;
            entrypoint->paddr = encoded_method->code_offset;
        } else {
            entrypoint->vaddr = encoded_method->code_offset;
            entrypoint->paddr = 0;
        }
        if (entrypoint && !rz_list_append(entrypoints, entrypoint)) {
            free(entrypoint);
        }
    }
 
    return entrypoints;
}

References dex_encoded_method_t::access_flags, dex_method_id_t::code_offset, dex_encoded_method_t::code_offset, dex_is_static, dex_resolve_string_id(), dex_class_def_t::direct_methods, entrypoints(), free(), dex_t::method_ids, dex_encoded_method_t::method_idx, dex_method_id_t::name_idx, NULL, rz_bin_addr_t::paddr, PFMT64u, RZ_DEX_RELOC_ADDRESS, RZ_DEX_VIRT_ADDRESS, rz_list_append(), rz_list_newf(), RZ_LOG_INFO, RZ_NEW0, rz_pvector_at(), rz_pvector_len(), rz_bin_addr_t::vaddr, and dex_class_def_t::virtual_methods.

Referenced by rz_bin_dex_entrypoints().

dex_resolve_fields_in_class()

static RzList* dex_resolve_fields_in_class ( RzBinDex *  dex, DexClassDef *  class_def, ut8 *  inserted  )

static

Definition at line 1008 of file dex.c.

                                                                                                   {
    RzList *fields = rz_list_newf((RzListFree)rz_bin_field_free);
    if (!fields) {
        return NULL;
    }
    DexFieldId *field_id = NULL;
    DexEncodedField *encoded_field = NULL;
    RzListIter *it = NULL;
 
    rz_list_foreach (class_def->static_fields, it, encoded_field) {
        if (encoded_field->field_idx >= rz_pvector_len(dex->field_ids)) {
            RZ_LOG_INFO("cannot find static field with index %" PFMT64u "\n", encoded_field->field_idx);
            continue;
        } else if (inserted[encoded_field->field_idx]) {
            continue;
        }
        inserted[encoded_field->field_idx] = true;
        field_id = (DexFieldId *)rz_pvector_at(dex->field_ids, encoded_field->field_idx);
 
        RzBinField *field = dex_field_to_bin_field(dex, encoded_field, field_id, true);
        if (!field || !rz_list_append(fields, field)) {
            rz_bin_field_free(field);
            break;
        }
    }
 
    rz_list_foreach (class_def->instance_fields, it, encoded_field) {
        if (encoded_field->field_idx >= rz_pvector_len(dex->field_ids)) {
            RZ_LOG_INFO("cannot find instance field with index %" PFMT64u "\n", encoded_field->field_idx);
            continue;
        } else if (inserted[encoded_field->field_idx]) {
            continue;
        }
        inserted[encoded_field->field_idx] = true;
        field_id = (DexFieldId *)rz_pvector_at(dex->field_ids, encoded_field->field_idx);
 
        RzBinField *field = dex_field_to_bin_field(dex, encoded_field, field_id, false);
        if (!field || !rz_list_append(fields, field)) {
            rz_bin_field_free(field);
            break;
        }
    }
    return fields;
}

References dex_field_to_bin_field(), field_id, dex_t::field_ids, dex_encoded_field_t::field_idx, fields, dex_class_def_t::instance_fields, NULL, PFMT64u, rz_bin_field_free(), rz_list_append(), rz_list_newf(), RZ_LOG_INFO, rz_pvector_at(), rz_pvector_len(), and dex_class_def_t::static_fields.

Referenced by rz_bin_dex_classes(), and rz_bin_dex_fields().

dex_resolve_fields_in_class_as_symbols()

static RzList* dex_resolve_fields_in_class_as_symbols ( RzBinDex *  dex, DexClassDef *  class_def, ut8 *  inserted  )

static

Definition at line 1075 of file dex.c.

                                                                                                              {
    RzList *fields = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!fields) {
        return NULL;
    }
    DexFieldId *field_id = NULL;
    DexEncodedField *encoded_field = NULL;
    RzListIter *it = NULL;
 
    rz_list_foreach (class_def->static_fields, it, encoded_field) {
        if (encoded_field->field_idx >= rz_pvector_len(dex->field_ids)) {
            RZ_LOG_INFO("cannot find static field with index %" PFMT64u "\n", encoded_field->field_idx);
            continue;
        }
        field_id = (DexFieldId *)rz_pvector_at(dex->field_ids, encoded_field->field_idx);
        inserted[encoded_field->field_idx] = true;
 
        RzBinSymbol *field = dex_field_to_symbol(dex, encoded_field, field_id, false);
        if (!field || !rz_list_append(fields, field)) {
            rz_bin_symbol_free(field);
            break;
        }
    }
 
    rz_list_foreach (class_def->instance_fields, it, encoded_field) {
        if (encoded_field->field_idx >= rz_pvector_len(dex->field_ids)) {
            RZ_LOG_INFO("cannot find instance field with index %" PFMT64u "\n", encoded_field->field_idx);
            continue;
        }
        field_id = (DexFieldId *)rz_pvector_at(dex->field_ids, encoded_field->field_idx);
        inserted[encoded_field->field_idx] = true;
 
        RzBinSymbol *field = dex_field_to_symbol(dex, encoded_field, field_id, false);
        if (!field || !rz_list_append(fields, field)) {
            rz_bin_symbol_free(field);
            break;
        }
    }
    return fields;
}

References dex_field_to_symbol(), field_id, dex_t::field_ids, dex_encoded_field_t::field_idx, fields, dex_class_def_t::instance_fields, NULL, PFMT64u, rz_bin_symbol_free(), rz_list_append(), rz_list_newf(), RZ_LOG_INFO, rz_pvector_at(), rz_pvector_len(), and dex_class_def_t::static_fields.

Referenced by rz_bin_dex_symbols().

dex_resolve_library()

static char* dex_resolve_library ( const char *  library )

static

Definition at line 899 of file dex.c.

                                                      {
    if (!library || library[0] != 'L') {
        return NULL;
    }
    char *demangled = strdup(library + 1);
    rz_str_replace_ch(demangled, '/', '.', 1);
    demangled[strlen(demangled) - 1] = 0;
    return demangled;
}

References NULL, rz_str_replace_ch(), and strdup().

Referenced by dex_field_to_symbol(), dex_method_to_symbol(), and rz_bin_dex_symbols().

dex_resolve_methods_in_class()

static RzList* dex_resolve_methods_in_class ( RzBinDex *  dex, DexClassDef *  class_def, ut8 *  inserted  )

static

Definition at line 939 of file dex.c.

                                                                                                    {
    RzList *methods = rz_list_newf((RzListFree)rz_bin_symbol_free);
    if (!methods) {
        return NULL;
    }
 
    DexMethodId *method_id = NULL;
    DexEncodedMethod *encoded_method = NULL;
    RzListIter *it = NULL;
 
    rz_list_foreach (class_def->direct_methods, it, encoded_method) {
        if (encoded_method->method_idx >= rz_pvector_len(dex->method_ids)) {
            RZ_LOG_INFO("cannot find direct method with index %" PFMT64u "\n", encoded_method->method_idx);
            continue;
        } else if (inserted[encoded_method->method_idx]) {
            continue;
        }
        method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
        inserted[encoded_method->method_idx] = true;
 
        RzBinSymbol *symbol = dex_method_to_symbol(dex, encoded_method, method_id, false);
        if (!symbol || !rz_list_append(methods, symbol)) {
            rz_bin_symbol_free(symbol);
            break;
        }
    }
 
    rz_list_foreach (class_def->virtual_methods, it, encoded_method) {
        if (encoded_method->method_idx >= rz_pvector_len(dex->method_ids)) {
            RZ_LOG_INFO("cannot find virtual method with index %" PFMT64u "\n", encoded_method->method_idx);
            continue;
        } else if (inserted[encoded_method->method_idx]) {
            continue;
        }
        method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
        inserted[encoded_method->method_idx] = true;
 
        RzBinSymbol *symbol = dex_method_to_symbol(dex, encoded_method, method_id, false);
        if (!symbol || !rz_list_append(methods, symbol)) {
            rz_bin_symbol_free(symbol);
            break;
        }
    }
 
    return methods;
}

References dex_method_to_symbol(), dex_class_def_t::direct_methods, dex_t::method_ids, dex_encoded_method_t::method_idx, NULL, PFMT64u, rz_bin_symbol_free(), rz_list_append(), rz_list_newf(), RZ_LOG_INFO, rz_pvector_at(), rz_pvector_len(), and dex_class_def_t::virtual_methods.

Referenced by rz_bin_dex_classes(), and rz_bin_dex_symbols().

dex_resolve_proto_id()

static char* dex_resolve_proto_id ( RzBinDex *  dex, const char *  name, ut32  proto_idx, bool  varargs  )

static

Definition at line 792 of file dex.c.

                                                                                                 {
    if (proto_idx >= rz_pvector_len(dex->proto_ids)) {
        RZ_LOG_INFO("cannot find proto_id with index %u\n", proto_idx);
        return NULL;
    }
 
    DexProtoId *proto_id = (DexProtoId *)rz_pvector_at(dex->proto_ids, proto_idx);
    if (proto_id->return_type_idx >= dex->type_ids_size) {
        RZ_LOG_INFO("cannot find return type id with index %u\n", proto_id->return_type_idx);
        return NULL;
    }
 
    RzStrBuf *sb = rz_strbuf_new(name);
    if (!sb) {
        return NULL;
    }
 
    const DexString *return_type = dex_resolve_string_id_native(dex, dex->types[proto_id->return_type_idx]);
    if (!return_type) {
        RZ_LOG_INFO("cannot find return type string with index %u\n", proto_id->return_type_idx);
        rz_strbuf_free(sb);
        return NULL;
    }
 
    rz_strbuf_append(sb, "(");
    for (ut32 i = 0; i < proto_id->type_list_size; ++i) {
        ut32 type_idx = proto_id->type_list[i];
 
        const DexString *param = dex_resolve_string_id_native(dex, dex->types[type_idx]);
        if (!param) {
            RZ_LOG_INFO("cannot find param string with index %d\n", dex->types[type_idx]);
            rz_strbuf_free(sb);
            return NULL;
        }
        if (varargs && (i + 1) >= proto_id->type_list_size) {
            rz_strbuf_append(sb, "...");
        }
        rz_strbuf_append_n(sb, param->data, param->size);
    }
    rz_strbuf_append(sb, ")");
    rz_strbuf_append_n(sb, return_type->data, return_type->size);
    return rz_strbuf_drain(sb);
}

References dex_string_t::data, dex_resolve_string_id_native(), i, NULL, dex_t::proto_ids, dex_proto_id_t::return_type_idx, RZ_LOG_INFO, rz_pvector_at(), rz_pvector_len(), rz_strbuf_append(), rz_strbuf_append_n(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), sb, dex_string_t::size, dex_t::type_ids_size, dex_proto_id_t::type_list, dex_proto_id_t::type_list_size, and dex_t::types.

Referenced by dex_method_to_symbol(), rz_bin_dex_imports(), rz_bin_dex_resolve_method_by_idx(), rz_bin_dex_resolve_proto_by_idx(), and rz_bin_dex_symbols().

dex_resolve_string_id()

static char* dex_resolve_string_id ( RzBinDex *  dex, ut32  string_idx  )

static

Definition at line 774 of file dex.c.

                                                                   {
    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 NULL;
    }
    return rz_str_ndup(string->data, string->size);
}

References dex_string_t::data, dex_resolve_string_id_native(), NULL, RZ_LOG_INFO, rz_str_ndup(), and dex_string_t::size.

Referenced by dex_field_to_bin_field(), dex_field_to_symbol(), dex_method_to_symbol(), dex_resolve_entrypoints_in_class(), dex_resolve_symbol_in_class_methods(), dex_resolve_type_id(), rz_bin_dex_imports(), rz_bin_dex_resolve_field_by_idx(), rz_bin_dex_resolve_method_by_idx(), rz_bin_dex_resolve_string_by_idx(), and rz_bin_dex_symbols().

dex_resolve_string_id_native()

static DexString* dex_resolve_string_id_native ( RzBinDex *  dex, ut32  string_idx  )

inlinestatic

Definition at line 767 of file dex.c.

                                                                                      {
    if (string_idx >= rz_pvector_len(dex->strings)) {
        return NULL;
    }
    return (DexString *)rz_pvector_at(dex->strings, string_idx);
}

References NULL, rz_pvector_at(), rz_pvector_len(), and dex_t::strings.

Referenced by dex_resolve_proto_id(), dex_resolve_string_id(), and rz_bin_dex_resolve_string_offset_by_idx().

dex_resolve_symbol_in_class_methods()

static bool dex_resolve_symbol_in_class_methods ( RzBinDex *  dex, DexClassDef *  class_def, RzBinSpecialSymbol  resolve, ut64 *  paddr, ut64 *  vaddr  )

static

Definition at line 1594 of file dex.c.

                                                                                                                                             {
    RzListIter *it;
    DexEncodedMethod *encoded_method = NULL;
 
    rz_list_foreach (class_def->direct_methods, it, encoded_method) {
        if (encoded_method->method_idx >= rz_pvector_len(dex->method_ids)) {
            RZ_LOG_INFO("cannot find virtual method with index %" PFMT64u "\n", encoded_method->method_idx);
            continue;
        }
        DexMethodId *method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
 
        char *name = dex_resolve_string_id(dex, method_id->name_idx);
        if (!name) {
            continue;
        }
        if (resolve == RZ_BIN_SPECIAL_SYMBOL_ENTRY || resolve == RZ_BIN_SPECIAL_SYMBOL_INIT) {
            if (strcmp(name, "<init>") != 0 && strcmp(name, "<clinit>") != 0) {
                free(name);
                continue;
            }
        } else if (resolve == RZ_BIN_SPECIAL_SYMBOL_MAIN) {
            if (strcmp(name, "main") != 0) {
                free(name);
                continue;
            }
        }
        free(name);
        if (method_id->code_offset < RZ_DEX_RELOC_ADDRESS) {
            *vaddr = RZ_DEX_VIRT_ADDRESS + encoded_method->code_offset;
            *paddr = method_id->code_offset;
        } else {
            *vaddr = encoded_method->code_offset;
            *paddr = 0;
        }
        return true;
    }
 
    rz_list_foreach (class_def->virtual_methods, it, encoded_method) {
        if (encoded_method->method_idx >= rz_pvector_len(dex->method_ids)) {
            RZ_LOG_INFO("cannot find direct method with index %" PFMT64u "\n", encoded_method->method_idx);
            continue;
        }
        DexMethodId *method_id = (DexMethodId *)rz_pvector_at(dex->method_ids, encoded_method->method_idx);
 
        char *name = dex_resolve_string_id(dex, method_id->name_idx);
        if (!name) {
            continue;
        }
        if (resolve == RZ_BIN_SPECIAL_SYMBOL_ENTRY || resolve == RZ_BIN_SPECIAL_SYMBOL_INIT) {
            if (strcmp(name, "<init>") != 0 && strcmp(name, "<clinit>") != 0) {
                free(name);
                continue;
            }
        } else if (resolve == RZ_BIN_SPECIAL_SYMBOL_MAIN) {
            if (strcmp(name, "main") != 0) {
                free(name);
                continue;
            }
        }
        free(name);
 
        if (method_id->code_offset < RZ_DEX_RELOC_ADDRESS) {
            *vaddr = RZ_DEX_VIRT_ADDRESS + encoded_method->code_offset;
            *paddr = method_id->code_offset;
        } else {
            *vaddr = encoded_method->code_offset;
            *paddr = 0;
        }
        return true;
    }
    return false;
}

References dex_method_id_t::code_offset, dex_encoded_method_t::code_offset, dex_resolve_string_id(), dex_class_def_t::direct_methods, free(), dex_t::method_ids, dex_encoded_method_t::method_idx, dex_method_id_t::name_idx, NULL, PFMT64u, resolve(), RZ_BIN_SPECIAL_SYMBOL_ENTRY, RZ_BIN_SPECIAL_SYMBOL_INIT, RZ_BIN_SPECIAL_SYMBOL_MAIN, RZ_DEX_RELOC_ADDRESS, RZ_DEX_VIRT_ADDRESS, RZ_LOG_INFO, rz_pvector_at(), rz_pvector_len(), and dex_class_def_t::virtual_methods.

Referenced by rz_bin_dex_resolve_symbol().

dex_resolve_type_id()

static char* dex_resolve_type_id ( RzBinDex *  dex, ut32  type_idx  )

static

Definition at line 783 of file dex.c.

                                                               {
    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 dex_resolve_string_id(dex, type_id);
}

References dex_resolve_string_id(), NULL, RZ_LOG_INFO, dex_t::type_ids_size, and dex_t::types.

Referenced by dex_field_to_bin_field(), dex_field_to_symbol(), dex_method_to_symbol(), rz_bin_dex_classes(), rz_bin_dex_imports(), rz_bin_dex_libraries(), rz_bin_dex_resolve_class_by_idx(), rz_bin_dex_resolve_field_by_idx(), rz_bin_dex_resolve_method_by_idx(), and rz_bin_dex_symbols().

dex_resolve_virtual_method_code()

static void dex_resolve_virtual_method_code ( RzBinDex *  dex, DexMethodId *  to_resolve, ut32  superclass_idx  )

static

Definition at line 359 of file dex.c.

                                                                                                         {
    DexMethodId *method_id = NULL;
    void **it;
 
    rz_pvector_foreach (dex->method_ids, it) {
        method_id = (DexMethodId *)*it;
        if (method_id == to_resolve ||
            method_id->class_idx != superclass_idx ||
            method_id->proto_idx != to_resolve->proto_idx ||
            method_id->name_idx != to_resolve->name_idx) {
            continue;
        }
        to_resolve->code_offset = method_id->code_offset;
        to_resolve->code_size = method_id->code_size;
        return;
    }
}

References dex_method_id_t::class_idx, dex_method_id_t::code_offset, dex_method_id_t::code_size, dex_t::method_ids, dex_method_id_t::name_idx, NULL, dex_method_id_t::proto_idx, and rz_pvector_foreach.

Referenced by dex_resolve_all_virtual_methods().

dex_string_free()

static void dex_string_free ( DexString *  string )

static

Definition at line 69 of file dex.c.

                                               {
    if (!string) {
        return;
    }
    free(string->data);
    free(string);
}

References dex_string_t::data, and free().

Referenced by rz_bin_dex_new().

dex_string_new()

static DexString* dex_string_new ( RzBuffer *  buf, ut64  offset, st64 *  pread  )

static

Definition at line 77 of file dex.c.

                                                                          {
    ut64 size = 0;
    char *data = NULL;
    st64 read;
    DexString *string = NULL;
 
    read = rz_buf_uleb128(buf, &size);
    data = malloc(size + 1);
    if (!data || rz_buf_read(buf, (ut8 *)data, size) != size) {
        free(data);
        return NULL;
    }
    data[size] = 0;
 
    string = RZ_NEW0(DexString);
    if (!string) {
        free(data);
        return NULL;
    }
 
    *pread = read;
    string->size = size;
    string->offset = offset;
    string->data = data;
    return string;
}

References free(), malloc(), NULL, pread, read(), rz_buf_read(), rz_buf_uleb128(), RZ_NEW0, st64, and ut64().

Referenced by dex_parse().

free_rz_bin_class()

static void free_rz_bin_class ( RzBinClass *  bclass )

static

Definition at line 1116 of file dex.c.

                                                  {
    if (!bclass) {
        return;
    }
    rz_list_free(bclass->methods);
    rz_list_free(bclass->fields);
    free(bclass->name);
    free(bclass->super);
    free(bclass->visibility_str);
    free(bclass);
}

References rz_bin_class_t::fields, free(), rz_bin_class_t::methods, rz_bin_class_t::name, rz_list_free(), rz_bin_class_t::super, and rz_bin_class_t::visibility_str.

Referenced by rz_bin_dex_classes().

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().

section_new()

static RzBinSection* section_new ( const char *  name, ut32  perm, ut32  size, ut64  paddr, ut64  vaddr  )

static

Definition at line 1184 of file dex.c.

                                                                                                 {
    RzBinSection *section = RZ_NEW0(RzBinSection);
    if (!section) {
        return NULL;
    }
    section->name = strdup(name);
    section->paddr = paddr;
    section->vaddr = vaddr;
    section->size = section->vsize = size;
    section->perm = perm;
    return section;
}

References NULL, RZ_NEW0, section::size, and strdup().

Referenced by rz_bin_dex_sections().

Variable Documentation

access_flags_list

const DexAccessFlagsReadable access_flags_list[CLASS_ACCESS_FLAGS_SIZE]

static

Initial value:

= {
    { ACCESS_FLAG_PUBLIC , "public" },
    { ACCESS_FLAG_PRIVATE , "private" },
    { ACCESS_FLAG_PROTECTED , "protected" },
    { ACCESS_FLAG_STATIC , "static" },
    { ACCESS_FLAG_FINAL , "final" },
    { ACCESS_FLAG_SYNCHRONIZED , "synchronized" },
    { ACCESS_FLAG_BRIDGE , "bridge" },
    { ACCESS_FLAG_VARARGS , "varargs" },
    { ACCESS_FLAG_NATIVE , "native" },
    { ACCESS_FLAG_INTERFACE , "interface" },
    { ACCESS_FLAG_ABSTRACT , "abstract" },
    { ACCESS_FLAG_STRICT , "strict" },
    { ACCESS_FLAG_SYNTHETIC , "synthetic" },
    { ACCESS_FLAG_ANNOTATION , "annotation" },
    { ACCESS_FLAG_ENUM , "enum" },
    { ACCESS_FLAG_MODULE , "module" },
    { ACCESS_FLAG_CONSTRUCTOR , "constructor" },
    { ACCESS_FLAG_DECLARED_SYNCHRONIZED , "synchronized" },
}

Definition at line 48 of file dex.c.

Referenced by rz_bin_dex_access_flags_readable().