object/read/macho/
load_command.rs

Help
1use core::marker::PhantomData;
2use core::mem;
3
4use crate::endian::Endian;
5use crate::macho;
6use crate::pod::Pod;
7use crate::read::macho::{MachHeader, SymbolTable};
8use crate::read::{Bytes, Error, ReadError, ReadRef, Result, StringTable};
9
10/// An iterator for the load commands from a [`MachHeader`].
11#[derive(Debug, Default, Clone, Copy)]
12pub struct LoadCommandIterator<'data, E: Endian> {
13    endian: E,
14    data: Bytes<'data>,
15    ncmds: u32,
16}
17
18impl<'data, E: Endian> LoadCommandIterator<'data, E> {
19    pub(super) fn new(endian: E, data: &'data [u8], ncmds: u32) -> Self {
20        LoadCommandIterator {
21            endian,
22            data: Bytes(data),
23            ncmds,
24        }
25    }
26
27    /// Return the next load command.
28    pub fn next(&mut self) -> Result<Option<LoadCommandData<'data, E>>> {
29        if self.ncmds == 0 {
30            return Ok(None);
31        }
32
33        let result = self.parse().map(Some);
34        if result.is_err() {
35            self.ncmds = 0;
36        } else {
37            self.ncmds -= 1;
38        }
39        result
40    }
41
42    fn parse(&mut self) -> Result<LoadCommandData<'data, E>> {
43        let header = self
44            .data
45            .read_at::<macho::LoadCommand<E>>(0)
46            .read_error("Invalid Mach-O load command header")?;
47        let cmd = header.cmd.get(self.endian);
48        let cmdsize = header.cmdsize.get(self.endian) as usize;
49        if cmdsize < mem::size_of::<macho::LoadCommand<E>>() {
50            return Err(Error("Invalid Mach-O load command size"));
51        }
52        let data = self
53            .data
54            .read_bytes(cmdsize)
55            .read_error("Invalid Mach-O load command size")?;
56        Ok(LoadCommandData {
57            cmd,
58            data,
59            marker: Default::default(),
60        })
61    }
62}
63
64impl<'data, E: Endian> Iterator for LoadCommandIterator<'data, E> {
65    type Item = Result<LoadCommandData<'data, E>>;
66
67    fn next(&mut self) -> Option<Self::Item> {
68        self.next().transpose()
69    }
70}
71
72/// The data for a [`macho::LoadCommand`].
73#[derive(Debug, Clone, Copy)]
74pub struct LoadCommandData<'data, E: Endian> {
75    cmd: u32,
76    // Includes the header.
77    data: Bytes<'data>,
78    marker: PhantomData<E>,
79}
80
81impl<'data, E: Endian> LoadCommandData<'data, E> {
82    /// Return the `cmd` field of the [`macho::LoadCommand`].
83    ///
84    /// This is one of the `LC_` constants.
85    pub fn cmd(&self) -> u32 {
86        self.cmd
87    }
88
89    /// Return the `cmdsize` field of the [`macho::LoadCommand`].
90    pub fn cmdsize(&self) -> u32 {
91        self.data.len() as u32
92    }
93
94    /// Parse the data as the given type.
95    #[inline]
96    pub fn data<T: Pod>(&self) -> Result<&'data T> {
97        self.data
98            .read_at(0)
99            .read_error("Invalid Mach-O command size")
100    }
101
102    /// Raw bytes of this [`macho::LoadCommand`] structure.
103    pub fn raw_data(&self) -> &'data [u8] {
104        self.data.0
105    }
106
107    /// Parse a load command string value.
108    ///
109    /// Strings used by load commands are specified by offsets that are
110    /// relative to the load command header.
111    pub fn string(&self, endian: E, s: macho::LcStr<E>) -> Result<&'data [u8]> {
112        self.data
113            .read_string_at(s.offset.get(endian) as usize)
114            .read_error("Invalid load command string offset")
115    }
116
117    /// Parse the command data according to the `cmd` field.
118    pub fn variant(&self) -> Result<LoadCommandVariant<'data, E>> {
119        Ok(match self.cmd {
120            macho::LC_SEGMENT => {
121                let mut data = self.data;
122                let segment = data.read().read_error("Invalid Mach-O command size")?;
123                LoadCommandVariant::Segment32(segment, data.0)
124            }
125            macho::LC_SYMTAB => LoadCommandVariant::Symtab(self.data()?),
126            macho::LC_THREAD | macho::LC_UNIXTHREAD => {
127                let mut data = self.data;
128                let thread = data.read().read_error("Invalid Mach-O command size")?;
129                LoadCommandVariant::Thread(thread, data.0)
130            }
131            macho::LC_DYSYMTAB => LoadCommandVariant::Dysymtab(self.data()?),
132            macho::LC_LOAD_DYLIB
133            | macho::LC_LOAD_WEAK_DYLIB
134            | macho::LC_REEXPORT_DYLIB
135            | macho::LC_LAZY_LOAD_DYLIB
136            | macho::LC_LOAD_UPWARD_DYLIB => LoadCommandVariant::Dylib(self.data()?),
137            macho::LC_ID_DYLIB => LoadCommandVariant::IdDylib(self.data()?),
138            macho::LC_LOAD_DYLINKER => LoadCommandVariant::LoadDylinker(self.data()?),
139            macho::LC_ID_DYLINKER => LoadCommandVariant::IdDylinker(self.data()?),
140            macho::LC_PREBOUND_DYLIB => LoadCommandVariant::PreboundDylib(self.data()?),
141            macho::LC_ROUTINES => LoadCommandVariant::Routines32(self.data()?),
142            macho::LC_SUB_FRAMEWORK => LoadCommandVariant::SubFramework(self.data()?),
143            macho::LC_SUB_UMBRELLA => LoadCommandVariant::SubUmbrella(self.data()?),
144            macho::LC_SUB_CLIENT => LoadCommandVariant::SubClient(self.data()?),
145            macho::LC_SUB_LIBRARY => LoadCommandVariant::SubLibrary(self.data()?),
146            macho::LC_TWOLEVEL_HINTS => LoadCommandVariant::TwolevelHints(self.data()?),
147            macho::LC_PREBIND_CKSUM => LoadCommandVariant::PrebindCksum(self.data()?),
148            macho::LC_SEGMENT_64 => {
149                let mut data = self.data;
150                let segment = data.read().read_error("Invalid Mach-O command size")?;
151                LoadCommandVariant::Segment64(segment, data.0)
152            }
153            macho::LC_ROUTINES_64 => LoadCommandVariant::Routines64(self.data()?),
154            macho::LC_UUID => LoadCommandVariant::Uuid(self.data()?),
155            macho::LC_RPATH => LoadCommandVariant::Rpath(self.data()?),
156            macho::LC_CODE_SIGNATURE
157            | macho::LC_SEGMENT_SPLIT_INFO
158            | macho::LC_FUNCTION_STARTS
159            | macho::LC_DATA_IN_CODE
160            | macho::LC_DYLIB_CODE_SIGN_DRS
161            | macho::LC_LINKER_OPTIMIZATION_HINT
162            | macho::LC_DYLD_EXPORTS_TRIE
163            | macho::LC_DYLD_CHAINED_FIXUPS => LoadCommandVariant::LinkeditData(self.data()?),
164            macho::LC_ENCRYPTION_INFO => LoadCommandVariant::EncryptionInfo32(self.data()?),
165            macho::LC_DYLD_INFO | macho::LC_DYLD_INFO_ONLY => {
166                LoadCommandVariant::DyldInfo(self.data()?)
167            }
168            macho::LC_VERSION_MIN_MACOSX
169            | macho::LC_VERSION_MIN_IPHONEOS
170            | macho::LC_VERSION_MIN_TVOS
171            | macho::LC_VERSION_MIN_WATCHOS => LoadCommandVariant::VersionMin(self.data()?),
172            macho::LC_DYLD_ENVIRONMENT => LoadCommandVariant::DyldEnvironment(self.data()?),
173            macho::LC_MAIN => LoadCommandVariant::EntryPoint(self.data()?),
174            macho::LC_SOURCE_VERSION => LoadCommandVariant::SourceVersion(self.data()?),
175            macho::LC_ENCRYPTION_INFO_64 => LoadCommandVariant::EncryptionInfo64(self.data()?),
176            macho::LC_LINKER_OPTION => LoadCommandVariant::LinkerOption(self.data()?),
177            macho::LC_NOTE => LoadCommandVariant::Note(self.data()?),
178            macho::LC_BUILD_VERSION => LoadCommandVariant::BuildVersion(self.data()?),
179            macho::LC_FILESET_ENTRY => LoadCommandVariant::FilesetEntry(self.data()?),
180            _ => LoadCommandVariant::Other,
181        })
182    }
183
184    /// Try to parse this command as a [`macho::SegmentCommand32`].
185    ///
186    /// Returns the segment command and the data containing the sections.
187    pub fn segment_32(self) -> Result<Option<(&'data macho::SegmentCommand32<E>, &'data [u8])>> {
188        if self.cmd == macho::LC_SEGMENT {
189            let mut data = self.data;
190            let segment = data.read().read_error("Invalid Mach-O command size")?;
191            Ok(Some((segment, data.0)))
192        } else {
193            Ok(None)
194        }
195    }
196
197    /// Try to parse this command as a [`macho::SymtabCommand`].
198    ///
199    /// Returns the segment command and the data containing the sections.
200    pub fn symtab(self) -> Result<Option<&'data macho::SymtabCommand<E>>> {
201        if self.cmd == macho::LC_SYMTAB {
202            Some(self.data()).transpose()
203        } else {
204            Ok(None)
205        }
206    }
207
208    /// Try to parse this command as a [`macho::DysymtabCommand`].
209    pub fn dysymtab(self) -> Result<Option<&'data macho::DysymtabCommand<E>>> {
210        if self.cmd == macho::LC_DYSYMTAB {
211            Some(self.data()).transpose()
212        } else {
213            Ok(None)
214        }
215    }
216
217    /// Try to parse this command as a [`macho::DylibCommand`].
218    pub fn dylib(self) -> Result<Option<&'data macho::DylibCommand<E>>> {
219        if self.cmd == macho::LC_LOAD_DYLIB
220            || self.cmd == macho::LC_LOAD_WEAK_DYLIB
221            || self.cmd == macho::LC_REEXPORT_DYLIB
222            || self.cmd == macho::LC_LAZY_LOAD_DYLIB
223            || self.cmd == macho::LC_LOAD_UPWARD_DYLIB
224        {
225            Some(self.data()).transpose()
226        } else {
227            Ok(None)
228        }
229    }
230
231    /// Try to parse this command as a [`macho::UuidCommand`].
232    pub fn uuid(self) -> Result<Option<&'data macho::UuidCommand<E>>> {
233        if self.cmd == macho::LC_UUID {
234            Some(self.data()).transpose()
235        } else {
236            Ok(None)
237        }
238    }
239
240    /// Try to parse this command as a [`macho::SegmentCommand64`].
241    pub fn segment_64(self) -> Result<Option<(&'data macho::SegmentCommand64<E>, &'data [u8])>> {
242        if self.cmd == macho::LC_SEGMENT_64 {
243            let mut data = self.data;
244            let command = data.read().read_error("Invalid Mach-O command size")?;
245            Ok(Some((command, data.0)))
246        } else {
247            Ok(None)
248        }
249    }
250
251    /// Try to parse this command as a [`macho::DyldInfoCommand`].
252    pub fn dyld_info(self) -> Result<Option<&'data macho::DyldInfoCommand<E>>> {
253        if self.cmd == macho::LC_DYLD_INFO || self.cmd == macho::LC_DYLD_INFO_ONLY {
254            Some(self.data()).transpose()
255        } else {
256            Ok(None)
257        }
258    }
259
260    /// Try to parse this command as an [`macho::EntryPointCommand`].
261    pub fn entry_point(self) -> Result<Option<&'data macho::EntryPointCommand<E>>> {
262        if self.cmd == macho::LC_MAIN {
263            Some(self.data()).transpose()
264        } else {
265            Ok(None)
266        }
267    }
268
269    /// Try to parse this command as a [`macho::BuildVersionCommand`].
270    pub fn build_version(self) -> Result<Option<&'data macho::BuildVersionCommand<E>>> {
271        if self.cmd == macho::LC_BUILD_VERSION {
272            Some(self.data()).transpose()
273        } else {
274            Ok(None)
275        }
276    }
277}
278
279/// A [`macho::LoadCommand`] that has been interpreted according to its `cmd` field.
280#[derive(Debug, Clone, Copy)]
281#[non_exhaustive]
282pub enum LoadCommandVariant<'data, E: Endian> {
283    /// `LC_SEGMENT`
284    Segment32(&'data macho::SegmentCommand32<E>, &'data [u8]),
285    /// `LC_SYMTAB`
286    Symtab(&'data macho::SymtabCommand<E>),
287    // obsolete: `LC_SYMSEG`
288    //Symseg(&'data macho::SymsegCommand<E>),
289    /// `LC_THREAD` or `LC_UNIXTHREAD`
290    Thread(&'data macho::ThreadCommand<E>, &'data [u8]),
291    // obsolete: `LC_IDFVMLIB` or `LC_LOADFVMLIB`
292    //Fvmlib(&'data macho::FvmlibCommand<E>),
293    // obsolete: `LC_IDENT`
294    //Ident(&'data macho::IdentCommand<E>),
295    // internal: `LC_FVMFILE`
296    //Fvmfile(&'data macho::FvmfileCommand<E>),
297    // internal: `LC_PREPAGE`
298    /// `LC_DYSYMTAB`
299    Dysymtab(&'data macho::DysymtabCommand<E>),
300    /// `LC_LOAD_DYLIB`, `LC_LOAD_WEAK_DYLIB`, `LC_REEXPORT_DYLIB`,
301    /// `LC_LAZY_LOAD_DYLIB`, or `LC_LOAD_UPWARD_DYLIB`
302    Dylib(&'data macho::DylibCommand<E>),
303    /// `LC_ID_DYLIB`
304    IdDylib(&'data macho::DylibCommand<E>),
305    /// `LC_LOAD_DYLINKER`
306    LoadDylinker(&'data macho::DylinkerCommand<E>),
307    /// `LC_ID_DYLINKER`
308    IdDylinker(&'data macho::DylinkerCommand<E>),
309    /// `LC_PREBOUND_DYLIB`
310    PreboundDylib(&'data macho::PreboundDylibCommand<E>),
311    /// `LC_ROUTINES`
312    Routines32(&'data macho::RoutinesCommand32<E>),
313    /// `LC_SUB_FRAMEWORK`
314    SubFramework(&'data macho::SubFrameworkCommand<E>),
315    /// `LC_SUB_UMBRELLA`
316    SubUmbrella(&'data macho::SubUmbrellaCommand<E>),
317    /// `LC_SUB_CLIENT`
318    SubClient(&'data macho::SubClientCommand<E>),
319    /// `LC_SUB_LIBRARY`
320    SubLibrary(&'data macho::SubLibraryCommand<E>),
321    /// `LC_TWOLEVEL_HINTS`
322    TwolevelHints(&'data macho::TwolevelHintsCommand<E>),
323    /// `LC_PREBIND_CKSUM`
324    PrebindCksum(&'data macho::PrebindCksumCommand<E>),
325    /// `LC_SEGMENT_64`
326    Segment64(&'data macho::SegmentCommand64<E>, &'data [u8]),
327    /// `LC_ROUTINES_64`
328    Routines64(&'data macho::RoutinesCommand64<E>),
329    /// `LC_UUID`
330    Uuid(&'data macho::UuidCommand<E>),
331    /// `LC_RPATH`
332    Rpath(&'data macho::RpathCommand<E>),
333    /// `LC_CODE_SIGNATURE`, `LC_SEGMENT_SPLIT_INFO`, `LC_FUNCTION_STARTS`,
334    /// `LC_DATA_IN_CODE`, `LC_DYLIB_CODE_SIGN_DRS`, `LC_LINKER_OPTIMIZATION_HINT`,
335    /// `LC_DYLD_EXPORTS_TRIE`, or `LC_DYLD_CHAINED_FIXUPS`.
336    LinkeditData(&'data macho::LinkeditDataCommand<E>),
337    /// `LC_ENCRYPTION_INFO`
338    EncryptionInfo32(&'data macho::EncryptionInfoCommand32<E>),
339    /// `LC_DYLD_INFO` or `LC_DYLD_INFO_ONLY`
340    DyldInfo(&'data macho::DyldInfoCommand<E>),
341    /// `LC_VERSION_MIN_MACOSX`, `LC_VERSION_MIN_IPHONEOS`, `LC_VERSION_MIN_WATCHOS`,
342    /// or `LC_VERSION_MIN_TVOS`
343    VersionMin(&'data macho::VersionMinCommand<E>),
344    /// `LC_DYLD_ENVIRONMENT`
345    DyldEnvironment(&'data macho::DylinkerCommand<E>),
346    /// `LC_MAIN`
347    EntryPoint(&'data macho::EntryPointCommand<E>),
348    /// `LC_SOURCE_VERSION`
349    SourceVersion(&'data macho::SourceVersionCommand<E>),
350    /// `LC_ENCRYPTION_INFO_64`
351    EncryptionInfo64(&'data macho::EncryptionInfoCommand64<E>),
352    /// `LC_LINKER_OPTION`
353    LinkerOption(&'data macho::LinkerOptionCommand<E>),
354    /// `LC_NOTE`
355    Note(&'data macho::NoteCommand<E>),
356    /// `LC_BUILD_VERSION`
357    BuildVersion(&'data macho::BuildVersionCommand<E>),
358    /// `LC_FILESET_ENTRY`
359    FilesetEntry(&'data macho::FilesetEntryCommand<E>),
360    /// An unrecognized or obsolete load command.
361    Other,
362}
363
364impl<E: Endian> macho::SymtabCommand<E> {
365    /// Return the symbol table that this command references.
366    pub fn symbols<'data, Mach: MachHeader<Endian = E>, R: ReadRef<'data>>(
367        &self,
368        endian: E,
369        data: R,
370    ) -> Result<SymbolTable<'data, Mach, R>> {
371        let symbols = data
372            .read_slice_at(
373                self.symoff.get(endian).into(),
374                self.nsyms.get(endian) as usize,
375            )
376            .read_error("Invalid Mach-O symbol table offset or size")?;
377        let str_start: u64 = self.stroff.get(endian).into();
378        let str_end = str_start
379            .checked_add(self.strsize.get(endian).into())
380            .read_error("Invalid Mach-O string table length")?;
381        let strings = StringTable::new(data, str_start, str_end);
382        Ok(SymbolTable::new(symbols, strings))
383    }
384}
385
386#[cfg(test)]
387mod tests {
388    use super::*;
389    use crate::LittleEndian;
390
391    #[test]
392    fn cmd_size_invalid() {
393        #[repr(align(16))]
394        struct Align<const N: usize>([u8; N]);
395        let mut commands = LoadCommandIterator::new(LittleEndian, &Align([0; 8]).0, 10);
396        assert!(commands.next().is_err());
397        let mut commands =
398            LoadCommandIterator::new(LittleEndian, &Align([0, 0, 0, 0, 7, 0, 0, 0, 0]).0, 10);
399        assert!(commands.next().is_err());
400        let mut commands =
401            LoadCommandIterator::new(LittleEndian, &Align([0, 0, 0, 0, 8, 0, 0, 0, 0]).0, 10);
402        assert!(commands.next().is_ok());
403    }
404}
object/read/macho/load_command.rs

object/read/macho/
load_command.rs
