bin_xtr_sep64.c File Reference

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

Go to the source code of this file.

Classes
struct	_RSepHdr64
struct	_RSepApp64
struct	_RSepMachoInfo
struct	_RSepSlice64
struct	_RSepXtr64Ctx

Macros
#define	RZ_BIN_MACH064   1
#define	BTW(val, min, max)   ((val) > min && (val) < max)

Typedefs
typedef struct _RSepHdr64	RSepHdr64
typedef struct _RSepApp64	RSepApp64
typedef struct _RSepMachoInfo	RSepMachoInfo
typedef struct _RSepSlice64	RSepSlice64
typedef struct _RSepXtr64Ctx	RSepXtr64Ctx

Functions
static RSepXtr64Ctx *	sep64_xtr_ctx_new (RzBuffer *buf)
static void	sep64_xtr_ctx_free (void *p)
static RSepSlice64 *	sep64_xtr_ctx_get_slice (RSepXtr64Ctx *ctx, RzBuffer *whole, int idx)
static RSepMachoInfo *	mach0_info_new (RzBuffer *buf, ut64 at, ut64 max_size)
static void	mach0_info_free (RSepMachoInfo *info)
static bool	read_arm64_ins (RzBuffer *b, int idx, ut64 *result)
static char *	get_proper_name (const char *app_name)
static RzBuffer *	extract_slice (RzBuffer *whole, RSepMachoInfo *info)
static void	fill_metadata_info_from_hdr (RzBinXtrMetadata *meta, struct MACH0_(mach_header) *hdr)
static bool	check_buffer (RzBuffer *b)
static bool	load (RzBin *bin)
static void	destroy (RzBin *bin)
static int	size (RzBin *bin)
static RzBinXtrData *	oneshot_buffer (RzBin *bin, RzBuffer *b, int idx)
static RzList *	oneshotall_buffer (RzBin *bin, RzBuffer *b)

Variables
RzBinXtrPlugin	rz_bin_xtr_plugin_xtr_sep64
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

BTW

#define BTW	(		val,
			min,
			max
	)		((val) > min && (val) < max)

Definition at line 92 of file bin_xtr_sep64.c.

RZ_BIN_MACH064

#define RZ_BIN_MACH064   1

Definition at line 10 of file bin_xtr_sep64.c.

Typedef Documentation

RSepApp64

typedef struct _RSepApp64 RSepApp64

RSepHdr64

typedef struct _RSepHdr64 RSepHdr64

RSepMachoInfo

typedef struct _RSepMachoInfo RSepMachoInfo

RSepSlice64

typedef struct _RSepSlice64 RSepSlice64

RSepXtr64Ctx

typedef struct _RSepXtr64Ctx RSepXtr64Ctx

Function Documentation

check_buffer()

static bool check_buffer ( RzBuffer *  b )

static

Definition at line 94 of file bin_xtr_sep64.c.

                                      {
    rz_return_val_if_fail(b, false);
 
    const ut64 sz = rz_buf_size(b);
    if (sz < 0x11c0) {
        return false;
    }
 
    ut64 msr_vbar_el1;
    if (!read_arm64_ins(b, 2, &msr_vbar_el1)) {
        return false;
    }
 
    if (msr_vbar_el1 != 0xd518c002) {
        return false;
    }
 
    ut64 adr;
    if (!read_arm64_ins(b, 1, &adr)) {
        return false;
    }
 
    if (adr != 0x10003fe2) {
        return false;
    }
 
    ut64 tmp;
    if (!read_arm64_ins(b, 512, &tmp)) {
        return false;
    }
 
    /* check exception vector */
    if (tmp != 0x14000000) {
        return false;
    }
 
    if (!read_arm64_ins(b, 1023, &tmp)) {
        return false;
    }
 
    if (tmp != 0x14000000) {
        return false;
    }
 
    if (!read_arm64_ins(b, 1028, &tmp)) {
        return false;
    }
 
    /* legion2 */
    if (tmp != 0x326e6f69) {
        return false;
    }
 
    /* data header start */
    ut64 hdr_offset;
    if (!read_arm64_ins(b, 1029, &hdr_offset)) {
        return false;
    };
 
    if (hdr_offset >= sz) {
        return false;
    }
 
    ut64 size;
    if (!rz_buf_read_le64_at(b, hdr_offset + 56, &size)) {
        return false;
    }
 
    /* check size */
    if (size != sz) {
        return false;
    }
 
    return true;
}

