egg.c File Reference

#include <rz_egg.h>
#include <config.h>

Go to the source code of this file.

Classes
struct	egg_patch_t

Macros
#define	RZ_EGG_FILL_TYPE_TRAP
#define	RZ_EGG_FILL_TYPE_NOP
#define	RZ_EGG_FILL_TYPE_CHAR
#define	RZ_EGG_FILL_TYPE_SEQ
#define	RZ_EGG_FILL_TYPE_SEQ

Functions
	RZ_LIB_VERSION (rz_egg)
void	egg_patch_free (void *p)
RZ_API const char *	rz_egg_os_as_string (int os)
RZ_API RzEgg *	rz_egg_new (void)
RZ_API int	rz_egg_add (RzEgg *a, RzEggPlugin *foo)
RZ_API char *	rz_egg_to_string (RzEgg *egg)
RZ_API void	rz_egg_free (RzEgg *egg)
RZ_API void	rz_egg_reset (RzEgg *egg)
RZ_API bool	rz_egg_setup (RzEgg *egg, const char *arch, int bits, int endian, const char *os)
RZ_API int	rz_egg_include (RzEgg *egg, const char *file, int format)
RZ_API void	rz_egg_load (RzEgg *egg, const char *code, int format)
RZ_API bool	rz_egg_load_file (RzEgg *egg, const char *file)
RZ_API void	rz_egg_syscall (RzEgg *egg, const char *arg,...)
RZ_API void	rz_egg_alloc (RzEgg *egg, int n)
RZ_API void	rz_egg_label (RzEgg *egg, const char *name)
RZ_API void	rz_egg_math (RzEgg *egg)
RZ_API int	rz_egg_raw (RzEgg *egg, const ut8 *b, int len)
static int	rz_egg_raw_prepend (RzEgg *egg, const ut8 *b, int len)
static int	rz_egg_prepend_bytes (RzEgg *egg, const ut8 *b, int len)
static int	rz_egg_append_bytes (RzEgg *egg, const ut8 *b, int len)
RZ_API void	rz_egg_if (RzEgg *egg, const char *reg, char cmp, int v)
RZ_API void	rz_egg_printf (RzEgg *egg, const char *fmt,...)
RZ_API bool	rz_egg_assemble_asm (RzEgg *egg, char **asm_list)
RZ_API bool	rz_egg_assemble (RzEgg *egg)
RZ_API int	rz_egg_compile (RzEgg *egg)
RZ_API RzBuffer *	rz_egg_get_bin (RzEgg *egg)
RZ_API char *	rz_egg_get_source (RzEgg *egg)
RZ_API char *	rz_egg_get_assembly (RzEgg *egg)
RZ_API void	rz_egg_append (RzEgg *egg, const char *src)
RZ_API int	rz_egg_run (RzEgg *egg)
RZ_API int	rz_egg_run_rop (RzEgg *egg)
static char *	eon (char *n)
RZ_API int	rz_egg_padding (RzEgg *egg, const char *pad)
RZ_API void	rz_egg_fill (RzEgg *egg, int pos, int type, int argc, int length)
RZ_API void	rz_egg_option_set (RzEgg *egg, const char *key, const char *val)
RZ_API char *	rz_egg_option_get (RzEgg *egg, const char *key)
RZ_API int	rz_egg_shellcode (RzEgg *egg, const char *name)
RZ_API int	rz_egg_encode (RzEgg *egg, const char *name)
RZ_API int	rz_egg_patch (RzEgg *egg, int off, const ut8 *buf, int len)
RZ_API bool	rz_egg_patch_num (RzEgg *egg, int off, ut64 num, ut32 bits)
RZ_API void	rz_egg_finalize (RzEgg *egg)
RZ_API void	rz_egg_pattern (RzEgg *egg, int size)

Variables
RzEggEmit	emit_x86
RzEggEmit	emit_x64
RzEggEmit	emit_arm
RzEggEmit	emit_trace
static RzEggPlugin *	egg_static_plugins [] = { RZ_EGG_STATIC_PLUGINS }

Macro Definition Documentation

RZ_EGG_FILL_TYPE_CHAR

#define RZ_EGG_FILL_TYPE_CHAR

Definition at line 458 of file egg.c.

RZ_EGG_FILL_TYPE_NOP

#define RZ_EGG_FILL_TYPE_NOP

Definition at line 457 of file egg.c.

RZ_EGG_FILL_TYPE_SEQ [1/2]

#define RZ_EGG_FILL_TYPE_SEQ

Definition at line 460 of file egg.c.

RZ_EGG_FILL_TYPE_SEQ [2/2]

#define RZ_EGG_FILL_TYPE_SEQ

Definition at line 460 of file egg.c.

RZ_EGG_FILL_TYPE_TRAP

#define RZ_EGG_FILL_TYPE_TRAP

Definition at line 456 of file egg.c.

Function Documentation

egg_patch_free()

void egg_patch_free

