elf_info.c File Reference

#include "elf.h"

Go to the source code of this file.

Classes
struct	mips_bits_translation
struct	section_note_osabi_translation
struct	machine_name_translation
struct	class_translation
struct	cpu_mips_translation
struct	arch_translation
struct	ver_flags_translation

Macros
#define	EF_MIPS_ABI_O32   0x00001000 /* O32 ABI. */
#define	EF_MIPS_ABI_O64   0x00002000 /* O32 extended for 64 bit. */
#define	EF_MIPS_ABI   0x0000f000
#define	VERSYM_VERSION   0x7fff

Functions
static ut64	get_main_offset_from_symbol (ELFOBJ *bin)
static ut64	get_main_offset_linux_64_pie (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_x86_non_pie (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_x86_pie (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_x86_gcc (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_mips (ELFOBJ *bin, ut64 entry, ut8 *buf, size_t size)
static ut64	get_main_offset_arm_glibc_thumb (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_arm_glibc_non_thumb (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_arm_glibc (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_main_offset_arm64 (ELFOBJ *bin, ut64 entry, ut8 *buf)
static ut64	get_entry_offset_from_shdr (ELFOBJ *bin)
static ut64	compute_boffset_from_phdr (ELFOBJ *bin)
static ut64	compute_baddr_from_phdr (ELFOBJ *bin)
static bool	elf_is_bind_now (ELFOBJ *bin)
static bool	elf_has_gnu_relro (ELFOBJ *bin)
static int	get_bits_common (ELFOBJ *bin)
static bool	has_thumb_symbol (ELFOBJ *bin)
static int	get_bits_mips_common (Elf_(Word) mips_type)
static int	is_playstation_hack (ELFOBJ *bin, Elf_(Word) mips_type)
static int	get_bits_mips (ELFOBJ *bin)
static bool	arch_is_mips (ELFOBJ *bin)
static bool	arch_is_arcompact (ELFOBJ *bin)
static char *	read_elf_intrp (ELFOBJ *bin, ut64 addr, size_t size)
static char *	get_elf_intrp (ELFOBJ *bin, RzBinElfSegment *segment)
static	Elf_ (Xword)
static char *	get_ver_flags (ut32 flags)
static bool	has_dt_rpath_entry (ELFOBJ *bin)
static char *	get_osabi_name_from_section_note (ELFOBJ *bin, RzBinElfSection *section)
static char *	get_osabi_name_from_shdr (ELFOBJ *bin)
static char *	get_osabi_name_from_ehdr (ELFOBJ *bin)
static char *	add_abi_info (ELFOBJ *bin, char *head_flag)
static char *	add_cpu_info (ELFOBJ *bin, char *head_flag)
static char *	get_head_flag (ELFOBJ *bin)
static bool	file_type_is_processor_specific (ELFOBJ *bin)
static bool	file_type_is_os_specific (ELFOBJ *bin)
static char *	get_file_type_basic (RZ_NONNULL ELFOBJ *bin)
static char *	get_cpu_mips (ELFOBJ *bin)
static bool	is_elf_class64 (ELFOBJ *bin)
static bool	is_mips_o32 (ELFOBJ *bin)
static bool	is_mips_n32 (ELFOBJ *bin)
static char *	get_abi_mips (ELFOBJ *bin)
RZ_OWN RzList *Elf_()	rz_bin_elf_get_libs (RZ_NONNULL ELFOBJ *bin)
	List all imported lib. More...
static bool	get_verdaux_entry_aux (ELFOBJ *bin, ut64 offset, Elf_(Verdaux) *entry)
static bool	get_verdaux_entry (ELFOBJ *bin, ut64 offset, Elf_(Verdaux) *entry)
static bool	get_verdef_entry_aux (ELFOBJ *bin, ut64 offset, Elf_(Verdef) *entry)
static bool	get_verdef_entry (ELFOBJ *bin, ut64 offset, Elf_(Verdef) *entry)
static bool	get_vernaux_entry_aux (ELFOBJ *bin, ut64 offset, Elf_(Vernaux) *entry)
static bool	get_vernaux_entry (ELFOBJ *bin, ut64 offset, Elf_(Vernaux) *entry)
static bool	get_verneed_entry_aux (ELFOBJ *bin, ut64 offset, Elf_(Verneed) *entry)
static bool	get_verneed_entry (ELFOBJ *bin, ut64 offset, Elf_(Verneed) *entry)
static bool	get_versym_entry_sdb_from_verneed (ELFOBJ *bin, Sdb *sdb, const char *key, Elf_(Versym) versym)
static bool	get_versym_entry_sdb_from_verdef (ELFOBJ *bin, Sdb *sdb, const char *key, Elf_(Versym) versym)
static Sdb *	get_gnu_versym (ELFOBJ *bin)
static Sdb *	get_vernaux_entry_sdb (ELFOBJ *bin, Elf_(Vernaux) vernaux_entry, size_t index)
static Sdb *	get_verneed_entry_sdb_aux (ELFOBJ *bin, Elf_(Verneed) verneed_entry, size_t index)
static Sdb *	get_verneed_entry_sdb (ELFOBJ *bin, Elf_(Verneed) verneed_entry, size_t offset)
static Sdb *	get_gnu_verneed (ELFOBJ *bin)
RZ_IPI RZ_OWN Sdb *Elf_()	rz_bin_elf_get_symbols_info (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_get_compiler (RZ_NONNULL ELFOBJ *bin)
	Get the compiler info from the .comment section. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_abi (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the application binary interface. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_arch (RZ_NONNULL ELFOBJ *bin)
	Get the elf binary architecture. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_cpu (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the cpu. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_elf_class (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the elf class. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_file_type (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the file type. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_head_flag (RZ_NONNULL ELFOBJ *bin)
	Return the head flag. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_machine_name (RZ_NONNULL ELFOBJ *bin)
	Return a string representing the machine name. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_osabi_name (RZ_NONNULL ELFOBJ *bin)
	Return the os application binary interface name. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_rpath (RZ_NONNULL ELFOBJ *bin)
	Get the rpath. More...
RZ_OWN char *Elf_()	rz_bin_elf_get_intrp (RZ_NONNULL ELFOBJ *bin)
	Get the program interpreter. More...
bool Elf_()	rz_bin_elf_is_stripped (RZ_NONNULL ELFOBJ *bin)
	Check if the binary is stripped. More...
bool Elf_()	rz_bin_elf_has_nx (RZ_NONNULL ELFOBJ *bin)
	Check if the stack is not executable. More...
bool Elf_()	rz_bin_elf_has_va (ELFOBJ *bin)
	Check if the elf use virtual address. More...
bool Elf_()	rz_bin_elf_is_executable (RZ_NONNULL ELFOBJ *bin)
	Check if the elf binary is executable. More...
bool Elf_()	rz_bin_elf_is_relocatable (RZ_NONNULL ELFOBJ *bin)
	Check if the elf binary is relocatable. More...
bool Elf_()	rz_bin_elf_is_static (RZ_NONNULL ELFOBJ *bin)
	Check if the binary is statically-linked library. More...
int Elf_()	rz_bin_elf_get_bits (RZ_NONNULL ELFOBJ *bin)
	Return the elf bits. More...
int Elf_()	rz_bin_elf_has_relro (RZ_NONNULL ELFOBJ *bin)
	Analyse if the elf binary has relro or partial relro. More...
bool Elf_()	rz_bin_elf_is_big_endian (RZ_NONNULL ELFOBJ *bin)
	Check the binary endianness. More...
ut64 Elf_()	rz_bin_elf_get_baddr (RZ_NONNULL ELFOBJ *bin)
	Compute the base address of the binary. More...
ut64 Elf_()	rz_bin_elf_get_boffset (RZ_NONNULL ELFOBJ *bin)
	Compute the base offset of the binary. More...
ut64 Elf_()	rz_bin_elf_get_entry_offset (RZ_NONNULL ELFOBJ *bin)
	Get the entry offset. More...
ut64 Elf_()	rz_bin_elf_get_fini_offset (RZ_NONNULL ELFOBJ *bin)
	Compute the fini offset of the binary. More...
ut64 Elf_()	rz_bin_elf_get_init_offset (RZ_NONNULL ELFOBJ *bin)
	Compute the init offset of the binary. More...
ut64 Elf_()	rz_bin_elf_get_main_offset (RZ_NONNULL ELFOBJ *bin)
	Compute the main offset of the binary. More...

Variables
static const struct mips_bits_translation	mips_bits_translation_table []
static const struct section_note_osabi_translation	section_note_osabi_translation_table []
static const struct machine_name_translation	machine_name_translation_table []
static const struct class_translation	class_translation_table []
static const struct cpu_mips_translation	cpu_mips_translation_table []
static const struct arch_translation	arch_translation_table []
static const struct ver_flags_translation	ver_flags_translation_table []

Macro Definition Documentation

EF_MIPS_ABI

#define EF_MIPS_ABI   0x0000f000

Definition at line 11 of file elf_info.c.

EF_MIPS_ABI_O32

#define EF_MIPS_ABI_O32   0x00001000 /* O32 ABI. */

Definition at line 9 of file elf_info.c.

EF_MIPS_ABI_O64

#define EF_MIPS_ABI_O64   0x00002000 /* O32 extended for 64 bit. */

Definition at line 10 of file elf_info.c.

VERSYM_VERSION

#define VERSYM_VERSION   0x7fff

Definition at line 13 of file elf_info.c.

Function Documentation

add_abi_info()

static char* add_abi_info ( ELFOBJ *  bin, char *  head_flag  )

static

Definition at line 755 of file elf_info.c.

                                                        {
    char *str = Elf_(rz_bin_elf_get_abi)(bin);
 
    if (str) {
        head_flag = rz_str_appendf(head_flag, " %s", str);
        free(str);
    }
 
    return head_flag;
}

References Elf_(), free(), rz_bin_elf_get_abi(), rz_str_appendf(), and cmd_descs_generate::str.

Referenced by get_head_flag().

add_cpu_info()

static char* add_cpu_info ( ELFOBJ *  bin, char *  head_flag  )

static

Definition at line 766 of file elf_info.c.

                                                        {
    char *str = Elf_(rz_bin_elf_get_cpu)(bin);
 
    if (str) {
        head_flag = rz_str_append_owned(head_flag, str);
    }
 
    return head_flag;
}

References Elf_(), rz_bin_elf_get_cpu(), rz_str_append_owned(), and cmd_descs_generate::str.

Referenced by get_head_flag().

arch_is_arcompact()

static bool arch_is_arcompact ( ELFOBJ *  bin )

static

Definition at line 626 of file elf_info.c.

                                           {
    return bin->ehdr.e_machine == EM_ARC_A5;
}

References EM_ARC_A5.

Referenced by rz_bin_elf_get_bits().

arch_is_mips()

static bool arch_is_mips ( ELFOBJ *  bin )

static

Definition at line 622 of file elf_info.c.

                                      {
    return Elf_(rz_bin_elf_has_segments)(bin) && bin->ehdr.e_machine == EM_MIPS;
}

References Elf_(), EM_MIPS, and rz_bin_elf_has_segments().

Referenced by rz_bin_elf_get_bits().

compute_baddr_from_phdr()

static ut64 compute_baddr_from_phdr ( ELFOBJ *  bin )

static

Definition at line 539 of file elf_info.c.

                                                 {
    ut64 base = UT64_MAX;
 
    RzBinElfSegment *iter;
    rz_bin_elf_foreach_segments(bin, iter) {
        if (iter->data.p_type == PT_LOAD) {
            base = RZ_MIN(base, iter->data.p_vaddr);
        }
    }
 
    return base == UT64_MAX ? 0 : base;
}

References PT_LOAD, rz_bin_elf_foreach_segments, RZ_MIN, RzBinElfSegment, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_baddr().

compute_boffset_from_phdr()

static ut64 compute_boffset_from_phdr ( ELFOBJ *  bin )

static

Definition at line 526 of file elf_info.c.

                                                   {
    ut64 base = UT64_MAX;
 
    RzBinElfSegment *iter;
    rz_bin_elf_foreach_segments(bin, iter) {
        if (iter->data.p_type == PT_LOAD) {
            base = RZ_MIN(base, iter->data.p_offset);
        }
    }
 
    return base == UT64_MAX ? 0 : base;
}

References PT_LOAD, rz_bin_elf_foreach_segments, RZ_MIN, RzBinElfSegment, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_boffset().

Elf_()

static Elf_ ( Xword  )

static

Definition at line 672 of file elf_info.c.

                                             {
    ut64 path;
 
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_RPATH, &path)) {
        return path;
    }
 
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_RUNPATH, &path)) {
        return path;
    }
 
    return 0;
}

References DT_RPATH, DT_RUNPATH, path, rz_bin_elf_get_dt_info(), and ut64().

Referenced by add_abi_info(), add_cpu_info(), arch_is_mips(), elf_has_gnu_relro(), elf_is_bind_now(), get_bits_mips(), get_cpu_mips(), get_entry_offset_from_shdr(), get_gnu_verneed(), get_gnu_versym(), get_main_offset_arm64(), get_main_offset_arm_glibc(), get_main_offset_arm_glibc_non_thumb(), get_main_offset_arm_glibc_thumb(), get_main_offset_linux_64_pie(), get_main_offset_mips(), get_main_offset_x86_gcc(), get_main_offset_x86_non_pie(), get_main_offset_x86_pie(), get_verdaux_entry_aux(), get_verdef_entry_aux(), get_vernaux_entry_aux(), get_vernaux_entry_sdb(), get_verneed_entry_aux(), get_verneed_entry_sdb(), get_verneed_entry_sdb_aux(), get_versym_entry_sdb_from_verdef(), get_versym_entry_sdb_from_verneed(), has_dt_rpath_entry(), has_thumb_symbol(), is_playstation_hack(), rz_bin_elf_get_baddr(), rz_bin_elf_get_bits(), rz_bin_elf_get_boffset(), rz_bin_elf_get_compiler(), rz_bin_elf_get_cpu(), rz_bin_elf_get_entry_offset(), rz_bin_elf_get_fini_offset(), rz_bin_elf_get_init_offset(), rz_bin_elf_get_intrp(), rz_bin_elf_get_libs(), rz_bin_elf_get_main_offset(), rz_bin_elf_get_rpath(), rz_bin_elf_get_symbols_info(), rz_bin_elf_has_nx(), rz_bin_elf_is_executable(), rz_bin_elf_is_static(), and rz_bin_elf_is_stripped().

elf_has_gnu_relro()

static bool elf_has_gnu_relro ( ELFOBJ *  bin )

static

Definition at line 566 of file elf_info.c.

                                           {
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return false;
    }
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_GNU_RELRO);
    return segment && segment->is_valid;
}

References Elf_(), PT_GNU_RELRO, rz_bin_elf_get_segment_with_type(), rz_bin_elf_has_segments(), and RzBinElfSegment.

Referenced by rz_bin_elf_has_relro().

elf_is_bind_now()

static bool elf_is_bind_now ( ELFOBJ *  bin )

static

Definition at line 552 of file elf_info.c.

                                         {
    ut64 flags_1;
 
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_BIND_NOW, NULL)) {
        return true;
    }
 
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_FLAGS_1, &flags_1)) {
        return flags_1 & DF_1_NOW;
    }
 
    return false;
}

References DF_1_NOW, DT_BIND_NOW, DT_FLAGS_1, Elf_(), NULL, rz_bin_elf_get_dt_info(), and ut64().

Referenced by rz_bin_elf_has_relro().

file_type_is_os_specific()

static bool file_type_is_os_specific ( ELFOBJ *  bin )

static

Definition at line 789 of file elf_info.c.

                                                  {
    return bin->ehdr.e_type >= ET_LOOS && bin->ehdr.e_type <= ET_HIOS;
}

References ET_HIOS, and ET_LOOS.

Referenced by rz_bin_elf_get_file_type().

file_type_is_processor_specific()

static bool file_type_is_processor_specific ( ELFOBJ *  bin )

static

Definition at line 785 of file elf_info.c.

                                                         {
    return bin->ehdr.e_type >= ET_LOPROC && bin->ehdr.e_type <= ET_HIPROC;
}

References ET_HIPROC, and ET_LOPROC.

Referenced by rz_bin_elf_get_file_type().

get_abi_mips()

static char* get_abi_mips ( ELFOBJ *  bin )

static

Definition at line 854 of file elf_info.c.

                                       {
    if (is_elf_class64(bin)) {
        return strdup("n64");
    }
 
    if (is_mips_n32(bin)) {
        return strdup("n32");
    }
 
    if (is_mips_o32(bin)) {
        return strdup("o32");
    }
 
    return NULL;
}

References is_elf_class64(), is_mips_n32(), is_mips_o32(), NULL, and strdup().

Referenced by rz_bin_elf_get_abi().

get_bits_common()

static int get_bits_common ( ELFOBJ *  bin )

static

Definition at line 575 of file elf_info.c.

                                        {
    switch (bin->ehdr.e_ident[EI_CLASS]) {
    case ELFCLASS32:
        return 32;
    case ELFCLASS64:
        return 64;
    case ELFCLASSNONE:
    default:
        return 32;
    }
}

References EI_CLASS, ELFCLASS32, ELFCLASS64, and ELFCLASSNONE.

Referenced by rz_bin_elf_get_bits().

get_bits_mips()

static int get_bits_mips ( ELFOBJ *  bin )

static

Definition at line 612 of file elf_info.c.

                                      {
    const Elf_(Word) mips_type = bin->ehdr.e_flags & EF_MIPS_ARCH;
 
    if (is_playstation_hack(bin, mips_type)) {
        return 64;
    }
 
    return get_bits_mips_common(mips_type);
}

References EF_MIPS_ARCH, Elf_(), get_bits_mips_common(), and is_playstation_hack().

Referenced by rz_bin_elf_get_bits().

get_bits_mips_common()

static int get_bits_mips_common ( Elf_(Word)  mips_type )

static

Definition at line 598 of file elf_info.c.

                                                      {
    for (size_t i = 0; i < RZ_ARRAY_SIZE(mips_bits_translation_table); i++) {
        if (mips_type == mips_bits_translation_table[i].type) {
            return mips_bits_translation_table[i].bits;
        }
    }
 
    return 32;
}

References i, mips_bits_translation_table, RZ_ARRAY_SIZE, and type.

Referenced by get_bits_mips().

get_cpu_mips()

static char* get_cpu_mips ( ELFOBJ *  bin )

static

Definition at line 810 of file elf_info.c.

                                       {
    Elf_(Word) mips_arch = bin->ehdr.e_flags & EF_MIPS_ARCH;
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(cpu_mips_translation_table); i++) {
        if (mips_arch == cpu_mips_translation_table[i].arch) {
            return strdup(cpu_mips_translation_table[i].name);
        }
    }
 
    return strdup(" Unknown mips ISA");
}

References arch, cpu_mips_translation_table, EF_MIPS_ARCH, Elf_(), i, RZ_ARRAY_SIZE, and strdup().

Referenced by rz_bin_elf_get_cpu().

get_elf_intrp()

static char* get_elf_intrp ( ELFOBJ *  bin, RzBinElfSegment *  segment  )

static

Definition at line 646 of file elf_info.c.

                                                                  {
    ut64 addr = segment->data.p_offset;
    size_t size = segment->data.p_filesz;
 
    if (!sdb_num_set(bin->kv, "elf_header.intrp_addr", addr, 0) ||
        !sdb_num_set(bin->kv, "elf_header.intrp_size", size, 0)) {
        return NULL;
    }
 
    if (size < 1 || size > rz_buf_size(bin->b)) {
        return NULL;
    }
 
    char *str = read_elf_intrp(bin, addr, size);
    if (!str) {
        return NULL;
    }
 
    if (!sdb_set(bin->kv, "elf_header.intrp", str, 0)) {
        free(str);
        return NULL;
    }
 
    return str;
}

References addr, free(), NULL, read_elf_intrp(), rz_buf_size(), sdb_num_set(), sdb_set(), cmd_descs_generate::str, and ut64().

Referenced by rz_bin_elf_get_intrp().

get_entry_offset_from_shdr()

static ut64 get_entry_offset_from_shdr ( ELFOBJ *  bin )

static

Definition at line 507 of file elf_info.c.

                                                    {
    RzBinElfSection *section = Elf_(rz_bin_elf_get_section_with_name)(bin, ".init.text");
    if (section) {
        return section->offset;
    }
 
    section = Elf_(rz_bin_elf_get_section_with_name)(bin, ".text");
    if (section) {
        return section->offset;
    }
 
    section = Elf_(rz_bin_elf_get_section_with_name)(bin, ".init");
    if (section) {
        return section->offset;
    }
 
    return UT64_MAX;
}

References Elf_(), section::offset, rz_bin_elf_get_section_with_name(), and UT64_MAX.

Referenced by rz_bin_elf_get_entry_offset().

get_file_type_basic()

static char* get_file_type_basic ( RZ_NONNULL ELFOBJ *  bin )

static

Definition at line 793 of file elf_info.c.

                                                         {
    switch (bin->ehdr.e_type) {
    case ET_NONE:
        return strdup("NONE (None)");
    case ET_REL:
        return strdup("REL (Relocatable file)");
    case ET_EXEC:
        return strdup("EXEC (Executable file)");
    case ET_DYN:
        return strdup("DYN (Shared object file)");
    case ET_CORE:
        return strdup("CORE (Core file)");
    }
 
    return NULL;
}

References ET_CORE, ET_DYN, ET_EXEC, ET_NONE, ET_REL, NULL, and strdup().

Referenced by rz_bin_elf_get_file_type().

get_gnu_verneed()

static Sdb* get_gnu_verneed ( ELFOBJ *  bin )

static

Definition at line 1247 of file elf_info.c.

                                         {
    ut64 verneed_addr;
    ut64 verneed_num;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERNEED, &verneed_addr) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERNEEDNUM, &verneed_num)) {
        return NULL;
    }
 
    ut64 verneed_offset = Elf_(rz_bin_elf_v2p(bin, verneed_addr));
    if (verneed_offset == UT64_MAX) {
        RZ_LOG_WARN("Failed to convert verneed virtual address to physical address.\n");
        return NULL;
    }
 
    Sdb *sdb = sdb_new0();
    if (!sdb) {
        return NULL;
    }
 
    if (!sdb_num_set(sdb, "num_entries", verneed_num, 0) ||
        !sdb_num_set(sdb, "addr", verneed_addr, 0) ||
        !sdb_num_set(sdb, "offset", verneed_offset, 0)) {
        sdb_free(sdb);
        return NULL;
    }
 
    for (size_t i = 0; i < verneed_num; i++) {
        Elf_(Verneed) verneed_entry;
        if (!get_verneed_entry(bin, verneed_offset, &verneed_entry)) {
            sdb_free(sdb);
            return NULL;
        }
 
        Sdb *sdb_version = get_verneed_entry_sdb(bin, verneed_entry, verneed_offset);
        if (!sdb_version) {
            sdb_free(sdb);
            return NULL;
        }
 
        char key[32];
        if (!sdb_ns_set(sdb, rz_strf(key, "version%zu", i), sdb_version)) {
            sdb_free(sdb_version);
            sdb_free(sdb);
            return NULL;
        }
 
        sdb_free(sdb_version);
 
        verneed_offset += verneed_entry.vn_next;
    }
 
    return sdb;
}