References adr(), b, read_arm64_ins(), rz_buf_read_le64_at, rz_buf_size(), rz_return_val_if_fail, size(), autogen_x86imm::tmp, and ut64().

destroy()

static void destroy ( RzBin *  bin )

static

Definition at line 174 of file bin_xtr_sep64.c.

                                {
    sep64_xtr_ctx_free(bin->cur->xtr_obj);
}

References sep64_xtr_ctx_free().

extract_slice()

static RzBuffer * extract_slice ( RzBuffer *  whole, RSepMachoInfo *  info  )

static

Definition at line 461 of file bin_xtr_sep64.c.

                                                                     {
    ut8 *content = NULL;
 
    content = (ut8 *)malloc(info->total_size);
    if (!content) {
        goto beach;
    }
    if (rz_buf_read_at(whole, info->text_offset_in_whole, content, info->text_size) != info->text_size) {
        goto beach;
    }
    ut64 data_offset = info->data_offset_in_whole ? info->data_offset_in_whole : info->text_offset_in_whole + info->data_offset;
    if (rz_buf_read_at(whole, data_offset, content + info->data_offset, info->data_size) != info->data_size) {
        goto beach;
    }
 
    return rz_buf_new_with_pointers(content, info->total_size, true);
beach:
    free(content);
 
    return NULL;
}

References free(), info(), malloc(), NULL, rz_buf_new_with_pointers(), rz_buf_read_at(), and ut64().

Referenced by sep64_xtr_ctx_get_slice().

fill_metadata_info_from_hdr()

static void fill_metadata_info_from_hdr ( RzBinXtrMetadata *  meta, struct MACH0_(mach_header) *  hdr  )

inlinestatic

Definition at line 483 of file bin_xtr_sep64.c.

                                                                                                         {
    meta->arch = strdup(MACH0_(get_cputype_from_hdr)(hdr));
    meta->bits = MACH0_(get_bits_from_hdr)(hdr);
    meta->machine = MACH0_(get_cpusubtype_from_hdr)(hdr);
    meta->type = MACH0_(get_filetype_from_hdr)(hdr);
}

References rz_bin_xtr_metadata_t::arch, rz_bin_xtr_metadata_t::bits, get_bits_from_hdr(), get_cpusubtype_from_hdr(), get_cputype_from_hdr(), get_filetype_from_hdr(), MACH0_, rz_bin_xtr_metadata_t::machine, strdup(), and rz_bin_xtr_metadata_t::type.

Referenced by sep64_xtr_ctx_get_slice().

get_proper_name()

static char * get_proper_name ( const char *  app_name )

static

Definition at line 490 of file bin_xtr_sep64.c.

                                                   {
    char *proper_name = calloc(13, 1);
    if (!proper_name) {
        return NULL;
    }
    int i;
 
    for (i = 12; i != -1; i--) {
        if (app_name[i] == ' ') {
            proper_name[i] = 0;
        } else {
            proper_name[i] = app_name[i];
        }
    }
 
    return proper_name;
}

References calloc(), i, and NULL.

Referenced by sep64_xtr_ctx_get_slice().

load()

static bool load ( RzBin *  bin )

static

Definition at line 170 of file bin_xtr_sep64.c.

                             {
    return ((bin->cur->xtr_obj = sep64_xtr_ctx_new(bin->cur->buf)) != NULL);
}

References bin::buf, NULL, and sep64_xtr_ctx_new().

mach0_info_free()

static void mach0_info_free ( RSepMachoInfo *  info )

static

Definition at line 452 of file bin_xtr_sep64.c.

                                                 {
    if (!info) {
        return;
    }
 
    free(info->hdr);
    free(info);
}

References free(), and info().

Referenced by sep64_xtr_ctx_get_slice().

mach0_info_new()

static RSepMachoInfo * mach0_info_new ( RzBuffer *  buf, ut64  at, ut64  max_size  )

static

