object/read/macho/
file.rs

Help
1use alloc::vec::Vec;
2use core::fmt::Debug;
3use core::{mem, str};
4
5use crate::endian::{self, BigEndian, Endian, Endianness};
6use crate::macho;
7use crate::pod::Pod;
8use crate::read::{
9    self, Architecture, ByteString, ComdatKind, Error, Export, FileFlags, Import,
10    NoDynamicRelocationIterator, Object, ObjectComdat, ObjectKind, ObjectMap, ObjectSection,
11    ReadError, ReadRef, Result, SectionIndex, SubArchitecture, SymbolIndex,
12};
13
14use super::{
15    DyldCacheImage, LoadCommandIterator, MachOSection, MachOSectionInternal, MachOSectionIterator,
16    MachOSegment, MachOSegmentInternal, MachOSegmentIterator, MachOSymbol, MachOSymbolIterator,
17    MachOSymbolTable, Nlist, Section, Segment, SymbolTable,
18};
19
20/// A 32-bit Mach-O object file.
21///
22/// This is a file that starts with [`macho::MachHeader32`], and corresponds
23/// to [`crate::FileKind::MachO32`].
24pub type MachOFile32<'data, Endian = Endianness, R = &'data [u8]> =
25    MachOFile<'data, macho::MachHeader32<Endian>, R>;
26/// A 64-bit Mach-O object file.
27///
28/// This is a file that starts with [`macho::MachHeader64`], and corresponds
29/// to [`crate::FileKind::MachO64`].
30pub type MachOFile64<'data, Endian = Endianness, R = &'data [u8]> =
31    MachOFile<'data, macho::MachHeader64<Endian>, R>;
32
33/// A partially parsed Mach-O file.
34///
35/// Most of the functionality of this type is provided by the [`Object`] trait implementation.
36#[derive(Debug)]
37pub struct MachOFile<'data, Mach, R = &'data [u8]>
38where
39    Mach: MachHeader,
40    R: ReadRef<'data>,
41{
42    pub(super) endian: Mach::Endian,
43    pub(super) data: R,
44    pub(super) header_offset: u64,
45    pub(super) header: &'data Mach,
46    pub(super) segments: Vec<MachOSegmentInternal<'data, Mach, R>>,
47    pub(super) sections: Vec<MachOSectionInternal<'data, Mach, R>>,
48    pub(super) symbols: SymbolTable<'data, Mach, R>,
49}
50
51impl<'data, Mach, R> MachOFile<'data, Mach, R>
52where
53    Mach: MachHeader,
54    R: ReadRef<'data>,
55{
56    /// Parse the raw Mach-O file data.
57    pub fn parse(data: R) -> Result<Self> {
58        let header = Mach::parse(data, 0)?;
59        let endian = header.endian()?;
60
61        // Build a list of segments and sections to make some operations more efficient.
62        let mut segments = Vec::new();
63        let mut sections = Vec::new();
64        let mut symbols = SymbolTable::default();
65        if let Ok(mut commands) = header.load_commands(endian, data, 0) {
66            while let Ok(Some(command)) = commands.next() {
67                if let Some((segment, section_data)) = Mach::Segment::from_command(command)? {
68                    segments.push(MachOSegmentInternal { segment, data });
69                    for section in segment.sections(endian, section_data)? {
70                        let index = SectionIndex(sections.len() + 1);
71                        sections.push(MachOSectionInternal::parse(index, section, data));
72                    }
73                } else if let Some(symtab) = command.symtab()? {
74                    symbols = symtab.symbols(endian, data)?;
75                }
76            }
77        }
78
79        Ok(MachOFile {
80            endian,
81            data,
82            header_offset: 0,
83            header,
84            segments,
85            sections,
86            symbols,
87        })
88    }
89
90    /// Parse the Mach-O file for the given image from the dyld shared cache.
91    /// This will read different sections from different subcaches, if necessary.
92    pub fn parse_dyld_cache_image<'cache, E: Endian>(
93        image: &DyldCacheImage<'data, 'cache, E, R>,
94    ) -> Result<Self> {
95        let (data, header_offset) = image.image_data_and_offset()?;
96        let header = Mach::parse(data, header_offset)?;
97        let endian = header.endian()?;
98
99        // Build a list of sections to make some operations more efficient.
100        // Also build a list of segments, because we need to remember which ReadRef
101        // to read each section's data from. Only the DyldCache knows this information,
102        // and we won't have access to it once we've exited this function.
103        let mut segments = Vec::new();
104        let mut sections = Vec::new();
105        let mut linkedit_data: Option<R> = None;
106        let mut symtab = None;
107        if let Ok(mut commands) = header.load_commands(endian, data, header_offset) {
108            while let Ok(Some(command)) = commands.next() {
109                if let Some((segment, section_data)) = Mach::Segment::from_command(command)? {
110                    // Each segment can be stored in a different subcache. Get the segment's
111                    // address and look it up in the cache mappings, to find the correct cache data.
112                    // This was observed for the arm64e __LINKEDIT segment in macOS 12.0.1.
113                    let addr = segment.vmaddr(endian).into();
114                    let (data, _offset) = image
115                        .cache
116                        .data_and_offset_for_address(addr)
117                        .read_error("Could not find segment data in dyld shared cache")?;
118                    if segment.name() == macho::SEG_LINKEDIT.as_bytes() {
119                        linkedit_data = Some(data);
120                    }
121                    segments.push(MachOSegmentInternal { segment, data });
122
123                    for section in segment.sections(endian, section_data)? {
124                        let index = SectionIndex(sections.len() + 1);
125                        sections.push(MachOSectionInternal::parse(index, section, data));
126                    }
127                } else if let Some(st) = command.symtab()? {
128                    symtab = Some(st);
129                }
130            }
131        }
132
133        // The symbols are found in the __LINKEDIT segment, so make sure to read them from the
134        // correct subcache.
135        let symbols = match (symtab, linkedit_data) {
136            (Some(symtab), Some(linkedit_data)) => symtab.symbols(endian, linkedit_data)?,
137            _ => SymbolTable::default(),
138        };
139
140        Ok(MachOFile {
141            endian,
142            data,
143            header_offset,
144            header,
145            segments,
146            sections,
147            symbols,
148        })
149    }
150
151    /// Return the section at the given index.
152    #[inline]
153    pub(super) fn section_internal(
154        &self,
155        index: SectionIndex,
156    ) -> Result<&MachOSectionInternal<'data, Mach, R>> {
157        index
158            .0
159            .checked_sub(1)
160            .and_then(|index| self.sections.get(index))
161            .read_error("Invalid Mach-O section index")
162    }
163
164    /// Returns the endianness.
165    pub fn endian(&self) -> Mach::Endian {
166        self.endian
167    }
168
169    /// Returns the raw data.
170    pub fn data(&self) -> R {
171        self.data
172    }
173
174    /// Returns the raw Mach-O file header.
175    #[deprecated(note = "Use `macho_header` instead")]
176    pub fn raw_header(&self) -> &'data Mach {
177        self.header
178    }
179
180    /// Get the raw Mach-O file header.
181    pub fn macho_header(&self) -> &'data Mach {
182        self.header
183    }
184
185    /// Get the Mach-O load commands.
186    pub fn macho_load_commands(&self) -> Result<LoadCommandIterator<'data, Mach::Endian>> {
187        self.header
188            .load_commands(self.endian, self.data, self.header_offset)
189    }
190
191    /// Get the Mach-O symbol table.
192    ///
193    /// Returns an empty symbol table if the file has no symbol table.
194    pub fn macho_symbol_table(&self) -> &SymbolTable<'data, Mach, R> {
195        &self.symbols
196    }
197
198    /// Return the `LC_BUILD_VERSION` load command if present.
199    pub fn build_version(&self) -> Result<Option<&'data macho::BuildVersionCommand<Mach::Endian>>> {
200        let mut commands = self
201            .header
202            .load_commands(self.endian, self.data, self.header_offset)?;
203        while let Some(command) = commands.next()? {
204            if let Some(build_version) = command.build_version()? {
205                return Ok(Some(build_version));
206            }
207        }
208        Ok(None)
209    }
210}
211
212impl<'data, Mach, R> read::private::Sealed for MachOFile<'data, Mach, R>
213where
214    Mach: MachHeader,
215    R: ReadRef<'data>,
216{
217}
218
219impl<'data, Mach, R> Object<'data> for MachOFile<'data, Mach, R>
220where
221    Mach: MachHeader,
222    R: ReadRef<'data>,
223{
224    type Segment<'file>
225        = MachOSegment<'data, 'file, Mach, R>
226    where
227        Self: 'file,
228        'data: 'file;
229    type SegmentIterator<'file>
230        = MachOSegmentIterator<'data, 'file, Mach, R>
231    where
232        Self: 'file,
233        'data: 'file;
234    type Section<'file>
235        = MachOSection<'data, 'file, Mach, R>
236    where
237        Self: 'file,
238        'data: 'file;
239    type SectionIterator<'file>
240        = MachOSectionIterator<'data, 'file, Mach, R>
241    where
242        Self: 'file,
243        'data: 'file;
244    type Comdat<'file>
245        = MachOComdat<'data, 'file, Mach, R>
246    where
247        Self: 'file,
248        'data: 'file;
249    type ComdatIterator<'file>
250        = MachOComdatIterator<'data, 'file, Mach, R>
251    where
252        Self: 'file,
253        'data: 'file;
254    type Symbol<'file>
255        = MachOSymbol<'data, 'file, Mach, R>
256    where
257        Self: 'file,
258        'data: 'file;
259    type SymbolIterator<'file>
260        = MachOSymbolIterator<'data, 'file, Mach, R>
261    where
262        Self: 'file,
263        'data: 'file;
264    type SymbolTable<'file>
265        = MachOSymbolTable<'data, 'file, Mach, R>
266    where
267        Self: 'file,
268        'data: 'file;
269    type DynamicRelocationIterator<'file>
270        = NoDynamicRelocationIterator
271    where
272        Self: 'file,
273        'data: 'file;
274
275    fn architecture(&self) -> Architecture {
276        match self.header.cputype(self.endian) {
277            macho::CPU_TYPE_ARM => Architecture::Arm,
278            macho::CPU_TYPE_ARM64 => Architecture::Aarch64,
279            macho::CPU_TYPE_ARM64_32 => Architecture::Aarch64_Ilp32,
280            macho::CPU_TYPE_X86 => Architecture::I386,
281            macho::CPU_TYPE_X86_64 => Architecture::X86_64,
282            macho::CPU_TYPE_MIPS => Architecture::Mips,
283            macho::CPU_TYPE_POWERPC => Architecture::PowerPc,
284            macho::CPU_TYPE_POWERPC64 => Architecture::PowerPc64,
285            _ => Architecture::Unknown,
286        }
287    }
288
289    fn sub_architecture(&self) -> Option<SubArchitecture> {
290        match (
291            self.header.cputype(self.endian),
292            self.header.cpusubtype(self.endian),
293        ) {
294            (macho::CPU_TYPE_ARM64, macho::CPU_SUBTYPE_ARM64E) => Some(SubArchitecture::Arm64E),
295            _ => None,
296        }
297    }
298
299    #[inline]
300    fn is_little_endian(&self) -> bool {
301        self.header.is_little_endian()
302    }
303
304    #[inline]
305    fn is_64(&self) -> bool {
306        self.header.is_type_64()
307    }
308
309    fn kind(&self) -> ObjectKind {
310        match self.header.filetype(self.endian) {
311            macho::MH_OBJECT => ObjectKind::Relocatable,
312            macho::MH_EXECUTE => ObjectKind::Executable,
313            macho::MH_CORE => ObjectKind::Core,
314            macho::MH_DYLIB => ObjectKind::Dynamic,
315            _ => ObjectKind::Unknown,
316        }
317    }
318
319    fn segments(&self) -> MachOSegmentIterator<'data, '_, Mach, R> {
320        MachOSegmentIterator {
321            file: self,
322            iter: self.segments.iter(),
323        }
324    }
325
326    fn section_by_name_bytes<'file>(
327        &'file self,
328        section_name: &[u8],
329    ) -> Option<MachOSection<'data, 'file, Mach, R>> {
330        // Translate the section_name by stripping the query_prefix to construct
331        // a function that matches names starting with name_prefix, taking into
332        // consideration the maximum section name length.
333        let make_prefix_matcher = |query_prefix: &'static [u8], name_prefix: &'static [u8]| {
334            const MAX_SECTION_NAME_LEN: usize = 16;
335            let suffix = section_name.strip_prefix(query_prefix).map(|suffix| {
336                let max_len = MAX_SECTION_NAME_LEN - name_prefix.len();
337                &suffix[..suffix.len().min(max_len)]
338            });
339            move |name: &[u8]| suffix.is_some() && name.strip_prefix(name_prefix) == suffix
340        };
341        // Matches "__text" when searching for ".text" and "__debug_str_offs"
342        // when searching for ".debug_str_offsets", as is common in
343        // macOS/Mach-O.
344        let matches_underscores_prefix = make_prefix_matcher(b".", b"__");
345        // Matches "__zdebug_info" when searching for ".debug_info" and
346        // "__zdebug_str_off" when searching for ".debug_str_offsets", as is
347        // used by Go when using GNU-style compression.
348        let matches_zdebug_prefix = make_prefix_matcher(b".debug_", b"__zdebug_");
349        self.sections().find(|section| {
350            section.name_bytes().map_or(false, |name| {
351                name == section_name
352                    || matches_underscores_prefix(name)
353                    || matches_zdebug_prefix(name)
354            })
355        })
356    }
357
358    fn section_by_index(&self, index: SectionIndex) -> Result<MachOSection<'data, '_, Mach, R>> {
359        let internal = *self.section_internal(index)?;
360        Ok(MachOSection {
361            file: self,
362            internal,
363        })
364    }
365
366    fn sections(&self) -> MachOSectionIterator<'data, '_, Mach, R> {
367        MachOSectionIterator {
368            file: self,
369            iter: self.sections.iter(),
370        }
371    }
372
373    fn comdats(&self) -> MachOComdatIterator<'data, '_, Mach, R> {
374        MachOComdatIterator { file: self }
375    }
376
377    fn symbol_by_index(&self, index: SymbolIndex) -> Result<MachOSymbol<'data, '_, Mach, R>> {
378        let nlist = self.symbols.symbol(index)?;
379        MachOSymbol::new(self, index, nlist).read_error("Unsupported Mach-O symbol index")
380    }
381
382    fn symbols(&self) -> MachOSymbolIterator<'data, '_, Mach, R> {
383        MachOSymbolIterator::new(self)
384    }
385
386    #[inline]
387    fn symbol_table(&self) -> Option<MachOSymbolTable<'data, '_, Mach, R>> {
388        Some(MachOSymbolTable { file: self })
389    }
390
391    fn dynamic_symbols(&self) -> MachOSymbolIterator<'data, '_, Mach, R> {
392        MachOSymbolIterator::empty(self)
393    }
394
395    #[inline]
396    fn dynamic_symbol_table(&self) -> Option<MachOSymbolTable<'data, '_, Mach, R>> {
397        None
398    }
399
400    fn object_map(&self) -> ObjectMap<'data> {
401        self.symbols.object_map(self.endian)
402    }
403
404    fn imports(&self) -> Result<Vec<Import<'data>>> {
405        let mut dysymtab = None;
406        let mut libraries = Vec::new();
407        let twolevel = self.header.flags(self.endian) & macho::MH_TWOLEVEL != 0;
408        if twolevel {
409            libraries.push(&[][..]);
410        }
411        let mut commands = self
412            .header
413            .load_commands(self.endian, self.data, self.header_offset)?;
414        while let Some(command) = commands.next()? {
415            if let Some(command) = command.dysymtab()? {
416                dysymtab = Some(command);
417            }
418            if twolevel {
419                if let Some(dylib) = command.dylib()? {
420                    libraries.push(command.string(self.endian, dylib.dylib.name)?);
421                }
422            }
423        }
424
425        let mut imports = Vec::new();
426        if let Some(dysymtab) = dysymtab {
427            let index = dysymtab.iundefsym.get(self.endian) as usize;
428            let number = dysymtab.nundefsym.get(self.endian) as usize;
429            for i in index..(index.wrapping_add(number)) {
430                let symbol = self.symbols.symbol(SymbolIndex(i))?;
431                let name = symbol.name(self.endian, self.symbols.strings())?;
432                let library = if twolevel {
433                    libraries
434                        .get(symbol.library_ordinal(self.endian) as usize)
435                        .copied()
436                        .read_error("Invalid Mach-O symbol library ordinal")?
437                } else {
438                    &[]
439                };
440                imports.push(Import {
441                    name: ByteString(name),
442                    library: ByteString(library),
443                });
444            }
445        }
446        Ok(imports)
447    }
448
449    fn exports(&self) -> Result<Vec<Export<'data>>> {
450        let mut dysymtab = None;
451        let mut commands = self
452            .header
453            .load_commands(self.endian, self.data, self.header_offset)?;
454        while let Some(command) = commands.next()? {
455            if let Some(command) = command.dysymtab()? {
456                dysymtab = Some(command);
457                break;
458            }
459        }
460
461        let mut exports = Vec::new();
462        if let Some(dysymtab) = dysymtab {
463            let index = dysymtab.iextdefsym.get(self.endian) as usize;
464            let number = dysymtab.nextdefsym.get(self.endian) as usize;
465            for i in index..(index.wrapping_add(number)) {
466                let symbol = self.symbols.symbol(SymbolIndex(i))?;
467                let name = symbol.name(self.endian, self.symbols.strings())?;
468                let address = symbol.n_value(self.endian).into();
469                exports.push(Export {
470                    name: ByteString(name),
471                    address,
472                });
473            }
474        }
475        Ok(exports)
476    }
477
478    #[inline]
479    fn dynamic_relocations(&self) -> Option<NoDynamicRelocationIterator> {
480        None
481    }
482
483    fn has_debug_symbols(&self) -> bool {
484        self.section_by_name(".debug_info").is_some()
485    }
486
487    fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
488        self.header.uuid(self.endian, self.data, self.header_offset)
489    }
490
491    fn relative_address_base(&self) -> u64 {
492        0
493    }
494
495    fn entry(&self) -> u64 {
496        if let Ok(mut commands) =
497            self.header
498                .load_commands(self.endian, self.data, self.header_offset)
499        {
500            while let Ok(Some(command)) = commands.next() {
501                if let Ok(Some(command)) = command.entry_point() {
502                    return command.entryoff.get(self.endian);
503                }
504            }
505        }
506        0
507    }
508
509    fn flags(&self) -> FileFlags {
510        FileFlags::MachO {
511            flags: self.header.flags(self.endian),
512        }
513    }
514}
515
516/// An iterator for the COMDAT section groups in a [`MachOFile64`].
517pub type MachOComdatIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
518    MachOComdatIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
519/// An iterator for the COMDAT section groups in a [`MachOFile64`].
520pub type MachOComdatIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
521    MachOComdatIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
522
523/// An iterator for the COMDAT section groups in a [`MachOFile`].
524///
525/// This is a stub that doesn't implement any functionality.
526#[derive(Debug)]
527pub struct MachOComdatIterator<'data, 'file, Mach, R = &'data [u8]>
528where
529    Mach: MachHeader,
530    R: ReadRef<'data>,
531{
532    #[allow(unused)]
533    file: &'file MachOFile<'data, Mach, R>,
534}
535
536impl<'data, 'file, Mach, R> Iterator for MachOComdatIterator<'data, 'file, Mach, R>
537where
538    Mach: MachHeader,
539    R: ReadRef<'data>,
540{
541    type Item = MachOComdat<'data, 'file, Mach, R>;
542
543    #[inline]
544    fn next(&mut self) -> Option<Self::Item> {
545        None
546    }
547}
548
549/// A COMDAT section group in a [`MachOFile32`].
550pub type MachOComdat32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
551    MachOComdat<'data, 'file, macho::MachHeader32<Endian>, R>;
552
553/// A COMDAT section group in a [`MachOFile64`].
554pub type MachOComdat64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
555    MachOComdat<'data, 'file, macho::MachHeader64<Endian>, R>;
556
557/// A COMDAT section group in a [`MachOFile`].
558///
559/// This is a stub that doesn't implement any functionality.
560#[derive(Debug)]
561pub struct MachOComdat<'data, 'file, Mach, R = &'data [u8]>
562where
563    Mach: MachHeader,
564    R: ReadRef<'data>,
565{
566    #[allow(unused)]
567    file: &'file MachOFile<'data, Mach, R>,
568}
569
570impl<'data, 'file, Mach, R> read::private::Sealed for MachOComdat<'data, 'file, Mach, R>
571where
572    Mach: MachHeader,
573    R: ReadRef<'data>,
574{
575}
576
577impl<'data, 'file, Mach, R> ObjectComdat<'data> for MachOComdat<'data, 'file, Mach, R>
578where
579    Mach: MachHeader,
580    R: ReadRef<'data>,
581{
582    type SectionIterator = MachOComdatSectionIterator<'data, 'file, Mach, R>;
583
584    #[inline]
585    fn kind(&self) -> ComdatKind {
586        unreachable!();
587    }
588
589    #[inline]
590    fn symbol(&self) -> SymbolIndex {
591        unreachable!();
592    }
593
594    #[inline]
595    fn name_bytes(&self) -> Result<&'data [u8]> {
596        unreachable!();
597    }
598
599    #[inline]
600    fn name(&self) -> Result<&'data str> {
601        unreachable!();
602    }
603
604    #[inline]
605    fn sections(&self) -> Self::SectionIterator {
606        unreachable!();
607    }
608}
609
610/// An iterator for the sections in a COMDAT section group in a [`MachOFile32`].
611pub type MachOComdatSectionIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
612    MachOComdatSectionIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
613/// An iterator for the sections in a COMDAT section group in a [`MachOFile64`].
614pub type MachOComdatSectionIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
615    MachOComdatSectionIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
616
617/// An iterator for the sections in a COMDAT section group in a [`MachOFile`].
618///
619/// This is a stub that doesn't implement any functionality.
620#[derive(Debug)]
621pub struct MachOComdatSectionIterator<'data, 'file, Mach, R = &'data [u8]>
622where
623    Mach: MachHeader,
624    R: ReadRef<'data>,
625{
626    #[allow(unused)]
627    file: &'file MachOFile<'data, Mach, R>,
628}
629
630impl<'data, 'file, Mach, R> Iterator for MachOComdatSectionIterator<'data, 'file, Mach, R>
631where
632    Mach: MachHeader,
633    R: ReadRef<'data>,
634{
635    type Item = SectionIndex;
636
637    fn next(&mut self) -> Option<Self::Item> {
638        None
639    }
640}
641
642/// A trait for generic access to [`macho::MachHeader32`] and [`macho::MachHeader64`].
643#[allow(missing_docs)]
644pub trait MachHeader: Debug + Pod {
645    type Word: Into<u64>;
646    type Endian: endian::Endian;
647    type Segment: Segment<Endian = Self::Endian, Section = Self::Section>;
648    type Section: Section<Endian = Self::Endian>;
649    type Nlist: Nlist<Endian = Self::Endian>;
650
651    /// Return true if this type is a 64-bit header.
652    ///
653    /// This is a property of the type, not a value in the header data.
654    fn is_type_64(&self) -> bool;
655
656    /// Return true if the `magic` field signifies big-endian.
657    fn is_big_endian(&self) -> bool;
658
659    /// Return true if the `magic` field signifies little-endian.
660    fn is_little_endian(&self) -> bool;
661
662    fn magic(&self) -> u32;
663    fn cputype(&self, endian: Self::Endian) -> u32;
664    fn cpusubtype(&self, endian: Self::Endian) -> u32;
665    fn filetype(&self, endian: Self::Endian) -> u32;
666    fn ncmds(&self, endian: Self::Endian) -> u32;
667    fn sizeofcmds(&self, endian: Self::Endian) -> u32;
668    fn flags(&self, endian: Self::Endian) -> u32;
669
670    // Provided methods.
671
672    /// Read the file header.
673    ///
674    /// Also checks that the magic field in the file header is a supported format.
675    fn parse<'data, R: ReadRef<'data>>(data: R, offset: u64) -> read::Result<&'data Self> {
676        let header = data
677            .read_at::<Self>(offset)
678            .read_error("Invalid Mach-O header size or alignment")?;
679        if !header.is_supported() {
680            return Err(Error("Unsupported Mach-O header"));
681        }
682        Ok(header)
683    }
684
685    fn is_supported(&self) -> bool {
686        self.is_little_endian() || self.is_big_endian()
687    }
688
689    fn endian(&self) -> Result<Self::Endian> {
690        Self::Endian::from_big_endian(self.is_big_endian()).read_error("Unsupported Mach-O endian")
691    }
692
693    fn load_commands<'data, R: ReadRef<'data>>(
694        &self,
695        endian: Self::Endian,
696        data: R,
697        header_offset: u64,
698    ) -> Result<LoadCommandIterator<'data, Self::Endian>> {
699        let data = data
700            .read_bytes_at(
701                header_offset + mem::size_of::<Self>() as u64,
702                self.sizeofcmds(endian).into(),
703            )
704            .read_error("Invalid Mach-O load command table size")?;
705        Ok(LoadCommandIterator::new(endian, data, self.ncmds(endian)))
706    }
707
708    /// Return the UUID from the `LC_UUID` load command, if one is present.
709    fn uuid<'data, R: ReadRef<'data>>(
710        &self,
711        endian: Self::Endian,
712        data: R,
713        header_offset: u64,
714    ) -> Result<Option<[u8; 16]>> {
715        let mut commands = self.load_commands(endian, data, header_offset)?;
716        while let Some(command) = commands.next()? {
717            if let Ok(Some(uuid)) = command.uuid() {
718                return Ok(Some(uuid.uuid));
719            }
720        }
721        Ok(None)
722    }
723}
724
725impl<Endian: endian::Endian> MachHeader for macho::MachHeader32<Endian> {
726    type Word = u32;
727    type Endian = Endian;
728    type Segment = macho::SegmentCommand32<Endian>;
729    type Section = macho::Section32<Endian>;
730    type Nlist = macho::Nlist32<Endian>;
731
732    fn is_type_64(&self) -> bool {
733        false
734    }
735
736    fn is_big_endian(&self) -> bool {
737        self.magic() == macho::MH_MAGIC
738    }
739
740    fn is_little_endian(&self) -> bool {
741        self.magic() == macho::MH_CIGAM
742    }
743
744    fn magic(&self) -> u32 {
745        self.magic.get(BigEndian)
746    }
747
748    fn cputype(&self, endian: Self::Endian) -> u32 {
749        self.cputype.get(endian)
750    }
751
752    fn cpusubtype(&self, endian: Self::Endian) -> u32 {
753        self.cpusubtype.get(endian)
754    }
755
756    fn filetype(&self, endian: Self::Endian) -> u32 {
757        self.filetype.get(endian)
758    }
759
760    fn ncmds(&self, endian: Self::Endian) -> u32 {
761        self.ncmds.get(endian)
762    }
763
764    fn sizeofcmds(&self, endian: Self::Endian) -> u32 {
765        self.sizeofcmds.get(endian)
766    }
767
768    fn flags(&self, endian: Self::Endian) -> u32 {
769        self.flags.get(endian)
770    }
771}
772
773impl<Endian: endian::Endian> MachHeader for macho::MachHeader64<Endian> {
774    type Word = u64;
775    type Endian = Endian;
776    type Segment = macho::SegmentCommand64<Endian>;
777    type Section = macho::Section64<Endian>;
778    type Nlist = macho::Nlist64<Endian>;
779
780    fn is_type_64(&self) -> bool {
781        true
782    }
783
784    fn is_big_endian(&self) -> bool {
785        self.magic() == macho::MH_MAGIC_64
786    }
787
788    fn is_little_endian(&self) -> bool {
789        self.magic() == macho::MH_CIGAM_64
790    }
791
792    fn magic(&self) -> u32 {
793        self.magic.get(BigEndian)
794    }
795
796    fn cputype(&self, endian: Self::Endian) -> u32 {
797        self.cputype.get(endian)
798    }
799
800    fn cpusubtype(&self, endian: Self::Endian) -> u32 {
801        self.cpusubtype.get(endian)
802    }
803
804    fn filetype(&self, endian: Self::Endian) -> u32 {
805        self.filetype.get(endian)
806    }
807
808    fn ncmds(&self, endian: Self::Endian) -> u32 {
809        self.ncmds.get(endian)
810    }
811
812    fn sizeofcmds(&self, endian: Self::Endian) -> u32 {
813        self.sizeofcmds.get(endian)
814    }
815
816    fn flags(&self, endian: Self::Endian) -> u32 {
817        self.flags.get(endian)
818    }
819}
object/read/macho/file.rs

object/read/macho/
file.rs
