lief 1.0.0

Official Rust bindings for LIEF
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

use super::Command;
use lief_ffi as ffi;

use crate::to_slice;
use crate::{common::FromFFI, declare_iterator};
use std::marker::PhantomData;

/// Structure that represents the `LC_DATA_IN_CODE` command
///
/// This command is used to list slices of code sections that contain data. The *slices*
/// information are stored as an array of [`DataCodeEntry`]
pub struct DataInCode<'a> {
    ptr: cxx::UniquePtr<ffi::MachO_DataInCode>,
    _owner: PhantomData<&'a ffi::MachO_Binary>,
}

impl DataInCode<'_> {
    /// Start of the array of the [`DataCodeEntry`] entries
    pub fn data_offset(&self) -> u32 {
        self.ptr.data_offset()
    }

    /// Size of the (raw) array (`size = sizeof(DataCodeEntry) * nb_elements`)
    pub fn data_size(&self) -> u32 {
        self.ptr.data_size()
    }

    /// Raw content as a slice of bytes
    pub fn content(&self) -> &[u8] {
        to_slice!(self.ptr.content());
    }

    /// Iterator over the [`DataCodeEntry`]
    pub fn entries(&self) -> Entries<'_> {
        Entries::new(self.ptr.entries())
    }
}

impl std::fmt::Debug for DataInCode<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let base = self as &dyn Command;
        f.debug_struct("DataInCode")
            .field("base", &base)
            .field("data_offset", &self.data_offset())
            .field("data_size", &self.data_size())
            .finish()
    }
}

impl FromFFI<ffi::MachO_DataInCode> for DataInCode<'_> {
    fn from_ffi(cmd: cxx::UniquePtr<ffi::MachO_DataInCode>) -> Self {
        Self {
            ptr: cmd,
            _owner: PhantomData,
        }
    }
}

impl Command for DataInCode<'_> {
    fn get_base(&self) -> &ffi::MachO_Command {
        self.ptr.as_ref().unwrap().as_ref()
    }
}

pub struct DataCodeEntry<'a> {
    ptr: cxx::UniquePtr<ffi::MachO_DataCodeEntry>,
    _owner: PhantomData<&'a ffi::MachO_DataInCode>,
}

#[allow(non_camel_case_types)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum EntryType {
    DATA,
    JUMP_TABLE_8,
    JUMP_TABLE_16,
    JUMP_TABLE_32,
    ABS_JUMP_TABLE_32,
    UNKNOWN(u32),
}

impl From<u32> for EntryType {
    fn from(value: u32) -> Self {
        match value {
            0x00000001 => EntryType::DATA,
            0x00000002 => EntryType::JUMP_TABLE_8,
            0x00000003 => EntryType::JUMP_TABLE_16,
            0x00000004 => EntryType::JUMP_TABLE_32,
            0x00000005 => EntryType::ABS_JUMP_TABLE_32,
            _ => EntryType::UNKNOWN(value),
        }
    }
}

impl DataCodeEntry<'_> {
    /// Offset of the data
    pub fn offset(&self) -> u32 {
        self.ptr.offset()
    }
    /// Length of the data
    pub fn length(&self) -> u32 {
        self.ptr.length()
    }

    /// Type of the data
    pub fn get_type(&self) -> EntryType {
        EntryType::from(self.ptr.get_type())
    }
}

impl std::fmt::Debug for DataCodeEntry<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DataCodeEntry")
            .field("offset", &self.offset())
            .field("length", &self.length())
            .field("type", &self.get_type())
            .finish()
    }
}

impl FromFFI<ffi::MachO_DataCodeEntry> for DataCodeEntry<'_> {
    fn from_ffi(ptr: cxx::UniquePtr<ffi::MachO_DataCodeEntry>) -> Self {
        Self {
            ptr,
            _owner: PhantomData,
        }
    }
}

declare_iterator!(
    Entries,
    DataCodeEntry<'a>,
    ffi::MachO_DataCodeEntry,
    ffi::MachO_DataInCode,
    ffi::MachO_DataInCode_it_entries
);