bool test_va_malloc_zero(void) {
RIO *io;
ut64 buf;
bool ret;
io = r_io_new ();
io->va = false;
r_io_open_at (io, "malloc://8", R_PERM_RW, 0644, 0x0);
buf = 0xdeadbeefcafebabe;
ret = r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert ("should be able to read", ret);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x00\x00\x00\x00\x00\x00\x00\x00", 8, "0 should be there initially");
r_io_free (io);
io = r_io_new ();
io->va = true;
r_io_open_at (io, "malloc://8", R_PERM_RW, 0644, 0x0);
buf = 0xdeadbeefcafebabe;
ret = r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert ("should be able to read", ret);
mu_test_status = MU_TEST_BROKEN;
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x00\x00\x00\x00\x00\x00\x00\x00", 8, "0 should be there initially");
r_io_free (io);
mu_end;
}
int main () {
int ret;
RIODesc *fd;
char buf[1024];
struct r_io_t *io;
io = r_io_new();
r_io_plugin_list(io);
//fd = r_io_open(io, "/bin/ls", R_IO_READ, 0);
fd = r_io_open(io, "dbg:///bin/ls", R_IO_READ, 0);
r_io_set_fd(io, fd);
//r_io_map_add(io, fd, R_IO_READ, 0, 0xf00000, 0xffff);
r_io_map_add(io, fd->fd, R_IO_READ, 0x8048000, 0, 0xffff);
memset(buf, 0, 1024);
//ret = r_io_read_at(io, 0xf00000, buf, 1024);
// ret = r_io_seek(io, 0x8048000, R_IO_SEEK_SET);
// printf("seek = 0x%"PFMT64x"\n", ret);
ret = r_io_read_at (io, 0, (ut8*)buf, 64);
//ret = r_io_read_at(io, 0x8048000, buf, 64);
printf("%d = %02x %02x %02x %02x\n", ret, buf[0], buf[1], buf[2], buf[3]);
r_io_free(io);
return 0;
}
bool test_r_io_pcache (void) {
RIO *io = r_io_new ();
ut8 buf[8];
int fd = r_io_fd_open (io, "malloc://3", R_PERM_RW, 0);
r_io_map_add (io, fd, R_PERM_RW, 0LL, 0LL, 1); //8
r_io_map_add (io, fd, R_PERM_RW, 1, 1, 1); //=
r_io_map_add (io, fd, R_PERM_RW, 1, 2, 1); //=
r_io_map_add (io, fd, R_PERM_RW, 1, 3, 1); //=
r_io_map_add (io, fd, R_PERM_RW, 1, 4, 1); //=
r_io_map_add (io, fd, R_PERM_RW, 1, 5, 1); //=
r_io_map_add (io, fd, R_PERM_RW, 2, 6, 1); //D
io->p_cache = 2;
io->va = true;
r_io_fd_write_at (io, fd, 0, (const ut8*)"8=D", 3);
r_io_read_at (io, 0x0, buf, 8);
mu_assert_streq ((const char *)buf, "", "pcache read happened, but it shouldn't");
io->p_cache = 1;
r_io_read_at (io, 0x0, buf, 8);
mu_assert_streq ((const char *)buf, "8=====D", "expected an ascii-pn from pcache");
r_io_fd_write_at (io, fd, 0, (const ut8*)"XXX", 3);
r_io_read_at (io, 0x0, buf, 8);
mu_assert_streq ((const char *)buf, "8=====D", "expected an ascii-pn from pcache");
io->p_cache = 0;
r_io_read_at (io, 0x0, buf, 8);
mu_assert_streq ((const char *)buf, "XXXXXXX", "expected censorship of the ascii-pn");
r_io_free (io);
mu_end;
}
bool test_r_io_priority2(void) {
RIO *io = r_io_new();
ut32 map0;
ut8 buf[2];
bool ret;
io->va = true;
RIODesc *desc0 = r_io_open_at (io, "malloc://1024", R_PERM_RW, 0644, 0x0);
mu_assert_notnull (desc0, "first malloc should be opened");
map0 = r_io_map_get (io, 0)->id;
ret = r_io_read_at (io, 0, (ut8 *)&buf, 2);
mu_assert ("should be able to read", ret);
mu_assert_memeq (buf, (ut8 *)"\x00\x00", 2, "0 should be there initially");
r_io_write_at (io, 0, (const ut8 *)"\x90\x90", 2);
r_io_read_at (io, 0, buf, 2);
mu_assert_memeq (buf, (ut8 *)"\x90\x90", 2, "0x90 was written");
RIODesc *desc1 = r_io_open_at (io, "malloc://1024", R_PERM_R, 0644, 0x0);
mu_assert_notnull (desc1, "second malloc should be opened");
r_io_read_at (io, 0, buf, 2);
mu_assert_memeq (buf, (ut8 *)"\x00\x00", 2, "0x00 from map1 should be on top");
r_io_map_priorize (io, map0);
r_io_read_at (io, 0, buf, 2);
mu_assert_memeq (buf, (ut8 *)"\x90\x90", 2, "0x90 from map0 should be on top after prioritize");
r_io_free (io);
mu_end;
}
int main(int argc, char **argv) {
const char *algo = "md5,sha1"; /* default hashing algorithm */
int c, rad = 0, quit = 0, bsize = 0;
RIO *io;
while ((c = getopt (argc, argv, "rva:s:b:Bhf:t:")) != -1) {
switch (c) {
case 'r':
rad = 1;
break;
case 'a':
algo = optarg;
break;
case 'B':
incremental = 0;
break;
case 'b':
bsize = (int)r_num_math (NULL, optarg);
break;
case 's':
{
ut64 algobit = r_hash_name_to_bits (algo);
RHash *ctx = r_hash_new (R_TRUE, algobit);
from = 0;
to = strlen (optarg);
do_hash_internal (ctx, //0, strlen (optarg),
algobit, (const ut8*) optarg,
strlen (optarg), 0, 1);
r_hash_free (ctx);
quit = R_TRUE;
}
break;
case 'f':
from = r_num_math (NULL, optarg);
break;
case 't':
to = r_num_math (NULL, optarg);
break;
case 'v':
printf ("rahash2 v"R2_VERSION"\n");
return 0;
case 'h':
return do_help (0);
}
}
if (quit)
return 0;
if (optind>=argc)
return do_help (1);
io = r_io_new ();
if (!r_io_open (io, argv[optind], 0, 0)) {
eprintf ("Cannot open '%s'\n", argv[optind]);
return 1;
}
return do_hash (algo, io, bsize, rad);
}
bool test_r_io_desc_exchange (void) {
RIO *io = r_io_new ();
int fd = r_io_fd_open (io, "malloc://3", R_PERM_R, 0),
fdx = r_io_fd_open (io, "malloc://6", R_PERM_R, 0);
r_io_desc_exchange (io, fd, fdx);
mu_assert ("Desc-exchange is broken", (r_io_fd_size (io, fd) == 6));
r_io_free (io);
mu_end;
}
bool test_r_io_mapsplit (void) {
RIO *io = r_io_new ();
io->va = true;
r_io_open_at (io, "null://2", R_PERM_R, 0LL, UT64_MAX);
mu_assert ("Found no map at UT64", r_io_map_get (io, UT64_MAX));
mu_assert ("Found no map at 0x0", r_io_map_get (io, 0x0));
r_io_free (io);
mu_end;
}
emu *emu_new()
{
struct emu_t *e = R_NEW0(emu);
e->reg = r_reg_new();
e->io = r_io_new();
e->bin = r_bin_new();
e->lib = r_lib_new("ramulate_plugin");
e->plugins = r_list_new();
e->a = r_asm_new();
e->op = R_NEW0(RAsmOp);
e->anal = r_anal_new();
e->anop = r_anal_op_new();
e->next_vs_id = 0;
e->screen = NULL;
r_lib_add_handler(e->lib, RAMULATE_EMU_PLUGIN, "emulation plugin handler", &emu_plugin_cb, &emu_plugin_cb_end, e);
return e;
}
bool test_r_io_priority(void) {
RIO *io = r_io_new();
ut32 map0, map1;
ut64 buf;
bool ret;
io->va = true;
r_io_open_at (io, "malloc://8", R_PERM_RW, 0644, 0x0);
map0 = r_io_map_get (io, 0)->id;
ret = r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert ("should be able to read", ret);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x00\x00\x00\x00\x00\x00\x00\x00", 8, "0 should be there initially");
buf = 0x9090909090909090;
r_io_write_at (io, 0, (ut8 *)&buf, 8);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x90\x90\x90\x90\x90\x90\x90\x90", 8, "0x90 should have been written");
r_io_open_at (io, "malloc://2", R_PERM_RW, 0644, 0x4);
map1 = r_io_map_get (io, 4)->id;
r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x90\x90\x90\x90\x00\x00\x90\x90", 8, "0x00 from map1 should overlap");
buf ^= UT64_MAX;
r_io_write_at (io, 0, (ut8 *)&buf, 8);
r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x6f\x6f\x6f\x6f\xff\xff\x6f\x6f", 8, "memory has been xored");
r_io_map_priorize (io, map0);
r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x6f\x6f\x6f\x6f\x90\x90\x6f\x6f", 8, "map0 should have been prioritized");
r_io_map_remap (io, map1, 0x2);
r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x6f\x6f\x6f\x6f\x90\x90\x6f\x6f", 8, "map1 should have been remapped");
r_io_map_priorize (io, map1);
r_io_read_at (io, 0, (ut8 *)&buf, 8);
mu_assert_memeq ((ut8 *)&buf, (ut8 *)"\x6f\x6f\xff\xff\x90\x90\x6f\x6f", 8, "map1 should have been prioritized");
r_io_free (io);
mu_end;
}
int main(int argc, char **argv) {
int i, ret, c, rad = 0, bsize = 0, numblocks = 0, ule = 0, b64mode = 0;
const char *algo = "sha256"; /* default hashing algorithm */
const char *seed = NULL;
char *hashstr = NULL;
int hashstr_len = 0;
int hashstr_hex = 0;
ut64 algobit;
RHash *ctx;
RIO *io;
while ((c = getopt (argc, argv, "jdDrvea:i:S:s:x:b:nBhf:t:kLq")) != -1) {
switch (c) {
case 'q': quiet = 1; break;
case 'i': iterations = atoi (optarg);
if (iterations<0) {
eprintf ("error: -i argument must be positive\n");
return 1;
}
break;
case 'j': rad = 'j'; break;
case 'S': seed = optarg; break;
case 'n': numblocks = 1; break;
case 'd': b64mode = 1; break;
case 'D': b64mode = 2; break;
case 'L': algolist (); return 0;
case 'e': ule = 1; break;
case 'r': rad = 1; break;
case 'k': rad = 2; break;
case 'a': algo = optarg; break;
case 'B': incremental = 0; break;
case 'b': bsize = (int)r_num_math (NULL, optarg); break;
case 'f': from = r_num_math (NULL, optarg); break;
case 't': to = 1+r_num_math (NULL, optarg); break;
case 'v': return blob_version ("rahash2");
case 'h': return do_help (0);
case 's': setHashString (optarg, 0); break;
case 'x': setHashString (optarg, 1); break;
break;
default: eprintf ("rahash2: Unknown flag\n"); return 1;
}
}
if ((st64)from>=0 && (st64)to<0) {
to = 0; // end of file
}
if (from || to) {
if (to && from>=to) {
eprintf ("Invalid -f or -t offsets\n");
return 1;
}
}
do_hash_seed (seed);
if (hashstr) {
#define INSIZE 32768
if (!strcmp (hashstr, "-")) {
int res = 0;
hashstr = malloc (INSIZE);
if (!hashstr)
return 1;
res = fread ((void*)hashstr, 1, INSIZE-1, stdin);
if (res<1) res = 0;
hashstr[res] = '\0';
hashstr_len = res;
}
if (hashstr_hex) {
ut8 *out = malloc ((strlen (hashstr)+1)*2);
hashstr_len = r_hex_str2bin (hashstr, out);
if (hashstr_len<1) {
eprintf ("Invalid hex string\n");
free (out);
}
hashstr = (char *)out;
/* out memleaks here, hashstr can't be freed */
} else {
hashstr_len = strlen (hashstr);
}
if (from) {
if (from>=hashstr_len) {
eprintf ("Invalid -f.\n");
return 1;
}
}
if (to) {
if (to>hashstr_len) {
eprintf ("Invalid -t.\n");
return 1;
}
} else {
to = hashstr_len;
}
hashstr = hashstr+from;
hashstr_len = to-from;
hashstr[hashstr_len] = '\0';
hashstr_len = r_str_unescape (hashstr);
switch (b64mode) {
case 1: // encode
{
char *out = malloc (((hashstr_len+1)*4)/3);
if (out) {
r_base64_encode (out, (const ut8*)hashstr, hashstr_len);
printf ("%s\n", out);
fflush (stdout);
free (out);
}
}
break;
case 2: // decode
{
ut8 *out = malloc (INSIZE);
if (out) {
int outlen = r_base64_decode (out,
(const char *)hashstr, hashstr_len);
write (1, out, outlen);
free (out);
}
}
break;
default:
{
char *str = (char *)hashstr;
int strsz = hashstr_len;
if (_s) {
// alloc/concat/resize
str = malloc (strsz + s.len);
if (s.prefix) {
memcpy (str, s.buf, s.len);
memcpy (str+s.len, hashstr, hashstr_len);
} else {
memcpy (str, hashstr, hashstr_len);
memcpy (str+strsz, s.buf, s.len);
}
strsz += s.len;
str[strsz] = 0;
}
algobit = r_hash_name_to_bits (algo);
for (i=1; i<0x800000; i<<=1) {
if (algobit & i) {
int hashbit = i & algobit;
ctx = r_hash_new (R_TRUE, hashbit);
from = 0;
to = strsz;
do_hash_internal (ctx, hashbit,
(const ut8*)str, strsz, rad, 1, ule);
r_hash_free (ctx);
}
}
if (_s) {
free (str);
free (s.buf);
}
}
}
return 0;
}
if (optind>=argc)
return do_help (1);
if (numblocks) {
bsize = -bsize;
} else if (bsize<0) {
eprintf ("rahash2: Invalid block size\n");
return 1;
}
io = r_io_new ();
for (ret=0, i=optind; i<argc; i++) {
switch (b64mode) {
case 1: // encode
{
int binlen;
char *out;
ut8 *bin = (ut8*)r_file_slurp (argv[i], &binlen);
if (!bin) {
eprintf ("Cannot open file\n");
continue;
}
out = malloc (((binlen+1)*4)/3);
if (out) {
r_base64_encode (out, bin, binlen);
printf ("%s\n", out);
fflush (stdout);
free (out);
}
free (bin);
}
break;
case 2: // decode
{
int binlen, outlen;
ut8 *out, *bin = (ut8*)r_file_slurp (argv[i], &binlen);
if (!bin) {
eprintf ("Cannot open file\n");
continue;
}
out = malloc (binlen+1);
if (out) {
outlen = r_base64_decode (out, (const char*)bin, binlen);
write (1, out, outlen);
free (out);
}
free (bin);
}
break;
default:
if (r_file_is_directory (argv[i])) {
eprintf ("rahash2: Cannot hash directories\n");
return 1;
}
if (!r_io_open_nomap (io, argv[i], 0, 0)) {
eprintf ("rahash2: Cannot open '%s'\n", argv[i]);
return 1;
}
ret |= do_hash (argv[i], algo, io, bsize, rad, ule);
}
}
free (hashstr);
r_io_free (io);
return ret;
}
static int rafind_open_file(char *file) {
const char *kw;
RListIter *iter;
bool last = false;
int ret;
if (!quiet) {
printf ("File: %s\n", file);
}
if (identify) {
char *cmd = r_str_newf ("r2 -e search.show=false -e search.maxhits=1 -nqcpm '%s'", file);
r_sandbox_system (cmd, 1);
free (cmd);
return 0;
}
io = r_io_new ();
fd = r_io_open_nomap (io, file, R_PERM_R, 0);
if (!fd) {
eprintf ("Cannot open file '%s'\n", file);
return 1;
}
r_cons_new ();
rs = r_search_new (mode);
if (!rs) {
return 1;
}
buf = calloc (1, bsize);
if (!buf) {
eprintf ("Cannot allocate %"PFMT64d" bytes\n", bsize);
return 1;
}
rs->align = align;
r_search_set_callback (rs, &hit, buf);
if (to == -1) {
to = r_io_size(io);
}
if (mode == R_SEARCH_STRING) {
/* TODO: implement using api */
r_sys_cmdf ("rabin2 -qzzz '%s'", file);
return 0;
}
if (mode == R_SEARCH_MAGIC) {
char *tostr = (to && to != UT64_MAX)?
r_str_newf ("-e search.to=%"PFMT64d, to): strdup ("");
char *cmd = r_str_newf ("r2"
" -e search.in=range"
" -e search.align=%d"
" -e search.from=%"PFMT64d
" %s -qnc/m '%s'",
align, from, tostr, file);
r_sandbox_system (cmd, 1);
free (cmd);
free (tostr);
return 0;
}
if (mode == R_SEARCH_ESIL) {
char *cmd;
r_list_foreach (keywords, iter, kw) {
cmd = r_str_newf ("r2 -qc \"/E %s\" %s", kw, file);
r_sandbox_system (cmd, 1);
free (cmd);
}
