bin_nso.c File Reference

#include <rz_bin.h>
#include "nxo/nxo.h"
#include <lz4.h>

Go to the source code of this file.

Classes
struct	NSOHeader

Macros
#define	NSO_OFF(x)   rz_offsetof(NSOHeader, x)
#define	NSO_OFFSET_MODMEMOFF   rz_offsetof(NXOStart, mod_memoffset)
#define	VFILE_NAME_DECOMPRESSED   "decompressed"

Functions
static ut64	baddr (RzBinFile *bf)
static bool	check_buffer (RzBuffer *b)
static bool	parse_header_aux (RzBuffer *buf, NSOHeader *r)
static NSOHeader *	parse_header (RzBuffer *buf)
static RzBinNXOObj *	nso_new (RzBuffer *buf)
static void	nso_free (RzBinNXOObj *bin)
static bool	decompress (RzBuffer *source_buf, ut64 source_offset, ut64 source_size, ut8 *dst_buf, ut64 decompressed_size)
static bool	load_buffer (RzBinFile *bf, RzBinObject *obj, RzBuffer *buf, Sdb *sdb)
static void	destroy (RzBinFile *bf)
static RzBinAddr *	binsym (RzBinFile *bf, RzBinSpecialSymbol type)
static RzList *	entries (RzBinFile *bf)
static Sdb *	get_sdb (RzBinFile *bf)
static RzList *	virtual_files (RzBinFile *bf)
static RzList *	maps (RzBinFile *bf)
static RzList *	sections (RzBinFile *bf)
static RzBinInfo *	info (RzBinFile *bf)

Variables
RzBinPlugin	rz_bin_plugin_nso
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

NSO_OFF

#define NSO_OFF

(

x

)

rz_offsetof(NSOHeader, x)

Definition at line 9 of file bin_nso.c.

NSO_OFFSET_MODMEMOFF

#define NSO_OFFSET_MODMEMOFF   rz_offsetof(NXOStart, mod_memoffset)

Definition at line 10 of file bin_nso.c.

VFILE_NAME_DECOMPRESSED

#define VFILE_NAME_DECOMPRESSED   "decompressed"

Definition at line 12 of file bin_nso.c.

Function Documentation

baddr()

static ut64 baddr ( RzBinFile *  bf )

static

Definition at line 34 of file bin_nso.c.

                                 {
    return 0x8000000;
}

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

binsym()

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

static

Definition at line 190 of file bin_nso.c.

                                                                 {
    return NULL; // TODO
}

References NULL.

check_buffer()

static bool check_buffer ( RzBuffer *  b )

static

Definition at line 38 of file bin_nso.c.

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

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

decompress()

static bool decompress ( RzBuffer *  source_buf, ut64  source_offset, ut64  source_size, ut8 *  dst_buf, ut64  decompressed_size  )

static

Definition at line 108 of file bin_nso.c.

                                                                                                                         {
    if (!source_size || decompressed_size > (ut64)SIZE_MAX || source_size > (ut64)INT_MAX || decompressed_size > (ut64)INT_MAX) {
        return false;
    }
    ut8 *tmp = RZ_NEWS0(ut8, source_size);
    if (!tmp) {
        return false;
    }
    if (rz_buf_read_at(source_buf, source_offset, tmp, source_size) != source_size) {
        free(tmp);
        return false;
    }
    int r = LZ4_decompress_safe((const char *)tmp, (char *)dst_buf, source_size, decompressed_size);
    free(tmp);
    return r == decompressed_size;
}

References free(), INT_MAX, LZ4_decompress_safe(), r, rz_buf_read_at(), RZ_NEWS0, SIZE_MAX, autogen_x86imm::tmp, and ut64().

Referenced by load_buffer(), and main().

destroy()

static void destroy ( RzBinFile *  bf )

static

Definition at line 183 of file bin_nso.c.

                                   {
    if (!bf->o) {
        return;
    }
    nso_free(bf->o->bin_obj);
}

