bin_wasm.c File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>
#include <rz_bin.h>
#include "wasm/wasm.h"
#include "../format/wasm/wasm.h"

Go to the source code of this file.

Macros
#define	B(x, y)   rz_buf_append_bytes(buf, (const ut8 *)(x), y)
#define	D(x)   rz_buf_append_ut32(buf, x)

Functions
static bool	check_buffer (RzBuffer *rbuf)
static bool	find_export (const ut32 *p, const RzBinWasmExportEntry *q)
static bool	load_buffer (RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb)
static void	destroy (RzBinFile *bf)
static ut64	baddr (RzBinFile *bf)
static RzBinAddr *	binsym (RzBinFile *bf, RzBinSpecialSymbol type)
static RzList *	sections (RzBinFile *bf)
static RzList *	entries (RzBinFile *bf)
static RzList *	symbols (RzBinFile *bf)
static RzList *	imports (RzBinFile *bf)
static RzList *	libs (RzBinFile *bf)
static RzBinInfo *	info (RzBinFile *bf)
static ut64	size (RzBinFile *bf)
static RzBuffer *	create (RzBin *bin, const ut8 *code, int codelen, const ut8 *data, int datalen, RzBinArchOptions *opt)

Variables
RzBinPlugin	rz_bin_plugin_wasm
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

B

#define B	(		x,
			y
	)		rz_buf_append_bytes(buf, (const ut8 *)(x), y)

D

#define D

(

x

)

rz_buf_append_ut32(buf, x)

Function Documentation

baddr()

static ut64 baddr ( RzBinFile *  bf )

static

Definition at line 41 of file bin_wasm.c.

                                 {
    return 0;
}

binsym()

static RzBinAddr* binsym ( RzBinFile *  bf, RzBinSpecialSymbol  type  )

static

Definition at line 45 of file bin_wasm.c.

                                                                 {
    return NULL; // TODO
}

References NULL.

check_buffer()

static bool check_buffer ( RzBuffer *  rbuf )

static

Definition at line 15 of file bin_wasm.c.

                                         {
    ut8 buf[4] = { 0 };
    return rbuf && rz_buf_read_at(rbuf, 0, buf, 4) == 4 && !memcmp(buf, RZ_BIN_WASM_MAGIC_BYTES, 4);
}

References RZ_BIN_WASM_MAGIC_BYTES, and rz_buf_read_at().

Referenced by load_buffer().

create()

static RzBuffer* create ( RzBin *  bin, const ut8 *  code, int  codelen, const ut8 *  data, int  datalen, RzBinArchOptions *  opt  )

static

Definition at line 316 of file bin_wasm.c.

                                                                                                                       {
    RzBuffer *buf = rz_buf_new_with_bytes(NULL, 0);
#define B(x, y) rz_buf_append_bytes(buf, (const ut8 *)(x), y)
#define D(x)    rz_buf_append_ut32(buf, x)
    B("\x00"
      "asm",
        4);
    B("\x01\x00\x00\x00", 4);
    return buf;
}

References B, NULL, and rz_buf_new_with_bytes().

destroy()

static void destroy ( RzBinFile *  bf )

static

Definition at line 37 of file bin_wasm.c.

                                   {
    rz_bin_wasm_destroy(bf);
}

References rz_bin_wasm_destroy().

entries()

static RzList* entries ( RzBinFile *  bf )

static

Definition at line 51 of file bin_wasm.c.

                                      {
    RzBinWasmObj *bin = bf && bf->o ? bf->o->bin_obj : NULL;
    // TODO
    RzList *ret = NULL;
    RzBinAddr *ptr = NULL;
    ut64 addr = 0x0;
 
    if (!(ret = rz_list_newf((RzListFree)free))) {
        return NULL;
    }
 
    addr = (ut64)rz_bin_wasm_get_entrypoint(bin);
    if (!addr) {
        RzList *codes = rz_bin_wasm_get_codes(bin);
        if (codes) {
            RzListIter *iter;
            RzBinWasmCodeEntry *func;
            rz_list_foreach (codes, iter, func) {
                addr = func->code;
                break;
            }
        }
        if (!addr) {
            rz_list_free(ret);
            return NULL;
        }
    }
    if ((ptr = RZ_NEW0(RzBinAddr))) {
        ptr->paddr = addr;
        ptr->vaddr = addr;
        rz_list_append(ret, ptr);
    }
    return ret;
}

