static int cmd_hash(void *data, const char *input) {
char *p, algo[32];
RCore *core = (RCore *)data;
ut32 i, len = core->blocksize;
const char *ptr;
if (input[0]==' ') return 0;
if (input[0]=='#' && !input[1]) {
algolist (1);
return R_TRUE;
}
if (input[0]=='!') {
#if 0
TODO: Honor OOBI
#!lua < file
#!lua <<EOF
#!lua
#!lua foo bar
//r_lang_run (core->lang, p+1, strlen (p+1));
//core->oobi, core->oobi_len);
#endif
if (input[1]=='?' || input[1]=='*' || input[1]=='\0') {
r_lang_list (core->lang);
return R_TRUE;
}
p = strchr (input+1, ' ');
if (p) *p=0;
// TODO: set argv here
if (r_lang_use (core->lang, input+1)) {
r_lang_setup (core->lang);
if (p) r_lang_run_file (core->lang, p+1);
else r_lang_prompt (core->lang);
} else eprintf ("Invalid hashbang plugin name. Try '#!'\n");
return R_TRUE;
}
static int cmd_hash(void *data, const char *input) {
char algo[32];
RCore *core = (RCore *)data;
ut32 osize = 0, len = core->blocksize;
const char *ptr;
int pos = 0, handled_cmd = R_FALSE;
switch (*input) {
case '\t':
case ' ':
return 0;
case '#':
if (!input[1]) {
algolist (1);
return R_TRUE;
}
case '!':
return cmd_hash_bang (core, input);
}
ptr = strchr (input, ' ');
sscanf (input, "%31s", algo);
if (ptr && *(ptr+1) && r_num_is_valid_input (core->num, ptr+1)) {
int nlen = r_num_math (core->num, ptr+1);
if (nlen>0) len = nlen;
osize = core->blocksize;
if (nlen>core->blocksize) {
r_core_block_size (core, nlen);
if (nlen != core->blocksize) {
eprintf ("Invalid block size\n");
r_core_block_size (core, osize);
return R_TRUE;
}
}
} else if (!ptr || !*(ptr+1)) osize = len;
/* TODO: Simplify this spaguetti monster */
while (osize > 0 && HASH_HANDLERS[pos].name != NULL) {
if (!r_str_ccmp (input, HASH_HANDLERS[pos].name, ' ')) {
HASH_HANDLERS[pos].handler (core->block, len);
handled_cmd = R_TRUE;
break;
}
pos++;
}
if (!osize) {
eprintf ("Error: provided size must be size > 0\n");
}
if (*input == '?') {
const char *helpmsg[] = {
"Usage: #algo <size> @ addr", "", "",
" #"," comment","note the space after the sharp sign",
" ##","","List hash/checksum algorithms.",
" #sha256", " 10K @ 33","calculate sha256 of 10K at 33",
NULL
};
const char *helpmsg2[] = {
"Hashes:","","", NULL };
const char *helpmsg3[] = {
"Usage #!interpreter [<args>] [<file] [<<eof]","","",
" #!","","list all available interpreters",
" #!python","","run python commandline",
" #!python"," foo.py","run foo.py python script (same as '. foo.py')",
//" #!python <<EOF get python code until 'EOF' mark\n"
" #!python"," arg0 a1 <<q","set arg0 and arg1 and read until 'q'",
NULL};
r_core_cmd_help (core, helpmsg);
r_core_cmd_help (core, helpmsg2);
algolist (0);
r_core_cmd_help (core, helpmsg3);
}
if (osize)
r_core_block_size (core, osize);
return handled_cmd;
}
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;
}
int main(int argc, char **argv) {
const char *algo = "sha256"; /* default hashing algorithm */
int c, rad = 0, quit = 0, bsize = 0;
RIO *io;
while ((c = getopt (argc, argv, "rva:s:b:Bhf:t:kL")) != -1) {
switch (c) {
case 'L': algolist (); return 0;
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 '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), rad, 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_file_is_directory (argv[optind])) {
eprintf ("Cannot hash directories\n");
return 1;
}
// TODO: use mmap
if (!r_io_open (io, argv[optind], 0, 0)) {
eprintf ("Cannot open '%s'\n", argv[optind]);
return 1;
}
if (bsize<1) {
eprintf ("Invalid block size\n");
return 1;
}
return do_hash (algo, io, bsize, rad);
}
static int cmd_hash(void *data, const char *input) {
char *p, algo[32];
RCore *core = (RCore *)data;
ut32 i, osize, len = core->blocksize;
const char *ptr;
if (input[0]==' ') return 0;
if (input[0]=='#' && !input[1]) {
algolist (1);
return R_TRUE;
}
if (input[0]=='!') {
const char *lang = input+1;
if (*lang==' ') {
RLangPlugin *p = r_lang_get_by_extension (core->lang, input+2);
if (p && p->name) lang = p->name;
} else if (input[1]=='?' || input[1]=='*' || input[1]=='\0') {
r_lang_list (core->lang);
return R_TRUE;
}
p = strchr (input, ' ');
if (p) *p=0;
// TODO: set argv here
if (r_lang_use (core->lang, lang)) {
r_lang_setup (core->lang);
if (p) r_lang_run_file (core->lang, p+1);
else r_lang_prompt (core->lang);
} else eprintf ("Invalid hashbang. See '#!' for help.\n");
return R_TRUE;
}
ptr = strchr (input, ' ');
sscanf (input, "%31s", algo);
if (ptr != NULL) {
int nlen = r_num_math (core->num, ptr+1);
if (nlen>0) len = nlen;
osize = core->blocksize;
if (nlen>core->blocksize) {
r_core_block_size (core, nlen);
}
} else osize =0;
/* TODO: Simplify this spaguetti monster */
if (!r_str_ccmp (input, "md4", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_MD4);
const ut8 *c = r_hash_do_md4 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_MD4; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "adler32", ' ')) {
ut32 hn = r_hash_adler32 (core->block, len);
ut8 *b = (ut8*)&hn;
r_cons_printf ("%02x%02x%02x%02x\n", b[0], b[1], b[2], b[3]);
} else
if (!r_str_ccmp (input, "md5", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_MD5);
const ut8 *c = r_hash_do_md5 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_MD5; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "sha1", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA1);
const ut8 *c = r_hash_do_sha1 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_SHA1; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "sha256", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA256);
const ut8 *c = r_hash_do_sha256 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_SHA256; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "sha512", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA512);
const ut8 *c = r_hash_do_sha512 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_SHA512; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "entropy", ' ')) {
r_cons_printf ("%lf\n", r_hash_entropy (core->block, len));
} else
if (!r_str_ccmp (input, "hamdist", ' ')) {
r_cons_printf ("%d\n", r_hash_hamdist (core->block, len));
} else
if (!r_str_ccmp (input, "pcprint", ' ')) {
r_cons_printf ("%d\n", r_hash_pcprint (core->block, len));
} else
if (!r_str_ccmp (input, "crc32", ' ')) {
r_cons_printf ("%04x\n", r_hash_crc32 (core->block, len));
} else
if (!r_str_ccmp (input, "xor", ' ')) {
r_cons_printf ("%02x\n", r_hash_xor (core->block, len));
} else
if (!r_str_ccmp (input, "crc16", ' ')) {
r_cons_printf ("%02x\n", r_hash_crc16 (0, core->block, len));
} else
if (input[0]=='?') {
r_cons_printf (
"Usage: #algo <size> @ addr\n"
" # this is a comment note the space after the sharp sign\n"
" ## List hash/checksum algorithms.\n"
" #sha256 10K @ 33 calculate sha256 of 10K at 33\n"
"Hashes:\n");
algolist (0);
r_cons_printf (
"Usage #!interpreter [<args>] [<file] [<<eof]\n"
" #! list all available interpreters\n"
" #!python run python commandline\n"
" #!python foo.py run foo.py python script (same as '. foo.py')\n"
//" #!python <<EOF get python code until 'EOF' mark\n"
" #!python arg0 a1 <<q set arg0 and arg1 and read until 'q'\n");
}
if (osize)
r_core_block_size (core, osize);
return 0;
}