(

void *

p

)

Definition at line 22 of file egg.c.

                             {
    struct egg_patch_t *ep = (struct egg_patch_t *)p;
    rz_buf_free(ep->b);
    free(ep);
}

References egg_patch_t::b, free(), p, and rz_buf_free().

Referenced by rz_egg_new(), and rz_egg_patch().

eon()

static char* eon ( char *  n )

inlinestatic

Definition at line 462 of file egg.c.

                                 {
    while (*n && (*n >= '0' && *n <= '9')) {
        n++;
    }
    return n;
}

References n.

Referenced by rz_egg_padding().

rz_egg_add()

RZ_API int rz_egg_add	(	RzEgg *	a,
		RzEggPlugin *	foo
	)

Definition at line 92 of file egg.c.

                                                  {
    RzListIter *iter;
    RzAsmPlugin *h;
    if (!foo->name) {
        return false;
    }
    rz_list_foreach (a->plugins, iter, h) {
        if (!strcmp(h->name, foo->name)) {
            return false;
        }
    }
    rz_list_append(a->plugins, foo);
    return true;
}

References a, foo, h, rz_main_t::name, and rz_list_append().

Referenced by rz_egg_new().

rz_egg_alloc()

RZ_API void rz_egg_alloc	(	RzEgg *	egg,
		int	n
	)

Definition at line 268 of file egg.c.

                                            {
    // add esp, n
}

rz_egg_append()

RZ_API void rz_egg_append	(	RzEgg *	egg,
		const char *	src
	)

Definition at line 438 of file egg.c.

                                                       {
    rz_buf_append_bytes(egg->src, (const ut8 *)src, strlen(src));
}

References rz_buf_append_bytes(), rz_egg_t::src, and src.

rz_egg_append_bytes()

static int rz_egg_append_bytes ( RzEgg *  egg, const ut8 *  b, int  len  )

static

Definition at line 319 of file egg.c.

                                                                  {
    if (!rz_egg_raw(egg, b, len)) {
        return false;
    }
 
    if (!rz_buf_append_bytes(egg->bin, b, len)) {
        return false;
    }
 
    return true;
}

References b, rz_egg_t::bin, len, rz_buf_append_bytes(), and rz_egg_raw().

Referenced by rz_egg_finalize(), and rz_egg_padding().

rz_egg_assemble()

RZ_API bool rz_egg_assemble

(

RzEgg *

egg

)

Definition at line 390 of file egg.c.

                                        {
    return rz_egg_assemble_asm(egg, NULL);
}

References NULL, and rz_egg_assemble_asm().

Referenced by egg_compile(), rz_core_syscall(), and rz_main_rz_gg().

rz_egg_assemble_asm()

RZ_API bool rz_egg_assemble_asm	(	RzEgg *	egg,
		char **	asm_list
	)

Definition at line 346 of file egg.c.

                                                             {
    RzAsmCode *asmcode = NULL;
    char *code = NULL;
    char *asm_name = NULL;
 
    if (asm_list) {
        char **asm_;
 
        for (asm_ = asm_list; *asm_; asm_ += 2) {
            if (!strcmp(egg->remit->arch, asm_[0])) {
                asm_name = asm_[1];
                break;
            }
        }
    }
    if (!asm_name) {
        if (egg->remit == &emit_x86 || egg->remit == &emit_x64) {
            asm_name = "x86.nz";
        } else if (egg->remit == &emit_arm) {
            asm_name = "arm";
        }
    }
    if (asm_name) {
        rz_asm_use(egg->rasm, asm_name);
        rz_asm_set_bits(egg->rasm, egg->bits);
        rz_asm_set_big_endian(egg->rasm, egg->endian);
        rz_asm_set_syntax(egg->rasm, RZ_ASM_SYNTAX_INTEL);
        code = rz_buf_to_string(egg->buf);
        asmcode = rz_asm_massemble(egg->rasm, code);
        if (asmcode) {
            if (asmcode->len > 0) {
                rz_buf_append_bytes(egg->bin, asmcode->bytes, asmcode->len);
            }
            // LEAK rz_asm_code_free (asmcode);
        } else {
            eprintf("fail assembling\n");
        }
    }
    bool ret = code ? asmcode != NULL : true;
    free(code);
    rz_asm_code_free(asmcode);
    return ret;
}

References rz_egg_emit_t::arch, rz_egg_t::bin, rz_egg_t::bits, rz_egg_t::buf, rz_asm_code_t::bytes, emit_arm, emit_x64, emit_x86, rz_egg_t::endian, eprintf, free(), rz_asm_code_t::len, NULL, rz_egg_t::rasm, rz_egg_t::remit, rz_asm_code_free(), rz_asm_massemble(), rz_asm_set_big_endian(), rz_asm_set_bits(), rz_asm_set_syntax(), RZ_ASM_SYNTAX_INTEL, rz_asm_use(), rz_buf_append_bytes(), and rz_buf_to_string().