References DT_VERNEED, DT_VERNEEDNUM, Elf_(), get_verneed_entry(), get_verneed_entry_sdb(), i, key, NULL, rz_bin_elf_get_dt_info(), rz_bin_elf_v2p(), RZ_LOG_WARN, rz_strf, sdb_free(), sdb_new0(), sdb_ns_set(), sdb_num_set(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_symbols_info().

get_gnu_versym()

static Sdb* get_gnu_versym ( ELFOBJ *  bin )

static

Definition at line 1089 of file elf_info.c.

                                        {
    ut64 versym_addr;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERSYM, &versym_addr)) {
        return false;
    }
 
    ut64 versym_offset = Elf_(rz_bin_elf_v2p(bin, versym_addr));
 
    if (versym_offset == UT64_MAX) {
        return NULL;
    }
 
    ut64 number_of_symbols = Elf_(rz_bin_elf_get_number_of_dynamic_symbols)(bin);
    if (!number_of_symbols) {
        return NULL;
    }
 
    Sdb *sdb = sdb_new0();
    if (!sdb) {
        return NULL;
    }
 
    if (!sdb_num_set(sdb, "num_entries", number_of_symbols, 0) ||
        !sdb_num_set(sdb, "addr", versym_addr, 0) ||
        !sdb_num_set(sdb, "offset", versym_offset, 0)) {
        sdb_free(sdb);
        return NULL;
    }
 
    ut64 versym_entry_offset = versym_offset;
 
    for (size_t i = 0; i < number_of_symbols; i++) {
        char key[32];
        if (rz_strf(key, "entry%zu", i) == NULL) {
            sdb_free(sdb);
            return NULL;
        }
 
        Elf_(Versym) versym_entry;
        if (!Elf_(rz_bin_elf_read_versym)(bin, &versym_entry_offset, &versym_entry)) {
            sdb_free(sdb);
            return NULL;
        }
 
        switch (versym_entry) {
        case VER_NDX_LOCAL:
            if (!sdb_set(sdb, key, "0 (*local*)", 0)) {
                sdb_free(sdb);
                return NULL;
            }
            break;
        case VER_NDX_GLOBAL:
            if (!sdb_set(sdb, key, "1 (*global*)", 0)) {
                sdb_free(sdb);
                return NULL;
            }
            break;
        default:
            if (get_versym_entry_sdb_from_verneed(bin, sdb, key, versym_entry)) {
                break;
            }
 
            if (!get_versym_entry_sdb_from_verdef(bin, sdb, key, versym_entry)) {
                sdb_free(sdb);
                return NULL;
            }
        }
    }
 
    return sdb;
}

