use crate::error::{Error, Result};
use crate::macho::{self, MachOView, Segment};
use crate::slot::ImportSlot;
use core::ffi::{c_char, c_int, c_void};
use mach2::dyld;
use mach2::kern_return::KERN_SUCCESS;
use mach2::traps::mach_task_self;
use mach2::vm::mach_vm_region;
use mach2::vm_region::{VM_REGION_BASIC_INFO_64, vm_region_basic_info_data_64_t};
use std::sync::{Arc, OnceLock};
#[derive(Debug, Clone)]
pub struct Module {
base: usize,
slide: isize,
segments: Vec<Segment>,
cpu_type: u32,
cpu_subtype: u32,
span: (usize, usize),
path: String,
thin_slice: OnceLock<Option<Arc<[u8]>>>,
}
unsafe fn read_mem(addr: usize, buf: &mut [u8]) {
unsafe {
core::ptr::copy_nonoverlapping(addr as *const u8, buf.as_mut_ptr(), buf.len());
}
}
fn locate(segments: &[Segment], slide: isize, off: u64, len: u64) -> Result<usize> {
for seg in segments {
if off >= seg.fileoff && off < seg.fileoff.saturating_add(seg.filesize) {
if off
.checked_add(len)
.is_none_or(|end| end > seg.fileoff.saturating_add(seg.filesize))
{
return Err(Error::Malformed("read spans past the segment"));
}
let vaddr = seg
.vmadd
.checked_add(off - seg.fileoff)
.ok_or(Error::Malformed("segment vaddr overflow"))?;
let addr = usize::try_from(vaddr).map_err(|_| Error::Malformed("address overflow"))?;
return Ok(addr.wrapping_add_signed(slide));
}
}
Err(Error::Malformed("file offset outside any segment"))
}
impl MachOView for Module {
fn cpu_type(&self) -> u32 {
self.cpu_type
}
fn cpu_subtype(&self) -> u32 {
self.cpu_subtype
}
fn read(&self, off: u64, buf: &mut [u8]) -> Result<()> {
let addr = locate(&self.segments, self.slide, off, buf.len() as u64)?;
unsafe { read_mem(addr, buf) };
Ok(())
}
fn file_backed(&self) -> bool {
self.thin_slice().is_some()
}
fn read_slot_encoding(&self, off: u64) -> Result<u64> {
let bytes = self
.thin_slice()
.ok_or(Error::Malformed("no on-disk file bytes"))?;
let start = usize::try_from(off).map_err(|_| Error::Malformed("offset overflow"))?;
let end = start
.checked_add(8)
.ok_or(Error::Malformed("read overflow"))?;
let slice = bytes
.get(start..end)
.ok_or(Error::Malformed("chain read past file end"))?;
let arr: [u8; 8] = slice
.try_into()
.map_err(|_| Error::Malformed("chain read"))?;
Ok(u64::from_le_bytes(arr))
}
fn slot_address(&self, off: u64) -> Result<u64> {
let addr = locate(
&self.segments,
self.slide,
off,
crate::arch::PTR_SIZE as u64,
)?;
if !addr.is_multiple_of(core::mem::align_of::<usize>()) {
return Err(Error::Malformed("slot is not pointer-aligned"));
}
Ok(addr as u64)
}
}
struct HeaderView {
base: usize,
limit: u64,
}
const MAX_HEADER_SPAN: u64 = 64 << 20;
fn mapped_extent_from(addr: usize) -> u64 {
let task = unsafe { mach_task_self() };
let mut region_addr = addr as u64;
let mut region_size: u64 = 0;
let mut info: vm_region_basic_info_data_64_t = unsafe { core::mem::zeroed() };
let mut count = vm_region_basic_info_data_64_t::count();
let mut object_name: mach2::port::mach_port_t = 0;
let kr = unsafe {
mach_vm_region(
task,
&raw mut region_addr,
&raw mut region_size,
VM_REGION_BASIC_INFO_64,
(&raw mut info).cast::<c_int>(),
&raw mut count,
&raw mut object_name,
)
};
let target = addr as u64;
if kr == KERN_SUCCESS
&& region_addr <= target
&& let Some(region_end) = region_addr.checked_add(region_size)
&& target < region_end
{
region_end - target
} else {
MAX_HEADER_SPAN
}
}
impl MachOView for HeaderView {
fn cpu_type(&self) -> u32 {
let mut b = [0u8; 4];
unsafe { read_mem(self.base + 4, &mut b) };
u32::from_le_bytes(b)
}
fn cpu_subtype(&self) -> u32 {
let mut b = [0u8; 4];
unsafe { read_mem(self.base + 8, &mut b) };
u32::from_le_bytes(b)
}
fn read(&self, off: u64, buf: &mut [u8]) -> Result<()> {
let end = off
.checked_add(buf.len() as u64)
.ok_or(Error::Malformed("read overflow"))?;
if end > self.limit {
return Err(Error::Malformed("header read out of range"));
}
let addr = self
.base
.checked_add(usize::try_from(off).unwrap_or(usize::MAX))
.ok_or(Error::Malformed("header address overflow"))?;
unsafe { read_mem(addr, buf) };
Ok(())
}
fn file_backed(&self) -> bool {
false
}
fn read_slot_encoding(&self, _off: u64) -> Result<u64> {
Err(Error::Malformed("bootstrap view has no slot encodings"))
}
fn slot_address(&self, _off: u64) -> Result<u64> {
Err(Error::Malformed("bootstrap view resolves no slots"))
}
}
impl Module {
pub unsafe fn from_address(address: *const c_void) -> Result<Self> {
let mut info: libc::Dl_info = unsafe { core::mem::zeroed() };
if unsafe { libc::dladdr(address, &raw mut info) } == 0 {
return Err(Error::ModuleNotFound {
reason: "address",
os_error: 0,
});
}
let base = info.dli_fbase as usize;
Self::from_base(base)
}
pub fn from_name(name: &str) -> Result<Self> {
let count = unsafe { dyld::_dyld_image_count() };
for i in 0..count {
let Some(image_name) = image_name(i) else {
continue;
};
let matches = if name.starts_with('/') {
image_name == name
} else {
image_name.ends_with(name)
};
if matches {
return Self::from_index(i);
}
}
Err(Error::ModuleNotFound {
reason: "name",
os_error: 0,
})
}
pub unsafe fn from_handle(handle: *mut c_void) -> Result<Self> {
if handle.is_null() {
return Err(Error::ModuleNotFound {
reason: "null handle",
os_error: 0,
});
}
let count = unsafe { dyld::_dyld_image_count() };
for extra in [0, libc::RTLD_FIRST] {
let flags = libc::RTLD_LAZY | libc::RTLD_NOLOAD | extra;
for i in 0..count {
let c_name: Option<Vec<u8>> = if i == 0 {
None
} else {
let Some(name) = image_name(i) else { continue };
let mut bytes: Vec<u8> = name.into_bytes();
bytes.push(0);
Some(bytes)
};
let path_ptr = match &c_name {
None => core::ptr::null(),
Some(bytes) => bytes.as_ptr().cast::<c_char>(),
};
let probe = unsafe { libc::dlopen(path_ptr, flags) };
if probe.is_null() {
continue;
}
unsafe { libc::dlclose(probe) };
if probe == handle {
return Self::from_index(i);
}
}
}
Err(Error::ModuleNotFound {
reason: "handle",
os_error: 0,
})
}
pub fn enumerate() -> Result<Vec<Self>> {
let count = unsafe { dyld::_dyld_image_count() };
let mut out = Vec::new();
for i in 0..count {
if let Ok(module) = Self::from_index(i) {
out.push(module);
}
}
Ok(out)
}
fn from_base(base: usize) -> Result<Self> {
let count = unsafe { dyld::_dyld_image_count() };
for i in 0..count {
if unsafe { dyld::_dyld_get_image_header(i) } as usize == base {
return Self::from_index(i);
}
}
Err(Error::ModuleNotFound {
reason: "base",
os_error: 0,
})
}
fn from_index(idx: u32) -> Result<Self> {
let header = unsafe { dyld::_dyld_get_image_header(idx) } as usize;
if header == 0 {
return Err(Error::ModuleNotFound {
reason: "index",
os_error: 0,
});
}
let slide = unsafe { dyld::_dyld_get_image_vmaddr_slide(idx) };
let path = image_name(idx).unwrap_or_default();
let mut magic = [0u8; 4];
unsafe { read_mem(header, &mut magic) };
if u32::from_le_bytes(magic) != macho::MH_MAGIC_64 {
return Err(Error::Unsupported(
"image is not a little-endian 64-bit Mach-O",
));
}
let boot = HeaderView {
base: header,
limit: mapped_extent_from(header),
};
if !crate::arch::macho_cpu_supported(boot.cpu_type()) {
return Err(Error::Unsupported("Mach-O cputype is not x86-64 or arm64"));
}
let segments = macho::segments_of(&boot)?;
if segments.is_empty() {
return Err(Error::Malformed("image has no LC_SEGMENT_64"));
}
let span = span_of(&segments, slide)?;
Ok(Self {
base: header,
slide,
segments,
cpu_type: boot.cpu_type(),
cpu_subtype: boot.cpu_subtype(),
span,
path,
thin_slice: OnceLock::new(),
})
}
#[must_use]
pub fn name(&self) -> &str {
match self.path.rfind('/') {
Some(pos) => self.path.get(pos + 1..).unwrap_or(&self.path),
None => &self.path,
}
}
#[must_use]
pub fn path(&self) -> &str {
&self.path
}
#[must_use]
pub fn base(&self) -> *const c_void {
self.base as *const c_void
}
#[must_use]
pub fn size(&self) -> usize {
self.span.1.saturating_sub(self.span.0)
}
pub(crate) fn base_addr(&self) -> usize {
self.base
}
fn thin_slice(&self) -> Option<&[u8]> {
self.thin_slice
.get_or_init(|| load_thin_slice(&self.path, self.cpu_type, self.cpu_subtype))
.as_deref()
}
pub fn imports(&self) -> Result<Vec<ImportSlot>> {
Ok(macho::parse_imports(self)?
.into_iter()
.map(|raw| ImportSlot::from_raw(self.base, raw))
.collect())
}
}
fn image_name(idx: u32) -> Option<String> {
let ptr = unsafe { dyld::_dyld_get_image_name(idx) };
if ptr.is_null() {
return None;
}
Some(
unsafe { core::ffi::CStr::from_ptr(ptr) }
.to_string_lossy()
.into_owned(),
)
}
fn span_of(segments: &[Segment], slide: isize) -> Result<(usize, usize)> {
let mut lo = usize::MAX;
let mut hi = 0usize;
for seg in segments {
let vmaddr =
usize::try_from(seg.vmaddr).map_err(|_| Error::Malformed("vmaddr overflow"))?;
let vmsize = usize::try_from(seg.vmsize).unwrap_or(0);
let start = vmaddr.wrapping_add_signed(slide);
let end = start.wrapping_add(vmsize);
lo = lo.min(start);
hi = hi.max(end);
}
Ok(if lo == usize::MAX { (0, 0) } else { (lo, hi) })
}
fn load_thin_slice(path: &str, cpu_type: u32, cpu_subtype: u32) -> Option<Arc<[u8]>> {
let file = std::fs::read(path).ok()?;
let range = macho::thin_slice_range(&file, cpu_type, cpu_subtype).ok()?;
Some(Arc::from(file.get(range)?))
}