pelf 0.1.5

A library for parsing/generating/analyzing ELF
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

/// utilities for parsing the entire ELF files.
mod file;
/// utilities for parsing the ELF headers.
mod header;
/// utilities for parsing the ELF Program Headers.
mod program_header;
/// utilities for parsing the ELF section header/data.
mod section;

/// errors that the parser uses
mod error;
pub use error::*;

use crate::header::{ELF_IDENT_DATA_2LSB, ELF_IDENT_DATA_2MSB};
use crate::prelude::*;

/// An 32-bit/64-bit ELF parser.
#[derive(Default)]
pub struct ElfParser {
    /// parse_config holds the configuration of the parser.
    pub(crate) parse_config: ElfParserConfig,
}

impl ElfParser {
    /// parses Elf64Half(u16) bytes.
    pub(crate) fn parse_elf64_half<'a>(
        &'a self,
        encoding: u8,
        b: &'a [u8],
    ) -> nom::IResult<&'a [u8], Elf64Half> {
        self.parse_elf64_u16(encoding, b)
    }

    /// parses Elf64SectionIndex(u16) bytes.
    pub(crate) fn parse_elf64_section_index<'a>(
        &'a self,
        encoding: u8,
        b: &'a [u8],
    ) -> nom::IResult<&'a [u8], Elf64SectionIndex> {
        self.parse_elf64_u16(encoding, b)
    }

    /// parses Elf64Word(u32) bytes.
    pub(crate) fn parse_elf64_word<'a>(
        &'a self,
        encoding: u8,
        b: &'a [u8],
    ) -> nom::IResult<&'a [u8], Elf64Word> {
        self.parse_elf64_u32(encoding, b)
    }

    /// parses Elf64Off(u64) bytes.
    pub(crate) fn parse_elf64_offset<'a>(
        &'a self,
        encoding: u8,
        b: &'a [u8],
    ) -> nom::IResult<&'a [u8], Elf64Off> {
        self.parse_elf64_u64(encoding, b)
    }

    /// parses Elf64Addr(u64) bytes.
    pub(crate) fn parse_elf64_address<'a>(
        &'a self,
        encoding: u8,
        b: &'a [u8],
    ) -> nom::IResult<&'a [u8], Elf64Off> {
        self.parse_elf64_u64(encoding, b)
    }

    /// parses Elf64Xword(u64) bytes.
    pub(crate) fn parse_elf64_xword<'a>(
        &'a self,
        encoding: u8,
        b: &'a [u8],
    ) -> nom::IResult<&'a [u8], Elf64Xword> {
        self.parse_elf64_u64(encoding, b)
    }

    /// parses u16 bytes in ELF.
    fn parse_elf64_u16<'a>(&'a self, encoding: u8, b: &'a [u8]) -> nom::IResult<&'a [u8], u16> {
        match encoding {
            ELF_IDENT_DATA_2LSB => nom::number::complete::le_u16(b),
            ELF_IDENT_DATA_2MSB => nom::number::complete::be_u16(b),
            _ => unreachable!(),
        }
    }

    /// parses u32 bytes in ELF.
    fn parse_elf64_u32<'a>(&'a self, encoding: u8, b: &'a [u8]) -> nom::IResult<&'a [u8], u32> {
        match encoding {
            ELF_IDENT_DATA_2LSB => nom::number::complete::le_u32(b),
            ELF_IDENT_DATA_2MSB => nom::number::complete::be_u32(b),
            _ => unreachable!(),
        }
    }

    /// parses u64 bytes in ELF.
    fn parse_elf64_u64<'a>(&'a self, encoding: u8, b: &'a [u8]) -> nom::IResult<&'a [u8], u64> {
        match encoding {
            ELF_IDENT_DATA_2LSB => nom::number::complete::le_u64(b),
            ELF_IDENT_DATA_2MSB => nom::number::complete::be_u64(b),
            _ => unreachable!(),
        }
    }
}

/// A configuration that determines what the parser parses/how the parser parses.
pub struct ElfParserConfig {
    /// determines whether the parser tries to parse ELF header or not.
    pub(crate) _parse_header: bool,
    /// determines whether the parser tries to parse ELF program header table or not.
    pub(crate) _parse_pht: bool,
    /// determines whether the parser tries to parse ELF section (data) or not.
    pub(crate) _parse_sections: bool,
}

impl ElfParserConfig {
    /// creates a new ElfParserConfig.
    pub fn new() -> Self {
        Self {
            _parse_header: true,
            _parse_pht: true,
            _parse_sections: true,
        }
    }

    /// build an ElfParser from the configuration.
    pub fn build(self) -> ElfParser {
        ElfParser { parse_config: self }
    }

    /// determines whether the parse tries to parse ELF header or not.
    pub fn parse_header(mut self, parse_header: bool) -> Self {
        self._parse_header = parse_header;
        self
    }

    /// determines whether the parse tries to parse ELF program header table or not.
    pub fn parse_program_header_table(mut self, parse_pht: bool) -> Self {
        self._parse_pht = parse_pht;
        self
    }

    /// determines whether the parse tries to parse ELF section (data) or not.
    pub fn parse_sections(mut self, parse_sections: bool) -> Self {
        self._parse_sections = parse_sections;
        self
    }
}

impl Default for ElfParserConfig {
    fn default() -> Self {
        Self {
            _parse_header: true,
            _parse_pht: true,
            _parse_sections: true,
        }
    }
}