References DT_VERSYM, Elf_(), get_versym_entry_sdb_from_verdef(), get_versym_entry_sdb_from_verneed(), i, key, NULL, rz_bin_elf_get_dt_info(), rz_bin_elf_read_versym(), rz_bin_elf_v2p(), rz_strf, sdb_free(), sdb_new0(), sdb_num_set(), sdb_set(), ut64(), UT64_MAX, VER_NDX_GLOBAL, and VER_NDX_LOCAL.

Referenced by rz_bin_elf_get_symbols_info().

get_head_flag()

static char* get_head_flag ( ELFOBJ *  bin )

static

Definition at line 776 of file elf_info.c.

                                        {
    char *head_flag = NULL;
 
    head_flag = add_cpu_info(bin, head_flag);
    head_flag = add_abi_info(bin, head_flag);
 
    return head_flag;
}

References add_abi_info(), add_cpu_info(), and NULL.

Referenced by rz_bin_elf_get_head_flag().

get_main_offset_arm64()

static ut64 get_main_offset_arm64 ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 488 of file elf_info.c.

                                                                     {
    if (buf[0x18 + 3] != 0x58 || buf[0x2f] != 0x00) {
        return UT64_MAX;
    }
 
    ut64 entry_vaddr = Elf_(rz_bin_elf_p2v)(bin, entry);
    if (entry_vaddr == UT64_MAX) {
        return UT64_MAX;
    }
 
    ut64 main_addr = rz_read_le32(buf + 0x30);
 
    if (main_addr >> 16 == entry_vaddr >> 16) {
        return Elf_(rz_bin_elf_v2p)(bin, main_addr);
    }
 
    return UT64_MAX;
}

References Elf_(), rz_bin_elf_p2v(), rz_bin_elf_v2p(), rz_read_le32(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_arm_glibc()

static ut64 get_main_offset_arm_glibc ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 477 of file elf_info.c.

                                                                         {
    // ARM Glibc
    if (Elf_(rz_bin_elf_is_thumb_addr)(entry)) {
        return get_main_offset_arm_glibc_thumb(bin, entry, buf);
    } else {
        return get_main_offset_arm_glibc_non_thumb(bin, entry, buf);
    }
 
    return UT64_MAX;
}

References Elf_(), get_main_offset_arm_glibc_non_thumb(), get_main_offset_arm_glibc_thumb(), rz_bin_elf_is_thumb_addr(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_arm_glibc_non_thumb()

static ut64 get_main_offset_arm_glibc_non_thumb ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 465 of file elf_info.c.

                                                                                   {
    if (!memcmp(buf, "\x00\xb0\xa0\xe3\x00\xe0\xa0\xe3", 8)) {
        return Elf_(rz_bin_elf_v2p)(bin, rz_read_le32(buf + 0x34) & ~1);
    }
 
    if (!memcmp(buf, "\x24\xc0\x9f\xe5\x00\xb0\xa0\xe3", 8)) {
        return Elf_(rz_bin_elf_v2p)(bin, rz_read_le32(buf + 0x30) & ~1);
    }
 
    return UT64_MAX;
}

References Elf_(), rz_bin_elf_v2p(), rz_read_le32(), and UT64_MAX.

Referenced by get_main_offset_arm_glibc().

get_main_offset_arm_glibc_thumb()

static ut64 get_main_offset_arm_glibc_thumb ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 443 of file elf_info.c.

                                                                               {
    size_t delta = 0;
 
    if (!memcmp(buf, "\xf0\x00\x0b\x4f\xf0\x00\x0e\x02\xbc\x6a\x46", 11)) {
        /* newer versions of gcc use push/pop */
        delta = 0x28;
    } else if (!memcmp(buf, "\xf0\x00\x0b\x4f\xf0\x00\x0e\x5d\xf8\x04\x1b", 11)) {
        /* older versions of gcc (4.5.x) use ldr/str */
        delta = 0x30;
    }
 
    if (delta) {
        ut64 tmp = rz_read_le32(buf + delta - 1) & ~1;
        ut64 pa = Elf_(rz_bin_elf_v2p)(bin, tmp);
        if (pa < rz_buf_size(bin->b)) {
            return pa;
        }
    }
 
    return UT64_MAX;
}

References delta, Elf_(), rz_bin_elf_v2p(), rz_buf_size(), rz_read_le32(), autogen_x86imm::tmp, ut64(), and UT64_MAX.

Referenced by get_main_offset_arm_glibc().

get_main_offset_from_symbol()

static ut64 get_main_offset_from_symbol ( ELFOBJ *  bin )

static

Definition at line 296 of file elf_info.c.

                                                     {
    RzBinElfSymbol *symbol;
    rz_bin_elf_foreach_symbols(bin, symbol) {
        if (symbol->name && !strcmp(symbol->name, "main")) {
            if (symbol->paddr != UT64_MAX) {
                return symbol->paddr;
            }
 
            return symbol->vaddr;
        }
    }
 
    return UT64_MAX;
}

References rz_bin_elf_symbol_t::name, rz_bin_elf_symbol_t::paddr, rz_bin_elf_foreach_symbols, UT64_MAX, and rz_bin_elf_symbol_t::vaddr.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_linux_64_pie()

static ut64 get_main_offset_linux_64_pie ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 311 of file elf_info.c.

                                                                            {
    /* linux64 pie main -- probably buggy in some cases */
    int bo = 29; // Begin offset may vary depending on the entry prelude
    // endbr64 - fedora bins have this
    if (buf[0] == 0xf3 && buf[1] == 0x0f && buf[2] == 0x1e && buf[3] == 0xfa) {
        // Change begin offset if binary starts with 'endbr64'
        bo = 33;
        // double xor for init and fini
        if (!memcmp(buf + 19, "\x45\x31\xc0\x31\xc9", 5)) {
            bo = 24;
        }
    }
    if (buf[bo] == 0x48) {
        ut8 ch = buf[bo + 1];
        if (ch == 0x8d) { // lea rdi, qword [rip + MAINDELTA]
            ut8 *p = buf + bo + 3;
            st32 maindelta = (st32)rz_read_le32(p);
            ut64 ventry = Elf_(rz_bin_elf_p2v)(bin, entry);
            if (ventry == UT64_MAX) {
                return UT64_MAX;
            }
            ut64 vmain = (ut64)(ventry + bo + maindelta) + 7;
            return Elf_(rz_bin_elf_v2p)(bin, vmain);
        } else if (ch == 0xc7) { // mov rdi, 0xADDR
            ut8 *p = buf + bo + 3;
            ut64 addr = (ut64)rz_read_le32(p);
            return Elf_(rz_bin_elf_v2p)(bin, addr);
        }
    }
 
    return UT64_MAX;
}

References addr, Elf_(), p, rz_bin_elf_p2v(), rz_bin_elf_v2p(), rz_read_le32(), st32, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_mips()

static ut64 get_main_offset_mips ( ELFOBJ *  bin, ut64  entry, ut8 *  buf, size_t  size  )

static

Definition at line 408 of file elf_info.c.

                                                                                 {
    /* get .got, calculate offset of main symbol */
    if (memcmp(buf, "\x21\x00\xe0\x03\x01\x00\x11\x04", 8)) {
        return UT64_MAX;
    }
 
    /*
       assuming the startup code looks like
       got = gp-0x7ff0
       got[index__libc_start_main] ( got[index_main] );
 
       looking for the instruction generating the first argument to find main
       lw a0, offset(gp)
       */
    ut64 got_addr;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_PLTGOT, &got_addr)) {
        return 0;
    }
 
    ut64 got_offset = Elf_(rz_bin_elf_v2p)(bin, got_addr);
    ut64 gp = got_offset + 0x7ff0;
 
    for (size_t i = 0; i < size; i += 4) {
        const ut32 instr = rz_read_le32(buf + i);
        if ((instr & 0xffff0000) == 0x8f840000) { // lw a0, offset(gp)
            const short delta = instr & 0x0000ffff;
            rz_buf_read_at(bin->b, /* got_entry_offset = */ gp + delta, buf, 4);
            return Elf_(rz_bin_elf_v2p)(bin, rz_read_le32(buf));
        }
    }
 
    return 0;
}

