elf_sections.c File Reference

#include "elf.h"

Go to the source code of this file.

Classes
struct	type_translation
struct	flag_translation

Functions
static bool	create_section_from_phdr (ELFOBJ *bin, RzVector *result, const char *name, ut64 addr, ut64 sz)
static const char *	get_plt_name (ELFOBJ *bin)
static bool	create_section_plt (ELFOBJ *bin, RzVector *result)
static void	rz_bin_elf_section_free (void *e, RZ_UNUSED void *user)
static RzVector *	get_sections_from_dt_dynamic (ELFOBJ *bin)
static bool	get_shdr_entry_aux (ELFOBJ *bin, Elf_(Shdr) *section, ut64 offset)
static bool	get_shdr_entry (ELFOBJ *bin, Elf_(Shdr) *section, ut64 offset)
static bool	set_elf_section_name (ELFOBJ *bin, RzBinElfSection *section, Elf_(Shdr) *shdr, size_t id)
static bool	set_elf_section_aux (ELFOBJ *bin, RzBinElfSection *section, Elf_(Shdr) *shdr, size_t id)
static bool	verify_shdr_entry (ELFOBJ *bin, Elf_(Shdr) *section)
static bool	set_elf_section (ELFOBJ *bin, RzBinObjectLoadOptions *option, RzBinElfSection *section, Elf_(Shdr) *shdr, size_t id)
RZ_BORROW RzBinElfSection *Elf_()	rz_bin_elf_get_section (RZ_NONNULL ELFOBJ *bin, Elf_(Half) index)
RZ_BORROW RzBinElfSection *Elf_()	rz_bin_elf_get_section_with_name (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL const char *name)
RZ_OWN RzList *Elf_()	rz_bin_elf_section_flag_to_rzlist (ut64 flag)
	Return a list of string representing flag options. More...
static RzBinElfSection	convert_elf_section (ELFOBJ *bin, RzBinObjectLoadOptions *options, Elf_(Shdr) *shdr, size_t pos)
static RzVector *	convert_sections_from_shdr (ELFOBJ *bin, RzBinObjectLoadOptions *options, RzVector *sections)
static RzVector *	convert_sections (ELFOBJ *bin, RzBinObjectLoadOptions *options, RzVector *sections)
RZ_OWN RzVector *Elf_()	rz_bin_elf_convert_sections (RZ_NONNULL ELFOBJ *bin, RZ_NONNULL RzBinObjectLoadOptions *options, RzVector *sections)
RZ_OWN RzVector *Elf_()	rz_bin_elf_sections_new (RZ_NONNULL ELFOBJ *bin)
RZ_OWN char *Elf_()	rz_bin_elf_section_type_to_string (ut64 type)
	Return a string representing the elf type. More...
bool Elf_()	rz_bin_elf_has_sections (RZ_NONNULL ELFOBJ *bin)

Variables
static const struct type_translation	type_translation_table []
static const struct flag_translation	flag_translation_table []

Function Documentation

convert_elf_section()

static RzBinElfSection convert_elf_section ( ELFOBJ *  bin, RzBinObjectLoadOptions *  options, Elf_(Shdr) *  shdr, size_t  pos  )

static

Definition at line 316 of file elf_sections.c.

                                                                                                                        {
    RzBinElfSection section;
 
    if (!set_elf_section(bin, options, &section, shdr, pos)) {
        RZ_LOG_WARN("The section %zu at 0x%" PFMT64x " seems to be invalid.\n", pos, section.offset);
    }
 
    return section;
}

References section::offset, options, PFMT64x, pos, RZ_LOG_WARN, and set_elf_section().

Referenced by convert_sections_from_shdr().

convert_sections()

static RzVector* convert_sections ( ELFOBJ *  bin, RzBinObjectLoadOptions *  options, RzVector *  sections  )

static

Definition at line 349 of file elf_sections.c.

                                                                                                    {
    RzVector *result = convert_sections_from_shdr(bin, options, sections);
    if (result) {
        return result;
    }
 
    if (Elf_(rz_bin_elf_has_segments)(bin)) {
        return get_sections_from_dt_dynamic(bin);
    }
 
    return result;
}

References convert_sections_from_shdr(), Elf_, get_sections_from_dt_dynamic(), options, rz_bin_elf_has_segments(), and sections().

Referenced by rz_bin_elf_convert_sections().

convert_sections_from_shdr()

static RzVector* convert_sections_from_shdr ( ELFOBJ *  bin, RzBinObjectLoadOptions *  options, RzVector *  sections  )

