bin_nro.c File Reference

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

Go to the source code of this file.

Classes
struct	NROHeader

Macros
#define	NRO_OFF(x)   (sizeof(NXOStart) + rz_offsetof(NROHeader, x))
#define	NRO_OFFSET_MODMEMOFF   rz_offsetof(NXOStart, mod_memoffset)

Functions
static ut64	baddr (RzBinFile *bf)
static bool	check_buffer (RzBuffer *b)
static bool	load_buffer (RzBinFile *bf, RzBinObject *obj, RzBuffer *b, Sdb *sdb)
static RzBinAddr *	binsym (RzBinFile *bf, RzBinSpecialSymbol type)
static RzList *	entries (RzBinFile *bf)
static Sdb *	get_sdb (RzBinFile *bf)
static RzList *	maps (RzBinFile *bf)
static RzList *	sections (RzBinFile *bf)
static RzList *	symbols (RzBinFile *bf)
static RzList *	imports (RzBinFile *bf)
static RzList *	libs (RzBinFile *bf)
static RzBinInfo *	info (RzBinFile *bf)

Variables
RzBinPlugin	rz_bin_plugin_nro
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

NRO_OFF

#define NRO_OFF

(

x

)

(sizeof(NXOStart) + rz_offsetof(NROHeader, x))

Definition at line 11 of file bin_nro.c.

NRO_OFFSET_MODMEMOFF

#define NRO_OFFSET_MODMEMOFF   rz_offsetof(NXOStart, mod_memoffset)

Definition at line 12 of file bin_nro.c.

Function Documentation

baddr()

static ut64 baddr ( RzBinFile *  bf )

static

Definition at line 30 of file bin_nro.c.

                                 {
    if (!bf) {
        return 0;
    }
 
    ut32 result;
    if (!rz_buf_read_le32_at(bf->buf, NRO_OFFSET_MODMEMOFF, &result)) {
        return 0;
    }
 
    return result;
}

References rz_bin_file_t::buf, NRO_OFFSET_MODMEMOFF, and rz_buf_read_le32_at.

Referenced by entries(), load_buffer(), maps(), and sections().

binsym()

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

static

Definition at line 73 of file bin_nro.c.

                                                                 {
    return NULL; // TODO
}

References NULL.

check_buffer()

static bool check_buffer ( RzBuffer *  b )

static

Definition at line 43 of file bin_nro.c.

                                      {
    ut8 magic[4];
    if (rz_buf_read_at(b, NRO_OFF(magic), magic, sizeof(magic)) == 4) {
        return fileType(magic) != NULL;
    }
    return false;
}

References b, fileType(), NRO_OFF, NULL, and rz_buf_read_at().

entries()

static RzList* entries ( RzBinFile *  bf )

static

Definition at line 77 of file bin_nro.c.

                                      {
    RzList *ret;
    RzBinAddr *ptr = NULL;
    if (!(ret = rz_list_new())) {
        return NULL;
    }
    ret->free = free;
    if ((ptr = RZ_NEW0(RzBinAddr))) {
        ptr->paddr = 0x80;
        ptr->vaddr = ptr->paddr + baddr(bf);
        rz_list_append(ret, ptr);
    }
    return ret;
}

References baddr(), rz_list_t::free, free(), NULL, rz_bin_addr_t::paddr, rz_list_append(), rz_list_new(), RZ_NEW0, and rz_bin_addr_t::vaddr.

get_sdb()

static Sdb* get_sdb ( RzBinFile *  bf )

static

Definition at line 92 of file bin_nro.c.

                                   {
    Sdb *kv = sdb_new0();
    sdb_num_set(kv, "nro_start.offset", 0, 0);
    sdb_num_set(kv, "nro_start.size", 16, 0);
    sdb_set(kv, "nro_start.format", "xxq unused mod_memoffset padding", 0);
    sdb_num_set(kv, "nro_header.offset", 16, 0);
    sdb_num_set(kv, "nro_header.size", 0x70, 0);
    sdb_set(kv, "nro_header.format", "xxxxxxxxxxxx magic unk size unk2 text_offset text_size ro_offset ro_size data_offset data_size bss_size unk3", 0);
    sdb_ns_set(bf->sdb, "info", kv);
    return kv;
}

References rz_bin_file_t::sdb, sdb_new0(), sdb_ns_set(), sdb_num_set(), and sdb_set().

imports()

static RzList* imports ( RzBinFile *  bf )

static

Definition at line 281 of file bin_nro.c.

                                      {
    RzBinNXOObj *bin;
    if (!bf || !bf->o || !bf->o->bin_obj) {
        return NULL;
    }
    bin = (RzBinNXOObj *)bf->o->bin_obj;
    return bin->imports_list;
}

References rz_bin_object_t::bin_obj, NULL, and rz_bin_file_t::o.

info()

static RzBinInfo* info ( RzBinFile *  bf )

static