Referenced by rz_egg_assemble().

rz_egg_compile()

RZ_API int rz_egg_compile

(

RzEgg *

egg

)

Definition at line 394 of file egg.c.

                                      {
    rz_buf_seek(egg->src, 0, RZ_BUF_SET);
    char b;
    int r = rz_buf_read(egg->src, (ut8 *)&b, sizeof(b));
    if (r != sizeof(b) || !egg->remit) {
        return true;
    }
    // only emit begin if code is found
    rz_egg_lang_init(egg);
    for (; b;) {
        rz_egg_lang_parsechar(egg, b);
        if (egg->lang.elem_n >= sizeof(egg->lang.elem)) {
            eprintf("ERROR: elem too large.\n");
            break;
        }
        int r = rz_buf_read(egg->src, (ut8 *)&b, sizeof(b));
        if (r != sizeof(b)) {
            break;
        }
        // XXX: some parse fail errors are false positives :(
    }
    if (egg->context > 0) {
        eprintf("ERROR: expected '}' at the end of the file. %d left\n", egg->context);
        return false;
    }
    // TODO: handle errors here
    return true;
}

References b, rz_egg_t::context, rz_egg_lang_t::elem, rz_egg_lang_t::elem_n, eprintf, rz_egg_t::lang, r, rz_egg_t::remit, rz_buf_read(), rz_buf_seek(), RZ_BUF_SET, rz_egg_lang_init(), rz_egg_lang_parsechar(), and rz_egg_t::src.

Referenced by egg_compile(), rz_cmd_debug(), rz_core_syscall(), and rz_main_rz_gg().

rz_egg_encode()

RZ_API int rz_egg_encode	(	RzEgg *	egg,
		const char *	name
	)

Definition at line 558 of file egg.c.

                                                       {
    RzEggPlugin *p;
    RzListIter *iter;
    RzBuffer *b;
    rz_list_foreach (egg->plugins, iter, p) {
        if (p->type == RZ_EGG_PLUGIN_ENCODER && !strcmp(name, p->name)) {
            b = p->build(egg);
            if (!b) {
                return false;
            }
            rz_buf_free(egg->bin);
            egg->bin = b;
            return true;
        }
    }
    return false;
}

References b, rz_egg_t::bin, p, rz_egg_t::plugins, rz_buf_free(), and RZ_EGG_PLUGIN_ENCODER.

Referenced by egg_compile(), and rz_main_rz_gg().

rz_egg_fill()

RZ_API void rz_egg_fill	(	RzEgg *	egg,
		int	pos,
		int	type,
		int	argc,
		int	length
	)

Definition at line 526 of file egg.c.

                                                                             {
    // TODO
}

rz_egg_finalize()

RZ_API void rz_egg_finalize

(

RzEgg *

egg

)

Definition at line 598 of file egg.c.

                                        {
    struct egg_patch_t *ep;
    RzListIter *iter;
    if (!egg->bin) {
        rz_buf_free(egg->bin);
        egg->bin = rz_buf_new_with_bytes(NULL, 0);
    }
    rz_list_foreach (egg->patches, iter, ep) {
        if (ep->off < 0) {
            ut64 sz;
            const ut8 *buf = rz_buf_data(ep->b, &sz);
            rz_egg_append_bytes(egg, buf, sz);
        } else if (ep->off < rz_buf_size(egg->bin)) {
            ut64 sz;
            const ut8 *buf = rz_buf_data(ep->b, &sz);
            int r = rz_buf_write_at(egg->bin, ep->off, buf, sz);
            if (r < sz) {
                eprintf("Error during patch\n");
                return;
            }
        } else {
            eprintf("Cannot patch outside\n");
            return;
        }
    }
}

References egg_patch_t::b, rz_egg_t::bin, eprintf, NULL, egg_patch_t::off, rz_egg_t::patches, r, rz_buf_data(), rz_buf_free(), rz_buf_new_with_bytes(), rz_buf_size(), rz_buf_write_at(), rz_egg_append_bytes(), and ut64().

Referenced by rz_main_rz_gg().

rz_egg_free()

RZ_API void rz_egg_free

(

RzEgg *

egg

)

Definition at line 111 of file egg.c.

                                    {
    if (!egg) {
        return;
    }
    rz_buf_free(egg->src);
    rz_buf_free(egg->buf);
    rz_buf_free(egg->bin);
    rz_list_free(egg->list);
    rz_asm_free(egg->rasm);
    rz_syscall_free(egg->syscall);
    sdb_free(egg->db);
    rz_list_free(egg->plugins);
    rz_list_free(egg->patches);
    rz_egg_lang_free(egg);
    free(egg);
}

References rz_egg_t::bin, rz_egg_t::buf, rz_egg_t::db, free(), rz_egg_t::list, rz_egg_t::patches, rz_egg_t::plugins, rz_egg_t::rasm, rz_asm_free(), rz_buf_free(), rz_egg_lang_free(), rz_list_free(), rz_syscall_free(), sdb_free(), rz_egg_t::src, and rz_egg_t::syscall.