static

Definition at line 326 of file elf_sections.c.

                                                                                                              {
    if (!sections) {
        return NULL;
    }
 
    RzVector *result = rz_vector_new(sizeof(RzBinElfSection), rz_bin_elf_section_free, NULL);
    if (!result) {
        return NULL;
    }
 
    size_t i;
    Elf_(Shdr) * section;
    rz_vector_enumerate(sections, section, i) {
        RzBinElfSection tmp = convert_elf_section(bin, options, section, i);
        if (!rz_vector_push(result, &tmp)) {
            rz_vector_free(result);
            return NULL;
        }
    }
 
    return result;
}

References convert_elf_section(), Elf_, i, NULL, options, rz_bin_elf_section_free(), rz_vector_enumerate, rz_vector_free(), rz_vector_new(), rz_vector_push(), sections(), and autogen_x86imm::tmp.

Referenced by convert_sections().

create_section_from_phdr()

static bool create_section_from_phdr ( ELFOBJ *  bin, RzVector *  result, const char *  name, ut64  addr, ut64  sz  )

static

Definition at line 66 of file elf_sections.c.

                                                                                                          {
    RzBinElfSection section = { 0 };
 
    section.offset = Elf_(rz_bin_elf_v2p)(bin, addr);
    if (section.offset == UT64_MAX) {
        RZ_LOG_WARN("Failed to convert section virtual address to physical address.\n")
        return false;
    }
 
    section.rva = addr;
    section.size = sz;
    section.name = strdup(name);
    if (!section.name) {
        return false;
    }
 
    if (!rz_vector_push(result, &section)) {
        return false;
    }
 
    return true;
}

References addr, Elf_, section::offset, rz_bin_elf_v2p(), RZ_LOG_WARN, rz_vector_push(), section::size, strdup(), and UT64_MAX.

Referenced by create_section_plt(), and get_sections_from_dt_dynamic().

create_section_plt()

static bool create_section_plt ( ELFOBJ *  bin, RzVector *  result  )

static

Definition at line 103 of file elf_sections.c.

                                                              {
    ut64 addr;
    ut64 size;
 
    const char *plt_name = get_plt_name(bin);
    if (!plt_name) {
        return true;
    }
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_JMPREL, &addr) || !Elf_(rz_bin_elf_get_dt_info)(bin, DT_PLTRELSZ, &size)) {
        return true;
    }
 
    return create_section_from_phdr(bin, result, plt_name, addr, size);
}

References addr, create_section_from_phdr(), DT_JMPREL, DT_PLTRELSZ, Elf_, get_plt_name(), rz_bin_elf_get_dt_info(), and ut64().

Referenced by get_sections_from_dt_dynamic().

get_plt_name()

static const char* get_plt_name ( ELFOBJ *  bin )

static

Definition at line 89 of file elf_sections.c.

                                             {
    ut64 dt_pltrel;
 
    if (!Elf_(rz_bin_elf_get_dt_info)(bin, DT_PLTREL, &dt_pltrel)) {
        return NULL;
    }
 
    if (dt_pltrel == DT_REL) {
        return ".rel.plt";
    }
 
    return ".rela.plt";
}

References DT_PLTREL, DT_REL, Elf_, NULL, rz_bin_elf_get_dt_info(), and ut64().

Referenced by create_section_plt().

get_sections_from_dt_dynamic()

static RzVector* get_sections_from_dt_dynamic ( ELFOBJ *  bin )

static

