object/read/macho/
load_command.rs

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    pub fn symtab(self) -> Result<Option<&'data macho::SymtabCommand<E>>> {
199        if self.cmd == macho::LC_SYMTAB {
200            Some(self.data()).transpose()
201        } else {
202            Ok(None)
203        }
204    }
205
206    /// Try to parse this command as a [`macho::DysymtabCommand`].
207    pub fn dysymtab(self) -> Result<Option<&'data macho::DysymtabCommand<E>>> {
208        if self.cmd == macho::LC_DYSYMTAB {
209            Some(self.data()).transpose()
210        } else {
211            Ok(None)
212        }
213    }
214
215    /// Try to parse this command as a [`macho::DylibCommand`].
216    pub fn dylib(self) -> Result<Option<&'data macho::DylibCommand<E>>> {
217        if self.cmd == macho::LC_LOAD_DYLIB
218            || self.cmd == macho::LC_LOAD_WEAK_DYLIB
219            || self.cmd == macho::LC_REEXPORT_DYLIB
220            || self.cmd == macho::LC_LAZY_LOAD_DYLIB
221            || self.cmd == macho::LC_LOAD_UPWARD_DYLIB
222        {
223            Some(self.data()).transpose()
224        } else {
225            Ok(None)
226        }
227    }
228
229    /// Try to parse this command as a [`macho::UuidCommand`].
230    pub fn uuid(self) -> Result<Option<&'data macho::UuidCommand<E>>> {
231        if self.cmd == macho::LC_UUID {
232            Some(self.data()).transpose()
233        } else {
234            Ok(None)
235        }
236    }
237
238    /// Try to parse this command as a [`macho::SegmentCommand64`].
239    pub fn segment_64(self) -> Result<Option<(&'data macho::SegmentCommand64<E>, &'data [u8])>> {
240        if self.cmd == macho::LC_SEGMENT_64 {
241            let mut data = self.data;
242            let command = data.read().read_error("Invalid Mach-O command size")?;
243            Ok(Some((command, data.0)))
244        } else {
245            Ok(None)
246        }
247    }
248
249    /// Try to parse this command as a [`macho::DyldInfoCommand`].
250    pub fn dyld_info(self) -> Result<Option<&'data macho::DyldInfoCommand<E>>> {
251        if self.cmd == macho::LC_DYLD_INFO || self.cmd == macho::LC_DYLD_INFO_ONLY {
252            Some(self.data()).transpose()
253        } else {
254            Ok(None)
255        }
256    }
257
258    /// Try to parse this command as an [`macho::EntryPointCommand`].
259    pub fn entry_point(self) -> Result<Option<&'data macho::EntryPointCommand<E>>> {
260        if self.cmd == macho::LC_MAIN {
261            Some(self.data()).transpose()
262        } else {
263            Ok(None)
264        }
265    }
266
267    /// Try to parse this command as a [`macho::BuildVersionCommand`].
268    pub fn build_version(self) -> Result<Option<&'data macho::BuildVersionCommand<E>>> {
269        if self.cmd == macho::LC_BUILD_VERSION {
270            Some(self.data()).transpose()
271        } else {
272            Ok(None)
273        }
274    }
275}
276
277/// A [`macho::LoadCommand`] that has been interpreted according to its `cmd` field.
278#[derive(Debug, Clone, Copy)]
279#[non_exhaustive]
280pub enum LoadCommandVariant<'data, E: Endian> {
281    /// `LC_SEGMENT`
282    Segment32(&'data macho::SegmentCommand32<E>, &'data [u8]),
283    /// `LC_SYMTAB`
284    Symtab(&'data macho::SymtabCommand<E>),
285    // obsolete: `LC_SYMSEG`
286    //Symseg(&'data macho::SymsegCommand<E>),
287    /// `LC_THREAD` or `LC_UNIXTHREAD`
288    Thread(&'data macho::ThreadCommand<E>, &'data [u8]),
289    // obsolete: `LC_IDFVMLIB` or `LC_LOADFVMLIB`
290    //Fvmlib(&'data macho::FvmlibCommand<E>),
291    // obsolete: `LC_IDENT`
292    //Ident(&'data macho::IdentCommand<E>),
293    // internal: `LC_FVMFILE`
294    //Fvmfile(&'data macho::FvmfileCommand<E>),
295    // internal: `LC_PREPAGE`
296    /// `LC_DYSYMTAB`
297    Dysymtab(&'data macho::DysymtabCommand<E>),
298    /// `LC_LOAD_DYLIB`, `LC_LOAD_WEAK_DYLIB`, `LC_REEXPORT_DYLIB`,
299    /// `LC_LAZY_LOAD_DYLIB`, or `LC_LOAD_UPWARD_DYLIB`
300    Dylib(&'data macho::DylibCommand<E>),
301    /// `LC_ID_DYLIB`
302    IdDylib(&'data macho::DylibCommand<E>),
303    /// `LC_LOAD_DYLINKER`
304    LoadDylinker(&'data macho::DylinkerCommand<E>),
305    /// `LC_ID_DYLINKER`
306    IdDylinker(&'data macho::DylinkerCommand<E>),
307    /// `LC_PREBOUND_DYLIB`
308    PreboundDylib(&'data macho::PreboundDylibCommand<E>),
309    /// `LC_ROUTINES`
310    Routines32(&'data macho::RoutinesCommand32<E>),
311    /// `LC_SUB_FRAMEWORK`
312    SubFramework(&'data macho::SubFrameworkCommand<E>),
313    /// `LC_SUB_UMBRELLA`
314    SubUmbrella(&'data macho::SubUmbrellaCommand<E>),
315    /// `LC_SUB_CLIENT`
316    SubClient(&'data macho::SubClientCommand<E>),
317    /// `LC_SUB_LIBRARY`
318    SubLibrary(&'data macho::SubLibraryCommand<E>),
319    /// `LC_TWOLEVEL_HINTS`
320    TwolevelHints(&'data macho::TwolevelHintsCommand<E>),
321    /// `LC_PREBIND_CKSUM`
322    PrebindCksum(&'data macho::PrebindCksumCommand<E>),
323    /// `LC_SEGMENT_64`
324    Segment64(&'data macho::SegmentCommand64<E>, &'data [u8]),
325    /// `LC_ROUTINES_64`
326    Routines64(&'data macho::RoutinesCommand64<E>),
327    /// `LC_UUID`
328    Uuid(&'data macho::UuidCommand<E>),
329    /// `LC_RPATH`
330    Rpath(&'data macho::RpathCommand<E>),
331    /// `LC_CODE_SIGNATURE`, `LC_SEGMENT_SPLIT_INFO`, `LC_FUNCTION_STARTS`,
332    /// `LC_DATA_IN_CODE`, `LC_DYLIB_CODE_SIGN_DRS`, `LC_LINKER_OPTIMIZATION_HINT`,
333    /// `LC_DYLD_EXPORTS_TRIE`, or `LC_DYLD_CHAINED_FIXUPS`.
334    LinkeditData(&'data macho::LinkeditDataCommand<E>),
335    /// `LC_ENCRYPTION_INFO`
336    EncryptionInfo32(&'data macho::EncryptionInfoCommand32<E>),
337    /// `LC_DYLD_INFO` or `LC_DYLD_INFO_ONLY`
338    DyldInfo(&'data macho::DyldInfoCommand<E>),
339    /// `LC_VERSION_MIN_MACOSX`, `LC_VERSION_MIN_IPHONEOS`, `LC_VERSION_MIN_WATCHOS`,
340    /// or `LC_VERSION_MIN_TVOS`
341    VersionMin(&'data macho::VersionMinCommand<E>),
342    /// `LC_DYLD_ENVIRONMENT`
343    DyldEnvironment(&'data macho::DylinkerCommand<E>),
344    /// `LC_MAIN`
345    EntryPoint(&'data macho::EntryPointCommand<E>),
346    /// `LC_SOURCE_VERSION`
347    SourceVersion(&'data macho::SourceVersionCommand<E>),
348    /// `LC_ENCRYPTION_INFO_64`
349    EncryptionInfo64(&'data macho::EncryptionInfoCommand64<E>),
350    /// `LC_LINKER_OPTION`
351    LinkerOption(&'data macho::LinkerOptionCommand<E>),
352    /// `LC_NOTE`
353    Note(&'data macho::NoteCommand<E>),
354    /// `LC_BUILD_VERSION`
355    BuildVersion(&'data macho::BuildVersionCommand<E>),
356    /// `LC_FILESET_ENTRY`
357    FilesetEntry(&'data macho::FilesetEntryCommand<E>),
358    /// An unrecognized or obsolete load command.
359    Other,
360}
361
362impl<E: Endian> macho::SymtabCommand<E> {
363    /// Return the symbol table that this command references.
364    pub fn symbols<'data, Mach: MachHeader<Endian = E>, R: ReadRef<'data>>(
365        &self,
366        endian: E,
367        data: R,
368    ) -> Result<SymbolTable<'data, Mach, R>> {
369        let symbols = data
370            .read_slice_at(
371                self.symoff.get(endian).into(),
372                self.nsyms.get(endian) as usize,
373            )
374            .read_error("Invalid Mach-O symbol table offset or size")?;
375        let str_start: u64 = self.stroff.get(endian).into();
376        let str_end = str_start
377            .checked_add(self.strsize.get(endian).into())
378            .read_error("Invalid Mach-O string table length")?;
379        let strings = StringTable::new(data, str_start, str_end);
380        Ok(SymbolTable::new(symbols, strings))
381    }
382}
383
384#[cfg(test)]
385mod tests {
386    use super::*;
387    use crate::LittleEndian;
388
389    #[test]
390    fn cmd_size_invalid() {
391        #[repr(align(16))]
392        struct Align<const N: usize>([u8; N]);
393        let mut commands = LoadCommandIterator::new(LittleEndian, &Align([0; 8]).0, 10);
394        assert!(commands.next().is_err());
395        let mut commands =
396            LoadCommandIterator::new(LittleEndian, &Align([0, 0, 0, 0, 7, 0, 0, 0, 0]).0, 10);
397        assert!(commands.next().is_err());
398        let mut commands =
399            LoadCommandIterator::new(LittleEndian, &Align([0, 0, 0, 0, 8, 0, 0, 0, 0]).0, 10);
400        assert!(commands.next().is_ok());
401    }
402}
object/read/macho/load_command.rs

object/read/macho/
load_command.rs