References addr, rz_bin_object_t::bin_obj, rz_bin_wasm_code_t::code, codes(), free(), NULL, rz_bin_file_t::o, rz_bin_addr_t::paddr, rz_bin_wasm_get_codes(), rz_bin_wasm_get_entrypoint(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, ut64(), and rz_bin_addr_t::vaddr.

find_export()

static bool find_export ( const ut32 *  p, const RzBinWasmExportEntry *  q  )

static

Definition at line 20 of file bin_wasm.c.

                                                                      {
    if (q->kind != RZ_BIN_WASM_EXTERNALKIND_Function) {
        return true;
    }
    return q->index != (*p);
}

References rz_bin_wasm_export_t::index, rz_bin_wasm_export_t::kind, and RZ_BIN_WASM_EXTERNALKIND_Function.

Referenced by symbols().

imports()

static RzList* imports ( RzBinFile *  bf )

static

Definition at line 232 of file bin_wasm.c.

                                      {
    RzBinWasmObj *bin = NULL;
    RzList *imports = NULL;
    RzBinImport *ptr = NULL;
 
    if (!bf || !bf->o || !bf->o->bin_obj) {
        return NULL;
    }
    bin = bf->o->bin_obj;
    RzList *ret = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!ret) {
        return NULL;
    }
    if (!(imports = rz_bin_wasm_get_imports(bin))) {
        goto bad_alloc;
    }
 
    RzBinWasmImportEntry *import = NULL;
    ut32 i = 0;
    RzListIter *iter;
    rz_list_foreach (imports, iter, import) {
        if (!(ptr = RZ_NEW0(RzBinImport))) {
            goto bad_alloc;
        }
        ptr->name = strdup(import->field_str);
        ptr->classname = strdup(import->module_str);
        ptr->ordinal = i;
        ptr->bind = "NONE";
        switch (import->kind) {
        case RZ_BIN_WASM_EXTERNALKIND_Function:
            ptr->type = "FUNC";
            break;
        case RZ_BIN_WASM_EXTERNALKIND_Table:
            ptr->type = "TABLE";
            break;
        case RZ_BIN_WASM_EXTERNALKIND_Memory:
            ptr->type = "MEM";
            break;
        case RZ_BIN_WASM_EXTERNALKIND_Global:
            ptr->type = "GLOBAL";
            break;
        }
        rz_list_append(ret, ptr);
    }
    return ret;
bad_alloc:
    rz_list_free(imports);
    rz_list_free(ret);
    return NULL;
}