Definition at line 294 of file bin_nro.c.

                                      {
    RzBinInfo *ret = RZ_NEW0(RzBinInfo);
    if (!ret) {
        return NULL;
    }
    ut8 magic[4];
    rz_buf_read_at(bf->buf, NRO_OFF(magic), magic, sizeof(magic));
    const char *ft = fileType(magic);
    if (!ft) {
        ft = "nro";
    }
    ret->file = strdup(bf->file);
    ret->rclass = strdup(ft);
    ret->os = strdup("switch");
    ret->arch = strdup("arm");
    ret->machine = strdup("Nintendo Switch");
    ret->subsystem = strdup(ft);
    if (!strncmp(ft, "nrr", 3)) {
        ret->bclass = strdup("program");
        ret->type = strdup("EXEC (executable file)");
    } else if (!strncmp(ft, "nro", 3)) {
        ret->bclass = strdup("object");
        ret->type = strdup("OBJECT (executable code)");
    } else { // mod
        ret->bclass = strdup("library");
        ret->type = strdup("MOD (executable library)");
    }
    ret->bits = 64;
    ret->has_va = true;
    ret->big_endian = false;
    ret->dbg_info = 0;
    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_file_t::buf, rz_bin_info_t::dbg_info, rz_bin_info_t::file, rz_bin_file_t::file, fileType(), rz_bin_info_t::has_va, rz_bin_info_t::machine, NRO_OFF, NULL, rz_bin_info_t::os, rz_bin_info_t::rclass, rz_buf_read_at(), RZ_NEW0, strdup(), rz_bin_info_t::subsystem, and rz_bin_info_t::type.

libs()

static RzList* libs ( RzBinFile *  bf )

static

Definition at line 290 of file bin_nro.c.

                                   {
    return NULL;
}

References NULL.

load_buffer()

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

static

Definition at line 51 of file bin_nro.c.

                                                                                {
    ut32 mod0;
    if (!rz_buf_read_le32_at(b, NRO_OFFSET_MODMEMOFF, &mod0)) {
        return false;
    }
 
    // XX bf->buf vs b :D this load_b
    RzBinNXOObj *bin = RZ_NEW0(RzBinNXOObj);
    if (!bin) {
        return false;
    }
 
    ut64 ba = baddr(bf);
    bin->methods_list = rz_list_newf((RzListFree)rz_bin_symbol_free);
    bin->imports_list = rz_list_newf((RzListFree)rz_bin_import_free);
    bin->classes_list = rz_list_newf((RzListFree)free);
    parseMod(b, bin, mod0, ba);
    obj->bin_obj = bin;
 
    return true;
}

References b, baddr(), rz_bin_object_t::bin_obj, free(), NRO_OFFSET_MODMEMOFF, parseMod(), rz_bin_import_free(), rz_bin_symbol_free(), rz_buf_read_le32_at, rz_list_newf(), RZ_NEW0, and ut64().

maps()

static RzList* maps ( RzBinFile *  bf )

static

Definition at line 104 of file bin_nro.c.

                                   {
    RzBuffer *b = bf->buf;
    RzList *ret = rz_list_newf((RzListFree)rz_bin_map_free);
    if (!ret) {
        return NULL;
    }
 
    ut64 ba = baddr(bf);
    ut64 bufsz = rz_buf_size(bf->buf);
 
    ut32 sig0;
    if (!rz_buf_read_le32_at(bf->buf, 0x18, &sig0)) {
        rz_list_free(ret);
        return NULL;
    }
 
    RzBinMap *map = NULL;
    if (sig0 && sig0 + 8 < bufsz) {
        map = RZ_NEW0(RzBinMap);
        if (!map) {
            return ret;
        }
 
        ut32 sig0sz;
        if (!rz_buf_read_le32_at(bf->buf, sig0 + 4, &sig0sz)) {
            rz_list_free(ret);
            ret = NULL;
            goto maps_err;
        }
 
        map->name = strdup("sig0");
        map->paddr = sig0;
        map->psize = sig0sz;
        map->vsize = sig0sz;
        map->vaddr = sig0 + ba;
        map->perm = RZ_PERM_R;
        rz_list_append(ret, map);
    } else {
        RZ_LOG_ERROR("Invalid SIG0 address\n");
    }
 
    // add text segment
    if (!(map = RZ_NEW0(RzBinMap))) {
        return ret;
    }
    map->name = strdup("text");
    ut32 tmp;
    if (!rz_buf_read_le32_at(b, NRO_OFF(text_memoffset), &tmp)) {
        goto maps_err;
    }
    map->paddr = tmp;
 
    if (!rz_buf_read_le32_at(b, NRO_OFF(text_size), &tmp)) {
        goto maps_err;
    }
    map->psize = tmp;
 
    map->vsize = map->psize;
    map->vaddr = map->paddr + ba;
    map->perm = RZ_PERM_RX;
    rz_list_append(ret, map);
 
    // add ro segment
    if (!(map = RZ_NEW0(RzBinMap))) {
        return ret;
    }
    map->name = strdup("ro");
    if (!rz_buf_read_le32_at(b, NRO_OFF(ro_memoffset), &tmp)) {
        goto maps_err;
    }
    map->paddr = tmp;
 
    if (!rz_buf_read_le32_at(b, NRO_OFF(ro_size), &tmp)) {
        goto maps_err;
    }
    map->psize = tmp;
 
    map->vsize = map->psize;
    map->vaddr = map->paddr + ba;
    map->perm = RZ_PERM_R;
    rz_list_append(ret, map);
 
    // add data segment
    if (!(map = RZ_NEW0(RzBinMap))) {
        return ret;
    }
    map->name = strdup("data");
    if (!rz_buf_read_le32_at(b, NRO_OFF(data_memoffset), &tmp)) {
        goto maps_err;
    }
    map->paddr = tmp;
 
    if (!rz_buf_read_le32_at(b, NRO_OFF(data_size), &tmp)) {
        goto maps_err;
    }
    map->psize = tmp;
 
    map->vsize = map->psize;
    map->vaddr = map->paddr + ba;
    map->perm = RZ_PERM_RW;
    rz_list_append(ret, map);
    return ret;
 
maps_err:
    free(map);
    return ret;
}

References b, baddr(), rz_bin_file_t::buf, free(), map(), NRO_OFF, NULL, rz_bin_map_free(), rz_buf_read_le32_at, rz_buf_size(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, RZ_PERM_R, RZ_PERM_RW, RZ_PERM_RX, strdup(), autogen_x86imm::tmp, and ut64().

Referenced by sections().

sections()

static RzList* sections ( RzBinFile *  bf )

static

Definition at line 212 of file bin_nro.c.

                                       {
    RzList *ret = NULL;
    RzBinSection *ptr = NULL;
    if (!(ret = rz_list_newf((RzListFree)rz_bin_section_free))) {
        return NULL;
    }
 
    ut64 ba = baddr(bf);
 
    if (!(ptr = RZ_NEW0(RzBinSection))) {
        return ret;
    }
    ptr->name = strdup("header");
    ptr->size = 0x80;
    ptr->vsize = 0x80;
    ptr->paddr = 0;
    ptr->vaddr = 0;
    ptr->perm = RZ_PERM_R;
    rz_list_append(ret, ptr);
 
    int bufsz = rz_buf_size(bf->buf);
 
    ut32 mod0;
    if (!rz_buf_read_le32_at(bf->buf, NRO_OFFSET_MODMEMOFF, &mod0)) {
        free(ret);
        return NULL;
    }
 
    if (mod0 && mod0 + 8 < bufsz) {
        if (!(ptr = RZ_NEW0(RzBinSection))) {
            return ret;
        }
        ut32 mod0sz;
        if (!rz_buf_read_le32_at(bf->buf, mod0 + 4, &mod0sz)) {
            free(ret);
            return NULL;
        }
        ptr->name = strdup("mod0");
        ptr->size = mod0sz;
        ptr->vsize = mod0sz;
        ptr->paddr = mod0;
        ptr->vaddr = mod0 + ba;
        ptr->perm = RZ_PERM_R; // rw-
        rz_list_append(ret, ptr);
    } else {
        RZ_LOG_ERROR("Invalid MOD0 address\n");
    }
 
    RzList *mappies = maps(bf);
    if (mappies) {
        RzList *msecs = rz_bin_sections_of_maps(mappies);
        if (msecs) {
            rz_list_join(ret, msecs);
            rz_list_free(msecs);
        }
        rz_list_free(mappies);
    }
    return ret;
}

References baddr(), rz_bin_file_t::buf, free(), maps(), rz_bin_section_t::name, NRO_OFFSET_MODMEMOFF, NULL, rz_bin_section_t::paddr, rz_bin_section_t::perm, rz_bin_section_free(), rz_bin_sections_of_maps(), rz_buf_read_le32_at, rz_buf_size(), rz_list_append(), rz_list_free(), rz_list_join(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, RZ_PERM_R, rz_bin_section_t::size, strdup(), ut64(), rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

symbols()

static RzList* symbols ( RzBinFile *  bf )

static

Definition at line 272 of file bin_nro.c.

                                      {
    RzBinNXOObj *bin;
    if (!bf || !bf->o || !bf->o->bin_obj) {
        return NULL;
    }
    bin = (RzBinNXOObj *)bf->o->bin_obj;
    return bin->methods_list;
}

References rz_bin_object_t::bin_obj, NULL, and rz_bin_file_t::o.

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 350 of file bin_nro.c.

rz_bin_plugin_nro

RzBinPlugin rz_bin_plugin_nro

Initial value:

= {
    .name = "nro",
    .desc = "Nintendo Switch NRO0 binaries",
    .license = "MIT",
    .load_buffer = &load_buffer,
    .check_buffer = &check_buffer,
    .baddr = &baddr,
    .binsym = &binsym,
    .entries = &entries,
    .maps = &maps,
    .sections = &sections,
    .get_sdb = &get_sdb,
    .symbols = &symbols,
    .imports = &imports,
    .info = &info,
    .libs = &libs,
}

Definition at line 331 of file bin_nro.c.