References rz_bin_object_t::bin_obj, nso_free(), and rz_bin_file_t::o.

entries()

static RzList* entries ( RzBinFile *  bf )

static

Definition at line 194 of file bin_nso.c.

                                      {
    RzList *ret;
    RzBuffer *b = bf->buf;
 
    if (!(ret = rz_list_new())) {
        return NULL;
    }
 
    ret->free = free;
 
    RzBinAddr *ptr = RZ_NEW0(RzBinAddr);
    if (!ptr) {
        rz_list_free(ret);
        return NULL;
    }
 
    ut32 tmp;
    if (!rz_buf_read_le32_at(b, NSO_OFF(text_memoffset), &tmp)) {
        rz_list_free(ret);
        free(ptr);
        return NULL;
    }
    ptr->paddr = tmp;
 
    if (!rz_buf_read_le32_at(b, NSO_OFF(text_loc), &tmp)) {
        rz_list_free(ret);
        free(ptr);
        return NULL;
    }
    ptr->vaddr = tmp;
 
    ptr->vaddr += baddr(bf);
 
    rz_list_append(ret, ptr);
 
    return ret;
}

References b, baddr(), rz_bin_file_t::buf, rz_list_t::free, free(), NSO_OFF, NULL, rz_bin_addr_t::paddr, rz_buf_read_le32_at, rz_list_append(), rz_list_free(), rz_list_new(), RZ_NEW0, autogen_x86imm::tmp, and rz_bin_addr_t::vaddr.

get_sdb()

static Sdb* get_sdb ( RzBinFile *  bf )

static

