use crate::println;
const EI_MAG0: usize = 0;
const EI_MAG3: usize = 3;
const EI_CLASS: usize = 4;
const EI_DATA: usize = 5;
const ELF_MAGIC: [u8; 4] = [0x7f, b'E', b'L', b'F'];
const ELFCLASS64: u8 = 2;
const ELFDATA2LSB: u8 = 1;
const ET_EXEC: u16 = 2;
const EM_RISCV: u16 = 243;
const PT_LOAD: u32 = 1;
#[derive(Debug, Clone)]
pub struct ElfSegment {
pub offset: usize,
pub vaddr: usize,
pub filesz: usize,
pub memsz: usize,
pub flags: u32,
}
#[derive(Debug, Clone)]
pub struct Elf {
pub entry: usize,
pub segments: alloc::vec::Vec<ElfSegment>,
}
fn read_u16(data: &[u8], offset: usize) -> u16 {
u16::from_le_bytes([data[offset], data[offset + 1]])
}
fn read_u32(data: &[u8], offset: usize) -> u32 {
u32::from_le_bytes([
data[offset],
data[offset + 1],
data[offset + 2],
data[offset + 3],
])
}
fn read_u64(data: &[u8], offset: usize) -> u64 {
u64::from_le_bytes([
data[offset],
data[offset + 1],
data[offset + 2],
data[offset + 3],
data[offset + 4],
data[offset + 5],
data[offset + 6],
data[offset + 7],
])
}
impl Elf {
pub fn parse(data: &[u8]) -> Result<Self, &'static str> {
if data.len() < 64 {
return Err("ELF: file too small for header");
}
if data[EI_MAG0..=EI_MAG3] != ELF_MAGIC {
return Err("ELF: bad magic");
}
if data[EI_CLASS] != ELFCLASS64 {
return Err("ELF: not 64-bit");
}
if data[EI_DATA] != ELFDATA2LSB {
return Err("ELF: not little-endian");
}
let e_type = read_u16(data, 16);
if e_type != ET_EXEC {
return Err("ELF: not executable");
}
let e_machine = read_u16(data, 18);
if e_machine != EM_RISCV {
return Err("ELF: not RISC-V");
}
let entry = read_u64(data, 24) as usize;
let phoff = read_u64(data, 32) as usize;
let phentsize = read_u16(data, 54) as usize;
let phnum = read_u16(data, 56) as usize;
println!(
"[ELF] entry={:#x} phoff={} phentsize={} phnum={}",
entry, phoff, phentsize, phnum
);
if phentsize < 56 {
return Err("ELF: program header entry too small");
}
let ph_table_size = phentsize
.checked_mul(phnum)
.ok_or("ELF: program header table overflow")?;
let ph_table_end = phoff
.checked_add(ph_table_size)
.ok_or("ELF: program header table overflow")?;
if ph_table_end > data.len() {
return Err("ELF: program header table out of bounds");
}
let mut segments = alloc::vec::Vec::new();
for i in 0..phnum {
let offset = phoff
.checked_add(
i.checked_mul(phentsize)
.ok_or("ELF: program header offset overflow")?,
)
.ok_or("ELF: program header offset overflow")?;
let header_end = offset
.checked_add(56)
.ok_or("ELF: program header offset overflow")?;
if header_end > data.len() {
return Err("ELF: program header out of bounds");
}
let p_type = read_u32(data, offset);
let p_flags = read_u32(data, offset + 4);
let p_offset = read_u64(data, offset + 8) as usize;
let p_vaddr = read_u64(data, offset + 16) as usize;
let p_filesz = read_u64(data, offset + 32) as usize;
let p_memsz = read_u64(data, offset + 40) as usize;
if p_type == PT_LOAD {
println!(
"[ELF] LOAD seg: vaddr={:#x} offset={:#x} filesz={} memsz={} flags={}",
p_vaddr, p_offset, p_filesz, p_memsz, p_flags
);
if p_filesz > p_memsz {
return Err("ELF: segment file size exceeds memory size");
}
let file_end = p_offset
.checked_add(p_filesz)
.ok_or("ELF: segment file range overflow")?;
if file_end > data.len() {
return Err("ELF: segment data out of bounds");
}
p_vaddr
.checked_add(p_memsz)
.ok_or("ELF: segment memory range overflow")?;
segments.push(ElfSegment {
offset: p_offset,
vaddr: p_vaddr,
filesz: p_filesz,
memsz: p_memsz,
flags: p_flags,
});
}
}
if segments.is_empty() {
return Err("ELF: no LOAD segments");
}
let entry_is_loadable = segments.iter().any(|seg| {
seg.vaddr <= entry && entry < seg.vaddr.checked_add(seg.memsz).unwrap_or(seg.vaddr)
});
if !entry_is_loadable {
return Err("ELF: entry outside LOAD segments");
}
Ok(Elf { entry, segments })
}
pub fn segment_data<'a>(&self, seg: &ElfSegment, raw: &'a [u8]) -> &'a [u8] {
&raw[seg.offset..seg.offset + seg.filesz]
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::process::user_elf::build_user_elf;
#[test_case]
fn elf_parser_accepts_embedded_user_elf_contract() {
let (elf, entry) = build_user_elf();
let parsed = Elf::parse(&elf).expect("embedded user ELF should parse");
assert_eq!(parsed.entry, entry);
assert_eq!(parsed.segments.len(), 1);
}
#[test_case]
fn elf_parser_rejects_non_executable_type() {
let (mut elf, _) = build_user_elf();
elf[16..18].copy_from_slice(&3u16.to_le_bytes()); assert!(matches!(Elf::parse(&elf), Err("ELF: not executable")));
}
#[test_case]
fn elf_parser_rejects_entry_outside_load_segments() {
let (mut elf, _) = build_user_elf();
elf[24..32].copy_from_slice(&0x9000_0000u64.to_le_bytes());
assert!(matches!(
Elf::parse(&elf),
Err("ELF: entry outside LOAD segments")
));
}
}