java_class_parser 0.0.2

provides a way of easily parsing and analyzing java classes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! The raw java class, a direct translation of the java [ClassFile structure][class_file]
//!
//! [class_file]: https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1

use crate::constant_pool::{parser, ConstantPool};
use crate::error::Error;
use nom::combinator::eof;
use nom::error::ParseError;
use nom::number::complete::{be_u16, be_u32};
use nom::sequence::tuple;
use nom::{multi, IResult};

/// A raw java class file structure. All members have public access.
///
/// Defined by the [jvm spec](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1).
#[derive(Debug, Clone)]
pub struct RawJavaClass {
    pub magic: u32,
    pub major: u16,
    pub minor: u16,
    pub constant_pool_count: u16,
    pub constant_pool: ConstantPool,
    pub access_flags: u16,
    pub this_class: u16,
    pub super_class: u16,
    pub interfaces_count: u16,
    pub interfaces: Box<[u16]>,
    pub fields_count: u16,
    pub fields: Box<[RawFieldInfo]>,
    pub methods_count: u16,
    pub methods: Box<[RawMethodInfo]>,
    pub attributes_count: u16,
    pub attributes: Box<[RawAttributeInfo]>,
}

/// The raw field info structure
#[derive(Debug, Default, Clone)]
pub struct RawFieldInfo {
    pub access_flags: u16,
    pub name_index: u16,
    pub descriptor_index: u16,
    pub attributes_count: u16,
    pub attributes: Box<[RawAttributeInfo]>,
}

/// The raw method info structure
#[derive(Debug, Default, Clone)]
pub struct RawMethodInfo {
    pub access_flags: u16,
    pub name_index: u16,
    pub descriptor_index: u16,
    pub attributes_count: u16,
    pub attributes: Box<[RawAttributeInfo]>,
}

/// The raw attribute info struct
#[derive(Debug, Default, Clone)]
pub struct RawAttributeInfo {
    pub attribute_name_index: u16,
    pub attribute_length: u32,
    pub info: Box<[u8]>,
}

/// Should parse the entire byte array to create a raw java class
pub fn parse_class_file_bytes(bytes: &[u8]) -> Result<RawJavaClass, Error> {
    fn inner<'a, E: ParseError<&'a [u8]>>(bytes: &'a [u8]) -> IResult<&'a [u8], RawJavaClass, E> {
        let mut tuple_parser = tuple((be_u32, be_u16, be_u16, be_u16));

        let (bytes, (magic, major, minor, constant_pool_count)) = tuple_parser(bytes)?;

        // for some reason, the constant pool contains n - 1 entries
        let (bytes, constant_pool) = parser::parse_constant_pool(constant_pool_count - 1)(bytes)?;

        let mut tuple_parser = tuple((be_u16, be_u16, be_u16, be_u16));
        let (bytes, (access_flags, this_class, super_class, interfaces_count)) =
            tuple_parser(bytes)?;
        let (bytes, interfaces) = multi::count(be_u16, interfaces_count as usize)(bytes)?;

        let (bytes, fields_count) = be_u16(bytes)?;
        let mut fields = vec![RawFieldInfo::default(); fields_count as usize];
        let (bytes, _) = multi::fill(parser::parse_field_info, &mut fields)(bytes)?;

        let (bytes, methods_count) = be_u16(bytes)?;
        let mut methods = vec![RawMethodInfo::default(); methods_count as usize];
        let (bytes, _) = multi::fill(parser::parse_method_info, &mut methods)(bytes)?;

        let (bytes, attributes_count) = be_u16(bytes)?;
        let mut attributes = vec![RawAttributeInfo::default(); attributes_count as usize];
        let (bytes, _) = multi::fill(parser::parse_attribute_info, &mut attributes)(bytes)?;

        let (bytes, _) = eof(bytes)?;

        Ok((
            bytes,
            RawJavaClass {
                magic,
                major,
                minor,
                constant_pool_count,
                constant_pool,
                access_flags,
                this_class,
                super_class,
                interfaces_count,
                interfaces: interfaces.into_boxed_slice(),
                fields_count,
                fields: fields.into_boxed_slice(),
                methods_count,
                methods: methods.into_boxed_slice(),
                attributes_count,
                attributes: attributes.into_boxed_slice(),
            },
        ))
    }

    inner::<nom::error::Error<_>>(bytes)
        .map(|(_, java)| java)
        .map_err(|e| Error::from(e))
}