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; }