le.h File Reference

#include <rz_bin.h>
#include "le_specs.h"

Go to the source code of this file.

Classes
struct	rz_bin_le_obj_s

Typedefs
typedef struct rz_bin_le_obj_s	rz_bin_le_obj_t

Functions
rz_bin_le_obj_t *	rz_bin_le_new_buf (RzBuffer *buf)
void	rz_bin_le_free (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_entrypoints (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_sections (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_symbols (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_imports (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_libs (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_relocs (rz_bin_le_obj_t *bin)

Typedef Documentation

rz_bin_le_obj_t

typedef struct rz_bin_le_obj_s rz_bin_le_obj_t

Function Documentation

rz_bin_le_free()

void rz_bin_le_free

(

rz_bin_le_obj_t *

bin

)

Definition at line 795 of file le.c.

                                          {
    rz_return_if_fail(bin);
    free(bin->header);
    free(bin->objtbl);
    free(bin->filename);
    free(bin);
}

References free(), and rz_return_if_fail.

Referenced by destroy(), and rz_bin_le_new_buf().

rz_bin_le_get_entrypoints()

RzList* rz_bin_le_get_entrypoints

(

rz_bin_le_obj_t *

bin

)

Definition at line 229 of file le.c.

                                                        {
    RzList *l = rz_list_newf((RzListFree)free);
    if (!l) {
        return NULL;
    }
    RzBinAddr *entry = RZ_NEW0(RzBinAddr);
    if (entry) {
        if ((bin->header->startobj - 1) < bin->header->objcnt) {
            entry->vaddr = (ut64)bin->objtbl[bin->header->startobj - 1].reloc_base_addr + bin->header->eip;
        }
    }
    rz_list_append(l, entry);
 
    return l;
}

References free(), NULL, rz_list_append(), rz_list_newf(), RZ_NEW0, and ut64().

Referenced by entries().

rz_bin_le_get_imports()

RzList* rz_bin_le_get_imports

(

rz_bin_le_obj_t *

bin

)

Definition at line 205 of file le.c.

                                                    {
    RzList *l = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!l) {
        return NULL;
    }
    LE_image_header *h = bin->header;
    ut64 offset = (ut64)h->impproc + bin->headerOff + 1; // First entry is a null string
    ut64 end = (ut64)h->fixupsize + h->fpagetab + bin->headerOff;
    while (offset < end) {
        RzBinImport *imp = RZ_NEW0(RzBinImport);
        if (!imp) {
            break;
        }
        imp->name = le_read_nonnull_str_at(bin->buf, &offset);
        if (!imp->name) {
            rz_bin_import_free(imp);
            break;
        }
        imp->type = RZ_BIN_TYPE_FUNC_STR;
        rz_list_append(l, imp);
    }
    return l;
}

References bin::buf, test_evm::end, h, le_read_nonnull_str_at(), rz_bin_import_t::name, NULL, rz_bin_import_free(), RZ_BIN_TYPE_FUNC_STR, rz_list_append(), rz_list_newf(), RZ_NEW0, rz_bin_import_t::type, and ut64().

Referenced by imports().

rz_bin_le_get_libs()

RzList* rz_bin_le_get_libs

(

rz_bin_le_obj_t *

bin

)

Definition at line 245 of file le.c.

                                                 {
    RzList *l = rz_list_newf((RzListFree)free);
    if (!l) {
        return NULL;
    }
    LE_image_header *h = bin->header;
    ut64 offset = (ut64)h->impmod + bin->headerOff;
    ut64 end = offset + h->impproc - h->impmod;
    while (offset < end) {
        char *name = le_read_nonnull_str_at(bin->buf, &offset);
        if (!name) {
            break;
        }
        rz_list_append(l, name);
    }
    return l;
}

References bin::buf, test_evm::end, free(), h, le_read_nonnull_str_at(), NULL, rz_list_append(), rz_list_newf(), ut64(), and while().

Referenced by libs().

rz_bin_le_get_relocs()

RzList* rz_bin_le_get_relocs

(

rz_bin_le_obj_t *

bin

)

Definition at line 453 of file le.c.

                                                   {
    RzList *l = rz_list_newf((RzListFree)free);
    if (!l) {
        return NULL;
    }
    RzList *entries = le_get_entries(bin);
    RzList *sections = rz_bin_le_get_sections(bin);
    LE_image_header *h = bin->header;
    ut64 cur_page = 0;
    const ut64 fix_rec_tbl_off = (ut64)h->frectab + bin->headerOff;
    ut32 tmp_offset;
    if (!rz_buf_read_ble32_at(bin->buf, (ut64)h->fpagetab + bin->headerOff + cur_page * sizeof(ut32), &tmp_offset, h->worder)) {
        rz_list_free(l);
        rz_list_free(entries);
        rz_list_free(sections);
        return NULL;
    }
 
    ut64 offset = tmp_offset + fix_rec_tbl_off;
 
    ut32 tmp_end;
    if (!rz_buf_read_ble32_at(bin->buf, (ut64)h->fpagetab + bin->headerOff + (cur_page + 1) * sizeof(ut32), &tmp_end, h->worder)) {
        rz_list_free(l);
        rz_list_free(entries);
        rz_list_free(sections);
        return NULL;
    }
    ut64 end = tmp_end + fix_rec_tbl_off;
 
    const RzBinSection *cur_section = (RzBinSection *)rz_list_get_n(sections, cur_page);
    ut64 cur_page_offset = cur_section ? cur_section->vaddr : 0;
    while (cur_page < h->mpages) {
        RzBinReloc *rel = RZ_NEW0(RzBinReloc);
        bool rel_appended = false; // whether rel has been appended to l and must not be freed
        if (!rel) {
            break;
        }
        LE_fixup_record_header header;
        int ret = rz_buf_read_at(bin->buf, offset, (ut8 *)&header, sizeof(header));
        if (ret != sizeof(header)) {
            RZ_LOG_WARN("Cannot read out of bounds relocation.\n");
            free(rel);
            break;
        }
        offset += sizeof(header);
        switch (header.source & F_SOURCE_TYPE_MASK) {
        case BYTEFIXUP:
            rel->type = RZ_BIN_RELOC_8;
            break;
        case SELECTOR16:
        case OFFSET16:
            rel->type = RZ_BIN_RELOC_16;
            break;
        case OFFSET32:
        case POINTER32:
        case SELFOFFSET32:
            rel->type = RZ_BIN_RELOC_32;
            break;
        case POINTER48:
            rel->type = 48;
            break;
        }
        ut8 repeat = 0;
        ut16 source = 0;
        if (header.source & F_SOURCE_LIST) {
            if (!rz_buf_read8_at(bin->buf, offset, &repeat)) {
                rz_bin_reloc_free(rel);
                break;
            }
            offset += sizeof(ut8);
        } else {
            if (!rz_buf_read_ble16_at(bin->buf, offset, &source, h->worder)) {
                rz_bin_reloc_free(rel);
                break;
            }
            offset += sizeof(ut16);
        }
        ut32 ordinal;
        if (header.target & F_TARGET_ORD16) {
            ut16 tmp;
            if (!rz_buf_read_ble16_at(bin->buf, offset, &tmp, h->worder)) {
                rz_bin_reloc_free(rel);
                break;
            }
            ordinal = tmp;
            offset += sizeof(ut16);
        } else {
            ut8 tmp;
            if (!rz_buf_read8_at(bin->buf, offset, &tmp)) {
                rz_bin_reloc_free(rel);
                break;
            }
            ordinal = tmp;
            offset += sizeof(ut8);
        }
        switch (header.target & F_TARGET_TYPE_MASK) {
        case INTERNAL:
            if ((ordinal - 1) < bin->header->objcnt) {
                rel->addend = bin->objtbl[ordinal - 1].reloc_base_addr;
                if ((header.source & F_SOURCE_TYPE_MASK) != SELECTOR16) {
                    if (header.target & F_TARGET_OFF32) {
                        ut32 tmp;
                        if (!rz_buf_read_ble32_offset(bin->buf, &offset, &tmp, h->worder)) {
                            rz_bin_reloc_free(rel);
                            continue;
                        }
                        rel->addend += tmp;
                    } else {
                        ut16 tmp;
                        if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                            rz_bin_reloc_free(rel);
                            continue;
                        }
                        rel->addend += tmp;
                    }
                }
            }
            break;
        case IMPORTORD: {
            RzBinImport *imp = RZ_NEW0(RzBinImport);
            if (!imp) {
                break;
            }
            char *mod_name = le_get_modname_by_ord(bin, ordinal);
            if (!mod_name) {
                rz_bin_import_free(imp);
                break;
            }
 
            if (header.target & F_TARGET_ORD8) {
                ut8 tmp;
                if (!rz_buf_read8_at(bin->buf, offset, &tmp)) {
                    rz_bin_import_free(imp);
                    break;
                }
                ordinal = tmp;
                offset += sizeof(ut8);
            } else if (header.target & F_TARGET_OFF32) {
                if (!rz_buf_read_ble32_offset(bin->buf, &offset, &ordinal, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
            } else {
                ut16 tmp;
                if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
                ordinal = tmp;
            }
            imp->name = rz_str_newf("%s.%u", mod_name, ordinal);
            imp->ordinal = ordinal;
            rel->import = imp;
            free(mod_name);
            break;
        }
        case IMPORTNAME: {
            RzBinImport *imp = RZ_NEW0(RzBinImport);
            if (!imp) {
                break;
            }
            ut32 nameoff;
            if (header.target & F_TARGET_OFF32) {
                if (!rz_buf_read_ble32_offset(bin->buf, &offset, &nameoff, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
            } else {
                ut16 tmp;
                if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
                nameoff = tmp;
            }
            ut64 off = (ut64)h->impproc + nameoff + bin->headerOff;
            char *proc_name = le_read_nonnull_str_at(bin->buf, &off);
            char *mod_name = le_get_modname_by_ord(bin, ordinal);
            imp->name = rz_str_newf("%s.%s", mod_name ? mod_name : "", proc_name ? proc_name : "");
            rel->import = imp;
            break;
        }
        case INTERNALENTRY:
            rel->addend = (ut64)(size_t)rz_list_get_n(entries, ordinal - 1);
            break;
        }
        if (header.target & F_TARGET_ADDITIVE) {
            ut32 additive = 0;
            if (header.target & F_TARGET_ADD32) {
                if (!rz_buf_read_ble32_offset(bin->buf, &offset, &additive, h->worder)) {
                    rz_bin_reloc_free(rel);
                    break;
                }
            } else {
                ut16 tmp;
                if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                    rz_bin_reloc_free(rel);
                    break;
                }
                additive = tmp;
            }
            rel->addend += additive;
        }
        if (!repeat) {
            rel->vaddr = cur_page_offset + source;
            rel->paddr = cur_section ? cur_section->paddr + source : 0;
            rz_list_append(l, rel);
            rel_appended = true;
        }
 
        if (header.target & F_TARGET_CHAIN) {
            ut32 fixupinfo;
            if (!rz_buf_read_ble32_at(bin->buf, cur_page_offset + source, &fixupinfo, h->worder)) {
                break;
            }
 
            ut64 base_target_address = rel->addend - (fixupinfo & 0xFFFFF);
            do {
                if (!rz_buf_read_ble32_at(bin->buf, cur_page_offset + source, &fixupinfo, h->worder)) {
                    break;
                }
                RzBinReloc *new = RZ_NEW0(RzBinReloc);
                *new = *rel;
                new->addend = base_target_address + (fixupinfo & 0xFFFFF);
                rz_list_append(l, new);
                source = (fixupinfo >> 20) & 0xFFF;
            } while (source != 0xFFF);
        }
 
        while (repeat) {
            ut16 off;
            if (!rz_buf_read_ble16_offset(bin->buf, &offset, &off, h->worder)) {
                break;
            }
            rel->vaddr = cur_page_offset + off;
            rel->paddr = cur_section ? cur_section->paddr + off : 0;
            RzBinReloc *new = RZ_NEW0(RzBinReloc);
            *new = *rel;
            rz_list_append(l, new);
            repeat--;
        }
        while (offset >= end) {
            cur_page++;
            if (cur_page >= h->mpages) {
                break;
            }
            ut64 at = h->fpagetab + bin->headerOff;
            ut32 w0;
            if (!rz_buf_read_ble32_at(bin->buf, at + cur_page * sizeof(ut32), &w0, h->worder)) {
                break;
            }
            ut32 w1;
            if (!rz_buf_read_ble32_at(bin->buf, at + (cur_page + 1) * sizeof(ut32), &w1, h->worder)) {
                break;
            }
            offset = fix_rec_tbl_off + w0;
            end = fix_rec_tbl_off + w1;
            if (offset < end) {
                cur_section = (RzBinSection *)rz_list_get_n(sections, cur_page);
                cur_page_offset = cur_section ? cur_section->vaddr : 0;
            }
        }
        if (!rel_appended) {
            rz_bin_reloc_free(rel);
        }
    }
    rz_list_free(entries);
    rz_list_free(sections);
    return l;
}

References rz_bin_reloc_t::addend, bin::buf, BYTEFIXUP, test_evm::end, entries(), F_SOURCE_LIST, F_SOURCE_TYPE_MASK, F_TARGET_ADD32, F_TARGET_ADDITIVE, F_TARGET_CHAIN, F_TARGET_OFF32, F_TARGET_ORD16, F_TARGET_ORD8, F_TARGET_TYPE_MASK, free(), h, header, if(), rz_bin_reloc_t::import, IMPORTNAME, IMPORTORD, INTERNAL, INTERNALENTRY, le_get_entries(), le_get_modname_by_ord(), le_read_nonnull_str_at(), rz_bin_import_t::name, NULL, off, OFFSET16, OFFSET32, rz_bin_import_t::ordinal, rz_bin_section_t::paddr, rz_bin_reloc_t::paddr, POINTER32, POINTER48, repeat(), rz_bin_import_free(), rz_bin_le_get_sections(), RZ_BIN_RELOC_16, RZ_BIN_RELOC_32, RZ_BIN_RELOC_8, rz_bin_reloc_free(), rz_buf_read8_at(), rz_buf_read_at(), rz_list_append(), rz_list_free(), rz_list_get_n(), rz_list_newf(), RZ_LOG_WARN, RZ_NEW0, rz_str_newf(), sections(), SELECTOR16, SELFOFFSET32, source, autogen_x86imm::tmp, rz_bin_reloc_t::type, ut64(), ut8, rz_bin_section_t::vaddr, rz_bin_reloc_t::vaddr, w0, and w1.

Referenced by relocs().

rz_bin_le_get_sections()

RzList* rz_bin_le_get_sections

(

rz_bin_le_obj_t *

bin

)

Definition at line 338 of file le.c.

                                                     {
    RzList *l = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!l) {
        return NULL;
    }
    LE_image_header *h = bin->header;
    ut32 pages_start_off = h->datapage;
    int i;
    for (i = 0; i < h->objcnt; i++) {
        RzBinSection *sec = RZ_NEW0(RzBinSection);
        if (!sec) {
            return l;
        }
        LE_object_entry *entry = &bin->objtbl[i];
        sec->name = rz_str_newf("obj.%d", i + 1);
        sec->vsize = entry->virtual_size;
        sec->vaddr = entry->reloc_base_addr;
        if (entry->flags & O_READABLE) {
            sec->perm |= RZ_PERM_R;
        }
        if (entry->flags & O_WRITABLE) {
            sec->perm |= RZ_PERM_W;
        }
        if (entry->flags & O_EXECUTABLE) {
            sec->perm |= RZ_PERM_X;
        }
        if (entry->flags & O_BIG_BIT) {
            sec->bits = RZ_SYS_BITS_32;
        } else {
            sec->bits = RZ_SYS_BITS_16;
        }
        sec->is_data = entry->flags & O_RESOURCE || !(sec->perm & RZ_PERM_X);
        if (!entry->page_tbl_entries) {
            rz_list_append(l, sec);
        }
        int j;
        ut32 page_size_sum = 0;
        ut32 next_idx = i < h->objcnt - 1 ? bin->objtbl[i + 1].page_tbl_idx - 1 : UT32_MAX;
        ut32 objmaptbloff = h->objmap + bin->headerOff;
        ut64 objpageentrysz = bin->is_le ? sizeof(ut32) : sizeof(LE_object_page_entry);
        for (j = 0; j < entry->page_tbl_entries; j++) {
            LE_object_page_entry page;
            RzBinSection *s = RZ_NEW0(RzBinSection);
            if (!s) {
                rz_bin_section_free(sec);
                return l;
            }
            s->name = rz_str_newf("%s.page.%d", sec->name, j);
            s->is_data = sec->is_data;
 
            int cur_idx = entry->page_tbl_idx + j - 1;
            ut64 page_entry_off = objpageentrysz * cur_idx + objmaptbloff;
            ut64 offset = page_entry_off;
            if (!(rz_buf_read_le32_offset(bin->buf, &offset, &page.offset) &&
                    rz_buf_read_le16_offset(bin->buf, &offset, &page.size) &&
                    rz_buf_read_le16_offset(bin->buf, &offset, &page.flags))) {
                RZ_LOG_WARN("Cannot read out of bounds page table entry.\n");
                rz_bin_section_free(s);
                break;
            }
            if (cur_idx < next_idx) { // If not true rest of pages will be zeroes
                if (bin->is_le) {
                    // Why is it big endian???
                    ut32 tmp_offset;
                    if (!rz_buf_read_be32_at(bin->buf, page_entry_off, &tmp_offset)) {
                        rz_bin_section_free(s);
                        break;
                    }
 
                    ut64 offset = tmp_offset >> 8;
                    s->paddr = (offset - 1) * h->pagesize + pages_start_off;
                    if (entry->page_tbl_idx + j == h->mpages) {
                        page.size = h->pageshift;
                    } else {
                        page.size = h->pagesize;
                    }
                } else if (page.flags == P_ITERATED) {
                    ut64 vaddr = sec->vaddr + page_size_sum;
                    __create_iter_sections(l, bin, sec, &page, vaddr, j);
                    rz_bin_section_free(s);
                    page_size_sum += h->pagesize;
                    continue;
                } else if (page.flags == P_COMPRESSED) {
                    // TODO
                    RZ_LOG_WARN("Compressed page not handled: %s", s->name);
                } else if (page.flags != P_ZEROED) {
                    s->paddr = ((ut64)page.offset << h->pageshift) + pages_start_off;
                }
            }
            s->vsize = h->pagesize;
            s->vaddr = sec->vaddr + page_size_sum;
            s->perm = sec->perm;
            s->size = page.size;
            s->bits = sec->bits;
            rz_list_append(l, s);
            page_size_sum += s->vsize;
        }
        if (entry->page_tbl_entries) {
            rz_bin_section_free(sec);
        }
    }
    return l;
}

References __create_iter_sections(), rz_bin_section_t::bits, bin::buf, LE_object_page_entry_s::flags, h, i, if(), rz_bin_section_t::is_data, rz_bin_section_t::name, next_idx(), NULL, O_BIG_BIT, O_EXECUTABLE, O_READABLE, O_RESOURCE, O_WRITABLE, LE_object_page_entry_s::offset, P_COMPRESSED, P_ITERATED, P_ZEROED, rz_bin_section_t::perm, rz_bin_section_free(), rz_buf_read_be32_at, rz_buf_read_le16_offset, rz_buf_read_le32_offset, rz_list_append(), rz_list_newf(), RZ_LOG_WARN, RZ_NEW0, RZ_PERM_R, RZ_PERM_W, RZ_PERM_X, rz_str_newf(), RZ_SYS_BITS_16, RZ_SYS_BITS_32, s, LE_object_page_entry_s::size, UT32_MAX, ut64(), rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

Referenced by rz_bin_le_get_relocs(), and sections().

rz_bin_le_get_symbols()

RzList* rz_bin_le_get_symbols

(

rz_bin_le_obj_t *

bin

)

Definition at line 191 of file le.c.

                                                    {
    RzList *l = rz_list_newf((RzListFree)rz_bin_symbol_free);
    RzList *entries = le_get_entries(bin);
    LE_image_header *h = bin->header;
    ut64 offset = (ut64)h->restab + bin->headerOff;
    ut32 end = h->enttab + bin->headerOff;
    le_get_symbols_at(bin, l, entries, offset, end);
    offset = h->nrestab;
    end = h->nrestab + h->cbnrestab;
    le_get_symbols_at(bin, l, entries, offset, end);
    rz_list_free(entries);
    return l;
}

References test_evm::end, entries(), h, le_get_entries(), le_get_symbols_at(), rz_bin_symbol_free(), rz_list_free(), rz_list_newf(), and ut64().

Referenced by symbols().

rz_bin_le_new_buf()

rz_bin_le_obj_t* rz_bin_le_new_buf

(

RzBuffer *

buf

)

Definition at line 803 of file le.c.

                                                  {
    rz_bin_le_obj_t *bin = RZ_NEW0(rz_bin_le_obj_t);
    if (!bin) {
        return NULL;
    }
 
    le_init_header(bin, buf);
    LE_image_header *h = bin->header;
    if (!memcmp("LE", h->magic, 2)) {
        bin->is_le = true;
    }
    bin->type = le_get_module_type(bin);
    bin->cpu = le_get_cpu_type(bin);
    bin->os = le_get_os_type(bin);
    bin->arch = le_get_arch(bin);
    bin->objtbl = calloc(h->objcnt, sizeof(LE_object_entry));
    if (!bin->objtbl) {
        rz_bin_le_free(bin);
        return NULL;
    }
    ut64 offset = (ut64)bin->headerOff + h->restab;
    bin->filename = le_read_nonnull_str_at(buf, &offset);
    offset = (ut64)bin->headerOff + h->objtab;
    for (ut32 i = 0; i < h->objcnt; i++) {
        LE_object_entry *le_obj_entry = bin->objtbl + i;
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->virtual_size);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->reloc_base_addr);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->flags);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->page_tbl_idx);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->page_tbl_entries);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->reserved);
    }
    bin->buf = buf;
    return bin;
}

References bin::buf, calloc(), LE_object_entry_s::flags, h, i, le_get_arch(), le_get_cpu_type(), le_get_module_type(), le_get_os_type(), le_init_header(), le_read_nonnull_str_at(), NULL, LE_object_entry_s::page_tbl_entries, LE_object_entry_s::page_tbl_idx, LE_object_entry_s::reloc_base_addr, LE_object_entry_s::reserved, rz_bin_le_free(), rz_buf_read_le32_offset, RZ_NEW0, ut64(), and LE_object_entry_s::virtual_size.

Referenced by load_buffer().