Definition at line 124 of file elf_sections.c.

                                                           {
    ut64 addr;
    ut64 size;
 
    RzVector *result = rz_vector_new(sizeof(RzBinElfSection), rz_bin_elf_section_free, NULL);
    if (!result) {
        return NULL;
    }
 
    // There is no info about the got size
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_PLTGOT, &addr)) {
        if (!create_section_from_phdr(bin, result, ".got.plt", addr, 0)) {
            rz_vector_free(result);
            return NULL;
        }
    }
 
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_REL, &addr) && Elf_(rz_bin_elf_get_dt_info)(bin, DT_RELSZ, &size)) {
        if (!create_section_from_phdr(bin, result, ".rel.dyn", addr, size)) {
            rz_vector_free(result);
            return NULL;
        }
    }
 
    if (Elf_(rz_bin_elf_get_dt_info)(bin, DT_RELA, &addr) && Elf_(rz_bin_elf_get_dt_info)(bin, DT_RELASZ, &size)) {
        if (!create_section_from_phdr(bin, result, ".rela.dyn", addr, size)) {
            rz_vector_free(result);
            return NULL;
        }
    }
 
    if (!create_section_plt(bin, result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    return result;
}

References addr, create_section_from_phdr(), create_section_plt(), DT_PLTGOT, DT_REL, DT_RELA, DT_RELASZ, DT_RELSZ, Elf_, NULL, rz_bin_elf_get_dt_info(), rz_bin_elf_section_free(), rz_vector_free(), rz_vector_len(), rz_vector_new(), and ut64().

Referenced by convert_sections().

get_shdr_entry()

static bool get_shdr_entry ( ELFOBJ *  bin, Elf_(Shdr) *  section, ut64  offset  )

static

Definition at line 181 of file elf_sections.c.

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

References get_shdr_entry_aux(), PFMT64x, and RZ_LOG_WARN.

Referenced by rz_bin_elf_sections_new().

get_shdr_entry_aux()

static bool get_shdr_entry_aux ( ELFOBJ *  bin, Elf_(Shdr) *  section, ut64  offset  )

static

Definition at line 168 of file elf_sections.c.

                                                                               {
    return Elf_(rz_bin_elf_read_word)(bin, &offset, &section->sh_name) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &section->sh_type) &&
        Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &section->sh_flags) &&
        Elf_(rz_bin_elf_read_addr)(bin, &offset, &section->sh_addr) &&
        Elf_(rz_bin_elf_read_off)(bin, &offset, &section->sh_offset) &&
        Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &section->sh_size) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &section->sh_link) &&
        Elf_(rz_bin_elf_read_word)(bin, &offset, &section->sh_info) &&
        Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &section->sh_addralign) &&
        Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &section->sh_entsize);
}

References Elf_, rz_bin_elf_read_addr(), rz_bin_elf_read_off(), rz_bin_elf_read_word(), and rz_bin_elf_read_word_xword().

Referenced by get_shdr_entry().

rz_bin_elf_convert_sections()

RZ_OWN RzVector* Elf_() rz_bin_elf_convert_sections	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL RzBinObjectLoadOptions *	options,
		RzVector *	sections
	)

Definition at line 362 of file elf_sections.c.

                                                                                                                                           {
    rz_return_val_if_fail(bin && options, NULL);
 
    RzVector *result = convert_sections(bin, options, sections);
    if (!result) {
        return NULL;
    }
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    return result;
}

References convert_sections(), NULL, options, rz_return_val_if_fail, rz_vector_free(), rz_vector_len(), and sections().

Referenced by init_shdr_aux().

rz_bin_elf_get_section()

RZ_BORROW RzBinElfSection* Elf_() rz_bin_elf_get_section	(	RZ_NONNULL ELFOBJ *	bin,
		Elf_(Half)	index
	)

Definition at line 264 of file elf_sections.c.

                                                                                                  {
    rz_return_val_if_fail(bin, NULL);
 
    if (!bin->sections) {
        return NULL;
    }
 
    if (index < rz_vector_len(bin->sections)) {
        return rz_vector_index_ptr(bin->sections, index);
    }
 
    return NULL;
}

References NULL, rz_return_val_if_fail, rz_vector_index_ptr(), and rz_vector_len().

Referenced by convert_elf_symbol_entry(), fix_rva_and_offset_relocable_file(), and get_section_elf_symbols().

rz_bin_elf_get_section_with_name()

RZ_BORROW RzBinElfSection* Elf_() rz_bin_elf_get_section_with_name	(	RZ_NONNULL ELFOBJ *	bin,
		RZ_NONNULL const char *	name
	)

Definition at line 278 of file elf_sections.c.

                                                                                                                       {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSection *section;
    rz_bin_elf_foreach_sections(bin, section) {
        if (section->is_valid && section->name && !strcmp(section->name, name)) {
            return section;
        }
    }
 
    return NULL;
}

References NULL, rz_bin_elf_foreach_sections, and rz_return_val_if_fail.

Referenced by get_entry_offset_from_shdr(), get_gnu_debugdata_elf_symbols(), get_import_addr_x86(), get_import_addr_x86_manual(), and rz_bin_elf_get_compiler().

rz_bin_elf_has_sections()

bool Elf_() rz_bin_elf_has_sections

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 440 of file elf_sections.c.

                                                           {
    rz_return_val_if_fail(bin, false);
 
    return bin->sections;
}

References rz_return_val_if_fail.

Referenced by rz_bin_elf_is_stripped().

rz_bin_elf_section_flag_to_rzlist()