References delta, DT_PLTGOT, Elf_(), i, rz_bin_elf_get_dt_info(), rz_bin_elf_v2p(), rz_buf_read_at(), rz_read_le32(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_x86_gcc()

static ut64 get_main_offset_x86_gcc ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 396 of file elf_info.c.

                                                                       {
    if (buf[0] != 0xe8 && memcmp(buf + 5, "\x50\xe8\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x53", 12)) {
        return UT64_MAX;
    }
 
    size_t SIZEOF_CALL = 5;
    ut64 rel_addr = (ut64)(buf[1] + (buf[2] << 8) + (buf[3] << 16) + (buf[4] << 24));
    ut64 addr = Elf_(rz_bin_elf_p2v)(bin, entry + SIZEOF_CALL);
    addr += rel_addr;
    return Elf_(rz_bin_elf_v2p)(bin, addr);
}

References addr, Elf_(), rz_bin_elf_p2v(), rz_bin_elf_v2p(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_x86_non_pie()

static ut64 get_main_offset_x86_non_pie ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 344 of file elf_info.c.

                                                                           {
    // X86-NONPIE
#if RZ_BIN_ELF64
    if (!memcmp(buf, "\x49\x89\xd9", 3) && buf[156] == 0xe8) { // openbsd
        return rz_read_le32(buf + 157) + entry + 156 + 5;
    }
    if (!memcmp(buf + 29, "\x48\xc7\xc7", 3)) { // linux
        ut64 addr = (ut64)rz_read_le32(buf + 29 + 3);
        return Elf_(rz_bin_elf_v2p)(bin, addr);
    }
#else
    if (buf[23] == '\x68') {
        ut64 addr = (ut64)rz_read_le32(buf + 23 + 1);
        return Elf_(rz_bin_elf_v2p)(bin, addr);
    }
#endif
 
    return UT64_MAX;
}

References addr, Elf_(), rz_bin_elf_v2p(), rz_read_le32(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_main_offset_x86_pie()

static ut64 get_main_offset_x86_pie ( ELFOBJ *  bin, ut64  entry, ut8 *  buf  )

static

Definition at line 364 of file elf_info.c.

                                                                       {
    // X86-PIE
    if (buf[0x00] == 0x48 && buf[0x1e] == 0x8d && buf[0x11] == 0xe8) {
        ut32 *pmain = (ut32 *)(buf + 0x30);
        ut64 vmain = Elf_(rz_bin_elf_p2v)(bin, (ut64)*pmain);
        ut64 ventry = Elf_(rz_bin_elf_p2v)(bin, entry);
        if (vmain >> 16 == ventry >> 16) {
            return vmain;
        }
    }
    // X86-PIE
    if (buf[0x1d] == 0x48 && buf[0x1e] == 0x8b) {
        if (!memcmp(buf, "\x31\xed\x49\x89", 4)) { // linux
            ut64 maddr, baddr;
            ut8 n32s[sizeof(ut32)] = { 0 };
            maddr = entry + 0x24 + rz_read_le32(buf + 0x20);
            if (rz_buf_read_at(bin->b, maddr, n32s, sizeof(ut32)) == -1) {
                return 0;
            }
            maddr = (ut64)rz_read_le32(&n32s[0]);
            baddr = (bin->ehdr.e_entry >> 16) << 16;
            if (Elf_(rz_bin_elf_has_segments)(bin)) {
                baddr = Elf_(rz_bin_elf_get_baddr)(bin);
            }
            maddr += baddr;
            return maddr;
        }
    }
 
    return UT64_MAX;
}

References baddr(), Elf_(), rz_bin_elf_get_baddr(), rz_bin_elf_has_segments(), rz_bin_elf_p2v(), rz_buf_read_at(), rz_read_le32(), ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_main_offset().

get_osabi_name_from_ehdr()

static char* get_osabi_name_from_ehdr ( ELFOBJ *  bin )

static

Definition at line 740 of file elf_info.c.

                                                   {
    switch (bin->ehdr.e_ident[EI_OSABI]) {
    case ELFOSABI_LINUX:
        return strdup("linux");
    case ELFOSABI_SOLARIS:
        return strdup("solaris");
    case ELFOSABI_FREEBSD:
        return strdup("freebsd");
    case ELFOSABI_HPUX:
        return strdup("hpux");
    }
 
    return NULL;
}

References EI_OSABI, ELFOSABI_FREEBSD, ELFOSABI_HPUX, ELFOSABI_LINUX, ELFOSABI_SOLARIS, NULL, and strdup().

Referenced by rz_bin_elf_get_osabi_name().

get_osabi_name_from_section_note()

static char* get_osabi_name_from_section_note ( ELFOBJ *  bin, RzBinElfSection *  section  )

static

Definition at line 706 of file elf_info.c.

                                                                                     {
    if (section->type != SHT_NOTE) {
        return NULL;
    }
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(section_note_osabi_translation_table); i++) {
        if (!strcmp(section->name, section_note_osabi_translation_table[i].note_name)) {
            return strdup(section_note_osabi_translation_table[i].os_name);
        }
    }
 
    return NULL;
}

References i, section_note_osabi_translation::note_name, NULL, RZ_ARRAY_SIZE, section_note_osabi_translation_table, SHT_NOTE, and strdup().

Referenced by get_osabi_name_from_shdr().

get_osabi_name_from_shdr()

static char* get_osabi_name_from_shdr ( ELFOBJ *  bin )

static

Definition at line 720 of file elf_info.c.

                                                   {
    if (!bin->shstrtab) {
        return NULL;
    }
 
    RzBinElfSection *section;
    rz_bin_elf_foreach_sections(bin, section) {
        if (!section->is_valid) {
            continue;
        }
 
        char *tmp = get_osabi_name_from_section_note(bin, section);
        if (tmp) {
            return tmp;
        }
    }
 
    return NULL;
}

References get_osabi_name_from_section_note(), NULL, rz_bin_elf_foreach_sections, and autogen_x86imm::tmp.

Referenced by rz_bin_elf_get_osabi_name().

get_ver_flags()

static char* get_ver_flags ( ut32  flags )

static

Definition at line 686 of file elf_info.c.

                                       {
    char *result = NULL;
 
    if (!flags) {
        return strdup("none");
    }
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(ver_flags_translation_table); i++) {
        if (flags & ver_flags_translation_table[i].flag) {
            result = rz_str_append(result, ver_flags_translation_table[i].name);
        }
    }
 
    return result;
}

References ver_flags_translation::flag, flags, i, NULL, RZ_ARRAY_SIZE, rz_str_append(), strdup(), and ver_flags_translation_table.

Referenced by get_vernaux_entry_sdb().

get_verdaux_entry()

static bool get_verdaux_entry ( ELFOBJ *  bin, ut64  offset, Elf_(Verdaux) *  entry  )

static

Definition at line 916 of file elf_info.c.

                                                                               {
    if (!get_verdaux_entry_aux(bin, offset, entry)) {
        RZ_LOG_WARN("Failed to read verdaux entry at 0x%" PFMT64x ".\n", offset);
        return false;
    }
 
    return true;
}

References get_verdaux_entry_aux(), PFMT64x, and RZ_LOG_WARN.

Referenced by get_versym_entry_sdb_from_verdef().

get_verdaux_entry_aux()

static bool get_verdaux_entry_aux ( ELFOBJ *  bin, ut64  offset, Elf_(Verdaux) *  entry  )

static

Definition at line 911 of file elf_info.c.

                                                                                   {
    return Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vda_name) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vda_next);
}

References Elf_(), and rz_bin_elf_read_word().

Referenced by get_verdaux_entry().

get_verdef_entry()

static bool get_verdef_entry ( ELFOBJ *  bin, ut64  offset, Elf_(Verdef) *  entry  )

static

Definition at line 935 of file elf_info.c.

                                                                             {
    if (!get_verdef_entry_aux(bin, offset, entry)) {
        RZ_LOG_WARN("Failed to read verdef entry at 0x%" PFMT64x ".\n", offset);
        return false;
    }
 
    return true;
}

References get_verdef_entry_aux(), PFMT64x, and RZ_LOG_WARN.

Referenced by get_versym_entry_sdb_from_verdef().

get_verdef_entry_aux()

static bool get_verdef_entry_aux ( ELFOBJ *  bin, ut64  offset, Elf_(Verdef) *  entry  )

static

Definition at line 925 of file elf_info.c.

                                                                                 {
    return Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vd_version) &&
        Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vd_flags) &&
        Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vd_ndx) &&
        Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vd_cnt) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vd_hash) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vd_aux) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vd_next);
}

References Elf_(), rz_bin_elf_read_half(), and rz_bin_elf_read_word().

Referenced by get_verdef_entry().

get_vernaux_entry()