Definition at line 232 of file bin_nso.c.

                                   {
    Sdb *kv = sdb_new0();
    sdb_num_set(kv, "nso_start.offset", 0, 0);
    sdb_num_set(kv, "nso_start.size", 16, 0);
    sdb_set(kv, "nso_start.format", "xxq unused mod_memoffset padding", 0);
    sdb_num_set(kv, "nso_header.offset", 0, 0);
    sdb_num_set(kv, "nso_header.size", 0x40, 0);
    sdb_set(kv, "nso_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().

info()

static RzBinInfo* info ( RzBinFile *  bf )

static

Definition at line 355 of file bin_nso.c.

                                      {
    RzBinInfo *ret = RZ_NEW0(RzBinInfo);
    if (!ret) {
        return NULL;
    }
    ut8 magic[4];
    if (rz_buf_read_at(bf->buf, NSO_OFF(magic), magic, sizeof(magic)) != sizeof(magic)) {
        free(ret);
        return NULL;
    }
 
    const char *ft = fileType(magic);
    if (!ft) {
        ft = "nso";
    }
    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);
    ret->bclass = strdup("program");
    ret->type = strdup("EXEC (executable file)");
    ret->bits = 64;
    ret->has_va = true;
    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_file_t::buf, rz_bin_info_t::dbg_info, rz_bin_info_t::file, rz_bin_file_t::file, fileType(), free(), rz_bin_info_t::has_va, rz_bin_info_t::machine, NSO_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.

load_buffer()

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

static

Definition at line 125 of file bin_nso.c.

                                                                                  {
    rz_return_val_if_fail(bf && buf, false);
    RzBinNXOObj *bin = nso_new(buf);
    if (!bin) {
        return false;
    }
    ut8 *tmp = NULL;
    NSOHeader *hdr = bin->header;
    if (hdr->ro_memoffset >= rz_buf_size(buf)) {
        RZ_LOG_ERROR("NSO file smaller than ro section offset\n");
        goto another_castle;
    }
    ut64 total_size = hdr->text_size + hdr->ro_size + hdr->data_size;
    if (total_size < hdr->text_size) {
        // Prevent integer overflow
        goto another_castle;
    }
    tmp = RZ_NEWS0(ut8, total_size);
    if (!tmp) {
        goto another_castle;
    }
    ut64 ba = baddr(bf);
 
    /* Decompress each section */
    if (!decompress(buf, hdr->text_memoffset, hdr->ro_memoffset - hdr->text_memoffset, tmp, hdr->text_size)) {
        RZ_LOG_ERROR("Failed to decompress NSO text section\n");
        goto another_castle;
    }
    if (!decompress(buf, hdr->ro_memoffset, hdr->data_memoffset - hdr->ro_memoffset, tmp + hdr->text_size, hdr->ro_size)) {
        RZ_LOG_ERROR("Failed to decompress NSO ro section\n");
        goto another_castle;
    }
    if (!decompress(buf, hdr->data_memoffset, rz_buf_size(buf) - hdr->data_memoffset, tmp + hdr->text_size + hdr->ro_size, hdr->data_size)) {
        RZ_LOG_ERROR("Failed to decompress NSO data section\n");
        goto another_castle;
    }
    bin->decompressed = rz_buf_new_with_pointers(tmp, total_size, true);
    if (!bin->decompressed) {
        goto another_castle;
    }
 
    /* Load unpacked binary */
    ut32 modoff;
    if (!rz_buf_read_le32_at(bin->decompressed, NSO_OFFSET_MODMEMOFF, &modoff)) {
        goto another_castle;
    }
 
    RZ_LOG_INFO("MOD Offset = 0x%" PFMT64x "\n", (ut64)modoff);
    parseMod(bin->decompressed, bin, modoff, ba);
    obj->bin_obj = bin;
    return true;
another_castle:
    nso_free(bin);
    free(tmp);
    obj->bin_obj = NULL;
    return false;
}

References baddr(), rz_bin_object_t::bin_obj, NSOHeader::data_memoffset, NSOHeader::data_size, decompress(), free(), nso_free(), nso_new(), NSO_OFFSET_MODMEMOFF, NULL, parseMod(), PFMT64x, NSOHeader::ro_memoffset, NSOHeader::ro_size, rz_buf_new_with_pointers(), rz_buf_read_le32_at, rz_buf_size(), RZ_LOG_ERROR, RZ_LOG_INFO, RZ_NEWS0, rz_return_val_if_fail, NSOHeader::text_memoffset, NSOHeader::text_size, autogen_x86imm::tmp, and ut64().

maps()

static RzList* maps ( RzBinFile *  bf )

static

Definition at line 263 of file bin_nso.c.

                                   {
    RzList *ret = rz_list_newf((RzListFree)rz_bin_map_free);
    if (!ret) {
        return NULL;
    }
 
    RzBinNXOObj *bin = bf->o->bin_obj;
    NSOHeader *hdr = bin->header;
    ut64 ba = baddr(bf);
 
    RzBinMap *map = RZ_NEW0(RzBinMap);
    if (!map) {
        return ret;
    }
    map->name = strdup("text");
    map->paddr = bin->decompressed ? 0 : hdr->text_memoffset;
    map->vsize = map->psize = hdr->text_size;
    map->vaddr = hdr->text_loc + ba;
    map->perm = RZ_PERM_RX;
    map->vfile_name = bin->decompressed ? strdup(VFILE_NAME_DECOMPRESSED) : NULL;
    rz_list_append(ret, map);
 
    // add ro segment
    map = RZ_NEW0(RzBinMap);
    if (!map) {
        return ret;
    }
    map->name = strdup("ro");
    map->paddr = bin->decompressed ? hdr->text_size : hdr->ro_memoffset;
    map->vsize = map->psize = hdr->ro_size;
    map->vaddr = hdr->ro_loc + ba;
    map->perm = RZ_PERM_R;
    map->vfile_name = bin->decompressed ? strdup(VFILE_NAME_DECOMPRESSED) : NULL;
    rz_list_append(ret, map);
 
    // add data segment
    map = RZ_NEW0(RzBinMap);
    if (!map) {
        return ret;
    }
    map->name = strdup("data");
    map->paddr = bin->decompressed ? hdr->text_size + hdr->ro_size : hdr->data_memoffset;
    map->vsize = map->psize = hdr->data_size;
    map->vaddr = hdr->data_loc + ba;
    map->perm = RZ_PERM_RW;
    map->vfile_name = bin->decompressed ? strdup(VFILE_NAME_DECOMPRESSED) : NULL;
    rz_list_append(ret, map);
    return ret;
}

References baddr(), rz_bin_object_t::bin_obj, NSOHeader::data_loc, NSOHeader::data_memoffset, NSOHeader::data_size, map(), NULL, rz_bin_file_t::o, NSOHeader::ro_loc, NSOHeader::ro_memoffset, NSOHeader::ro_size, rz_bin_map_free(), rz_list_append(), rz_list_newf(), RZ_NEW0, RZ_PERM_R, RZ_PERM_RW, RZ_PERM_RX, strdup(), NSOHeader::text_loc, NSOHeader::text_memoffset, NSOHeader::text_size, ut64(), and VFILE_NAME_DECOMPRESSED.

Referenced by sections().

nso_free()

static void nso_free ( RzBinNXOObj *  bin )

static

Definition at line 99 of file bin_nso.c.

                                       {
    if (!bin) {
        return;
    }
    rz_buf_free(bin->decompressed);
    free(bin->header);
    free(bin);
}

References free(), and rz_buf_free().

Referenced by destroy(), and load_buffer().

nso_new()

static RzBinNXOObj* nso_new ( RzBuffer *  buf )

static

Definition at line 86 of file bin_nso.c.

                                           {
    RzBinNXOObj *bin = RZ_NEW0(RzBinNXOObj);
    if (!bin) {
        return NULL;
    }
    bin->header = parse_header(buf);
    if (!bin->header) {
        free(bin);
        return NULL;
    }
    return bin;
}

References free(), NULL, parse_header(), and RZ_NEW0.

Referenced by load_buffer().

parse_header()

static NSOHeader* parse_header ( RzBuffer *  buf )

static

Definition at line 68 of file bin_nso.c.

                                              {
    RZ_STATIC_ASSERT(sizeof(NSOHeader) == 64);
    if (rz_buf_size(buf) < sizeof(NSOHeader)) {
        return NULL;
    }
    NSOHeader *r = RZ_NEW0(NSOHeader);
    if (!r) {
        return NULL;
    }
 
    if (!parse_header_aux(buf, r)) {
        free(r);
        return NULL;
    }
 
    return r;
}

References free(), NULL, parse_header_aux(), r, rz_buf_size(), RZ_NEW0, and RZ_STATIC_ASSERT.

Referenced by nso_new().

parse_header_aux()

static bool parse_header_aux ( RzBuffer *  buf, NSOHeader *  r  )

static

Definition at line 49 of file bin_nso.c.

                                                          {
    return rz_buf_read_le32_at(buf, NSO_OFF(magic), &r->magic) &&
        rz_buf_read_le32_at(buf, NSO_OFF(pad0), &r->pad0) &&
        rz_buf_read_le32_at(buf, NSO_OFF(pad1), &r->pad1) &&
        rz_buf_read_le32_at(buf, NSO_OFF(pad2), &r->pad2) &&
        rz_buf_read_le32_at(buf, NSO_OFF(text_memoffset), &r->text_memoffset) &&
        rz_buf_read_le32_at(buf, NSO_OFF(text_loc), &r->text_loc) &&
        rz_buf_read_le32_at(buf, NSO_OFF(text_size), &r->text_size) &&
        rz_buf_read_le32_at(buf, NSO_OFF(pad3), &r->pad3) &&
        rz_buf_read_le32_at(buf, NSO_OFF(ro_memoffset), &r->ro_memoffset) &&
        rz_buf_read_le32_at(buf, NSO_OFF(ro_loc), &r->ro_loc) &&
        rz_buf_read_le32_at(buf, NSO_OFF(ro_size), &r->ro_size) &&
        rz_buf_read_le32_at(buf, NSO_OFF(pad4), &r->pad4) &&
        rz_buf_read_le32_at(buf, NSO_OFF(data_memoffset), &r->data_memoffset) &&
        rz_buf_read_le32_at(buf, NSO_OFF(data_loc), &r->data_loc) &&
        rz_buf_read_le32_at(buf, NSO_OFF(data_size), &r->data_size) &&
        rz_buf_read_le32_at(buf, NSO_OFF(bss_size), &r->bss_size);
}

References NSO_OFF, r, and rz_buf_read_le32_at.

Referenced by parse_header().

sections()

static RzList* sections ( RzBinFile *  bf )

static

Definition at line 313 of file bin_nso.c.

                                       {
    RzList *ret = NULL;
    RzBinSection *ptr = NULL;
    RzBuffer *b = bf->buf;
    if (!(ret = rz_list_newf((RzListFree)rz_bin_section_free))) {
        return NULL;
    }
 
    if (!(ptr = RZ_NEW0(RzBinSection))) {
        return ret;
    }
    ptr->name = strdup("header");
    ut32 tmp;
    if (!rz_buf_read_le32_at(b, NSO_OFF(text_memoffset), &tmp)) {
        rz_list_free(ret);
        return NULL;
    }
    ptr->size = tmp;
 
    if (!rz_buf_read_le32_at(b, NSO_OFF(text_memoffset), &tmp)) {
        rz_list_free(ret);
        return NULL;
    }
    ptr->vsize = tmp;
 
    ptr->paddr = 0;
    ptr->vaddr = 0;
    ptr->perm = RZ_PERM_R;
    rz_list_append(ret, ptr);
 
    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 b, rz_bin_file_t::buf, maps(), rz_bin_section_t::name, NSO_OFF, 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_list_append(), rz_list_free(), rz_list_join(), rz_list_newf(), RZ_NEW0, RZ_PERM_R, rz_bin_section_t::size, strdup(), autogen_x86imm::tmp, rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

virtual_files()

static RzList* virtual_files ( RzBinFile *  bf )

static

Definition at line 244 of file bin_nso.c.

                                            {
    RzList *ret = rz_list_newf((RzListFree)rz_bin_virtual_file_free);
    if (!ret) {
        return NULL;
    }
    RzBinNXOObj *bin = bf->o->bin_obj;
    if (bin->decompressed) {
        RzBinVirtualFile *vf = RZ_NEW0(RzBinVirtualFile);
        if (!vf) {
            return ret;
        }
        vf->buf = bin->decompressed;
        vf->buf_owned = false;
        vf->name = strdup(VFILE_NAME_DECOMPRESSED);
        rz_list_push(ret, vf);
    }
    return ret;
}

References rz_bin_object_t::bin_obj, rz_bin_virtual_file_t::buf, rz_bin_virtual_file_t::buf_owned, rz_bin_virtual_file_t::name, NULL, rz_bin_file_t::o, rz_bin_virtual_file_free(), rz_list_newf(), rz_list_push(), RZ_NEW0, strdup(), and VFILE_NAME_DECOMPRESSED.

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 405 of file bin_nso.c.

rz_bin_plugin_nso

RzBinPlugin rz_bin_plugin_nso

Initial value:

= {
    .name = "nso",
    .desc = "Nintendo Switch NSO0 binaries",
    .license = "MIT",
    .load_buffer = &load_buffer,
    .destroy = &destroy,
    .check_buffer = &check_buffer,
    .baddr = &baddr,
    .binsym = &binsym,
    .entries = &entries,
    .virtual_files = &virtual_files,
    .maps = &maps,
    .sections = &sections,
    .get_sdb = &get_sdb,
    .info = &info,
}

Definition at line 387 of file bin_nso.c.