simple_elf 0.1.1

simple parser for amd64 elf files
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

#![allow(non_camel_case_types)]

use nom::number;
use nom::IResult;
use serde::Serialize;

#[derive(Debug, Clone, Copy, Serialize)]
pub enum SymbolBinding {
    STB_LOCAL,  // Not visible outside the object file
    STB_GLOBAL, // Global symbol, visible to all object files
    STB_WEAK,   // Global scope, but with lower precedence than global symbols
    UNSPECIFIED(u8),
}

impl Into<u8> for SymbolBinding {
    fn into(self) -> u8 {
        match self {
            Self::STB_LOCAL => 0,
            Self::STB_GLOBAL => 1,
            Self::STB_WEAK => 2,
            Self::UNSPECIFIED(v) => v,
        }
    }
}

impl From<u8> for SymbolBinding {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::STB_LOCAL,
            1 => Self::STB_GLOBAL,
            2 => Self::STB_WEAK,
            _ => Self::UNSPECIFIED(value),
        }
    }
}
#[derive(Debug, Clone, Copy, Serialize)]
pub enum SymbolType {
    STT_NOTYPE,  // No type specified (e.g., an absolute symbol)
    STT_OBJECT,  // Data object
    STT_FUNC,    // Function entry point
    STT_SECTION, // Symbol is associated with a section
    STT_FILE,    // Source file associated with the object file
    UNSPECIFIED(u8),
}

impl Into<u8> for SymbolType {
    fn into(self) -> u8 {
        match self {
            Self::STT_NOTYPE => 0,
            Self::STT_OBJECT => 1,
            Self::STT_FUNC => 2,
            Self::STT_SECTION => 3,
            Self::STT_FILE => 4,
            Self::UNSPECIFIED(v) => v,
        }
    }
}
impl From<u8> for SymbolType {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::STT_NOTYPE,
            1 => Self::STT_OBJECT,
            2 => Self::STT_FUNC,
            3 => Self::STT_SECTION,
            4 => Self::STT_FILE,
            _ => Self::UNSPECIFIED(value),
        }
    }
}

#[derive(Debug, Clone, Serialize)]
pub struct Elf64_Sym {
    pub st_name: u32,  /* Symbol name  if 0 it has no name */
    pub st_info: u8,   /* Type and Binding attributes */
    pub st_other: u8,  /* Reserved */
    pub st_shndx: u16, /* Section table index */
    pub st_value: u64, /* Symbol value */
    pub st_size: u64,  /* Size of object (e.g., common) */
    pub symbol_type: SymbolType,
    pub symbol_binding: SymbolBinding,
    pub name: String,
}

impl Into<Vec<u8>> for Elf64_Sym {
    fn into(self) -> Vec<u8> {
        let mut out: Vec<u8> = Vec::new();
        out.extend(self.st_name.to_le_bytes());
        out.push(self.st_info);
        out.push(self.st_other);
        out.extend(self.st_shndx.to_le_bytes());
        out.extend(self.st_value.to_le_bytes());
        out.extend(self.st_size.to_le_bytes());
        out
    }
}

impl Into<Vec<u8>> for &Elf64_Sym {
    fn into(self) -> Vec<u8> {
        let mut out: Vec<u8> = Vec::new();
        out.extend(self.st_name.to_le_bytes());
        out.push(self.st_info);
        out.push(self.st_other);
        out.extend(self.st_shndx.to_le_bytes());
        out.extend(self.st_value.to_le_bytes());
        out.extend(self.st_size.to_le_bytes());
        out
    }
}

impl Elf64_Sym {
    pub fn parse(raw: &[u8]) -> IResult<&[u8], Self> {
        let (remaining, st_name) = number::complete::le_u32(raw)?;
        let (remaining, st_info) = number::complete::le_u8(remaining)?;
        let (remaining, st_other) = number::complete::le_u8(remaining)?;
        let (remaining, st_shndx) = number::complete::le_u16(remaining)?;
        let (remaining, st_value) = number::complete::le_u64(remaining)?;
        let (remaining, st_size) = number::complete::le_u64(remaining)?;
        Ok((
            remaining,
            Self {
                st_info,
                st_name,
                st_size,
                st_other,
                st_shndx,
                st_value,
                symbol_type: SymbolType::from(st_info << 4),
                symbol_binding: SymbolBinding::from(st_info >> 4),
                name: String::new(),
            },
        ))
    }
}