vendor/object/src/read/macho/load_command.rs

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