Referenced by rz_core_fini(), rz_debug_free(), rz_egg_new(), and rz_main_rz_gg().

rz_egg_get_assembly()

RZ_API char* rz_egg_get_assembly

(

RzEgg *

egg

)

Definition at line 434 of file egg.c.

                                             {
    return rz_buf_to_string(egg->buf);
}

References rz_egg_t::buf, and rz_buf_to_string().

Referenced by rz_main_rz_gg().

rz_egg_get_bin()

RZ_API RzBuffer* rz_egg_get_bin

(

RzEgg *

egg

)

Definition at line 423 of file egg.c.

                                            {
    // TODO increment reference
    return egg->bin;
}

References rz_egg_t::bin.

Referenced by egg_compile(), rz_cmd_debug(), rz_core_syscall(), and rz_main_rz_gg().

rz_egg_get_source()

RZ_API char* rz_egg_get_source

(

RzEgg *

egg

)

Definition at line 430 of file egg.c.

                                           {
    return rz_buf_to_string(egg->src);
}

References rz_buf_to_string(), and rz_egg_t::src.

rz_egg_if()

RZ_API void rz_egg_if	(	RzEgg *	egg,
		const char *	reg,
		char	cmp,
		int	v
	)

Definition at line 332 of file egg.c.

                                                                    {
    //  egg->depth++;
}

rz_egg_include()

RZ_API int rz_egg_include	(	RzEgg *	egg,
		const char *	file,
		int	format
	)

Definition at line 181 of file egg.c.

                                                                    {
    size_t sz;
    const ut8 *foo = (const ut8 *)rz_file_slurp(file, &sz);
    if (!foo) {
        return 0;
    }
    // XXX: format breaks compiler layers
    switch (format) {
    case 'r': // raw
        rz_egg_raw(egg, foo, (int)sz);
        break;
    case 'a': // assembly
        rz_buf_append_bytes(egg->buf, foo, (ut64)sz);
        break;
    default:
        rz_buf_append_bytes(egg->src, foo, (ut64)sz);
    }
    free((void *)foo);
    return 1;
}

References rz_egg_t::buf, foo, free(), rz_buf_append_bytes(), rz_egg_raw(), rz_file_slurp(), rz_egg_t::src, and ut64().

Referenced by rz_egg_load_file().

rz_egg_label()

RZ_API void rz_egg_label	(	RzEgg *	egg,
		const char *	name
	)

Definition at line 272 of file egg.c.

                                                       {
    rz_egg_printf(egg, "%s:\n", name);
}

References rz_egg_printf().

rz_egg_load()

RZ_API void rz_egg_load	(	RzEgg *	egg,
		const char *	code,
		int	format
	)

Definition at line 202 of file egg.c.

                                                                  {
    rz_return_if_fail(code);
    switch (format) {
    case 'a': // assembly
        rz_buf_append_bytes(egg->buf, (const ut8 *)code, strlen(code));
        break;
    default:
        rz_buf_append_bytes(egg->src, (const ut8 *)code, strlen(code));
        break;
    }
}

References rz_egg_t::buf, rz_buf_append_bytes(), rz_return_if_fail, and rz_egg_t::src.

Referenced by rz_cmd_debug(), rz_core_syscall(), and rz_main_rz_gg().

rz_egg_load_file()

RZ_API bool rz_egg_load_file	(	RzEgg *	egg,
		const char *	file
	)

Definition at line 214 of file egg.c.

                                                           {
    rz_return_val_if_fail(file, false);
    // We have to reset the RzEgg state first
    rz_egg_reset(egg);
    if (rz_str_endswith(file, ".c")) {
        char *fileSanitized = strdup(file);
        rz_str_sanitize(fileSanitized);
        const char *arch = rz_sys_arch_str(egg->arch);
        const char *os = rz_egg_os_as_string(egg->os);
        char *textFile = rz_egg_Cfile_parser(fileSanitized, arch, os, egg->bits);
        if (!textFile) {
            RZ_LOG_ERROR("Failure while parsing '%s'\n", fileSanitized);
            free(fileSanitized);
            return false;
        }
        size_t l;
        char *buf = rz_file_slurp(textFile, &l);
        if (buf && l > 0) {
            rz_egg_raw(egg, (const ut8 *)buf, (int)l);
        } else {
            RZ_LOG_ERROR("Error loading '%s'\n", textFile);
        }
        rz_file_rm(textFile);
        free(fileSanitized);
        free(textFile);
        free(buf);
    } else {
        int fmt;
        if (rz_str_endswith(file, ".s") || rz_str_endswith(file, ".asm")) {
            fmt = 'a';
        } else {
            fmt = 0;
        }
        if (!rz_egg_include(egg, file, fmt)) {
            RZ_LOG_ERROR("Cannot open '%s'\n", file);
            return false;
        }
    }
    return true;
}