References rz_bin_object_t::bin_obj, rz_bin_import_t::bind, rz_bin_import_t::classname, i, rz_bin_import_t::name, NULL, rz_bin_file_t::o, rz_bin_import_t::ordinal, rz_bin_import_free(), RZ_BIN_WASM_EXTERNALKIND_Function, RZ_BIN_WASM_EXTERNALKIND_Global, RZ_BIN_WASM_EXTERNALKIND_Memory, RZ_BIN_WASM_EXTERNALKIND_Table, rz_bin_wasm_get_imports(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, strdup(), and rz_bin_import_t::type.

Referenced by symbols().

info()

static RzBinInfo* info ( RzBinFile *  bf )

static

Definition at line 287 of file bin_wasm.c.

                                      {
    RzBinInfo *ret = NULL;
 
    if (!(ret = RZ_NEW0(RzBinInfo))) {
        return NULL;
    }
    ret->file = strdup(bf->file);
    ret->bclass = strdup("module");
    ret->rclass = strdup("wasm");
    ret->os = strdup("WebAssembly");
    ret->arch = strdup("wasm");
    ret->machine = strdup(ret->arch);
    ret->subsystem = strdup("wasm");
    ret->type = strdup("EXEC");
    ret->bits = 32;
    ret->has_va = 0;
    ret->big_endian = false;
    ret->dbg_info = 0;
    return ret;
}

References rz_bin_info_t::arch, rz_bin_info_t::bclass, rz_bin_info_t::big_endian, rz_bin_info_t::bits, rz_bin_info_t::dbg_info, rz_bin_info_t::file, rz_bin_file_t::file, rz_bin_info_t::has_va, rz_bin_info_t::machine, NULL, rz_bin_info_t::os, rz_bin_info_t::rclass, RZ_NEW0, strdup(), rz_bin_info_t::subsystem, and rz_bin_info_t::type.

libs()

static RzList* libs ( RzBinFile *  bf )

static

Definition at line 283 of file bin_wasm.c.

                                   {
    return NULL;
}

References NULL.

load_buffer()

static bool load_buffer ( RzBinFile *  bf, RzBinObject *  obj, RzBuffer *  buf, Sdb *  sdb  )

static

Definition at line 27 of file bin_wasm.c.

                                                                                  {
    rz_return_val_if_fail(bf && buf && rz_buf_size(buf) != UT64_MAX, false);
 
    if (check_buffer(buf)) {
        obj->bin_obj = rz_bin_wasm_init(bf, buf);
        return true;
    }
    return false;
}

References rz_bin_object_t::bin_obj, check_buffer(), rz_bin_wasm_init(), rz_buf_size(), rz_return_val_if_fail, and UT64_MAX.

sections()

static RzList* sections ( RzBinFile *  bf )

static

Definition at line 86 of file bin_wasm.c.

                                       {
    RzBinWasmObj *bin = bf && bf->o ? bf->o->bin_obj : NULL;
    RzList *ret = NULL;
    RzList *secs = NULL;
    RzBinSection *ptr = NULL;
    RzBinWasmSection *sec;
 
    if (!(ret = rz_list_newf((RzListFree)free))) {
        return NULL;
    }
    if (!(secs = rz_bin_wasm_get_sections(bin))) {
        rz_list_free(ret);
        return NULL;
    }
    RzListIter *iter;
    rz_list_foreach (secs, iter, sec) {
        if (!(ptr = RZ_NEW0(RzBinSection))) {
            rz_list_free(secs);
            rz_list_free(ret);
            return NULL;
        }
        ptr->name = strdup((char *)sec->name);
        if (sec->id == RZ_BIN_WASM_SECTION_DATA || sec->id == RZ_BIN_WASM_SECTION_MEMORY) {
            ptr->is_data = true;
        }
        ptr->size = sec->payload_len;
        ptr->vsize = sec->payload_len;
        ptr->vaddr = sec->offset;
        ptr->paddr = sec->offset;
        // TODO permissions
        ptr->perm = 0;
        rz_list_append(ret, ptr);
    }
    return ret;
}

References rz_bin_object_t::bin_obj, free(), rz_bin_wasm_section_t::id, rz_bin_section_t::is_data, rz_bin_wasm_section_t::name, rz_bin_section_t::name, NULL, rz_bin_file_t::o, rz_bin_wasm_section_t::offset, rz_bin_section_t::paddr, rz_bin_wasm_section_t::payload_len, rz_bin_section_t::perm, rz_bin_wasm_get_sections(), RZ_BIN_WASM_SECTION_DATA, RZ_BIN_WASM_SECTION_MEMORY, rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, rz_bin_section_t::size, strdup(), rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

size()

static ut64 size ( RzBinFile *  bf )

static

Definition at line 308 of file bin_wasm.c.

                                {
    if (!bf || !bf->buf) {
        return 0;
    }
    return rz_buf_size(bf->buf);
}

References rz_bin_file_t::buf, and rz_buf_size().

symbols()

static RzList* symbols ( RzBinFile *  bf )

static

Definition at line 122 of file bin_wasm.c.

                                      {
    RzBinWasmObj *bin = NULL;
    RzList *ret = NULL, *codes = NULL, *imports = NULL, *exports = NULL;
    RzBinSymbol *ptr = NULL;
 
    if (!bf || !bf->o || !bf->o->bin_obj) {
        return NULL;
    }
    bin = bf->o->bin_obj;
    if (!(ret = rz_list_newf((RzListFree)rz_bin_symbol_free))) {
        return NULL;
    }
    if (!(codes = rz_bin_wasm_get_codes(bin))) {
        goto bad_alloc;
    }
    if (!(imports = rz_bin_wasm_get_imports(bin))) {
        goto bad_alloc;
    }
    if (!(exports = rz_bin_wasm_get_exports(bin))) {
        goto bad_alloc;
    }
 
    ut32 fcn_idx = 0,
         table_idx = 0,
         mem_idx = 0,
         global_idx = 0;
 
    ut32 i = 0;
    RzBinWasmImportEntry *imp;
    RzListIter *iter;
    rz_list_foreach (imports, iter, imp) {
        if (!(ptr = RZ_NEW0(RzBinSymbol))) {
            goto bad_alloc;
        }
        ptr->name = strdup(imp->field_str);
        ptr->libname = strdup(imp->module_str);
        ptr->is_imported = true;
        ptr->forwarder = "NONE";
        ptr->bind = "NONE";
        switch (imp->kind) {
        case RZ_BIN_WASM_EXTERNALKIND_Function:
            ptr->type = RZ_BIN_TYPE_FUNC_STR;
            fcn_idx++;
            break;
        case RZ_BIN_WASM_EXTERNALKIND_Table:
            ptr->type = "TABLE";
            table_idx++;
            break;
        case RZ_BIN_WASM_EXTERNALKIND_Memory:
            ptr->type = "MEMORY";
            mem_idx++;
            break;
        case RZ_BIN_WASM_EXTERNALKIND_Global:
            ptr->type = RZ_BIN_BIND_GLOBAL_STR;
            global_idx++;
            break;
        }
        ptr->size = 0;
        ptr->vaddr = -1;
        ptr->paddr = -1;
        ptr->ordinal = i;
        i += 1;
        rz_list_append(ret, ptr);
    }
 
    RzListIter *is_exp = NULL;
    RzBinWasmCodeEntry *func;
    // RzBinWasmExportEntry *export = NULL;
    rz_list_foreach (codes, iter, func) {
        if (!(ptr = RZ_NEW0(RzBinSymbol))) {
            goto bad_alloc;
        }
 
        const char *fcn_name = rz_bin_wasm_get_function_name(bin, fcn_idx);
        if (fcn_name) {
            ptr->name = strdup(fcn_name);
 
            is_exp = rz_list_find(exports, &fcn_idx, (RzListComparator)find_export);
            if (is_exp) {
                ptr->bind = RZ_BIN_BIND_GLOBAL_STR;
            }
        } else {
            // fallback if symbol is not found.
            ptr->name = rz_str_newf("fcn.%d", fcn_idx);
        }
 
        ptr->forwarder = "NONE";
        if (!ptr->bind) {
            ptr->bind = "NONE";
        }
        ptr->type = RZ_BIN_TYPE_FUNC_STR;
        ptr->size = func->len;
        ptr->vaddr = (ut64)func->code;
        ptr->paddr = (ut64)func->code;
        ptr->ordinal = i;
        i++;
        fcn_idx++;
        rz_list_append(ret, ptr);
    }
 
    // TODO: globals, tables and memories
    return ret;
bad_alloc:
    // not so sure if imports should be freed.
    rz_list_free(exports);
    rz_list_free(codes);
    rz_list_free(ret);
    return NULL;
}

References rz_bin_object_t::bin_obj, rz_bin_symbol_t::bind, rz_bin_wasm_code_t::code, codes(), rz_bin_wasm_import_t::field_str, find_export(), rz_bin_symbol_t::forwarder, i, imports(), rz_bin_symbol_t::is_imported, rz_bin_wasm_import_t::kind, rz_bin_wasm_code_t::len, rz_bin_symbol_t::libname, rz_bin_wasm_import_t::module_str, rz_bin_symbol_t::name, NULL, rz_bin_file_t::o, rz_bin_symbol_t::ordinal, rz_bin_symbol_t::paddr, RZ_BIN_BIND_GLOBAL_STR, rz_bin_symbol_free(), RZ_BIN_TYPE_FUNC_STR, RZ_BIN_WASM_EXTERNALKIND_Function, RZ_BIN_WASM_EXTERNALKIND_Global, RZ_BIN_WASM_EXTERNALKIND_Memory, RZ_BIN_WASM_EXTERNALKIND_Table, rz_bin_wasm_get_codes(), rz_bin_wasm_get_exports(), rz_bin_wasm_get_function_name(), rz_bin_wasm_get_imports(), rz_list_append(), rz_list_find(), rz_list_free(), rz_list_newf(), RZ_NEW0, rz_str_newf(), rz_bin_symbol_t::size, strdup(), rz_bin_symbol_t::type, ut64(), and rz_bin_symbol_t::vaddr.

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_BIN,
    .data = &rz_bin_plugin_wasm,
    .version = RZ_VERSION
}

Definition at line 348 of file bin_wasm.c.

rz_bin_plugin_wasm

RzBinPlugin rz_bin_plugin_wasm

Initial value:

= {
    .name = "wasm",
    .desc = "WebAssembly bin plugin",
    .license = "MIT",
    .load_buffer = &load_buffer,
    .size = &size,
    .destroy = &destroy,
    .check_buffer = &check_buffer,
    .baddr = &baddr,
    .binsym = &binsym,
    .entries = &entries,
    .maps = &rz_bin_maps_of_file_sections,
    .sections = &sections,
    .symbols = &symbols,
    .imports = &imports,
    .info = &info,
    .libs = &libs,
    .create = &create,
}

Definition at line 327 of file bin_wasm.c.