R_API char *r_hash_to_string(RHash *ctx, const char *name, const ut8 *data, int len) {
char *digest_hex = NULL;
int i, digest_size;
ut64 algo = r_hash_name_to_bits (name);
if (!ctx)
ctx = r_hash_new (R_TRUE, algo);
r_hash_do_begin (ctx, algo);
r_hash_calculate (ctx, algo, data, len);
r_hash_do_end (ctx, algo);
digest_size = r_hash_size (algo);
digest_hex = malloc ((digest_size *2)+1);
for (i = 0; i< digest_size; i++)
sprintf (digest_hex+(i*2), "%02x", ctx->digest[i]);
digest_hex[digest_size*2] = 0;
r_hash_free (ctx);
return digest_hex;
}
R_API void r_hash_do_spice(RHash *ctx, int algo, int loops, RHashSeed *seed) {
ut8 buf[1024];
int i, len, hlen = r_hash_size (algo);
for (i = 0; i< loops; i++) {
if (seed) {
if (seed->prefix) {
memcpy (buf, seed->buf, seed->len);
memcpy (buf+seed->len, ctx->digest, hlen);
} else {
memcpy (buf, ctx->digest, hlen);
memcpy (buf+hlen, seed->buf, seed->len);
}
len = hlen + seed->len;
} else {
memcpy (buf, ctx->digest, hlen);
len = hlen;
}
(void)r_hash_calculate (ctx, algo, buf, len);
}
}
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 int do_hash(const char *algo, RIO *io, int bsize, int rad) {
ut8 *buf;
RHash *ctx;
ut64 j, fsize;
int i;
ut64 algobit = r_hash_name_to_bits (algo);
if (algobit == R_HASH_NONE) {
eprintf ("Invalid hashing algorithm specified\n");
return 1;
}
fsize = r_io_size (io);
if (bsize == 0 || bsize > fsize)
bsize = fsize;
if (to == 0LL)
to = fsize;
if (from>to) {
eprintf ("Invalid -f -t range\n");
return 1;
}
if (fsize == -1LL) {
eprintf ("Unknown file size\n");
return 1;
}
buf = malloc (bsize+1);
ctx = r_hash_new (R_TRUE, algobit);
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);
for (j=from; j<to; j+=bsize) {
r_io_read_at (io, j, buf, bsize);
do_hash_internal (ctx,
hashbit, buf, ((j+bsize)<fsize)?
bsize: (fsize-j), rad, 0);
}
r_hash_do_end (ctx, i);
do_hash_print (ctx, i, dlen, rad);
}
}
} else {
/* iterate over all algorithm bits */
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_read_at (io, j, buf, bsize);
from = j;
to = j+bsize;
do_hash_internal (ctx, hashbit, buf, nsize, rad, 1);
}
from = ofrom;
to = oto;
}
}
}
r_hash_free (ctx);
free (buf);
return 0;
}
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;
const char *compareStr = NULL;
ut8 *compareBin = NULL;
int hashstr_len = -1;
int hashstr_hex = 0;
ut64 algobit;
RHash *ctx;
RIO *io;
while ((c = getopt (argc, argv, "jdDrvea:i:S:s:x:b:nBhf:t:kLqc:")) != -1) {
switch (c) {
case 'q': quiet = 1; break;
case 'i':
if (!optarg) return 1;
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;
case 'c': compareStr = optarg; break;
default: eprintf ("rahash2: Unknown flag\n"); return 1;
}
}
if (compareStr) {
int compareBin_len;
if (bsize && !incremental) {
eprintf ("rahash2: Option -c incompatible with -b and -B options.\n");
return 1;
}
if (b64mode) {
eprintf ("rahash2: Option -c incompatible with -d or -D options.\n");
return 1;
}
algobit = r_hash_name_to_bits(algo);
// if algobit represents a single algorithm then it's a power of 2
if (!is_power_of_two (algobit)) {
eprintf ("rahash2: Option -c incompatible with multiple algorithms in -a.\n");
return 1;
}
compareBin = malloc ((strlen (compareStr) + 1) * 2);
if (!compareBin)
return 1;
compareBin_len = r_hex_str2bin (compareStr, compareBin);
if (compareBin_len < 1) {
eprintf ("rahash2: Invalid -c hex hash\n");
free (compareBin);
return 1;
}
else if (compareBin_len != r_hash_size (algobit)) {
eprintf (
"rahash2: Given -c hash has %d bytes but the selected algorithm returns %d bytes.\n",
compareBin_len,
r_hash_size(algobit));
free (compareBin);
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
ret = 0;
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);
return 1;
}
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);
compare_hashes (ctx, compareBin,
r_hash_size (algobit), &ret);
r_hash_free (ctx);
}
}
if (_s) {
free (str);
free (s.buf);
}
}
}
return ret;
}
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 (!strcmp (argv[i], "-")) {
int sz = 0;
ut8 *buf = (ut8*)r_stdin_slurp (&sz);
char *uri = r_str_newf ("malloc://%d", sz);
if (sz>0) {
if (!r_io_open_nomap (io, uri, 0, 0)) {
eprintf ("rahash2: Cannot open malloc://1024\n");
return 1;
}
r_io_pwrite (io, 0, buf, sz);
}
free (uri);
} else {
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, compareBin);
}
}
free (hashstr);
r_io_free (io);
return ret;
}
rsize
r_hmac_size (const RHmac * hmac)
{
return r_hash_size (hmac->inner);
}