Definition at line 376 of file bin_xtr_sep64.c.

                                                                            {
    rz_return_val_if_fail(max_size >= 1024, NULL);
 
    RSepMachoInfo *result = NULL;
    struct MACH0_(mach_header) *hdr = NULL;
    ut8 *commands = NULL;
    ut64 total_size = 0, text_size = 0, data_offset = 0, data_size = 0;
 
    ut32 hdr_size = sizeof(struct MACH0_(mach_header));
    hdr = malloc(hdr_size);
    if (!hdr) {
        goto beach;
    }
    if (rz_buf_read_at(buf, at, (ut8 *)hdr, hdr_size) != hdr_size) {
        goto beach;
    }
    if (hdr->magic != MH_MAGIC_64 || !BTW(hdr->sizeofcmds, 0, max_size)) {
        goto beach;
    }
 
    commands = malloc(hdr->sizeofcmds);
    if (!commands) {
        goto beach;
    }
    if (rz_buf_read_at(buf, at + hdr_size, commands, hdr->sizeofcmds) != hdr->sizeofcmds) {
        goto beach;
    }
 
    ut32 i;
    ut8 *cursor = commands;
    for (i = 0; i < hdr->ncmds; i++) {
        const struct load_command *cmd = (struct load_command *)cursor;
        if (cmd->cmd == LC_SEGMENT_64) {
            const struct MACH0_(segment_command) *seg = (struct MACH0_(segment_command) *)cursor;
            ut64 end = seg->fileoff + seg->filesize;
            if (total_size < end) {
                total_size = end;
            }
            if (!strcmp(seg->segname, "__TEXT")) {
                text_size = seg->filesize;
            } else if (!strcmp(seg->segname, "__DATA")) {
                data_offset = seg->fileoff;
                data_size = seg->filesize;
            }
        }
        cursor = cursor + cmd->cmdsize;
    }
 
    if (total_size == 0 || text_size == 0 || data_offset == 0 || data_size == 0) {
        goto beach;
    }
 
    result = RZ_NEW0(RSepMachoInfo);
    if (!result) {
        goto beach;
    }
 
    result->hdr = hdr;
    result->total_size = total_size;
    result->text_size = text_size;
    result->data_offset = data_offset;
    result->data_size = data_size;
    result->text_offset_in_whole = at;
 
    free(commands);
 
    return result;
beach:
 
    free(result);
    free(hdr);
    free(commands);
 
    return NULL;
}

References BTW, cmd, commands, test_evm::end, free(), i, LC_SEGMENT_64, malloc(), MH_MAGIC_64, NULL, rz_buf_read_at(), RZ_NEW0, rz_return_val_if_fail, and ut64().

Referenced by sep64_xtr_ctx_get_slice().

oneshot_buffer()

static RzBinXtrData* oneshot_buffer ( RzBin *  bin, RzBuffer *  b, int  idx  )

static

Definition at line 183 of file bin_xtr_sep64.c.

                                                                      {
    rz_return_val_if_fail(bin && bin->cur, NULL);
 
    if (!bin->cur->xtr_obj) {
        bin->cur->xtr_obj = sep64_xtr_ctx_new(b);
    }
    RSepXtr64Ctx *ctx = bin->cur->xtr_obj;
 
    RSepSlice64 *slice = sep64_xtr_ctx_get_slice(ctx, b, idx);
    RzBinXtrData *res = rz_bin_xtrdata_new(slice->buf, slice->nominal_offset, slice->total_size, 3 + ctx->hdr->n_apps, slice->meta);
 
    rz_buf_free(slice->buf);
    free(slice);
    return res;
}

References b, _RSepSlice64::buf, free(), setup::idx, _RSepSlice64::meta, _RSepSlice64::nominal_offset, NULL, rz_bin_xtrdata_new(), rz_buf_free(), rz_return_val_if_fail, sep64_xtr_ctx_get_slice(), sep64_xtr_ctx_new(), and _RSepSlice64::total_size.

Referenced by oneshotall_buffer().

oneshotall_buffer()

static RzList* oneshotall_buffer ( RzBin *  bin, RzBuffer *  b  )

static

Definition at line 199 of file bin_xtr_sep64.c.

                                                          {
    RzBinXtrData *data = oneshot_buffer(bin, b, 0);
    if (data) {
        int narch = data->file_count;
        RzList *res = rz_list_newf(rz_bin_xtrdata_free);
        if (!res) {
            rz_bin_xtrdata_free(data);
            return NULL;
        }
        rz_list_append(res, data);
        int i;
        for (i = 1; data && i < narch; i++) {
            data = oneshot_buffer(bin, b, i);
            rz_list_append(res, data);
        }
        return res;
    }
    return NULL;
}