static bool get_vernaux_entry ( ELFOBJ *  bin, ut64  offset, Elf_(Vernaux) *  entry  )

static

Definition at line 952 of file elf_info.c.

                                                                               {
    if (!get_vernaux_entry_aux(bin, offset, entry)) {
        RZ_LOG_WARN("Failed to read vernaux entry at 0x%" PFMT64x ".\n", offset);
        return false;
    }
 
    return true;
}

References get_vernaux_entry_aux(), PFMT64x, and RZ_LOG_WARN.

Referenced by get_verneed_entry_sdb(), and get_versym_entry_sdb_from_verneed().

get_vernaux_entry_aux()

static bool get_vernaux_entry_aux ( ELFOBJ *  bin, ut64  offset, Elf_(Vernaux) *  entry  )

static

Definition at line 944 of file elf_info.c.

                                                                                   {
    return Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vna_hash) &&
        Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vna_flags) &&
        Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vna_other) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vna_name) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vna_next);
}

References Elf_(), rz_bin_elf_read_half(), and rz_bin_elf_read_word().

Referenced by get_vernaux_entry().

get_vernaux_entry_sdb()

static Sdb* get_vernaux_entry_sdb ( ELFOBJ *  bin, Elf_(Vernaux)  vernaux_entry, size_t  index  )

static

Definition at line 1162 of file elf_info.c.

                                                                                          {
    const char *tmp = Elf_(rz_bin_elf_strtab_get)(bin->dynstr, vernaux_entry.vna_name);
    if (!tmp) {
        return NULL;
    }
 
    Sdb *sdb_vernaux = sdb_new0();
    if (!sdb_vernaux) {
        return NULL;
    }
 
    char *flags = get_ver_flags(vernaux_entry.vna_flags);
    if (!sdb_set_owned(sdb_vernaux, "flags", flags, 0)) {
        sdb_free(sdb_vernaux);
        return NULL;
    }
 
    if (!sdb_num_set(sdb_vernaux, "idx", index, 0) ||
        !sdb_num_set(sdb_vernaux, "version", vernaux_entry.vna_other, 0) ||
        !sdb_set(sdb_vernaux, "name", tmp, 0)) {
        sdb_free(sdb_vernaux);
        return NULL;
    }
 
    return sdb_vernaux;
}

References Elf_(), flags, get_ver_flags(), NULL, rz_bin_elf_strtab_get(), sdb_free(), sdb_new0(), sdb_num_set(), sdb_set(), sdb_set_owned(), and autogen_x86imm::tmp.

Referenced by get_verneed_entry_sdb().

get_verneed_entry()

static bool get_verneed_entry ( ELFOBJ *  bin, ut64  offset, Elf_(Verneed) *  entry  )

static

Definition at line 968 of file elf_info.c.

                                                                               {
    if (!get_verneed_entry_aux(bin, offset, entry)) {
        RZ_LOG_WARN("Failed to read verneed entry at 0x%" PFMT64x ".\n", offset);
        return false;
    }
 
    return true;
}

References get_verneed_entry_aux(), PFMT64x, and RZ_LOG_WARN.

Referenced by get_gnu_verneed(), and get_versym_entry_sdb_from_verneed().

get_verneed_entry_aux()

static bool get_verneed_entry_aux ( ELFOBJ *  bin, ut64  offset, Elf_(Verneed) *  entry  )

static

Definition at line 960 of file elf_info.c.

                                                                                   {
    return Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vn_version) &&
        Elf_(rz_bin_elf_read_half)(bin, &offset, &entry->vn_cnt) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vn_file) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vn_aux) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &entry->vn_next);
}

References Elf_(), rz_bin_elf_read_half(), and rz_bin_elf_read_word().

Referenced by get_verneed_entry().

get_verneed_entry_sdb()

static Sdb* get_verneed_entry_sdb ( ELFOBJ *  bin, Elf_(Verneed)  verneed_entry, size_t  offset  )

static

Definition at line 1211 of file elf_info.c.

                                                                                           {
    Sdb *sdb_version = get_verneed_entry_sdb_aux(bin, verneed_entry, offset);
    if (!sdb_version) {
        return NULL;
    }
 
    ut64 vernaux_entry_offset = offset + verneed_entry.vn_aux;
 
    for (size_t i = 0; i < verneed_entry.vn_cnt; i++) {
        Elf_(Vernaux) vernaux_entry;
        if (!get_vernaux_entry(bin, vernaux_entry_offset, &vernaux_entry)) {
            sdb_free(sdb_version);
            return NULL;
        }
 
        Sdb *sdb_vernaux = get_vernaux_entry_sdb(bin, vernaux_entry, vernaux_entry_offset);
        if (!sdb_vernaux) {
            sdb_free(sdb_version);
            return NULL;
        }
 
        char key[32];
        if (!sdb_ns_set(sdb_version, rz_strf(key, "vernaux%zu", i), sdb_vernaux)) {
            sdb_free(sdb_vernaux);
            sdb_free(sdb_version);
            return NULL;
        }
 
        sdb_free(sdb_vernaux);
 
        vernaux_entry_offset += vernaux_entry.vna_next;
    }
 
    return sdb_version;
}

References Elf_(), get_vernaux_entry(), get_vernaux_entry_sdb(), get_verneed_entry_sdb_aux(), i, key, NULL, rz_strf, sdb_free(), sdb_ns_set(), and ut64().

Referenced by get_gnu_verneed().

get_verneed_entry_sdb_aux()

static Sdb* get_verneed_entry_sdb_aux ( ELFOBJ *  bin, Elf_(Verneed)  verneed_entry, size_t  index  )

static

Definition at line 1189 of file elf_info.c.

                                                                                              {
    const char *tmp = Elf_(rz_bin_elf_strtab_get)(bin->dynstr, verneed_entry.vn_file);
    if (!tmp) {
        return NULL;
    }
 
    Sdb *sdb_version = sdb_new0();
    if (!sdb_version) {
        return NULL;
    }
 
    if (!sdb_num_set(sdb_version, "cnt", verneed_entry.vn_cnt, 0) ||
        !sdb_num_set(sdb_version, "idx", index, 0) ||
        !sdb_num_set(sdb_version, "vn_version", verneed_entry.vn_version, 0) ||
        !sdb_set(sdb_version, "file_name", tmp, 0)) {
        sdb_free(sdb_version);
        return NULL;
    }
 
    return sdb_version;
}

References Elf_(), NULL, rz_bin_elf_strtab_get(), sdb_free(), sdb_new0(), sdb_num_set(), sdb_set(), and autogen_x86imm::tmp.

Referenced by get_verneed_entry_sdb().

get_versym_entry_sdb_from_verdef()

static bool get_versym_entry_sdb_from_verdef ( ELFOBJ *  bin, Sdb *  sdb, const char *  key, Elf_(Versym)  versym  )

static

Definition at line 1035 of file elf_info.c.

                                                                                                          {
    ut64 verdef_addr;
    ut64 verdef_num;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERDEF, &verdef_addr) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERDEFNUM, &verdef_num)) {
        return false;
    }
 
    ut64 verdef_offset = Elf_(rz_bin_elf_v2p(bin, verdef_addr));
 
    if (verdef_offset == UT64_MAX) {
        return false;
    }
 
    ut64 verdef_entry_offset = verdef_offset;
 
    for (size_t i = 0; i < verdef_num; i++) {
        Elf_(Verdef) verdef_entry;
        if (!get_verdef_entry(bin, verdef_entry_offset, &verdef_entry)) {
            return false;
        }
 
        if (!verdef_entry.vd_cnt || verdef_entry.vd_ndx != (versym & VERSYM_VERSION)) {
            verdef_entry_offset += verdef_entry.vd_next;
            continue;
        }
 
        ut64 verdaux_entry_offset = verdef_entry_offset + verdef_entry.vd_aux;
 
        Elf_(Verdaux) verdaux_entry;
        if (!get_verdaux_entry(bin, verdaux_entry_offset, &verdaux_entry)) {
            return false;
        }
 
        const char *tmp = Elf_(rz_bin_elf_strtab_get)(bin->dynstr, verdaux_entry.vda_name);
        if (!tmp) {
            return false;
        }
 
        char *value = rz_str_newf("%u (%s)", versym & VERSYM_VERSION, tmp);
        if (!value) {
            return false;
        }
 
        if (!sdb_set_owned(sdb, key, value, 0)) {
            return false;
        }
 
        return true;
    }
 
    return false;
}

References DT_VERDEF, DT_VERDEFNUM, Elf_(), get_verdaux_entry(), get_verdef_entry(), i, key, rz_bin_elf_get_dt_info(), rz_bin_elf_strtab_get(), rz_bin_elf_v2p(), rz_str_newf(), sdb_set_owned(), autogen_x86imm::tmp, ut64(), UT64_MAX, value, and VERSYM_VERSION.

Referenced by get_gnu_versym().

get_versym_entry_sdb_from_verneed()

static bool get_versym_entry_sdb_from_verneed ( ELFOBJ *  bin, Sdb *  sdb, const char *  key, Elf_(Versym)  versym  )

static

Definition at line 977 of file elf_info.c.

                                                                                                           {
    ut64 verneed_addr;
    ut64 verneed_num;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERNEED, &verneed_addr) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_VERNEEDNUM, &verneed_num)) {
        return false;
    }
 
    ut64 verneed_offset = Elf_(rz_bin_elf_v2p(bin, verneed_addr));
 
    if (verneed_offset == UT64_MAX) {
        return false;
    }
 
    ut64 verneed_entry_offset = verneed_offset;
 
    for (size_t i = 0; i < verneed_num; i++) {
        Elf_(Verneed) verneed_entry;
        if (!get_verneed_entry(bin, verneed_entry_offset, &verneed_entry)) {
            return false;
        }
 
        ut64 vernaux_entry_offset = verneed_entry_offset + verneed_entry.vn_aux;
 
        for (size_t j = 0; j < verneed_entry.vn_cnt; j++) {
            Elf_(Vernaux) vernaux_entry;
            if (!get_vernaux_entry(bin, vernaux_entry_offset, &vernaux_entry)) {
                return false;
            }
 
            if (vernaux_entry.vna_other != versym) {
                vernaux_entry_offset += vernaux_entry.vna_next;
                continue;
            }
 
            const char *tmp = Elf_(rz_bin_elf_strtab_get)(bin->dynstr, vernaux_entry.vna_name);
            if (!tmp) {
                return false;
            }
 
            char *value = rz_str_newf("%u (%s)", versym & VERSYM_VERSION, tmp);
            if (!value) {
                return false;
            }
 
            if (!sdb_set_owned(sdb, key, value, 0)) {
                return false;
            }
 
            return true;
        }
 
        verneed_entry_offset += verneed_entry.vn_next;
    }
 
    return false;
}

