static void do_hash_print(RHash *ctx, int hash, int dlen, int rad) {
char *o;
const ut8 *c = ctx->digest;
const char *hname = r_hash_name (hash);
int i;
switch (rad) {
case 0:
printf ("0x%08"PFMT64x"-0x%08"PFMT64x" %s: ", from, to, hname);
for (i=0; i<dlen; i++)
printf ("%02x", c[i]);
printf ("\n");
break;
case 1:
printf ("e file.%s=", hname);
for (i=0; i<dlen; i++)
printf ("%02x", c[i]);
printf ("\n");
break;
default:
o = r_print_randomart (c, dlen, from);
printf ("%s\n%s\n", hname, o);
free (o);
break;
}
}
static void do_hash_print(RHash *ctx, int hash, int dlen, int rad, int ule) {
char *o;
const ut8 *c = ctx->digest;
const char *hname = r_hash_name (hash);
switch (rad) {
case 0:
if (!quiet)
printf ("0x%08"PFMT64x"-0x%08"PFMT64x" %s: ",
from, to-1, hname);
do_hash_hexprint (c, dlen, ule, rad);
break;
case 1:
printf ("e file.%s=", hname);
do_hash_hexprint (c, dlen, ule, rad);
break;
case 'j':
printf ("{\"name\":\"%s\",\"hash\":\"", hname);
do_hash_hexprint (c, dlen, ule, rad);
printf ("\"}");
break;
default:
o = r_print_randomart (c, dlen, from);
printf ("%s\n%s\n", hname, o);
free (o);
break;
}
}
static void algolist() {
ut64 bits;
int i;
for (i=0; ; i++) {
bits = ((ut64)1)<<i;
const char *name = r_hash_name (bits);
if (!name||!*name) break;
printf ("%s\n", name);
}
}
static void do_hash_print(RHash *ctx, int hash, int dlen, int rad) {
const ut8 *c = ctx->digest;
const char *hname = r_hash_name (hash);
int i;
if (rad) {
printf ("e file.%s=", hname);
for (i=0; i<dlen; i++)
printf ("%02x", c[i]);
printf ("\n");
} else {
printf ("0x%08"PFMT64x"-0x%08"PFMT64x" %s: ", from, to, hname);
for (i=0; i<dlen; i++)
printf ("%02x", c[i]);
printf ("\n");
}
}
static void algolist(int mode) {
const char *name;
ut64 bits;
int i;
for (i=0; ; i++) {
bits = 1<<i;
name = r_hash_name (bits);
if (!name||!*name) break;
if (mode) {
r_cons_printf ("%s\n", name);
} else {
r_cons_printf (" #%s", name);
if (!((i+1)%10)) r_cons_newline ();
}
}
if (!mode) r_cons_printf ("\n");
}
static void cmd_write_op (RCore *core, const char *input) {
ut8 *buf;
int len;
int value;
if (!input[0])
return;
switch (input[1]) {
case 'e':
if (input[2]!=' ') {
r_cons_printf ("Usage: 'woe from-to step'\n");
return;
}
/* fallthru */
case 'a':
case 's':
case 'A':
case 'x':
case 'r':
case 'l':
case 'm':
case 'd':
case 'o':
case 'w':
case '2':
case '4':
if (input[2]) { // parse val from arg
r_core_write_op (core, input+3, input[1]);
r_core_block_read (core);
} else { // use clipboard instead of val
r_core_write_op (core, NULL, input[1]);
r_core_block_read (core);
}
break;
case 'R':
r_core_cmd0 (core, "wr $b");
break;
case 'n':
r_core_write_op (core, "ff", 'x');
r_core_block_read (core);
break;
case 'E': // "woE" encrypt
case 'D': // "woD" decrypt
{
int direction = (input[1] == 'E') ? 0 : 1;
const char *algo = NULL;
const char *key = NULL;
const char *iv = NULL;
char *space, *args = strdup (r_str_trim_ro (input+2));
space = strchr (args, ' ');
if (space) {
*space++ = 0;
key = space;
space = strchr (key, ' ');
if (space) {
*space++ = 0;
iv = space;
}
}
algo = args;
if (algo && *algo && key) {
encrypt_or_decrypt_block (core, algo, key, direction, iv);
} else {
eprintf ("Usage: wo%c [algo] [key] [IV]\n", ((!direction)?'E':'D'));
eprintf ("Currently supported hashes:\n");
ut64 bits;
int i;
for (i = 0; ; i++) {
bits = ((ut64)1) << i;
const char *name = r_hash_name (bits);
if (!name || !*name) break;
printf (" %s\n", name);
}
eprintf ("Available Encoders/Decoders: \n");
// TODO: do not hardcode
eprintf (" base64\n");
eprintf (" base91\n");
eprintf (" punycode\n");
eprintf ("Currently supported crypto algos:\n");
for (i = 0; ; i++) {
bits = ((ut64)1) << i;
const char *name = r_crypto_name (bits);
if (!name || !*name) break;
printf (" %s\n", name);
}
}
free (args);
}
break;
case 'p': // debrujin patterns
switch (input[2]) {
case 'D': // "wopD"
len = (int)(input[3]==' ')
? r_num_math (core->num, input + 3)
: core->blocksize;
if (len > 0) {
/* XXX This seems to fail at generating long patterns (wopD 512K) */
buf = (ut8*)r_debruijn_pattern (len, 0, NULL); //debruijn_charset);
if (buf) {
const ut8 *ptr = buf;
ut64 addr = core->offset;
if (input[3] == '*') {
int i;
r_cons_printf ("wx ");
for (i = 0; i < len; i++) {
r_cons_printf ("%02x", buf[i]);
}
r_cons_newline ();
} else {
while (true) {
int res = r_core_write_at (core, addr, ptr, len);
if (res < 1 || len == res) {
break;
}
if (res < len) {
ptr += res;
len -= res;
addr += res;
}
}
}
free (buf);
} else {
eprintf ("Couldn't generate pattern of length %d\n", len);
}
}
break;
case 'O': // "wopO"
if (strlen (input) > 4 && strncmp (input + 4, "0x", 2)) {
eprintf ("Need hex value with `0x' prefix e.g. 0x41414142\n");
} else if (input[3] == ' ') {
value = r_num_get (core->num, input + 4);
core->num->value = r_debruijn_offset (value, r_config_get_i (core->config, "cfg.bigendian"));
r_cons_printf ("%"PFMT64d"\n", core->num->value);
}
break;
case '\0':
case '?':
default:
r_core_cmd_help (core, help_msg_wop);
break;
}
break;
case '\0':
case '?':
default:
r_core_cmd_help (core, help_msg_wo);
break;
}
}
static int do_hash(const char *file, const char *algo, RIO *io, int bsize, int rad, int ule) {
ut64 j, fsize, algobit = r_hash_name_to_bits (algo);
RHash *ctx;
ut8 *buf;
int i, first = 1;
if (algobit == R_HASH_NONE) {
eprintf ("rahash2: Invalid hashing algorithm specified\n");
return 1;
}
fsize = r_io_size (io);
if (fsize <1) {
eprintf ("rahash2: Invalid file size\n");
return 1;
}
if (bsize<0) bsize = fsize / -bsize;
if (bsize == 0 || bsize > fsize) bsize = fsize;
if (to == 0LL) to = fsize;
if (from>to) {
eprintf ("rahash2: Invalid -f -t range\n");
return 1;
}
if (fsize == -1LL) {
eprintf ("rahash2: Unknown file size\n");
return 1;
}
buf = malloc (bsize+1);
if (!buf)
return 1;
ctx = r_hash_new (R_TRUE, algobit);
if (rad == 'j')
printf ("[");
if (incremental) {
for (i=1; i<0x800000; i<<=1) {
if (algobit & i) {
int hashbit = i & algobit;
int dlen = r_hash_size (hashbit);
r_hash_do_begin (ctx, i);
if (rad == 'j') {
if (first) {
first = 0;
} else {
printf (",");
}
}
if (s.buf && s.prefix) {
do_hash_internal (ctx,
hashbit, s.buf, s.len, rad, 0, ule);
}
for (j=from; j<to; j+=bsize) {
int len = ((j+bsize)>to)? (to-j): bsize;
r_io_pread (io, j, buf, len);
do_hash_internal (ctx, hashbit, buf,
len, rad, 0, ule);
}
if (s.buf && !s.prefix) {
do_hash_internal (ctx, hashbit, s.buf,
s.len, rad, 0, ule);
}
r_hash_do_end (ctx, i);
if (iterations>0)
r_hash_do_spice (ctx, i, iterations, _s);
if (!*r_hash_name (i))
continue;
if (!quiet && rad != 'j')
printf ("%s: ", file);
do_hash_print (ctx, i, dlen, rad, ule);
}
}
if (_s)
free (_s->buf);
} else {
/* iterate over all algorithm bits */
if (s.buf)
eprintf ("Warning: Seed ignored on per-block hashing.\n");
for (i=1; i<0x800000; i<<=1) {
ut64 f, t, ofrom, oto;
if (algobit & i) {
int hashbit = i & algobit;
ofrom = from;
oto = to;
f = from;
t = to;
for (j=f; j<t; j+=bsize) {
int nsize = (j+bsize<fsize)? bsize: (fsize-j);
r_io_pread (io, j, buf, bsize);
from = j;
to = j+bsize;
if (to>fsize)
to = fsize;
do_hash_internal (ctx, hashbit, buf, nsize, rad, 1, ule);
}
from = ofrom;
to = oto;
}
}
}
if (rad == 'j')
printf ("]\n");
r_hash_free (ctx);
free (buf);
return 0;
}
static void cmd_write_op (RCore *core, const char *input) {
ut8 *buf;
int len;
const char* help_msg[] = {
"Usage:","wo[asmdxoArl24]"," [hexpairs] @ addr[!bsize]",
"wo[aAdlmorwx24]","", "without hexpair values, clipboard is used",
"woa"," [val]", "+= addition (f.ex: woa 0102)",
"woA"," [val]","&= and",
"wod"," [val]", "/= divide",
"woD","[algo] [key] [IV]","decrypt current block with given algo and key",
"woe"," [from to] [step] [wsz=1]",".. create sequence",
"woE"," [algo] [key] [IV]", "encrypt current block with given algo and key",
"wol"," [val]","<<= shift left",
"wom"," [val]", "*= multiply",
"woo"," [val]","|= or",
"wop[DO]"," [arg]","De Bruijn Patterns",
"wor"," [val]", ">>= shift right",
"woR","","random bytes (alias for 'wr $b')",
"wos"," [val]", "-= substraction",
"wow"," [val]", "== write looped value (alias for 'wb')",
"wox"," [val]","^= xor (f.ex: wox 0x90)",
"wo2"," [val]","2= 2 byte endian swap",
"wo4"," [val]", "4= 4 byte endian swap",
NULL
};
if (!input[0])
return;
switch (input[1]) {
case 'e':
if (input[2]!=' ') {
r_cons_printf ("Usage: 'woe from-to step'\n");
return;
}
/* fallthru */
case 'a':
case 's':
case 'A':
case 'x':
case 'r':
case 'l':
case 'm':
case 'd':
case 'o':
case 'w':
case '2':
case '4':
if (input[2]) { // parse val from arg
r_core_write_op (core, input+3, input[1]);
r_core_block_read (core);
} else { // use clipboard instead of val
r_core_write_op (core, NULL, input[1]);
r_core_block_read (core);
}
break;
case 'R':
r_core_cmd0 (core, "wr $b");
break;
case 'n':
r_core_write_op (core, "ff", 'x');
r_core_block_read (core);
break;
case 'E': // encrypt
case 'D': // decrypt
{
int direction = (input[1] == 'E') ? 0 : 1;
const char *algo = NULL;
const char *key = NULL;
const char *iv = NULL;
char *space, *args = strdup (r_str_chop_ro (input+2));
space = strchr (args, ' ');
if (space) {
*space++ = 0;
key = space;
space = strchr (key, ' ');
if (space) {
*space++ = 0;
iv = space;
}
}
algo = args;
if (algo && *algo) {
encrypt_or_decrypt_block (core, algo, key, direction, iv);
} else {
eprintf ("Usage: wo%c [algo] [key] [IV]\n", ((!direction)?'E':'D'));
eprintf ("Currently supported hashes:\n");
ut64 bits;
int i;
for (i = 0; ; i++) {
bits = ((ut64)1) << i;
const char *name = r_hash_name (bits);
if (!name || !*name) break;
printf (" %s\n", name);
}
eprintf ("Available Encoders/Decoders: \n");
// TODO: do not hardcode
eprintf (" base64\n");
eprintf (" base91\n");
eprintf (" punycode\n");
eprintf ("Currently supported crypto algos:\n");
for (i = 0; ; i++) {
bits = ((ut64)1) << i;
const char *name = r_crypto_name (bits);
if (!name || !*name) break;
printf (" %s\n", name);
}
}
free (args);
}
break;
case 'p': // debrujin patterns
switch (input[2]) {
case 'D': // "wopD"
len = (int)(input[3]==' ')
? r_num_math (core->num, input + 3)
: core->blocksize;
if (len > 0) {
/* XXX This seems to fail at generating long patterns (wopD 512K) */
buf = (ut8*)r_debruijn_pattern (len, 0, NULL); //debruijn_charset);
if (buf) {
const ut8 *ptr = buf;
ut64 addr = core->offset;
while (true) {
int res = r_core_write_at (core, addr, ptr, len);
if (res < 1 || len == res) {
break;
}
if (res < len) {
ptr += res;
len -= res;
addr += res;
}
}
free (buf);
} else {
eprintf ("Couldn't generate pattern of length %d\n", len);
}
}
break;
case 'O': // "wopO"
len = (int)(input[3]==' ')
? r_num_math (core->num, input + 3)
: core->blocksize;
core->num->value = r_debruijn_offset (len, r_config_get_i (core->config, "cfg.bigendian"));
r_cons_printf ("%"PFMT64d"\n", core->num->value);
break;
case '\0':
case '?':
default:
{
const char* wop_help_msg[] = {
"Usage:","wop[DO]"," len @ addr | value",
"wopD"," len [@ addr]","Write a De Bruijn Pattern of length 'len' at address 'addr'",
"wopO"," value", "Finds the given value into a De Bruijn Pattern at current offset",
NULL
};
r_core_cmd_help (core, wop_help_msg);
break;
}
}
break;
case '\0':
case '?':
default:
r_core_cmd_help (core, help_msg);
break;
}
}
