portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moving java from shlr to core

Browse source 
Removed unused code and comments.
Removed dead code
Moved print method outside class.c
Moved json method outside class.c
Removed yc_w_refs and i_mref which never worked.
Fixed set_flags method to work as intended.
Fixed various parsing errors.
Fixed many memory leaks.
Fixed "insecure" rz_cons_printf warning.
removed `#define V`, `#define U` and `#define _`
Implemented newshell calls.
Optimized code.
Refactoring rz_bin_java_get_field_offsets
Avoid loading static core plugins when not needed.
Removed useless `if 0`
This commit is contained in:
wargio 2021-02-11 22:14:52 +01:00 committed by Giovanni
parent 041d487de7
commit 8005c480b2
28 changed files with 2803 additions and 3146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
librz/analysis/meson.build
View file

@ -106,6 +106,8 @@ rz_analysis_sources = [
'../asm/arch/h8300/h8300_disas.c',
'../asm/arch/hexagon/hexagon.c',
'../asm/arch/hexagon/hexagon_disas.c',
'../asm/arch/java/code.c',
'../asm/arch/java/ops.c',
'../asm/arch/mcore/mcore.c',
'../asm/arch/msp430/msp430_disas.c',
'../asm/arch/or1k/or1k_disas.c',
@ -182,7 +184,7 @@ rz_analysis = library('rz_analysis', rz_analysis_sources,
rz_hash_dep,
rz_parse_dep,
rz_asm_dep,
java_dep,
rz_bin_dep,
capstone_dep
],
install: true,
@ -209,6 +211,7 @@ pkgconfig_mod.generate(rz_analysis,
'rz_syscall',
'rz_search',
'rz_cons',
'rz_bin',
'rz_flag'
],
description: 'rizin foundation libraries'

22
librz/analysis/p/analysis_java.c
View file

@ -6,9 +6,9 @@
#include <rz_lib.h>
#include <rz_analysis.h>
#include "../../../shlr/java/ops.h"
#include "../../../shlr/java/code.h"
#include "../../../shlr/java/class.h"
#include "../../asm/arch/java/ops.h"
#include "../../asm/arch/java/code.h"
#include "../../bin/format/java/class.h"
#ifdef IFDBG
#define dprintf eprintf
@ -49,21 +49,21 @@ static int java_switch_op(RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, con
if (pos + 8 + 8 > len) {
return op->size;
}
const int min_val = (ut32)(UINT(data, pos + 4));
const int max_val = (ut32)(UINT(data, pos + 8));
const int min_val = (ut32)(rz_read_at_be32(data, pos + 4));
const int max_val = (ut32)(rz_read_at_be32(data, pos + 8));
ut32 default_loc = (ut32)(UINT(data, pos)), cur_case = 0;
ut32 default_loc = (ut32)(rz_read_at_be32(data, pos)), cur_case = 0;
op->switch_op = rz_analysis_switch_op_new(addr, min_val, max_val, default_loc);
pos += 12;
if (max_val > min_val && ((max_val - min_val) < (UT16_MAX / 4))) {
//caseop = rz_analysis_switch_op_add_case(op->switch_op, addr+default_loc, -1, addr+offset);
for (cur_case = 0; cur_case <= max_val - min_val; pos += 4, cur_case++) {
//ut32 value = (ut32)(UINT (data, pos));
//ut32 value = (ut32)(rz_read_at_be32 (data, pos));
if (pos + 4 >= len) {
// switch is too big can't read further
break;
}
int offset = (int)(ut32)(RZ_BIN_JAVA_UINT(data, pos));
st32 offset = (st32)(rz_read_at_be32(data, pos));
rz_analysis_switch_op_add_case(op->switch_op, addr + pos, cur_case + min_val, addr + offset);
}
} else {
@ -261,15 +261,15 @@ static int java_op(RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, const ut8
op->stackptr = -8;
}
if (op->type == RZ_ANALYSIS_OP_TYPE_CJMP) {
op->jump = addr + (short)(USHORT(data, 1));
op->jump = addr + (short)(rz_read_at_be16(data, 1));
op->fail = addr + sz;
IFDBG eprintf("%s jmpto 0x%04" PFMT64x " failto 0x%04" PFMT64x ".\n",
JAVA_OPS[op_byte].name, op->jump, op->fail);
} else if (op->type == RZ_ANALYSIS_OP_TYPE_JMP) {
op->jump = addr + (short)(USHORT(data, 1));
op->jump = addr + (short)(rz_read_at_be16(data, 1));
IFDBG eprintf("%s jmpto 0x%04" PFMT64x ".\n", JAVA_OPS[op_byte].name, op->jump);
} else if ((op->type & RZ_ANALYSIS_OP_TYPE_CALL) == RZ_ANALYSIS_OP_TYPE_CALL) {
op->jump = (int)(short)(USHORT(data, 1));
op->jump = (int)(short)(rz_read_at_be16(data, 1));
op->fail = addr + sz;
//IFDBG eprintf ("%s callto 0x%04x failto 0x%04x.\n", JAVA_OPS[op_byte].name, op->jump, op->fail);
}

65
shlr/java/code.c → librz/asm/arch/java/code.c
View file

@ -11,12 +11,6 @@
#include <stdarg.h>
#include "ops.h"
#include "code.h"
#include "class.h"
#define V if (verbose)
#define DO_THE_DBG 0
#define IFDBG if (DO_THE_DBG)
#ifndef RZ_API
#define RZ_API
@ -39,34 +33,22 @@ typedef struct current_table_switch_t {
static CurrentTableSwitch SWITCH_OP;
static ut64 BYTES_CONSUMED = 0LL;
//static RzBinJavaObj *BIN_OBJ = NULL;
static void init_switch_op(void) {
memset(&SWITCH_OP, 0, sizeof(SWITCH_OP));
}
static int enter_switch_op(ut64 addr, const ut8 *bytes, int len) {
#if 0
int sz = ((BYTES_CONSUMED+1) % 4)
? (1 + 4 - (BYTES_CONSUMED+1) % 4)
: 1; // + (BYTES_CONSUMED+1) % 4;
#endif
if (len < 16) {
return 0;
}
int sz = 4;
IFDBG {
int sz2 = (4 - (addr + 1) % 4) + (addr + 1) % 4;
eprintf("Addr approach: 0x%04x and BYTES_CONSUMED approach: 0x%04" PFMT64x ", BYTES_CONSUMED%%4 = 0x%04x\n",
sz2, BYTES_CONSUMED, sz);
}
init_switch_op();
IN_SWITCH_OP = 1;
SWITCH_OP.addr = addr;
SWITCH_OP.def_jmp = (UINT(bytes, sz));
SWITCH_OP.min_val = (UINT(bytes, sz + 4));
SWITCH_OP.max_val = (UINT(bytes, sz + 8));
SWITCH_OP.def_jmp = (rz_read_at_be32(bytes, sz));
SWITCH_OP.min_val = (rz_read_at_be32(bytes, sz + 4));
SWITCH_OP.max_val = (rz_read_at_be32(bytes, sz + 8));
sz += 12;
return sz;
}
@ -93,18 +75,12 @@ static int update_switch_op(ut64 addr, const ut8 *bytes) {
if (ccase + 1 > SWITCH_OP.max_val) {
IN_SWITCH_OP = 0;
}
IFDBG {
eprintf("Addr approach: 0x%04" PFMT64x
" and BYTES_CONSUMED approach: 0x%04" PFMT64x
"\n",
addr, BYTES_CONSUMED);
}
return update_bytes_consumed(sz);
}
static int handle_switch_op(ut64 addr, const ut8 *bytes, char *output, int outlen) {
int sz = 4;
ut32 jmp = (int)(UINT(bytes, 0)) + SWITCH_OP.addr;
ut32 jmp = (int)(rz_read_at_be32(bytes, 0)) + SWITCH_OP.addr;
int ccase = SWITCH_OP.cur_val + SWITCH_OP.min_val;
snprintf(output, outlen, "case %d: goto 0x%04x", ccase, jmp);
update_switch_op(addr, bytes);
@ -121,17 +97,13 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
return handle_switch_op(addr, bytes, output, outlen);
}
#if 0
IFDBG eprintf ("Handling the following opcode %s expects: %d byte(s), BYTES_CONSUMED: 0x%04"PFMT64x"\n",
JAVA_OPS[idx].name, JAVA_OPS[idx].size, BYTES_CONSUMED);
#endif
switch (op_byte) {
case 0x10: // "bipush"
snprintf(output, outlen, "%s %d", JAVA_OPS[idx].name, (char)bytes[1]);
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
case 0x11:
snprintf(output, outlen, "%s %d", JAVA_OPS[idx].name, (int)USHORT(bytes, 1));
snprintf(output, outlen, "%s %d", JAVA_OPS[idx].name, (int)rz_read_at_be16(bytes, 1));
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
case 0x15: // "iload"
@ -155,18 +127,18 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
snprintf(output, outlen, "%s %s", JAVA_OPS[idx].name, arg);
free(arg);
} else {
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, USHORT(bytes, 1));
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, rz_read_at_be16(bytes, 1));
}
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
case 0x13:
case 0x14:
arg = rz_bin_java_resolve_without_space(obj, (int)USHORT(bytes, 1));
arg = rz_bin_java_resolve_without_space(obj, (int)rz_read_at_be16(bytes, 1));
if (arg) {
snprintf(output, outlen, "%s %s", JAVA_OPS[idx].name, arg);
free(arg);
} else {
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, USHORT(bytes, 1));
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, rz_read_at_be16(bytes, 1));
}
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
@ -193,7 +165,7 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
case 0xa7: // goto
case 0xa8: // jsr
snprintf(output, outlen, "%s 0x%04" PFMT64x, JAVA_OPS[idx].name,
(addr + (short)USHORT(bytes, 1)));
(addr + (short)rz_read_at_be16(bytes, 1)));
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
// XXX - Figure out what constitutes the [<high>] value
@ -209,12 +181,12 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
case 0xb8: // invokestatic
case 0xb9: // invokeinterface
case 0xba: // invokedynamic
arg = rz_bin_java_resolve_without_space(obj, (int)USHORT(bytes, 1));
arg = rz_bin_java_resolve_without_space(obj, (int)rz_read_at_be16(bytes, 1));
if (arg) {
snprintf(output, outlen, "%s %s", JAVA_OPS[idx].name, arg);
free(arg);
} else {
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, USHORT(bytes, 1));
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, rz_read_at_be16(bytes, 1));
}
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
@ -222,12 +194,12 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
case 0xbd: // anewarray
case 0xc0: // checkcast
case 0xc1: // instance of
arg = rz_bin_java_resolve_without_space(obj, (int)USHORT(bytes, 1));
arg = rz_bin_java_resolve_without_space(obj, (int)rz_read_at_be16(bytes, 1));
if (arg) {
snprintf(output, outlen, "%s %s", JAVA_OPS[idx].name, arg);
free(arg);
} else {
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, USHORT(bytes, 1));
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, rz_read_at_be16(bytes, 1));
}
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
@ -235,12 +207,12 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
case 0xb3: // putstatic
case 0xb4: // getfield
case 0xb5: // putfield
arg = rz_bin_java_resolve_with_space(obj, (int)USHORT(bytes, 1));
arg = rz_bin_java_resolve_with_space(obj, (int)rz_read_at_be16(bytes, 1));
if (arg) {
snprintf(output, outlen, "%s %s", JAVA_OPS[idx].name, arg);
free(arg);
} else {
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, USHORT(bytes, 1));
snprintf(output, outlen, "%s #%d", JAVA_OPS[idx].name, rz_read_at_be16(bytes, 1));
}
output[outlen - 1] = 0;
return update_bytes_consumed(JAVA_OPS[idx].size);
@ -265,17 +237,12 @@ RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *b
}
RZ_API void rz_java_new_method(void) {
IFDBG eprintf("Reseting the bytes consumed, they were: 0x%04" PFMT64x ".\n", BYTES_CONSUMED);
// eprintf("Reseting the bytes consumed, they were: 0x%04" PFMT64x ".\n", BYTES_CONSUMED);
init_switch_op();
IN_SWITCH_OP = 0;
BYTES_CONSUMED = 0;
}
RZ_API void U(rz_java_set_obj)(RzBinJavaObj *obj) {
// eprintf ("SET CP (%p) %d\n", cp, n);
//BIN_OBJ = obj;
}
RZ_API int rz_java_disasm(RzBinJavaObj *obj, ut64 addr, const ut8 *bytes, int len, char *output, int outlen) {
//rz_cons_printf ("rz_java_disasm (allowed %d): 0x%02x, 0x%0x.\n", outlen, bytes[0], addr);
return java_print_opcode(obj, addr, bytes[0], bytes, len, output, outlen);

3
shlr/java/code.h → librz/asm/arch/java/code.h
View file

@ -2,7 +2,7 @@
#define _INCLUDE_R_JAVA_H_
#include <rz_types.h>
#include "class.h"
#include "../../bin/format/java/class.h"
typedef struct java_op {
const char *name;
@ -16,7 +16,6 @@ extern struct java_op JAVA_OPS[JAVA_OPS_COUNT];
RZ_API int java_print_opcode(RzBinJavaObj *obj, ut64 addr, int idx, const ut8 *bytes, int len, char *output, int outlen);
RZ_API int rz_java_disasm(RzBinJavaObj *obj, ut64 addr, const ut8 *bytes, int len, char *output, int outlen);
RZ_API int rz_java_assemble(ut64 addr, ut8 *bytes, const char *string);
//RZ_API void rz_java_set_obj(RzBinJavaObj *obj);
RZ_API void rz_java_new_method(void);
#endif

0
shlr/java/ops.c → librz/asm/arch/java/ops.c
View file

0
shlr/java/ops.h → librz/asm/arch/java/ops.h
View file

5
librz/asm/meson.build
View file

@ -111,6 +111,8 @@ rz_asm_sources = [
'arch/hppa/gnu/hppa-dis.c',
#'arch/i4004/i4004dis.c',
#'arch/i8080/i8080dis.c',
'arch/java/code.c',
'arch/java/ops.c',
'arch/lanai/gnu/lanai-dis.c',
'arch/lanai/gnu/lanai-opc.c',
'arch/mips/gnu/mips-dis.c',
@ -224,8 +226,8 @@ rz_asm = library('rz_asm', rz_asm_sources,
rz_syscall_dep,
rz_flag_dep,
rz_parse_dep,
rz_bin_dep,
capstone_dep,
java_dep
],
install: true,
implicit_include_directories: false,
@ -247,6 +249,7 @@ pkgconfig_mod.generate(rz_asm,
'rz_syscall',
'rz_parse',
'rz_flag',
'rz_bin',
'rz_socket'
],
description: 'rizin foundation libraries'

4
librz/asm/p/asm_java.c
View file

@ -6,8 +6,8 @@
#include <rz_asm.h>
#include <rz_core.h>
#include "../../shlr/java/code.h"
#include "../../shlr/java/class.h"
//#include "../../bin/format/java/class.h"
#include "../arch/java/code.h"
static int disassemble(RzAsm *a, RzAsmOp *op, const ut8 *buf, int len) {
RzBinJavaObj *obj = NULL;

2140
shlr/java/class.c → librz/bin/format/java/class.c
View file

File diff suppressed because it is too large Load diff

344
shlr/java/class.h → librz/bin/format/java/class.h
View file

@ -4,45 +4,21 @@
#define _INCLUDE_JAVA_CLASS_H_
#include <rz_types.h>
#undef U
#define U(x) x
#include <rz_list.h>
#include <rz_bin.h>
#include <sdb.h>
#include <rz_util.h>
#define raw_to_float(x, y) ((float)rz_read_at_be32(x, y))
double raw_to_double(const ut8 *raw, ut64 offset);
#if defined(_MSC_VER) && !defined(RZ_API_BIN_ONLY)
#undef RZ_API
#define RZ_API
#endif
#define USHORT(x, y) ((ut16)(x[y + 1] | (x[y] << 8)))
#if 1
#define UINT(x, y) (ut32)(((x[y] & 0xff) << 24) | ((x[y + 1] & 0xff) << 16) | ((x[y + 2] & 0xff) << 8) | (x[y + 3] & 0xff))
#else
static inline ut32 UINT(const ut8 *x, const int y) {
ut32 ret = 0;
ret = (x[y] & 0xff) << 24;
ret |= (x[y + 1] & 0xff) << 16;
ret |= (x[y + 2] & 0xff) << 8;
ret |= (x[y + 3] & 0xff);
return ret;
}
#endif
#define RZ_BIN_JAVA_MAXSTR 256
#define RZ_BIN_JAVA_USHORT(x, y) ((ut16)(((0xff & x[y + 1]) | ((x[y] & 0xff) << 8)) & 0xffff))
#define RZ_BIN_JAVA_UINT(x, y) ((ut32)(((x[y] & 0xff) << 24) | ((x[y + 1] & 0xff) << 16) | ((x[y + 2] & 0xff) << 8) | (x[y + 3] & 0xff)))
#define RZ_BIN_JAVA_FLOAT(x, y) ((float)RZ_BIN_JAVA_UINT(x, y))
#define RZ_BIN_JAVA_LONG(x, y) (((ut64)RZ_BIN_JAVA_UINT(x, y) << 32) | ((ut64)RZ_BIN_JAVA_UINT(x, y + 4) & 0xffffffff))
//#define RZ_BIN_JAVA_DOUBLE(x,y) ((double)RBIN_JAVA_LONG(x,y))
//#define RZ_BIN_JAVA_SWAPUSHORT(x) ((ut16)((x<<8)|((x>>8)&0x00FF)))
#define RZ_BIN_JAVA_DOUBLE(x, y) rbin_java_raw_to_double(x, y)
typedef enum {
RZ_BIN_JAVA_METHOD_ACC_PUBLIC = 0x0001,
RZ_BIN_JAVA_METHOD_ACC_PRIVATE = 0x0002,
@ -62,7 +38,7 @@ typedef enum {
RZ_BIN_JAVA_METHOD_ACC_SYNTHETIC = 0x1000,
RZ_BIN_JAVA_METHOD_ACC_ANNOTATION = 0x2000,
RZ_BIN_JAVA_METHOD_ACC_ENUM = 0x4000
} RZ_BIN_JAVA_METHOD_ACCESS;
} RzBinJavaMethodAccess;
typedef enum {
RZ_BIN_JAVA_FIELD_ACC_PUBLIC = 0x0001,
@ -76,7 +52,7 @@ typedef enum {
RZ_BIN_JAVA_FIELD_ACC_SYNTHETIC = 0x1000,
RZ_BIN_JAVA_FIELD_ACC_ENUM = 0x4000
} RZ_BIN_JAVA_FIELD_ACCESS;
} RzBinJavaFieldAccess;
typedef enum {
RZ_BIN_JAVA_CLASS_ACC_PUBLIC = 0x0001,
@ -97,7 +73,7 @@ typedef enum {
RZ_BIN_JAVA_CLASS_ACC_SYNTHETIC = 0x1000,
RZ_BIN_JAVA_CLASS_ACC_ANNOTATION = 0x2000,
RZ_BIN_JAVA_CLASS_ACC_ENUM = 0x4000
} RZ_BIN_JAVA_CLASS_ACCESS;
} RzBinJavaClassAccess;
typedef struct {
char *str;
@ -116,7 +92,7 @@ typedef enum {
RZ_BIN_JAVA_REF_INVOKESPECIAL = 7,
RZ_BIN_JAVA_REF_NEWINVOKESPECIAL = 8,
RZ_BIN_JAVA_REF_INVOKEINTERFACE = 9
} RZ_BIN_JAVA_REF_TYPE;
} RzBinJavaRefType;
typedef enum {
RZ_BIN_JAVA_CP_NULL = 0,
@ -138,7 +114,7 @@ typedef enum {
RZ_BIN_JAVA_CP_METHODTYPE = 16,
RZ_BIN_JAVA_CP_NOTHIN_17 = 17,
RZ_BIN_JAVA_CP_INVOKEDYNAMIC = 18,
} RZ_BIN_JAVA_CP_TYPE;
} RzBinJavaCPType;
typedef enum {
RZ_BIN_JAVA_STACK_FRAME_IMPLICIT = 0,
@ -149,32 +125,32 @@ typedef enum {
RZ_BIN_JAVA_STACK_FRAME_APPEND,
RZ_BIN_JAVA_STACK_FRAME_FULL_FRAME,
RZ_BIN_JAVA_STACK_FRAME_RESERVED
} RZ_BIN_JAVA_STACK_FRAME_TYPE;
} RzBinJavaStackFrameType;
typedef enum {
RZ_BIN_JAVA_ATTR_TYPE_ANNOTATION_DEFAULT_ATTR = 0,
RZ_BIN_JAVA_ATTR_TYPE_BOOTSTRAP_METHODS_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_CODE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_CONST_VALUE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_DEPRECATED_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_ENCLOSING_METHOD_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_EXCEPTIONS_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_INNER_CLASSES_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_LINE_NUMBER_TABLE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_LOCAL_VARIABLE_TABLE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_LOCAL_VARIABLE_TYPE_TABLE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_RUNTIME_INVISIBLE_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_RUNTIME_VISIBLE_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_RUNTIME_VISIBLE_PARAMETER_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_SIGNATURE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_SOURCE_DEBUG_EXTENTSION_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_SOURCE_FILE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_STACK_MAP_TABLE_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_SYNTHETIC_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_UNKNOWN_ATTR,
RZ_BIN_JAVA_ATTR_TYPE_FAILED_ATTR
} RZ_BIN_JAVA_ATTR_TYPE;
RZ_BIN_JAVA_ATTRIBUTE_ANNOTATION_DEFAULT_ATTR = 0,
RZ_BIN_JAVA_ATTRIBUTE_BOOTSTRAP_METHODS_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_CODE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_CONST_VALUE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_DEPRECATED_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_ENCLOSING_METHOD_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_EXCEPTIONS_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_INNER_CLASSES_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_LINE_NUMBER_TABLE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_LOCAL_VARIABLE_TABLE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_LOCAL_VARIABLE_TYPE_TABLE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATION_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_SIGNATURE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_SOURCE_DEBUG_EXTENTSION_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_SOURCE_FILE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_STACK_MAP_TABLE_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_SYNTHETIC_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_UNKNOWN_ATTR,
RZ_BIN_JAVA_ATTRIBUTE_FAILED_ATTR
} RzBinJavaAttributeType;
typedef enum {
RZ_BIN_JAVA_STACKMAP_TOP = 0,
@ -187,15 +163,15 @@ typedef enum {
RZ_BIN_JAVA_STACKMAP_OBJECT,
RZ_BIN_JAVA_STACKMAP_UNINIT,
RZ_BIN_JAVA_STACKMAP_UNKNOWN
} RZ_BIN_JAVA_STACKMAP_TYPE;
} RzBinJavaStackmapType;
typedef enum {
RZ_BIN_JAVA_FIELD_TYPE_FIELD = 0,
RZ_BIN_JAVA_FIELD_TYPE_METHOD,
RZ_BIN_JAVA_FIELD_TYPE_INTERFACE
} RZ_BIN_JAVA_FIELD_TYPE;
} RzBinJavaFieldType;
typedef struct rz_bin_java_meta {
typedef struct {
ut64 file_offset;
void *type_info;
ut32 ord;
@ -203,48 +179,46 @@ typedef struct rz_bin_java_meta {
/* Class Reference Informations */
//struct rz_bin_R_BIN_JAVA_CP_ant_t;
typedef struct rz_bin_java_class_info_t {
typedef struct {
ut16 name_idx;
} RzBinJavaCPTypeClass;
typedef struct rz_bin_java_fieldref_info_t {
typedef struct {
ut16 class_idx;
ut16 name_and_type_idx;
} RzBinJavaCPTypeFieldRef;
typedef struct rz_bin_java_methodref_info_t {
typedef struct {
ut16 class_idx;
ut16 name_and_type_idx;
} RzBinJavaCPTypeMethodRef;
typedef struct rz_bin_java_interfacemethodref_info_t {
typedef struct {
ut16 class_idx;
ut16 name_and_type_idx;
} RzBinJavaCPTypeInterfaceMethodRef;
typedef struct rz_bin_java_methodhandle_info_t {
typedef struct {
ut8 reference_kind;
ut16 reference_index;
} RzBinJavaCPTypeMethodHandle;
typedef struct rz_bin_java_methodtype_info_t {
typedef struct {
ut16 descriptor_index;
} RzBinJavaCPTypeMethodType;
typedef struct rz_bin_java_invokedynamic_info_t {
typedef struct {
ut16 bootstrap_method_attr_index;
ut16 name_and_type_index;
} RzBinJavaCPTypeInvokeDynamic;
/* Primitive Type Informations */
typedef struct rz_bin_java_string_info_t {
typedef struct {
ut16 string_idx;
} RzBinJavaCPTypeString;
typedef struct rz_bin_java_integer_info_t {
typedef struct {
union {
ut8 raw[4];
ut32 dword;
@ -252,14 +226,14 @@ typedef struct rz_bin_java_integer_info_t {
} RzBinJavaCPTypeInteger;
typedef struct rz_bin_java_float_info_t {
typedef struct {
union {
ut8 raw[4];
ut32 dword;
} bytes;
} RzBinJavaCPTypeFloat;
typedef struct rz_bin_java_long_info_t {
typedef struct {
union {
ut8 raw[8];
ut64 qword;
@ -270,7 +244,7 @@ typedef struct rz_bin_java_long_info_t {
} bytes;
} RzBinJavaCPTypeLong;
typedef struct rz_bin_java_double_info_t {
typedef struct {
union {
ut8 raw[8];
struct {
@ -282,17 +256,17 @@ typedef struct rz_bin_java_double_info_t {
/* Meta-data Info */
typedef struct rz_bin_java_name_and_type_info_t {
typedef struct {
ut16 name_idx;
ut16 descriptor_idx;
} RzBinJavaCPTypeNameAndType;
typedef struct rz_bin_java_utf8_info_t {
typedef struct {
ut16 length;
ut8 *bytes;
} RzBinJavaCPTypeUtf8;
typedef struct rz_bin_java_cp_object_t {
typedef struct {
RzBinJavaMetaInfo *metas;
ut64 file_offset;
ut8 tag;
@ -320,14 +294,15 @@ typedef struct rz_bin_java_cp_object_t {
ut16 idx;
} RzBinJavaCPTypeObj;
typedef struct rz_bin_java_stack_map_frame_t { // attribute StackMap
typedef struct _stackmap_frame { // attribute StackMap
ut64 file_offset;
ut64 size;
ut32 code_offset;
ut8 tag;
ut8 type;
struct rz_bin_java_stack_map_frame_t *p_stack_frame;
struct _stackmap_frame *p_stack_frame;
RzBinJavaMetaInfo *metas;
ut32 offset_delta;
@ -340,11 +315,11 @@ typedef struct rz_bin_java_stack_map_frame_t { // attribute StackMap
} RzBinJavaStackMapFrame;
typedef struct rz_bin_java_source_debugging_extension_attr_t {
typedef struct {
ut8 *debug_extension;
} RzBinJavaSourceDebugExtensionAttr;
typedef struct rz_bin_java_enclosing_method_attr_t {
typedef struct {
ut16 class_idx;
ut16 method_idx;
char *class_name;
@ -352,7 +327,7 @@ typedef struct rz_bin_java_enclosing_method_attr_t {
char *method_descriptor;
} RzBinJavaEnclosingMethodAttr;
typedef struct rz_bin_java_boot_strap_arg_t {
typedef struct {
ut64 file_offset;
ut64 size;
ut16 argument_info_idx;
@ -360,7 +335,7 @@ typedef struct rz_bin_java_boot_strap_arg_t {
RzBinJavaCPTypeObj *argument_info_cp_obj;
} RzBinJavaBootStrapArgument;
typedef struct rz_bin_java_boot_strap_method_t {
typedef struct {
ut64 file_offset;
ut64 size;
ut16 bootstrap_method_ref;
@ -369,7 +344,7 @@ typedef struct rz_bin_java_boot_strap_method_t {
RzList *bootstrap_arguments;
} RzBinJavaBootStrapMethod;
typedef struct rz_bin_java_boot_strap_methods_t {
typedef struct {
ut16 num_bootstrap_methods;
RzList *bootstrap_methods;
} RzBinJavaBootstrapMethodsAttr;
@ -391,13 +366,13 @@ typedef struct {
RzBinJavaCPTypeObj *class_info_cp_obj;
} RzBinJavaClassInfoValue;
typedef struct rz_bin_java_element_value_ary_t {
typedef struct {
ut64 size;
ut32 num_values;
RzList *values;
} RzBinJavaElementValueArray;
typedef struct rz_bin_java_annotation_t {
typedef struct {
ut64 size;
ut16 type_idx;
ut16 num_element_value_pairs;
@ -422,9 +397,9 @@ typedef enum {
RZ_BIN_JAVA_EV_TAG_ANNOTATION = '@',
// RZ_BIN_JAVA_EV_TAG_CLASSNAME = 'L',
RZ_BIN_JAVA_EV_TAG_UNKNOWN = 0xff,
} RZ_BIN_JAVA_EV_TAG;
} RzBinJavaEVTag;
typedef struct rz_bin_java_element_value_t {
typedef struct {
RzBinJavaMetaInfo *metas;
ut64 size;
ut8 tag;
@ -438,7 +413,7 @@ typedef struct rz_bin_java_element_value_t {
} value;
} RzBinJavaElementValue;
typedef struct rz_bin_java_element_value_pair_t {
typedef struct {
ut64 file_offset;
ut64 size;
ut16 element_name_idx;
@ -446,7 +421,7 @@ typedef struct rz_bin_java_element_value_pair_t {
RzBinJavaElementValue *value;
} RzBinJavaElementValuePair;
typedef struct rz_bin_java_annotations_attr_t {
typedef struct {
ut64 size;
ut16 num_annotations;
RzList *annotations;
@ -456,7 +431,7 @@ typedef RzBinJavaAnnotationsArray RzBinJavaRuntimeVisibleAnnotationsAttr;
typedef RzBinJavaAnnotationsArray RzBinJavaRuntimeInvisibleAnnotationsAttr;
typedef RzBinJavaAnnotationsArray RzBinJavaRuntimeParameterAnnotationsArray;
typedef struct rz_bin_java_parameter_annotation_attr_t {
typedef struct {
ut8 num_parameters;
// RzBinJavaRuntimeParameterAnnotationsArray
RzList *parameter_annotations;
@ -464,22 +439,22 @@ typedef struct rz_bin_java_parameter_annotation_attr_t {
typedef RzBinJavaRuntimeVisibleParameterAnnotationsAttr RzBinJavaRuntimeInvisibleParameterAnnotationsAttr;
typedef struct rz_bin_java_parameter_annotations_attr_t {
typedef struct {
RzBinJavaElementValue *default_value;
} RzBinJavaAnnotationDefaultAttr;
typedef struct rz_bin_java_stack_map_table_attr_t { // attribute StackMap
typedef struct { // attribute StackMap
ut32 code_size;
ut32 number_of_entries;
RzList *stack_map_frame_entries;
} RzBinJavaStackMapTableAttr;
typedef struct rz_bin_java_signature_attr_t {
typedef struct {
ut16 signature_idx;
char *signature;
} RzBinJavaSignatureAttr;
typedef struct rz_bin_java_stack_verification_t {
typedef struct {
ut64 file_offset;
ut64 size;
ut8 tag;
@ -490,7 +465,7 @@ typedef struct rz_bin_java_stack_verification_t {
} info;
} RzBinJavaVerificationObj;
typedef struct rz_bin_java_fm_t {
typedef struct {
RzBinJavaMetaInfo *metas;
ut64 size;
char *name;
@ -499,7 +474,7 @@ typedef struct rz_bin_java_fm_t {
char *flags_str;
ut64 file_offset;
RZ_BIN_JAVA_FIELD_TYPE type;
RzBinJavaFieldType type;
ut16 flags;
ut16 name_idx;
ut16 descriptor_idx;
@ -511,7 +486,7 @@ typedef struct rz_bin_java_fm_t {
ut64 method_number;
} RzBinJavaField;
typedef struct rz_bin_java_interface_info_desc_t {
typedef struct {
char *name;
ut64 size;
ut64 file_offset;
@ -519,16 +494,16 @@ typedef struct rz_bin_java_interface_info_desc_t {
RzBinJavaCPTypeObj *cp_class;
} RzBinJavaInterfaceInfo;
typedef struct rz_bin_java_attr_constant_t {
typedef struct {
ut16 constantvalue_idx;
} RzBinJavaConstantValueAttr;
typedef struct rz_bin_java_attr_exceptions_t {
typedef struct {
ut16 number_of_exceptions;
ut16 *exception_idx_table;
} RzBinJavaExceptionsAttr;
typedef struct rz_bin_java_attr_exception_table_entry_t {
typedef struct {
ut64 file_offset;
ut16 start_pc;
ut16 end_pc;
@ -537,7 +512,7 @@ typedef struct rz_bin_java_attr_exception_table_entry_t {
ut64 size;
} RzBinJavaExceptionEntry;
typedef struct rz_bin_java_attr_code_t {
typedef struct {
ut64 file_offset;
ut32 code_offset;
ut16 max_stack;
@ -553,29 +528,29 @@ typedef struct rz_bin_java_attr_code_t {
RzBinJavaStackMapFrame *implicit_frame;
} RzBinJavaCodeAttr;
typedef struct rz_bin_java_attr_inner_classes_t {
typedef struct {
ut16 number_of_classes;
RzList *classes;
} RzBinJavaInnerClassesAttribute;
typedef struct rz_bin_java_attr_source_file_t {
typedef struct {
ut16 sourcefile_idx;
} RzBinJavaSourceFileAttribute;
typedef struct rz_bin_java_line_number_table_t {
typedef struct {
ut64 file_offset;
ut16 start_pc;
ut16 line_number;
ut64 size;
} RzBinJavaLineNumberAttribute;
typedef struct rz_bin_java_attr_linenum_t {
typedef struct {
ut64 file_offset;
ut16 line_number_table_length;
RzList *line_number_table; // RzBinJavaLineNumberTable*
} RzBinJavaLineNumberTableAttribute;
typedef struct rz_bin_java_attr_localvariabletype_t {
typedef struct {
char *name;
char *signature;
@ -588,12 +563,12 @@ typedef struct rz_bin_java_attr_localvariabletype_t {
ut64 size;
} RzBinJavaLocalVariableTypeAttribute;
typedef struct rz_bin_java_attr_localvariable_type_table_t {
typedef struct {
ut16 table_length;
RzList *local_variable_table; // RzBinJavaLocalVariable
} RzBinJavaLocalVariableTypeTableAttribute;
typedef struct rz_bin_java_attr_localvariable_t {
typedef struct {
char *name;
char *descriptor;
@ -606,12 +581,12 @@ typedef struct rz_bin_java_attr_localvariable_t {
ut64 size;
} RzBinJavaLocalVariableAttribute;
typedef struct rz_bin_java_attr_localvariable_table_t {
typedef struct {
ut16 table_length;
RzList *local_variable_table; // RzBinJavaLocalVariable
} RzBinJavaLocalVariableTableAttribute;
typedef struct rz_bin_java_attr_t {
typedef struct {
ut8 *bytes;
ut64 pos;
ut64 size;
@ -650,7 +625,7 @@ typedef struct rz_bin_java_attr_t {
} RzBinJavaAttrInfo;
typedef struct rz_bin_java_attr_classes_t {
typedef struct {
char *name;
char *flags_str;
ut64 file_offset;
@ -663,14 +638,14 @@ typedef struct rz_bin_java_attr_classes_t {
ut64 size;
} RzBinJavaClassesAttribute;
typedef struct rz_bin_java_classfile_t {
typedef struct {
ut8 cafebabe[4];
ut8 minor[2];
ut8 major[2];
ut16 cp_count;
} RzBinJavaClass;
typedef struct rz_bin_java_classfile2_t {
typedef struct {
ut16 access_flags;
char *flags_str;
char *this_class_name;
@ -681,14 +656,14 @@ typedef struct rz_bin_java_classfile2_t {
RzBinJavaAttrInfo *this_class_entrypoint_code_attr;
} RzBinJavaClass2;
typedef struct rz_bin_java_lines_t {
typedef struct {
int count;
int *addr;
int *line;
} RzBinJavaLines;
typedef struct rz_bin_java_obj_t {
struct rz_bin_java_classfile_t cf;
typedef struct {
RzBinJavaClass cf;
RzBinJavaClass2 cf2;
const char *lang;
@ -701,8 +676,10 @@ typedef struct rz_bin_java_obj_t {
ut32 classes_size, classes_count;
ut32 attrs_size, attrs_count;
ut64 loadaddr; // load address that is used to calc actual offset
// when multiple bins are loaded at once
// load address that is used to calc actual offset
// when multiple bins are loaded at once
ut64 loadaddr;
int size;
int calc_size;
char *file;
@ -723,7 +700,6 @@ typedef struct rz_bin_java_obj_t {
ut32 interface_idx;
ut32 attributes_idx;
//ut32 classes_idx; //TODO: when classes list is being used, update this value
int fsym;
int fsymsz;
@ -734,7 +710,6 @@ typedef struct rz_bin_java_obj_t {
RzBinJavaField *entrypoint;
RzBinJavaAttrInfo *entrypoint_code_attr;
//RzList* classes_list; // TODO: Not sure if this is necessary. it would be the inner classes info.
RzList *fields_list;
RzList *methods_list;
RzList *cp_list;
@ -752,8 +727,8 @@ typedef struct rz_bin_java_obj_t {
RzStrConstPool constpool;
} RzBinJavaObj;
RZ_API RzList *U(rz_bin_java_get_interface_names)(RzBinJavaObj *bin);
RZ_API RzBinJavaCPTypeObj *U(rz_bin_java_get_item_from_cp)(RzBinJavaObj *bin, int i);
RZ_API RzList *rz_bin_java_get_interface_names(RzBinJavaObj *bin);
RZ_API RzBinJavaCPTypeObj *rz_bin_java_get_item_from_cp(RzBinJavaObj *bin, int i);
RZ_API RzBinJavaCPTypeObj *rz_bin_java_get_item_from_bin_cp_list(RzBinJavaObj *bin, ut64 idx);
RZ_API ut8 *rz_bin_java_cp_get_idx_bytes(RzBinJavaObj *bin, ut16 idx, ut32 *out_sz);
RZ_API RzList *rz_bin_java_get_lib_names(RzBinJavaObj *bin);
@ -771,7 +746,7 @@ RZ_API RzBinJavaObj *rz_bin_java_new_buf(RzBuffer *buf, ut64 baddr, Sdb *kv);
RZ_API int rz_bin_java_valid_class(const ut8 *buf, ut64 buf_sz);
// Stuff used to manage Java Class File Constant Information
typedef struct rz_bin_java_object_allocs_t {
typedef struct {
RzBinJavaCPTypeObj *(*new_obj)(RzBinJavaObj *bin, ut8 *buffer, ut64 offset);
void (*delete_obj)(void /*RzBinJavaCPTypeObj*/ *obj);
void (*print_summary)(RzBinJavaCPTypeObj *obj);
@ -779,21 +754,20 @@ typedef struct rz_bin_java_object_allocs_t {
char *(*stringify_obj)(RzBinJavaCPTypeObj *obj);
} RzBinJavaCPTypeObjectAllocs;
typedef struct rz_bin_java_attr_allocs_t {
//void (*new_obj) (RzBinJavaObj *bin, RzBinJavaAttrInfo *obj, ut64 offset) ;
typedef struct {
RzBinJavaAttrInfo *(*new_obj)(RzBinJavaObj *bin, ut8 *buffer, ut64 sz, ut64 buf_offset);
void (*delete_obj)(void /*RzBinJavaAttrInfo*/ *obj);
void (*print_summary)(RzBinJavaAttrInfo *obj);
ut64 (*calc_size)(RzBinJavaAttrInfo *obj);
} RzBinJavaAttrInfoObjectAllocs;
typedef struct rz_bin_java_ver_allocs_t {
typedef struct {
void (*new_obj)(RzBinJavaObj *bin, ut32 code_length, ut64 offset);
void (*delete_obj)(void /*RzBinJavaAttrInfo*/ *obj);
void (*print_summary)(RzBinJavaAttrInfo *obj);
} RzBinJavaVerInfoObjectAllocs;
typedef struct rz_bin_java_stack_frame_allocs_t {
typedef struct {
RzBinJavaStackMapFrame *(*new_obj)(RzBinJavaObj *bin, ut64 offset);
void (*delete_obj)(void /* RzBinJavaStackMapFrame*/ *obj);
void (*print_summary)(RzBinJavaStackMapFrame *obj);
@ -805,25 +779,25 @@ typedef struct {
void (*print_summary)(RzBinJavaElementValue *obj);
} RzBinJavaElementValueObjectAllocs;
typedef struct rz_bin_R_BIN_JAVA_CP_ant_meta_t {
typedef struct {
char *name;
ut8 tag;
ut32 len;
RzBinJavaCPTypeObjectAllocs *allocs;
} RzBinJavaCPTypeMetas;
typedef struct rz_bin_java_attr_meta_t {
typedef struct {
char *name;
ut8 type;
RzBinJavaAttrInfoObjectAllocs *allocs;
} RzBinJavaAttrMetas;
typedef struct rz_bin_java_ver_meta_t {
typedef struct {
char *name;
ut8 type;
} RzBinJavaVerificationMetas;
typedef struct rz_bin_java_stack_frame_meta_t {
typedef struct {
char *name;
ut8 type;
RzBinJavaStackMapFrameObjectAllocs *allocs;
@ -840,12 +814,12 @@ typedef struct {
ut8 tag;
} RzBinJavaRefMetas;
typedef struct java_const_value_str_t {
typedef struct {
ut32 len;
char *str;
} _JavaStr;
typedef struct java_const_value_ref_t {
typedef struct {
char *class_name;
char *name;
char *desc;
@ -853,7 +827,7 @@ typedef struct java_const_value_ref_t {
ut8 is_field;
} _JavaRef;
typedef struct java_const_value_t {
typedef struct {
const char *type;
union {
ut8 _null;
@ -868,7 +842,7 @@ typedef struct java_const_value_t {
_JavaStr *_str;
_JavaRef *_ref;
} value;
} ConstJavaValue;
} _ConstJavaValue;
RZ_API ut8 *rz_bin_java_get_attr_buf(RzBinJavaObj *bin, ut64 sz, const ut64 offset, const ut8 *buf, const ut64 len);
RZ_API char *rz_bin_java_get_name_from_cp_item_list(RzList *cp_list, ut64 idx);
@ -947,67 +921,67 @@ RZ_API RzList *rz_bin_java_get_field_definitions(RzBinJavaObj *bin);
RZ_API char *rz_bin_java_get_field_definition(RzBinJavaField *fm_type);
RZ_API RzList *rz_bin_java_get_import_definitions(RzBinJavaObj *bin);
RZ_API RzList *rz_bin_java_get_field_offsets(RzBinJavaObj *bin);
RZ_API RzList *U(rz_bin_java_get_method_offsets)(RzBinJavaObj *bin);
RZ_API RzList *rz_bin_java_get_method_offsets(RzBinJavaObj *bin);
RZ_API ut16 U(rz_bin_java_calculate_method_access_value)(const char *access_flags_str);
RZ_API ut16 U(rz_bin_java_calculate_field_access_value)(const char *access_flags_str);
RZ_API ut16 U(rz_bin_java_calculate_class_access_value)(const char *access_flags_str);
RZ_API ut16 rz_bin_java_calculate_method_access_value(const char *access_flags_str);
RZ_API ut16 rz_bin_java_calculate_field_access_value(const char *access_flags_str);
RZ_API ut16 rz_bin_java_calculate_class_access_value(const char *access_flags_str);
RZ_API RzList *U(retrieve_all_method_access_string_and_value)(void);
RZ_API RzList *U(retrieve_all_field_access_string_and_value)(void);
RZ_API RzList *U(retrieve_all_class_access_string_and_value)(void);
RZ_API RzList *retrieve_all_method_access_string_and_value(void);
RZ_API RzList *retrieve_all_field_access_string_and_value(void);
RZ_API RzList *retrieve_all_class_access_string_and_value(void);
RZ_API char *retrieve_method_access_string(ut16 flags);
RZ_API char *retrieve_field_access_string(ut16 flags);
RZ_API char *retrieve_class_method_access_string(ut16 flags);
RZ_API char *U(rz_bin_java_resolve)(RzBinJavaObj *obj, int idx, ut8 space_bn_name_type);
RZ_API char *rz_bin_java_resolve(RzBinJavaObj *obj, int idx, ut8 space_bn_name_type);
RZ_API char *rz_bin_java_resolve_with_space(RzBinJavaObj *obj, int idx);
RZ_API char *rz_bin_java_resolve_without_space(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API char *U(rz_bin_java_resolve_cp_idx_type)(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API char *U(rz_bin_java_resolve_b64_encode)(RzBinJavaObj *BIN_OBJ, ut16 idx);
RZ_API ut64 U(rz_bin_java_resolve_cp_idx_address)(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API char *U(rz_bin_java_resolve_cp_idx_to_string)(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API int U(rz_bin_java_resolve_cp_idx_print_summary)(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API char *rz_bin_java_resolve_cp_idx_type(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API char *rz_bin_java_resolve_b64_encode(RzBinJavaObj *BIN_OBJ, ut16 idx);
RZ_API ut64 rz_bin_java_resolve_cp_idx_address(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API char *rz_bin_java_resolve_cp_idx_to_string(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API int rz_bin_java_resolve_cp_idx_print_summary(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API struct java_const_value_t *U(rz_bin_java_resolve_to_const_value)(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API void U(rz_bin_java_free_const_value)(struct java_const_value_t *cp_value);
RZ_API _ConstJavaValue *rz_bin_java_resolve_to_const_value(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API void rz_bin_java_free_const_value(_ConstJavaValue *cp_value);
RZ_API char *U(rz_bin_java_get_fcn_name)(RzBinJavaField *fm_type);
RZ_API char *rz_bin_java_get_fcn_name(RzBinJavaField *fm_type);
RZ_API RzList *rz_bin_java_get_args(RzBinJavaField *fm_type);
RZ_API RzList *rz_bin_java_get_ret(RzBinJavaField *fm_type);
RZ_API RzList *U(rz_bin_java_get_args_from_bin)(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API RzList *U(rz_bin_java_get_ret_from_bin)(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API char *U(rz_bin_java_get_fcn_name_from_bin)(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API int U(rz_bin_java_is_method_static)(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API RzList *rz_bin_java_get_args_from_bin(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API RzList *rz_bin_java_get_ret_from_bin(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API char *rz_bin_java_get_fcn_name_from_bin(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API int rz_bin_java_is_method_static(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API ut8 rz_bin_java_does_cp_idx_ref_method(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API ut8 rz_bin_java_does_cp_idx_ref_field(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API int U(rz_bin_java_is_method_protected)(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API int U(rz_bin_java_is_method_private)(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API int rz_bin_java_is_method_protected(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API int rz_bin_java_is_method_private(RzBinJavaObj *bin_obj, ut64 addr);
RZ_API RzBinJavaAttrInfo *rz_bin_java_get_method_code_attribute(const RzBinJavaField *method);
RZ_API char *U(rz_bin_java_get_method_name)(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API bool U(rz_bin_java_print_method_idx_summary)(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API ut32 U(rz_bin_java_get_method_count)(RzBinJavaObj *bin_obj);
RZ_API RzList *U(rz_bin_java_get_method_num_name)(RzBinJavaObj *bin_obj);
RZ_API char *rz_bin_java_get_method_name(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API bool rz_bin_java_print_method_idx_summary(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API ut32 rz_bin_java_get_method_count(RzBinJavaObj *bin_obj);
RZ_API RzList *rz_bin_java_get_method_num_name(RzBinJavaObj *bin_obj);
RZ_API char *U(rz_bin_java_get_field_name)(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API int U(rz_bin_java_print_field_idx_summary)(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API ut32 U(rz_bin_java_get_field_count)(RzBinJavaObj *bin_obj);
RZ_API RzList *U(rz_bin_java_get_field_num_name)(RzBinJavaObj *bin_obj);
RZ_API char *rz_bin_java_get_field_name(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API int rz_bin_java_print_field_idx_summary(RzBinJavaObj *bin_obj, ut32 idx);
RZ_API ut32 rz_bin_java_get_field_count(RzBinJavaObj *bin_obj);
RZ_API RzList *rz_bin_java_get_field_num_name(RzBinJavaObj *bin_obj);
RZ_API RzList *U(rz_bin_java_find_cp_const_by_val)(RzBinJavaObj *bin_obj, const ut8 *bytes, ut32 len, const char t);
RZ_API char U(rz_bin_java_resolve_cp_idx_tag)(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API RzList *rz_bin_java_find_cp_const_by_val(RzBinJavaObj *bin_obj, const ut8 *bytes, ut32 len, const char t);
RZ_API char rz_bin_java_resolve_cp_idx_tag(RzBinJavaObj *BIN_OBJ, int idx);
RZ_API int U(rz_bin_java_integer_cp_set)(RzBinJavaObj *bin, ut16 idx, ut32 val);
RZ_API int U(rz_bin_java_float_cp_set)(RzBinJavaObj *bin, ut16 idx, float val);
RZ_API int U(rz_bin_java_long_cp_set)(RzBinJavaObj *bin, ut16 idx, ut64 val);
RZ_API int U(rz_bin_java_double_cp_set)(RzBinJavaObj *bin, ut16 idx, ut32 val);
RZ_API int U(rz_bin_java_utf8_cp_set)(RzBinJavaObj *bin, ut16 idx, const ut8 *buffer, ut32 len);
RZ_API ut8 *U(rz_bin_java_cp_get_bytes)(ut8 tag, ut32 *out_sz, const ut8 *buf, const ut64 len);
RZ_API ut8 *U(rz_bin_java_cp_idx_get_bytes)(RzBinJavaObj *bin, ut16 idx, ut32 *out_sz);
RZ_API ut32 U(rz_bin_java_cp_get_size)(RzBinJavaObj *bin, ut16 idx);
RZ_API int rz_bin_java_integer_cp_set(RzBinJavaObj *bin, ut16 idx, ut32 val);
RZ_API int rz_bin_java_float_cp_set(RzBinJavaObj *bin, ut16 idx, float val);
RZ_API int rz_bin_java_long_cp_set(RzBinJavaObj *bin, ut16 idx, ut64 val);
RZ_API int rz_bin_java_double_cp_set(RzBinJavaObj *bin, ut16 idx, ut32 val);
RZ_API int rz_bin_java_utf8_cp_set(RzBinJavaObj *bin, ut16 idx, const ut8 *buffer, ut32 len);
RZ_API ut8 *rz_bin_java_cp_get_bytes(ut8 tag, ut32 *out_sz, const ut8 *buf, const ut64 len);
RZ_API ut8 *rz_bin_java_cp_idx_get_bytes(RzBinJavaObj *bin, ut16 idx, ut32 *out_sz);
RZ_API ut32 rz_bin_java_cp_get_size(RzBinJavaObj *bin, ut16 idx);
RZ_API ut64 rz_bin_java_parse_cp_pool(RzBinJavaObj *bin, const ut64 offset, const ut8 *buf, const ut64 len);
RZ_API ut64 rz_bin_java_parse_interfaces(RzBinJavaObj *bin, const ut64 offset, const ut8 *buf, const ut64 len);
@ -1019,25 +993,15 @@ RZ_API void rz_bin_add_import(RzBinJavaObj *bin, RzBinJavaCPTypeObj *cp_obj, con
RZ_API void rz_bin_java_set_imports(RzBinJavaObj *bin);
RZ_API RzList *rz_bin_java_get_imports(RzBinJavaObj *bin);
RZ_API ut64 U(rz_bin_java_get_method_start)(RzBinJavaObj *bin, RzBinJavaField *method);
RZ_API ut64 U(rz_bin_java_get_method_end)(RzBinJavaObj *bin, RzBinJavaField *method);
RZ_API ut64 rz_bin_java_get_method_start(RzBinJavaObj *bin, RzBinJavaField *method);
RZ_API ut64 rz_bin_java_get_method_end(RzBinJavaObj *bin, RzBinJavaField *method);
RZ_API ut8 *rz_bin_java_cp_get_fref_bytes(RzBinJavaObj *bin, ut32 *out_sz, ut8 tag, ut16 cn_idx, ut16 fn_idx, ut16 ft_idx);
RZ_API ut8 *U(rz_bin_java_cp_append_method_ref)(RzBinJavaObj *bin, ut32 *out_sz, ut16 cn_idx, ut16 fn_idx, ut16 ft_idx);
RZ_API ut8 *U(rz_bin_java_cp_append_field_ref)(RzBinJavaObj *bin, ut32 *out_sz, ut16 cn_idx, ut16 fn_idx, ut16 ft_idx);
RZ_API char *U(rz_bin_java_unmangle_without_flags)(const char *name, const char *descriptor);
RZ_API ut8 *rz_bin_java_cp_append_method_ref(RzBinJavaObj *bin, ut32 *out_sz, ut16 cn_idx, ut16 fn_idx, ut16 ft_idx);
RZ_API ut8 *rz_bin_java_cp_append_field_ref(RzBinJavaObj *bin, ut32 *out_sz, ut16 cn_idx, ut16 fn_idx, ut16 ft_idx);
RZ_API char *rz_bin_java_unmangle_without_flags(const char *name, const char *descriptor);
RZ_API char *rz_bin_java_unmangle(const char *flags, const char *name, const char *descriptor);
RZ_API bool rz_bin_java_get_field_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_method_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_import_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_interface_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_fm_type_definition_json(RzBinJavaObj *bin, RzBinJavaField *fm_type, int is_method, PJ *j);
RZ_API bool rz_bin_java_get_field_json_definition(RzBinJavaObj *bin, RzBinJavaField *fm_type, PJ *j);
RZ_API bool rz_bin_java_get_method_json_definition(RzBinJavaObj *bin, RzBinJavaField *fm_type, PJ *j);
RZ_API bool rz_bin_java_get_bin_obj_json(RzBinJavaObj *bin, PJ *j);
RZ_API ut64 rz_bin_java_calc_class_size(ut8 *bytes, ut64 size);
RZ_API int rz_bin_java_valid_class(const ut8 *buf, ut64 buf_sz);
#endif

14
librz/bin/format/java/internals.h Normal file
View file

@ -0,0 +1,14 @@
// SPDX-License-Identifier: Apache-2.0
#ifndef JAVA_INTERNALS_H
#define JAVA_INTERNALS_H
extern RzBinJavaVerificationMetas RZ_BIN_JAVA_VERIFICATION_METAS[];
extern RzBinJavaAccessFlags FIELD_ACCESS_FLAGS[];
extern RzBinJavaAccessFlags METHOD_ACCESS_FLAGS[];
extern RzBinJavaAccessFlags CLASS_ACCESS_FLAGS[];
extern RzBinJavaRefMetas RZ_BIN_JAVA_REF_METAS[];
extern RzBinJavaElementValueMetas RZ_BIN_JAVA_ELEMENT_VALUE_METAS[];
extern RzBinJavaVerificationMetas RZ_BIN_JAVA_VERIFICATION_METAS[];
extern RzBinJavaStackMapFrameMetas RZ_BIN_JAVA_STACK_MAP_FRAME_METAS[];
#endif /* JAVA_INTERNALS_H */

154
librz/bin/format/java/json.c Normal file
View file

@ -0,0 +1,154 @@
// SPDX-License-Identifier: LGPL-3.0-only
#include "json.h"
RZ_API bool rz_bin_java_get_bin_obj_json(RzBinJavaObj *bin, PJ *j) {
rz_return_val_if_fail(bin && j, false);
RzList *classes = rz_bin_java_get_classes(bin);
const RzBinClass *class_ = rz_list_get_n(classes, 0);
pj_o(j);
if (class_) {
int dummy = 0;
RzListIter *iter;
const RzBinClass *class_v = NULL;
// add access flags like in methods
bool is_public = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_PUBLIC) != 0);
bool is_final = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_FINAL) != 0);
bool is_super = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_SUPER) != 0);
bool is_interface = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_INTERFACE) != 0);
bool is_abstract = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_ABSTRACT) != 0);
bool is_synthetic = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_SYNTHETIC) != 0);
bool is_annotation = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_ANNOTATION) != 0);
bool is_enum = ((class_->visibility & RZ_BIN_JAVA_CLASS_ACC_ENUM) != 0);
pj_kN(j, "access_flags", class_->visibility);
pj_kb(j, "is_public", is_public);
pj_kb(j, "is_final", is_final);
pj_kb(j, "is_super", is_super);
pj_kb(j, "is_interface", is_interface);
pj_kb(j, "is_abstract", is_abstract);
pj_kb(j, "is_synthetic", is_synthetic);
pj_kb(j, "is_annotation", is_annotation);
pj_kb(j, "is_enum", is_enum);
pj_ks(j, "name", class_->name ? class_->name : "");
pj_ks(j, "super", class_->super ? class_->super : "");
pj_ka(j, "interfaces");
rz_list_foreach (classes, iter, class_v) {
if (!dummy) {
dummy++;
continue;
}
// enumerate all interface classes and append them to the interfaces
if ((class_v->visibility & RZ_BIN_JAVA_CLASS_ACC_INTERFACE) != 0 && class_v->name) {
pj_s(j, class_v->name);
}
}
pj_end(j);
}
rz_list_free(classes);
pj_k(j, "methods");
if (!rz_bin_java_get_method_json_definitions(bin, j)) {
eprintf("[java] failed to insert method defintions in object\n");
}
pj_k(j, "fields");
if (!rz_bin_java_get_field_json_definitions(bin, j)) {
eprintf("[java] failed to insert field defintions in object\n");
}
pj_k(j, "imports");
if (!rz_bin_java_get_import_json_definitions(bin, j)) {
eprintf("[java] failed to import field defintions in object\n");
}
pj_end(j);
return true;
}
RZ_API bool rz_bin_java_get_import_json_definitions(RzBinJavaObj *bin, PJ *j) {
rz_return_val_if_fail(bin && j, false);
RzList *the_list;
RzListIter *iter = NULL;
char *new_str;
if (!(the_list = rz_bin_java_get_lib_names(bin))) {
return false;
}
pj_a(j);
rz_list_foreach (the_list, iter, new_str) {
char *tmp = new_str;
while (*tmp) {
if (*tmp == '/') {
*tmp = '.';
}
tmp++;
}
pj_s(j, new_str);
}
rz_list_free(the_list);
pj_end(j);
return true;
}
RZ_API bool rz_bin_java_get_interface_json_definitions(RzBinJavaObj *bin, PJ *j) {
rz_return_val_if_fail(bin && j, false);
RzList *the_list;
RzListIter *iter = NULL;
char *new_str;
if (!(the_list = rz_bin_java_get_interface_names(bin))) {
return false;
}
pj_a(j);
rz_list_foreach (the_list, iter, new_str) {
char *tmp = new_str;
while (*tmp) {
if (*tmp == '/') {
*tmp = '.';
}
tmp++;
}
pj_s(j, new_str);
}
rz_list_free(the_list);
pj_end(j);
return true;
}
RZ_API bool rz_bin_java_get_method_json_definitions(RzBinJavaObj *bin, PJ *j) {
rz_return_val_if_fail(bin && j, false);
RzBinJavaField *fm_type = NULL;
RzListIter *iter = NULL;
pj_a(j);
rz_list_foreach (bin->methods_list, iter, fm_type) {
if (!rz_bin_java_get_method_json_definition(bin, fm_type, j)) {
eprintf("[java] failed to insert method defintion in array.\n");
}
}
pj_end(j);
return true;
}
RZ_API bool rz_bin_java_get_field_json_definitions(RzBinJavaObj *bin, PJ *j) {
rz_return_val_if_fail(bin && j, false);
RzBinJavaField *fm_type = NULL;
RzListIter *iter = NULL;
pj_a(j);
rz_list_foreach (bin->fields_list, iter, fm_type) {
if (!rz_bin_java_get_field_json_definition(bin, fm_type, j)) {
eprintf("[java] failed to insert field defintion in array.\n");
}
}
pj_end(j);
return true;
}

16
librz/bin/format/java/json.h Normal file
View file

@ -0,0 +1,16 @@
// SPDX-License-Identifier: Apache-2.0
#ifndef JAVA_JSON_H
#define JAVA_JSON_H
#include "class.h"
RZ_API bool rz_bin_java_get_field_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_method_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_import_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_interface_json_definitions(RzBinJavaObj *bin, PJ *j);
RZ_API bool rz_bin_java_get_fm_type_definition_json(RzBinJavaObj *bin, RzBinJavaField *fm_type, int is_method, PJ *j);
RZ_API bool rz_bin_java_get_field_json_definition(RzBinJavaObj *bin, RzBinJavaField *fm_type, PJ *j);
RZ_API bool rz_bin_java_get_method_json_definition(RzBinJavaObj *bin, RzBinJavaField *fm_type, PJ *j);
RZ_API bool rz_bin_java_get_bin_obj_json(RzBinJavaObj *bin, PJ *j);
#endif /* JAVA_JSON_H */

892
librz/bin/format/java/print.c Normal file
View file

@ -0,0 +1,892 @@
// SPDX-License-Identifier: LGPL-3.0-only
#include "print.h"
#include "internals.h"
extern char *sanitize_string(const char *bytes, ut32 len);
static double custom_pow(ut64 base, int exp) {
ut8 flag = 0;
ut64 res = 1;
if (exp < 0) {
flag = 1;
exp *= -1;
}
while (exp) {
if (exp & 1) {
res *= base;
}
exp >>= 1;
base *= base;
// eprintf("Result: %" PFMT64d ", base: %" PFMT64d ", exp: %d\n", res, base, exp);
}
if (flag == 0) {
return 1.0 * res;
}
return (1.0 / res);
}
double raw_to_double(const ut8 *raw, ut64 offset) {
ut64 bits = rz_read_at_be64(raw, offset);
int s = ((bits >> 63) == 0) ? 1 : -1;
int e = (int)((bits >> 52) & 0x7ffL);
long m = (e == 0) ? (bits & 0xfffffffffffffLL) << 1 : (bits & 0xfffffffffffffLL) | 0x10000000000000LL;
double res = 0.0;
// eprintf("Convert Long to Double: %08" PFMT64x "\n", bits);
if (bits == 0x7ff0000000000000LL) {
return INFINITY;
}
if (bits == 0xfff0000000000000LL) {
return -INFINITY;
}
if (0x7ff0000000000001LL <= bits && bits <= 0x7fffffffffffffffLL) {
return NAN;
}
if (0xfff0000000000001LL <= bits && bits <= 0xffffffffffffffffLL) {
return NAN;
}
res = s * m * custom_pow(2, e - 1075); // XXXX TODO Get double to work correctly here
// eprintf(" High-bytes = %02x %02x %02x %02x\n", raw[0], raw[1], raw[2], raw[3]);
// eprintf(" Low-bytes = %02x %02x %02x %02x\n", raw[4], raw[5], raw[6], raw[7]);
// eprintf("Convert Long to Double s: %d, m: 0x%08lx, e: 0x%08x, res: %f\n", s, m, e, res);
return res;
}
RZ_API void rz_bin_java_print_utf8_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* Utf8.\n");
return;
}
char *str = sanitize_string((const char *)obj->info.cp_utf8.bytes, obj->info.cp_utf8.length);
printf("UTF8 ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" length = %d\n", obj->info.cp_utf8.length);
printf(" utf8 = %s\n", str);
free(str);
}
RZ_API void rz_bin_java_print_attr_summary(RzBinJavaAttrInfo *attr) {
if (attr == NULL) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *.\n");
return;
}
((RzBinJavaAttrMetas *)attr->metas->type_info)->allocs->print_summary(attr);
}
RZ_API void rz_bin_java_print_source_debug_attr_summary(RzBinJavaAttrInfo *attr) {
ut32 i = 0;
if (attr == NULL) {
printf("Attempting to print an invalid RzBinJavaSourceDebugExtensionAttr *.\n");
return;
}
printf("Source Debug Extension Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Extension Length: %d\n", attr->length);
printf(" Source Debug Extension value: \n");
for (i = 0; i < attr->length; i++) {
printf("%c", attr->info.debug_extensions.debug_extension[i]);
}
printf("\n Source Debug Extension End\n");
}
RZ_API void rz_bin_java_print_unknown_attr_summary(RzBinJavaAttrInfo *attr) {
if (attr == NULL) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *Unknown.\n");
return;
}
printf("Unknown Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
}
RZ_API void rz_bin_java_print_code_exceptions_attr_summary(RzBinJavaExceptionEntry *exc_entry) {
if (exc_entry == NULL) {
printf("Attempting to print an invalid RzBinJavaExceptionEntry *.\n");
return;
}
printf(" Exception Table Entry Information\n");
printf(" offset: 0x%08" PFMT64x "\n", exc_entry->file_offset);
printf(" catch_type: %d\n", exc_entry->catch_type);
printf(" start_pc: 0x%04x\n", exc_entry->start_pc);
printf(" end_pc: 0x%04x\n", exc_entry->end_pc);
printf(" handler_pc: 0x%04x\n", exc_entry->handler_pc);
}
// End free Constant Pool types
RZ_API void rz_bin_java_print_code_attr_summary(RzBinJavaAttrInfo *attr) {
RzListIter *iter = NULL, *iter_tmp = NULL;
RzBinJavaExceptionEntry *exc_entry = NULL;
RzBinJavaAttrInfo *_attr = NULL;
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *Code.\n");
return;
}
printf("Code Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d, Attribute Count: %d\n", attr->length, attr->info.code_attr.attributes_count);
printf(" Max Stack: %d\n", attr->info.code_attr.max_stack);
printf(" Max Locals: %d\n", attr->info.code_attr.max_locals);
printf(" Code Length: %d\n", attr->info.code_attr.code_length);
printf(" Code At Offset: 0x%08" PFMT64x "\n", (ut64)attr->info.code_attr.code_offset);
printf("Code Attribute Exception Table Information:\n");
printf(" Exception Table Length: %d\n", attr->info.code_attr.exception_table_length);
if (attr->info.code_attr.exception_table) {
// Delete the attr entries
rz_list_foreach_safe (attr->info.code_attr.exception_table, iter, iter_tmp, exc_entry) {
rz_bin_java_print_code_exceptions_attr_summary(exc_entry);
}
}
printf(" Implicit Method Stack Frame:\n");
rz_bin_java_print_stack_map_frame_summary(attr->info.code_attr.implicit_frame);
printf("Code Attribute Attributes Information:\n");
if (attr->info.code_attr.attributes && attr->info.code_attr.attributes_count > 0) {
printf(" Code Attribute Attributes Count: %d\n", attr->info.code_attr.attributes_count);
rz_list_foreach_safe (attr->info.code_attr.attributes, iter, iter_tmp, _attr) {
rz_bin_java_print_attr_summary(_attr);
}
}
}
RZ_API void rz_bin_java_print_constant_value_attr_summary(RzBinJavaAttrInfo *attr) {
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *ConstantValue.\n");
return;
}
printf("Constant Value Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" ConstantValue Index: %d\n", attr->info.constant_value_attr.constantvalue_idx);
}
RZ_API void rz_bin_java_print_deprecated_attr_summary(RzBinJavaAttrInfo *attr) {
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *Deperecated.\n");
return;
}
printf("Deperecated Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
}
RZ_API void rz_bin_java_print_enclosing_methods_attr_summary(RzBinJavaAttrInfo *attr) {
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *Deperecated.\n");
return;
}
printf("Enclosing Method Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" Class Info Index : 0x%02x\n", attr->info.enclosing_method_attr.class_idx);
printf(" Method Name and Type Index : 0x%02x\n", attr->info.enclosing_method_attr.method_idx);
printf(" Class Name : %s\n", attr->info.enclosing_method_attr.class_name);
printf(" Method Name and Desc : %s %s\n", attr->info.enclosing_method_attr.method_name, attr->info.enclosing_method_attr.method_descriptor);
}
RZ_API void rz_bin_java_print_exceptions_attr_summary(RzBinJavaAttrInfo *attr) {
ut32 i = 0;
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *Exceptions.\n");
return;
}
printf("Exceptions Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
for (i = 0; i < attr->info.exceptions_attr.number_of_exceptions; i++) {
printf(" Exceptions Attribute Index[%d]: %d\n", i, attr->info.exceptions_attr.exception_idx_table[i]);
}
}
RZ_API void rz_bin_java_print_classes_attr_summary(RzBinJavaClassesAttribute *icattr) {
if (!icattr) {
printf("Attempting to print an invalid RzBinJavaClassesAttribute* (InnerClasses element).\n");
return;
}
printf(" Inner Classes Class Attribute Offset: 0x%08" PFMT64x "\n", icattr->file_offset);
printf(" Inner Classes Class Attribute Class Name (%d): %s\n", icattr->inner_name_idx, icattr->name);
printf(" Inner Classes Class Attribute Class inner_class_info_idx: %d\n", icattr->inner_class_info_idx);
printf(" Inner Classes Class Attribute Class inner_class_access_flags: 0x%02x %s\n", icattr->inner_class_access_flags, icattr->flags_str);
printf(" Inner Classes Class Attribute Class outer_class_info_idx: %d\n", icattr->outer_class_info_idx);
printf(" Inner Classes Class Field Information:\n");
rz_bin_java_print_field_summary(icattr->clint_field);
printf(" Inner Classes Class Field Information:\n");
rz_bin_java_print_field_summary(icattr->clint_field);
printf(" Inner Classes Class Attr Info Information:\n");
rz_bin_java_print_attr_summary(icattr->clint_attr);
}
RZ_API void rz_bin_java_print_inner_classes_attr_summary(RzBinJavaAttrInfo *attr) {
RzBinJavaClassesAttribute *icattr;
RzListIter *iter, *iter_tmp;
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *InnerClasses.\n");
return;
}
printf("Inner Classes Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_list_foreach_safe (attr->info.inner_classes_attr.classes, iter, iter_tmp, icattr) {
rz_bin_java_print_classes_attr_summary(icattr);
}
}
RZ_API void rz_bin_java_print_line_number_attr_summary(RzBinJavaLineNumberAttribute *lnattr) {
if (!lnattr) {
printf("Attempting to print an invalid RzBinJavaLineNumberAttribute *.\n");
return;
}
printf(" Line Number Attribute Offset: 0x%08" PFMT64x "\n", lnattr->file_offset);
printf(" Line Number Attribute StartPC: %d\n", lnattr->start_pc);
printf(" Line Number Attribute LineNumber: %d\n", lnattr->line_number);
}
RZ_API void rz_bin_java_print_line_number_table_attr_summary(RzBinJavaAttrInfo *attr) {
RzBinJavaLineNumberAttribute *lnattr;
RzListIter *iter, *iter_tmp;
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *LineNumberTable.\n");
return;
}
printf("Line Number Table Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_list_foreach_safe (attr->info.line_number_table_attr.line_number_table, iter, iter_tmp, lnattr) {
rz_bin_java_print_line_number_attr_summary(lnattr);
}
}
RZ_API void rz_bin_java_print_local_variable_attr_summary(RzBinJavaLocalVariableAttribute *lvattr) {
if (!lvattr) {
printf("Attempting to print an invalid RzBinJavaLocalVariableAttribute *.\n");
return;
}
printf(" Local Variable Attribute offset: 0x%08" PFMT64x "\n", lvattr->file_offset);
printf(" Local Variable Attribute start_pc: %d\n", lvattr->start_pc);
printf(" Local Variable Attribute Length: %d\n", lvattr->length);
printf(" Local Variable Attribute name_idx: %d\n", lvattr->name_idx);
printf(" Local Variable Attribute name: %s\n", lvattr->name);
printf(" Local Variable Attribute descriptor_idx: %d\n", lvattr->descriptor_idx);
printf(" Local Variable Attribute descriptor: %s\n", lvattr->descriptor);
printf(" Local Variable Attribute index: %d\n", lvattr->index);
}
RZ_API void rz_bin_java_print_local_variable_table_attr_summary(RzBinJavaAttrInfo *attr) {
RzBinJavaLocalVariableAttribute *lvattr;
RzListIter *iter, *iter_tmp;
if (attr == NULL) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *LocalVariableTable.\n");
return;
}
printf("Local Variable Table Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_list_foreach_safe (attr->info.local_variable_table_attr.local_variable_table, iter, iter_tmp, lvattr) {
rz_bin_java_print_local_variable_attr_summary(lvattr);
}
}
RZ_API void rz_bin_java_print_local_variable_type_attr_summary(RzBinJavaLocalVariableTypeAttribute *lvattr) {
if (!lvattr) {
printf("Attempting to print an invalid RzBinJavaLocalVariableTypeAttribute *.\n");
return;
}
printf(" Local Variable Type Attribute offset: 0x%08" PFMT64x "\n", lvattr->file_offset);
printf(" Local Variable Type Attribute start_pc: %d\n", lvattr->start_pc);
printf(" Local Variable Type Attribute Length: %d\n", lvattr->length);
printf(" Local Variable Type Attribute name_idx: %d\n", lvattr->name_idx);
printf(" Local Variable Type Attribute name: %s\n", lvattr->name);
printf(" Local Variable Type Attribute signature_idx: %d\n", lvattr->signature_idx);
printf(" Local Variable Type Attribute signature: %s\n", lvattr->signature);
printf(" Local Variable Type Attribute index: %d\n", lvattr->index);
}
RZ_API void rz_bin_java_print_local_variable_type_table_attr_summary(RzBinJavaAttrInfo *attr) {
RzBinJavaLocalVariableTypeAttribute *lvtattr;
RzListIter *iter, *iter_tmp;
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *LocalVariableTable.\n");
return;
}
printf("Local Variable Type Table Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_list_foreach_safe (attr->info.local_variable_type_table_attr.local_variable_table, iter, iter_tmp, lvtattr) {
rz_bin_java_print_local_variable_type_attr_summary(lvtattr);
}
}
RZ_API void rz_bin_java_print_signature_attr_summary(RzBinJavaAttrInfo *attr) {
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *SignatureAttr.\n");
return;
}
printf("Signature Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" Signature UTF8 Index: %d\n", attr->info.signature_attr.signature_idx);
printf(" Signature string: %s\n", attr->info.signature_attr.signature);
}
RZ_API void rz_bin_java_print_source_code_file_attr_summary(RzBinJavaAttrInfo *attr) {
if (!attr) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *SourceFile.\n");
return;
}
printf("Source File Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" Source File Index: %d\n", attr->info.source_file_attr.sourcefile_idx);
}
RZ_API void rz_bin_java_print_synthetic_attr_summary(RzBinJavaAttrInfo *attr) {
if (attr == NULL) {
printf("Attempting to print an invalid RzBinJavaAttrInfo *Synthetic.\n");
return;
}
printf("Synthetic Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" Attribute Index: %d\n", attr->info.source_file_attr.sourcefile_idx);
}
RZ_API void rz_bin_java_print_stack_map_table_attr_summary(RzBinJavaAttrInfo *attr) {
RzListIter *iter, *iter_tmp;
RzList *ptrList;
RzBinJavaStackMapFrame *frame;
if (attr == NULL) {
printf("Attempting to print an invalid RzBinJavaStackMapTableAttr* .\n");
return;
}
printf("StackMapTable Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" StackMapTable Method Code Size: 0x%08x\n", attr->info.stack_map_table_attr.code_size);
printf(" StackMapTable Frame Entries: 0x%08x\n", attr->info.stack_map_table_attr.number_of_entries);
printf(" StackMapTable Frames:\n");
ptrList = attr->info.stack_map_table_attr.stack_map_frame_entries;
if (ptrList) {
rz_list_foreach_safe (ptrList, iter, iter_tmp, frame) {
rz_bin_java_print_stack_map_frame_summary(frame);
}
}
}
RZ_API void rz_bin_java_print_stack_map_frame_summary(RzBinJavaStackMapFrame *obj) {
RzListIter *iter, *iter_tmp;
RzList *ptrList;
RzBinJavaVerificationObj *ver_obj;
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaStackMapFrame* .\n");
return;
}
printf("Stack Map Frame Information\n");
printf(" Tag Value = 0x%02x Name: %s\n", obj->tag, ((RzBinJavaStackMapFrameMetas *)obj->metas->type_info)->name);
printf(" Offset: 0x%08" PFMT64x "\n", obj->file_offset);
printf(" Local Variable Count = 0x%04x\n", obj->number_of_locals);
printf(" Stack Items Count = 0x%04x\n", obj->number_of_stack_items);
printf(" Local Variables:\n");
ptrList = obj->local_items;
rz_list_foreach_safe (ptrList, iter, iter_tmp, ver_obj) {
rz_bin_java_print_verification_info_summary(ver_obj);
}
printf(" Stack Items:\n");
ptrList = obj->stack_items;
rz_list_foreach_safe (ptrList, iter, iter_tmp, ver_obj) {
rz_bin_java_print_verification_info_summary(ver_obj);
}
}
RZ_API void rz_bin_java_print_verification_info_summary(RzBinJavaVerificationObj *obj) {
ut8 tag_value = RZ_BIN_JAVA_STACKMAP_UNKNOWN;
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaVerificationObj* .\n");
return;
}
if (obj->tag < RZ_BIN_JAVA_STACKMAP_UNKNOWN) {
tag_value = obj->tag;
}
printf("Verification Information\n");
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Tag Value = 0x%02x\n", obj->tag);
printf(" Name = %s\n", RZ_BIN_JAVA_VERIFICATION_METAS[tag_value].name);
if (obj->tag == RZ_BIN_JAVA_STACKMAP_OBJECT) {
printf(" Object Constant Pool Index = 0x%x\n", obj->info.obj_val_cp_idx);
} else if (obj->tag == RZ_BIN_JAVA_STACKMAP_UNINIT) {
printf(" Uninitialized Object offset in code = 0x%x\n", obj->info.uninit_offset);
}
}
RZ_API void rz_bin_java_print_field_summary(RzBinJavaField *field) {
RzBinJavaAttrInfo *attr;
RzListIter *iter, *iter_tmp;
if (field) {
if (field->type == RZ_BIN_JAVA_FIELD_TYPE_METHOD) {
rz_bin_java_print_method_summary(field);
} else {
#if 0
rz_bin_java_print_interface_summary (field);
return;
} * /
#endif
printf("Field Summary Information:\n");
printf(" File Offset: 0x%08" PFMT64x "\n", field->file_offset);
printf(" Name Index: %d (%s)\n", field->name_idx, field->name);
printf(" Descriptor Index: %d (%s)\n", field->descriptor_idx, field->descriptor);
printf(" Access Flags: 0x%02x (%s)\n", field->flags, field->flags_str);
printf(" Field Attributes Count: %d\n", field->attr_count);
printf(" Field Attributes:\n");
rz_list_foreach_safe (field->attributes, iter, iter_tmp, attr) {
rz_bin_java_print_attr_summary(attr);
}
}
} else {
printf("Attempting to print an invalid RzBinJavaField* Field.\n");
}
}
RZ_API void rz_bin_java_print_method_summary(RzBinJavaField *field) {
RzBinJavaAttrInfo *attr;
RzListIter *iter, *iter_tmp;
if (field == NULL) {
printf("Attempting to print an invalid RzBinJavaField* Method.\n");
return;
}
printf("Method Summary Information:\n");
printf(" File Offset: 0x%08" PFMT64x "\n", field->file_offset);
printf(" Name Index: %d (%s)\n", field->name_idx, field->name);
printf(" Descriptor Index: %d (%s)\n", field->descriptor_idx, field->descriptor);
printf(" Access Flags: 0x%02x (%s)\n", field->flags, field->flags_str);
printf(" Method Attributes Count: %d\n", field->attr_count);
printf(" Method Attributes:\n");
rz_list_foreach_safe (field->attributes, iter, iter_tmp, attr) {
rz_bin_java_print_attr_summary(attr);
}
}
RZ_API void rz_bin_java_print_interfacemethodref_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* InterfaceMethodRef.\n");
return;
}
printf("InterfaceMethodRef ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Class Index = %d\n", obj->info.cp_interface.class_idx);
printf(" Name and type Index = %d\n", obj->info.cp_interface.name_and_type_idx);
}
RZ_API void rz_bin_java_print_methodhandle_cp_summary(RzBinJavaCPTypeObj *obj) {
ut8 ref_kind;
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* RzBinJavaCPTypeMethodHandle.\n");
return;
}
ref_kind = obj->info.cp_method_handle.reference_kind;
printf("MethodHandle ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Reference Kind = (0x%02x) %s\n", ref_kind, RZ_BIN_JAVA_REF_METAS[ref_kind].name);
printf(" Reference Index = %d\n", obj->info.cp_method_handle.reference_index);
}
RZ_API void rz_bin_java_print_methodtype_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* RzBinJavaCPTypeMethodType.\n");
return;
}
printf("MethodType ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Descriptor Index = 0x%02x\n", obj->info.cp_method_type.descriptor_index);
}
RZ_API void rz_bin_java_print_invokedynamic_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* RzBinJavaCPTypeInvokeDynamic.\n");
return;
}
printf("InvokeDynamic ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Bootstrap Method Attr Index = (0x%02x)\n", obj->info.cp_invoke_dynamic.bootstrap_method_attr_index);
printf(" Bootstrap Name and Type Index = (0x%02x)\n", obj->info.cp_invoke_dynamic.name_and_type_index);
}
RZ_API void rz_bin_java_print_methodref_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* MethodRef.\n");
return;
}
printf("MethodRef ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Class Index = %d\n", obj->info.cp_method.class_idx);
printf(" Name and type Index = %d\n", obj->info.cp_method.name_and_type_idx);
}
RZ_API void rz_bin_java_print_fieldref_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* FieldRef.\n");
return;
}
printf("FieldRef ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Class Index = %d\n", obj->info.cp_field.class_idx);
printf(" Name and type Index = %d\n", obj->info.cp_field.name_and_type_idx);
}
RZ_API void rz_bin_java_print_classref_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* ClassRef.\n");
return;
}
printf("ClassRef ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Name Index = %d\n", obj->info.cp_class.name_idx);
}
RZ_API void rz_bin_java_print_string_cp_summary(RzBinJavaCPTypeObj *obj) {
if (!obj) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* String.\n");
return;
}
printf("String ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" String Index = %d\n", obj->info.cp_string.string_idx);
}
RZ_API void rz_bin_java_print_integer_cp_summary(RzBinJavaCPTypeObj *obj) {
ut8 *b = NULL;
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* Integer.\n");
return;
}
b = obj->info.cp_integer.bytes.raw;
printf("Integer ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" bytes = %02x %02x %02x %02x\n", b[0], b[1], b[2], b[3]);
printf(" integer = %d\n", rz_read_at_be32(obj->info.cp_integer.bytes.raw, 0));
}
RZ_API void rz_bin_java_print_float_cp_summary(RzBinJavaCPTypeObj *obj) {
ut8 *b = NULL;
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* Double.\n");
return;
}
b = obj->info.cp_float.bytes.raw;
printf("Float ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" Bytes = %02x %02x %02x %02x\n", b[0], b[1], b[2], b[3]);
printf(" Float = %f\n", raw_to_float(obj->info.cp_float.bytes.raw, 0));
}
RZ_API void rz_bin_java_print_long_cp_summary(RzBinJavaCPTypeObj *obj) {
ut8 *b = NULL;
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* Long.\n");
return;
}
b = obj->info.cp_long.bytes.raw;
printf("Long ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" High-Bytes = %02x %02x %02x %02x\n", b[0], b[1], b[2], b[3]);
printf(" Low-Bytes = %02x %02x %02x %02x\n", b[4], b[5], b[6], b[7]);
printf(" Long = %08" PFMT64x "\n", rz_read_at_be64(obj->info.cp_long.bytes.raw, 0));
}
RZ_API void rz_bin_java_print_double_cp_summary(RzBinJavaCPTypeObj *obj) {
ut8 *b = NULL;
if (!obj) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* Double.\n");
return;
}
b = obj->info.cp_double.bytes.raw;
printf("Double ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" High-Bytes = %02x %02x %02x %02x\n", b[0], b[1], b[2], b[3]);
printf(" Low-Bytes = %02x %02x %02x %02x\n", b[4], b[5], b[6], b[7]);
printf(" Double = %f\n", raw_to_double(obj->info.cp_double.bytes.raw, 0));
}
RZ_API void rz_bin_java_print_name_and_type_cp_summary(RzBinJavaCPTypeObj *obj) {
if (obj == NULL) {
printf("Attempting to print an invalid RzBinJavaCPTypeObj* Name_And_Type.\n");
return;
}
printf("Name_And_Type ConstantPool Type (%d) ", obj->metas->ord);
printf(" Offset: 0x%08" PFMT64x "", obj->file_offset);
printf(" name_idx = (%d)\n", obj->info.cp_name_and_type.name_idx);
printf(" descriptor_idx = (%d)\n", obj->info.cp_name_and_type.descriptor_idx);
}
RZ_API void rz_bin_java_print_null_cp_summary(RzBinJavaCPTypeObj *obj) {
printf("Unknown ConstantPool Type Tag: 0x%04x .\n", obj->tag);
}
RZ_API void rz_bin_java_print_unknown_cp_summary(RzBinJavaCPTypeObj *obj) {
printf("NULL ConstantPool Type.\n");
}
RZ_API void rz_bin_java_print_element_pair_summary(RzBinJavaElementValuePair *evp) {
if (!evp) {
printf("Attempting to print an invalid RzBinJavaElementValuePair *pair.\n");
return;
}
printf("Element Value Pair information:\n");
printf(" EV Pair File Offset: 0x%08" PFMT64x "\n", evp->file_offset);
printf(" EV Pair Element Name index: 0x%02x\n", evp->element_name_idx);
printf(" EV Pair Element Name: %s\n", evp->name);
printf(" EV Pair Element Value:\n");
rz_bin_java_print_element_value_summary(evp->value);
}
RZ_API void rz_bin_java_print_element_value_summary(RzBinJavaElementValue *element_value) {
RzBinJavaCPTypeObj *obj;
RzBinJavaElementValue *ev_element = NULL;
RzListIter *iter = NULL, *iter_tmp = NULL;
char *name;
if (!element_value) {
printf("Attempting to print an invalid RzBinJavaElementValuePair *pair.\n");
return;
}
name = ((RzBinJavaElementValueMetas *)element_value->metas->type_info)->name;
printf("Element Value information:\n");
printf(" EV Pair File Offset: 0x%08" PFMT64x "\n", element_value->file_offset);
printf(" EV Value Type (%d): %s\n", element_value->tag, name);
switch (element_value->tag) {
case RZ_BIN_JAVA_EV_TAG_BYTE:
case RZ_BIN_JAVA_EV_TAG_CHAR:
case RZ_BIN_JAVA_EV_TAG_DOUBLE:
case RZ_BIN_JAVA_EV_TAG_FLOAT:
case RZ_BIN_JAVA_EV_TAG_INT:
case RZ_BIN_JAVA_EV_TAG_LONG:
case RZ_BIN_JAVA_EV_TAG_SHORT:
case RZ_BIN_JAVA_EV_TAG_BOOLEAN:
case RZ_BIN_JAVA_EV_TAG_STRING:
printf(" EV Value Constant Value index: 0x%02x\n", element_value->value.const_value.const_value_idx);
printf(" EV Value Constant Value Information:\n");
obj = element_value->value.const_value.const_value_cp_obj;
if (obj && obj->metas && obj->metas->type_info) {
((RzBinJavaCPTypeMetas *)obj->metas->type_info)->allocs->print_summary(obj);
}
break;
case RZ_BIN_JAVA_EV_TAG_ENUM:
printf(" EV Value Enum Constant Value Const Name Index: 0x%02x\n", element_value->value.enum_const_value.const_name_idx);
printf(" EV Value Enum Constant Value Type Name Index: 0x%02x\n", element_value->value.enum_const_value.type_name_idx);
printf(" EV Value Enum Constant Value Const CP Information:\n");
obj = element_value->value.enum_const_value.const_name_cp_obj;
if (obj && obj->metas && obj->metas->type_info) {
((RzBinJavaCPTypeMetas *)obj->metas->type_info)->allocs->print_summary(obj);
}
printf(" EV Value Enum Constant Value Type CP Information:\n");
obj = element_value->value.enum_const_value.type_name_cp_obj;
if (obj && obj->metas && obj->metas->type_info) {
((RzBinJavaCPTypeMetas *)obj->metas->type_info)->allocs->print_summary(obj);
}
break;
case RZ_BIN_JAVA_EV_TAG_CLASS:
printf(" EV Value Class Info Index: 0x%02x\n", element_value->value.class_value.class_info_idx);
printf(" EV Value Class Info CP Information:\n");
obj = element_value->value.class_value.class_info_cp_obj;
if (obj && obj->metas && obj->metas->type_info) {
((RzBinJavaCPTypeMetas *)obj->metas->type_info)->allocs->print_summary(obj);
}
break;
case RZ_BIN_JAVA_EV_TAG_ARRAY:
printf(" EV Value Array Value Number of Values: 0x%04x\n", element_value->value.array_value.num_values);
printf(" EV Value Array Values\n");
rz_list_foreach_safe (element_value->value.array_value.values, iter, iter_tmp, ev_element) {
rz_bin_java_print_element_value_summary(ev_element);
}
break;
case RZ_BIN_JAVA_EV_TAG_ANNOTATION:
printf(" EV Annotation Information:\n");
rz_bin_java_print_annotation_summary(&element_value->value.annotation_value);
break;
default:
// printf unable to handle tag
break;
}
}
RZ_API void rz_bin_java_print_annotation_summary(RzBinJavaAnnotation *annotation) {
RzListIter *iter = NULL, *iter_tmp = NULL;
RzBinJavaElementValuePair *evp = NULL;
if (!annotation) {
// TODO printf invalid annotation
return;
}
printf(" Annotation Type Index: 0x%02x\n", annotation->type_idx);
printf(" Annotation Number of EV Pairs: 0x%04x\n", annotation->num_element_value_pairs);
printf(" Annotation EV Pair Values:\n");
if (annotation->element_value_pairs) {
rz_list_foreach_safe (annotation->element_value_pairs, iter, iter_tmp, evp) {
rz_bin_java_print_element_pair_summary(evp);
}
}
}
RZ_API void rz_bin_java_print_bootstrap_method_argument_summary(RzBinJavaBootStrapArgument *bsm_arg) {
if (!bsm_arg) {
printf("Attempting to print an invalid RzBinJavaBootStrapArgument *.\n");
return;
}
printf("Bootstrap Method Argument Information:\n");
printf(" Offset: 0x%08" PFMT64x "", bsm_arg->file_offset);
printf(" Name_And_Type Index = (0x%02x)\n", bsm_arg->argument_info_idx);
if (bsm_arg->argument_info_cp_obj) {
printf(" Bootstrap Method Argument Type and Name Info:\n");
((RzBinJavaCPTypeMetas *)bsm_arg->argument_info_cp_obj)->allocs->print_summary(bsm_arg->argument_info_cp_obj);
} else {
printf(" Bootstrap Method Argument Type and Name Info: INVALID\n");
}
}
RZ_API void rz_bin_java_print_bootstrap_method_summary(RzBinJavaBootStrapMethod *bsm) {
RzBinJavaBootStrapArgument *bsm_arg = NULL;
RzListIter *iter = NULL, *iter_tmp = NULL;
if (!bsm) {
printf("Attempting to print an invalid RzBinJavaBootStrapArgument *.\n");
return;
}
printf("Bootstrap Method Information:\n");
printf(" Offset: 0x%08" PFMT64x "", bsm->file_offset);
printf(" Method Reference Index = (0x%02x)\n", bsm->bootstrap_method_ref);
printf(" Number of Method Arguments = (0x%02x)\n", bsm->num_bootstrap_arguments);
if (bsm->bootstrap_arguments) {
rz_list_foreach_safe (bsm->bootstrap_arguments, iter, iter_tmp, bsm_arg) {
if (bsm_arg) {
rz_bin_java_print_bootstrap_method_argument_summary(bsm_arg);
}
}
} else {
printf(" Bootstrap Method Argument: NONE \n");
}
}
RZ_API void rz_bin_java_print_bootstrap_methods_attr_summary(RzBinJavaAttrInfo *attr) {
RzListIter *iter, *iter_tmp;
RzBinJavaBootStrapMethod *obj = NULL;
if (!attr || attr->type == RZ_BIN_JAVA_ATTRIBUTE_BOOTSTRAP_METHODS_ATTR) {
printf("Unable to print attribue summary for RzBinJavaAttrInfo *RzBinJavaBootstrapMethodsAttr");
return;
}
printf("Bootstrap Methods Attribute Information Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "", attr->file_offset);
printf(" Length: 0x%08x", attr->length);
printf(" Number of Method Arguments = (0x%02x)\n", attr->info.bootstrap_methods_attr.num_bootstrap_methods);
if (attr->info.bootstrap_methods_attr.bootstrap_methods) {
rz_list_foreach_safe (attr->info.bootstrap_methods_attr.bootstrap_methods, iter, iter_tmp, obj) {
if (obj) {
rz_bin_java_print_bootstrap_method_summary(obj);
}
}
} else {
printf(" Bootstrap Methods: NONE \n");
}
}
RZ_API void rz_bin_java_print_annotation_default_attr_summary(RzBinJavaAttrInfo *attr) {
if (attr && attr->type == RZ_BIN_JAVA_ATTRIBUTE_ANNOTATION_DEFAULT_ATTR) {
printf("Annotation Default Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_bin_java_print_element_value_summary((attr->info.annotation_default_attr.default_value));
} else {
// TODO: printf attr is invalid
}
}
RZ_API void rz_bin_java_print_annotation_array_summary(RzBinJavaAnnotationsArray *annotation_array) {
RzListIter *iter = NULL, *iter_tmp = NULL;
RzBinJavaAnnotation *annotation;
if (!annotation_array->annotations) {
// TODO printf
return;
}
printf(" Annotation Array Information:\n");
printf(" Number of Annotation Array Elements: %d\n", annotation_array->num_annotations);
rz_list_foreach_safe (annotation_array->annotations, iter, iter_tmp, annotation) {
rz_bin_java_print_annotation_summary(annotation);
}
}
RZ_API void rz_bin_java_print_rtv_annotations_attr_summary(RzBinJavaAttrInfo *attr) {
if (attr && attr->type == RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATION_ATTR) {
printf("Runtime Visible Annotations Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_bin_java_print_annotation_array_summary(&attr->info.annotation_array);
}
}
RZ_API void rz_bin_java_print_rti_annotations_attr_summary(RzBinJavaAttrInfo *attr) {
if (attr && attr->type == RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATION_ATTR) {
printf("Runtime Invisible Annotations Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
rz_bin_java_print_annotation_array_summary(&attr->info.annotation_array);
}
}
RZ_API void rz_bin_java_print_rtvp_annotations_attr_summary(RzBinJavaAttrInfo *attr) {
RzBinJavaAnnotationsArray *annotation_array = NULL;
RzListIter *iter = NULL, *iter_tmp = NULL;
if (attr && attr->type == RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATION_ATTR) {
printf("Runtime Visible Parameter Annotations Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" Number of Runtime Invisible Parameters: %d\n", attr->info.rtvp_annotations_attr.num_parameters);
rz_list_foreach_safe (attr->info.rtvp_annotations_attr.parameter_annotations, iter, iter_tmp, annotation_array) {
rz_bin_java_print_annotation_array_summary(annotation_array);
}
}
}
RZ_API void rz_bin_java_print_rtip_annotations_attr_summary(RzBinJavaAttrInfo *attr) {
RzBinJavaAnnotationsArray *annotation_array = NULL;
RzListIter *iter = NULL, *iter_tmp = NULL;
if (attr && attr->type == RZ_BIN_JAVA_ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATION_ATTR) {
printf("Runtime Invisible Parameter Annotations Attribute Information:\n");
printf(" Attribute Offset: 0x%08" PFMT64x "\n", attr->file_offset);
printf(" Attribute Name Index: %d (%s)\n", attr->name_idx, attr->name);
printf(" Attribute Length: %d\n", attr->length);
printf(" Number of Runtime Invisible Parameters: %d\n", attr->info.rtip_annotations_attr.num_parameters);
rz_list_foreach_safe (attr->info.rtip_annotations_attr.parameter_annotations, iter, iter_tmp, annotation_array) {
rz_bin_java_print_annotation_array_summary(annotation_array);
}
}
}
RZ_API void rz_bin_java_print_stack_map_append_frame_summary(RzBinJavaStackMapFrame *obj) {
RzListIter *iter, *iter_tmp;
RzList *ptrList;
RzBinJavaVerificationObj *ver_obj;
printf("Stack Map Frame Information\n");
printf(" Tag Value = 0x%02x Name: %s\n", obj->tag, ((RzBinJavaStackMapFrameMetas *)obj->metas->type_info)->name);
printf(" Offset: 0x%08" PFMT64x "\n", obj->file_offset);
printf(" Local Variable Count = 0x%04x\n", obj->number_of_locals);
printf(" Local Variables:\n");
ptrList = obj->local_items;
rz_list_foreach_safe (ptrList, iter, iter_tmp, ver_obj) {
rz_bin_java_print_verification_info_summary(ver_obj);
}
printf(" Stack Items Count = 0x%04x\n", obj->number_of_stack_items);
printf(" Stack Items:\n");
ptrList = obj->stack_items;
rz_list_foreach_safe (ptrList, iter, iter_tmp, ver_obj) {
rz_bin_java_print_verification_info_summary(ver_obj);
}
}

59
librz/bin/format/java/print.h Normal file
View file

@ -0,0 +1,59 @@
// SPDX-License-Identifier: Apache-2.0
#ifndef JAVA_PRINT_H
#define JAVA_PRINT_H
#include "class.h"
RZ_API void rz_bin_java_print_utf8_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_name_and_type_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_double_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_long_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_float_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_integer_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_string_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_classref_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_fieldref_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_methodref_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_interfacemethodref_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_unknown_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_null_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_unknown_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_methodhandle_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_methodtype_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_invokedynamic_cp_summary(RzBinJavaCPTypeObj *obj);
RZ_API void rz_bin_java_print_stack_map_table_attr_summary(RzBinJavaAttrInfo *obj);
RZ_API void rz_bin_java_print_stack_map_frame_summary(RzBinJavaStackMapFrame *obj);
RZ_API void rz_bin_java_print_verification_info_summary(RzBinJavaVerificationObj *obj);
RZ_API void rz_bin_java_print_stack_map_append_frame_summary(RzBinJavaStackMapFrame *obj);
RZ_API void rz_bin_java_print_annotation_default_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_enclosing_methods_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_local_variable_type_attr_summary(RzBinJavaLocalVariableTypeAttribute *lvattr);
RZ_API void rz_bin_java_print_local_variable_type_table_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_signature_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_source_debug_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_element_value_summary(RzBinJavaElementValue *element_value);
RZ_API void rz_bin_java_print_annotation_summary(RzBinJavaAnnotation *annotation);
RZ_API void rz_bin_java_print_element_pair_summary(RzBinJavaElementValuePair *evp);
RZ_API void rz_bin_java_print_bootstrap_methods_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_rtv_annotations_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_rti_annotations_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_annotation_array_summary(RzBinJavaAnnotationsArray *annotation_array);
RZ_API void rz_bin_java_print_rtvp_annotations_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_rtip_annotations_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_field_summary(RzBinJavaField *field);
RZ_API void rz_bin_java_print_method_summary(RzBinJavaField *field);
RZ_API void rz_bin_java_print_code_exceptions_attr_summary(RzBinJavaExceptionEntry *exc_entry);
RZ_API void rz_bin_java_print_code_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_constant_value_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_deprecated_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_exceptions_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_classes_attr_summary(RzBinJavaClassesAttribute *icattr);
RZ_API void rz_bin_java_print_inner_classes_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_line_number_table_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_local_variable_attr_summary(RzBinJavaLocalVariableAttribute *lvattr);
RZ_API void rz_bin_java_print_local_variable_table_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_source_code_file_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_synthetic_attr_summary(RzBinJavaAttrInfo *attr);
RZ_API void rz_bin_java_print_attr_summary(RzBinJavaAttrInfo *attr);
#endif /* JAVA_PRINT_H */

4
librz/bin/meson.build
View file

@ -84,6 +84,9 @@ rz_bin_sources = [
'format/elf/elf64.c',
'format/elf/elf64_write.c',
'format/elf/elf_write.c',
'format/java/class.c',
'format/java/print.c',
'format/java/json.c',
'format/mach0/coresymbolication.c',
'format/mach0/dyldcache.c',
'format/mach0/fatmach0.c',
@ -141,7 +144,6 @@ rz_bin = library('rz_bin', rz_bin_sources,
include_directories: rz_bin_inc,
c_args: ['-DRZ_API_BIN_ONLY=1'] + library_cflags,
dependencies: [
java_dep,
lz4_dep,
yxml_dep,
rz_util_dep,

18
librz/bin/p/bin_java.c
View file

@ -5,8 +5,8 @@
#include <rz_lib.h>
#include <rz_bin.h>
#include "../../shlr/java/class.h"
#include "../../shlr/java/code.h"
#include "../asm/arch/java/code.h"
#include "../format/java/class.h"
#define IFDBG_BIN_JAVA if (0)
@ -61,11 +61,11 @@ static void add_bin_obj_to_sdb(RzBinJavaObj *bin) {
static Sdb *get_sdb(RzBinFile *bf) {
RzBinObject *o = bf->o;
struct rz_bin_java_obj_t *bin;
RzBinJavaObj *bin;
if (!o) {
return NULL;
}
bin = (struct rz_bin_java_obj_t *)o->bin_obj;
bin = (RzBinJavaObj *)o->bin_obj;
if (bin->kv) {
return bin->kv;
}
@ -73,7 +73,7 @@ static Sdb *get_sdb(RzBinFile *bf) {
}
static bool load_buffer(RzBinFile *bf, void **bin_obj, RzBuffer *buf, ut64 loadaddr, Sdb *sdb) {
struct rz_bin_java_obj_t *tmp_bin_obj = NULL;
RzBinJavaObj *tmp_bin_obj = NULL;
RzBuffer *tbuf = rz_buf_ref(buf);
tmp_bin_obj = rz_bin_java_new_buf(tbuf, loadaddr, sdb);
if (!tmp_bin_obj) {
@ -89,7 +89,7 @@ static bool load_buffer(RzBinFile *bf, void **bin_obj, RzBuffer *buf, ut64 loada
}
static void destroy(RzBinFile *bf) {
rz_bin_java_free((struct rz_bin_java_obj_t *)bf->o->bin_obj);
rz_bin_java_free((RzBinJavaObj *)bf->o->bin_obj);
sdb_free(DB);
DB = NULL;
}
@ -103,15 +103,15 @@ static ut64 baddr(RzBinFile *bf) {
}
static RzList *classes(RzBinFile *bf) {
return rz_bin_java_get_classes((struct rz_bin_java_obj_t *)bf->o->bin_obj);
return rz_bin_java_get_classes((RzBinJavaObj *)bf->o->bin_obj);
}
static RzList *symbols(RzBinFile *bf) {
return rz_bin_java_get_symbols((struct rz_bin_java_obj_t *)bf->o->bin_obj);
return rz_bin_java_get_symbols((RzBinJavaObj *)bf->o->bin_obj);
}
static RzList *strings(RzBinFile *bf) {
return rz_bin_java_get_strings((struct rz_bin_java_obj_t *)bf->o->bin_obj);
return rz_bin_java_get_strings((RzBinJavaObj *)bf->o->bin_obj);
}
static RzBinInfo *info(RzBinFile *bf) {

2
librz/core/cmd.c
View file

@ -6638,7 +6638,7 @@ RZ_API void rz_core_cmd_init(RzCore *core) {
{ "z", "zignatures", rz_cmd_zign },
};
core->rcmd = rz_cmd_new(!!core->cons);
core->rcmd = rz_cmd_new(!!core->cons, true);
core->rcmd->macro.user = core;
core->rcmd->macro.num = core->num;
core->rcmd->macro.cmd = core_cmd0_wrapper;

6
librz/core/cmd_api.c
View file

@ -161,7 +161,7 @@ RZ_API void rz_cmd_alias_init(RzCmd *cmd) {
cmd->aliases.values = NULL;
}
RZ_API RzCmd *rz_cmd_new(bool has_cons) {
RZ_API RzCmd *rz_cmd_new(bool has_cons, bool add_core_plugins) {
int i;
RzCmd *cmd = RZ_NEW0(RzCmd);
if (!cmd) {
@ -175,7 +175,9 @@ RZ_API RzCmd *rz_cmd_new(bool has_cons) {
cmd->nullcallback = cmd->data = NULL;
cmd->ht_cmds = ht_pp_new0();
cmd->root_cmd_desc = create_cmd_desc(cmd, NULL, RZ_CMD_DESC_TYPE_GROUP, "", &root_help, true);
rz_core_plugin_init(cmd);
if (add_core_plugins) {
rz_core_plugin_init(cmd);
}
rz_cmd_macro_init(&cmd->macro);
rz_cmd_alias_init(cmd);
return cmd;

1
librz/core/meson.build
View file

@ -100,7 +100,6 @@ rz_core_deps = [
rz_bin_dep,
platform_deps,
gdb_dep,
java_dep,
lrt,
shell_parser_dep
]

2125
librz/core/p/core_java.c
View file

File diff suppressed because it is too large Load diff

2
librz/include/rz_cmd.h
View file

@ -440,7 +440,7 @@ RZ_API int rz_core_plugin_add(RzCmd *cmd, RzCorePlugin *plugin);
RZ_API int rz_core_plugin_check(RzCmd *cmd, const char *a0);
RZ_API int rz_core_plugin_fini(RzCmd *cmd);
RZ_API RzCmd *rz_cmd_new(bool has_cons);
RZ_API RzCmd *rz_cmd_new(bool has_cons, bool add_core_plugins);
RZ_API RzCmd *rz_cmd_free(RzCmd *cmd);
RZ_API int rz_cmd_set_data(RzCmd *cmd, void *data);
RZ_API int rz_cmd_add(RzCmd *cmd, const char *command, RzCmdCb callback);

2
librz/meson.build
View file

@ -198,7 +198,7 @@ bp_plugins = [
]
core_plugins = [
'java'
'java',
]
crypto_plugins = [

22
shlr/meson.build
View file

@ -86,28 +86,6 @@ bochs_dep = declare_dependency(
include_directories: bochs_inc
)
# handle java dependency
java_files = [
'java/class.c',
'java/code.c',
'java/ops.c',
]
java_inc = [platform_inc, include_directories('java')]
librzjava = static_library('rzjava', java_files,
dependencies: [rz_util_dep],
include_directories: java_inc,
implicit_include_directories: false
)
java_dep = declare_dependency(
link_with: librzjava,
include_directories: java_inc
)
# handle qnx dependency
qnx_files = [
'qnx/src/core.c',

2
test/db/analysis/java
View file

@ -141,7 +141,7 @@ wx cafebabe0000002f004008002208003a08003c070031070036070037070038070039090004001
ib;af;
s 0x425; p8 2;
java flags_str_at m 0x425
java set_flags 0x425 0x009
java set_flags 0x425 m "public static"
p8 2;
java flags_str_at m 0x425
EOF

2
test/unit/test_autocmplt.c
View file

@ -55,7 +55,7 @@ static RzCore *fake_core_new(void) {
mu_assert_notnull(cf, "file should be opened");
rz_core_bin_load(core, "bins/elf/hello_world", 0);
rz_cmd_free(core->rcmd);
RzCmd *cmd = rz_cmd_new(true);
RzCmd *cmd = rz_cmd_new(true, false);
mu_assert_notnull(cmd, "cmd should be created");
RzCmdDesc *root = rz_cmd_get_root(cmd);
mu_assert_notnull(root, "root should be present");

38
test/unit/test_cmd.c
View file

@ -92,21 +92,21 @@ static RzCmdStatus afl_argv_handler(RzCore *core, int argc, const char **argv) {
}
bool test_cmd_descriptor_argv(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *cd = rz_cmd_desc_argv_new(cmd, root, "afl", afl_argv_handler, &fake_help);
mu_assert_notnull(cd, "cmddesc created");
mu_assert_streq(cd->name, "afl", "command descriptor name is afl");
mu_assert_eq(cd->type, RZ_CMD_DESC_TYPE_ARGV, "type of command descriptor is argv");
mu_assert_ptreq(rz_cmd_desc_parent(cd), root, "root parent descriptor");
mu_assert_eq(root->n_children, 1, "root has 1 child");
mu_assert_eq(root->n_children, 1, "root has 1 children");
mu_assert_eq(cd->n_children, 0, "no children");
rz_cmd_free(cmd);
mu_end;
}
bool test_cmd_descriptor_argv_nested(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *af_cd = rz_cmd_desc_group_new(cmd, root, "af", NULL, NULL, &fake_help);
rz_cmd_desc_argv_new(cmd, root, "af2", NULL, &fake_help);
@ -122,7 +122,7 @@ static int a_oldinput_cb(void *user, const char *input) {
}
bool test_cmd_descriptor_oldinput(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *cd = rz_cmd_desc_oldinput_new(cmd, root, "a", a_oldinput_cb, NULL);
mu_assert_notnull(cd, "cmddesc created");
@ -147,7 +147,7 @@ bool test_cmd_descriptor_group(void) {
const RzCmdDescHelp a_exec_help = { .summary = "a exec help", .args = fake_args };
const RzCmdDescHelp a_group_help = { .summary = "a group help" };
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *cd = rz_cmd_desc_group_new(cmd, root, "a", a_exec_cb, &a_exec_help, &a_group_help);
rz_cmd_desc_argv_new(cmd, cd, "ab", ab_cb, &ab_help);
@ -197,7 +197,7 @@ static int w_handler(void *user, const char *input) {
}
bool test_cmd_descriptor_tree(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *a_cd = rz_cmd_desc_group_new(cmd, root, "a", NULL, NULL, &fake_help);
rz_cmd_desc_argv_new(cmd, a_cd, "ap", ap_handler, &fake_help);
@ -214,7 +214,7 @@ bool test_cmd_descriptor_tree(void) {
}
bool test_cmd_get_desc(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *a_cd = rz_cmd_desc_group_new(cmd, root, "a", NULL, NULL, &fake_help);
RzCmdDesc *ap_cd = rz_cmd_desc_group_new(cmd, a_cd, "ap", ap_handler, NULL, &fake_help);
@ -279,7 +279,7 @@ bool test_cmd_call_desc(void) {
.args = pd_help_args,
};
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *p_cd = rz_cmd_desc_group_new(cmd, root, "p", NULL, NULL, &fake_help);
rz_cmd_desc_argv_new(cmd, p_cd, "pd", pd_handler, &pd_help);
@ -348,7 +348,7 @@ bool test_cmd_help(void) {
.args = fake_args,
};
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *p_cd = rz_cmd_desc_group_new(cmd, root, "p", NULL, NULL, &p_group_help);
rz_cmd_desc_argv_new(cmd, p_cd, "pd", pd_handler, &pd_help);
@ -415,7 +415,7 @@ bool test_cmd_group_help(void) {
.args = fake_args,
};
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *p_cd = rz_cmd_desc_group_new(cmd, root, "p", p_handler_argv, &p_help, &p_group_help);
rz_cmd_desc_argv_new(cmd, p_cd, "pd", pd_handler, &pd_help);
@ -437,7 +437,7 @@ bool test_cmd_group_help(void) {
bool test_cmd_oldinput_help(void) {
rz_cons_new();
RzCmd *cmd = rz_cmd_new(true);
RzCmd *cmd = rz_cmd_new(true, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *p_cd = rz_cmd_desc_group_new(cmd, root, "p", NULL, NULL, &fake_help);
rz_cmd_desc_argv_new(cmd, p_cd, "pd", pd_handler, &fake_help);
@ -457,7 +457,7 @@ bool test_cmd_oldinput_help(void) {
}
bool test_remove_cmd(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *x_cd = rz_cmd_desc_argv_new(cmd, root, "x", NULL, &fake_help);
RzCmdDesc *p_cd = rz_cmd_desc_group_new(cmd, root, "p", NULL, NULL, &fake_help);
@ -496,7 +496,7 @@ bool test_cmd_args(void) {
x_help.summary = "x summary";
x_help.args = x_args;
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *x_cd = rz_cmd_desc_argv_new(cmd, root, "x", NULL, &x_help);
@ -522,7 +522,7 @@ bool test_cmd_argv_modes(void) {
z_help.summary = "z summary";
z_help.args = z_args;
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *z_cd = rz_cmd_desc_argv_modes_new(cmd, root, "z", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET | RZ_OUTPUT_MODE_LONG_JSON, z_modes_handler, &z_help);
@ -567,7 +567,7 @@ bool test_cmd_group_argv_modes(void) {
RzCmdDescHelp z_group_help = { 0 };
z_group_help.summary = "z group summary";
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *z_cd = rz_cmd_desc_group_modes_new(cmd, root, "z", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET, z_modes_handler, &z_help, &z_group_help);
RzCmdDesc *zd_cd = rz_cmd_desc_argv_new(cmd, z_cd, "zd", zd_handler, &fake_help);
@ -605,7 +605,7 @@ static bool foreach_cmdname_cb(RzCmd *cmd, const RzCmdDesc *desc, void *user) {
}
bool test_foreach_cmdname(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *z_cd = rz_cmd_desc_group_modes_new(cmd, root, "z", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET, z_modes_handler, &fake_help, &fake_help);
rz_cmd_desc_argv_new(cmd, z_cd, "zd", zd_handler, &fake_help);
@ -646,7 +646,7 @@ bool test_foreach_cmdname(void) {
}
bool test_foreach_cmdname_begin(void) {
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *z_cd = rz_cmd_desc_group_modes_new(cmd, root, "z", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_QUIET, z_modes_handler, &fake_help, &fake_help);
rz_cmd_desc_argv_new(cmd, z_cd, "zd", zd_handler, &fake_help);
@ -786,7 +786,7 @@ bool test_arg_flags(void) {
RzCmdDescHelp x_help = { 0 };
x_help.summary = "x summary";
x_help.args = x_args;
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
rz_cmd_desc_argv_new(cmd, root, "z", z_last_handler, &z_help);
rz_cmd_desc_argv_new(cmd, root, "x", x_array_handler, &x_help);
@ -825,7 +825,7 @@ bool test_get_arg(void) {
RzCmdDescHelp x_help = { 0 };
x_help.summary = "x summary";
x_help.args = x_args;
RzCmd *cmd = rz_cmd_new(false);
RzCmd *cmd = rz_cmd_new(false, false);
RzCmdDesc *root = rz_cmd_get_root(cmd);
RzCmdDesc *z_cd = rz_cmd_desc_argv_new(cmd, root, "z", z_last_handler, &z_help);
RzCmdDesc *x_cd = rz_cmd_desc_argv_new(cmd, root, "x", x_array_handler, &x_help);

2
test/unit/test_core_cmd.c
View file

@ -68,7 +68,7 @@ static RzCmdStatus cmd_last_opt_handler(RzCore *core, int argc, const char **arg
static RzCore *fake_core_new(void) {
RzCore *core = rz_core_new();
rz_cmd_free(core->rcmd);
core->rcmd = rz_cmd_new(true);
core->rcmd = rz_cmd_new(true, false);
core->rcmd->data = core;
RzCmdDesc *root = rz_cmd_get_root(core->rcmd);
rz_cmd_desc_argv_new(core->rcmd, root, "string", string_handler, &string_help);