References DT_VERNEED, DT_VERNEEDNUM, Elf_(), get_vernaux_entry(), get_verneed_entry(), i, key, rz_bin_elf_get_dt_info(), rz_bin_elf_strtab_get(), rz_bin_elf_v2p(), rz_str_newf(), sdb_set_owned(), autogen_x86imm::tmp, ut64(), UT64_MAX, value, and VERSYM_VERSION.

Referenced by get_gnu_versym().

has_dt_rpath_entry()

static bool has_dt_rpath_entry ( ELFOBJ *  bin )

static

Definition at line 702 of file elf_info.c.

                                            {
    return Elf_(rz_bin_elf_get_dt_info)(bin, DT_RPATH, NULL) || Elf_(rz_bin_elf_get_dt_info)(bin, DT_RUNPATH, NULL);
}

References DT_RPATH, DT_RUNPATH, Elf_(), NULL, and rz_bin_elf_get_dt_info().

Referenced by rz_bin_elf_get_rpath().

has_thumb_symbol()

static bool has_thumb_symbol ( ELFOBJ *  bin )

static

Definition at line 587 of file elf_info.c.

                                          {
    RzBinElfSymbol *symbol;
    rz_bin_elf_foreach_symbols(bin, symbol) {
        if (Elf_(rz_bin_elf_is_thumb_addr)(symbol->paddr) || Elf_(rz_bin_elf_is_thumb_addr)(symbol->vaddr)) {
            return true;
        }
    }
 
    return false;
}

References Elf_(), rz_bin_elf_symbol_t::paddr, rz_bin_elf_foreach_symbols, rz_bin_elf_is_thumb_addr(), and rz_bin_elf_symbol_t::vaddr.

Referenced by rz_bin_elf_get_bits().

is_elf_class64()

static bool is_elf_class64 ( ELFOBJ *  bin )

static

Definition at line 822 of file elf_info.c.

                                        {
    return bin->ehdr.e_ident[EI_CLASS] == ELFCLASS64;
}

References EI_CLASS, and ELFCLASS64.

Referenced by get_abi_mips().

is_mips_n32()

static bool is_mips_n32 ( ELFOBJ *  bin )

static

Definition at line 842 of file elf_info.c.

                                     {
    if (bin->ehdr.e_ident[EI_CLASS] != ELFCLASS32) {
        return false;
    }
 
    if ((bin->ehdr.e_flags & EF_MIPS_ABI2) == 0 || (bin->ehdr.e_flags & EF_MIPS_ABI) != 0) {
        return false;
    }
 
    return true;
}

References EF_MIPS_ABI, EF_MIPS_ABI2, EI_CLASS, and ELFCLASS32.

Referenced by get_abi_mips().

is_mips_o32()

static bool is_mips_o32 ( ELFOBJ *  bin )

static

Definition at line 826 of file elf_info.c.

                                     {
    if (bin->ehdr.e_ident[EI_CLASS] != ELFCLASS32) {
        return false;
    }
 
    if ((bin->ehdr.e_flags & EF_MIPS_ABI2) != 0) {
        return false;
    }
 
    if ((bin->ehdr.e_flags & EF_MIPS_ABI) != 0 && (bin->ehdr.e_flags & EF_MIPS_ABI) != EF_MIPS_ABI_O32) {
        return false;
    }
 
    return true;
}

References EF_MIPS_ABI, EF_MIPS_ABI2, EF_MIPS_ABI_O32, EI_CLASS, and ELFCLASS32.

Referenced by get_abi_mips().

is_playstation_hack()

static int is_playstation_hack ( ELFOBJ *  bin, Elf_(Word)  mips_type  )

static

Definition at line 608 of file elf_info.c.

                                                                  {
    return Elf_(rz_bin_elf_is_executable)(bin) && Elf_(rz_bin_elf_is_static)(bin) && mips_type == EF_MIPS_ARCH_3;
}

References EF_MIPS_ARCH_3, Elf_(), rz_bin_elf_is_executable(), and rz_bin_elf_is_static().

Referenced by get_bits_mips().

read_elf_intrp()

static char* read_elf_intrp ( ELFOBJ *  bin, ut64  addr, size_t  size  )

static

Definition at line 630 of file elf_info.c.

                                                                 {
    char *str = malloc(size + 1);
    if (!str) {
        return NULL;
    }
 
    if (rz_buf_read_at(bin->b, addr, (ut8 *)str, size) < 0) {
        free(str);
        return NULL;
    }
 
    str[size] = 0;
 
    return str;
}

References addr, free(), malloc(), NULL, rz_buf_read_at(), and cmd_descs_generate::str.

Referenced by get_elf_intrp().

rz_bin_elf_get_abi()

RZ_OWN char* Elf_() rz_bin_elf_get_abi

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the application binary interface.

Parameters

elf

type

Returns

allocated string

Only work on mips right now. Use the elf header to deduce the application binary interface

Definition at line 1386 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    if (bin->ehdr.e_machine == EM_MIPS) {
        return get_abi_mips(bin);
    }
 
    return NULL;
}

References EM_MIPS, get_abi_mips(), NULL, and rz_return_val_if_fail.

Referenced by add_abi_info().

rz_bin_elf_get_arch()

RZ_OWN char* Elf_() rz_bin_elf_get_arch

(

RZ_NONNULL ELFOBJ *

bin

)

Get the elf binary architecture.

Parameters

elf

binary

Returns

an allocated string

With the elf header (e_machine) deduce the elf architecture

Definition at line 1403 of file elf_info.c.

                                                               {
    rz_return_val_if_fail(bin, NULL);
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(arch_translation_table); i++) {
        if (bin->ehdr.e_machine == arch_translation_table[i].arch) {
            return strdup(arch_translation_table[i].name);
        }
    }
 
    return strdup("");
}

References arch_translation_table, i, NULL, RZ_ARRAY_SIZE, rz_return_val_if_fail, and strdup().

rz_bin_elf_get_baddr()

ut64 Elf_() rz_bin_elf_get_baddr

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the base address of the binary.

Parameters

elf

binary

Returns

the base address

To compute the base address, one determines the memory address associated with the lowest p_vaddr value for a PT_LOAD segment.

Definition at line 1772 of file elf_info.c.

                                                        {
    rz_return_val_if_fail(bin, 0);
 
    if (Elf_(rz_bin_elf_is_relocatable)(bin)) {
        return 0x08000000;
    }
 
    if (Elf_(rz_bin_elf_has_segments)(bin)) {
        return compute_baddr_from_phdr(bin);
    }
 
    return 0;
}

References compute_baddr_from_phdr(), Elf_(), rz_bin_elf_has_segments(), rz_bin_elf_is_relocatable(), and rz_return_val_if_fail.

Referenced by get_main_offset_x86_pie(), and init().

rz_bin_elf_get_bits()

int Elf_() rz_bin_elf_get_bits

(

RZ_NONNULL ELFOBJ *

bin

)

Return the elf bits.

Parameters

elf

binary

Returns

the number of bits

...

Definition at line 1697 of file elf_info.c.

                                                      {
    rz_return_val_if_fail(bin, 0);
 
    /* Hack for ARCompact */
    if (arch_is_arcompact(bin)) {
        return 16;
    }
 
    /* Hack for Ps2 */
    if (arch_is_mips(bin)) {
        return get_bits_mips(bin);
    }
 
    /* Hack for Thumb */
    if (Elf_(rz_bin_elf_is_arm_binary_supporting_thumb)(bin)) {
        if (!Elf_(rz_bin_elf_is_static)(bin) && has_thumb_symbol(bin)) {
            return 16;
        }
 
        ut64 entry = Elf_(rz_bin_elf_get_entry_offset)(bin);
        if (Elf_(rz_bin_elf_is_thumb_addr)(entry)) {
            return 16;
        }
    }
 
    return get_bits_common(bin);
}

References arch_is_arcompact(), arch_is_mips(), Elf_(), get_bits_common(), get_bits_mips(), has_thumb_symbol(), rz_bin_elf_get_entry_offset(), rz_bin_elf_is_arm_binary_supporting_thumb(), rz_bin_elf_is_static(), rz_bin_elf_is_thumb_addr(), rz_return_val_if_fail, and ut64().

Referenced by init().

rz_bin_elf_get_boffset()

ut64 Elf_() rz_bin_elf_get_boffset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the base offset of the binary.

Parameters

elf

binary

Returns

the base offset

To compute the base address, one determines the memory address associated with the lowest p_offset value for a PT_LOAD segment.

Definition at line 1795 of file elf_info.c.

                                                          {
    rz_return_val_if_fail(bin, 0);
 
    if (Elf_(rz_bin_elf_has_segments)(bin)) {
        return compute_boffset_from_phdr(bin);
    }
 
    return 0;
}

References compute_boffset_from_phdr(), Elf_(), rz_bin_elf_has_segments(), and rz_return_val_if_fail.

Referenced by init().

rz_bin_elf_get_compiler()

RZ_OWN char* Elf_() rz_bin_elf_get_compiler

(

RZ_NONNULL ELFOBJ *

bin

)

Get the compiler info from the .comment section.

Parameters

elf

binary

Returns

a ptr to an allocated string

...

Definition at line 1339 of file elf_info.c.

                                                                   {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSection *section = Elf_(rz_bin_elf_get_section_with_name)(bin, ".comment");
    if (!section) {
        return NULL;
    }
 
    ut64 offset = section->offset;
    ut64 size = RZ_MIN(section->size, 128);
    if (size < 1) {
        return NULL;
    }
 
    char *result = malloc(size + 1);
    if (!result) {
        return NULL;
    }
 
    if (rz_buf_read_at(bin->b, offset, (ut8 *)result, size) < 1) {
        free(result);
        return NULL;
    }
    result[size] = 0;
 
    size_t result_len = strlen(result);
    char *end = result + result_len;
 
    if (result_len != size && end[1]) {
        end[0] = ' ';
    }
 
    rz_str_trim(result);
    char *res = rz_str_escape(result);
 
    free(result);
    return res;
}

References Elf_(), test_evm::end, free(), malloc(), NULL, section::offset, rz_bin_elf_get_section_with_name(), rz_buf_read_at(), RZ_MIN, rz_return_val_if_fail, rz_str_escape(), rz_str_trim(), section::size, and ut64().

rz_bin_elf_get_cpu()

RZ_OWN char* Elf_() rz_bin_elf_get_cpu

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the cpu.

Parameters

elf

type

Returns

allocated string

Only work on mips right now. Use the elf header to deduce the cpu

Definition at line 1422 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return NULL;
    }
 
    if (bin->ehdr.e_machine == EM_MIPS) {
        return get_cpu_mips(bin);
    }
 
    return NULL;
}

References Elf_(), EM_MIPS, get_cpu_mips(), NULL, rz_bin_elf_has_segments(), and rz_return_val_if_fail.

