elf_segments.c File Reference

#include "elf.h"

Go to the source code of this file.

Functions
static bool	get_phdr_entry (ELFOBJ *bin, Elf_(Phdr) *segment, ut64 offset)
static bool	verify_phdr_entry (ELFOBJ *bin, RzBinObjectLoadOptions *options, Elf_(Phdr) *entry)
static bool	get_elf_segment (ELFOBJ *bin, RzBinObjectLoadOptions *options, RzBinElfSegment *segment, ut64 offset, size_t pos)
static RzVector *	get_segments_from_phdr (ELFOBJ *bin, size_t count, RzBinObjectLoadOptions *options)
static size_t	get_number_of_segments (ELFOBJ *bin, RzVector *sections)
RZ_BORROW RzBinElfSegment *Elf_()	rz_bin_elf_get_segment_with_type (RZ_NONNULL ELFOBJ *bin, Elf_(Word) type)
RZ_OWN RzVector *Elf_()	rz_bin_elf_segments_new (RZ_NONNULL ELFOBJ *bin, RzVector *sections, RZ_NONNULL RzBinObjectLoadOptions *options)
bool Elf_()	rz_bin_elf_has_segments (RZ_NONNULL ELFOBJ *bin)

Function Documentation

get_elf_segment()

static bool get_elf_segment ( ELFOBJ *  bin, RzBinObjectLoadOptions *  options, RzBinElfSegment *  segment, ut64  offset, size_t  pos  )

static

Definition at line 56 of file elf_segments.c.

                                                                                                                             {
    if (!get_phdr_entry(bin, &segment->data, offset)) {
        RZ_LOG_WARN("Failed to read segment entry at 0x%" PFMT64x ".\n", offset);
        return false;
    }
 
    segment->is_valid = verify_phdr_entry(bin, options, &segment->data);
    if (!segment->is_valid) {
        RZ_LOG_WARN("The segment %zu at 0x%" PFMT64x " seems to be invalid.\n", pos, offset);
    }
 
    return true;
}

References get_phdr_entry(), options, PFMT64x, pos, RZ_LOG_WARN, and verify_phdr_entry().

Referenced by get_segments_from_phdr().

get_number_of_segments()

static size_t get_number_of_segments ( ELFOBJ *  bin, RzVector *  sections  )

static

Definition at line 101 of file elf_segments.c.

                                                                      {
    if (bin->ehdr.e_phnum != PN_XNUM) {
        return bin->ehdr.e_phnum;
    }
 
    if (!sections) {
        RZ_LOG_WARN("Failed to fetch the number of segments because there are no sections.\n");
        return 0;
    }
 
    Elf_(Shdr) *section = rz_vector_index_ptr(sections, 0);
    if (!section) {
        RZ_LOG_WARN("Failed to fetch the number of segments from the section 0.\n");
        return 0;
    }
 
    return section->sh_info;
}

References Elf_, PN_XNUM, RZ_LOG_WARN, rz_vector_index_ptr(), and sections().

Referenced by rz_bin_elf_segments_new().

get_phdr_entry()

static bool get_phdr_entry ( ELFOBJ *  bin, Elf_(Phdr) *  segment, ut64  offset  )

static

Definition at line 7 of file elf_segments.c.

                                                                           {
    if (!Elf_(rz_bin_elf_read_word)(bin, &offset, &segment->p_type) ||
#if RZ_BIN_ELF64
        !Elf_(rz_bin_elf_read_word)(bin, &offset, &segment->p_flags) ||
#endif
        !Elf_(rz_bin_elf_read_off)(bin, &offset, &segment->p_offset) ||
        !Elf_(rz_bin_elf_read_addr)(bin, &offset, &segment->p_vaddr) ||
        !Elf_(rz_bin_elf_read_addr)(bin, &offset, &segment->p_paddr) ||
        !Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &segment->p_filesz) ||
        !Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &segment->p_memsz) ||
#ifndef RZ_BIN_ELF64
        !Elf_(rz_bin_elf_read_word)(bin, &offset, &segment->p_flags) ||
#endif
        !Elf_(rz_bin_elf_read_word_xword)(bin, &offset, &segment->p_align)) {
        return false;
    }
 
    return true;
}

References Elf_, RZ_BIN_ELF64, 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_elf_segment().

get_segments_from_phdr()

static RzVector* get_segments_from_phdr ( ELFOBJ *  bin, size_t  count, RzBinObjectLoadOptions *  options  )

static

