use alloc::vec::Vec;
use crate::error::{Error, Result};
use crate::ident::{EI_NIDENT, ElfClass, ElfIdent};
use crate::program::ProgramHeader;
use crate::reader::{ReadAt, SliceReader};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ElfType {
None,
Rel,
Exec,
Dyn,
Core,
Other(u16),
}
impl ElfType {
#[must_use]
pub const fn from_u16(value: u16) -> Self {
match value {
0 => Self::None,
1 => Self::Rel,
2 => Self::Exec,
3 => Self::Dyn,
4 => Self::Core,
other => Self::Other(other),
}
}
#[must_use]
pub const fn to_u16(self) -> u16 {
match self {
Self::None => 0,
Self::Rel => 1,
Self::Exec => 2,
Self::Dyn => 3,
Self::Core => 4,
Self::Other(value) => value,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Machine(pub u16);
impl Machine {
pub const NONE: Self = Self(0);
pub const I386: Self = Self(3);
pub const ARM: Self = Self(40);
pub const X86_64: Self = Self(62);
pub const AARCH64: Self = Self(183);
pub const RISCV: Self = Self(243);
#[must_use]
pub const fn value(self) -> u16 {
self.0
}
#[must_use]
pub const fn name(self) -> Option<&'static str> {
match self.0 {
3 => Some("i386"),
40 => Some("arm"),
62 => Some("x86-64"),
183 => Some("aarch64"),
243 => Some("riscv"),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ElfHeader {
pub ident: ElfIdent,
pub r#type: ElfType,
pub machine: Machine,
pub version: u32,
pub entry: u64,
pub phoff: u64,
pub shoff: u64,
pub flags: u32,
pub ehsize: u16,
pub phentsize: u16,
pub phnum: u16,
pub shentsize: u16,
pub shnum: u16,
pub shstrndx: u16,
}
impl ElfHeader {
#[must_use]
pub const fn size(class: ElfClass) -> u64 {
match class {
ElfClass::Elf32 => 52,
ElfClass::Elf64 => 64,
}
}
pub fn parse<R: ReadAt>(reader: &R, ident: ElfIdent) -> Result<Self> {
let endian = ident.data;
let class = ident.class;
let machine_raw = reader.read_u16_at(18, endian)?;
let (entry, phoff, shoff, tail) = match class {
ElfClass::Elf64 => (
reader.read_u64_at(24, endian)?,
reader.read_u64_at(32, endian)?,
reader.read_u64_at(40, endian)?,
48u64,
),
ElfClass::Elf32 => (
u64::from(reader.read_u32_at(24, endian)?),
u64::from(reader.read_u32_at(28, endian)?),
u64::from(reader.read_u32_at(32, endian)?),
36u64,
),
};
Ok(Self {
ident,
r#type: ElfType::from_u16(reader.read_u16_at(16, endian)?),
machine: Machine(machine_raw),
version: reader.read_u32_at(20, endian)?,
entry,
phoff,
shoff,
flags: reader.read_u32_at(tail, endian)?,
ehsize: reader.read_u16_at(tail + 4, endian)?,
phentsize: reader.read_u16_at(tail + 6, endian)?,
phnum: reader.read_u16_at(tail + 8, endian)?,
shentsize: reader.read_u16_at(tail + 10, endian)?,
shnum: reader.read_u16_at(tail + 12, endian)?,
shstrndx: reader.read_u16_at(tail + 14, endian)?,
})
}
pub fn write(&self, out: &mut Vec<u8>) {
let endian = self.ident.data;
let class = self.ident.class;
out.extend_from_slice(&self.ident.to_bytes());
out.extend_from_slice(&endian.u16_bytes(self.r#type.to_u16()));
out.extend_from_slice(&endian.u16_bytes(self.machine.0));
out.extend_from_slice(&endian.u32_bytes(self.version));
match class {
ElfClass::Elf64 => {
out.extend_from_slice(&endian.u64_bytes(self.entry));
out.extend_from_slice(&endian.u64_bytes(self.phoff));
out.extend_from_slice(&endian.u64_bytes(self.shoff));
}
ElfClass::Elf32 => {
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.entry)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.phoff)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.shoff)));
}
}
out.extend_from_slice(&endian.u32_bytes(self.flags));
out.extend_from_slice(&endian.u16_bytes(self.ehsize));
out.extend_from_slice(&endian.u16_bytes(self.phentsize));
out.extend_from_slice(&endian.u16_bytes(self.phnum));
out.extend_from_slice(&endian.u16_bytes(self.shentsize));
out.extend_from_slice(&endian.u16_bytes(self.shnum));
out.extend_from_slice(&endian.u16_bytes(self.shstrndx));
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ElfHeaders {
pub ident: ElfIdent,
pub header: ElfHeader,
pub program_headers: Vec<ProgramHeader>,
}
impl ElfHeaders {
pub fn read_from<R: ReadAt>(reader: &R) -> Result<Self> {
let mut ident_bytes = [0u8; EI_NIDENT];
reader.read_exact_at(0, &mut ident_bytes)?;
let ident = ElfIdent::parse(&ident_bytes)?;
let header = ElfHeader::parse(reader, ident)?;
let endian = ident.data;
let class = ident.class;
let entry_size = ProgramHeader::size(class);
let mut program_headers = Vec::new();
for index in 0..u64::from(header.phnum) {
let offset = header
.phoff
.checked_add(index * entry_size)
.ok_or_else(|| Error::generic("program header table offset overflows"))?;
program_headers.push(ProgramHeader::parse(reader, offset, endian, class)?);
}
Ok(Self {
ident,
header,
program_headers,
})
}
pub fn from_slice(data: &[u8]) -> Result<Self> {
Self::read_from(&SliceReader::new(data))
}
}