binsider 0.3.2

Analyze ELF binaries like a boss
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

use crate::elf::Property;
use elf::{
    endian::AnyEndian,
    relocation::{Rel, Rela},
    ElfBytes, ParseError,
};
use std::io::Error as IoError;

/// ELF relocations wrapper.
#[derive(Clone, Debug, Default)]
pub struct Relocations {
    /// Relocations.
    rels: Vec<Rel>,
    /// Relocations with addend.
    relas: Vec<Rela>,
}

impl<'a> TryFrom<&'a ElfBytes<'a, AnyEndian>> for Relocations {
    type Error = ParseError;
    fn try_from(elf: &'a ElfBytes<'a, AnyEndian>) -> Result<Self, Self::Error> {
        let parsing_table = elf
            .section_headers()
            .ok_or_else(|| ParseError::IOError(IoError::other("parsing table does not exist")))?;
        Ok(Self {
            rels: parsing_table
                .iter()
                .filter(|shdr| shdr.sh_type == elf::abi::SHT_REL)
                .flat_map(|v| {
                    elf.section_data_as_rels(&v)
                        .expect("failed to read rels section")
                        .collect::<Vec<Rel>>()
                })
                .collect(),
            relas: parsing_table
                .iter()
                .filter(|shdr| shdr.sh_type == elf::abi::SHT_RELA)
                .flat_map(|v| {
                    elf.section_data_as_relas(&v)
                        .expect("failed to read relas section")
                        .collect::<Vec<Rela>>()
                })
                .collect(),
        })
    }
}

impl Property<'_> for Relocations {
    fn items(&self) -> Vec<Vec<String>> {
        let mut relocations = Vec::new();
        self.rels.iter().for_each(|v| {
            relocations.push(vec![
                format!("{:#X?}", v.r_type),
                format!("{:#X?}", v.r_sym),
                format!("{:#X?}", v.r_offset),
                String::from("-"),
            ]);
        });
        self.relas.iter().for_each(|v| {
            relocations.push(vec![
                format!("{:#X?}", v.r_type),
                format!("{:#X?}", v.r_sym),
                format!("{:#X?}", v.r_offset),
                format!("{:#X?}", v.r_addend),
            ]);
        });
        relocations
    }
}