RZ_OWN RzList* Elf_() rz_bin_elf_section_flag_to_rzlist

(

ut64

flag

)

Return a list of string representing flag options.

Parameters

elf

flag

Returns

RzList of string representing flag options

Compare the flag to common option such as SHF_WRITE, SHF_ALLOC, ect

Definition at line 298 of file elf_sections.c.

                                                                  {
    RzList *flag_list = rz_list_new();
    if (!flag_list) {
        return NULL;
    }
 
    for (size_t i = 0; i < RZ_ARRAY_SIZE(flag_translation_table); i++) {
        if (flag & flag_translation_table[i].flag) {
            if (!rz_list_append(flag_list, flag_translation_table[i].name)) {
                rz_list_free(flag_list);
                return NULL;
            }
        }
    }
 
    return flag_list;
}

References flag_translation::flag, flag_translation_table, i, NULL, RZ_ARRAY_SIZE, rz_list_append(), rz_list_free(), and rz_list_new().

rz_bin_elf_section_free()

static void rz_bin_elf_section_free ( void *  e, RZ_UNUSED void *  user  )

static

Definition at line 119 of file elf_sections.c.

                                                                   {
    RzBinElfSection *ptr = e;
    free(ptr->name);
}

References e, free(), and rz_bin_elf_section_t::name.

Referenced by convert_sections_from_shdr(), and get_sections_from_dt_dynamic().

rz_bin_elf_section_type_to_string()

RZ_OWN char* Elf_() rz_bin_elf_section_type_to_string

(

ut64

type

)

Return a string representing the elf type.

Parameters

elf

type

Returns

allocated string

Compare the type SHT_NULL, SHT_PROGBITS, etc and return the string representation

Definition at line 422 of file elf_sections.c.

                                                                {
    for (size_t i = 0; i < RZ_ARRAY_SIZE(type_translation_table); i++) {
        if (type == type_translation_table[i].type) {
            return rz_str_new(type_translation_table[i].name);
        }
    }
 
    if (type >= SHT_LOPROC && type <= SHT_HIPROC) {
        return rz_str_newf("LOPROC+0x%08" PFMT64x, type - SHT_LOPROC);
    }
 
    if (type >= SHT_LOUSER && type <= SHT_HIUSER) {
        return rz_str_newf("LOUSER+0x%08" PFMT64x, type - SHT_LOUSER);
    }
 
    return rz_str_newf("0x%" PFMT64x, type);
}

References i, PFMT64x, RZ_ARRAY_SIZE, rz_str_new(), rz_str_newf(), SHT_HIPROC, SHT_HIUSER, SHT_LOPROC, SHT_LOUSER, type, and type_translation_table.

rz_bin_elf_sections_new()

RZ_OWN RzVector* Elf_() rz_bin_elf_sections_new

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 378 of file elf_sections.c.

                                                                       {
    rz_return_val_if_fail(bin, NULL);
 
    if (!bin->ehdr.e_shnum) {
        return NULL;
    }
 
    if (!Elf_(rz_bin_elf_check_array)(bin, bin->ehdr.e_shoff, bin->ehdr.e_shnum, sizeof(Elf_(Phdr)))) {
        RZ_LOG_WARN("Invalid section header (check array failed).\n");
        return NULL;
    }
 
    RzVector *result = rz_vector_new(sizeof(Elf_(Shdr)), NULL, NULL);
    if (!result) {
        return NULL;
    }
 
    ut64 offset = bin->ehdr.e_shoff;
 
    for (size_t i = 0; i < bin->ehdr.e_shnum; i++) {
        Elf_(Shdr) *section = rz_vector_push(result, NULL);
        if (!section) {
            rz_vector_free(result);
            return NULL;
        }
 
        if (!get_shdr_entry(bin, section, offset)) {
            rz_vector_free(result);
            return NULL;
        }
 
        offset += sizeof(Elf_(Shdr));
    }
 
    return result;
}

References Elf_, get_shdr_entry(), i, NULL, rz_bin_elf_check_array(), RZ_LOG_WARN, rz_return_val_if_fail, rz_vector_free(), rz_vector_new(), rz_vector_push(), and ut64().

Referenced by init().

set_elf_section()

static bool set_elf_section ( ELFOBJ *  bin, RzBinObjectLoadOptions *  option, RzBinElfSection *  section, Elf_(Shdr) *  shdr, size_t  id  )

static

