use bytemuck::Pod;
use object::{Endianness, elf::FileHeader64, pod, read::elf::FileHeader};
use crate::{
elf::{
constants::{
ET_REL, SHT_DYNSYM, SHT_GNU_VERDEF, SHT_GNU_VERNEED,
SHT_GNU_VERSYM, SHT_GROUP, SHT_NOBITS, SHT_REL, SHT_RELA,
SHT_SYMTAB, STT_SECTION, VER_NDX_GLOBAL,
},
structs::{
Ehdr64, Rela64, Shdr64, Sym64, Verdaux64, Verdef64, Vernaux64,
Verneed64,
},
},
error::{Error, Result},
util::cstr_at,
};
const EHDR_SIZE: usize = core::mem::size_of::<Ehdr64>();
#[derive(Clone, Copy)]
pub struct ObjectFile<'data> {
bytes: &'data [u8],
header: &'data Ehdr64,
sections: &'data [Shdr64],
shstrtab: &'data [u8],
symtab_idx: Option<usize>,
dynsym_idx: Option<usize>,
}
#[derive(Clone, Copy)]
pub enum Relocs<'data> {
None,
Rela(&'data [Rela64]),
Rel,
}
impl<'data> Relocs<'data> {
pub fn entries(self) -> Result<Option<&'data [Rela64]>> {
match self {
Self::None => Ok(None),
Self::Rela(entries) => Ok(Some(entries)),
Self::Rel => Err(Error::Format(
"SHT_REL relocations (only SHT_RELA is supported)",
)),
}
}
}
pub struct SymbolTable<'data> {
pub syms: &'data [Sym64],
strtab: &'data [u8],
}
#[derive(Clone, Copy)]
pub struct Group<'data> {
pub signature: &'data [u8],
pub signature_hash: u64,
pub flags: u32,
pub members: &'data [u32],
}
impl<'data> ObjectFile<'data> {
pub fn parse(bytes: &'data [u8]) -> Result<Self> {
let header = FileHeader64::<Endianness>::parse(bytes)
.map_err(|_| Error::Format("invalid ELF header"))?;
if !header.is_little_endian() {
return Err(Error::Format("expected little-endian ELF"));
}
let endian = Endianness::Little;
let table = header
.sections(endian, bytes)
.map_err(|_| Error::Format("invalid ELF section table"))?;
let ehdr = view_one::<Ehdr64>(bytes, 0, EHDR_SIZE, "ELF header")?;
let sections = cast_section_table(table.iter().as_slice())?;
let shstrtab = if sections.is_empty() {
&[][..]
} else {
let shstrndx = header
.shstrndx(endian, bytes)
.map_err(|_| Error::Format("invalid ELF section name index"))?;
name_table(bytes, sections, shstrndx)?
};
names_in_range(
shstrtab,
sections.iter().map(|s| s.sh_name.get()),
"section name offset",
)?;
let symtab_idx = find_unique_section(sections, SHT_SYMTAB)?;
let dynsym_idx = find_unique_section(sections, SHT_DYNSYM)?;
Ok(Self {
bytes,
header: ehdr,
sections,
shstrtab,
symtab_idx,
dynsym_idx,
})
}
pub fn header(&self) -> &Ehdr64 {
self.header
}
pub fn machine(&self) -> u16 {
self.header.e_machine.get()
}
pub fn is_relocatable(&self) -> bool {
self.header.e_type.get() == ET_REL
}
pub fn sections(&self) -> &'data [Shdr64] {
self.sections
}
pub fn section_name(&self, shdr: &Shdr64) -> &'data [u8] {
cstr_at(self.shstrtab, shdr.sh_name.get())
}
pub fn section_name_starts_with(
&self,
shdr: &Shdr64,
prefix: &[u8],
) -> bool {
let at = shdr.sh_name.get() as usize;
self.shstrtab
.get(at..at.saturating_add(prefix.len()))
.is_some_and(|head| head == prefix)
}
pub fn section_name_is(&self, shdr: &Shdr64, want: &[u8]) -> bool {
let at = shdr.sh_name.get() as usize;
let end = at.saturating_add(want.len());
self.shstrtab.get(at..end).is_some_and(|head| head == want)
&& self.shstrtab.get(end) == Some(&0)
}
pub fn section_data(&self, shdr: &Shdr64) -> Result<&'data [u8]> {
if shdr.sh_type.get() == SHT_NOBITS {
return Ok(&[]);
}
section_payload(self.bytes, shdr, "section data")
}
pub fn symbol_table(&self) -> Result<Option<SymbolTable<'data>>> {
let Some(&idx) = self.symtab_idx.as_ref() else {
return Ok(None);
};
let symtab = self
.sections
.get(idx)
.ok_or(Error::OutOfRange("symbol table index"))?;
let strtab = self
.sections
.get(symtab.sh_link.get() as usize)
.ok_or(Error::OutOfRange("symbol string table index"))?;
let table = SymbolTable {
syms: view_slice(
self.bytes,
symtab,
core::mem::size_of::<Sym64>(),
"symbol table entries",
)?,
strtab: section_payload(self.bytes, strtab, "symbol string table")?,
};
table.check_names("symbol name offset")?;
Ok(Some(table))
}
pub fn dynamic_symbols(&self) -> Result<Option<SymbolTable<'data>>> {
let Some(&idx) = self.dynsym_idx.as_ref() else {
return Ok(None);
};
let dynsym = self
.sections
.get(idx)
.ok_or(Error::OutOfRange("dynamic symbol table index"))?;
let strtab = self
.sections
.get(dynsym.sh_link.get() as usize)
.ok_or(Error::OutOfRange("dynamic string table index"))?;
let table = SymbolTable {
syms: view_slice(
self.bytes,
dynsym,
core::mem::size_of::<Sym64>(),
"dynamic symbol table entries",
)?,
strtab: section_payload(
self.bytes,
strtab,
"dynamic string table",
)?,
};
table.check_names("dynamic symbol name offset")?;
Ok(Some(table))
}
pub fn relocations(
&self,
target_shndx: u16,
) -> Result<Option<&'data [Rela64]>> {
for shdr in self.sections {
let applies =
shdr.sh_type.get() == SHT_RELA || shdr.sh_type.get() == SHT_REL;
if applies && shdr.sh_info.get() == u32::from(target_shndx) {
return relocs_of(self.bytes, shdr)?.entries();
}
}
Ok(None)
}
pub fn reloc_index(&self) -> Result<Vec<Relocs<'data>>> {
let len = self.sections.len();
let mut out = vec![Relocs::None; len];
for shdr in self.sections {
let is_reloc =
shdr.sh_type.get() == SHT_RELA || shdr.sh_type.get() == SHT_REL;
if !is_reloc {
continue;
}
let Ok(target) = usize::try_from(shdr.sh_info.get()) else {
continue;
};
if target < len && matches!(out[target], Relocs::None) {
out[target] = relocs_of(self.bytes, shdr)?;
}
}
Ok(out)
}
pub fn groups(&self, out: &mut Vec<Group<'data>>) -> Result<()> {
out.clear();
let mut syms = GroupSymbols::default();
for shdr in self.sections {
if shdr.sh_type.get() != SHT_GROUP {
continue;
}
let data = self.section_data(shdr)?;
let words: &[u32] = bytemuck::try_cast_slice(data)
.map_err(|_| Error::Format("group section words"))?;
if words.is_empty() {
continue;
}
let signature = self.group_signature(shdr, &mut syms)?;
out.push(Group {
signature,
signature_hash: crate::symbol::name_hash(signature),
flags: words[0],
members: &words[1..],
});
}
Ok(())
}
pub fn version_table(&self) -> Result<VersionTable<'data>> {
let mut versym: &[u16] = &[];
let mut needs = Vec::new();
let mut defs = Vec::new();
for shdr in self.sections {
match shdr.sh_type.get() {
SHT_GNU_VERSYM => {
let data = self.section_data(shdr)?;
versym = bytemuck::try_cast_slice(data)
.map_err(|_| Error::Format(".gnu.version words"))?;
self.check_versym_len(shdr, versym.len())?;
}
SHT_GNU_VERNEED => {
let data = self.section_data(shdr)?;
let strtab = self.strtab_for(shdr)?;
needs = parse_verneed(data, strtab)?;
}
SHT_GNU_VERDEF => {
let data = self.section_data(shdr)?;
let strtab = self.strtab_for(shdr)?;
defs = parse_verdef(data, strtab)?;
}
_ => {}
}
}
Ok(VersionTable {
versym,
needs,
defs,
})
}
fn check_versym_len(&self, shdr: &Shdr64, len: usize) -> Result<()> {
let Some(linked) = self.sections.get(shdr.sh_link.get() as usize)
else {
return Ok(());
};
let ty = linked.sh_type.get();
if ty != SHT_SYMTAB && ty != SHT_DYNSYM {
return Ok(());
}
let entsize = core::mem::size_of::<Sym64>() as u64;
let count = usize::try_from(linked.sh_size.get() / entsize)
.map_err(|_| Error::OutOfRange("symbol table entries"))?;
if len < count {
return Err(Error::Format(
".gnu.version is shorter than its symbol table",
));
}
Ok(())
}
fn strtab_for(&self, shdr: &Shdr64) -> Result<&'data [u8]> {
let linked = self
.sections
.get(shdr.sh_link.get() as usize)
.ok_or(Error::OutOfRange("version string table index"))?;
self.section_data(linked)
}
fn group_signature(
&self,
group: &Shdr64,
syms: &mut GroupSymbols<'data>,
) -> Result<&'data [u8]> {
let link = group.sh_link.get();
if syms.link != Some(link) {
*syms = self.group_symbols(link)?;
}
let sym = syms
.syms
.get(group.sh_info.get() as usize)
.ok_or(Error::OutOfRange("group signature symbol"))?;
if sym.type_() == STT_SECTION {
let sec = self
.sections
.get(sym.st_shndx.get() as usize)
.ok_or(Error::OutOfRange("signature section"))?;
Ok(self.section_name(sec))
} else {
Ok(cstr_at(syms.strtab, sym.st_name.get()))
}
}
fn group_symbols(&self, link: u32) -> Result<GroupSymbols<'data>> {
let symtab = self
.sections
.get(link as usize)
.ok_or(Error::OutOfRange("group symbol table section"))?;
let syms: &[Sym64] = view_slice(
self.bytes,
symtab,
core::mem::size_of::<Sym64>(),
"group symbol table",
)?;
let strtab = self
.sections
.get(symtab.sh_link.get() as usize)
.ok_or(Error::OutOfRange("group string table"))?;
let strtab = section_payload(self.bytes, strtab, "group string table")?;
Ok(GroupSymbols {
link: Some(link),
syms,
strtab,
})
}
}
#[derive(Default)]
struct GroupSymbols<'data> {
link: Option<u32>,
syms: &'data [Sym64],
strtab: &'data [u8],
}
fn find_unique_section(
sections: &[Shdr64],
sh_type: u32,
) -> Result<Option<usize>> {
let mut found: Option<usize> = None;
for (i, shdr) in sections.iter().enumerate() {
if shdr.sh_type.get() == sh_type {
if found.is_some() {
return Err(Error::Format("duplicate symbol table section"));
}
found = Some(i);
}
}
Ok(found)
}
impl<'data> SymbolTable<'data> {
pub fn name(&self, sym: &Sym64) -> &'data [u8] {
cstr_at(self.strtab, sym.st_name.get())
}
pub fn iter(&self) -> core::slice::Iter<'_, Sym64> {
self.syms.iter()
}
fn check_names(&self, what: &'static str) -> Result<()> {
names_in_range(
self.strtab,
self.syms.iter().map(|s| s.st_name.get()),
what,
)
}
}
impl<'data> IntoIterator for &'data SymbolTable<'data> {
type Item = &'data Sym64;
type IntoIter = core::slice::Iter<'data, Sym64>;
fn into_iter(self) -> Self::IntoIter {
self.syms.iter()
}
}
fn names_in_range(
table: &[u8],
offsets: impl Iterator<Item = u32>,
what: &'static str,
) -> Result<()> {
for off in offsets {
let start = usize::try_from(off).unwrap_or(usize::MAX);
if off != 0 && start >= table.len() {
return Err(Error::OutOfRange(what));
}
}
Ok(())
}
fn cast_section_table(
sections: &[object::elf::SectionHeader64<Endianness>],
) -> Result<&[Shdr64]> {
if sections.is_empty() {
return Ok(&[]);
}
let raw = pod::bytes_of_slice(sections);
bytemuck::try_cast_slice::<u8, Shdr64>(raw).map_err(Into::into)
}
fn name_table<'a>(
bytes: &'a [u8],
sections: &'a [Shdr64],
shstrndx: u32,
) -> Result<&'a [u8]> {
let index = usize::try_from(shstrndx)
.map_err(|_| Error::OutOfRange("section name table index"))?;
let shdr = sections
.get(index)
.ok_or(Error::OutOfRange("section name table index"))?;
section_payload(bytes, shdr, "section name string table")
}
fn section_payload<'a>(
bytes: &'a [u8],
shdr: &Shdr64,
what: &'static str,
) -> Result<&'a [u8]> {
let offset = usize_from(shdr.sh_offset.get(), what)?;
let size = usize_from(shdr.sh_size.get(), what)?;
bytes
.get(offset..end_of(offset, size, what)?)
.ok_or(Error::OutOfRange(what))
}
fn end_of(offset: usize, size: usize, what: &'static str) -> Result<usize> {
offset.checked_add(size).ok_or(Error::OutOfRange(what))
}
fn relocs_of<'a>(bytes: &'a [u8], shdr: &Shdr64) -> Result<Relocs<'a>> {
match shdr.sh_type.get() {
SHT_RELA => Ok(Relocs::Rela(view_slice(
bytes,
shdr,
core::mem::size_of::<Rela64>(),
"RELA entries",
)?)),
SHT_REL => Ok(Relocs::Rel),
_ => Err(Error::Format("not a relocation section")),
}
}
fn view_slice<'a, T: Pod>(
bytes: &'a [u8],
shdr: &Shdr64,
entsize: usize,
what: &'static str,
) -> Result<&'a [T]> {
if shdr.sh_entsize.get() != 0
&& usize_from(shdr.sh_entsize.get(), what)? != entsize
{
return Err(Error::Format(what));
}
let offset = usize_from(shdr.sh_offset.get(), what)?;
let count = usize_from(shdr.sh_size.get(), what)? / entsize.max(1);
view_slice_raw(bytes, offset, count, entsize, what)
}
fn view_one<'a, T: Pod>(
bytes: &'a [u8],
offset: usize,
size: usize,
what: &'static str,
) -> Result<&'a T> {
let raw = bytes
.get(offset..end_of(offset, size, what)?)
.ok_or(Error::OutOfRange(what))?;
bytemuck::try_from_bytes(raw).map_err(Into::into)
}
fn view_slice_raw<'a, T: Pod>(
bytes: &'a [u8],
offset: usize,
count: usize,
entsize: usize,
what: &'static str,
) -> Result<&'a [T]> {
let span = count.checked_mul(entsize).ok_or(Error::OutOfRange(what))?;
let raw = bytes
.get(offset..end_of(offset, span, what)?)
.ok_or(Error::OutOfRange(what))?;
bytemuck::try_cast_slice::<u8, T>(raw).map_err(Into::into)
}
fn usize_from<T: TryInto<usize>>(
value: T,
what: &'static str,
) -> Result<usize> {
value.try_into().map_err(|_| Error::OutOfRange(what))
}
#[derive(Clone)]
pub struct VersionNeed<'data> {
pub soname: &'data [u8],
pub aux: Vec<VersionNaux<'data>>,
}
#[derive(Clone, Copy)]
pub struct VersionNaux<'data> {
pub name: &'data [u8],
pub hash: u32,
pub flags: u16,
pub index: u16,
}
#[derive(Clone)]
pub struct VersionDef<'data> {
pub flags: u16,
pub index: u16,
pub hash: u32,
pub names: Vec<&'data [u8]>,
}
#[derive(Clone, Copy)]
pub struct VersionDaux<'data> {
pub name: &'data [u8],
}
#[derive(Clone, Default)]
pub struct VersionTable<'data> {
pub versym: &'data [u16],
pub needs: Vec<VersionNeed<'data>>,
pub defs: Vec<VersionDef<'data>>,
}
impl VersionTable<'_> {
pub fn version_of(&self, i: usize) -> u16 {
self.versym.get(i).copied().unwrap_or(VER_NDX_GLOBAL)
}
pub const fn is_empty(&self) -> bool {
self.versym.is_empty() && self.needs.is_empty() && self.defs.is_empty()
}
}
fn parse_verneed<'data>(
payload: &'data [u8],
dynstr: &'data [u8],
) -> Result<Vec<VersionNeed<'data>>> {
let mut out = Vec::new();
let mut off = 0usize;
for _ in 0..=u16::MAX {
let Some(rec) = view_one_at::<Verneed64>(payload, off) else {
if payload.is_empty() {
return Ok(out);
}
return Err(Error::Format("truncated .gnu.version_r record"));
};
let soname = cstr_at(dynstr, rec.vn_file.get());
let mut aux = Vec::new();
let mut aoff = off + usize::try_from(rec.vn_aux.get()).unwrap_or(0);
for _ in 0..=u16::MAX {
let Some(a) = view_one_at::<Vernaux64>(payload, aoff) else {
return Err(Error::Format(
"truncated .gnu.version_r auxiliary record",
));
};
aux.push(VersionNaux {
name: cstr_at(dynstr, a.vna_name.get()),
hash: a.vna_hash.get(),
flags: a.vna_flags.get(),
index: a.vna_other.get(),
});
if a.vna_next.get() == 0 {
break;
}
aoff = advance_offset(aoff, a.vna_next.get());
}
out.push(VersionNeed { soname, aux });
if rec.vn_next.get() == 0 {
return Ok(out);
}
off = advance_offset(off, rec.vn_next.get());
}
Err(Error::Format("unterminated .gnu.version_r chain"))
}
fn parse_verdef<'data>(
payload: &'data [u8],
dynstr: &'data [u8],
) -> Result<Vec<VersionDef<'data>>> {
let mut out = Vec::new();
let mut off = 0usize;
for _ in 0..=u16::MAX {
let Some(rec) = view_one_at::<Verdef64>(payload, off) else {
if payload.is_empty() {
return Ok(out);
}
return Err(Error::Format("truncated .gnu.version_d record"));
};
let mut names = Vec::new();
let mut aoff = off + usize::try_from(rec.vd_aux.get()).unwrap_or(0);
for _ in 0..=u16::MAX {
let Some(a) = view_one_at::<Verdaux64>(payload, aoff) else {
return Err(Error::Format(
"truncated .gnu.version_d auxiliary record",
));
};
names.push(cstr_at(dynstr, a.vda_name.get()));
if a.vda_next.get() == 0 {
break;
}
aoff = advance_offset(aoff, a.vda_next.get());
}
out.push(VersionDef {
flags: rec.vd_flags.get(),
index: rec.vd_ndx.get(),
hash: rec.vd_hash.get(),
names,
});
if rec.vd_next.get() == 0 {
return Ok(out);
}
off = advance_offset(off, rec.vd_next.get());
}
Err(Error::Format("unterminated .gnu.version_d chain"))
}
fn advance_offset(off: usize, delta: u32) -> usize {
off.saturating_add(usize::try_from(delta).unwrap_or(0))
}
fn view_one_at<T: Pod>(bytes: &[u8], offset: usize) -> Option<&T> {
let size = core::mem::size_of::<T>();
let raw = bytes.get(offset..offset.checked_add(size)?)?;
bytemuck::try_from_bytes(raw).ok()
}