Referenced by add_cpu_info().

rz_bin_elf_get_elf_class()

RZ_OWN char* Elf_() rz_bin_elf_get_elf_class

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the elf class.

Parameters

elf

binary

Returns

allocated string

Check the elf header (e_ident) to deduce the elf class

Definition at line 1443 of file elf_info.c.

                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(class_translation_table); i++) {
        if (bin->ehdr.e_ident[EI_CLASS] == class_translation_table[i].class) {
            return strdup(class_translation_table[i].name);
        }
    }
 
    return rz_str_newf("<unknown: %x>", bin->ehdr.e_ident[EI_CLASS]);
}

References class_translation::class, class_translation_table, EI_CLASS, i, NULL, RZ_ARRAY_SIZE, rz_return_val_if_fail, rz_str_newf(), and strdup().

rz_bin_elf_get_entry_offset()

ut64 Elf_() rz_bin_elf_get_entry_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Get the entry offset.

Parameters

elf

binary

Returns

the entry offset

Get the entry offset from the elf header (e_entry), and if the information isn't defined section header will be used.

Definition at line 1813 of file elf_info.c.

                                                               {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    if (!Elf_(rz_bin_elf_is_executable)(bin)) {
        return UT64_MAX;
    }
 
    ut64 entry = bin->ehdr.e_entry;
    if (entry) {
        ut64 tmp = Elf_(rz_bin_elf_v2p)(bin, entry);
        if (tmp == UT64_MAX) {
            return entry;
        }
 
        return tmp;
    }
 
    return get_entry_offset_from_shdr(bin);
}

References Elf_(), get_entry_offset_from_shdr(), rz_bin_elf_is_executable(), rz_bin_elf_v2p(), rz_return_val_if_fail, autogen_x86imm::tmp, ut64(), and UT64_MAX.

Referenced by rz_bin_elf_get_bits(), and rz_bin_elf_get_main_offset().

rz_bin_elf_get_file_type()

RZ_OWN char* Elf_() rz_bin_elf_get_file_type

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the file type.

Parameters

elf

binary

Returns

allocated string

Use the elf header (e_type) to deduce the file type

Definition at line 1462 of file elf_info.c.

                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    char *result = get_file_type_basic(bin);
    if (result) {
        return result;
    }
 
    if (file_type_is_processor_specific(bin)) {
        return rz_str_newf("Processor Specific: %x", bin->ehdr.e_type);
    }
 
    if (file_type_is_os_specific(bin)) {
        return rz_str_newf("OS Specific: %x", bin->ehdr.e_type);
    }
 
    return rz_str_newf("<unknown>: %x", bin->ehdr.e_type);
}

References file_type_is_os_specific(), file_type_is_processor_specific(), get_file_type_basic(), NULL, rz_return_val_if_fail, and rz_str_newf().

rz_bin_elf_get_fini_offset()

ut64 Elf_() rz_bin_elf_get_fini_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the fini offset of the binary.

Parameters

elf

binary

Returns

the init offset

Get the offset from the vaddr store in the dynamic section (dt_fini)

Definition at line 1840 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, 0);
 
    ut64 addr;
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin)) {
        return 0;
    }
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_FINI, &addr)) {
        return 0;
    }
 
    return Elf_(rz_bin_elf_v2p)(bin, addr);
}

References addr, DT_FINI, Elf_(), rz_bin_elf_get_dt_info(), rz_bin_elf_has_dt_dynamic(), rz_bin_elf_v2p(), rz_return_val_if_fail, and ut64().

rz_bin_elf_get_head_flag()

RZ_OWN char* Elf_() rz_bin_elf_get_head_flag

(

RZ_NONNULL ELFOBJ *

bin

)

Return the head flag.

Returns

allocated string

...

Definition at line 1487 of file elf_info.c.

                                                                    {
    rz_return_val_if_fail(bin, NULL);
 
    char *head_flag = get_head_flag(bin);
 
    if (RZ_STR_ISEMPTY(head_flag)) {
        free(head_flag);
        return strdup("unknown_flag");
    }
 
    return head_flag;
}

References free(), get_head_flag(), NULL, rz_return_val_if_fail, RZ_STR_ISEMPTY, and strdup().

rz_bin_elf_get_init_offset()

ut64 Elf_() rz_bin_elf_get_init_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the init offset of the binary.

Parameters

elf

binary

Returns

the init offset

Get the offset from the vaddr store in the dynamic section (dt_init)

Definition at line 1863 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, 0);
 
    ut64 addr;
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin)) {
        return 0;
    }
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_INIT, &addr)) {
        return 0;
    }
 
    return Elf_(rz_bin_elf_v2p)(bin, addr);
}

References addr, DT_INIT, Elf_(), rz_bin_elf_get_dt_info(), rz_bin_elf_has_dt_dynamic(), rz_bin_elf_v2p(), rz_return_val_if_fail, and ut64().

rz_bin_elf_get_intrp()

RZ_OWN char* Elf_() rz_bin_elf_get_intrp

(

RZ_NONNULL ELFOBJ *

bin

)

Get the program interpreter.

Parameters

elf

binary

Returns

an allocated string

Get the program interpreter from the phdr

Definition at line 1568 of file elf_info.c.

                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return NULL;
    }
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_INTERP);
    if (!segment || !segment->is_valid) {
        return NULL;
    }
 
    return get_elf_intrp(bin, segment);
}

References Elf_(), get_elf_intrp(), NULL, PT_INTERP, rz_bin_elf_get_segment_with_type(), rz_bin_elf_has_segments(), rz_return_val_if_fail, and RzBinElfSegment.

rz_bin_elf_get_libs()

RZ_OWN RzList* Elf_() rz_bin_elf_get_libs

(

RZ_NONNULL ELFOBJ *

bin

)

List all imported lib.

Parameters

elf

binary

Returns

an allocated list of RzBinElfLib

Use dynamic information (dt_needed) to generate a list of imported lib

Definition at line 877 of file elf_info.c.

                                                                 {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_dt_dynamic)(bin) || !bin->dynstr) {
        return NULL;
    }
 
    RzVector *dt_needed = Elf_(rz_bin_elf_get_dt_needed)(bin);
    if (!dt_needed) {
        return NULL;
    }
 
    RzList *result = rz_list_newf(free);
    if (!result) {
        return NULL;
    }
 
    ut64 *iter = NULL;
    rz_vector_foreach(dt_needed, iter) {
        char *tmp = Elf_(rz_bin_elf_strtab_get_dup)(bin->dynstr, *iter);
        if (!tmp) {
            rz_list_free(result);
            return NULL;
        }
 
        if (!rz_list_append(result, tmp)) {
            rz_list_free(result);
            return NULL;
        }
    }
 
    return result;
}

References Elf_(), free(), NULL, rz_bin_elf_get_dt_needed(), rz_bin_elf_has_dt_dynamic(), rz_bin_elf_strtab_get_dup(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_return_val_if_fail, rz_vector_foreach, autogen_x86imm::tmp, and ut64().

rz_bin_elf_get_machine_name()

RZ_OWN char* Elf_() rz_bin_elf_get_machine_name

(

RZ_NONNULL ELFOBJ *

bin

)

Return a string representing the machine name.

Parameters

elf

type

Returns

allocated string

Use http://www.sco.com/developers/gabi/latest/ch4.eheader.html and the elf header (e_machine)

Definition at line 1508 of file elf_info.c.

                                                                       {
    rz_return_val_if_fail(bin, NULL);
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(machine_name_translation_table); i++) {
        if (bin->ehdr.e_machine == machine_name_translation_table[i].machine) {
            return strdup(machine_name_translation_table[i].name);
        }
    }
 
    return rz_str_newf("<unknown>: 0x%x", bin->ehdr.e_machine);
}

References i, machine_name_translation_table, NULL, RZ_ARRAY_SIZE, rz_return_val_if_fail, rz_str_newf(), and strdup().

rz_bin_elf_get_main_offset()

ut64 Elf_() rz_bin_elf_get_main_offset

(

RZ_NONNULL ELFOBJ *

bin

)

Compute the main offset of the binary.

Parameters

elf

binary

Returns

the main offset

...

Definition at line 1886 of file elf_info.c.

                                                              {
    rz_return_val_if_fail(bin, UT64_MAX);
 
    ut8 buf[256] = { 0 };
    ut64 entry = Elf_(rz_bin_elf_get_entry_offset)(bin);
    ut64 main_addr;
 
    if (entry == UT64_MAX || entry > bin->size || (entry + sizeof(buf)) > bin->size) {
        return UT64_MAX;
    }
 
    if (rz_buf_read_at(bin->b, entry, buf, sizeof(buf)) < 0) {
        return UT64_MAX;
    }
 
    main_addr = get_main_offset_arm64(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_arm_glibc(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_mips(bin, entry, buf, RZ_ARRAY_SIZE(buf));
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_x86_gcc(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_x86_pie(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_x86_non_pie(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    main_addr = get_main_offset_linux_64_pie(bin, entry, buf);
    if (main_addr != UT64_MAX) {
        return main_addr;
    }
 
    return get_main_offset_from_symbol(bin);
}

References Elf_(), get_main_offset_arm64(), get_main_offset_arm_glibc(), get_main_offset_from_symbol(), get_main_offset_linux_64_pie(), get_main_offset_mips(), get_main_offset_x86_gcc(), get_main_offset_x86_non_pie(), get_main_offset_x86_pie(), RZ_ARRAY_SIZE, rz_bin_elf_get_entry_offset(), rz_buf_read_at(), rz_return_val_if_fail, ut64(), and UT64_MAX.

rz_bin_elf_get_osabi_name()

RZ_OWN char* Elf_() rz_bin_elf_get_osabi_name

(

RZ_NONNULL ELFOBJ *

bin

)

Return the os application binary interface name.

Parameters

elf

binary

Returns

an allocated string

Check the ehdr or the shdr to get the os name

Definition at line 1527 of file elf_info.c.

                                                                     {
    rz_return_val_if_fail(bin, NULL);
 
    char *name = get_osabi_name_from_ehdr(bin);
    if (name) {
        return name;
    }
 
    name = get_osabi_name_from_shdr(bin);
    if (name) {
        return name;
    }
 
    return strdup("linux");
}

References get_osabi_name_from_ehdr(), get_osabi_name_from_shdr(), name, NULL, rz_return_val_if_fail, and strdup().

rz_bin_elf_get_rpath()

RZ_OWN char* Elf_() rz_bin_elf_get_rpath

(

RZ_NONNULL ELFOBJ *

bin

)

Get the rpath.

Parameters

elf

binary

Returns

allocated string

Use DT_RPATH or DT_RUNPATH to return the string

Definition at line 1550 of file elf_info.c.

                                                                {
    rz_return_val_if_fail(bin, NULL);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin) || !bin->dynstr || !has_dt_rpath_entry(bin)) {
        return NULL;
    }
 
    Elf_(Xword) val = get_dt_rpath(bin);
    return Elf_(rz_bin_elf_strtab_get_dup)(bin->dynstr, val);
}

References Elf_(), has_dt_rpath_entry(), NULL, rz_bin_elf_has_segments(), rz_bin_elf_strtab_get_dup(), rz_return_val_if_fail, and val.

rz_bin_elf_get_symbols_info()

RZ_IPI RZ_OWN Sdb* Elf_() rz_bin_elf_get_symbols_info

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 1301 of file elf_info.c.

                                                                             {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_is_executable)(bin)) {
        return NULL;
    }
 
    Sdb *res = sdb_new0();
    if (!res) {
        return NULL;
    }
 
    Sdb *sdb = get_gnu_verneed(bin);
    if (sdb && !sdb_ns_set(res, "verneed", sdb)) {
        sdb_free(res);
        sdb_free(sdb);
        return NULL;
    }
    sdb_free(sdb);
 
    sdb = get_gnu_versym(bin);
    if (sdb && !sdb_ns_set(res, "versym", sdb)) {
        sdb_free(res);
        sdb_free(sdb);
        return NULL;
    }
    sdb_free(sdb);
 
    return res;
}

References Elf_(), get_gnu_verneed(), get_gnu_versym(), NULL, rz_bin_elf_is_executable(), rz_return_val_if_fail, sdb_free(), sdb_new0(), and sdb_ns_set().

Referenced by init_symbols_info_aux().

rz_bin_elf_has_nx()

bool Elf_() rz_bin_elf_has_nx

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the stack is not executable.

Parameters

elf

binary

Returns

true, false

Check p_flags from the segment PT_GNU_STACK

Definition at line 1615 of file elf_info.c.

                                                     {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_has_segments)(bin)) {
        return false;
    }
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_GNU_STACK);
    if (!segment || !segment->is_valid) {
        return false;
    }
 
    return !(segment->data.p_flags & PF_X);
}

