use super::{ExtractionContext, support::append_segment};
use crate::dyld::ObjcOptimization;
use crate::util::{read_u32_le, read_u64_le};
use crate::{DyldContext, Error, Result};
use std::collections::{HashMap, HashSet};
pub const OBJC_IMAGE_IS_SIMULATED: u32 = 1 << 0;
pub const OBJC_IMAGE_IS_REPLACEMENT: u32 = 1 << 1;
pub const OBJC_IMAGE_SUPPORTS_GC: u32 = 1 << 2;
pub const OBJC_IMAGE_OPTIMIZED_BY_DYLD: u32 = 1 << 3;
pub const OBJC_IMAGE_SIGNED_CLASS_RO: u32 = 1 << 4;
pub const OBJC_IMAGE_SUPPORTS_COMPACTION: u32 = 1 << 5;
pub const METHOD_LIST_RELATIVE_FLAG: u32 = 0x8000_0000;
pub const METHOD_LIST_DIRECT_SEL_FLAG: u32 = 0x4000_0000;
pub const METHOD_LIST_TYPE_OFFSETS_FLAG: u32 = 0x2000_0000;
#[deprecated(note = "use METHOD_LIST_TYPE_OFFSETS_FLAG; this is an encoding bit")]
pub const METHOD_LIST_UNIQUED_FLAG: u32 = METHOD_LIST_TYPE_OFFSETS_FLAG;
pub const METHOD_LIST_COUNT_MASK: u32 = 0x00FF_FFFF;
pub fn fix_objc(ctx: &mut ExtractionContext) -> Result<()> {
let roots: Vec<_> = ctx
.macho
.segments()
.flat_map(|s| &s.sections)
.filter(|s| {
matches!(
s.name(),
"__objc_classlist"
| "__objc_nlclslist"
| "__objc_catlist"
| "__objc_nlcatlist"
| "__objc_protolist"
| "__objc_selrefs"
)
})
.map(|s| (s.name().to_string(), s.section.addr, s.section.size))
.collect();
if roots.is_empty() {
return Ok(());
}
let cache = std::sync::Arc::clone(&ctx.cache);
let end = cache
.mappings
.iter()
.map(|m| m.address + m.size)
.max()
.unwrap_or(0);
let base = end
.checked_add(0x3fff)
.map(|v| v & !0x3fff)
.ok_or_else(|| invalid("ObjC output address overflow"))?;
let category_class_properties = ctx
.macho
.segments()
.flat_map(|s| &s.sections)
.filter(|s| s.name() == "__objc_imageinfo" && s.section.size >= 8)
.map(|s| {
cache
.data_at_addr(s.section.addr, 8)
.map(|data| read_u32_le(&data[4..]) & (1 << 6) != 0)
})
.collect::<Result<Vec<_>>>()?
.into_iter()
.any(|v| v);
let width = ctx.macho.pointer_size();
let mut builder = ObjcBuilder {
cache: &cache,
width,
opts: cache.objc_optimization()?,
base,
category_class_properties,
data: Vec::new(),
strings: HashMap::new(),
objects: HashMap::new(),
active_lists: HashSet::new(),
};
let mut patches = Vec::new();
let mut classes = HashSet::new();
for (kind, start, size) in roots {
if size % width as u64 != 0 {
return Err(invalid("misaligned ObjC pointer section"));
}
cache.data_at_addr(start, size as usize)?;
for slot in (start..start + size).step_by(width) {
let addr = clean(cache.pointer_at(slot)?);
tracing::debug!("ObjC root {kind} at {slot:#x} -> {addr:#x}");
if addr == 0 {
continue;
}
match kind.as_str() {
"__objc_classlist" | "__objc_nlclslist" => {
let mut pending = vec![(addr, slot)];
while let Some((class, reference)) = pending.pop() {
if !ctx.macho.contains_addr(class) {
patches.push((reference, builder.class(class)?));
continue;
}
if !classes.insert(class) {
continue;
}
cache.data_at_addr(class, 5 * width)?;
let data_field = class + (4 * width) as u64;
let mask = if width == 4 { 3 } else { 7 };
let ro = clean(cache.pointer_at(data_field)?) & !mask;
if ro != 0 {
let new_ro = builder.class_ro(ro)?;
let bits = cache.pointer_at(data_field)? & mask;
patches.push((data_field, new_ro | bits));
}
let isa = clean(cache.pointer_at(class)?);
if isa != 0 && isa != class {
pending.push((isa, class));
}
}
}
"__objc_catlist" | "__objc_nlcatlist" => {
patches.push((slot, builder.category(addr)?))
}
"__objc_protolist" => patches.push((slot, builder.protocol(addr)?)),
"__objc_selrefs" => patches.push((slot, builder.string(addr)?)),
_ => unreachable!(),
}
}
}
if builder.data.is_empty() {
return Ok(());
}
append_segment(ctx, "__EXTRA_OBJC", base, &builder.data, 1)?;
for (addr, value) in patches {
let offset = ctx
.macho
.addr_to_offset(addr)
.ok_or(Error::AddressNotFound { addr })?;
ctx.macho.write_pointer(offset, value)?;
}
let image_infos: Vec<_> = ctx
.macho
.segments()
.flat_map(|s| &s.sections)
.filter(|s| s.name() == "__objc_imageinfo" && s.section.size >= 8)
.map(|s| s.section.offset as usize)
.collect();
for offset in image_infos {
let flags = ctx.macho.read_u32(offset + 4)?;
ctx.macho
.write_u32(offset + 4, flags & !OBJC_IMAGE_OPTIMIZED_BY_DYLD)?;
}
ctx.info(&format!(
"Restored Objective-C metadata ({} bytes)",
builder.data.len()
));
Ok(())
}
struct ObjcBuilder<'a> {
cache: &'a DyldContext,
width: usize,
opts: Option<ObjcOptimization>,
base: u64,
data: Vec<u8>,
category_class_properties: bool,
strings: HashMap<u64, u64>,
objects: HashMap<(u64, u8), u64>,
active_lists: HashSet<(u64, u8)>,
}
impl ObjcBuilder<'_> {
fn reserve(&mut self, size: usize) -> Result<(u64, usize)> {
let off = self
.data
.len()
.checked_add(7)
.map(|v| v & !7)
.ok_or_else(|| invalid("ObjC output size overflow"))?;
let end = off
.checked_add(size)
.filter(|n| *n <= u32::MAX as usize)
.ok_or_else(|| invalid("ObjC output exceeds file offset limit"))?;
self.base
.checked_add(end as u64)
.filter(|v| self.width == 8 || *v <= u32::MAX as u64)
.ok_or_else(|| invalid("ObjC output address overflow"))?;
self.data.resize(end, 0);
Ok((self.base + off as u64, off))
}
fn put(&mut self, off: usize, value: u64) -> Result<()> {
if self.width == 4 && value > u32::MAX as u64 {
return Err(invalid("32-bit ObjC pointer overflow"));
}
self.data[off..off + self.width].copy_from_slice(&value.to_le_bytes()[..self.width]);
Ok(())
}
fn ptr(&self, addr: u64) -> Result<u64> {
Ok(clean(self.cache.pointer_at(addr).map_err(|e| {
invalid(&format!("ObjC pointer at {addr:#x}: {e}"))
})?))
}
fn string(&mut self, addr: u64) -> Result<u64> {
if addr == 0 {
return Ok(0);
}
if let Some(&value) = self.strings.get(&addr) {
return Ok(value);
}
let string = self
.cache
.cstring_at(addr)
.map_err(|e| invalid(&format!("ObjC string {addr:#x}: {e}")))?;
let (value, off) = self.reserve(string.len())?;
self.data[off..off + string.len()].copy_from_slice(string);
self.strings.insert(addr, value);
Ok(value)
}
fn string_field(&mut self, src: u64, dst: usize) -> Result<()> {
let ptr = self.ptr(src)?;
let value = self.string(ptr)?;
self.put(dst, value)?;
Ok(())
}
fn record(&mut self, addr: u64, size: usize, pointers: &[usize]) -> Result<(u64, usize)> {
let bytes = self
.cache
.data_at_addr(addr, size)
.map_err(|e| invalid(&format!("ObjC record {addr:#x} ({size} bytes): {e}")))?;
let (value, off) = self.reserve(size)?;
self.data[off..off + size].copy_from_slice(bytes);
for &field in pointers {
let p = self.ptr(addr + field as u64)?;
self.put(off + field, p)?;
}
Ok((value, off))
}
fn class(&mut self, addr: u64) -> Result<u64> {
if addr == 0 {
return Ok(0);
}
if let Some(&value) = self.objects.get(&(addr, 7)) {
return Ok(value);
}
let w = self.width;
let (value, off) = self.record(addr, 5 * w, &[0, w, 4 * w])?;
self.objects.insert((addr, 7), value);
let isa = self.class(self.ptr(addr)?)?;
self.put(off, isa)?;
let superclass = self.class(self.ptr(addr + w as u64)?)?;
self.put(off + w, superclass)?;
let bits = self.ptr(addr + (4 * w) as u64)?;
let mask = if w == 4 { 3 } else { 7 };
let ro = self.class_ro(bits & !mask)?;
self.put(off + 4 * w, ro | (bits & mask))?;
Ok(value)
}
fn class_ro(&mut self, addr: u64) -> Result<u64> {
tracing::debug!("class_ro {addr:#x}");
if let Some(&value) = self.objects.get(&(addr, 0)) {
return Ok(value);
}
let w = self.width;
let prefix = if w == 8 { 16 } else { 12 };
let fields: Vec<_> = (0..7).map(|i| prefix + i * w).collect();
let (value, off) = self.record(addr, prefix + 7 * w, &fields)?;
self.objects.insert((addr, 0), value);
for field in [fields[0], fields[1], fields[5]] {
self.string_field(addr + field as u64, off + field)?;
}
let methods = self.methods(self.ptr(addr + fields[2] as u64)?)?;
self.put(off + fields[2], methods)?;
let protocols = self.protocol_list(self.ptr(addr + fields[3] as u64)?)?;
self.put(off + fields[3], protocols)?;
let ivars = self.fields(self.ptr(addr + fields[4] as u64)?, true)?;
self.put(off + fields[4], ivars)?;
let properties = self.fields(self.ptr(addr + fields[6] as u64)?, false)?;
self.put(off + fields[6], properties)?;
Ok(value)
}
fn category(&mut self, addr: u64) -> Result<u64> {
if let Some(&value) = self.objects.get(&(addr, 1)) {
return Ok(value);
}
let w = self.width;
let size = if self.category_class_properties {
7 * w
} else {
6 * w
};
let fields: Vec<_> = (0..size / w).map(|i| i * w).collect();
let (value, off) = self.record(addr, size, &fields)?;
self.objects.insert((addr, 1), value);
self.string_field(addr, off)?;
for field in [2 * w, 3 * w] {
let methods = self.methods(self.ptr(addr + field as u64)?)?;
self.put(off + field, methods)?;
}
let protocols = self.protocol_list(self.ptr(addr + (4 * w) as u64)?)?;
self.put(off + 4 * w, protocols)?;
let properties = self.fields(self.ptr(addr + (5 * w) as u64)?, false)?;
self.put(off + 5 * w, properties)?;
if self.category_class_properties {
let properties = self.fields(self.ptr(addr + (6 * w) as u64)?, false)?;
self.put(off + 6 * w, properties)?;
}
Ok(value)
}
fn protocol(&mut self, addr: u64) -> Result<u64> {
tracing::debug!("ObjC protocol {addr:#x}");
if addr == 0 {
return Ok(0);
}
if let Some(&value) = self.objects.get(&(addr, 2)) {
return Ok(value);
}
let w = self.width;
let minimum = 8 * w + 8;
let prefix = self.cache.data_at_addr(addr, minimum)?;
let size = read_u32_le(&prefix[8 * w..]) as usize;
if !(minimum..=4096).contains(&size) {
return Err(invalid("invalid ObjC protocol size"));
}
let fields: Vec<_> = (0..8).map(|i| i * w).collect();
let (value, off) = self.record(addr, size, &fields)?;
self.objects.insert((addr, 2), value);
self.string_field(addr + w as u64, off + w)?;
let protocols = self.protocol_list(self.ptr(addr + (2 * w) as u64)?)?;
self.put(off + 2 * w, protocols)?;
let mut count = 0;
for field in (3..7).map(|i| i * w) {
let methods = self.methods(self.ptr(addr + field as u64)?)?;
if methods != 0 {
count += read_u32_le(&self.data[(methods - self.base) as usize + 4..]) as usize;
}
self.put(off + field, methods)?;
}
let properties = self.fields(self.ptr(addr + (7 * w) as u64)?, false)?;
self.put(off + 7 * w, properties)?;
if size >= minimum + w {
let types = self.ptr(addr + minimum as u64)?;
let new_types = if types == 0 {
0
} else {
let bytes = count
.checked_mul(w)
.ok_or_else(|| invalid("protocol type count overflow"))?;
self.cache.data_at_addr(types, bytes)?;
let (v, o) = self.reserve(bytes)?;
for i in 0..count {
self.string_field(types + (i * w) as u64, o + i * w)?;
}
v
};
self.put(off + minimum, new_types)?;
}
if size >= minimum + 2 * w {
self.string_field(addr + (minimum + w) as u64, off + minimum + w)?;
}
if size >= minimum + 3 * w {
let props = self.fields(self.ptr(addr + (minimum + 2 * w) as u64)?, false)?;
self.put(off + minimum + 2 * w, props)?;
}
Ok(value)
}
fn lists(&mut self, addr: u64, kind: u8) -> Result<Vec<u64>> {
if addr == 0 {
return Ok(Vec::new());
}
if addr & 1 == 0 {
return Ok(vec![addr]);
}
if !self.active_lists.insert((addr, kind)) {
return Err(invalid("cyclic ObjC relative list"));
}
let start = addr & !1;
let h = self.cache.data_at_addr(start, 8)?;
if read_u32_le(h) != 8 {
return Err(invalid("unsupported ObjC relative list entry size"));
}
let count = read_u32_le(&h[4..]) as usize;
let bytes = self.cache.data_at_addr(
start + 8,
count
.checked_mul(8)
.ok_or_else(|| invalid("relative list size overflow"))?,
)?;
let mut out = Vec::new();
for (i, entry) in bytes.chunks_exact(8).enumerate() {
let field = start + 8 + (i * 8) as u64;
let target = field
.checked_add_signed((read_u64_le(entry) as i64) >> 16)
.ok_or_else(|| invalid("relative list address overflow"))?;
out.extend(self.lists(target, kind)?);
}
self.active_lists.remove(&(addr, kind));
Ok(out)
}
fn methods(&mut self, addr: u64) -> Result<u64> {
if addr == 0 {
return Ok(0);
}
if let Some(&value) = self.objects.get(&(addr, 3)) {
return Ok(value);
}
let mut methods = Vec::new();
for list in self.lists(addr, 3)? {
tracing::debug!("method list {list:#x}");
let h = self.cache.data_at_addr(list, 8)?;
let flags = read_u32_le(h);
let count = read_u32_le(&h[4..]) as usize;
let relative = flags & METHOD_LIST_RELATIVE_FLAG != 0;
let stride = (flags & 0xfffc) as usize;
if count == 0 {
continue;
}
if stride < if relative { 12 } else { 3 * self.width } {
return Err(invalid(&format!(
"invalid method entry size at {list:#x}: flags={flags:#x}, count={count}"
)));
}
let entries = self.cache.data_at_addr(
list + 8,
count
.checked_mul(stride)
.ok_or_else(|| invalid("method list size overflow"))?,
)?;
for (i, entry) in entries.chunks_exact(stride).enumerate() {
let field = list + 8 + (i * stride) as u64;
let (name, types, imp) = if relative {
resolve_relative_method(self.cache, self.opts, flags, field, entry)?
} else {
(
self.ptr(field)?,
self.ptr(field + self.width as u64)?,
self.ptr(field + (2 * self.width) as u64)?,
)
};
methods.push((self.string(name)?, self.string(types)?, imp));
}
}
let count = u32::try_from(methods.len()).map_err(|_| invalid("method count overflow"))?;
let stride = 3 * self.width;
let (value, off) = self.reserve(8 + methods.len() * stride)?;
self.data[off..off + 4].copy_from_slice(&(stride as u32).to_le_bytes());
self.data[off + 4..off + 8].copy_from_slice(&count.to_le_bytes());
for (i, (name, types, imp)) in methods.into_iter().enumerate() {
self.put(off + 8 + i * stride, name)?;
self.put(off + 8 + self.width + i * stride, types)?;
self.put(off + 8 + 2 * self.width + i * stride, imp)?;
}
self.objects.insert((addr, 3), value);
Ok(value)
}
fn protocol_list(&mut self, addr: u64) -> Result<u64> {
tracing::debug!("ObjC protocol list {addr:#x}");
if addr == 0 {
return Ok(0);
}
if let Some(&value) = self.objects.get(&(addr, 4)) {
return Ok(value);
}
let mut protocols = Vec::new();
for list in self.lists(addr, 4)? {
let raw_count = self.cache.data_at_addr(list, self.width)?;
let count = usize::try_from(if self.width == 4 {
read_u32_le(raw_count) as u64
} else {
read_u64_le(raw_count)
})
.map_err(|_| invalid("protocol list count overflow"))?;
self.cache.data_at_addr(
list + self.width as u64,
count
.checked_mul(self.width)
.ok_or_else(|| invalid("protocol list size overflow"))?,
)?;
for i in 0..count {
protocols.push(self.ptr(list + self.width as u64 + (i * self.width) as u64)?);
}
}
let (value, off) = self.reserve(self.width + protocols.len() * self.width)?;
self.objects.insert((addr, 4), value);
self.put(off, protocols.len() as u64)?;
for (i, p) in protocols.into_iter().enumerate() {
let v = self.protocol(p)?;
self.put(off + self.width + i * self.width, v)?;
}
Ok(value)
}
fn fields(&mut self, addr: u64, ivars: bool) -> Result<u64> {
tracing::debug!("ObjC field list {addr:#x}, ivars={ivars}");
if addr == 0 {
return Ok(0);
}
let kind = if ivars { 5 } else { 6 };
if let Some(&value) = self.objects.get(&(addr, kind)) {
return Ok(value);
}
let stride = if ivars {
3 * self.width + 8
} else {
2 * self.width
};
let mut entries = Vec::new();
for list in self.lists(addr, kind)? {
let h = self.cache.data_at_addr(list, 8)?;
let source_stride = read_u32_le(h) as usize;
let count = read_u32_le(&h[4..]) as usize;
if count == 0 {
continue;
}
if source_stride < stride {
return Err(invalid(&format!(
"invalid property/ivar entry size {source_stride} at {list:#x} (ivars={ivars}, count={count})"
)));
}
self.cache.data_at_addr(
list + 8,
count
.checked_mul(source_stride)
.ok_or_else(|| invalid("field list size overflow"))?,
)?;
for i in 0..count {
entries.push(list + 8 + (i * source_stride) as u64);
}
}
let (value, off) = self.reserve(8 + entries.len() * stride)?;
self.data[off..off + 4].copy_from_slice(&(stride as u32).to_le_bytes());
self.data[off + 4..off + 8].copy_from_slice(&(entries.len() as u32).to_le_bytes());
for (i, src) in entries.into_iter().enumerate() {
let dst = off + 8 + i * stride;
self.data[dst..dst + stride].copy_from_slice(self.cache.data_at_addr(src, stride)?);
if ivars {
let ptr = self.ptr(src)?;
if ptr != 0 {
let bytes = self.cache.data_at_addr(ptr, 4)?;
let (v, o) = self.reserve(4)?;
self.data[o..o + 4].copy_from_slice(bytes);
self.put(dst, v)?;
}
self.string_field(src + self.width as u64, dst + self.width)?;
self.string_field(src + (2 * self.width) as u64, dst + 2 * self.width)?;
} else {
self.string_field(src, dst)?;
self.string_field(src + self.width as u64, dst + self.width)?;
}
}
self.objects.insert((addr, kind), value);
Ok(value)
}
}
fn resolve_relative_method(
cache: &DyldContext,
opts: Option<ObjcOptimization>,
flags: u32,
field: u64,
entry: &[u8],
) -> Result<(u64, u64, u64)> {
let relative = |base: u64, off: usize| {
base.checked_add_signed(read_u32_le(&entry[off..]) as i32 as i64)
.ok_or_else(|| invalid("relative method address overflow"))
};
let name = if flags & METHOD_LIST_DIRECT_SEL_FLAG != 0 {
relative(opts.map_or(field, |o| o.selector_base), 0)?
} else {
clean(cache.pointer_at(relative(field, 0)?)?)
};
let types = if flags & METHOD_LIST_TYPE_OFFSETS_FLAG != 0 {
relative(
opts.ok_or_else(|| invalid("base-relative method types without selector base"))?
.selector_base,
4,
)?
} else if read_u32_le(&entry[4..]) == 0 {
0
} else {
relative(field + 4, 4)?
};
Ok((name, types, relative(field + 8, 8)?))
}
fn clean(pointer: u64) -> u64 {
pointer & 0x0000_ffff_ffff_ffff
}
fn invalid(reason: &str) -> Error {
Error::Parse {
offset: 0,
reason: reason.into(),
}
}