Magic-Mirror/radare2
1
0
Fork 0
mirror of https://github.com/radareorg/radare2.git synced 2025-02-25 16:51:30 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Add anal.ex option, cleanup and improve the Java support ##anal

Browse Source 
* Current java implementation of the analysis is not working well
* RBin.Java doesnt updates the vsizes because it seems to break things. wip for another PR
* Added anal.ex option to use extensions or not
This commit is contained in:
radare 2019-05-08 18:26:11 +02:00 committed by GitHub
parent 981902b660
commit bf5e302881
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 346 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
libr/anal/anal_ex.c
View File

@ -28,11 +28,8 @@ static void r_anal_ex_perform_post_anal_bb_cb(RAnal *anal, RAnalState *state, ut
static void r_anal_ex_perform_revisit_bb_cb(RAnal *anal, RAnalState *state, ut64 addr);
ut64 extract_code_op(ut64 ranal2_op_type);
ut64 extract_load_store_op(ut64 ranal2_op_type);
ut64 extract_unknown_op(ut64 ranal2_op_type);
ut64 extract_bin_op(ut64 ranal2_op_type);
static void r_anal_ex_perform_pre_anal(RAnal *anal, RAnalState *state, ut64 addr) {
if (anal && anal->cur && anal->cur->pre_anal) {
@ -59,13 +56,13 @@ static void r_anal_ex_perform_pre_anal_bb_cb(RAnal *anal, RAnalState *state, ut6
}*/
static void r_anal_ex_perform_post_anal_op_cb(RAnal *anal, RAnalState *state, ut64 addr) {
if (anal && anal->cur && anal->cur->post_anal_op_cb) {
if (anal && anal->use_ex && anal->cur && anal->cur->post_anal_op_cb) {
anal->cur->post_anal_op_cb (anal, state, addr);
}
}
static void r_anal_ex_perform_post_anal_bb_cb(RAnal *anal, RAnalState *state, ut64 addr) {
if (anal && anal->cur && anal->cur->post_anal_bb_cb) {
if (anal && anal->use_ex && anal->cur && anal->cur->post_anal_bb_cb) {
anal->cur->post_anal_bb_cb (anal, state, addr);
}
}
@ -83,7 +80,7 @@ static void r_anal_ex_perform_post_anal(RAnal *anal, RAnalState *state, ut64 add
}
static void r_anal_ex_perform_revisit_bb_cb(RAnal *anal, RAnalState *state, ut64 addr) {
if (anal && anal->cur && anal->cur->revisit_bb_anal) {
if (anal && anal->use_ex && anal->cur && anal->cur->revisit_bb_anal) {
anal->cur->revisit_bb_anal (anal, state, addr);
}
}
@ -388,22 +385,21 @@ R_API int r_anal_ex_is_op_type_eop(ut64 x) {
(x & R_ANAL_EX_CODEOP_SWITCH) == R_ANAL_EX_CODEOP_SWITCH);
}
ut64 extract_code_op(ut64 ranal2_op_type) {
static ut64 extract_code_op(ut64 ranal2_op_type) {
ut64 conditional = R_ANAL_EX_COND_OP & ranal2_op_type ? R_ANAL_OP_TYPE_COND : 0;
ut64 code_op_val = ranal2_op_type & (R_ANAL_EX_CODE_OP | 0x1FF);
switch (code_op_val) {
case R_ANAL_EX_CODEOP_CALL : return conditional | R_ANAL_OP_TYPE_CALL;
case R_ANAL_EX_CODEOP_JMP : return conditional | R_ANAL_OP_TYPE_JMP;
case R_ANAL_EX_CODEOP_RET : return conditional | R_ANAL_OP_TYPE_RET;
case R_ANAL_EX_CODEOP_LEAVE: return R_ANAL_OP_TYPE_LEAVE;
case R_ANAL_EX_CODEOP_SWI : return R_ANAL_OP_TYPE_SWI;
case R_ANAL_EX_CODEOP_TRAP : return R_ANAL_OP_TYPE_TRAP;
case R_ANAL_EX_CODEOP_SWITCH: return R_ANAL_OP_TYPE_SWITCH;
case R_ANAL_EX_CODEOP_CALL: return conditional | R_ANAL_OP_TYPE_CALL;
case R_ANAL_EX_CODEOP_JMP: return conditional | R_ANAL_OP_TYPE_JMP;
case R_ANAL_EX_CODEOP_RET: return conditional | R_ANAL_OP_TYPE_RET;
case R_ANAL_EX_CODEOP_LEAVE: return R_ANAL_OP_TYPE_LEAVE;
case R_ANAL_EX_CODEOP_SWI: return R_ANAL_OP_TYPE_SWI;
case R_ANAL_EX_CODEOP_TRAP: return R_ANAL_OP_TYPE_TRAP;
case R_ANAL_EX_CODEOP_SWITCH: return R_ANAL_OP_TYPE_SWITCH;
}
return R_ANAL_OP_TYPE_UNK;
}
ut64 extract_load_store_op(ut64 ranal2_op_type) {
if ( (ranal2_op_type & R_ANAL_EX_LDST_OP_PUSH) == R_ANAL_EX_LDST_OP_PUSH) {
return R_ANAL_OP_TYPE_PUSH;
@ -420,7 +416,6 @@ ut64 extract_load_store_op(ut64 ranal2_op_type) {
return R_ANAL_OP_TYPE_UNK;
}
ut64 extract_unknown_op(ut64 ranal2_op_type) {
if ((ranal2_op_type & R_ANAL_EX_CODEOP_JMP) == R_ANAL_EX_CODEOP_JMP) {
return R_ANAL_OP_TYPE_UJMP;
@ -435,54 +430,68 @@ ut64 extract_unknown_op(ut64 ranal2_op_type) {
}
ut64 extract_bin_op(ut64 ranal2_op_type) {
ut64 bin_op_val = ranal2_op_type & (R_ANAL_EX_BIN_OP | 0x80000);
switch (bin_op_val) {
case R_ANAL_EX_BINOP_XCHG:return R_ANAL_OP_TYPE_XCHG;
case R_ANAL_EX_BINOP_CMP: return R_ANAL_OP_TYPE_CMP;
case R_ANAL_EX_BINOP_ADD: return R_ANAL_OP_TYPE_ADD;
case R_ANAL_EX_BINOP_SUB: return R_ANAL_OP_TYPE_SUB;
case R_ANAL_EX_BINOP_MUL: return R_ANAL_OP_TYPE_MUL;
case R_ANAL_EX_BINOP_DIV: return R_ANAL_OP_TYPE_DIV;
case R_ANAL_EX_BINOP_SHR: return R_ANAL_OP_TYPE_SHR;
case R_ANAL_EX_BINOP_SHL: return R_ANAL_OP_TYPE_SHL;
case R_ANAL_EX_BINOP_SAL: return R_ANAL_OP_TYPE_SAL;
case R_ANAL_EX_BINOP_SAR: return R_ANAL_OP_TYPE_SAR;
case R_ANAL_EX_BINOP_OR : return R_ANAL_OP_TYPE_OR;
case R_ANAL_EX_BINOP_AND: return R_ANAL_OP_TYPE_AND;
case R_ANAL_EX_BINOP_XOR: return R_ANAL_OP_TYPE_XOR;
case R_ANAL_EX_BINOP_NOT: return R_ANAL_OP_TYPE_NOT;
case R_ANAL_EX_BINOP_MOD: return R_ANAL_OP_TYPE_MOD;
case R_ANAL_EX_BINOP_ROR: return R_ANAL_OP_TYPE_ROR;
case R_ANAL_EX_BINOP_ROL: return R_ANAL_OP_TYPE_ROL;
default: break;
}
return R_ANAL_OP_TYPE_UNK;
}
R_API ut64 r_anal_ex_map_anal_ex_to_anal_op_type (ut64 ranal2_op_type) {
switch (ranal2_op_type) {
case R_ANAL_EX_NULL_OP: return R_ANAL_OP_TYPE_NULL;
case R_ANAL_EX_NOP: return R_ANAL_OP_TYPE_NOP;
case R_ANAL_EX_ILL_OP: return R_ANAL_OP_TYPE_ILL;
case R_ANAL_EX_BINOP_XCHG:return R_ANAL_OP_TYPE_XCHG;
case R_ANAL_EX_BINOP_CMP: return R_ANAL_OP_TYPE_CMP;
case R_ANAL_EX_BINOP_ADD: return R_ANAL_OP_TYPE_ADD;
case R_ANAL_EX_BINOP_SUB: return R_ANAL_OP_TYPE_SUB;
case R_ANAL_EX_BINOP_MUL: return R_ANAL_OP_TYPE_MUL;
case R_ANAL_EX_BINOP_DIV: return R_ANAL_OP_TYPE_DIV;
case R_ANAL_EX_BINOP_SHR: return R_ANAL_OP_TYPE_SHR;
case R_ANAL_EX_BINOP_SHL: return R_ANAL_OP_TYPE_SHL;
case R_ANAL_EX_BINOP_SAL: return R_ANAL_OP_TYPE_SAL;
case R_ANAL_EX_BINOP_SAR: return R_ANAL_OP_TYPE_SAR;
case R_ANAL_EX_BINOP_OR : return R_ANAL_OP_TYPE_OR;
case R_ANAL_EX_BINOP_AND: return R_ANAL_OP_TYPE_AND;
case R_ANAL_EX_BINOP_XOR: return R_ANAL_OP_TYPE_XOR;
case R_ANAL_EX_BINOP_NOT: return R_ANAL_OP_TYPE_NOT;
case R_ANAL_EX_BINOP_MOD: return R_ANAL_OP_TYPE_MOD;
case R_ANAL_EX_BINOP_ROR: return R_ANAL_OP_TYPE_ROR;
case R_ANAL_EX_BINOP_ROL: return R_ANAL_OP_TYPE_ROL;
default: break;
}
if (ranal2_op_type & R_ANAL_EX_UNK_OP) {
return extract_unknown_op(ranal2_op_type);
return R_ANAL_OP_TYPE_UNK;
}
R_API ut64 r_anal_ex_map_anal_ex_to_anal_op_type (ut64 t) {
ut64 t2 = extract_bin_op(t);
if (t2 != R_ANAL_OP_TYPE_UNK) {
return t2;
}
if (ranal2_op_type & R_ANAL_EX_CODE_OP) {
return extract_code_op(ranal2_op_type);
switch (t) {
case R_ANAL_EX_NULL_OP: return R_ANAL_OP_TYPE_NULL;
case R_ANAL_EX_NOP: return R_ANAL_OP_TYPE_NOP;
case R_ANAL_EX_BINOP_ADD: return R_ANAL_OP_TYPE_ADD;
case R_ANAL_EX_BINOP_AND: return R_ANAL_OP_TYPE_AND;
case R_ANAL_EX_BINOP_MUL: return R_ANAL_OP_TYPE_MUL;
case R_ANAL_EX_BINOP_XOR: return R_ANAL_OP_TYPE_XOR;
case R_ANAL_EX_BINOP_XCHG: return R_ANAL_OP_TYPE_MOV;
case R_ANAL_EX_OBJOP_NEW: return R_ANAL_OP_TYPE_UCALL;
case R_ANAL_EX_OBJOP_SIZE: return R_ANAL_OP_TYPE_UCALL;
case R_ANAL_EX_ILL_OP: return R_ANAL_OP_TYPE_ILL;
default:
if (t & R_ANAL_EX_UNK_OP) {
return extract_unknown_op (t);
}
if (t & R_ANAL_EX_CODE_OP) {
return extract_code_op (t);
}
if (t & R_ANAL_EX_REP_OP) {
ut64 ret = r_anal_ex_map_anal_ex_to_anal_op_type (t & ~R_ANAL_EX_REP_OP);
return R_ANAL_OP_TYPE_REP | ret;
}
if (t & (R_ANAL_EX_LOAD_OP | R_ANAL_EX_STORE_OP)) {
return extract_load_store_op(t);
}
if (t & R_ANAL_EX_BIN_OP) {
return extract_bin_op (t);
}
break;
}
if (ranal2_op_type & R_ANAL_EX_REP_OP) {
ut64 ret = r_anal_ex_map_anal_ex_to_anal_op_type (ranal2_op_type & ~R_ANAL_EX_REP_OP);
return R_ANAL_OP_TYPE_REP | ret;
}
if (ranal2_op_type & (R_ANAL_EX_LOAD_OP | R_ANAL_EX_STORE_OP)) {
return extract_load_store_op(ranal2_op_type);
}
if (ranal2_op_type & R_ANAL_EX_BIN_OP) {
return extract_bin_op(ranal2_op_type);
if (R_ANAL_EX_OBJOP_CAST & t) {
return R_ANAL_OP_TYPE_MOV;
}
return R_ANAL_OP_TYPE_UNK;
}

2
libr/anal/fcn.c
View File

@ -1768,7 +1768,7 @@ R_API int r_anal_fcn(RAnal *anal, RAnalFunction *fcn, ut64 addr, ut64 len, int r
}
if (anal->cur && anal->cur->fcn) {
int result = anal->cur->fcn (anal, fcn, addr, reftype);
if (anal->cur->custom_fn_anal) {
if (anal->use_ex && anal->cur->custom_fn_anal) {
return result;
}
}

312
libr/anal/p/anal_java.c
View File

@ -1,4 +1,4 @@
/* radare - Apache 2.0 - Copyright 2010-2015 - pancake and
/* radare - Apache 2.0 - Copyright 2010-2019 - pancake and
Adam Pridgen <dso@rice.edu || adam.pridgen@thecoverofnight.com> */
#include <string.h>
@ -133,10 +133,12 @@ static ut64 java_get_method_start () {
}
static int java_revisit_bb_anal_recursive_descent(RAnal *anal, RAnalState *state, ut64 addr) {
RAnalBlock *current_head = state && state->current_bb_head ? state->current_bb_head : NULL;
if (current_head && state->current_bb &&
state->current_bb->type & R_ANAL_BB_TYPE_TAIL) {
r_anal_ex_update_bb_cfg_head_tail (current_head, current_head, state->current_bb);
r_return_val_if_fail (anal && state, R_ANAL_RET_ERROR);
RAnalBlock *head = state->current_bb_head;
RAnalBlock *bb = state->current_bb;
r_return_val_if_fail (bb && head, R_ANAL_RET_ERROR);
if (bb->type & R_ANAL_BB_TYPE_TAIL) {
r_anal_ex_update_bb_cfg_head_tail (head, head, bb);
// XXX should i do this instead -> r_anal_ex_perform_post_anal_bb_cb (anal, state, addr+offset);
state->done = 1;
}
@ -144,18 +146,13 @@ static int java_revisit_bb_anal_recursive_descent(RAnal *anal, RAnalState *state
}
static int java_recursive_descent(RAnal *anal, RAnalState *state, ut64 addr) {
RAnalBlock *bb;
RAnalBlock *current_head;
r_return_val_if_fail (anal && state && state->current_bb && state->current_bb_head, 0);
if (!anal || !state || !state->current_bb || state->current_bb_head) {
return 0;
}
RAnalBlock *bb = state->current_bb;
RAnalBlock *head = state->current_bb_head;
bb = state->current_bb;
current_head = state->current_bb_head;
if (current_head && state->current_bb->type & R_ANAL_BB_TYPE_TAIL) {
r_anal_ex_update_bb_cfg_head_tail (current_head, current_head, state->current_bb);
if (head && bb->type & R_ANAL_BB_TYPE_TAIL) {
r_anal_ex_update_bb_cfg_head_tail (head, head, bb);
}
// basic filter for handling the different type of operations
@ -207,9 +204,7 @@ static int java_linear_sweep(RAnal *anal, RAnalState *state, ut64 addr) {
}
static int handle_bb_cf_recursive_descent (RAnal *anal, RAnalState *state) {
RAnalBlock *bb = state->current_bb;
ut64 addr = 0;
int result = 0;
if (!bb) {
@ -226,137 +221,137 @@ static int handle_bb_cf_recursive_descent (RAnal *anal, RAnalState *state) {
// XXX - transition to type2 control flow condtions
switch (control_type) {
case R_ANAL_OP_TYPE_CALL:
IFDBG eprintf (" - Handling a call @ 0x%04"PFMT64x".\n", addr);
r_anal_xrefs_set (anal, bb->addr, bb->jump, R_ANAL_REF_TYPE_CALL);
result = R_ANAL_RET_ERROR;
break;
case R_ANAL_OP_TYPE_JMP:
{
RList * jmp_list;
IFDBG eprintf (" - Handling a jmp @ 0x%04"PFMT64x" to 0x%04"PFMT64x".\n", addr, bb->jump);
case R_ANAL_OP_TYPE_CALL:
IFDBG eprintf (" - Handling a call @ 0x%04"PFMT64x".\n", addr);
r_anal_xrefs_set (anal, bb->addr, bb->jump, R_ANAL_REF_TYPE_CALL);
result = R_ANAL_RET_ERROR;
break;
case R_ANAL_OP_TYPE_JMP:
{
RList * jmp_list;
IFDBG eprintf (" - Handling a jmp @ 0x%04"PFMT64x" to 0x%04"PFMT64x".\n", addr, bb->jump);
// visited some other time
if (!r_anal_state_search_bb (state, bb->jump)) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, bb->jump );
if (jmp_list) {
bb->jumpbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (bb->jumpbb) {
bb->jump = bb->jumpbb->addr;
}
} else {
bb->jumpbb = r_anal_state_search_bb (state, bb->jump);
if (bb->jumpbb) {
bb->jump = bb->jumpbb->addr;
}
// visited some other time
if (!r_anal_state_search_bb (state, bb->jump)) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, bb->jump );
if (jmp_list) {
bb->jumpbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (state->done == 1) {
IFDBG eprintf (" Looks like this jmp (bb @ 0x%04"PFMT64x") found a return.\n", addr);
}
result = R_ANAL_RET_END;
}
break;
case R_ANAL_OP_TYPE_CJMP:
{
RList *jmp_list;
ut8 encountered_stop = 0;
IFDBG eprintf (" - Handling a cjmp @ 0x%04"PFMT64x" jmp to 0x%04"PFMT64x" and fail to 0x%04"PFMT64x".\n", addr, bb->jump, bb->fail);
IFDBG eprintf (" - Handling jmp to 0x%04"PFMT64x".\n", bb->jump);
// visited some other time
if (!r_anal_state_search_bb (state, bb->jump)) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, bb->jump );
if (jmp_list) {
bb->jumpbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (bb->jumpbb) {
bb->jump = bb->jumpbb->addr;
}
} else {
bb->jumpbb = r_anal_state_search_bb (state, bb->jump);
if (bb->jumpbb) {
bb->jump = bb->jumpbb->addr;
}
if (state->done == 1) {
IFDBG eprintf (" Looks like this jmp (bb @ 0x%04"PFMT64x") found a return.\n", addr);
state->done = 0;
encountered_stop = 1;
}
if (!r_anal_state_search_bb (state, bb->fail)) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, bb->fail );
if (jmp_list) {
bb->failbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (bb->failbb) {
bb->fail = bb->failbb->addr;
}
} else {
bb->failbb = r_anal_state_search_bb (state, bb->fail);
if (bb->failbb) {
bb->fail = bb->failbb->addr;
}
}
IFDBG eprintf (" - Handling an cjmp @ 0x%04"PFMT64x" jmp to 0x%04"PFMT64x" and fail to 0x%04"PFMT64x".\n", addr, bb->jump, bb->fail);
IFDBG eprintf (" - Handling fail to 0x%04"PFMT64x".\n", bb->fail);
// r_anal_state_merge_bb_list (state, fail_list);
if (state->done == 1) {
IFDBG eprintf (" Looks like this fail (bb @ 0x%04"PFMT64x") found a return.\n", addr);
}
result = R_ANAL_RET_END;
if (encountered_stop) {
state->done = 1;
} else {
bb->jumpbb = r_anal_state_search_bb (state, bb->jump);
if (bb->jumpbb) {
bb->jump = bb->jumpbb->addr;
}
}
break;
case R_ANAL_OP_TYPE_SWITCH:
if (state->done == 1) {
IFDBG eprintf (" Looks like this jmp (bb @ 0x%04"PFMT64x") found a return.\n", addr);
}
result = R_ANAL_RET_END;
}
break;
case R_ANAL_OP_TYPE_CJMP:
{
IFDBG eprintf (" - Handling an switch @ 0x%04"PFMT64x".\n", addr);
if (bb->switch_op) {
RAnalCaseOp *caseop;
RListIter *iter;
RList *jmp_list = NULL;
ut8 encountered_stop = 0;
r_list_foreach (bb->switch_op->cases, iter, caseop) {
if (caseop) {
if (r_anal_state_addr_is_valid (state, caseop->jump) ) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, caseop->jump );
if (jmp_list) {
caseop->jumpbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (state->done == 1) {
IFDBG eprintf (" Looks like this jmp (bb @ 0x%04"PFMT64x") found a return.\n", addr);
state->done = 0;
encountered_stop = 1;
}
RList *jmp_list;
ut8 encountered_stop = 0;
IFDBG eprintf (" - Handling a cjmp @ 0x%04"PFMT64x" jmp to 0x%04"PFMT64x" and fail to 0x%04"PFMT64x".\n", addr, bb->jump, bb->fail);
IFDBG eprintf (" - Handling jmp to 0x%04"PFMT64x".\n", bb->jump);
// visited some other time
if (!r_anal_state_search_bb (state, bb->jump)) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, bb->jump );
if (jmp_list) {
bb->jumpbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (bb->jumpbb) {
bb->jump = bb->jumpbb->addr;
}
} else {
bb->jumpbb = r_anal_state_search_bb (state, bb->jump);
bb->jump = bb->jumpbb->addr;
}
if (state->done == 1) {
IFDBG eprintf (" Looks like this jmp (bb @ 0x%04"PFMT64x") found a return.\n", addr);
state->done = 0;
encountered_stop = 1;
}
if (!r_anal_state_search_bb (state, bb->fail)) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, bb->fail );
if (jmp_list) {
bb->failbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (bb->failbb) {
bb->fail = bb->failbb->addr;
}
} else {
bb->failbb = r_anal_state_search_bb (state, bb->fail);
if (bb->failbb) {
bb->fail = bb->failbb->addr;
}
}
IFDBG eprintf (" - Handling an cjmp @ 0x%04"PFMT64x" jmp to 0x%04"PFMT64x" and fail to 0x%04"PFMT64x".\n", addr, bb->jump, bb->fail);
IFDBG eprintf (" - Handling fail to 0x%04"PFMT64x".\n", bb->fail);
// r_anal_state_merge_bb_list (state, fail_list);
if (state->done == 1) {
IFDBG eprintf (" Looks like this fail (bb @ 0x%04"PFMT64x") found a return.\n", addr);
}
result = R_ANAL_RET_END;
if (encountered_stop) {
state->done = 1;
}
}
break;
case R_ANAL_OP_TYPE_SWITCH:
{
IFDBG eprintf (" - Handling an switch @ 0x%04"PFMT64x".\n", addr);
if (bb->switch_op) {
RAnalCaseOp *caseop;
RListIter *iter;
RList *jmp_list = NULL;
ut8 encountered_stop = 0;
r_list_foreach (bb->switch_op->cases, iter, caseop) {
if (caseop) {
if (r_anal_state_addr_is_valid (state, caseop->jump) ) {
jmp_list = r_anal_ex_perform_analysis ( anal, state, caseop->jump );
if (jmp_list) {
caseop->jumpbb = (RAnalBlock *)r_list_get_n (jmp_list, 0);
}
if (state->done == 1) {
IFDBG eprintf (" Looks like this jmp (bb @ 0x%04"PFMT64x") found a return.\n", addr);
state->done = 0;
encountered_stop = 1;
}
}
}
r_list_free (jmp_list);
if (encountered_stop) {
state->done = 1;
}
}
result = R_ANAL_RET_END;
r_list_free (jmp_list);
if (encountered_stop) {
state->done = 1;
}
}
break;
case R_ANAL_OP_TYPE_TRAP:
case R_ANAL_OP_TYPE_UJMP:
case R_ANAL_OP_TYPE_IJMP:
case R_ANAL_OP_TYPE_RJMP:
case R_ANAL_OP_TYPE_IRJMP:
case R_ANAL_OP_TYPE_RET:
case R_ANAL_OP_TYPE_ILL:
IFDBG eprintf (" - Handling an ret @ 0x%04"PFMT64x".\n", addr);
state->done = 1;
result = R_ANAL_RET_END;
break;
default: break;
result = R_ANAL_RET_END;
}
break;
case R_ANAL_OP_TYPE_TRAP:
case R_ANAL_OP_TYPE_UJMP:
case R_ANAL_OP_TYPE_IJMP:
case R_ANAL_OP_TYPE_RJMP:
case R_ANAL_OP_TYPE_IRJMP:
case R_ANAL_OP_TYPE_RET:
case R_ANAL_OP_TYPE_ILL:
IFDBG eprintf (" - Handling an ret @ 0x%04"PFMT64x".\n", addr);
state->done = 1;
result = R_ANAL_RET_END;
break;
default: break;
}
state->current_depth--;
@ -380,10 +375,10 @@ static int java_post_anal_linear_sweep(RAnal *anal, RAnalState *state, ut64 addr
if (paddr64 && !r_anal_state_search_bb (state, *paddr64)) {
ut64 list_length = 0;
IFDBG eprintf (" - Visiting 0x%04"PFMT64x" for analysis.\n", *paddr64);
jmp_list = r_anal_ex_perform_analysis ( anal, state, *paddr64 );
jmp_list = r_anal_ex_perform_analysis (anal, state, *paddr64 );
list_length = r_list_length (jmp_list);
r_list_free (jmp_list);
if ( list_length > 0) {
if (list_length > 0) {
IFDBG eprintf (" - Found %"PFMT64d" more basic blocks missed on the initial pass.\n", *paddr64);
}
}
@ -482,7 +477,6 @@ static int handle_bb_cf_linear_sweep (RAnal *anal, RAnalState *state) {
//many flaws UAF
static int analyze_from_code_buffer(RAnal *anal, RAnalFunction *fcn, ut64 addr, const ut8 *code_buf, ut64 code_length) {
char gen_name[1025];
RListIter *bb_iter;
RAnalBlock *bb;
ut64 actual_size = 0;
@ -492,9 +486,8 @@ static int analyze_from_code_buffer(RAnal *anal, RAnalFunction *fcn, ut64 addr,
free (fcn->name);
free (fcn->dsc);
snprintf (gen_name, 1024, "sym.%08"PFMT64x"", addr);
fcn->name = strdup (gen_name);
fcn->name = r_str_newf ("sym.%08"PFMT64x, addr);
fcn->dsc = strdup ("unknown");
r_anal_fcn_set_size (NULL, fcn, code_length);
fcn->type = R_ANAL_FCN_TYPE_FCN;
@ -526,23 +519,20 @@ static int analyze_from_code_buffer(RAnal *anal, RAnalFunction *fcn, ut64 addr,
static int analyze_from_code_attr (RAnal *anal, RAnalFunction *fcn, RBinJavaField *method, ut64 loadaddr) {
RBinJavaAttrInfo* code_attr = method ? r_bin_java_get_method_code_attribute(method) : NULL;
ut8 * code_buf = NULL;
int result = false;
ut64 code_length = 0;
ut64 code_addr = -1;
if (!code_attr) {
fcn->name = strdup ("sym.UNKNOWN");
fcn->dsc = strdup ("unknown");
r_anal_fcn_set_size (NULL, fcn, code_length);
r_anal_fcn_set_size (NULL, fcn, 1); // code_length);
fcn->type = R_ANAL_FCN_TYPE_FCN;
fcn->addr = 0;
return R_ANAL_RET_ERROR;
}
code_length = code_attr->info.code_attr.code_length;
code_addr = code_attr->info.code_attr.code_offset;
code_buf = calloc (1, code_length);
ut64 code_length = code_attr->info.code_attr.code_length;
ut64 code_addr = code_attr->info.code_attr.code_offset;
ut8 *code_buf = calloc (1, code_length);
anal->iob.read_at (anal->iob.io, code_addr + loadaddr, code_buf, code_length);
result = analyze_from_code_buffer (anal, fcn, code_addr + loadaddr, code_buf, code_length);
@ -647,8 +637,7 @@ static int java_analyze_fns( RAnal *anal, ut64 start, ut64 end, int reftype, int
RList * anal_fcns = NULL;
ut8 analyze_all = 0;
//RAnalRef *ref = NULL;
int result = R_ANAL_RET_ERROR;
int result = 0; // R_ANAL_RET_ERROR;
if (end == UT64_MAX) {
analyze_all = 1;
@ -673,7 +662,7 @@ static int java_analyze_fns( RAnal *anal, ut64 start, ut64 end, int reftype, int
java_set_function_prototype (anal, fcn, method);
result = analyze_from_code_attr (anal, fcn, method, loadaddr);
if (result == R_ANAL_RET_ERROR) {
//eprintf ("Failed to parse java fn: %s @ 0x%04"PFMT64x"\n", fcn->name, fcn->addr);
eprintf ("Failed to parse java fn: %s @ 0x%04"PFMT64x"\n", fcn->name, fcn->addr);
return result;
// XXX - TO Stop or not to Stop ??
}
@ -744,15 +733,17 @@ static int java_switch_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data,
static int java_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data, int len, RAnalOpMask mask) {
/* get opcode size */
if (len < 1) {
op->type = R_ANAL_OP_TYPE_ILL;
return 1;
}
//ut8 op_byte = data[0];
ut8 op_byte = data[0];
op->jump = UT64_MAX;
op->fail = UT64_MAX;
int sz = JAVA_OPS[op_byte].size;
if (!op) {
op->type = R_ANAL_OP_TYPE_ILL;
return sz;
}
memset (op, '\0', sizeof (RAnalOp));
IFDBG {
//eprintf ("Extracting op from buffer (%d byte(s)) @ 0x%04x\n", len, addr);
//eprintf ("Parsing op: (0x%02x) %s.\n", op_byte, JAVA_OPS[op_byte].name);
@ -798,6 +789,15 @@ static int java_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data, int len
// incomplete analysis here
return 0;
}
if (op->type == R_ANAL_OP_TYPE_POP) {
op->stackop = R_ANAL_STACK_INC;
op->stackptr = 8;
}
op->direction = R_ANAL_OP_DIR_EXEC;
if (op->type == R_ANAL_OP_TYPE_PUSH) {
op->stackop = R_ANAL_STACK_INC;
op->stackptr = -8;
}
if (op->type == R_ANAL_OP_TYPE_CJMP) {
op->jump = addr + (short)(USHORT (data, 1));
op->fail = addr + sz;
@ -933,17 +933,21 @@ static int java_reset_counter (RAnal *anal, ut64 start_addr ) {
return true;
}
#define USE_CUSTOM_ANAL 1
RAnalPlugin r_anal_plugin_java = {
.name = "java",
.desc = "Java bytecode analysis plugin",
.license = "Apache",
.arch = "java",
.bits = 32,
#if USE_CUSTOM_ANAL
.custom_fn_anal = 1,
.reset_counter = java_reset_counter,
.analyze_fns = java_analyze_fns,
.post_anal_bb_cb = java_recursive_descent,
.revisit_bb_anal = java_revisit_bb_anal_recursive_descent,
#endif
.op = &java_op,
.cmd_ext = java_cmd_ext,
0
@ -955,11 +959,13 @@ RAnalPlugin r_anal_plugin_java_ls = {
.license = "Apache",
.arch = "java",
.bits = 32,
#if USE_CUSTOM_ANAL
.custom_fn_anal = 1,
.analyze_fns = java_analyze_fns,
.post_anal_bb_cb = java_linear_sweep,
.post_anal = java_post_anal_linear_sweep,
.revisit_bb_anal = java_revisit_bb_anal_recursive_descent,
#endif
.op = &java_op,
.cmd_ext = java_cmd_ext,
0

2
libr/bin/p/bin_java.c
View File

@ -1,4 +1,4 @@
/* radare - LGPL - Copyright 2009-2017 - pancake, nibble, Adam Pridgen <dso@rice.edu || adam.pridgen@thecoverofnight.com> */
/* radare - LGPL - Copyright 2009-2019 - pancake, nibble, Adam Pridgen <dso@rice.edu || adam.pridgen@thecoverofnight.com> */
#include <r_types.h>
#include <r_util.h>

9
libr/core/canal.c
View File

@ -1610,10 +1610,13 @@ R_API int r_core_anal_esil_fcn(RCore *core, ut64 at, ut64 from, int reftype, int
* reference to that fcn */
R_API int r_core_anal_fcn(RCore *core, ut64 at, ut64 from, int reftype, int depth) {
if (from == UT64_MAX && r_anal_get_fcn_in (core->anal, at, 0)) {
if (core->anal->verbose) {
eprintf ("Message: Invalid address for function 0x%08"PFMT64x"\n", at);
}
return 0;
}
bool use_esil = r_config_get_i (core->config, "anal.esil");
const bool use_esil = r_config_get_i (core->config, "anal.esil");
RAnalFunction *fcn;
RListIter *iter;
@ -1636,7 +1639,7 @@ R_API int r_core_anal_fcn(RCore *core, ut64 at, ut64 from, int reftype, int dept
/* if there is an anal plugin and it wants to analyze the function itself,
* run it instead of the normal analysis */
if (core->anal->cur && core->anal->cur->analyze_fns) {
if (core->anal->use_ex && core->anal->cur && core->anal->cur->analyze_fns) {
int result = R_ANAL_RET_ERROR;
result = core->anal->cur->analyze_fns (core->anal, at, from, reftype, depth);
/* update the flags after running the analysis function of the plugin */
@ -1648,9 +1651,11 @@ R_API int r_core_anal_fcn(RCore *core, ut64 at, ut64 from, int reftype, int dept
return result;
}
if (from != UT64_MAX && !at) {
eprintf ("invalid address\n");
return false;
}
if (at == UT64_MAX || depth < 0) {
eprintf ("err dp\n");
return false;
}
if (r_cons_is_breaked ()) {

8
libr/core/cconfig.c
View File

@ -2151,6 +2151,13 @@ static bool cb_zoombyte(void *user, void *data) {
return true;
}
static bool cb_analex(void *user, void *data) {
RCore *core = (RCore *) user;
RConfigNode *node = (RConfigNode *) data;
core->anal->use_ex = node->i_value;
return true;
}
static bool cb_analverbose(void *user, void *data) {
RCore *core = (RCore *) user;
RConfigNode *node = (RConfigNode *) data;
@ -2650,6 +2657,7 @@ R_API int r_core_config_init(RCore *core) {
/* anal */
SETPREF ("anal.fcnprefix", "fcn", "Prefix new function names with this");
SETCB ("anal.ex", "true", &cb_analex, "Use the anal extension methods from the selected plugin if available");
SETCB ("anal.verbose", "false", &cb_analverbose, "Show RAnal warnings when analyzing code");
SETPREF ("anal.a2f", "false", "Use the new WIP analysis algorithm (core/p/a2f), anal.depth ignored atm");
SETCB ("anal.roregs", "gp,zero", (RConfigCallback)&cb_anal_roregs, "Comma separated list of register names to be readonly");

7
libr/core/cmd_anal.c
View File

@ -1694,11 +1694,8 @@ static void core_anal_bytes(RCore *core, const ut8 *buf, int len, int nops, int
if (op.failcycles) {
printline ("failcycles", "%d\n", op.failcycles);
}
{
const char *t2 = r_anal_optype_to_string (op.type2);
if (t2 && strcmp (t2, "null")) {
printline ("type2", "%s\n", t2);
}
if (op.type2) {
printline ("type2", "0x%x\n", op.type2);
}
if (op.reg) {
printline ("reg", "%s\n", op.reg);

2
libr/core/disasm.c
View File

@ -4753,7 +4753,7 @@ R_API int r_core_print_disasm(RPrint *p, RCore *core, ut64 addr, ut8 *buf, int l
{ /* used by asm.emu */
r_reg_arena_push (core->anal->reg);
}
if (core->anal->cur && core->anal->cur->reset_counter) {
if (core->anal->use_ex && core->anal->cur && core->anal->cur->reset_counter) {
core->anal->cur->reset_counter (core->anal, addr);
}

150
libr/core/p/core_java.c
View File

@ -1,4 +1,4 @@
/* radare - Apache - Copyright 2014-2016 - dso, pancake */
/* radare - Apache - Copyright 2014-2019 - dso, pancake */
#include <r_types.h>
#include <r_lib.h>
@ -9,11 +9,6 @@
#include <r_anal.h>
#include <r_anal_ex.h>
#if 0
#include "../../../shlr/java/ops.c"
#include "../../../shlr/java/code.c"
#include "../../../shlr/java/class.c"
#endif
#include "../../../shlr/java/class.h"
#include "../../../shlr/java/code.h"
#include "../../../shlr/java/dsojson.h"
@ -985,23 +980,22 @@ static int r_cmd_java_handle_find_cp_const (RCore *core, const char *cmd) {
char op = bb->op_bytes[0];
cp_res = NULL;
switch (op) {
case 0x12:
cp_res = (idx == (ut16) -1) || (bb->op_bytes[1] == idx) ?
R_NEW0(RCmdJavaCPResult) : NULL;
if (cp_res) {
cp_res->idx = bb->op_bytes[1];
}
break;
case 0x13:
case 0x14:
cp_res = (idx == (ut16) -1) || (R_BIN_JAVA_USHORT (bb->op_bytes, 1) == idx) ?
R_NEW0(RCmdJavaCPResult) : NULL;
if (cp_res) {
cp_res->idx = R_BIN_JAVA_USHORT (bb->op_bytes, 1);
}
break;
case 0x12:
cp_res = (idx == (ut16) -1) || (bb->op_bytes[1] == idx) ?
R_NEW0(RCmdJavaCPResult) : NULL;
if (cp_res) {
cp_res->idx = bb->op_bytes[1];
}
break;
case 0x13:
case 0x14:
cp_res = (idx == (ut16) -1) || (R_BIN_JAVA_USHORT (bb->op_bytes, 1) == idx) ?
R_NEW0(RCmdJavaCPResult) : NULL;
if (cp_res) {
cp_res->idx = R_BIN_JAVA_USHORT (bb->op_bytes, 1);
}
break;
}
if (cp_res) {
cp_res->addr = bb->addr;
cp_res->obj = r_bin_java_get_item_from_cp (obj, cp_res->idx);
@ -1044,9 +1038,9 @@ static int r_cmd_java_handle_field_info (RCore *core, const char *cmd) {
}
switch (*(cmd)) {
case 'c': return r_cmd_java_print_field_num_name (obj);
case 's': return r_cmd_java_print_field_summary (obj, idx);
case 'n': return r_cmd_java_print_field_name (obj, idx);
case 'c': return r_cmd_java_print_field_num_name (obj);
case 's': return r_cmd_java_print_field_summary (obj, idx);
case 'n': return r_cmd_java_print_field_name (obj, idx);
}
IFDBG r_cons_printf ("Command is (%s)\n", cmd);
eprintf ("[-] r_cmd_java: invalid command syntax.\n");
@ -1074,9 +1068,9 @@ static int r_cmd_java_handle_method_info (RCore *core, const char *cmd) {
}
switch (*(cmd)) {
case 'c': return r_cmd_java_print_method_num_name (obj);
case 's': return r_cmd_java_print_method_summary (obj, idx);
case 'n': return r_cmd_java_print_method_name (obj, idx);
case 'c': return r_cmd_java_print_method_num_name (obj);
case 's': return r_cmd_java_print_method_summary (obj, idx);
case 'n': return r_cmd_java_print_method_name (obj, idx);
}
IFDBG r_cons_printf ("Command is (%s)\n", cmd);
@ -1184,15 +1178,11 @@ static int r_cmd_java_handle_isvalid (RCore *core, const char *cmd) {
res = r_sz < sz ? false : true;
free (buf);
break;
}else {
} else {
sz <<= 1;
}
}
if (res) {
r_cons_printf ("True\n");
} else {
r_cons_printf ("False\n");
}
r_cons_printf ("%s\n", r_str_bool (res));
} else {
r_cmd_java_print_cmd_help (JAVA_CMDS + ISVALID_IDX);
}
@ -1209,12 +1199,12 @@ static int r_cmd_java_handle_resolve_cp (RCore *core, const char *cmd) {
int res = false;
if (idx > 0 && obj) {
switch (c_type) {
case 't': return r_cmd_java_resolve_cp_type (obj, idx);
case 'c': return r_cmd_java_resolve_cp_idx (obj, idx);
case 'e': return r_cmd_java_resolve_cp_idx_b64 (obj, idx);
case 'a': return r_cmd_java_resolve_cp_address (obj, idx);
case 's': return r_cmd_java_resolve_cp_summary (obj, idx);
case 'k': return r_cmd_java_resolve_cp_to_key (obj, idx);
case 't': return r_cmd_java_resolve_cp_type (obj, idx);
case 'c': return r_cmd_java_resolve_cp_idx (obj, idx);
case 'e': return r_cmd_java_resolve_cp_idx_b64 (obj, idx);
case 'a': return r_cmd_java_resolve_cp_address (obj, idx);
case 's': return r_cmd_java_resolve_cp_summary (obj, idx);
case 'k': return r_cmd_java_resolve_cp_to_key (obj, idx);
}
} else if (obj && c_type == 'g') {
for (idx = 1; idx <=obj->cp_count; idx++) {
@ -1247,9 +1237,9 @@ static int r_cmd_java_get_all_access_flags_value (const char *cmd) {
char *str = NULL;
switch (*(cmd)) {
case 'f': the_list = retrieve_all_field_access_string_and_value (); break;
case 'm': the_list = retrieve_all_method_access_string_and_value (); break;
case 'c': the_list = retrieve_all_class_access_string_and_value (); break;
case 'f': the_list = retrieve_all_field_access_string_and_value (); break;
case 'm': the_list = retrieve_all_method_access_string_and_value (); break;
case 'c': the_list = retrieve_all_class_access_string_and_value (); break;
}
if (!the_list) {
eprintf ("[-] r_cmd_java: incorrect syntax for the flags calculation.\n");
@ -1257,9 +1247,9 @@ static int r_cmd_java_get_all_access_flags_value (const char *cmd) {
return false;
}
switch (*(cmd)) {
case 'f': r_cons_printf ("[=] Fields Access Flags List\n"); break;
case 'm': r_cons_printf ("[=] Methods Access Flags List\n"); break;
case 'c': r_cons_printf ("[=] Class Access Flags List\n");; break;
case 'f': r_cons_printf ("[=] Fields Access Flags List\n"); break;
case 'm': r_cons_printf ("[=] Methods Access Flags List\n"); break;
case 'c': r_cons_printf ("[=] Class Access Flags List\n");; break;
}
r_list_foreach (the_list, iter, str) {
@ -1283,9 +1273,9 @@ static int r_cmd_java_handle_calc_flags (RCore *core, const char *cmd) {
const char *lcmd = *cmd+1 == ' '? cmd+2 : cmd+1;
IFDBG eprintf ("Seeing %s and accepting %s\n", cmd, lcmd);
switch (*(lcmd)) {
case 'f':
case 'm':
case 'c': res = r_cmd_java_get_all_access_flags_value (lcmd); break;
case 'f':
case 'm':
case 'c': res = r_cmd_java_get_all_access_flags_value (lcmd); break;
}
// Just print them all out
if (res == false) {
@ -1317,18 +1307,18 @@ static int r_cmd_java_handle_flags_str (RCore *core, const char *cmd) {
if (p && f_type) {
switch (f_type) {
case 'm': flags_str = retrieve_method_access_string((ut16) flag_value); break;
case 'f': flags_str = retrieve_field_access_string((ut16) flag_value); break;
case 'c': flags_str = retrieve_class_method_access_string((ut16) flag_value); break;
default: flags_str = NULL;
case 'm': flags_str = retrieve_method_access_string((ut16) flag_value); break;
case 'f': flags_str = retrieve_field_access_string((ut16) flag_value); break;
case 'c': flags_str = retrieve_class_method_access_string((ut16) flag_value); break;
default: flags_str = NULL;
}
}
if (flags_str) {
switch (f_type) {
case 'm': r_cons_printf ("Method Access Flags String: "); break;
case 'f': r_cons_printf ("Field Access Flags String: "); break;
case 'c': r_cons_printf ("Class Access Flags String: "); break;
case 'm': r_cons_printf ("Method Access Flags String: "); break;
case 'f': r_cons_printf ("Field Access Flags String: "); break;
case 'c': r_cons_printf ("Class Access Flags String: "); break;
}
r_cons_println (flags_str);
free (flags_str);
@ -1366,18 +1356,18 @@ static int r_cmd_java_handle_flags_str_at (RCore *core, const char *cmd) {
if (p && f_type) {
switch (f_type) {
case 'm': flags_str = retrieve_method_access_string((ut16) flag_value); break;
case 'f': flags_str = retrieve_field_access_string((ut16) flag_value); break;
case 'c': flags_str = retrieve_class_method_access_string((ut16) flag_value); break;
default: flags_str = NULL;
case 'm': flags_str = retrieve_method_access_string((ut16) flag_value); break;
case 'f': flags_str = retrieve_field_access_string((ut16) flag_value); break;
case 'c': flags_str = retrieve_class_method_access_string((ut16) flag_value); break;
default: flags_str = NULL;
}
}
if (flags_str) {
switch (f_type) {
case 'm': r_cons_printf ("Method Access Flags String: "); break;
case 'f': r_cons_printf ("Field Access Flags String: "); break;
case 'c': r_cons_printf ("Class Access Flags String: "); break;
case 'm': r_cons_printf ("Method Access Flags String: "); break;
case 'f': r_cons_printf ("Field Access Flags String: "); break;
case 'c': r_cons_printf ("Class Access Flags String: "); break;
}
r_cons_println (flags_str);
free (flags_str);
@ -1405,20 +1395,16 @@ static char r_cmd_java_is_valid_java_mcf (char b) {
static int r_cmd_java_handle_set_flags (RCore * core, const char * input) {
//#define SET_ACC_FLAGS_ARGS "< c | m | f> <addr> <d | <s <flag value separated by space> >"
const char *p = r_cmd_java_consumetok (input, ' ', -1);
ut64 addr = p && r_cmd_java_is_valid_input_num_value(core, p) ? r_cmd_java_get_input_num_value (core, p) : -1;
ut32 flag_value = -1;
char f_type = '?';
int res = false;
p = r_cmd_java_strtok (p+1, ' ', -1);
ut64 addr = p && r_cmd_java_is_valid_input_num_value (core, p)
? r_cmd_java_get_input_num_value (core, p) : -1;
p = r_cmd_java_strtok (p + 1, ' ', -1);
if (!p || !*p) {
r_cmd_java_print_cmd_help (JAVA_CMDS+SET_ACC_FLAGS_IDX);
return true;
}
f_type = p && *p ? r_cmd_java_is_valid_java_mcf (*(++p)) : 0;
const char f_type = p && *p ? r_cmd_java_is_valid_java_mcf (*(++p)) : '?';
flag_value = r_cmd_java_is_valid_input_num_value(core, p) ? r_cmd_java_get_input_num_value (core, p) : -1;
int flag_value = r_cmd_java_is_valid_input_num_value(core, p) ? r_cmd_java_get_input_num_value (core, p) : -1;
if (flag_value == 16 && f_type == 'f') {
flag_value = -1;
@ -1431,33 +1417,33 @@ static int r_cmd_java_handle_set_flags (RCore * core, const char * input) {
if (flag_value == -1) {
flag_value = r_cmd_java_is_valid_input_num_value (core, p) ? r_cmd_java_get_input_num_value (core, p) : -1;
}
bool res = false;
if (!input) {
eprintf ("[-] r_cmd_java: no address provided .\n");
res = true;
} else if (addr == -1) {
eprintf ("[-] r_cmd_java: no address provided .\n");
res = true;
} else if (!f_type && flag_value == -1) {
} else if (f_type == '?' && flag_value == -1) {
eprintf ("[-] r_cmd_java: no flag type provided .\n");
res = true;
}
if (res) {
r_cmd_java_print_cmd_help (JAVA_CMDS+SET_ACC_FLAGS_IDX);
r_cmd_java_print_cmd_help (JAVA_CMDS + SET_ACC_FLAGS_IDX);
return res;
}
IFDBG r_cons_printf ("Writing to %c to 0x%"PFMT64x", %s.\n", f_type, addr, p);
IFDBG r_cons_printf ("Writing ftype '%c' to 0x%"PFMT64x", %s.\n", f_type, addr, p);
// handling string based access flags (otherwise skip ahead)
// handling string based access flags (otherwise skip ahead)
IFDBG r_cons_printf ("Converting %s to flags\n",p);
if (f_type && flag_value != -1) {
switch (f_type) {
case 'f': flag_value = r_bin_java_calculate_field_access_value (p); break;
case 'm': flag_value = r_bin_java_calculate_method_access_value (p); break;
case 'c': flag_value = r_bin_java_calculate_class_access_value (p); break;
default: flag_value = -1;
case 'f': flag_value = r_bin_java_calculate_field_access_value (p); break;
case 'm': flag_value = r_bin_java_calculate_method_access_value (p); break;
case 'c': flag_value = r_bin_java_calculate_class_access_value (p); break;
default: flag_value = -1;
}
}
IFDBG r_cons_printf ("Current args: (flag_value: 0x%04x addr: 0x%"PFMT64x")\n.", flag_value, addr, res);
@ -1466,7 +1452,7 @@ static int r_cmd_java_handle_set_flags (RCore * core, const char * input) {
IFDBG r_cons_printf ("Writing 0x%04x to 0x%"PFMT64x": %d.", flag_value, addr, res);
} else {
eprintf ("[-] r_cmd_java: invalid flag value or type provided .\n");
r_cmd_java_print_cmd_help (JAVA_CMDS+SET_ACC_FLAGS_IDX);
r_cmd_java_print_cmd_help (JAVA_CMDS + SET_ACC_FLAGS_IDX);
res = true;
}
return res;

1
libr/include/r_anal.h
View File

@ -714,6 +714,7 @@ typedef struct r_anal_t {
int seggrn;
RFlagGetAtAddr flag_get;
REvent *ev;
bool use_ex;
} RAnal;
typedef struct r_anal_hint_t {

35
shlr/java/class.c
View File

@ -2634,6 +2634,7 @@ R_API RBinSymbol *r_bin_java_create_new_symbol_from_ref(RBinJavaCPTypeObj *obj,
return sym;
}
// TODO: vaddr+vsize break things if set
R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
RBinSection *section = NULL;
RList *sections = r_list_newf (free);
@ -2644,8 +2645,15 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
section = R_NEW0 (RBinSection);
if (section) {
section->name = strdup ("constant_pool");
section->size = bin->cp_size;
section->paddr = bin->cp_offset + baddr;
section->size = bin->cp_size;
#if 0
section->vsize = section->size;
section->vaddr = 0x10; // XXX // bin->cp_offset; // + baddr;
#endif
section->vaddr = baddr;
// section->vaddr = section->paddr;
// section->vsize = section->size;
section->perm = R_PERM_R;
section->add = true;
r_list_append (sections, section);
@ -2658,6 +2666,10 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
section->name = strdup ("fields");
section->size = bin->fields_size;
section->paddr = bin->fields_offset + baddr;
#if 0
section->vsize = section->size;
section->vaddr = section->paddr;
#endif
section->perm = R_PERM_R;
section->add = true;
r_list_append (sections, section);
@ -2670,6 +2682,10 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
if (section) {
section->name = r_str_newf ("attrs.%s", fm_type->name);
section->size = fm_type->size - (fm_type->file_offset - fm_type->attr_offset);
#if 0
section->vsize = section->size;
section->vaddr = section->paddr;
#endif
section->paddr = fm_type->attr_offset + baddr;
section->perm = R_PERM_R;
section->add = true;
@ -2682,8 +2698,10 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
section = R_NEW0 (RBinSection);
if (section) {
section->name = strdup ("methods");
section->size = bin->methods_size;
section->paddr = bin->methods_offset + baddr;
section->size = bin->methods_size;
// section->vaddr = section->paddr;
// section->vsize = section->size;
section->perm = R_PERM_RX;
section->add = true;
r_list_append (sections, section);
@ -2696,8 +2714,10 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
if (section) {
section->name = r_str_newf ("attrs.%s", fm_type->name);
section->size = fm_type->size - (fm_type->file_offset - fm_type->attr_offset);
// section->vsize = section->size;
// section->vaddr = section->paddr;
section->paddr = fm_type->attr_offset + baddr;
section->perm = R_PERM_R;
section->perm = R_PERM_R | R_PERM_X;
section->add = true;
r_list_append (sections, section);
}
@ -2708,8 +2728,10 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
section = R_NEW0 (RBinSection);
if (section) {
section->name = strdup ("interfaces");
section->size = bin->interfaces_size;
section->paddr = bin->interfaces_offset + baddr;
section->size = bin->interfaces_size;
// section->vaddr = section->paddr;
// section->vsize = section->size;
section->perm = R_PERM_R;
section->add = true;
r_list_append (sections, section);
@ -2720,8 +2742,11 @@ R_API RList *r_bin_java_get_sections(RBinJavaObj *bin) {
section = R_NEW0 (RBinSection);
if (section) {
section->name = strdup ("attributes");
section->size = bin->attrs_size;
section->paddr = bin->attrs_offset + baddr;
section->size = bin->attrs_size;
// section->vaddr = section->paddr;
// section->vsize = section->size;
section->perm = R_PERM_R;
section->perm = R_PERM_R;
section->add = true;
r_list_append (sections, section);

1
sys/rebuild.sh
View File

@ -43,6 +43,7 @@ RebuildIOSDebug() {
RebuildJava() {
Rebuild shlr/java
Rebuild libr/asm
Rebuild libr/anal
Rebuild libr/bin
Rebuild libr/core
}