References Elf_(), PF_X, PT_GNU_STACK, rz_bin_elf_get_segment_with_type(), rz_bin_elf_has_segments(), rz_return_val_if_fail, and RzBinElfSegment.

rz_bin_elf_has_relro()

int Elf_() rz_bin_elf_has_relro

(

RZ_NONNULL ELFOBJ *

bin

)

Analyse if the elf binary has relro or partial relro.

Parameters

elf

binary

Returns

RZ_BIN_ELF_NO_RELRO, RZ_BIN_ELF_PART_RELRO or RZ_BIN_ELF_FULL_RELRO

Check if the elf has bind now enable and with PT_GNU_RELRO can deduct the relro type

Definition at line 1733 of file elf_info.c.

                                                       {
    rz_return_val_if_fail(bin, RZ_BIN_ELF_NO_RELRO);
 
    bool is_bind_now = elf_is_bind_now(bin);
    bool has_gnu_relro = elf_has_gnu_relro(bin);
 
    if (has_gnu_relro) {
        if (is_bind_now) {
            return RZ_BIN_ELF_FULL_RELRO;
        }
 
        return RZ_BIN_ELF_PART_RELRO;
    }
 
    return RZ_BIN_ELF_NO_RELRO;
}

References elf_has_gnu_relro(), elf_is_bind_now(), RZ_BIN_ELF_FULL_RELRO, RZ_BIN_ELF_NO_RELRO, RZ_BIN_ELF_PART_RELRO, and rz_return_val_if_fail.

Referenced by get_import_addr_x86_manual(), and init_dt_dynamic_sdb().

rz_bin_elf_has_va()

bool Elf_() rz_bin_elf_has_va

(

ELFOBJ *

bin

)

Check if the elf use virtual address.

Parameters

elf

binary

Returns

always true

Return always true

Definition at line 1637 of file elf_info.c.

                                          {
    return true;
}

rz_bin_elf_is_big_endian()

bool Elf_() rz_bin_elf_is_big_endian

(

RZ_NONNULL ELFOBJ *

bin

)

Check the binary endianness.

Parameters

elf

type

Returns

is_big_endian ?

Use the elf header (e_ident[EI_DATA]) to check the binary endianness

Definition at line 1757 of file elf_info.c.

                                                            {
    rz_return_val_if_fail(bin, false);
 
    return bin->ehdr.e_ident[EI_DATA] == ELFDATA2MSB;
}

References EI_DATA, ELFDATA2MSB, and rz_return_val_if_fail.

rz_bin_elf_is_executable()

bool Elf_() rz_bin_elf_is_executable

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the elf binary is executable.

Parameters

elf

binary

Returns

is_executable ?

Use the elf header entry e_type to deduct if the elf is executable.

Definition at line 1648 of file elf_info.c.

                                                            {
    rz_return_val_if_fail(bin, false);
 
    const Elf_(Half) type = bin->ehdr.e_type;
    return type == ET_EXEC || type == ET_DYN;
}

References Elf_(), ET_DYN, ET_EXEC, rz_return_val_if_fail, and type.

Referenced by get_dynamic_elf_symbols(), is_playstation_hack(), rz_bin_elf_get_entry_offset(), and rz_bin_elf_get_symbols_info().

rz_bin_elf_is_relocatable()

bool Elf_() rz_bin_elf_is_relocatable

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the elf binary is relocatable.

Parameters

elf

binary

Returns

is_relocatable ?

Use the elf header entry e_type to deduct if the elf is relocatable.

Definition at line 1662 of file elf_info.c.

                                                             {
    rz_return_val_if_fail(bin, false);
    return bin->ehdr.e_type == ET_REL;
}

References ET_REL, and rz_return_val_if_fail.

Referenced by convert_elf_symbol_entry(), filter_import(), fix_rva_and_offset(), init(), rz_bin_elf_get_baddr(), rz_bin_elf_p2v(), rz_bin_elf_v2p(), and set_elf_section_aux().

rz_bin_elf_is_static()

bool Elf_() rz_bin_elf_is_static

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the binary is statically-linked library.

Parameters

elf

binary

Returns

is_static ?

Check the presence of PT_INTERP or PT_DYNAMIC in the program header

Definition at line 1674 of file elf_info.c.

                                                        {
    rz_return_val_if_fail(bin, false);
 
    RzBinElfSegment *segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_INTERP);
    if (segment && segment->is_valid) {
        return false;
    }
 
    segment = Elf_(rz_bin_elf_get_segment_with_type)(bin, PT_DYNAMIC);
    if (segment && segment->is_valid) {
        return false;
    }
 
    return true;
}

References Elf_(), PT_DYNAMIC, PT_INTERP, rz_bin_elf_get_segment_with_type(), rz_return_val_if_fail, and RzBinElfSegment.

Referenced by init(), is_playstation_hack(), and rz_bin_elf_get_bits().

rz_bin_elf_is_stripped()

bool Elf_() rz_bin_elf_is_stripped

(

RZ_NONNULL ELFOBJ *

bin

)

Check if the binary is stripped.

Parameters

elf	binary
is_stripped	?

Returns

a ptr to a new allocated RzBinSymbol

Use the shdr to check if the binary is stripped

Definition at line 1591 of file elf_info.c.

                                                          {
    rz_return_val_if_fail(bin, false);
 
    if (!Elf_(rz_bin_elf_has_sections)(bin)) {
        return false;
    }
 
    RzBinElfSection *section;
    rz_bin_elf_foreach_sections(bin, section) {
        if (section->type == SHT_SYMTAB) {
            return false;
        }
    }
 
    return true;
}

References Elf_(), rz_bin_elf_foreach_sections, rz_bin_elf_has_sections(), rz_return_val_if_fail, and SHT_SYMTAB.

Variable Documentation

arch_translation_table

const struct arch_translation arch_translation_table[]

static

Definition at line 1 of file elf_info.c.

Referenced by rz_bin_elf_get_arch().

class_translation_table

const struct class_translation class_translation_table[]

static

Initial value:

= {
    { ELFCLASSNONE, "none" },
    { ELFCLASS32, "ELF32" },
    { ELFCLASS64, "ELF64" }
}

Definition at line 1 of file elf_info.c.

Referenced by rz_bin_elf_get_elf_class().

cpu_mips_translation_table

const struct cpu_mips_translation cpu_mips_translation_table[]

static

Initial value:

= {
    { EF_MIPS_ARCH_1, "mips1" },
    { EF_MIPS_ARCH_2, "mips2" },
    { EF_MIPS_ARCH_3, "mips3" },
    { EF_MIPS_ARCH_4, "mips4" },
    { EF_MIPS_ARCH_5, "mips5" },
    { EF_MIPS_ARCH_32, "mips32" },
    { EF_MIPS_ARCH_64, "mips64" },
    { EF_MIPS_ARCH_32R2, "mips32r2" },
    { EF_MIPS_ARCH_64R2, "mips64r2" },
}

Definition at line 1 of file elf_info.c.

Referenced by get_cpu_mips().

machine_name_translation_table

const struct machine_name_translation machine_name_translation_table[]

static

Definition at line 1 of file elf_info.c.

Referenced by rz_bin_elf_get_machine_name().

mips_bits_translation_table

const struct mips_bits_translation mips_bits_translation_table[]

static

Initial value:

= {
    { EF_MIPS_ARCH_1, 32 },
    { EF_MIPS_ARCH_2, 32 },
    { EF_MIPS_ARCH_3, 32 },
    { EF_MIPS_ARCH_4, 32 },
    { EF_MIPS_ARCH_5, 32 },
    { EF_MIPS_ARCH_32, 32 },
    { EF_MIPS_ARCH_64, 64 },
    { EF_MIPS_ARCH_32R2, 32 },
    { EF_MIPS_ARCH_64R2, 64 }
}

Definition at line 1 of file elf_info.c.

Referenced by get_bits_mips_common().

section_note_osabi_translation_table

const struct section_note_osabi_translation section_note_osabi_translation_table[]

static

Initial value:

= {
    { ".note.openbsd.ident", "openbsd" },
    { ".note.minix.ident", "minix" },
    { ".note.netbsd.ident", "netbsd" },
    { ".note.android.ident", "android" }
}

Definition at line 1 of file elf_info.c.

Referenced by get_osabi_name_from_section_note().

ver_flags_translation_table

const struct ver_flags_translation ver_flags_translation_table[]

static

Initial value:

= {
    { VER_FLG_BASE, "BASE " },
    { VER_FLG_BASE | VER_FLG_WEAK, "| " },
    { VER_FLG_WEAK, "WEAK " },
    { ~(VER_FLG_BASE | VER_FLG_WEAK), "| <unknown>" }
}

Definition at line 1 of file elf_info.c.

Referenced by get_ver_flags().