use alloc::string::String;
use alloc::vec::Vec;
use crate::errors::FileParseError;
pub mod bind_imm {
pub const SELF: i8 = -1;
pub const FLAT_LOOKUP: i8 = -2;
pub const WEAK_LOOKUP: i8 = -3;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BindOpcode {
Done,
SetDylibOrdinalUleb(u64),
SetDylibOrdinalImm(i8),
SetDylibSpecialImm(i8),
SetSymbolTrailingFlagsImm(u8),
SetTypeImm(u8),
SetAddendSleb(i64),
SetSegmentAndOffsetUleb {
segment: u64,
offset: u64,
},
AddAddrUleb(u64),
DoBind,
DoBindAddAddrUleb(u64),
DoBindAddAddrImmScaled(u8),
DoBindUlebTimesSkippingUleb {
count: u64,
skip: u64,
},
Unknown(u8),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExportTrieEntry {
pub name: String,
pub flags: u64,
pub address: Option<u64>,
pub reexport_dylib: Option<u64>,
pub reexport_name: Option<String>,
pub resolver: Option<u64>,
}
const EXPORT_SYMBOL_FLAGS_REEXPORT: u64 = 0x08;
const EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER: u64 = 0x10;
pub fn decode_bind_opcodes(data: &[u8]) -> Result<Vec<BindOpcode>, FileParseError> {
let mut out = Vec::new();
let mut pos = 0usize;
while pos < data.len() {
let byte = data[pos];
pos += 1;
let op = match byte {
0x00 => BindOpcode::Done,
0x10 => {
let (v, n) = read_uleb128(data, pos)?;
pos += n;
BindOpcode::SetDylibOrdinalUleb(v)
}
b if (b & 0xF0) == 0x40 => BindOpcode::SetDylibOrdinalImm((b & 0x0F) as i8),
b if (b & 0xF0) == 0x30 => BindOpcode::SetDylibSpecialImm(-((b & 0x0F) as i8)),
b if (b & 0xF0) == 0x50 => BindOpcode::SetSymbolTrailingFlagsImm(b & 0x0F),
b if (b & 0xF0) == 0x70 => BindOpcode::SetTypeImm(b & 0x0F),
0x80 => {
let (v, n) = read_sleb128(data, pos)?;
pos += n;
BindOpcode::SetAddendSleb(v)
}
0x90 => {
let (seg, n1) = read_uleb128(data, pos)?;
pos += n1;
let (off, n2) = read_uleb128(data, pos)?;
pos += n2;
BindOpcode::SetSegmentAndOffsetUleb {
segment: seg,
offset: off,
}
}
0xA0 => {
let (v, n) = read_uleb128(data, pos)?;
pos += n;
BindOpcode::AddAddrUleb(v)
}
0xB0 => BindOpcode::DoBind,
0xC0 => {
let (v, n) = read_uleb128(data, pos)?;
pos += n;
BindOpcode::DoBindAddAddrUleb(v)
}
b if (b & 0xF0) == 0xD0 => BindOpcode::DoBindAddAddrImmScaled(b & 0x0F),
0xE0 => {
let (count, n1) = read_uleb128(data, pos)?;
pos += n1;
let (skip, n2) = read_uleb128(data, pos)?;
pos += n2;
BindOpcode::DoBindUlebTimesSkippingUleb { count, skip }
}
other => BindOpcode::Unknown(other),
};
out.push(op);
if matches!(out.last(), Some(BindOpcode::Done)) {
break;
}
}
Ok(out)
}
pub fn decode_export_trie(data: &[u8]) -> Result<Vec<ExportTrieEntry>, FileParseError> {
let mut out = Vec::new();
let mut pending = alloc::vec![(0usize, String::new())];
let mut visited = alloc::vec![false; data.len()];
while let Some((node_offset, prefix)) = pending.pop() {
if node_offset >= data.len() {
return Err(FileParseError::BufferOverflow);
}
if visited[node_offset] {
return Err(FileParseError::InvalidFileFormat);
}
visited[node_offset] = true;
let mut pos = node_offset;
let terminal_size = if data[pos] & 0x80 != 0 {
let (value, width) = read_uleb128(data, pos)?;
pos += width;
usize::try_from(value).map_err(|_| FileParseError::BufferOverflow)?
} else {
let value = data[pos] as usize;
pos += 1;
value
};
if terminal_size > 0 {
let term_end = pos
.checked_add(terminal_size)
.ok_or(FileParseError::BufferOverflow)?;
let term = data
.get(pos..term_end)
.ok_or(FileParseError::BufferOverflow)?;
pos = term_end;
if let Some(entry) = parse_terminal_export(prefix.clone(), term)? {
out.push(entry);
}
}
let Some(&child_count) = data.get(pos) else {
continue;
};
pos += 1;
let mut children = Vec::with_capacity(child_count as usize);
for _ in 0..child_count {
let tail = data.get(pos..).ok_or(FileParseError::BufferOverflow)?;
let end = tail
.iter()
.position(|b| *b == 0)
.ok_or(FileParseError::BufferOverflow)?;
let edge = core::str::from_utf8(&tail[..end])
.map_err(|_| FileParseError::InvalidFileFormat)?;
pos += end + 1;
let (child_offset, width) = read_uleb128(data, pos)?;
pos += width;
let child_offset =
usize::try_from(child_offset).map_err(|_| FileParseError::BufferOverflow)?;
let mut child_prefix = prefix.clone();
child_prefix.push_str(edge);
children.push((child_offset, child_prefix));
}
pending.extend(children.into_iter().rev());
}
Ok(out)
}
fn parse_terminal_export(
name: String,
term: &[u8],
) -> Result<Option<ExportTrieEntry>, FileParseError> {
if term.is_empty() {
return Ok(None);
}
let (flags, n1) = read_uleb128(term, 0)?;
let mut pos = n1;
if flags & EXPORT_SYMBOL_FLAGS_REEXPORT != 0 {
let (dylib, n2) = read_uleb128(term, pos)?;
pos += n2;
let reexport_name = read_cstring(term, pos)?;
return Ok(Some(ExportTrieEntry {
name,
flags,
address: None,
reexport_dylib: Some(dylib),
reexport_name: Some(reexport_name),
resolver: None,
}));
}
let (address, n3) = read_uleb128(term, pos)?;
pos += n3;
let resolver = if flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER != 0 {
let (r, n4) = read_uleb128(term, pos)?;
pos += n4;
Some(r)
} else {
None
};
let _ = pos;
Ok(Some(ExportTrieEntry {
name,
flags,
address: Some(address),
reexport_dylib: None,
reexport_name: None,
resolver,
}))
}
fn read_cstring(data: &[u8], offset: usize) -> Result<String, FileParseError> {
let slice = data.get(offset..).ok_or(FileParseError::BufferOverflow)?;
let stop = slice.iter().position(|&b| b == 0).unwrap_or(slice.len());
Ok(String::from_utf8_lossy(&slice[..stop]).into_owned())
}
fn read_uleb128(data: &[u8], mut offset: usize) -> Result<(u64, usize), FileParseError> {
let start = offset;
let mut result = 0u64;
let mut shift = 0u32;
loop {
let byte = *data.get(offset).ok_or(FileParseError::BufferOverflow)?;
offset += 1;
result |= ((byte & 0x7F) as u64) << shift;
if byte & 0x80 == 0 {
break;
}
shift += 7;
if shift > 63 {
return Err(FileParseError::InvalidFileFormat);
}
}
Ok((result, offset - start))
}
fn read_sleb128(data: &[u8], mut offset: usize) -> Result<(i64, usize), FileParseError> {
let start = offset;
let mut result = 0i64;
let mut shift = 0u32;
let mut byte;
loop {
byte = *data.get(offset).ok_or(FileParseError::BufferOverflow)?;
offset += 1;
result |= ((byte & 0x7F) as i64) << shift;
shift += 7;
if byte & 0x80 == 0 {
break;
}
if shift > 63 {
return Err(FileParseError::InvalidFileFormat);
}
}
if shift < 64 && (byte & 0x40) != 0 {
result |= !0i64 << shift;
}
Ok((result, offset - start))
}
pub const DYLD_CHAINED_IMPORT: u32 = 1;
pub const DYLD_CHAINED_IMPORT_ADDEND: u32 = 2;
pub const DYLD_CHAINED_IMPORT_ADDEND64: u32 = 3;
pub const DYLD_CHAINED_PTR_ARM64E: u16 = 1;
pub const DYLD_CHAINED_PTR_64: u16 = 2;
pub const DYLD_CHAINED_PTR_32: u16 = 3;
pub const DYLD_CHAINED_PTR_32_CACHE: u16 = 4;
pub const DYLD_CHAINED_PTR_32_FIRMWARE: u16 = 5;
pub const DYLD_CHAINED_PTR_64_OFFSET: u16 = 6;
pub const DYLD_CHAINED_PTR_ARM64E_KERNEL: u16 = 7;
pub const DYLD_CHAINED_PTR_64_KERNEL_CACHE: u16 = 8;
pub const DYLD_CHAINED_PTR_ARM64E_USERLAND: u16 = 9;
pub const DYLD_CHAINED_PTR_ARM64E_FIRMWARE: u16 = 10;
pub const DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE: u16 = 11;
pub const DYLD_CHAINED_PTR_ARM64E_USERLAND24: u16 = 12;
pub const DYLD_CHAINED_PTR_ARM64E_SHARED_CACHE: u16 = 13;
pub const DYLD_CHAINED_PTR_ARM64E_SEGMENTED: u16 = 14;
pub const DYLD_CHAINED_PTR_START_NONE: u16 = 0xffff;
pub const DYLD_CHAINED_PTR_START_MULTI: u16 = 0x8000;
pub const DYLD_CHAINED_PTR_START_LAST: u16 = 0x8000;
pub fn chained_pointer_stride(format: u16) -> Option<u16> {
match format {
DYLD_CHAINED_PTR_ARM64E
| DYLD_CHAINED_PTR_ARM64E_USERLAND
| DYLD_CHAINED_PTR_ARM64E_USERLAND24
| DYLD_CHAINED_PTR_ARM64E_SHARED_CACHE => Some(8),
DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE => Some(1),
2..=8 | DYLD_CHAINED_PTR_ARM64E_FIRMWARE | DYLD_CHAINED_PTR_ARM64E_SEGMENTED => Some(4),
_ => None,
}
}
pub fn chained_pointer_width(format: u16) -> usize {
match format {
DYLD_CHAINED_PTR_32 | DYLD_CHAINED_PTR_32_CACHE | DYLD_CHAINED_PTR_32_FIRMWARE => 4,
_ => 8,
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ChainedImport {
pub library_ordinal: i32,
pub weak: bool,
pub addend: i64,
pub name: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ChainedSegment {
pub segment_index: usize,
pub page_size: u16,
pub pointer_format: u16,
pub segment_offset: u64,
pub max_valid_pointer: u32,
pub page_count: u16,
pub page_starts: Vec<u16>,
}
impl ChainedSegment {
pub fn chain_starts(&self, page: usize) -> ChainStarts<'_> {
let mut starts = ChainStarts {
table: &self.page_starts,
next: None,
single: None,
};
if page >= usize::from(self.page_count) {
return starts;
}
match self.page_starts.get(page).copied() {
Some(DYLD_CHAINED_PTR_START_NONE) | None => {}
Some(start) if start & DYLD_CHAINED_PTR_START_MULTI != 0 => {
starts.next = Some(usize::from(start & !DYLD_CHAINED_PTR_START_MULTI));
}
Some(start) => starts.single = Some(start),
}
starts
}
pub fn decode_pointer(&self, word: u64) -> Result<ChainedPointer, FileParseError> {
decode_chained_pointer_as(self.pointer_format, self.max_valid_pointer, word)
}
}
#[derive(Clone, Debug)]
pub struct ChainStarts<'a> {
table: &'a [u16],
next: Option<usize>,
single: Option<u16>,
}
impl Iterator for ChainStarts<'_> {
type Item = u16;
fn next(&mut self) -> Option<u16> {
if let Some(start) = self.single.take() {
return Some(start);
}
let index = self.next?;
let entry = *self.table.get(index)?;
self.next = (entry & DYLD_CHAINED_PTR_START_LAST == 0).then_some(index + 1);
Some(entry & !DYLD_CHAINED_PTR_START_LAST)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ChainedFixups {
pub imports_format: u32,
pub imports: Vec<ChainedImport>,
pub segments: Vec<ChainedSegment>,
}
pub fn decode_chained_fixups(data: &[u8]) -> Result<ChainedFixups, FileParseError> {
fn bytes<const N: usize>(data: &[u8], offset: usize) -> Result<[u8; N], FileParseError> {
data.get(
offset
..offset
.checked_add(N)
.ok_or(FileParseError::BufferOverflow)?,
)
.ok_or(FileParseError::BufferOverflow)?
.try_into()
.map_err(|_| FileParseError::BufferOverflow)
}
fn word(data: &[u8], offset: usize) -> Result<u32, FileParseError> {
bytes(data, offset).map(u32::from_le_bytes)
}
fn half(data: &[u8], offset: usize) -> Result<u16, FileParseError> {
bytes(data, offset).map(u16::from_le_bytes)
}
fn quad(data: &[u8], offset: usize) -> Result<u64, FileParseError> {
bytes(data, offset).map(u64::from_le_bytes)
}
let imports_format = word(data, 20)?;
let record_size = match imports_format {
DYLD_CHAINED_IMPORT => 4,
DYLD_CHAINED_IMPORT_ADDEND => 8,
DYLD_CHAINED_IMPORT_ADDEND64 => 16,
_ => 0,
};
if word(data, 0)? != 0 || record_size == 0 {
return Err(FileParseError::UnsupportedFeature(String::from(
"chained fixup encoding",
)));
}
if word(data, 24)? != 0 {
return Err(FileParseError::UnsupportedFeature(String::from(
"compressed chained fixup symbols",
)));
}
let mut remaining = data.len().saturating_mul(8);
let imports_offset = word(data, 8)? as usize;
let symbols_offset = word(data, 12)? as usize;
let count = word(data, 16)? as usize;
if count > data.len() / record_size {
return Err(FileParseError::BufferOverflow);
}
let imports_end = count
.checked_mul(record_size)
.and_then(|size| imports_offset.checked_add(size))
.ok_or(FileParseError::BufferOverflow)?;
data.get(imports_offset..imports_end)
.ok_or(FileParseError::BufferOverflow)?;
let mut imports = Vec::new();
for i in 0..count {
let at = imports_offset + i * record_size;
let (ordinal, weak, name_offset, addend) = if imports_format == DYLD_CHAINED_IMPORT_ADDEND64
{
let raw = quad(data, at)?;
let ordinal = raw as u16;
let ordinal = if ordinal > 0xfff0 {
i32::from(ordinal as i16)
} else {
i32::from(ordinal)
};
(
ordinal,
raw & 0x10000 != 0,
(raw >> 32) as usize,
quad(data, at + 8)? as i64,
)
} else {
let raw = word(data, at)?;
let ordinal = raw as u8;
let ordinal = if ordinal > 0xf0 {
i32::from(ordinal as i8)
} else {
i32::from(ordinal)
};
let addend = if imports_format == DYLD_CHAINED_IMPORT_ADDEND {
i64::from(word(data, at + 4)? as i32)
} else {
0
};
(ordinal, raw & 256 != 0, (raw >> 9) as usize, addend)
};
let offset = symbols_offset
.checked_add(name_offset)
.ok_or(FileParseError::BufferOverflow)?;
let tail = data.get(offset..).ok_or(FileParseError::BufferOverflow)?;
let end = tail
.iter()
.take(remaining.saturating_add(1))
.position(|b| *b == 0)
.ok_or(if tail.len() <= remaining {
FileParseError::BufferOverflow
} else {
FileParseError::ValueTooLarge
})?;
remaining = remaining
.checked_sub(end + 1)
.ok_or(FileParseError::ValueTooLarge)?;
imports.push(ChainedImport {
library_ordinal: ordinal,
weak,
addend,
name: core::str::from_utf8(&tail[..end])
.map_err(|_| FileParseError::InvalidFileFormat)?
.into(),
});
}
let starts = word(data, 4)? as usize;
let count = word(data, starts)? as usize;
if count > data.len() / 4 {
return Err(FileParseError::BufferOverflow);
}
let starts_end = count
.checked_mul(4)
.and_then(|size| size.checked_add(4))
.and_then(|size| starts.checked_add(size))
.ok_or(FileParseError::BufferOverflow)?;
data.get(starts..starts_end)
.ok_or(FileParseError::BufferOverflow)?;
let mut segments = Vec::new();
for i in 0..count {
let offset = word(
data,
starts
.checked_add(4 + i * 4)
.ok_or(FileParseError::BufferOverflow)?,
)? as usize;
if offset == 0 {
continue;
}
let offset = starts
.checked_add(offset)
.ok_or(FileParseError::BufferOverflow)?;
let size = word(data, offset)? as usize;
let segment_data = data
.get(
offset
..offset
.checked_add(size)
.ok_or(FileParseError::BufferOverflow)?,
)
.ok_or(FileParseError::BufferOverflow)?;
let page_size = half(segment_data, 4)?;
let pointer_format = half(segment_data, 6)?;
if chained_pointer_stride(pointer_format).is_none() {
return Err(FileParseError::UnsupportedFeature(String::from(
"chained pointer format",
)));
}
if page_size == 0 {
return Err(FileParseError::InvalidFileFormat);
}
let segment_offset = quad(segment_data, 8)?;
let max_valid_pointer = word(segment_data, 16)?;
let page_count = half(segment_data, 20)?;
let entries = segment_data.len().saturating_sub(22) / 2;
if entries < usize::from(page_count) {
return Err(FileParseError::BufferOverflow);
}
remaining = remaining
.checked_sub(entries * core::mem::size_of::<u16>())
.ok_or(FileParseError::ValueTooLarge)?;
let page_starts = (0..entries)
.map(|p| half(segment_data, 22 + p * 2))
.collect::<Result<Vec<_>, _>>()?;
let align = if pointer_format == DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE {
1
} else {
4
};
let valid = |start: u16| start < page_size && start.is_multiple_of(align);
for &start in &page_starts[..usize::from(page_count)] {
if start == DYLD_CHAINED_PTR_START_NONE {
continue;
}
if start & DYLD_CHAINED_PTR_START_MULTI == 0 {
if !valid(start) {
return Err(FileParseError::InvalidFileFormat);
}
continue;
}
let mut index = usize::from(start & !DYLD_CHAINED_PTR_START_MULTI);
if index < usize::from(page_count) {
return Err(FileParseError::InvalidFileFormat);
}
loop {
let entry = *page_starts
.get(index)
.ok_or(FileParseError::InvalidFileFormat)?;
if !valid(entry & !DYLD_CHAINED_PTR_START_LAST) {
return Err(FileParseError::InvalidFileFormat);
}
if entry & DYLD_CHAINED_PTR_START_LAST != 0 {
break;
}
index += 1;
}
}
segments.push(ChainedSegment {
segment_index: i,
page_size,
pointer_format,
segment_offset,
max_valid_pointer,
page_count,
page_starts,
});
}
Ok(ChainedFixups {
imports_format,
imports,
segments,
})
}
#[derive(Clone, Debug)]
pub struct ChainedFixupSlot {
pub segment_index: usize,
pub pointer_format: u16,
pub vm_offset: u64,
pub raw: crate::field::Field<u64>,
pub pointer: ChainedPointer,
}
impl ChainedFixupSlot {
pub fn rebase_vmaddr(&self, image_base: u64) -> Option<u64> {
match self.pointer {
ChainedPointer::Rebase { target, high8, .. } => {
let vmaddr = matches!(
self.pointer_format,
DYLD_CHAINED_PTR_ARM64E
| DYLD_CHAINED_PTR_64
| DYLD_CHAINED_PTR_32
| DYLD_CHAINED_PTR_32_FIRMWARE
| DYLD_CHAINED_PTR_ARM64E_FIRMWARE
);
let address = if vmaddr {
target
} else {
image_base.checked_add(target)?
};
Some(address | u64::from(high8) << 56)
}
ChainedPointer::AuthRebase { target, .. } => image_base.checked_add(target),
_ => None,
}
}
}
impl<B: core::ops::Deref<Target = [u8]>> super::MachO<B> {
pub fn chained_fixups(&self) -> Result<Option<ChainedFixups>, FileParseError> {
for cmd in &self.load_commands {
if cmd.cmd.value != 0x80000034 {
continue;
}
let offset = cmd.offset();
if cmd.cmdsize.value < 16 {
return Err(FileParseError::InvalidFileFormat);
}
let order = self.byte_order();
let start = order.read_u32(&self.buffer, offset + 8)? as usize;
let size = order.read_u32(&self.buffer, offset + 12)? as usize;
let end = start
.checked_add(size)
.ok_or(FileParseError::BufferOverflow)?;
return decode_chained_fixups(
self.buffer
.get(start..end)
.ok_or(FileParseError::BufferOverflow)?,
)
.map(Some);
}
Ok(None)
}
pub fn chained_fixup_slots(&self) -> Result<Option<Vec<ChainedFixupSlot>>, FileParseError> {
let Some(fixups) = self.chained_fixups()? else {
return Ok(None);
};
let order = self.byte_order();
let mut remaining = self.buffer.len();
let mut slots = Vec::new();
for starts in &fixups.segments {
let segment = self
.segments
.get(starts.segment_index)
.ok_or(FileParseError::InvalidFileFormat)?;
let width = chained_pointer_width(starts.pointer_format) as u64;
let page_size = u64::from(starts.page_size);
for page in 0..usize::from(starts.page_count) {
let page_start = (page as u64) * page_size;
let page_end = page_start + page_size;
for start in starts.chain_starts(page) {
let mut offset = page_start + u64::from(start);
loop {
remaining = remaining
.checked_sub(1)
.ok_or(FileParseError::ValueTooLarge)?;
let end = offset + width;
if end > page_end || end > segment.filesize() || end > segment.vmsize() {
return Err(FileParseError::InvalidFileFormat);
}
let file_offset = segment
.fileoff()
.checked_add(offset)
.and_then(|o| usize::try_from(o).ok())
.ok_or(FileParseError::BufferOverflow)?;
let word = if width == 4 {
u64::from(order.read_u32(&self.buffer, file_offset)?)
} else {
order.read_u64(&self.buffer, file_offset)?
};
let pointer = starts.decode_pointer(word)?;
let (ordinal, next) = match pointer {
ChainedPointer::Bind { ordinal, next, .. }
| ChainedPointer::AuthBind { ordinal, next, .. } => {
(Some(ordinal), next)
}
ChainedPointer::Rebase { next, .. }
| ChainedPointer::AuthRebase { next, .. }
| ChainedPointer::CacheRebase { next, .. }
| ChainedPointer::SegmentedRebase { next, .. }
| ChainedPointer::NonPointer { next, .. } => (None, next),
};
if ordinal.is_some_and(|o| o as usize >= fixups.imports.len()) {
return Err(FileParseError::InvalidFileFormat);
}
slots.push(ChainedFixupSlot {
segment_index: starts.segment_index,
pointer_format: starts.pointer_format,
vm_offset: starts
.segment_offset
.checked_add(offset)
.ok_or(FileParseError::BufferOverflow)?,
raw: crate::field::Field::new(word, file_offset, width as usize),
pointer,
});
if next == 0 {
break;
}
offset += u64::from(next);
}
}
}
}
Ok(Some(slots))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PointerAuthKey {
IA,
IB,
DA,
DB,
}
impl PointerAuthKey {
fn from_bits(bits: u64) -> Self {
match bits & 3 {
0 => Self::IA,
1 => Self::IB,
2 => Self::DA,
_ => Self::DB,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PointerAuth {
pub key: PointerAuthKey,
pub diversity: u16,
pub address_diversity: bool,
}
impl PointerAuth {
pub fn discriminator(&self, slot_address: u64) -> u64 {
if self.address_diversity {
(slot_address & 0x0000_ffff_ffff_ffff) | u64::from(self.diversity) << 48
} else {
u64::from(self.diversity)
}
}
fn from_word(word: u64, diversity_shift: u32) -> Self {
PointerAuth {
key: PointerAuthKey::from_bits(word >> (diversity_shift + 17)),
diversity: (word >> diversity_shift) as u16,
address_diversity: (word >> (diversity_shift + 16)) & 1 != 0,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ChainedPointer {
Bind {
ordinal: u32,
addend: i64,
next: u16,
},
Rebase {
target: u64,
high8: u8,
next: u16,
},
AuthBind {
ordinal: u32,
auth: PointerAuth,
next: u16,
},
AuthRebase {
target: u64,
auth: PointerAuth,
next: u16,
},
CacheRebase {
target: u64,
cache_level: u8,
auth: Option<PointerAuth>,
next: u16,
},
SegmentedRebase {
target_segment: u8,
target_offset: u32,
auth: Option<PointerAuth>,
next: u16,
},
NonPointer {
value: u32,
next: u16,
},
}
pub fn decode_chained_pointer(word: u64) -> Result<ChainedPointer, FileParseError> {
decode_chained_pointer_as(DYLD_CHAINED_PTR_64_OFFSET, 0, word)
}
pub fn decode_chained_pointer_as(
format: u16,
max_valid_pointer: u32,
word: u64,
) -> Result<ChainedPointer, FileParseError> {
let bits = |shift: u32, width: u32| (word >> shift) & ((1u64 << width) - 1);
let stride = u64::from(chained_pointer_stride(format).ok_or_else(|| {
FileParseError::UnsupportedFeature(String::from("chained pointer format"))
})?);
let scaled = |next: u64| (next * stride) as u16;
match format {
DYLD_CHAINED_PTR_64 | DYLD_CHAINED_PTR_64_OFFSET => {
let next = scaled(bits(51, 12));
if word >> 63 != 0 {
if bits(32, 19) != 0 {
return Err(FileParseError::InvalidFileFormat);
}
Ok(ChainedPointer::Bind {
ordinal: bits(0, 24) as u32,
addend: bits(24, 8) as i64,
next,
})
} else {
if bits(44, 7) != 0 {
return Err(FileParseError::InvalidFileFormat);
}
Ok(ChainedPointer::Rebase {
target: bits(0, 36),
high8: bits(36, 8) as u8,
next,
})
}
}
DYLD_CHAINED_PTR_ARM64E
| DYLD_CHAINED_PTR_ARM64E_KERNEL
| DYLD_CHAINED_PTR_ARM64E_USERLAND
| DYLD_CHAINED_PTR_ARM64E_FIRMWARE
| DYLD_CHAINED_PTR_ARM64E_USERLAND24 => {
let next = scaled(bits(51, 11));
let ordinal_bits = if format == DYLD_CHAINED_PTR_ARM64E_USERLAND24 {
24
} else {
16
};
let (auth, bind) = (word >> 63 != 0, (word >> 62) & 1 != 0);
if bind && bits(ordinal_bits, 32 - ordinal_bits) != 0 {
return Err(FileParseError::InvalidFileFormat);
}
let ordinal = bits(0, ordinal_bits) as u32;
Ok(match (auth, bind) {
(true, true) => ChainedPointer::AuthBind {
ordinal,
auth: PointerAuth::from_word(word, 32),
next,
},
(true, false) => ChainedPointer::AuthRebase {
target: bits(0, 32),
auth: PointerAuth::from_word(word, 32),
next,
},
(false, true) => ChainedPointer::Bind {
ordinal,
addend: ((bits(32, 19) << 45) as i64) >> 45,
next,
},
(false, false) => ChainedPointer::Rebase {
target: bits(0, 43),
high8: bits(43, 8) as u8,
next,
},
})
}
DYLD_CHAINED_PTR_64_KERNEL_CACHE | DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE => {
Ok(ChainedPointer::CacheRebase {
target: bits(0, 30),
cache_level: bits(30, 2) as u8,
auth: (word >> 63 != 0).then(|| PointerAuth::from_word(word, 32)),
next: scaled(bits(51, 12)),
})
}
DYLD_CHAINED_PTR_ARM64E_SHARED_CACHE => {
let next = scaled(bits(52, 11));
if word >> 63 != 0 {
Ok(ChainedPointer::AuthRebase {
target: bits(0, 34),
auth: PointerAuth {
key: if bits(51, 1) != 0 {
PointerAuthKey::DA
} else {
PointerAuthKey::IA
},
diversity: bits(34, 16) as u16,
address_diversity: bits(50, 1) != 0,
},
next,
})
} else {
if bits(42, 10) != 0 {
return Err(FileParseError::InvalidFileFormat);
}
Ok(ChainedPointer::Rebase {
target: bits(0, 34),
high8: bits(34, 8) as u8,
next,
})
}
}
DYLD_CHAINED_PTR_ARM64E_SEGMENTED => {
let auth = word >> 63 != 0;
if !auth && bits(32, 19) != 0 {
return Err(FileParseError::InvalidFileFormat);
}
Ok(ChainedPointer::SegmentedRebase {
target_segment: bits(28, 4) as u8,
target_offset: bits(0, 28) as u32,
auth: auth.then(|| PointerAuth::from_word(word, 32)),
next: scaled(bits(51, 12)),
})
}
DYLD_CHAINED_PTR_32 => {
let next = scaled(bits(26, 5));
if bits(31, 1) != 0 {
return Ok(ChainedPointer::Bind {
ordinal: bits(0, 20) as u32,
addend: bits(20, 6) as i64,
next,
});
}
let target = bits(0, 26) as u32;
if max_valid_pointer != 0 && target > max_valid_pointer {
let bias = (0x0400_0000 + max_valid_pointer) / 2;
return Ok(ChainedPointer::NonPointer {
value: target.wrapping_sub(bias),
next,
});
}
Ok(ChainedPointer::Rebase {
target: u64::from(target),
high8: 0,
next,
})
}
DYLD_CHAINED_PTR_32_CACHE => Ok(ChainedPointer::Rebase {
target: bits(0, 30),
high8: 0,
next: scaled(bits(30, 2)),
}),
_ => Ok(ChainedPointer::Rebase {
target: bits(0, 26),
high8: 0,
next: scaled(bits(26, 6)),
}),
}
}