mirror of
https://github.com/radareorg/radare2.git
synced 2025-04-03 01:52:04 +00:00
Fix memleaks in av, lot of anal code cleanup and do not always allocate bb->diff
This commit is contained in:
pancake
parent
b68c345948
commit
fd0810fbf1
@ -8,8 +8,9 @@
|
||||
|
||||
R_LIB_VERSION(r_anal);
|
||||
|
||||
static RAnalPlugin *anal_static_plugins[] =
|
||||
{ R_ANAL_STATIC_PLUGINS };
|
||||
static RAnalPlugin *anal_static_plugins[] = {
|
||||
R_ANAL_STATIC_PLUGINS
|
||||
};
|
||||
|
||||
R_API void r_anal_set_limits(RAnal *anal, ut64 from, ut64 to) {
|
||||
free (anal->limit);
|
||||
@ -31,11 +32,9 @@ static void meta_unset_for(void *user, int idx) {
|
||||
}
|
||||
|
||||
static int meta_count_for(void *user, int idx) {
|
||||
int ret;
|
||||
RSpaces *s = (RSpaces*)user;
|
||||
RAnal *anal = (RAnal*)s->user;
|
||||
ret = r_meta_space_count_for (anal, idx);
|
||||
return ret;
|
||||
return r_meta_space_count_for (anal, idx);
|
||||
}
|
||||
|
||||
R_API RAnal *r_anal_new() {
|
||||
@ -163,9 +162,8 @@ R_API bool r_anal_use(RAnal *anal, const char *name) {
|
||||
}
|
||||
|
||||
R_API char *r_anal_get_reg_profile(RAnal *anal) {
|
||||
if (anal && anal->cur && anal->cur->get_reg_profile)
|
||||
return anal->cur->get_reg_profile (anal);
|
||||
return NULL;
|
||||
return (anal && anal->cur && anal->cur->get_reg_profile)
|
||||
? anal->cur->get_reg_profile (anal) : NULL;
|
||||
}
|
||||
|
||||
// deprecate.. or at least reuse get_reg_profile...
|
||||
@ -187,13 +185,7 @@ R_API bool r_anal_set_reg_profile(RAnal *anal) {
|
||||
R_API bool r_anal_set_fcnsign(RAnal *anal, const char *name) {
|
||||
#define FCNSIGNPATH R2_LIBDIR"/radare2/"R2_VERSION"/fcnsign"
|
||||
char *file = NULL;
|
||||
const char *arch;
|
||||
if (anal->cur && anal->cur->arch) {
|
||||
arch = anal->cur->arch;
|
||||
} else arch = R_SYS_ARCH;
|
||||
if (!arch) {
|
||||
return false;
|
||||
}
|
||||
const char *arch = (anal->cur && anal->cur->arch) ? anal->cur->arch : R_SYS_ARCH;
|
||||
if (name && *name) {
|
||||
file = sdb_fmt (0, "%s/%s.sdb", FCNSIGNPATH, name);
|
||||
} else {
|
||||
@ -272,17 +264,19 @@ R_API char *r_anal_strmask (RAnal *anal, const char *data) {
|
||||
}
|
||||
len = r_hex_str2bin (data, buf);
|
||||
while (idx < len) {
|
||||
if ((oplen = r_anal_op (anal, op, 0, buf+idx, len-idx)) <1)
|
||||
if ((oplen = r_anal_op (anal, op, 0, buf+idx, len-idx)) < 1) {
|
||||
break;
|
||||
}
|
||||
switch (op->type) {
|
||||
case R_ANAL_OP_TYPE_CALL:
|
||||
case R_ANAL_OP_TYPE_UCALL:
|
||||
case R_ANAL_OP_TYPE_CJMP:
|
||||
case R_ANAL_OP_TYPE_JMP:
|
||||
case R_ANAL_OP_TYPE_UJMP:
|
||||
if (op->nopcode != 0)
|
||||
memset (ret+(idx+op->nopcode)*2,
|
||||
'.', (oplen-op->nopcode)*2);
|
||||
if (op->nopcode != 0) {
|
||||
memset (ret + (idx + op->nopcode) * 2,
|
||||
'.', (oplen - op->nopcode) * 2);
|
||||
}
|
||||
}
|
||||
idx += oplen;
|
||||
}
|
||||
@ -295,18 +289,6 @@ R_API void r_anal_trace_bb(RAnal *anal, ut64 addr) {
|
||||
RAnalBlock *bbi;
|
||||
RAnalFunction *fcni;
|
||||
RListIter *iter2;
|
||||
#define OLD 0
|
||||
#if OLD
|
||||
RListIter *iter;
|
||||
r_list_foreach (anal->fcns, iter, fcni) {
|
||||
r_list_foreach (fcni->bbs, iter2, bbi) {
|
||||
if (addr>=bbi->addr && addr<(bbi->addr+bbi->size)) {
|
||||
bbi->traced = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
fcni = r_anal_get_fcn_in (anal, addr, 0);
|
||||
if (fcni) {
|
||||
r_list_foreach (fcni->bbs, iter2, bbi) {
|
||||
@ -316,7 +298,6 @@ R_API void r_anal_trace_bb(RAnal *anal, ut64 addr) {
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
R_API RList* r_anal_get_fcns (RAnal *anal) {
|
||||
@ -472,26 +453,29 @@ R_API bool r_anal_noreturn_at(RAnal *anal, ut64 addr) {
|
||||
RAnalFunction *f = r_anal_get_fcn_at (anal, addr, 0);
|
||||
RFlagItem *fi = anal->flb.get_at (anal->flb.f, addr);
|
||||
r_list_foreach (anal->noreturn, iter, nr) {
|
||||
if (addr == nr->addr) {
|
||||
return true;
|
||||
}
|
||||
if (nr->name) {
|
||||
RFlagItem *fi2 = anal->flb.get (anal->flb.f, nr->name);
|
||||
if (fi2 && fi2->offset == addr)
|
||||
if (fi2 && fi2->offset == addr) {
|
||||
return true;
|
||||
if (f && !strcmp (f->name, nr->name))
|
||||
}
|
||||
if (f && !strcmp (f->name, nr->name)) {
|
||||
return true;
|
||||
if (fi && fi->name && !strcmp (fi->name, nr->name))
|
||||
return true;
|
||||
} else {
|
||||
if (addr == nr->addr)
|
||||
}
|
||||
if (fi && fi->name && !strcmp (fi->name, nr->name)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static int cmp_range(const void *a, const void *b) {
|
||||
RAnalRange *range_a = (RAnalRange *)a;
|
||||
RAnalRange *range_b = (RAnalRange *)b;
|
||||
return range_a->from > range_b->from;
|
||||
RAnalRange *ra = (RAnalRange *)a;
|
||||
RAnalRange *rb = (RAnalRange *)b;
|
||||
return (a && b)? (ra->from > rb->from): 0;
|
||||
}
|
||||
|
||||
static int build_range(void *p, const char *k, const char *v) {
|
||||
@ -501,23 +485,21 @@ static int build_range(void *p, const char *k, const char *v) {
|
||||
hint = r_anal_hint_from_string (a, sdb_atoi (k + 5), v);
|
||||
if (hint->bits) {
|
||||
RAnalRange *range = R_NEW0 (RAnalRange);
|
||||
if (!range) {
|
||||
return 0;
|
||||
if (range) {
|
||||
range->bits = hint->bits;
|
||||
range->from = hint->addr;
|
||||
r_list_append (list_range, range);
|
||||
}
|
||||
range->bits = hint->bits;
|
||||
range->from = hint->addr;
|
||||
r_list_append (list_range, range);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
//based on anal hint we construct a list of RAnalRange to handle
|
||||
//better arm/thumb though maybe handy in other contexts
|
||||
// based on anal hint we construct a list of RAnalRange to handle
|
||||
// better arm/thumb though maybe handy in other contexts
|
||||
R_API void r_anal_build_range_on_hints(RAnal *a) {
|
||||
RListIter *iter;
|
||||
RAnalRange *range;
|
||||
//construct again the range from hint to handle properly arm/thumb
|
||||
// construct again the range from hint to handle properly arm/thumb
|
||||
r_list_free (a->bits_ranges);
|
||||
a->bits_ranges = r_list_new ();
|
||||
a->bits_ranges->free = free;
|
||||
|
||||
@ -16,7 +16,7 @@ R_API RAnalBlock *r_anal_bb_new() {
|
||||
bb->type = R_ANAL_BB_TYPE_NULL;
|
||||
bb->cond = NULL;
|
||||
bb->fingerprint = NULL;
|
||||
bb->diff = r_anal_diff_new ();
|
||||
bb->diff = NULL; //r_anal_diff_new ();
|
||||
bb->label = NULL;
|
||||
bb->op_pos = R_NEWS0 (ut16, DFLT_NINSTR);
|
||||
bb->op_pos_size = DFLT_NINSTR;
|
||||
@ -27,14 +27,11 @@ R_API void r_anal_bb_free(RAnalBlock *bb) {
|
||||
if (!bb) return;
|
||||
r_anal_cond_free (bb->cond);
|
||||
free (bb->fingerprint);
|
||||
if (bb->diff) {
|
||||
r_anal_diff_free (bb->diff);
|
||||
bb->diff = NULL;
|
||||
}
|
||||
r_anal_diff_free (bb->diff);
|
||||
bb->diff = NULL;
|
||||
free (bb->op_bytes);
|
||||
if (bb->switch_op) {
|
||||
r_anal_switch_op_free (bb->switch_op);
|
||||
}
|
||||
r_anal_switch_op_free (bb->switch_op);
|
||||
bb->switch_op = NULL;
|
||||
bb->fingerprint = NULL;
|
||||
bb->cond = NULL;
|
||||
free (bb->label);
|
||||
@ -139,10 +136,13 @@ R_API RAnalBlock *r_anal_bb_from_offset(RAnal *anal, ut64 off) {
|
||||
RListIter *iter, *iter2;
|
||||
RAnalFunction *fcn;
|
||||
RAnalBlock *bb;
|
||||
r_list_foreach (anal->fcns, iter, fcn)
|
||||
r_list_foreach (fcn->bbs, iter2, bb)
|
||||
if (r_anal_bb_is_in_offset (bb, off))
|
||||
r_list_foreach (anal->fcns, iter, fcn) {
|
||||
r_list_foreach (fcn->bbs, iter2, bb) {
|
||||
if (r_anal_bb_is_in_offset (bb, off)) {
|
||||
return bb;
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -154,17 +154,22 @@ R_API ut16 r_anal_bb_offset_inst(RAnalBlock *bb, int i) {
|
||||
}
|
||||
|
||||
/* set the offset of the i-th instruction in the basicblock bb */
|
||||
R_API void r_anal_bb_set_offset(RAnalBlock *bb, int i, ut16 v) {
|
||||
R_API bool r_anal_bb_set_offset(RAnalBlock *bb, int i, ut16 v) {
|
||||
// the offset 0 of the instruction 0 is not stored because always 0
|
||||
if (i > 0 && v > 0) {
|
||||
if (i >= bb->op_pos_size) {
|
||||
ut16 *tmp_op_pos = realloc (bb->op_pos, (i * 2) * sizeof (*bb->op_pos));
|
||||
if (!tmp_op_pos) return;
|
||||
bb->op_pos_size = i * 2;
|
||||
int new_pos_size = i * 2;
|
||||
ut16 *tmp_op_pos = realloc (bb->op_pos, new_pos_size * sizeof (*bb->op_pos));
|
||||
if (!tmp_op_pos) {
|
||||
return false;
|
||||
}
|
||||
bb->op_pos_size = new_pos_size;
|
||||
bb->op_pos = tmp_op_pos;
|
||||
}
|
||||
bb->op_pos[i - 1] = v;
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/* return the address of the instruction that occupy a given offset.
|
||||
@ -173,8 +178,9 @@ R_API ut64 r_anal_bb_opaddr_at(RAnalBlock *bb, ut64 off) {
|
||||
ut16 delta, delta_off, last_delta;
|
||||
int i;
|
||||
|
||||
if (!r_anal_bb_is_in_offset (bb, off)) return UT64_MAX;
|
||||
|
||||
if (!r_anal_bb_is_in_offset (bb, off)) {
|
||||
return UT64_MAX;
|
||||
}
|
||||
last_delta = 0;
|
||||
delta_off = off - bb->addr;
|
||||
for (i = 0; i < bb->ninstr; i++) {
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
/* radare - LGPL - Copyright 2010-2015 - nibble, pancake */
|
||||
/* radare - LGPL - Copyright 2010-2016 - nibble, pancake */
|
||||
|
||||
#include <r_anal.h>
|
||||
#include <r_util.h>
|
||||
#include <r_diff.h>
|
||||
|
||||
R_API RAnalDiff *r_anal_diff_new() {
|
||||
RAnalDiff *diff = R_NEW (RAnalDiff);
|
||||
RAnalDiff *diff = R_NEW0 (RAnalDiff);
|
||||
if (diff) {
|
||||
diff->type = R_ANAL_DIFF_TYPE_NULL;
|
||||
diff->addr = -1;
|
||||
@ -27,7 +27,9 @@ R_API void* r_anal_diff_free(RAnalDiff *diff) {
|
||||
|
||||
/* 0-1 */
|
||||
R_API void r_anal_diff_setup(RAnal *anal, int doops, double thbb, double thfcn) {
|
||||
if (doops>=0) anal->diff_ops = doops;
|
||||
if (doops >= 0) {
|
||||
anal->diff_ops = doops;
|
||||
}
|
||||
anal->diff_thbb = (thbb>=0)? thbb: R_ANAL_THRESHOLDBB;
|
||||
anal->diff_thfcn = (thfcn>=0)? thfcn: R_ANAL_THRESHOLDFCN;
|
||||
}
|
||||
@ -96,50 +98,64 @@ R_API int r_anal_diff_fingerprint_fcn(RAnal *anal, RAnalFunction *fcn) {
|
||||
return len;
|
||||
}
|
||||
|
||||
R_API int r_anal_diff_bb(RAnal *anal, RAnalFunction *fcn, RAnalFunction *fcn2) {
|
||||
R_API bool r_anal_diff_bb(RAnal *anal, RAnalFunction *fcn, RAnalFunction *fcn2) {
|
||||
RAnalBlock *bb, *bb2, *mbb, *mbb2;
|
||||
RListIter *iter, *iter2;
|
||||
double t, ot;
|
||||
|
||||
if (!anal) return false;
|
||||
if (anal->cur && anal->cur->diff_bb)
|
||||
if (!anal || !fcn || !fcn2) {
|
||||
return false;
|
||||
}
|
||||
if (anal->cur && anal->cur->diff_bb) {
|
||||
return (anal->cur->diff_bb (anal, fcn, fcn2));
|
||||
|
||||
}
|
||||
fcn->diff->type = fcn2->diff->type = R_ANAL_DIFF_TYPE_MATCH;
|
||||
r_list_foreach (fcn->bbs, iter, bb) {
|
||||
if (bb->diff && bb->diff->type != R_ANAL_DIFF_TYPE_NULL)
|
||||
if (bb->diff && bb->diff->type != R_ANAL_DIFF_TYPE_NULL) {
|
||||
continue;
|
||||
}
|
||||
ot = 0;
|
||||
mbb = mbb2 = NULL;
|
||||
r_list_foreach (fcn2->bbs, iter2, bb2) {
|
||||
if (bb2->diff && bb2->diff->type == R_ANAL_DIFF_TYPE_NULL) {
|
||||
r_diff_buffers_distance (NULL, bb->fingerprint, bb->size,
|
||||
bb2->fingerprint, bb2->size, NULL, &t);
|
||||
#if 0
|
||||
eprintf ("BB: %llx - %llx => %lli - %lli => %f\n", bb->addr, bb2->addr,
|
||||
bb->size, bb->size, t);
|
||||
#endif
|
||||
if (t > anal->diff_thbb && t > ot) {
|
||||
ot = t;
|
||||
mbb = bb;
|
||||
mbb2 = bb2;
|
||||
if (t == 1) break;
|
||||
if (t == 1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (mbb != NULL && mbb2 != NULL) {
|
||||
if (ot == 1 || t > anal->diff_thfcn )
|
||||
if (mbb && mbb2) {
|
||||
if (!mbb->diff) {
|
||||
mbb->diff = r_anal_diff_new();
|
||||
}
|
||||
if (!mbb2->diff) {
|
||||
mbb2->diff = r_anal_diff_new();
|
||||
}
|
||||
if (!mbb->diff || !mbb2->diff) {
|
||||
return false;
|
||||
}
|
||||
if (ot == 1 || t > anal->diff_thfcn) {
|
||||
mbb->diff->type = mbb2->diff->type = R_ANAL_DIFF_TYPE_MATCH;
|
||||
else mbb->diff->type = mbb2->diff->type = \
|
||||
fcn->diff->type = fcn2->diff->type = R_ANAL_DIFF_TYPE_UNMATCH;
|
||||
} else {
|
||||
mbb->diff->type = mbb2->diff->type = \
|
||||
fcn->diff->type = fcn2->diff->type = \
|
||||
R_ANAL_DIFF_TYPE_UNMATCH;
|
||||
}
|
||||
R_FREE (mbb->fingerprint);
|
||||
R_FREE (mbb2->fingerprint);
|
||||
mbb->diff->addr = mbb2->addr;
|
||||
mbb2->diff->addr = mbb->addr;
|
||||
mbb->diff->size = mbb2->size;
|
||||
mbb2->diff->size = mbb->size;
|
||||
} else
|
||||
} else {
|
||||
fcn->diff->type = fcn2->diff->type = R_ANAL_DIFF_TYPE_UNMATCH;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@ -166,17 +182,16 @@ R_API int r_anal_diff_fcn(RAnal *anal, RList *fcns, RList *fcns2) {
|
||||
}
|
||||
r_list_foreach (fcns2, iter2, fcn2) {
|
||||
if (fcn2->type != R_ANAL_FCN_TYPE_SYM ||
|
||||
fcn2->name == NULL ||
|
||||
strcmp (fcn->name, fcn2->name)) {
|
||||
!fcn2->name || strcmp (fcn->name, fcn2->name)) {
|
||||
continue;
|
||||
}
|
||||
r_diff_buffers_distance (NULL, fcn->fingerprint, r_anal_fcn_size (fcn),
|
||||
fcn2->fingerprint, r_anal_fcn_size (fcn2),
|
||||
NULL, &t);
|
||||
fcn2->fingerprint, r_anal_fcn_size (fcn2),
|
||||
NULL, &t);
|
||||
/* Set flag in matched functions */
|
||||
fcn->diff->type = fcn2->diff->type = (t == 1)
|
||||
? R_ANAL_DIFF_TYPE_MATCH
|
||||
: R_ANAL_DIFF_TYPE_UNMATCH;
|
||||
? R_ANAL_DIFF_TYPE_MATCH
|
||||
: R_ANAL_DIFF_TYPE_UNMATCH;
|
||||
fcn->diff->dist = fcn2->diff->dist = t;
|
||||
R_FREE (fcn->fingerprint);
|
||||
R_FREE (fcn2->fingerprint);
|
||||
|
||||
@ -34,7 +34,9 @@
|
||||
|
||||
#define VERBOSE_DELAY if(0)
|
||||
|
||||
#if USE_SDB_CACHE
|
||||
static Sdb *HB = NULL;
|
||||
#endif
|
||||
|
||||
R_API const char *r_anal_fcn_type_tostring(int type) {
|
||||
switch (type) {
|
||||
@ -1294,11 +1296,16 @@ R_API int r_anal_fcn_add_bb(RAnal *anal, RAnalFunction *fcn, ut64 addr, ut64 siz
|
||||
bb->fail = fail;
|
||||
bb->type = type;
|
||||
if (diff) {
|
||||
bb->diff->type = diff->type;
|
||||
bb->diff->addr = diff->addr;
|
||||
R_FREE (bb->diff->name);
|
||||
if (diff->name) {
|
||||
bb->diff->name = strdup (diff->name);
|
||||
if (!bb->diff) {
|
||||
bb->diff = r_anal_diff_new ();
|
||||
}
|
||||
if (bb->diff) {
|
||||
bb->diff->type = diff->type;
|
||||
bb->diff->addr = diff->addr;
|
||||
if (diff->name) {
|
||||
R_FREE (bb->diff->name);
|
||||
bb->diff->name = strdup (diff->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
_________________UpdateBB (fcn, bb);
|
||||
|
||||
@ -2164,7 +2164,7 @@ static void anop(RAnal *a, RAnalOp *op, ut64 addr, const ut8 *buf, int len, csh
|
||||
static int cs_len_prefix_opcode(uint8_t *item) {
|
||||
int i, len = 0;
|
||||
for (i = 0; i < 4; i++) {
|
||||
len = len + (item[i] != 0) ? 1 : 0;
|
||||
len += (item[i] != 0) ? 1 : 0;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
@ -1,21 +1,23 @@
|
||||
#include <r_anal.h>
|
||||
/* radare - LGPL - Copyright 2014-2016 - pancake, dso */
|
||||
|
||||
#include <r_anal.h>
|
||||
|
||||
RAnalSwitchOp *switch_op_new() {
|
||||
RAnalSwitchOp * swop = R_NEW0 (RAnalSwitchOp);
|
||||
if (!swop) return NULL;
|
||||
swop->cases = r_list_new ();
|
||||
if (!swop->cases) {
|
||||
free (swop);
|
||||
return NULL;
|
||||
if (swop) {
|
||||
swop->cases = r_list_new ();
|
||||
if (!swop->cases) {
|
||||
free (swop);
|
||||
return NULL;
|
||||
}
|
||||
swop->cases->free = (void *)free;
|
||||
swop->min_val = swop->def_val = swop->max_val = 0;
|
||||
}
|
||||
swop->cases->free = (void *)free;
|
||||
swop->min_val = swop->def_val = swop->max_val = 0;
|
||||
return swop;
|
||||
}
|
||||
|
||||
R_API RAnalSwitchOp * r_anal_switch_op_new(ut64 addr, ut64 min_val, ut64 def_val) {
|
||||
RAnalSwitchOp *swop = switch_op_new();
|
||||
RAnalSwitchOp *swop = switch_op_new ();
|
||||
if (swop) {
|
||||
swop->addr = addr;
|
||||
swop->min_val = min_val;
|
||||
@ -26,15 +28,18 @@ R_API RAnalSwitchOp * r_anal_switch_op_new(ut64 addr, ut64 min_val, ut64 def_val
|
||||
}
|
||||
|
||||
R_API void r_anal_switch_op_free(RAnalSwitchOp * swop) {
|
||||
if (!swop || (((ut32)(size_t)swop)==UT32_MAX)) return;
|
||||
if (swop->cases)
|
||||
r_list_free(swop->cases);
|
||||
free(swop);
|
||||
if (!swop || (((ut32)(size_t)swop)==UT32_MAX)) {
|
||||
return;
|
||||
}
|
||||
r_list_free (swop->cases);
|
||||
free (swop);
|
||||
}
|
||||
|
||||
R_API RAnalCaseOp* r_anal_switch_op_add_case(RAnalSwitchOp * swop, ut64 addr, ut64 value, ut64 jump) {
|
||||
RAnalCaseOp * caseop = R_NEW0(RAnalCaseOp);
|
||||
if (!caseop) return NULL;
|
||||
RAnalCaseOp * caseop = R_NEW0 (RAnalCaseOp);
|
||||
if (!caseop) {
|
||||
return NULL;
|
||||
}
|
||||
caseop->addr = addr;
|
||||
caseop->value = value;
|
||||
caseop->jump = jump;
|
||||
|
||||
140
libr/core/anal.c
140
libr/core/anal.c
@ -37,14 +37,15 @@ static RCore *mycore = NULL;
|
||||
#define MINLEN 1
|
||||
static int is_string (const ut8 *buf, int size, int *len) {
|
||||
int i;
|
||||
if (size<1)
|
||||
if (size < 1) {
|
||||
return 0;
|
||||
if (size>3 && buf[0] && !buf[1] && buf[2] && !buf[3]) {
|
||||
}
|
||||
if (size > 3 && buf[0] && !buf[1] && buf[2] && !buf[3]) {
|
||||
*len = 1; // XXX: TODO: Measure wide string length
|
||||
return 2; // is wide
|
||||
}
|
||||
for (i=0; i<size; i++) {
|
||||
if (!buf[i] && i>MINLEN) {
|
||||
for (i = 0; i < size; i++) {
|
||||
if (!buf[i] && i > MINLEN) {
|
||||
*len = i;
|
||||
return 1;
|
||||
}
|
||||
@ -70,8 +71,7 @@ static int is_string (const ut8 *buf, int size, int *len) {
|
||||
// - addr is in different section than core->offset
|
||||
static bool iscodesection(RCore *core, ut64 addr) {
|
||||
RIOSection *s = r_io_section_vget (core->io, addr);
|
||||
if (!s) return false;
|
||||
if (strstr (s->name, "text")) {
|
||||
if (s && s->name && strstr (s->name, "text")) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@ -1002,8 +1002,9 @@ static int core_anal_graph_nodes(RCore *core, RAnalFunction *fcn, int opts) {
|
||||
free (str);
|
||||
}
|
||||
}
|
||||
if (is_json)
|
||||
if (is_json) {
|
||||
r_cons_printf ("]}");
|
||||
}
|
||||
free (pal_jump);
|
||||
free (pal_fail);
|
||||
free (pal_trfa);
|
||||
@ -1050,14 +1051,13 @@ R_API int r_core_anal_bb(RCore *core, RAnalFunction *fcn, ut64 at, int head) {
|
||||
goto error;
|
||||
}
|
||||
do {
|
||||
// check io error
|
||||
#if SLOW_IO
|
||||
if (r_io_read_at (core->io, at + bblen, buf, 4) != 4) { // ETOOSLOW
|
||||
goto error;
|
||||
}
|
||||
r_core_read_at (core, at+bblen, buf, core->anal->opt.bb_max_size);
|
||||
r_core_read_at (core, at + bblen, buf, core->anal->opt.bb_max_size);
|
||||
#else
|
||||
if (r_io_read_at (core->io, at + bblen, buf, core->anal->opt.bb_max_size) != 4) { // ETOOSLOW
|
||||
if (r_io_read_at (core->io, at + bblen, buf, core->anal->opt.bb_max_size) != core->anal->opt.bb_max_size) { // ETOOSLOW
|
||||
goto error;
|
||||
}
|
||||
#endif
|
||||
@ -1066,10 +1066,10 @@ R_API int r_core_anal_bb(RCore *core, RAnalFunction *fcn, ut64 at, int head) {
|
||||
}
|
||||
buflen = core->anal->opt.bb_max_size;
|
||||
bblen = r_anal_bb (core->anal, bb, at+bblen, buf, buflen, head);
|
||||
if (bblen == R_ANAL_RET_ERROR ||
|
||||
(bblen == R_ANAL_RET_END && bb->size < 1)) { /* Error analyzing bb */
|
||||
if (bblen == R_ANAL_RET_ERROR || (bblen == R_ANAL_RET_END && bb->size < 1)) { /* Error analyzing bb */
|
||||
goto error;
|
||||
} else if (bblen == R_ANAL_RET_END) { /* bb analysis complete */
|
||||
}
|
||||
if (bblen == R_ANAL_RET_END) { /* bb analysis complete */
|
||||
if (core->anal->split) {
|
||||
ret = r_anal_fcn_bb_overlaps (fcn, bb);
|
||||
}
|
||||
@ -3138,28 +3138,33 @@ R_API void r_core_anal_esil(RCore *core, const char *str, const char *target) {
|
||||
#define VTABLE_BUFF_SIZE 10
|
||||
|
||||
typedef struct vtable_info_t {
|
||||
ut64 saddr;//starting address
|
||||
ut64 saddr; //starting address
|
||||
int methods;
|
||||
} vtable_info;
|
||||
|
||||
static const char *textSectionName = ".text";
|
||||
static const char *roSectionName =".rodata";
|
||||
|
||||
static void printVtable(RCore *core, vtable_info *table) {
|
||||
if (table && core) {
|
||||
int curMethod = 0;
|
||||
int totalMethods = table->methods;
|
||||
ut64 startAddress = table->saddr;
|
||||
const char *methodName = "No Name found";
|
||||
ut64 bits = r_config_get_i (core->config, "asm.bits");
|
||||
char *methodName;
|
||||
const char *noMethodName = "No Name found";
|
||||
int bits = r_config_get_i (core->config, "asm.bits");
|
||||
const char *lang = r_config_get (core->config, "bin.lang");
|
||||
r_cons_printf ("\nVtable Found at : 0x%08"PFMT64x"\n", startAddress);
|
||||
r_cons_printf ("\nVtable Found at 0x%08"PFMT64x"\n", startAddress);
|
||||
int wordSize = bits / 8;
|
||||
while (curMethod < totalMethods) {
|
||||
ut64 curAddressValue = r_io_read_i (core->io, startAddress, 8);
|
||||
RBinSymbol* curSymbol = r_bin_get_symbol_at_vaddr (core->bin, curAddressValue);
|
||||
if (curSymbol) methodName = r_bin_demangle (core->bin->cur, lang, curSymbol->name);
|
||||
r_cons_printf ("0x%-08"PFMT64x" : %s\n", startAddress, methodName);
|
||||
if (curSymbol) {
|
||||
methodName = r_bin_demangle (core->bin->cur, lang, curSymbol->name);
|
||||
} else {
|
||||
methodName = noMethodName;
|
||||
}
|
||||
r_cons_printf ("0x%08"PFMT64x" : %s\n", startAddress, methodName);
|
||||
if (methodName != noMethodName) {
|
||||
free (methodName);
|
||||
}
|
||||
startAddress += wordSize;
|
||||
curMethod++;
|
||||
}
|
||||
@ -3173,29 +3178,30 @@ static int inTextSection(RCore *core, ut64 curAddress) {
|
||||
//section of the curAddress
|
||||
RBinSection* value = r_bin_get_section_at (core->bin->cur->o, curAddressValue, true);
|
||||
//If the pointed value lies in .text section
|
||||
return value && (!strcmp (value->name, textSectionName));
|
||||
return value && (!strcmp (value->name, ".text");
|
||||
}
|
||||
|
||||
static int isVtableStart(RCore *core, ut64 curAddress) {
|
||||
if (curAddress == UT64_MAX || curAddress == 0) {
|
||||
return false;
|
||||
}
|
||||
RAsmOp asmop = {0};
|
||||
RAnalRef *xref;
|
||||
RListIter *xrefIter;
|
||||
ut8 buf[VTABLE_BUFF_SIZE];
|
||||
if (!curAddress || curAddress == UT64_MAX) {
|
||||
return false;
|
||||
}
|
||||
if (inTextSection (core, curAddress)) {
|
||||
//total xref's to curAddress
|
||||
// total xref's to curAddress
|
||||
RList *xrefs = r_anal_xrefs_get (core->anal, curAddress);
|
||||
if (!r_list_empty (xrefs)) {
|
||||
r_list_foreach (xrefs, xrefIter, xref) {
|
||||
//section in which currenct xref lies
|
||||
RBinSection* xrefsection = r_bin_get_section_at(core->bin->cur->o, xref->addr, true);
|
||||
if (!strcmp (xrefsection->name, textSectionName)) {
|
||||
// section in which currenct xref lies
|
||||
if (inTextSection (core, xref->addr)) {
|
||||
r_io_read_at (core->io, xref->addr, buf, VTABLE_BUFF_SIZE);
|
||||
RAsmCode *disassembly = r_asm_mdisassemble (core->assembler, buf, VTABLE_BUFF_SIZE);
|
||||
if ((!strncmp (disassembly->buf_asm, "mov", 3)) ||
|
||||
(!strncmp (disassembly->buf_asm, "lea", 3))) {
|
||||
return true;
|
||||
if (r_asm_disassemble (core->assembler, &asmop, buf, VTABLE_BUFF_SIZE) > 0) {
|
||||
if ((!strncmp (asmop.buf_asm, "mov", 3)) ||
|
||||
(!strncmp (asmop.buf_asm, "lea", 3))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -3212,51 +3218,47 @@ RList* search_virtual_tables(RCore *core){
|
||||
ut64 endAddress;
|
||||
RListIter * iter;
|
||||
RIOSection *section;
|
||||
RList *vtables = r_list_new();//List of vtables
|
||||
RList *vtables = r_list_new();
|
||||
ut64 bits = r_config_get_i (core->config, "asm.bits");
|
||||
int wordSize = bits/8;
|
||||
if (vtables) {
|
||||
if (core->io->sections) {
|
||||
r_list_foreach (core->io->sections, iter, section){
|
||||
if (!strcmp(section->name, roSectionName) ) {//checking for .rodata
|
||||
ut8 *segBuff = calloc (1, section->size);
|
||||
r_io_read_at( core->io, section->offset, segBuff, section->size);
|
||||
startAddress = section->vaddr;
|
||||
endAddress = startAddress + (section->size) - (bits/8);
|
||||
while (startAddress <= endAddress) {
|
||||
if (isVtableStart(core, startAddress)) {
|
||||
vtable_info *vtable = calloc (1, sizeof(vtable_info));
|
||||
vtable->saddr = startAddress;
|
||||
int noOfMethods = 0;
|
||||
while (inTextSection(core, startAddress)) {
|
||||
noOfMethods++;
|
||||
startAddress += wordSize;
|
||||
}
|
||||
vtable->methods = noOfMethods;
|
||||
r_list_append (vtables, vtable);
|
||||
continue;
|
||||
}
|
||||
startAddress += 1;
|
||||
int wordSize = bits / 8;
|
||||
if (!vtables) {
|
||||
return NULL;
|
||||
}
|
||||
r_list_foreach (core->io->sections, iter, section) {
|
||||
if (!strcmp (section->name, ".rodata")) {
|
||||
ut8 *segBuff = calloc (1, section->size);
|
||||
r_io_read_at( core->io, section->offset, segBuff, section->size);
|
||||
startAddress = section->vaddr;
|
||||
endAddress = startAddress + (section->size) - (bits/8);
|
||||
while (startAddress <= endAddress) {
|
||||
if (isVtableStart (core, startAddress)) {
|
||||
vtable_info *vtable = calloc (1, sizeof(vtable_info));
|
||||
vtable->saddr = startAddress;
|
||||
int noOfMethods = 0;
|
||||
while (inTextSection (core, startAddress)) {
|
||||
noOfMethods++;
|
||||
startAddress += wordSize;
|
||||
}
|
||||
vtable->methods = noOfMethods;
|
||||
r_list_append (vtables, vtable);
|
||||
continue;
|
||||
}
|
||||
startAddress += 1;
|
||||
}
|
||||
} else {
|
||||
//stripped binary
|
||||
eprintf ("No virtual tables Found\n");
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
//no space allocated for vtables
|
||||
eprintf ("Initialization Error\n");
|
||||
}
|
||||
if (r_list_empty (vtables)) {
|
||||
// stripped binary?
|
||||
eprintf ("No virtual tables found\n");
|
||||
r_list_free (vtables);
|
||||
return NULL;
|
||||
}
|
||||
return vtables;
|
||||
}
|
||||
|
||||
R_API void r_core_anal_list_vtables(void *core) {
|
||||
const char *curArch =((RCore *)core)->bin->cur->o->info->arch;
|
||||
const char *curSupportedArch = "x86";
|
||||
if (!strcmp (curArch, curSupportedArch)) {
|
||||
const char *curArch = ((RCore *)core)->bin->cur->o->info->arch;
|
||||
if (!strcmp (curArch, "x86")) {
|
||||
RList* vtables = search_virtual_tables ((RCore *)core);
|
||||
RListIter* vtableIter;
|
||||
vtable_info* table;
|
||||
@ -3265,5 +3267,7 @@ R_API void r_core_anal_list_vtables(void *core) {
|
||||
printVtable ((RCore *)core, table);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
eprintf ("Unsupported architecture to find vtables\n");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1160,7 +1160,7 @@ R_API int r_anal_bb(RAnal *anal, RAnalBlock *bb,
|
||||
ut64 addr, ut8 *buf, ut64 len, int head);
|
||||
R_API RAnalBlock *r_anal_bb_from_offset(RAnal *anal, ut64 off);
|
||||
R_API int r_anal_bb_is_in_offset(RAnalBlock *bb, ut64 addr);
|
||||
R_API void r_anal_bb_set_offset(RAnalBlock *bb, int i, ut16 v);
|
||||
R_API bool r_anal_bb_set_offset(RAnalBlock *bb, int i, ut16 v);
|
||||
R_API ut16 r_anal_bb_offset_inst(RAnalBlock *bb, int i);
|
||||
R_API ut64 r_anal_bb_opaddr_at(RAnalBlock *bb, ut64 addr);
|
||||
|
||||
@ -1348,7 +1348,7 @@ R_API void r_anal_diff_setup_i(RAnal *anal, int doops, int thbb, int thfcn);
|
||||
R_API void* r_anal_diff_free(RAnalDiff *diff);
|
||||
R_API int r_anal_diff_fingerprint_bb(RAnal *anal, RAnalBlock *bb);
|
||||
R_API int r_anal_diff_fingerprint_fcn(RAnal *anal, RAnalFunction *fcn);
|
||||
R_API int r_anal_diff_bb(RAnal *anal, RAnalFunction *fcn, RAnalFunction *fcn2);
|
||||
R_API bool r_anal_diff_bb(RAnal *anal, RAnalFunction *fcn, RAnalFunction *fcn2);
|
||||
R_API int r_anal_diff_fcn(RAnal *anal, RList *fcns, RList *fcns2);
|
||||
R_API int r_anal_diff_eval(RAnal *anal);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user