Definition at line 70 of file elf_segments.c.

                                                                                                    {
    RzVector *result = rz_vector_new(sizeof(RzBinElfSegment), NULL, NULL);
    if (!result) {
        return NULL;
    }
 
    ut64 offset = bin->ehdr.e_phoff;
 
    for (size_t i = 0; i < count; i++) {
        RzBinElfSegment *segment = rz_vector_push(result, NULL);
        if (!segment) {
            rz_vector_free(result);
            return NULL;
        }
 
        if (!get_elf_segment(bin, options, segment, offset, i)) {
            rz_vector_free(result);
            return NULL;
        }
 
        offset += sizeof(Elf_(Phdr));
    }
 
    if (!rz_vector_len(result)) {
        rz_vector_free(result);
        return NULL;
    }
 
    return result;
}

References count, Elf_, get_elf_segment(), i, NULL, options, rz_vector_free(), rz_vector_len(), rz_vector_new(), rz_vector_push(), RzBinElfSegment, and ut64().

Referenced by rz_bin_elf_segments_new().

rz_bin_elf_get_segment_with_type()

RZ_BORROW RzBinElfSegment* Elf_() rz_bin_elf_get_segment_with_type	(	RZ_NONNULL ELFOBJ *	bin,
		Elf_(Word)	type
	)

Definition at line 120 of file elf_segments.c.

                                                                                                           {
    rz_return_val_if_fail(bin, NULL);
 
    RzBinElfSegment *iter;
    rz_bin_elf_foreach_segments(bin, iter) {
        if (iter->data.p_type == type) {
            return iter;
        }
    }
 
    return NULL;
}

References NULL, rz_bin_elf_foreach_segments, rz_return_val_if_fail, RzBinElfSegment, and type.

Referenced by elf_has_gnu_relro(), init_dt_dynamic(), rz_bin_elf_get_intrp(), rz_bin_elf_has_nx(), and rz_bin_elf_is_static().

rz_bin_elf_has_segments()

bool Elf_() rz_bin_elf_has_segments

(

RZ_NONNULL ELFOBJ *

bin

)

Definition at line 149 of file elf_segments.c.

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

References rz_return_val_if_fail.

Referenced by arch_is_mips(), convert_sections(), elf_has_gnu_relro(), get_main_offset_x86_pie(), get_targets_map_base(), rz_bin_elf_get_baddr(), rz_bin_elf_get_boffset(), rz_bin_elf_get_cpu(), rz_bin_elf_get_intrp(), rz_bin_elf_get_rpath(), rz_bin_elf_has_nx(), rz_bin_elf_p2v(), and rz_bin_elf_v2p().

rz_bin_elf_segments_new()

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

Definition at line 133 of file elf_segments.c.

                                                                                                                                       {
    rz_return_val_if_fail(bin && options, NULL);
 
    size_t count = get_number_of_segments(bin, sections);
    if (!count) {
        return NULL;
    }
 
    if (!Elf_(rz_bin_elf_check_array)(bin, bin->ehdr.e_phoff, count, sizeof(Elf_(Phdr)))) {
        RZ_LOG_WARN("Invalid program header (check array failed).\n");
        return NULL;
    }
 
    return get_segments_from_phdr(bin, count, options);
}

References count, Elf_, get_number_of_segments(), get_segments_from_phdr(), NULL, options, rz_bin_elf_check_array(), RZ_LOG_WARN, rz_return_val_if_fail, and sections().

Referenced by init_phdr_aux().

verify_phdr_entry()

static bool verify_phdr_entry ( ELFOBJ *  bin, RzBinObjectLoadOptions *  options, Elf_(Phdr) *  entry  )

static

Definition at line 27 of file elf_segments.c.

                                                                                                {
    if (!options->elf_checks_segments) {
        return true;
    }
 
    if (!entry->p_offset && !entry->p_vaddr && !entry->p_paddr && !entry->p_filesz && !entry->p_memsz) {
        return true;
    }
 
    Elf_(Off) end_off;
    if (!Elf_(rz_bin_elf_add_off)(&end_off, entry->p_offset, entry->p_filesz) || end_off > bin->size) {
        return false;
    }
 
    if (!Elf_(rz_bin_elf_add_addr)(NULL, entry->p_vaddr, entry->p_memsz)) {
        return false;
    }
 
    if (entry->p_flags == PT_LOAD && (!entry->p_memsz || entry->p_filesz > entry->p_memsz)) {
        return false;
    }
 
    if (entry->p_align && entry->p_offset % entry->p_align != entry->p_vaddr % entry->p_align) {
        return false;
    }
 
    return true;
}

References Elf_, NULL, options, PT_LOAD, rz_bin_elf_add_addr(), and rz_bin_elf_add_off().

Referenced by get_elf_segment().