use object::{
Endianness, macho,
read::{
Object, ObjectSection, StringTable,
macho::{MachHeader, MachOFile64, Nlist, Section},
},
};
use crate::{
error::{Error, Result},
macho::{
constants::{
CPU_TYPE_ARM64, CPU_TYPE_X86_64, FAT_CIGAM, FAT_CIGAM_64,
FAT_MAGIC, FAT_MAGIC_64, MH_CIGAM, MH_CIGAM_64, MH_MAGIC,
MH_MAGIC_64, MH_OBJECT,
},
structs::{MachReloc, MachSection, MachSymbol},
},
util::trim_nul,
};
pub struct MachOFile<'data> {
inner: MachOFile64<'data>,
}
#[derive(Clone, Copy)]
pub struct MachSymbolTable<'data> {
syms: &'data [macho::Nlist64<Endianness>],
strings: StringTable<'data, &'data [u8]>,
endian: Endianness,
}
impl<'data> MachOFile<'data> {
pub fn parse(bytes: &'data [u8]) -> Result<Self> {
reject_non_object(bytes)?;
let inner = MachOFile64::parse(bytes)
.map_err(|_| Error::Format("invalid Mach-O header"))?;
Ok(Self { inner })
}
pub fn cpu_type(&self) -> u32 {
self.inner.macho_header().cputype(self.inner.endian())
}
pub fn cpu_subtype(&self) -> u32 {
self.inner.macho_header().cpusubtype(self.inner.endian())
}
pub fn filetype(&self) -> u32 {
self.inner.macho_header().filetype(self.inner.endian())
}
pub fn is_object(&self) -> bool {
self.filetype() == MH_OBJECT
}
pub fn is_x86_64(&self) -> bool {
self.cpu_type() == CPU_TYPE_X86_64
}
pub fn is_arm64(&self) -> bool {
self.cpu_type() == CPU_TYPE_ARM64
}
pub fn entry(&self) -> u64 {
self.inner.entry()
}
pub fn section_addr(&self, n_sect: u8) -> Option<u64> {
let endian = self.inner.endian();
let zero_based = usize::from(n_sect).checked_sub(1)?;
self.inner
.sections()
.nth(zero_based)
.map(|s| s.macho_section().addr(endian))
}
pub fn sections(&self) -> Vec<MachSection<'data>> {
let endian = self.inner.endian();
let cputype = self.cpu_type();
let mut out = Vec::new();
for (i, section) in self.inner.sections().enumerate() {
let raw = section.macho_section();
let relocs = section.macho_relocations().map_or_else(
|_| Vec::new(),
|e| decode_relocations(endian, cputype, e),
);
let data = section.data().unwrap_or(&[]);
out.push(MachSection {
index: u32::try_from(i + 1).unwrap_or(u32::MAX),
sectname: trim_nul(raw.name()),
segname: trim_nul(raw.segment_name()),
addr: raw.addr(endian),
size: raw.size(endian),
align: raw.align(endian),
flags: raw.flags(endian),
data,
relocations: relocs,
});
}
out
}
pub fn symbols(&self) -> MachSymbolTable<'data> {
let table = self.inner.macho_symbol_table();
MachSymbolTable {
syms: table.iter().as_slice(),
strings: table.strings(),
endian: self.inner.endian(),
}
}
}
impl<'data> MachSymbolTable<'data> {
pub fn len(&self) -> usize {
self.syms.len()
}
pub fn is_empty(&self) -> bool {
self.syms.is_empty()
}
pub fn nth(&self, index: usize) -> Option<MachSymbol<'data>> {
let n = self.syms.get(index)?;
Some(decode_symbol(n, self.strings, self.endian))
}
pub fn iter(&self) -> MachSymbolIter<'data> {
MachSymbolIter {
syms: self.syms.iter(),
strings: self.strings,
endian: self.endian,
}
}
}
pub struct MachSymbolIter<'a> {
syms: core::slice::Iter<'a, macho::Nlist64<Endianness>>,
strings: StringTable<'a, &'a [u8]>,
endian: Endianness,
}
impl<'a> Iterator for MachSymbolIter<'a> {
type Item = MachSymbol<'a>;
fn next(&mut self) -> Option<Self::Item> {
let n = self.syms.next()?;
Some(decode_symbol(n, self.strings, self.endian))
}
}
fn decode_symbol<'data>(
n: &'data macho::Nlist64<Endianness>,
strings: StringTable<'data, &'data [u8]>,
endian: Endianness,
) -> MachSymbol<'data> {
MachSymbol {
name: n.name(endian, strings).unwrap_or(&[]),
n_strx: n.n_strx(endian),
n_type: n.n_type(),
n_sect: n.n_sect(),
n_desc: n.n_desc(endian),
n_value: n.n_value(endian),
}
}
impl<'data> IntoIterator for &'data MachSymbolTable<'data> {
type Item = MachSymbol<'data>;
type IntoIter = MachSymbolIter<'data>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
fn reject_non_object(bytes: &[u8]) -> Result<()> {
match magic_u32(bytes) {
MH_MAGIC_64 | MH_CIGAM_64 => Ok(()),
MH_MAGIC | MH_CIGAM => {
Err(Error::Format("32-bit Mach-O is not supported"))
}
FAT_MAGIC | FAT_MAGIC_64 | FAT_CIGAM | FAT_CIGAM_64 => {
Err(Error::Format("fat Mach-O is not supported"))
}
_ => Err(Error::Format("not a Mach-O object")),
}
}
fn magic_u32(bytes: &[u8]) -> u32 {
let mut wide = [0u8; 4];
let n = wide.len().min(bytes.len());
wide[..n].copy_from_slice(&bytes[..n]);
u32::from_le_bytes(wide)
}
fn decode_relocations(
endian: Endianness,
cputype: u32,
entries: &[macho::Relocation<Endianness>],
) -> Vec<MachReloc> {
let mut out = Vec::with_capacity(entries.len());
for reloc in entries {
if reloc.r_scattered(endian, cputype) {
let info = reloc.scattered_info(endian);
out.push(MachReloc {
r_address: info.r_address,
r_symbolnum: info.r_value,
r_pcrel: info.r_pcrel,
r_length: info.r_length,
r_extern: false,
r_type: info.r_type,
r_scattered: true,
});
} else {
let info = reloc.info(endian);
out.push(MachReloc {
r_address: info.r_address,
r_symbolnum: info.r_symbolnum,
r_pcrel: info.r_pcrel,
r_length: info.r_length,
r_extern: info.r_extern,
r_type: info.r_type,
r_scattered: false,
});
}
}
out
}