ne.h File Reference

#include <rz_types.h>
#include <rz_list.h>
#include <rz_util.h>
#include <rz_bin.h>
#include "ne_specs.h"

Go to the source code of this file.

Classes
struct	rz_ne_resource_entry
struct	rz_ne_resource
struct	rz_bin_ne_obj_t

Functions
void	rz_bin_ne_free (rz_bin_ne_obj_t *bin)
rz_bin_ne_obj_t *	rz_bin_ne_new_buf (RzBuffer *buf, bool verbose)
RzList *	rz_bin_ne_get_relocs (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_imports (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_symbols (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_segments (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_entrypoints (rz_bin_ne_obj_t *bin)

Function Documentation

rz_bin_ne_free()

void rz_bin_ne_free

(

rz_bin_ne_obj_t *

bin

)

Definition at line 659 of file ne.c.

                                          {
    if (!bin) {
        return;
    }
    // rz_list_free (bin->imports); // double free
    rz_list_free(bin->resources);
    free(bin->entry_table);
    free(bin->ne_header);
    free(bin->resident_name_table);
    free(bin->segment_entries);
    free(bin);
}

References free(), and rz_list_free().

Referenced by destroy(), and rz_bin_ne_new_buf().

rz_bin_ne_get_entrypoints()

RzList* rz_bin_ne_get_entrypoints

(

rz_bin_ne_obj_t *

bin

)

Definition at line 384 of file ne.c.

                                                        {
    RzList *entries = rz_list_newf(free);
    if (!entries) {
        return NULL;
    }
    RzBinAddr *entry;
    RzList *segments = rz_bin_ne_get_segments(bin);
    if (!segments) {
        rz_list_free(entries);
        return NULL;
    }
    if (bin->ne_header->csEntryPoint) {
        entry = RZ_NEW0(RzBinAddr);
        if (!entry) {
            rz_list_free(entries);
            return NULL;
        }
        entry->bits = 16;
        RzBinSection *s = rz_list_get_n(segments, bin->ne_header->csEntryPoint - 1);
        entry->paddr = bin->ne_header->ipEntryPoint + (s ? s->paddr : 0);
        rz_list_append(entries, entry);
    }
    ut32 off = 0;
    while (off < bin->ne_header->EntryTableLength) {
        ut8 bundle_length = *(ut8 *)(bin->entry_table + off);
        if (!bundle_length) {
            break;
        }
        off++;
        if (off >= bin->ne_header->EntryTableLength) {
            break;
        }
        ut8 bundle_type = *(ut8 *)(bin->entry_table + off);
        off++;
        int i;
        for (i = 0; i < bundle_length; i++) {
            entry = RZ_NEW0(RzBinAddr);
            if (!entry) {
                rz_list_free(entries);
                return NULL;
            }
            off++;
            if (!bundle_type) { // Skip
                off--;
                free(entry);
                break;
            } else if (bundle_type == 0xFF) { // Moveable
                off += 2;
                ut8 segnum = *(bin->entry_table + off);
                off++;
                ut16 segoff = *(ut16 *)(bin->entry_table + off);
                if (!segnum) {
                    free(entry);
                    continue;
                }
                entry->paddr = (ut64)bin->segment_entries[segnum - 1].offset * bin->alignment + segoff;
            } else { // Fixed
                ut16 *p = (ut16 *)(bin->entry_table + off);
                if (off >= bin->ne_header->EntryTableLength || bundle_type > bin->ne_header->SegCount) {
                    free(entry);
                    continue;
                }
                entry->paddr = (ut64)bin->segment_entries[bundle_type - 1].offset * bin->alignment + (*p);
            }
            off += 2;
            rz_list_append(entries, entry);
        }
    }
    rz_list_free(segments);
    bin->entries = entries;
    return entries;
}

References entries(), free(), i, NULL, off, p, rz_bin_ne_get_segments(), rz_list_append(), rz_list_free(), rz_list_get_n(), rz_list_newf(), RZ_NEW0, s, and ut64().

Referenced by entries(), and rz_bin_ne_get_symbols().

rz_bin_ne_get_imports()

RzList* rz_bin_ne_get_imports

(

rz_bin_ne_obj_t *

bin

)

Definition at line 348 of file ne.c.

                                                    {
    RzList *imports = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!imports) {
        return NULL;
    }
    ut16 off = bin->ne_header->ImportNameTable + bin->header_offset + 1;
    int i;
    for (i = 0; i < bin->ne_header->ModRefs; i++) {
        RzBinImport *imp = RZ_NEW0(RzBinImport);
        if (!imp) {
            break;
        }
        ut8 sz;
        if (!rz_buf_read8_at(bin->buf, off, &sz)) {
            break;
        }
        if (!sz) {
            rz_bin_import_free(imp);
            break;
        }
        off++;
        char *name = malloc((ut64)sz + 1);
        if (!name) {
            break;
        }
        rz_buf_read_at(bin->buf, off, (ut8 *)name, sz);
        name[sz] = '\0';
        imp->name = name;
        imp->ordinal = i + 1;
        rz_list_append(imports, imp);
        off += sz;
    }
    bin->imports = imports;
    return imports;
}

References bin::buf, i, imports(), malloc(), name, rz_bin_import_t::name, NULL, off, rz_bin_import_t::ordinal, rz_bin_import_free(), rz_buf_read8_at(), rz_buf_read_at(), rz_list_append(), rz_list_newf(), RZ_NEW0, and ut64().

Referenced by imports(), and rz_bin_ne_buf_init().

rz_bin_ne_get_relocs()

RzList* rz_bin_ne_get_relocs

(

rz_bin_ne_obj_t *

bin

)

Definition at line 457 of file ne.c.

                                                   {
    RzList *segments = bin->segments;
    if (!segments) {
        return NULL;
    }
    RzList *entries = bin->entries;
    if (!entries) {
        return NULL;
    }
    RzList *symbols = bin->symbols;
    if (!symbols) {
        return NULL;
    }
 
    ut16 *modref = calloc(bin->ne_header->ModRefs, sizeof(ut16));
    if (!modref) {
        return NULL;
    }
    rz_buf_read_at(bin->buf, (ut64)bin->ne_header->ModRefTable + bin->header_offset, (ut8 *)modref, bin->ne_header->ModRefs * sizeof(ut16));
 
    RzList *relocs = rz_list_newf(free);
    if (!relocs) {
        free(modref);
        return NULL;
    }
 
    ut64 bufsz = rz_buf_size(bin->buf);
    RzListIter *it;
    RzBinSection *seg;
    int index = -1;
    rz_list_foreach (segments, it, seg) {
        index++;
        if (!(bin->segment_entries[index].flags & RELOCINFO)) {
            continue;
        }
        ut32 off, start = off = seg->paddr + seg->size;
        if ((ut64)off + 2 > bufsz) {
            continue;
        }
        ut16 length;
        if (!rz_buf_read_le16_at(bin->buf, off, &length)) {
            continue;
        }
 
        if (!length) {
            continue;
        }
        off += 2;
        while (off < start + length * sizeof(NE_image_reloc_item) && off + sizeof(NE_image_reloc_item) <= bufsz) {
            RzBinReloc *reloc = RZ_NEW0(RzBinReloc);
            if (!reloc) {
                return NULL;
            }
            NE_image_reloc_item rel;
            rz_buf_read_at(bin->buf, off, (ut8 *)&rel, sizeof(rel));
            reloc->paddr = seg->paddr + rel.offset;
            switch (rel.type) {
            case LOBYTE:
                reloc->type = RZ_BIN_RELOC_8;
                break;
            case SEL_16:
            case OFF_16:
                reloc->type = RZ_BIN_RELOC_16;
                break;
            case POI_32:
            case OFF_32:
                reloc->type = RZ_BIN_RELOC_32;
                break;
            case POI_48:
                reloc->type = RZ_BIN_RELOC_64;
                break;
            }
 
            ut32 offset;
            if (rel.flags & (IMPORTED_ORD | IMPORTED_NAME)) {
                RzBinImport *imp = RZ_NEW0(RzBinImport);
                if (!imp) {
                    free(reloc);
                    break;
                }
                char *name = NULL;
                if (rel.index > bin->ne_header->ModRefs || !rel.index) {
                    name = rz_str_newf("UnknownModule%d_%x", rel.index, off); // ????
                } else {
                    offset = modref[rel.index - 1] + bin->header_offset + bin->ne_header->ImportNameTable;
                    name = __read_nonnull_str_at(bin->buf, offset);
                }
                if (rel.flags & IMPORTED_ORD) {
                    imp->ordinal = rel.func_ord;
                    imp->name = rz_str_newf("%s.%s", name, __func_name_from_ord(name, rel.func_ord));
                } else {
                    offset = bin->header_offset + bin->ne_header->ImportNameTable + rel.name_off;
                    char *func = __read_nonnull_str_at(bin->buf, offset);
                    imp->name = rz_str_newf("%s.%s", name, func);
                    free(func);
                }
                free(name);
                reloc->import = imp;
            } else if (rel.flags & OSFIXUP) {
                // TODO
            } else {
                if (strstr(seg->name, "FIXED")) {
                    RzBinSection *s = rz_list_get_n(segments, rel.segnum - 1);
                    if (s) {
                        offset = s->paddr + rel.segoff;
                    } else {
                        offset = -1;
                    }
                } else {
                    RzBinAddr *entry = rz_list_get_n(entries, rel.entry_ordinal - 1);
                    if (entry) {
                        offset = entry->paddr;
                    } else {
                        offset = -1;
                    }
                }
                reloc->addend = offset;
                RzBinSymbol *sym = NULL;
                RzListIter *sit;
                rz_list_foreach (symbols, sit, sym) {
                    if (sym->paddr == reloc->addend) {
                        reloc->symbol = sym;
                        break;
                    }
                }
            }
 
            if (rel.flags & ADDITIVE) {
                reloc->additive = 1;
                rz_list_append(relocs, reloc);
            } else {
                do {
                    rz_list_append(relocs, reloc);
                    ut16 tmp_offset;
                    if (!rz_buf_read_le16_at(bin->buf, reloc->paddr, &tmp_offset)) {
                        reloc = NULL;
                        break;
                    }
 
                    offset = tmp_offset;
 
                    RzBinReloc *tmp = reloc;
                    reloc = RZ_NEW0(RzBinReloc);
                    if (!reloc) {
                        break;
                    }
                    *reloc = *tmp;
                    reloc->paddr = seg->paddr + offset;
                } while (offset != 0xFFFF);
                free(reloc);
            }
 
            off += sizeof(NE_image_reloc_item);
        }
    }
    free(modref);
    return relocs;
}

References __func_name_from_ord(), __read_nonnull_str_at(), rz_bin_reloc_t::addend, ADDITIVE, rz_bin_reloc_t::additive, bin::buf, calloc(), entries(), _RELOC::entry_ordinal, _RELOC::flags, free(), _RELOC::func_ord, rz_bin_reloc_t::import, IMPORTED_NAME, IMPORTED_ORD, _RELOC::index, length, LOBYTE, rz_bin_section_t::name, rz_bin_import_t::name, _RELOC::name_off, NULL, off, OFF_16, OFF_32, _RELOC::offset, rz_bin_import_t::ordinal, OSFIXUP, rz_bin_section_t::paddr, rz_bin_symbol_t::paddr, rz_bin_reloc_t::paddr, POI_32, POI_48, RELOCINFO, relocs(), RZ_BIN_RELOC_16, RZ_BIN_RELOC_32, RZ_BIN_RELOC_64, RZ_BIN_RELOC_8, rz_buf_read_at(), rz_buf_read_le16_at, rz_buf_size(), rz_list_append(), rz_list_get_n(), rz_list_newf(), RZ_NEW0, rz_str_newf(), s, _RELOC::segnum, _RELOC::segoff, SEL_16, rz_bin_section_t::size, start, rz_bin_reloc_t::symbol, symbols(), autogen_x86imm::tmp, _RELOC::type, rz_bin_reloc_t::type, and ut64().

Referenced by relocs().

rz_bin_ne_get_segments()

RzList* rz_bin_ne_get_segments

(

rz_bin_ne_obj_t *

bin

)

Definition at line 78 of file ne.c.

                                                     {
    int i;
    if (!bin) {
        return NULL;
    }
    RzList *segments = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!segments) {
        return NULL;
    }
    for (i = 0; i < bin->ne_header->SegCount; i++) {
        RzBinSection *bs = RZ_NEW0(RzBinSection);
        NE_image_segment_entry *se = &bin->segment_entries[i];
        if (!bs || !se) {
            free(bs);
            return segments;
        }
        bs->size = se->length;
        bs->vsize = se->minAllocSz ? se->minAllocSz : 64000;
        bs->bits = RZ_SYS_BITS_16;
        bs->is_data = se->flags & IS_DATA;
        bs->perm = __translate_perms(se->flags);
        bs->paddr = (ut64)se->offset * bin->alignment;
        bs->name = rz_str_newf("%s.%" PFMT64d, se->flags & IS_MOVEABLE ? "MOVEABLE" : "FIXED", bs->paddr);
        bs->is_segment = true;
        rz_list_append(segments, bs);
    }
    bin->segments = segments;
    return segments;
}

References __translate_perms(), rz_bin_section_t::bits, _SEGMENT::flags, free(), i, IS_DATA, rz_bin_section_t::is_data, IS_MOVEABLE, rz_bin_section_t::is_segment, _SEGMENT::length, _SEGMENT::minAllocSz, rz_bin_section_t::name, NULL, _SEGMENT::offset, rz_bin_section_t::paddr, rz_bin_section_t::perm, PFMT64d, rz_bin_section_free(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_str_newf(), RZ_SYS_BITS_16, rz_bin_section_t::size, ut64(), and rz_bin_section_t::vsize.

Referenced by rz_bin_ne_get_entrypoints(), and sections().

rz_bin_ne_get_symbols()

RzList* rz_bin_ne_get_symbols

(

rz_bin_ne_obj_t *

bin

)

Definition at line 121 of file ne.c.

                                                    {
    RzBinSymbol *sym;
    ut16 off = bin->ne_header->ResidNamTable + bin->header_offset;
    RzList *symbols = rz_list_newf(free);
    if (!symbols) {
        return NULL;
    }
    RzList *entries = rz_bin_ne_get_entrypoints(bin);
    bool resident = true, first = true;
    while (true) {
        ut8 sz;
        if (!rz_buf_read8_at(bin->buf, off, &sz)) {
            break;
        }
        if (!sz) {
            first = true;
            if (resident) {
                resident = false;
                off = bin->ne_header->OffStartNonResTab;
                if (!rz_buf_read8_at(bin->buf, off, &sz)) {
                    break;
                }
                if (!sz) {
                    break;
                }
            } else {
                break;
            }
        }
        char *name = malloc((ut64)sz + 1);
        if (!name) {
            break;
        }
        off++;
        rz_buf_read_at(bin->buf, off, (ut8 *)name, sz);
        name[sz] = '\0';
        off += sz;
        sym = RZ_NEW0(RzBinSymbol);
        if (!sym) {
            break;
        }
        ne_sanitize_name(name, sz);
        sym->name = name;
        if (!first) {
            sym->bind = RZ_BIN_BIND_GLOBAL_STR;
        }
        ut16 entry_off;
        if (!rz_buf_read_le16_at(bin->buf, off, &entry_off)) {
            rz_bin_symbol_free(sym);
            break;
        }
        off += 2;
        RzBinAddr *entry = rz_list_get_n(entries, entry_off);
        if (entry) {
            sym->paddr = entry->paddr;
        } else {
            sym->paddr = -1;
        }
        sym->ordinal = entry_off;
        rz_list_append(symbols, sym);
        first = false;
    }
    RzListIter *it;
    RzBinAddr *en;
    int i = 1;
    rz_list_foreach (entries, it, en) {
        if (!rz_list_find(symbols, &en->paddr, __find_symbol_by_paddr)) {
            sym = RZ_NEW0(RzBinSymbol);
            if (!sym) {
                break;
            }
            sym->name = rz_str_newf("entry%d", i - 1);
            sym->paddr = en->paddr;
            sym->bind = RZ_BIN_BIND_GLOBAL_STR;
            sym->ordinal = i;
            rz_list_append(symbols, sym);
        }
        i++;
    }
    bin->symbols = symbols;
    return symbols;
}

References __find_symbol_by_paddr(), rz_bin_symbol_t::bind, bin::buf, entries(), free(), i, malloc(), name, rz_bin_symbol_t::name, ne_sanitize_name(), NULL, off, rz_bin_symbol_t::ordinal, rz_bin_addr_t::paddr, rz_bin_symbol_t::paddr, RZ_BIN_BIND_GLOBAL_STR, rz_bin_ne_get_entrypoints(), rz_bin_symbol_free(), rz_buf_read8_at(), rz_buf_read_at(), rz_buf_read_le16_at, rz_list_append(), rz_list_find(), rz_list_get_n(), rz_list_newf(), RZ_NEW0, rz_str_newf(), symbols(), and ut64().

Referenced by symbols().

rz_bin_ne_new_buf()

rz_bin_ne_obj_t* rz_bin_ne_new_buf	(	RzBuffer *	buf,
		bool	verbose
	)

Definition at line 672 of file ne.c.

                                                                {
    rz_bin_ne_obj_t *bin = RZ_NEW0(rz_bin_ne_obj_t);
    if (!bin) {
        return NULL;
    }
    if (!rz_bin_ne_buf_init(buf, bin)) {
        rz_bin_ne_free(bin);
        return NULL;
    }
    return bin;
}

References NULL, rz_bin_ne_buf_init(), rz_bin_ne_free(), and RZ_NEW0.

Referenced by load_buffer().