References b, rz_bin_xtr_extract_t::file_count, i, NULL, oneshot_buffer(), rz_bin_xtrdata_free(), rz_list_append(), and rz_list_newf().

read_arm64_ins()

static bool read_arm64_ins ( RzBuffer *  b, int  idx, ut64 *  result  )

static

Definition at line 508 of file bin_xtr_sep64.c.

                                                               {
    ut32 tmp;
 
    bool res = rz_buf_read_le32_at(b, idx * 4, &tmp);
    if (!res) {
        return false;
    }
 
    *result = tmp;
    return res;
}

References b, setup::idx, rz_buf_read_le32_at, and autogen_x86imm::tmp.

Referenced by check_buffer().

sep64_xtr_ctx_free()

static void sep64_xtr_ctx_free ( void *  p )

static

Definition at line 271 of file bin_xtr_sep64.c.

                                        {
    if (!p) {
        return;
    }
 
    RSepXtr64Ctx *ctx = p;
 
    RZ_FREE(ctx->hdr);
    RZ_FREE(ctx->apps);
 
    free(ctx);
}

References free(), p, and RZ_FREE.

Referenced by destroy().

sep64_xtr_ctx_get_slice()

static RSepSlice64 * sep64_xtr_ctx_get_slice ( RSepXtr64Ctx *  ctx, RzBuffer *  whole, int  idx  )

static

Definition at line 284 of file bin_xtr_sep64.c.

                                                                                         {
    if (idx >= ctx->hdr->n_apps + 3) {
        return NULL;
    }
 
    ut64 whole_size = rz_buf_size(whole);
    RzBuffer *slice_buf = NULL;
    char *name = NULL;
    RSepSlice64 *slice = NULL;
    RSepMachoInfo *info = NULL;
    RzBinXtrMetadata *meta = NULL;
    ut64 nominal_offset = 0;
    ut64 total_size = 0;
 
    if (idx == 0) {
        name = strdup("boot");
        slice_buf = rz_buf_new_slice(whole, 0, ctx->hdr->kernel_base_paddr);
        total_size = ctx->hdr->kernel_base_paddr;
    } else if (idx == 1) {
        name = strdup("kernel");
        info = mach0_info_new(whole, ctx->hdr->kernel_base_paddr, whole_size - ctx->hdr->kernel_base_paddr);
        if (!info) {
            goto beach;
        }
        slice_buf = rz_buf_new_slice(whole, ctx->hdr->kernel_base_paddr, info->total_size);
        nominal_offset = ctx->hdr->kernel_base_paddr;
        total_size = info->total_size;
    } else if (idx == 2) {
        name = get_proper_name(ctx->hdr->init_name);
        info = mach0_info_new(whole, ctx->hdr->init_base_paddr, whole_size - ctx->hdr->init_base_paddr);
        if (!info) {
            goto beach;
        }
        slice_buf = extract_slice(whole, info);
        nominal_offset = ctx->hdr->init_base_paddr;
        total_size = info->total_size;
    } else {
        int app_idx = idx - 3;
        name = get_proper_name(ctx->apps[app_idx].app_name);
        info = mach0_info_new(whole, ctx->apps[app_idx].phys_text, whole_size - ctx->apps[app_idx].phys_text);
        if (!info) {
            goto beach;
        }
        info->data_offset_in_whole = ctx->apps[app_idx].phys_data;
        slice_buf = extract_slice(whole, info);
        nominal_offset = ctx->apps[app_idx].phys_text;
        total_size = info->total_size;
    }
 
    if (!name || !slice_buf) {
        goto beach;
    }
 
    meta = RZ_NEW0(RzBinXtrMetadata);
    if (!meta) {
        goto beach;
    }
 
    if (info) {
        fill_metadata_info_from_hdr(meta, info->hdr);
    } else {
        meta->arch = strdup("arm");
        meta->bits = 64;
        meta->machine = strdup("arm64e");
        meta->type = strdup("Executable file");
    }
 
    meta->xtr_type = "SEP";
    meta->libname = name;
 
    slice = RZ_NEW0(RSepSlice64);
    if (!slice) {
        goto beach;
    }
 
    slice->buf = slice_buf;
    slice->nominal_offset = nominal_offset;
    slice->total_size = total_size;
    slice->meta = meta;
 
    mach0_info_free(info);
 
    return slice;
beach:
    rz_buf_free(slice_buf);
    free(name);
    free(slice);
    free(meta);
    mach0_info_free(info);
    return NULL;
}