References rz_egg_t::arch, arch, rz_egg_t::bits, free(), rz_egg_t::os, rz_egg_Cfile_parser(), rz_egg_include(), rz_egg_os_as_string(), rz_egg_raw(), rz_egg_reset(), rz_file_rm(), rz_file_slurp(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_endswith(), rz_str_sanitize(), rz_sys_arch_str(), and strdup().

Referenced by rz_core_egg_compile_file(), and rz_main_rz_gg().

rz_egg_math()

RZ_API void rz_egg_math

(

RzEgg *

egg

)

Definition at line 276 of file egg.c.

                                    { //, char eq, const char *vs, char type, const char *sr
    // TODO
    // e->mathop (egg, op, type, eq, p);
}

rz_egg_new()

RZ_API RzEgg* rz_egg_new

(

void

)

Definition at line 44 of file egg.c.

                               {
    int i;
    RzEgg *egg = RZ_NEW0(RzEgg);
    if (!egg) {
        return NULL;
    }
    egg->src = rz_buf_new_with_bytes(NULL, 0);
    if (!egg->src) {
        goto beach;
    }
    egg->buf = rz_buf_new_with_bytes(NULL, 0);
    if (!egg->buf) {
        goto beach;
    }
    egg->bin = rz_buf_new_with_bytes(NULL, 0);
    if (!egg->bin) {
        goto beach;
    }
    egg->remit = &emit_x86;
    egg->syscall = rz_syscall_new();
    if (!egg->syscall) {
        goto beach;
    }
    egg->rasm = rz_asm_new();
    if (!egg->rasm) {
        goto beach;
    }
    egg->bits = 0;
    egg->endian = 0;
    egg->db = sdb_new(NULL, NULL, 0);
    if (!egg->db) {
        goto beach;
    }
    egg->patches = rz_list_newf(egg_patch_free);
    if (!egg->patches) {
        goto beach;
    }
    egg->plugins = rz_list_new();
    for (i = 0; i < RZ_ARRAY_SIZE(egg_static_plugins); i++) {
        rz_egg_add(egg, egg_static_plugins[i]);
    }
    return egg;
 
beach:
    rz_egg_free(egg);
    return NULL;
}

References rz_egg_t::bin, rz_egg_t::bits, rz_egg_t::buf, rz_egg_t::db, egg_patch_free(), egg_static_plugins, emit_x86, rz_egg_t::endian, i, NULL, rz_egg_t::patches, rz_egg_t::plugins, rz_egg_t::rasm, rz_egg_t::remit, RZ_ARRAY_SIZE, rz_asm_new(), rz_buf_new_with_bytes(), rz_egg_add(), rz_egg_free(), rz_list_new(), rz_list_newf(), RZ_NEW0, rz_syscall_new(), sdb_new(), rz_egg_t::src, and rz_egg_t::syscall.

Referenced by rz_core_init(), rz_debug_new(), and rz_main_rz_gg().

rz_egg_option_get()

RZ_API char* rz_egg_option_get	(	RzEgg *	egg,
		const char *	key
	)

Definition at line 534 of file egg.c.

                                                            {
    return sdb_get(egg->db, key, NULL);
}

References rz_egg_t::db, key, NULL, and sdb_get().

Referenced by build(), egg_compile(), egg_option(), rz_core_egg_compile(), rz_egg_config_handler(), and rz_egg_show_config_handler().

rz_egg_option_set()

RZ_API void rz_egg_option_set	(	RzEgg *	egg,
		const char *	key,
		const char *	val
	)

Definition at line 530 of file egg.c.

                                                                            {
    sdb_set(egg->db, key, val, 0);
}

References rz_egg_t::db, key, sdb_set(), and val.

Referenced by egg_option(), rz_core_egg_compile(), rz_egg_config_handler(), rz_egg_encoder_handler(), rz_egg_padding_handler(), rz_egg_type_handler(), and rz_main_rz_gg().

rz_egg_os_as_string()

RZ_API const char* rz_egg_os_as_string

(

int

os

)

Definition at line 28 of file egg.c.

                                               {
    switch (os) {
    case RZ_EGG_OS_LINUX: return "linux";
    case RZ_EGG_OS_OSX: return "osx";
    case RZ_EGG_OS_DARWIN: return "darwin";
    case RZ_EGG_OS_WATCHOS: return "watchos";
    case RZ_EGG_OS_IOS: return "ios";
    case RZ_EGG_OS_MACOS: return "macos";
    case RZ_EGG_OS_W32: return "win32";
    case RZ_EGG_OS_WINDOWS: return "windows";
    case RZ_EGG_OS_BEOS: return "beos";
    case RZ_EGG_OS_FREEBSD: return "freebsd";
    default: return "linux";
    }
}

References RZ_EGG_OS_BEOS, RZ_EGG_OS_DARWIN, RZ_EGG_OS_FREEBSD, RZ_EGG_OS_IOS, RZ_EGG_OS_LINUX, RZ_EGG_OS_MACOS, RZ_EGG_OS_OSX, RZ_EGG_OS_W32, RZ_EGG_OS_WATCHOS, and RZ_EGG_OS_WINDOWS.

Referenced by rz_egg_load_file().

rz_egg_padding()

RZ_API int rz_egg_padding	(	RzEgg *	egg,
		const char *	pad
	)

Definition at line 472 of file egg.c.

                                                       {
    int number;
    ut8 *buf, padding_byte;
    char *p, *o = strdup(pad);
 
    for (p = o; *p;) { // parse pad string
        const char f = *p++;
        number = strtol(p, NULL, 10);
 
        if (number < 1) {
            eprintf("Invalid padding length at %d\n", number);
            free(o);
            return false;
        }
        p = eon(p);
 
        switch (f) {
        case 's':
        case 'S': padding_byte = 0; break;
        case 'n':
        case 'N': padding_byte = 0x90; break;
        case 'a':
        case 'A': padding_byte = 'A'; break;
        case 't':
        case 'T': padding_byte = 0xcc; break;
        default:
            eprintf("Invalid padding format (%c)\n", *p);
            eprintf("Valid ones are:\n");
            eprintf("   s S : NULL byte");
            eprintf("   n N : nop");
            eprintf("   a A : 0x41");
            eprintf("   t T : trap (0xcc)");
            free(o);
            return false;
        }
 
        buf = malloc(number);
        if (!buf) {
            free(o);
            return false;
        }
 
        memset(buf, padding_byte, number);
        if (f >= 'a' && f <= 'z') {
            rz_egg_prepend_bytes(egg, buf, number);
        } else {
            rz_egg_append_bytes(egg, buf, number);
        }
        free(buf);
    }
    free(o);
    return true;
}

References eon(), eprintf, f, free(), malloc(), memset(), NULL, p, pad(), rz_egg_append_bytes(), rz_egg_prepend_bytes(), and strdup().

Referenced by egg_compile(), and rz_main_rz_gg().

rz_egg_patch()

RZ_API int rz_egg_patch	(	RzEgg *	egg,
		int	off,
		const ut8 *	buf,
		int	len
	)

Definition at line 576 of file egg.c.

                                                                      {
    struct egg_patch_t *ep = RZ_NEW(struct egg_patch_t);
    if (!ep) {
        return false;
    }
    ep->b = rz_buf_new_with_bytes(buf, len);
    if (!ep->b) {
        egg_patch_free(ep);
        return false;
    }
    ep->off = off;
    rz_list_append(egg->patches, ep);
    return true;
}

References egg_patch_t::b, egg_patch_free(), len, off, egg_patch_t::off, rz_egg_t::patches, rz_buf_new_with_bytes(), rz_list_append(), and RZ_NEW.

Referenced by rz_egg_patch_num(), and rz_main_rz_gg().

rz_egg_patch_num()

RZ_API bool rz_egg_patch_num	(	RzEgg *	egg,
		int	off,
		ut64	num,
		ut32	bits
	)

Definition at line 591 of file egg.c.

                                                                       {
    rz_return_val_if_fail(egg && bits <= 64, false);
    ut8 buf[8] = { 0 };
    rz_write_ble(buf, num, egg->endian, bits);
    return rz_egg_patch(egg, off, buf, bits / 8);
}

References bits(), rz_egg_t::endian, num, off, rz_egg_patch(), rz_return_val_if_fail, and rz_write_ble().

Referenced by rz_main_rz_gg().

rz_egg_pattern()

RZ_API void rz_egg_pattern	(	RzEgg *	egg,
		int	size
	)

Definition at line 625 of file egg.c.

                                                 {
    char *ret = rz_debruijn_pattern((int)size, 0, NULL);
    if (ret) {
        rz_egg_prepend_bytes(egg, (const ut8 *)ret, strlen(ret));
        free(ret);
    } else {
        eprintf("Invalid debruijn pattern length.\n");
    }
}

References eprintf, free(), NULL, rz_debruijn_pattern(), and rz_egg_prepend_bytes().

Referenced by rz_main_rz_gg().

rz_egg_prepend_bytes()

static int rz_egg_prepend_bytes ( RzEgg *  egg, const ut8 *  b, int  len  )

static

Definition at line 309 of file egg.c.

                                                                   {
    if (!rz_egg_raw_prepend(egg, b, len)) {
        return false;
    }
    if (!rz_buf_prepend_bytes(egg->bin, b, len)) {
        return false;
    }
    return true;
}

References b, rz_egg_t::bin, len, rz_buf_prepend_bytes(), and rz_egg_raw_prepend().

Referenced by rz_egg_padding(), and rz_egg_pattern().

rz_egg_printf()

RZ_API void rz_egg_printf	(	RzEgg *	egg,
		const char *	fmt,
			...
	)

Definition at line 336 of file egg.c.

                                                            {
    va_list ap;
    int len;
    char buf[1024];
    va_start(ap, fmt);
    len = vsnprintf(buf, sizeof(buf), fmt, ap);
    rz_buf_append_bytes(egg->buf, (const ut8 *)buf, len);
    va_end(ap);
}

References rz_egg_t::buf, len, rz_buf_append_bytes(), and vsnprintf.

Referenced by emit_arg(), emit_branch(), emit_call(), emit_comment(), emit_equ(), emit_frame(), emit_frame_end(), emit_get_result(), emit_get_while_end(), emit_init(), emit_jmp(), emit_load(), emit_load_ptr(), emit_mathop(), emit_restore_stack(), emit_set_string(), emit_string(), emit_syscall_args(), emit_trap(), emit_while_end(), parsedatachar(), rcc_fun(), rz_egg_label(), and rz_egg_lang_parsechar().

rz_egg_raw()

RZ_API int rz_egg_raw	(	RzEgg *	egg,
		const ut8 *	b,
		int	len
	)

Definition at line 281 of file egg.c.

                                                         {
    int outlen = len * 2; // two hexadecimal digits per byte
    char *out = malloc(outlen + 1);
    if (!out) {
        return false;
    }
    (void)rz_hex_bin2str(b, len, out);
    rz_buf_append_bytes(egg->buf, (const ut8 *)".hex ", 5);
    rz_buf_append_bytes(egg->buf, (const ut8 *)out, outlen);
    rz_buf_append_bytes(egg->buf, (const ut8 *)"\n", 1);
    free(out);
    return true;
}

References b, rz_egg_t::buf, free(), len, malloc(), out, rz_buf_append_bytes(), and rz_hex_bin2str().

Referenced by rz_egg_append_bytes(), rz_egg_include(), rz_egg_load_file(), rz_egg_shellcode(), and rz_main_rz_gg().

rz_egg_raw_prepend()

static int rz_egg_raw_prepend ( RzEgg *  egg, const ut8 *  b, int  len  )

static

Definition at line 295 of file egg.c.

                                                                 {
    int outlen = len * 2; // two hexadecimal digits per byte
    char *out = malloc(outlen + 1);
    if (!out) {
        return false;
    }
    rz_hex_bin2str(b, len, out);
    rz_buf_prepend_bytes(egg->buf, (const ut8 *)"\n", 1);
    rz_buf_prepend_bytes(egg->buf, (const ut8 *)out, outlen);
    rz_buf_prepend_bytes(egg->buf, (const ut8 *)".hex ", 5);
    free(out);
    return true;
}

References b, rz_egg_t::buf, free(), len, malloc(), out, rz_buf_prepend_bytes(), and rz_hex_bin2str().

Referenced by rz_egg_prepend_bytes().

rz_egg_reset()

RZ_API void rz_egg_reset

(

RzEgg *

egg

)

Definition at line 128 of file egg.c.

                                     {
    rz_egg_lang_include_init(egg);
    rz_buf_free(egg->src);
    rz_buf_free(egg->buf);
    rz_buf_free(egg->bin);
    egg->src = rz_buf_new_with_bytes(NULL, 0);
    egg->buf = rz_buf_new_with_bytes(NULL, 0);
    egg->bin = rz_buf_new_with_bytes(NULL, 0);
    rz_list_purge(egg->patches);
}

References rz_egg_t::bin, rz_egg_t::buf, NULL, rz_egg_t::patches, rz_buf_free(), rz_buf_new_with_bytes(), rz_egg_lang_include_init(), rz_list_purge(), and rz_egg_t::src.

Referenced by rz_cmd_debug(), rz_core_egg_compile(), rz_core_syscall(), and rz_egg_load_file().

rz_egg_run()

RZ_API int rz_egg_run

(

RzEgg *

egg

)

Definition at line 443 of file egg.c.

                                  {
    ut64 tmpsz;
    const ut8 *tmp = rz_buf_data(egg->bin, &tmpsz);
    bool res = rz_sys_run(tmp, tmpsz);
    return res;
}

References rz_egg_t::bin, rz_buf_data(), rz_sys_run(), autogen_x86imm::tmp, and ut64().

Referenced by rz_main_rz_gg().

rz_egg_run_rop()

RZ_API int rz_egg_run_rop

(

RzEgg *

egg

)

Definition at line 450 of file egg.c.

                                      {
    ut64 sz;
    const ut8 *tmp = rz_buf_data(egg->bin, &sz);
    return rz_sys_run_rop(tmp, sz);
}

References rz_egg_t::bin, rz_buf_data(), rz_sys_run_rop(), autogen_x86imm::tmp, and ut64().

Referenced by rz_main_rz_gg().

rz_egg_setup()

RZ_API bool rz_egg_setup	(	RzEgg *	egg,
		const char *	arch,
		int	bits,
		int	endian,
		const char *	os
	)

Definition at line 139 of file egg.c.

                                                                                             {
    const char *asmcpu = NULL; // TODO
    egg->remit = NULL;
 
    egg->os = os ? rz_str_djb2_hash(os) : RZ_EGG_OS_DEFAULT;
    if (!strcmp(arch, "x86")) {
        egg->arch = RZ_SYS_ARCH_X86;
        switch (bits) {
        case 32:
            rz_syscall_setup(egg->syscall, arch, bits, asmcpu, os);
            egg->remit = &emit_x86;
            egg->bits = bits;
            break;
        case 64:
            rz_syscall_setup(egg->syscall, arch, bits, asmcpu, os);
            egg->remit = &emit_x64;
            egg->bits = bits;
            break;
        }
    } else if (!strcmp(arch, "arm")) {
        egg->arch = RZ_SYS_ARCH_ARM;
        switch (bits) {
        case 16:
        case 32:
        case 64:
            rz_syscall_setup(egg->syscall, arch, bits, asmcpu, os);
            egg->remit = &emit_arm;
            egg->bits = bits;
            egg->endian = endian;
            break;
        }
    } else if (!strcmp(arch, "trace")) {
        // rz_syscall_setup (egg->syscall, arch, os, bits);
        egg->remit = &emit_trace;
        egg->bits = bits;
        egg->endian = endian;
    } else {
        return false;
    }
    return true;
}

References rz_egg_t::arch, arch, rz_egg_t::bits, bits(), emit_arm, emit_trace, emit_x64, emit_x86, rz_egg_t::endian, NULL, rz_egg_t::os, rz_egg_t::remit, RZ_EGG_OS_DEFAULT, rz_str_djb2_hash(), RZ_SYS_ARCH_ARM, RZ_SYS_ARCH_X86, rz_syscall_setup(), and rz_egg_t::syscall.

Referenced by cb_asmarch(), rz_cmd_debug(), rz_core_egg_setup(), rz_core_init(), rz_debug_new(), and rz_main_rz_gg().

rz_egg_shellcode()

RZ_API int rz_egg_shellcode	(	RzEgg *	egg,
		const char *	name
	)

Definition at line 538 of file egg.c.

                                                          {
    RzEggPlugin *p;
    RzListIter *iter;
    RzBuffer *b;
    rz_list_foreach (egg->plugins, iter, p) {
        if (p->type == RZ_EGG_PLUGIN_SHELLCODE && !strcmp(name, p->name)) {
            b = p->build(egg);
            if (!b) {
                eprintf("%s Shellcode has failed\n", p->name);
                return false;
            }
            ut64 tmpsz;
            const ut8 *tmp = rz_buf_data(b, &tmpsz);
            rz_egg_raw(egg, tmp, tmpsz);
            return true;
        }
    }
    return false;
}

References b, eprintf, p, rz_egg_t::plugins, rz_buf_data(), RZ_EGG_PLUGIN_SHELLCODE, rz_egg_raw(), autogen_x86imm::tmp, and ut64().

Referenced by rz_core_egg_compile(), and rz_main_rz_gg().

rz_egg_syscall()

RZ_API void rz_egg_syscall	(	RzEgg *	egg,
		const char *	arg,
			...
	)

Definition at line 255 of file egg.c.

                                                             {
    RzSyscallItem *item = rz_syscall_get(egg->syscall,
        rz_syscall_get_num(egg->syscall, arg), -1);
    if (!strcmp(arg, "close")) {
        // egg->remit->syscall_args ();
    }
    if (!item) {
        return;
    }
    egg->remit->syscall(egg, item->num);
    rz_syscall_item_free(item);
}

References rz_syscall_item_t::num, rz_egg_t::remit, rz_syscall_get(), rz_syscall_get_num(), rz_syscall_item_free(), rz_egg_t::syscall, and rz_egg_emit_t::syscall.

rz_egg_to_string()

RZ_API char* rz_egg_to_string

(

RzEgg *

egg

)

Definition at line 107 of file egg.c.

                                          {
    return rz_buf_to_string(egg->buf);
}

References rz_egg_t::buf, and rz_buf_to_string().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_egg

)

Variable Documentation

egg_static_plugins

RzEggPlugin* egg_static_plugins[] = { RZ_EGG_STATIC_PLUGINS }

static

Definition at line 15 of file egg.c.

Referenced by rz_egg_new().

emit_arm

RzEggEmit emit_arm

extern

Referenced by rz_egg_assemble_asm(), and rz_egg_setup().

emit_trace

RzEggEmit emit_trace

extern

Referenced by rz_egg_setup().

emit_x64

RzEggEmit emit_x64

extern

Referenced by rz_egg_assemble_asm(), and rz_egg_setup().

emit_x86

RzEggEmit emit_x86

extern

Referenced by rz_egg_assemble_asm(), rz_egg_new(), and rz_egg_setup().