# -*- coding:utf-8 -*-
'''
Created on 2018年12月14日
gen wallet
@author: user
'''
import os, sys
import logging
# from importlib import reload
reload(sys)
# sys.setdefaultencoding('utf8')
PY_GEN_PATH = "D:/download/pygen/bitauto".replace('/', os.sep)
TABLE_NUM = 100
logger = logging.getLogger('parse_javabytecode')
LOG_FILE = 'parse_javabytecode.log'
# LOG_FORMATTER = '%(asctime)s - %(levelname)s - %(filename)s - %(funcName)s - %(lineno)d - %(message)s'
LOG_FORMATTER = '%(message)s'
def config_logger():
logger.setLevel(logging.DEBUG)
if not os.path.exists(PY_GEN_PATH):
logger.info("文件夹不存在,已自行创建")
os.makedirs(PY_GEN_PATH, 777)
handler = logging.FileHandler(os.path.join(PY_GEN_PATH, LOG_FILE))
handler.setLevel(logging.DEBUG)
fmter = logging.Formatter(LOG_FORMATTER)
handler.setFormatter(fmter)
logger.addHandler(handler)
# 控制台打印
console = logging.StreamHandler()
console.setLevel(level=logging.DEBUG) # 设置为INFO级别
console.setFormatter(fmter)
logger.addHandler(console)
def inputParse(jvm_file):
# 每个字段占用的字节数
magic_size = 4
minor_ver = 2
major_ver = 2
# 常量池计数是从1而不是0开始
const_pool_count = 2
# constant_pool
cur = 0
raw_code = ''
with open(jvm_file, 'r') as f:
content = f.readline().encode('hex')
while(content):
raw_code = raw_code + content
content = f.readline().encode('hex')
cont_len = len(raw_code)
magic_num = raw_code[cur:cur + 2 * magic_size]
cur = cur + 2 * magic_size
print('magic_num:{}'.format(magic_num))
minor_version = raw_code[cur:cur + 2 * minor_ver]
cur = cur + 2 * minor_ver
print('minor_version:{} ,means:{}'.format(minor_version, int(minor_version, 16)))
major_version = raw_code[cur:cur + 2 * major_ver]
cur = cur + 2 * major_ver
print('major_version:{} ,means:{}'.format(major_version, int(major_version, 16)))
constant_pool_count = raw_code[cur:cur + 2 * const_pool_count]
cur = cur + 2 * const_pool_count
print('constant_pool_count:{} ,means:{}'.format(constant_pool_count, int(constant_pool_count, 16)))
cp_flag = 1
const_utf8_info_flag = 1
const_integer_info_flag = 3
const_float_info_flag = 4
const_long_info_flag = 5
const_double_info_flag = 6
const_class_info_flag = 7
const_string_info_flag = 8
const_fieldref_info_flag = 9
const_methodref_info_flag = 10
const_interfacemethodref_info_flag = 11
const_nameandtype_info_flag = 12
const_methodhandle_info_flag = 15
const_methodtype_info_flag = 16
const_invokedynamic_info_flag = 18
cur_cp_num = 1
int_const_cp = int(constant_pool_count, 16)
print('const_constant_pool size:{}'.format(str(int_const_cp)))
while (cur_cp_num < int_const_cp):
print('cur_cp_num:{}'.format(cur_cp_num))
cur_cp_tag = raw_code[cur:cur + 2 * cp_flag]
cur = cur + 2 * cp_flag
print('cur_cp_tag:{} means:{}'.format(cur_cp_tag, int(cur_cp_tag, 16)))
int_cur_cp_tag = int(cur_cp_tag, 16)
#print('int_cur_cp_tag:{}'.format(str(int_cur_cp_tag)))
if(int_cur_cp_tag == const_utf8_info_flag):
cp_utf8_len_size = 2
cur_utf8_length = raw_code[cur:cur + 2 * cp_utf8_len_size]
int_utf8_length=int(cur_utf8_length,16)
cur = cur + 2 * cp_utf8_len_size
print("cur_utf8_length:{} means:{}".format(cur_utf8_length, int_utf8_length))
cp_utf8_bytes_size = 1
'''
cp_utf8_bytes = raw_code[cur:cur + 2 * cp_utf8_bytes_size]
cur = cur + 2 * cp_utf8_bytes_size
'''
cp_utf8_bytes = raw_code[cur:cur + 2 * (int_utf8_length)]
print('cp_utf8_bytes:{} means:{}'.format(cp_utf8_bytes,cp_utf8_bytes.decode('hex')))
cur = cur + 2 * (int_utf8_length)
elif (int_cur_cp_tag == const_integer_info_flag):
cp_int_bytes_size = 4
cp_int_bytes = raw_code[cur:cur + 2 * cp_int_bytes_size]
cur = cur + 2 * cp_int_bytes_size
print('cp_int_bytes:{}'.format(cp_int_bytes))
elif (int_cur_cp_tag == const_float_info_flag):
cp_float_bytes_size = 4
cp_float_bytes = raw_code[cur:cur + 2 * cp_float_bytes_size]
cur = cur + 2 * cp_float_bytes_size
print('cp_float_bytes:{}'.format(cp_float_bytes))
elif (int_cur_cp_tag == const_long_info_flag ):
cp_long_bytes_size = 8
cp_long_bytes = raw_code[cur:cur + 2 * cp_long_bytes_size]
cur = cur + 2 * cp_long_bytes_size
print('cp_long_bytes:{}'.format(cp_long_bytes))
elif (int_cur_cp_tag == const_double_info_flag):
cp_double_bytes_size = 8
cp_double_bytes = raw_code[cur:cur + 2 * cp_double_bytes_size]
cur = cur + 2 * cp_double_bytes_size
print('cp_double_bytes:{}'.format(cp_double_bytes))
elif (int_cur_cp_tag == const_class_info_flag):
cp_class_index_size = 2
cp_class_index = raw_code[cur:cur + 2 * cp_class_index_size]
cur = cur + 2 * cp_class_index_size
print('cp_class_index:{} means:{}'.format(cp_class_index,int(cp_class_index,16)))
elif (int_cur_cp_tag == const_string_info_flag):
cp_string_index_size = 2
cp_string_index = raw_code[cur:cur + 2 * cp_string_index_size]
cur = cur + 2 * cp_string_index_size
print('cp_string_index:{} means:{}'.format(cp_string_index,int(cp_string_index,16)))
elif (int_cur_cp_tag == const_fieldref_info_flag):
cp_fieldref_index_size = 2
cp_fieldref_index = raw_code[cur:cur + 2 * cp_fieldref_index_size]
cur = cur + 2 * cp_fieldref_index_size
print('cp_fieldref_index:{} means:{}'.format(cp_fieldref_index,int(cp_fieldref_index,16)))
cp_fieldref_index2_size = 2
cp_fieldref_index2 = raw_code[cur:cur + 2 * cp_fieldref_index2_size]
cur = cur + 2 * cp_fieldref_index2_size
print('cp_fieldref_index2:{} means:{}'.format(cp_fieldref_index2,int(cp_fieldref_index2,16)))
elif (int_cur_cp_tag == const_methodref_info_flag ):
cp_methodref_index_size = 2
cp_methodref_index = raw_code[cur:cur + 2 * cp_methodref_index_size]
cur = cur + 2 * cp_methodref_index_size
print('cp_methodref_index:{} means:{}'.format(cp_methodref_index,int(cp_methodref_index,16)))
cp_methodref_index2_size = 2
cp_methodref_index2 = raw_code[cur:cur + 2 * cp_methodref_index2_size]
cur = cur + 2 * cp_methodref_index2_size
print('cp_methodref_index2:{} means:{}'.format(cp_methodref_index2,int(cp_methodref_index2,16)))
elif (int_cur_cp_tag == const_interfacemethodref_info_flag ):
cp_interfacemethodref_index_size = 2
cp_interfacemethodref_index = raw_code[cur:cur + 2 * cp_interfacemethodref_index_size]
cur = cur + 2 * cp_interfacemethodref_index_size
print('cp_interfacemethodref_index:{} means:{}'.format(cp_interfacemethodref_index,int(cp_interfacemethodref_index,16)))
cp_interfacemethodref_index2_size = 2
cp_interfacemethodref_index2 = raw_code[cur:cur + 2 * cp_interfacemethodref_index2_size]
cur = cur + 2 * cp_interfacemethodref_index2_size
print('cp_interfacemethodref_index2:{} means:{}'.format(cp_interfacemethodref_index2,int(cp_interfacemethodref_index2,16)))
elif (int_cur_cp_tag == const_nameandtype_info_flag):
cp_nameandtype_index_size = 2
cp_nameandtype_index = raw_code[cur:cur + 2 * cp_nameandtype_index_size]
cur = cur + 2 * cp_nameandtype_index_size
print('cp_nameandtype_index:{} means:{}'.format(cp_nameandtype_index,int(cp_nameandtype_index,16)))
cp_nameandtype_index2_size = 2
cp_nameandtype_index2 = raw_code[cur:cur + 2 * cp_nameandtype_index2_size]
cur = cur + 2 * cp_nameandtype_index2_size
print('cp_nameandtype_index2:{} means:{}'.format(cp_nameandtype_index2,int(cp_nameandtype_index2,16)))
cur_cp_num = cur_cp_num + 1
access_flag_size = 2
this_class_size=2
super_class_size=2
interfaces_count_size=2
access_flag = raw_code[cur:cur + 2 * access_flag_size]
cur = cur + 2 * access_flag_size
print('access_flag:{} '.format(access_flag))
this_class=raw_code[cur:cur + 2 * this_class_size]
cur = cur + 2 * this_class_size
print('this_class:{} '.format(this_class))
super_class=raw_code[cur:cur + 2 * super_class_size]
cur = cur + 2 * super_class_size
print('super_class:{} '.format(super_class))
this_class=raw_code[cur:cur + 2 * this_class_size]
cur = cur + 2 * this_class_size
print('this_class:{} '.format(this_class))
interfaces_count=raw_code[cur:cur + 2 * interfaces_count_size]
cur = cur + 2 * interfaces_count_size
print('interfaces_count:{} '.format(interfaces_count))
def main(file_name):
inputParse(file_name)
# inputParse(raw_tx)
if __name__ == '__main__':
config_logger()
file_name = 'D:\programs\java-dev/normal\src\main\java\com\scott\dev\JavaBytecodeClient.class'.replace('\\','/')
main(file_name)