Definition at line 252 of file elf_sections.c.

                                                                                                                                 {
    bool tmp = set_elf_section_aux(bin, section, shdr, id);
 
    if (!option->elf_checks_sections) {
        section->is_valid = true;
        return true;
    }
 
    section->is_valid = tmp && verify_shdr_entry(bin, shdr);
    return section->is_valid;
}

References set_elf_section_aux(), autogen_x86imm::tmp, and verify_shdr_entry().

Referenced by convert_elf_section().

set_elf_section_aux()

static bool set_elf_section_aux ( ELFOBJ *  bin, RzBinElfSection *  section, Elf_(Shdr) *  shdr, size_t  id  )

static

Definition at line 210 of file elf_sections.c.

                                                                                                     {
    section->offset = shdr->sh_offset;
    section->size = shdr->sh_size;
    section->align = shdr->sh_addralign;
    section->flags = shdr->sh_flags;
    section->link = shdr->sh_link;
    section->info = shdr->sh_info;
    section->type = shdr->sh_type;
 
    if (Elf_(rz_bin_elf_is_relocatable)(bin)) {
        section->rva = bin->baddr + shdr->sh_offset;
    } else {
        if (shdr->sh_flags & SHF_ALLOC) {
            section->rva = shdr->sh_addr;
        } else {
            section->rva = UT64_MAX;
        }
    }
    return set_elf_section_name(bin, section, shdr, id);
}

References section::align, Elf_, section::flags, section::offset, rz_bin_elf_is_relocatable(), set_elf_section_name(), SHF_ALLOC, section::size, and UT64_MAX.

Referenced by set_elf_section().

set_elf_section_name()

static bool set_elf_section_name ( ELFOBJ *  bin, RzBinElfSection *  section, Elf_(Shdr) *  shdr, size_t  id  )

static

Definition at line 190 of file elf_sections.c.

                                                                                                      {
    if (!bin->shstrtab || !Elf_(rz_bin_elf_strtab_has_index)(bin->shstrtab, shdr->sh_name)) {
        section->name = rz_str_newf("invalid%zu", id);
        return false;
    }
 
    if (shdr->sh_type == SHT_NULL) {
        section->name = NULL;
        return true;
    }
 
    section->name = Elf_(rz_bin_elf_strtab_get_dup)(bin->shstrtab, shdr->sh_name);
    if (section->name) {
        return true;
    }
 
    section->name = NULL;
    return false;
}

References Elf_, NULL, rz_bin_elf_strtab_get_dup(), rz_bin_elf_strtab_has_index(), rz_str_newf(), and SHT_NULL.

Referenced by set_elf_section_aux().

verify_shdr_entry()

static bool verify_shdr_entry ( ELFOBJ *  bin, Elf_(Shdr) *  section  )

static

Definition at line 231 of file elf_sections.c.

                                                                 {
    if (section->sh_link != SHT_SUNW_COMDAT && section->sh_link >= bin->ehdr.e_shnum) {
        return false;
    }
 
    Elf_(Off) end_off;
    if (!Elf_(rz_bin_elf_add_off)(&end_off, section->sh_offset, section->sh_size)) {
        return false;
    }
 
    if (section->sh_type != SHT_NOBITS && end_off > bin->size) {
        return false;
    }
 
    if (!Elf_(rz_bin_elf_add_addr)(NULL, section->sh_addr, section->sh_size)) {
        return false;
    }
 
    return true;
}

References Elf_, NULL, rz_bin_elf_add_addr(), rz_bin_elf_add_off(), SHT_NOBITS, and SHT_SUNW_COMDAT.

Referenced by set_elf_section().

Variable Documentation

flag_translation_table

const struct flag_translation flag_translation_table[]

static

Initial value:

= {
    { SHF_WRITE, "write" },
    { SHF_ALLOC, "alloc" },
    { SHF_EXECINSTR, "execute" },
    { SHF_MERGE, "merge" },
    { SHF_STRINGS, "strings" },
    { SHF_INFO_LINK, "info" },
    { SHF_LINK_ORDER, "link_order" },
    { SHF_OS_NONCONFORMING, "extra_os_processing_reqd" },
    { SHF_GROUP, "group" },
    { SHF_TLS, "TLS" },
    { SHF_EXCLUDE, "exclude" },
    { SHF_COMPRESSED, "compressed" }
}

Definition at line 1 of file elf_sections.c.

Referenced by rz_bin_elf_section_flag_to_rzlist().

type_translation_table

const struct type_translation type_translation_table[]

static

Definition at line 1 of file elf_sections.c.

Referenced by rz_bin_elf_section_type_to_string().