References rz_bin_xtr_metadata_t::arch, rz_bin_xtr_metadata_t::bits, _RSepSlice64::buf, extract_slice(), fill_metadata_info_from_hdr(), free(), get_proper_name(), setup::idx, info(), rz_bin_xtr_metadata_t::libname, mach0_info_free(), mach0_info_new(), rz_bin_xtr_metadata_t::machine, _RSepSlice64::meta, name, _RSepSlice64::nominal_offset, NULL, rz_buf_free(), rz_buf_new_slice(), rz_buf_size(), RZ_NEW0, strdup(), _RSepSlice64::total_size, rz_bin_xtr_metadata_t::type, ut64(), and rz_bin_xtr_metadata_t::xtr_type.

Referenced by oneshot_buffer().

sep64_xtr_ctx_new()

static RSepXtr64Ctx * sep64_xtr_ctx_new ( RzBuffer *  buf )

static

Definition at line 219 of file bin_xtr_sep64.c.

                                                      {
    RSepHdr64 *hdr = NULL;
    RSepApp64 *apps = NULL;
    RSepXtr64Ctx *ctx = NULL;
 
    ut64 hdr_offset;
    if (!rz_buf_read_le64_at(buf, 0x1014, &hdr_offset)) {
        goto beach;
    }
 
    if (hdr_offset == UT64_MAX) {
        goto beach;
    }
 
    hdr = RZ_NEW0(RSepHdr64);
    if (!hdr) {
        goto beach;
    }
    if (rz_buf_fread_at(buf, hdr_offset, (ut8 *)hdr, "16c16l16c16c3l", 1) != sizeof(RSepHdr64)) {
        goto beach;
    }
 
    if (!hdr->n_apps) {
        goto beach;
    }
 
    ut64 apps_at = hdr_offset + sizeof(RSepHdr64);
    apps = RZ_NEWS0(RSepApp64, hdr->n_apps);
    if (!apps) {
        goto beach;
    }
    if (rz_buf_fread_at(buf, apps_at, (ut8 *)apps, "9l2i16c16cl", hdr->n_apps) != (sizeof(RSepApp64) * hdr->n_apps)) {
        goto beach;
    }
 
    ctx = RZ_NEW0(RSepXtr64Ctx);
    if (!ctx) {
        goto beach;
    }
 
    ctx->hdr = hdr;
    ctx->apps = apps;
 
    return ctx;
beach:
    free(hdr);
    free(apps);
    free(ctx);
 
    return NULL;
}

References free(), _RSepHdr64::n_apps, NULL, rz_buf_fread_at(), rz_buf_read_le64_at, RZ_NEW0, RZ_NEWS0, ut64(), and UT64_MAX.

Referenced by load(), and oneshot_buffer().

size()

static int size ( RzBin *  bin )

static

Definition at line 178 of file bin_xtr_sep64.c.

                            {
    // TODO
    return 0;
}

Referenced by check_buffer().

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_BIN_XTR,
    .data = &rz_bin_xtr_plugin_xtr_sep64,
    .version = RZ_VERSION
}

Definition at line 534 of file bin_xtr_sep64.c.

rz_bin_xtr_plugin_xtr_sep64

RzBinXtrPlugin rz_bin_xtr_plugin_xtr_sep64

Initial value:

= {
    .name = "xtr.sep64",
    .desc = "64-bit SEP bin extractor plugin",
    .license = "LGPL3",
    .check_buffer = check_buffer,
    .load = &load,
    .destroy = &destroy,
    .size = &size,
    .extract_from_buffer = &oneshot_buffer,
    .extractall_from_buffer = &oneshotall_buffer,
    .free_xtr = &sep64_xtr_ctx_free,
}

Definition at line 520 of file bin_xtr_sep64.c.