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 [::Nlist] = dataResult<&[::Nlist], …>
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: u64 = str_startOption
379 .checked_add(self.strsize.get(endian).into())
380 .read_error("Invalid Mach-O string table length")?;
381 let strings: StringTable<'_, R> = 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}
405