R_API char *r_hash_to_string(RHash *ctx, const char *name, const ut8 *data, int len) {
ut64 algo = r_hash_name_to_bits (name);
char *digest_hex = NULL;
RHash *myctx = NULL;
int i, digest_size;
if (!algo || !data) {
return NULL;
}
if (!ctx) {
myctx = ctx = r_hash_new (true, algo);
}
r_hash_do_begin (ctx, algo);
digest_size = r_hash_calculate (ctx, algo, data, len);
r_hash_do_end (ctx, algo);
if (digest_size > 0) {
if (digest_size * 2 < digest_size) {
digest_hex = NULL;
} else {
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;
}
}
if (myctx) {
r_hash_free (myctx);
}
return digest_hex;
}
static int do_hash_internal(RHash *ctx, int hash, const ut8 *buf, int len, int rad, int print) {
int dlen = r_hash_calculate (ctx, hash, buf, len);
if (!dlen) return 0;
if (!print) return 1;
if (hash == R_HASH_ENTROPY) {
double e = r_hash_entropy (buf, len);
if (rad) {
eprintf ("entropy: %10f\n", e);
} else {
printf ("0x%08"PFMT64x"-0x%08"PFMT64x" %10f: ",
from, to, e);
r_print_progressbar (NULL, 12.5 * e, 60);
printf ("\n");
}
} else do_hash_print (ctx, hash, dlen, rad);
return 1;
}
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 bin_info(RCore *r, int mode) {
int i, j;
char str[R_FLAG_NAME_SIZE];
char size_str[32];
char baddr_str[32];
RBinInfo *info = r_bin_get_info (r->bin);
RBinFile *binfile = r_core_bin_cur (r);
const char *compiled = NULL;
if (!binfile || !info) {
if (mode & R_CORE_BIN_JSON) r_cons_printf ("{}");
return false;
}
compiled = get_compile_time (binfile->sdb);
snprintf (size_str, sizeof (size_str),
"%"PFMT64d, r_bin_get_size (r->bin));
snprintf (baddr_str, sizeof (baddr_str),
"%"PFMT64d, info->baddr);
if (IS_MODE_SET (mode)) {
r_config_set (r->config, "file.type", info->rclass);
r_config_set (r->config, "cfg.bigendian", info->big_endian ? "true" : "false");
if (info->rclass && !strcmp (info->rclass, "fs")) {
r_config_set (r->config, "asm.arch", info->arch);
r_core_cmdf (r, "m /root %s 0", info->arch);
} else {
if (info->lang) {
r_config_set (r->config, "bin.lang", info->lang);
}
r_config_set (r->config, "asm.os", info->os);
r_config_set (r->config, "asm.arch", info->arch);
r_config_set (r->config, "anal.arch", info->arch);
snprintf (str, R_FLAG_NAME_SIZE, "%i", info->bits);
r_config_set (r->config, "asm.bits", str);
r_config_set (r->config, "asm.dwarf",
(R_BIN_DBG_STRIPPED &info->dbg_info) ? "false" : "true");
}
} else if (IS_MODE_SIMPLE (mode)) {
r_cons_printf ("arch %s\n", info->arch);
r_cons_printf ("bits %d\n", info->bits);
r_cons_printf ("os %s\n", info->os);
r_cons_printf ("endian %s\n", info->big_endian? "big": "little");
} else if (IS_MODE_RAD (mode)) {
if (info->type && !strcmp (info->type, "fs")) {
r_cons_printf ("e file.type=fs\n");
r_cons_printf ("m /root %s 0\n", info->arch);
} else {
r_cons_printf ("e cfg.bigendian=%s\n"
"e asm.bits=%i\n"
"e asm.dwarf=%s\n",
r_str_bool (info->big_endian),
info->bits,
r_str_bool (R_BIN_DBG_STRIPPED &info->dbg_info));
if (info->lang && *info->lang) {
r_cons_printf ("e bin.lang=%s\n", info->lang);
}
if (info->rclass && *info->rclass) {
r_cons_printf ("e file.type=%s\n",
info->rclass);
}
if (info->os) {
r_cons_printf ("e asm.os=%s\n", info->os);
}
if (info->arch) {
r_cons_printf ("e asm.arch=%s\n", info->arch);
}
}
} else {
// XXX: if type is 'fs' show something different?
if (IS_MODE_JSON (mode)) r_cons_printf ("{");
pair_bool ("pic", info->has_pi, mode, false);
pair_bool ("canary", info->has_canary, mode, false);
pair_bool ("nx", info->has_nx, mode, false);
pair_bool ("crypto", info->has_crypto, mode, false);
pair_bool ("va", info->has_va, mode, false);
pair_str ("bintype", info->rclass, mode, false);
pair_str ("class", info->bclass, mode, false);
pair_str ("lang", info->lang, mode, false);
pair_str ("arch", info->arch, mode, false);
pair_int ("bits", info->bits, mode, false);
pair_str ("machine", info->machine, mode, false);
pair_str ("os", info->os, mode, false);
pair_str ("subsys", info->subsystem, mode, false);
pair_str ("endian", info->big_endian ? "big" : "little", mode, false);
pair_bool ("stripped", R_BIN_DBG_STRIPPED & info->dbg_info, mode, false);
pair_bool ("static", r_bin_is_static (r->bin), mode, false);
pair_bool ("linenum", R_BIN_DBG_LINENUMS & info->dbg_info, mode, false);
pair_bool ("lsyms", R_BIN_DBG_SYMS & info->dbg_info, mode, false);
pair_bool ("relocs", R_BIN_DBG_RELOCS & info->dbg_info, mode, false);
pair_str ("rpath", info->rpath, mode, false);
pair_str ("binsz", size_str, mode, false);
pair_str ("compiled", compiled, mode, false);
pair_str ("guid", info->guid, mode, false);
pair_str ("dbg_file", info->debug_file_name, mode, true);
for (i = 0; info->sum[i].type; i++) {
int len;
RBinHash *h = &info->sum[i];
ut64 hash = r_hash_name_to_bits (h->type);
RHash *rh = r_hash_new (true, hash);
len = r_hash_calculate (rh, hash, (const ut8*)
binfile->buf->buf+h->from, h->to);
if (len < 1) eprintf ("Invaild wtf\n");
r_hash_free (rh);
r_cons_printf ("%s\t%d-%dc\t", h->type, h->from, h->to+h->from);
for (j = 0; j < h->len; j++) {
r_cons_printf ("%02x", h->buf[j]);
}
r_cons_newline ();
}
if (IS_MODE_JSON (mode)) r_cons_printf ("}");
}
return true;
}