mirror of
https://github.com/Momoko-Ayase/Senbei.git
synced 2026-09-19 03:57:59 -04:00
refactor: align platform crate boundaries
This commit is contained in:
bfloat16
@@ -0,0 +1,107 @@
|
||||
use crate::{Error, Result, invalid};
|
||||
|
||||
#[must_use]
|
||||
pub fn elf_hash(name: &[u8]) -> u32 {
|
||||
let mut value = 0_u32;
|
||||
for &byte in name {
|
||||
value = value.wrapping_shl(4).wrapping_add(u32::from(byte));
|
||||
let high = value & 0xf000_0000;
|
||||
if high != 0 {
|
||||
value ^= high >> 24;
|
||||
value &= !high;
|
||||
}
|
||||
}
|
||||
value
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn gnu_hash(name: &[u8]) -> u32 {
|
||||
name.iter().fold(5381_u32, |value, &byte| {
|
||||
value.wrapping_mul(33).wrapping_add(u32::from(byte))
|
||||
})
|
||||
}
|
||||
|
||||
pub fn build_sysv_hash(names: &[Vec<u8>]) -> Result<Vec<u8>> {
|
||||
if names.len() < 2 {
|
||||
return invalid("dynamic symbol table is unexpectedly empty");
|
||||
}
|
||||
let bucket_count = names.len();
|
||||
let symbol_count = names.len();
|
||||
let mut buckets = vec![0_u32; bucket_count];
|
||||
let mut chains = vec![0_u32; symbol_count];
|
||||
for (symbol_index, name) in names.iter().enumerate().skip(1) {
|
||||
let bucket_index = elf_hash(name) as usize % bucket_count;
|
||||
let symbol_index32 = u32::try_from(symbol_index)
|
||||
.map_err(|_| Error::Invalid("dynamic symbol index exceeds u32".to_owned()))?;
|
||||
if buckets[bucket_index] == 0 {
|
||||
buckets[bucket_index] = symbol_index32;
|
||||
continue;
|
||||
}
|
||||
let mut chain_index = buckets[bucket_index] as usize;
|
||||
while chains[chain_index] != 0 {
|
||||
chain_index = chains[chain_index] as usize;
|
||||
}
|
||||
chains[chain_index] = symbol_index32;
|
||||
}
|
||||
let mut output = Vec::with_capacity((2 + bucket_count + symbol_count) * 4);
|
||||
output.extend_from_slice(
|
||||
&u32::try_from(bucket_count)
|
||||
.map_err(|_| Error::Invalid("SysV bucket count exceeds u32".to_owned()))?
|
||||
.to_le_bytes(),
|
||||
);
|
||||
output.extend_from_slice(
|
||||
&u32::try_from(symbol_count)
|
||||
.map_err(|_| Error::Invalid("SysV symbol count exceeds u32".to_owned()))?
|
||||
.to_le_bytes(),
|
||||
);
|
||||
for value in buckets.into_iter().chain(chains) {
|
||||
output.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
Ok(output)
|
||||
}
|
||||
|
||||
pub fn build_gnu_hash(names: &[Vec<u8>]) -> Result<Vec<u8>> {
|
||||
let hashes = names
|
||||
.iter()
|
||||
.skip(1)
|
||||
.map(|name| gnu_hash(name))
|
||||
.collect::<Vec<_>>();
|
||||
if hashes.is_empty() {
|
||||
return invalid("GNU hash requires at least one dynamic symbol");
|
||||
}
|
||||
let bloom_shift = 5_u32;
|
||||
let mut bloom_word = 0_u64;
|
||||
for &value in &hashes {
|
||||
bloom_word |= 1_u64 << (value & 63);
|
||||
bloom_word |= 1_u64 << ((value >> bloom_shift) & 63);
|
||||
}
|
||||
let mut chains = hashes
|
||||
.into_iter()
|
||||
.map(|value| value & !1)
|
||||
.collect::<Vec<_>>();
|
||||
let last = chains
|
||||
.last_mut()
|
||||
.ok_or_else(|| Error::Invalid("GNU hash chain is empty".to_owned()))?;
|
||||
*last |= 1;
|
||||
let mut output = Vec::with_capacity(28 + chains.len() * 4);
|
||||
for value in [1_u32, 1, 1, bloom_shift] {
|
||||
output.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
output.extend_from_slice(&bloom_word.to_le_bytes());
|
||||
output.extend_from_slice(&1_u32.to_le_bytes());
|
||||
for value in chains {
|
||||
output.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
Ok(output)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn standard_elf_hash_is_stable() {
|
||||
assert_eq!(elf_hash(b"printf"), 0x0779_05a6);
|
||||
assert_eq!(gnu_hash(b"printf"), 0x156b_2bb8);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,636 @@
|
||||
use crate::{Error, Result, invalid};
|
||||
|
||||
pub const SHT_NOBITS: u32 = 8;
|
||||
pub const SHT_STRTAB: u32 = 3;
|
||||
pub const SHT_LOUSER: u32 = 0x8000_0000;
|
||||
pub const SHF_ALLOC: u64 = 2;
|
||||
const PT_LOAD: u32 = 1;
|
||||
pub const PF_R: u32 = 4;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct LoadSegment {
|
||||
pub offset: u64,
|
||||
pub virtual_address: u64,
|
||||
pub file_size: u64,
|
||||
pub memory_size: u64,
|
||||
pub flags: u32,
|
||||
pub alignment: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct SectionHeader {
|
||||
pub name: u32,
|
||||
pub section_type: u32,
|
||||
pub flags: u64,
|
||||
pub address: u64,
|
||||
pub offset: u64,
|
||||
pub size: u64,
|
||||
pub link: u32,
|
||||
pub info: u32,
|
||||
pub alignment: u64,
|
||||
pub entry_size: u64,
|
||||
}
|
||||
|
||||
impl SectionHeader {
|
||||
pub const SIZE: usize = 0x40;
|
||||
|
||||
fn parse(data: &[u8], offset: usize) -> Result<Self> {
|
||||
Ok(Self {
|
||||
name: read_u32(data, offset)?,
|
||||
section_type: read_u32(data, offset + 4)?,
|
||||
flags: read_u64(data, offset + 8)?,
|
||||
address: read_u64(data, offset + 0x10)?,
|
||||
offset: read_u64(data, offset + 0x18)?,
|
||||
size: read_u64(data, offset + 0x20)?,
|
||||
link: read_u32(data, offset + 0x28)?,
|
||||
info: read_u32(data, offset + 0x2c)?,
|
||||
alignment: read_u64(data, offset + 0x30)?,
|
||||
entry_size: read_u64(data, offset + 0x38)?,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn encode(self) -> [u8; Self::SIZE] {
|
||||
let mut output = [0_u8; Self::SIZE];
|
||||
output[0..4].copy_from_slice(&self.name.to_le_bytes());
|
||||
output[4..8].copy_from_slice(&self.section_type.to_le_bytes());
|
||||
output[8..0x10].copy_from_slice(&self.flags.to_le_bytes());
|
||||
output[0x10..0x18].copy_from_slice(&self.address.to_le_bytes());
|
||||
output[0x18..0x20].copy_from_slice(&self.offset.to_le_bytes());
|
||||
output[0x20..0x28].copy_from_slice(&self.size.to_le_bytes());
|
||||
output[0x28..0x2c].copy_from_slice(&self.link.to_le_bytes());
|
||||
output[0x2c..0x30].copy_from_slice(&self.info.to_le_bytes());
|
||||
output[0x30..0x38].copy_from_slice(&self.alignment.to_le_bytes());
|
||||
output[0x38..0x40].copy_from_slice(&self.entry_size.to_le_bytes());
|
||||
output
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct ElfLayout {
|
||||
pub entrypoint: u64,
|
||||
pub program_header_offset: usize,
|
||||
pub program_header_size: usize,
|
||||
pub program_header_count: usize,
|
||||
pub program_headers: Vec<LoadSegment>,
|
||||
pub section_headers: Vec<SectionHeader>,
|
||||
pub section_name_index: usize,
|
||||
pub private_section_index: usize,
|
||||
}
|
||||
|
||||
impl ElfLayout {
|
||||
pub fn parse(data: &[u8], require_private: bool) -> Result<Self> {
|
||||
let ident = slice(data, 0, 6)?;
|
||||
if ident[..4] != *b"\x7fELF" || ident[4] != 2 || ident[5] != 1 {
|
||||
return invalid("input is not a little-endian ELF64 file");
|
||||
}
|
||||
if read_u16(data, 0x12)? != crate::AARCH64_MACHINE {
|
||||
return invalid("input is not an AArch64 ELF");
|
||||
}
|
||||
let entrypoint = read_u64(data, 0x18)?;
|
||||
let program_header_offset = usize_from_u64(read_u64(data, 0x20)?, "program header offset")?;
|
||||
let section_header_offset = usize_from_u64(read_u64(data, 0x28)?, "section header offset")?;
|
||||
let program_header_size = usize::from(read_u16(data, 0x36)?);
|
||||
let program_header_count = usize::from(read_u16(data, 0x38)?);
|
||||
let section_header_size = usize::from(read_u16(data, 0x3a)?);
|
||||
let section_header_count = usize::from(read_u16(data, 0x3c)?);
|
||||
let section_name_index = usize::from(read_u16(data, 0x3e)?);
|
||||
if program_header_size != 0x38 || section_header_size != SectionHeader::SIZE {
|
||||
return invalid("unexpected ELF program/section header size");
|
||||
}
|
||||
|
||||
let mut program_headers = Vec::new();
|
||||
for index in 0..program_header_count {
|
||||
let offset = checked_index(program_header_offset, index, program_header_size)?;
|
||||
if read_u32(data, offset)? != PT_LOAD {
|
||||
continue;
|
||||
}
|
||||
let segment = LoadSegment {
|
||||
flags: read_u32(data, offset + 4)?,
|
||||
offset: read_u64(data, offset + 8)?,
|
||||
virtual_address: read_u64(data, offset + 0x10)?,
|
||||
file_size: read_u64(data, offset + 0x20)?,
|
||||
memory_size: read_u64(data, offset + 0x28)?,
|
||||
alignment: read_u64(data, offset + 0x30)?,
|
||||
};
|
||||
let file_end = segment
|
||||
.offset
|
||||
.checked_add(segment.file_size)
|
||||
.ok_or_else(|| Error::Invalid(format!("PT_LOAD {index} file range overflow")))?;
|
||||
if file_end > data.len() as u64 {
|
||||
return invalid(format!("PT_LOAD {index} exceeds input file"));
|
||||
}
|
||||
program_headers.push(segment);
|
||||
}
|
||||
if program_headers.is_empty() {
|
||||
return invalid("input ELF contains no PT_LOAD segments");
|
||||
}
|
||||
|
||||
let mut section_headers = Vec::with_capacity(section_header_count);
|
||||
for index in 0..section_header_count {
|
||||
let offset = checked_index(section_header_offset, index, section_header_size)?;
|
||||
section_headers.push(SectionHeader::parse(data, offset)?);
|
||||
}
|
||||
if section_name_index >= section_headers.len() {
|
||||
return invalid("ELF section-name index is out of range");
|
||||
}
|
||||
let private = section_headers
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(index, section)| (section.section_type == SHT_LOUSER).then_some(index))
|
||||
.collect::<Vec<_>>();
|
||||
let private_section_index = match private.as_slice() {
|
||||
[index] => *index,
|
||||
[] if !require_private => usize::MAX,
|
||||
_ => {
|
||||
return invalid(format!(
|
||||
"expected {} SHT_LOUSER section, found {}",
|
||||
if require_private {
|
||||
"one"
|
||||
} else {
|
||||
"at most one"
|
||||
},
|
||||
private.len()
|
||||
));
|
||||
}
|
||||
};
|
||||
let layout = Self {
|
||||
entrypoint,
|
||||
program_header_offset,
|
||||
program_header_size,
|
||||
program_header_count,
|
||||
program_headers,
|
||||
section_headers,
|
||||
section_name_index,
|
||||
private_section_index,
|
||||
};
|
||||
// Section roles are resolved from the ELF's own string table. Validate
|
||||
// it at the format boundary so callers cannot silently continue with
|
||||
// fabricated or lossy section names.
|
||||
layout.section_names(data)?;
|
||||
Ok(layout)
|
||||
}
|
||||
|
||||
pub fn private_section(&self) -> Result<SectionHeader> {
|
||||
self.section_headers
|
||||
.get(self.private_section_index)
|
||||
.copied()
|
||||
.ok_or_else(|| Error::Invalid("ELF has no private section".to_owned()))
|
||||
}
|
||||
|
||||
pub fn load_end(&self) -> Result<u64> {
|
||||
self.program_headers
|
||||
.iter()
|
||||
.map(|segment| {
|
||||
segment
|
||||
.virtual_address
|
||||
.checked_add(segment.memory_size)
|
||||
.ok_or_else(|| Error::Invalid("PT_LOAD memory end overflow".to_owned()))
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?
|
||||
.into_iter()
|
||||
.max()
|
||||
.ok_or_else(|| Error::Invalid("ELF has no PT_LOAD memory range".to_owned()))
|
||||
}
|
||||
|
||||
pub fn file_load_end(&self) -> Result<u64> {
|
||||
self.program_headers
|
||||
.iter()
|
||||
.map(|segment| {
|
||||
segment
|
||||
.offset
|
||||
.checked_add(segment.file_size)
|
||||
.ok_or_else(|| Error::Invalid("PT_LOAD file end overflow".to_owned()))
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()?
|
||||
.into_iter()
|
||||
.max()
|
||||
.ok_or_else(|| Error::Invalid("ELF has no PT_LOAD file range".to_owned()))
|
||||
}
|
||||
|
||||
pub fn load_alignment(&self) -> Result<u64> {
|
||||
let alignment = self
|
||||
.program_headers
|
||||
.iter()
|
||||
.map(|segment| segment.alignment)
|
||||
.max()
|
||||
.ok_or_else(|| Error::Invalid("ELF has no PT_LOAD alignment".to_owned()))?;
|
||||
if alignment == 0 || !alignment.is_power_of_two() {
|
||||
return invalid(format!("invalid PT_LOAD alignment 0x{alignment:x}"));
|
||||
}
|
||||
Ok(alignment)
|
||||
}
|
||||
|
||||
pub fn append_load_segment(&self, output: &mut [u8], segment: LoadSegment) -> Result<Self> {
|
||||
if self.program_header_size != 0x38 {
|
||||
return invalid("unexpected ELF program header size");
|
||||
}
|
||||
if segment.file_size == 0 {
|
||||
return invalid("new PT_LOAD has no file contents");
|
||||
}
|
||||
if segment.memory_size < segment.file_size {
|
||||
return invalid("new PT_LOAD memory size is smaller than file size");
|
||||
}
|
||||
if segment.alignment == 0 || !segment.alignment.is_power_of_two() {
|
||||
return invalid(format!(
|
||||
"invalid new PT_LOAD alignment 0x{:x}",
|
||||
segment.alignment
|
||||
));
|
||||
}
|
||||
if segment.offset % segment.alignment != segment.virtual_address % segment.alignment {
|
||||
return invalid("new PT_LOAD offset and address are misaligned");
|
||||
}
|
||||
let segment_file_end = segment
|
||||
.offset
|
||||
.checked_add(segment.file_size)
|
||||
.ok_or_else(|| Error::Invalid("new PT_LOAD file range overflow".to_owned()))?;
|
||||
let segment_memory_end = segment
|
||||
.virtual_address
|
||||
.checked_add(segment.memory_size)
|
||||
.ok_or_else(|| Error::Invalid("new PT_LOAD memory range overflow".to_owned()))?;
|
||||
if segment_file_end > output.len() as u64 {
|
||||
return invalid("new PT_LOAD exceeds output mapping");
|
||||
}
|
||||
for existing in &self.program_headers {
|
||||
let existing_file_end = existing
|
||||
.offset
|
||||
.checked_add(existing.file_size)
|
||||
.ok_or_else(|| Error::Invalid("PT_LOAD file range overflow".to_owned()))?;
|
||||
if segment.offset < existing_file_end && existing.offset < segment_file_end {
|
||||
return invalid("new PT_LOAD overlaps an existing file range");
|
||||
}
|
||||
let existing_memory_end = existing
|
||||
.virtual_address
|
||||
.checked_add(existing.memory_size)
|
||||
.ok_or_else(|| Error::Invalid("PT_LOAD memory range overflow".to_owned()))?;
|
||||
if segment.virtual_address < existing_memory_end
|
||||
&& existing.virtual_address < segment_memory_end
|
||||
{
|
||||
return invalid("new PT_LOAD overlaps an existing memory range");
|
||||
}
|
||||
}
|
||||
let new_count = self
|
||||
.program_header_count
|
||||
.checked_add(1)
|
||||
.ok_or_else(|| Error::Invalid("program header count overflow".to_owned()))?;
|
||||
let new_count_u16 = u16::try_from(new_count)
|
||||
.map_err(|_| Error::Invalid("program header count exceeds u16".to_owned()))?;
|
||||
let header_offset = checked_index(
|
||||
self.program_header_offset,
|
||||
self.program_header_count,
|
||||
self.program_header_size,
|
||||
)?;
|
||||
let header_end = header_offset
|
||||
.checked_add(self.program_header_size)
|
||||
.ok_or_else(|| Error::Invalid("new program header range overflow".to_owned()))?;
|
||||
slice(output, header_offset, self.program_header_size)?;
|
||||
let first_file_section = self
|
||||
.section_headers
|
||||
.iter()
|
||||
.filter(|section| section.section_type != SHT_NOBITS && section.size != 0)
|
||||
.map(|section| section.offset)
|
||||
.min();
|
||||
if first_file_section.is_some_and(|offset| header_end as u64 > offset) {
|
||||
return invalid("no space for an additional program header");
|
||||
}
|
||||
|
||||
let mut header = [0_u8; 0x38];
|
||||
header[0..4].copy_from_slice(&PT_LOAD.to_le_bytes());
|
||||
header[4..8].copy_from_slice(&segment.flags.to_le_bytes());
|
||||
header[8..0x10].copy_from_slice(&segment.offset.to_le_bytes());
|
||||
header[0x10..0x18].copy_from_slice(&segment.virtual_address.to_le_bytes());
|
||||
header[0x18..0x20].copy_from_slice(&segment.virtual_address.to_le_bytes());
|
||||
header[0x20..0x28].copy_from_slice(&segment.file_size.to_le_bytes());
|
||||
header[0x28..0x30].copy_from_slice(&segment.memory_size.to_le_bytes());
|
||||
header[0x30..0x38].copy_from_slice(&segment.alignment.to_le_bytes());
|
||||
output
|
||||
.get_mut(header_offset..header_end)
|
||||
.ok_or_else(|| Error::Invalid("new program header exceeds output".to_owned()))?
|
||||
.copy_from_slice(&header);
|
||||
output
|
||||
.get_mut(0x38..0x3a)
|
||||
.ok_or_else(|| Error::Invalid("ELF header is truncated".to_owned()))?
|
||||
.copy_from_slice(&new_count_u16.to_le_bytes());
|
||||
|
||||
let mut updated = self.clone();
|
||||
updated.program_header_count = new_count;
|
||||
updated.program_headers.push(segment);
|
||||
Ok(updated)
|
||||
}
|
||||
|
||||
/// Resolve every section's name from the ELF `shstrtab` section.
|
||||
///
|
||||
/// The returned names are source data, not role labels supplied by the
|
||||
/// caller. Any malformed string-table reference is an input error.
|
||||
pub fn section_names(&self, data: &[u8]) -> Result<Vec<String>> {
|
||||
let table = self
|
||||
.section_headers
|
||||
.get(self.section_name_index)
|
||||
.copied()
|
||||
.ok_or_else(|| Error::Invalid("ELF section-name index is out of range".to_owned()))?;
|
||||
if table.section_type != SHT_STRTAB {
|
||||
return invalid(format!(
|
||||
"ELF section-name table has unexpected type 0x{:x}",
|
||||
table.section_type
|
||||
));
|
||||
}
|
||||
let strings = slice_u64(data, table.offset, table.size)?;
|
||||
if strings.is_empty() || strings[0] != 0 {
|
||||
return invalid("ELF section-name table does not start with NUL");
|
||||
}
|
||||
if strings.last().copied() != Some(0) {
|
||||
return invalid("ELF section-name table is not NUL terminated");
|
||||
}
|
||||
self.section_headers
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(index, section)| {
|
||||
let offset = section.name as usize;
|
||||
if offset >= strings.len() {
|
||||
return invalid(format!(
|
||||
"ELF section {index} name offset 0x{offset:x} exceeds section-name table"
|
||||
));
|
||||
}
|
||||
let end = strings[offset..]
|
||||
.iter()
|
||||
.position(|&byte| byte == 0)
|
||||
.map(|length| offset + length)
|
||||
.ok_or_else(|| {
|
||||
Error::Invalid(format!(
|
||||
"ELF section {index} name at 0x{offset:x} is unterminated"
|
||||
))
|
||||
})?;
|
||||
let name = std::str::from_utf8(&strings[offset..end]).map_err(|error| {
|
||||
Error::Invalid(format!(
|
||||
"ELF section {index} name at 0x{offset:x} is not UTF-8: {error}"
|
||||
))
|
||||
})?;
|
||||
if index == 0 && section.name != 0 {
|
||||
return invalid("ELF null section has a nonzero name offset");
|
||||
}
|
||||
Ok(name.to_owned())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn file_offset_to_virtual_address(&self, offset: u64, size: u64) -> Result<u64> {
|
||||
let end = offset
|
||||
.checked_add(size)
|
||||
.ok_or_else(|| Error::Invalid("file range overflow".to_owned()))?;
|
||||
for segment in &self.program_headers {
|
||||
let segment_end = segment
|
||||
.offset
|
||||
.checked_add(segment.file_size)
|
||||
.ok_or_else(|| Error::Invalid("PT_LOAD file range overflow".to_owned()))?;
|
||||
if segment.offset <= offset && end <= segment_end {
|
||||
return segment
|
||||
.virtual_address
|
||||
.checked_add(offset - segment.offset)
|
||||
.ok_or_else(|| Error::Invalid("virtual address overflow".to_owned()));
|
||||
}
|
||||
}
|
||||
invalid(format!(
|
||||
"file range 0x{offset:x}..0x{end:x} is not in PT_LOAD"
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn slice(data: &[u8], offset: usize, size: usize) -> Result<&[u8]> {
|
||||
let end = offset
|
||||
.checked_add(size)
|
||||
.ok_or_else(|| Error::Invalid("byte range overflow".to_owned()))?;
|
||||
data.get(offset..end).ok_or_else(|| {
|
||||
Error::Invalid(format!(
|
||||
"byte range 0x{offset:x}..0x{end:x} is out of bounds"
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
pub fn slice_u64(data: &[u8], offset: u64, size: u64) -> Result<&[u8]> {
|
||||
slice(
|
||||
data,
|
||||
usize_from_u64(offset, "file offset")?,
|
||||
usize_from_u64(size, "file size")?,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn read_u16(data: &[u8], offset: usize) -> Result<u16> {
|
||||
let bytes: [u8; 2] = slice(data, offset, 2)?
|
||||
.try_into()
|
||||
.map_err(|_| Error::Invalid("invalid u16 range".to_owned()))?;
|
||||
Ok(u16::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
pub fn read_u32(data: &[u8], offset: usize) -> Result<u32> {
|
||||
let bytes: [u8; 4] = slice(data, offset, 4)?
|
||||
.try_into()
|
||||
.map_err(|_| Error::Invalid("invalid u32 range".to_owned()))?;
|
||||
Ok(u32::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
pub fn read_u64(data: &[u8], offset: usize) -> Result<u64> {
|
||||
let bytes: [u8; 8] = slice(data, offset, 8)?
|
||||
.try_into()
|
||||
.map_err(|_| Error::Invalid("invalid u64 range".to_owned()))?;
|
||||
Ok(u64::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
pub fn read_i64(data: &[u8], offset: usize) -> Result<i64> {
|
||||
let bytes: [u8; 8] = slice(data, offset, 8)?
|
||||
.try_into()
|
||||
.map_err(|_| Error::Invalid("invalid i64 range".to_owned()))?;
|
||||
Ok(i64::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
pub fn usize_from_u64(value: u64, field: &str) -> Result<usize> {
|
||||
usize::try_from(value).map_err(|_| Error::Invalid(format!("{field} 0x{value:x} exceeds usize")))
|
||||
}
|
||||
|
||||
pub fn checked_index(base: usize, index: usize, stride: usize) -> Result<usize> {
|
||||
index
|
||||
.checked_mul(stride)
|
||||
.and_then(|value| base.checked_add(value))
|
||||
.ok_or_else(|| Error::Invalid("table index overflow".to_owned()))
|
||||
}
|
||||
|
||||
pub fn align_up(value: u64, alignment: u64) -> Result<u64> {
|
||||
if alignment == 0 || !alignment.is_power_of_two() {
|
||||
return invalid(format!("invalid alignment {alignment}"));
|
||||
}
|
||||
value
|
||||
.checked_add(alignment - 1)
|
||||
.map(|aligned| aligned & !(alignment - 1))
|
||||
.ok_or_else(|| Error::Invalid("alignment overflow".to_owned()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn layout(name_index: u32) -> ElfLayout {
|
||||
ElfLayout {
|
||||
entrypoint: 0,
|
||||
program_header_offset: 0,
|
||||
program_header_size: 0x38,
|
||||
program_header_count: 0,
|
||||
program_headers: Vec::new(),
|
||||
section_headers: vec![
|
||||
SectionHeader {
|
||||
name: 0,
|
||||
section_type: 0,
|
||||
flags: 0,
|
||||
address: 0,
|
||||
offset: 0,
|
||||
size: 0,
|
||||
link: 0,
|
||||
info: 0,
|
||||
alignment: 0,
|
||||
entry_size: 0,
|
||||
},
|
||||
SectionHeader {
|
||||
name: name_index,
|
||||
section_type: 1,
|
||||
flags: 0,
|
||||
address: 0,
|
||||
offset: 0,
|
||||
size: 0,
|
||||
link: 0,
|
||||
info: 0,
|
||||
alignment: 0,
|
||||
entry_size: 0,
|
||||
},
|
||||
SectionHeader {
|
||||
name: 1,
|
||||
section_type: SHT_STRTAB,
|
||||
flags: 0,
|
||||
address: 0,
|
||||
offset: 0,
|
||||
size: 8,
|
||||
link: 0,
|
||||
info: 0,
|
||||
alignment: 1,
|
||||
entry_size: 0,
|
||||
},
|
||||
],
|
||||
section_name_index: 2,
|
||||
private_section_index: usize::MAX,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn section_names_resolve_from_elf_string_table() {
|
||||
let names = layout(1)
|
||||
.section_names(b"\0text\0\0\0")
|
||||
.expect("valid names");
|
||||
assert_eq!(names, ["", "text", "text"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn section_names_reject_out_of_range_name_offsets() {
|
||||
let error = layout(8)
|
||||
.section_names(b"\0text\0\0\0")
|
||||
.expect_err("invalid offset");
|
||||
assert!(error.to_string().contains("exceeds section-name table"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn section_names_reject_invalid_utf8() {
|
||||
let mut elf_layout = layout(1);
|
||||
elf_layout.section_headers[1].name = 1;
|
||||
let error = elf_layout
|
||||
.section_names(b"\0\xff\0\0\0\0\0\0")
|
||||
.expect_err("invalid UTF-8");
|
||||
assert!(error.to_string().contains("is not UTF-8"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn section_names_reject_non_string_table() {
|
||||
let mut elf_layout = layout(1);
|
||||
elf_layout.section_headers[2].section_type = 1;
|
||||
let error = elf_layout
|
||||
.section_names(b"\0text\0\0\0")
|
||||
.expect_err("wrong section type");
|
||||
assert!(error.to_string().contains("unexpected type"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn section_names_reject_unterminated_table() {
|
||||
let elf_layout = layout(1);
|
||||
let error = elf_layout
|
||||
.section_names(b"\0text\0\x01\x01")
|
||||
.expect_err("unterminated table");
|
||||
assert!(error.to_string().contains("not NUL terminated"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn append_load_segment_updates_program_headers() {
|
||||
let elf_layout = ElfLayout {
|
||||
entrypoint: 0,
|
||||
program_header_offset: 0,
|
||||
program_header_size: 0x38,
|
||||
program_header_count: 0,
|
||||
program_headers: Vec::new(),
|
||||
section_headers: Vec::new(),
|
||||
section_name_index: 0,
|
||||
private_section_index: usize::MAX,
|
||||
};
|
||||
let mut output = vec![0_u8; 0x2000];
|
||||
let updated = elf_layout
|
||||
.append_load_segment(
|
||||
&mut output,
|
||||
LoadSegment {
|
||||
offset: 0x1000,
|
||||
virtual_address: 0x2000,
|
||||
file_size: 0x20,
|
||||
memory_size: 0x20,
|
||||
flags: PF_R,
|
||||
alignment: 0x1000,
|
||||
},
|
||||
)
|
||||
.expect("append segment");
|
||||
assert_eq!(updated.program_header_count, 1);
|
||||
assert_eq!(updated.program_headers[0].virtual_address, 0x2000);
|
||||
assert_eq!(&output[0..4], &PT_LOAD.to_le_bytes());
|
||||
assert_eq!(&output[0x38..0x3a], &1_u16.to_le_bytes());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn append_load_segment_rejects_program_header_overlap() {
|
||||
let mut elf_layout = ElfLayout {
|
||||
entrypoint: 0,
|
||||
program_header_offset: 0,
|
||||
program_header_size: 0x38,
|
||||
program_header_count: 0,
|
||||
program_headers: Vec::new(),
|
||||
section_headers: Vec::new(),
|
||||
section_name_index: 0,
|
||||
private_section_index: usize::MAX,
|
||||
};
|
||||
elf_layout.section_headers.push(SectionHeader {
|
||||
name: 0,
|
||||
section_type: 1,
|
||||
flags: 0,
|
||||
address: 0,
|
||||
offset: 0x20,
|
||||
size: 1,
|
||||
link: 0,
|
||||
info: 0,
|
||||
alignment: 1,
|
||||
entry_size: 0,
|
||||
});
|
||||
let mut output = vec![0_u8; 0x100];
|
||||
let error = elf_layout
|
||||
.append_load_segment(
|
||||
&mut output,
|
||||
LoadSegment {
|
||||
offset: 0x80,
|
||||
virtual_address: 0x1080,
|
||||
file_size: 0x20,
|
||||
memory_size: 0x20,
|
||||
flags: PF_R,
|
||||
alignment: 0x1000,
|
||||
},
|
||||
)
|
||||
.expect_err("overlapping program header");
|
||||
assert!(error.to_string().contains("additional program header"));
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,64 @@
|
||||
use goblin::elf::{Elf, header::EM_AARCH64, program_header::PT_LOAD};
|
||||
use thiserror::Error;
|
||||
|
||||
pub mod hash;
|
||||
pub mod layout;
|
||||
|
||||
pub use hash::{build_gnu_hash, build_sysv_hash};
|
||||
pub use layout::{
|
||||
ElfLayout, LoadSegment, PF_R, SHF_ALLOC, SHT_LOUSER, SHT_NOBITS, SectionHeader, align_up,
|
||||
checked_index, read_i64, read_u16, read_u32, read_u64, slice, slice_u64, usize_from_u64,
|
||||
};
|
||||
|
||||
/// ELF machine identifier for AArch64.
|
||||
pub const AARCH64_MACHINE: u16 = EM_AARCH64;
|
||||
|
||||
/// Dynamic sections required by the restored AArch64 loader image.
|
||||
pub const DYNAMIC_SECTION_NAMES: [&str; 8] = [
|
||||
".dynsym",
|
||||
".gnu.version",
|
||||
".gnu.version_r",
|
||||
".gnu.hash",
|
||||
".dynstr",
|
||||
".rela.dyn",
|
||||
".rela.plt",
|
||||
".dynamic",
|
||||
];
|
||||
|
||||
/// Dynamic sections needed to identify a protected image before extraction.
|
||||
pub const PROBE_SECTION_NAMES: [&str; 5] = [
|
||||
".dynsym",
|
||||
".dynstr",
|
||||
".gnu.hash",
|
||||
".gnu.version",
|
||||
".gnu.version_r",
|
||||
];
|
||||
|
||||
/// ELF64 dynamic table record sizes.
|
||||
pub const ELF64_SYMBOL_SIZE: usize = 0x18;
|
||||
pub const ELF64_RELA_SIZE: usize = 0x18;
|
||||
|
||||
/// AArch64 relocation kinds used by the dynamic linker.
|
||||
pub const R_AARCH64_ABS64: u32 = 0x101;
|
||||
pub const R_AARCH64_GLOB_DAT: u32 = 0x401;
|
||||
pub const R_AARCH64_JUMP_SLOT: u32 = 0x402;
|
||||
pub const R_AARCH64_RELATIVE: u32 = 0x403;
|
||||
pub const VER_NDX_GLOBAL: u16 = 1;
|
||||
|
||||
/// ELF dynamic-table tag identifiers used by restored images.
|
||||
pub const DT_PLTRELSZ: u64 = 2;
|
||||
pub const DT_HASH: u64 = 4;
|
||||
pub const DT_STRTAB: u64 = 5;
|
||||
pub const DT_SYMTAB: u64 = 6;
|
||||
pub const DT_RELA: u64 = 7;
|
||||
pub const DT_RELASZ: u64 = 8;
|
||||
pub const DT_STRSZ: u64 = 10;
|
||||
pub const DT_JMPREL: u64 = 23;
|
||||
pub const DT_GNU_HASH: u64 = 0x6fff_fef5;
|
||||
pub const DT_VERSYM: u64 = 0x6fff_fff0;
|
||||
pub const DT_RELACOUNT: u64 = 0x6fff_fff9;
|
||||
pub const DT_VERNEED: u64 = 0x6fff_fffe;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum Error {
|
||||
#[error("ELF parse failed: {0}")]
|
||||
@@ -11,6 +69,8 @@ pub enum Error {
|
||||
NotElf64,
|
||||
#[error("input is not an AArch64 image")]
|
||||
NotAarch64,
|
||||
#[error("invalid ELF layout: {0}")]
|
||||
Invalid(String),
|
||||
}
|
||||
|
||||
pub type Result<T> = std::result::Result<T, Error>;
|
||||
@@ -31,6 +91,17 @@ pub fn is_aarch64(data: &[u8]) -> bool {
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
/// Return whether a short prefix identifies an ELF64 little-endian AArch64
|
||||
/// image. This is intentionally a prefix-only check for filesystem scanners;
|
||||
/// callers that need structural guarantees must use [`parse`].
|
||||
#[must_use]
|
||||
pub fn is_aarch64_prefix(data: &[u8]) -> bool {
|
||||
data.get(0..6) == Some(b"\x7fELF\x02\x01")
|
||||
&& data
|
||||
.get(18..20)
|
||||
.is_some_and(|bytes| u16::from_le_bytes([bytes[0], bytes[1]]) == EM_AARCH64)
|
||||
}
|
||||
|
||||
/// Return the maximum file end among PT_LOAD segments.
|
||||
pub fn load_file_end(data: &[u8]) -> Result<u64> {
|
||||
let elf = parse(data)?;
|
||||
@@ -43,6 +114,10 @@ pub fn load_file_end(data: &[u8]) -> Result<u64> {
|
||||
.unwrap_or(0))
|
||||
}
|
||||
|
||||
pub(crate) fn invalid<T>(message: impl Into<String>) -> Result<T> {
|
||||
Err(Error::Invalid(message.into()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
Reference in New Issue
Block a user