1use crate::println;
7
8const EI_MAG0: usize = 0;
10const EI_MAG3: usize = 3;
11const EI_CLASS: usize = 4;
12const EI_DATA: usize = 5;
13
14const ELF_MAGIC: [u8; 4] = [0x7f, b'E', b'L', b'F'];
16const ELFCLASS64: u8 = 2;
17const ELFDATA2LSB: u8 = 1;
18
19const ET_EXEC: u16 = 2; const EM_RISCV: u16 = 243;
24
25const PT_LOAD: u32 = 1;
27
28#[derive(Debug, Clone)]
30pub struct ElfSegment {
31 pub offset: usize,
33 pub vaddr: usize,
35 pub filesz: usize,
37 pub memsz: usize,
39 pub flags: u32,
41}
42
43#[derive(Debug, Clone)]
45pub struct Elf {
46 pub entry: usize,
48 pub segments: alloc::vec::Vec<ElfSegment>,
50}
51
52fn read_u16(data: &[u8], offset: usize) -> u16 {
54 u16::from_le_bytes([data[offset], data[offset + 1]])
55}
56
57fn read_u32(data: &[u8], offset: usize) -> u32 {
59 u32::from_le_bytes([
60 data[offset],
61 data[offset + 1],
62 data[offset + 2],
63 data[offset + 3],
64 ])
65}
66
67fn read_u64(data: &[u8], offset: usize) -> u64 {
69 u64::from_le_bytes([
70 data[offset],
71 data[offset + 1],
72 data[offset + 2],
73 data[offset + 3],
74 data[offset + 4],
75 data[offset + 5],
76 data[offset + 6],
77 data[offset + 7],
78 ])
79}
80
81impl Elf {
82 pub fn parse(data: &[u8]) -> Result<Self, &'static str> {
86 if data.len() < 64 {
88 return Err("ELF: file too small for header");
89 }
90
91 if data[EI_MAG0..=EI_MAG3] != ELF_MAGIC {
93 return Err("ELF: bad magic");
94 }
95 if data[EI_CLASS] != ELFCLASS64 {
97 return Err("ELF: not 64-bit");
98 }
99 if data[EI_DATA] != ELFDATA2LSB {
101 return Err("ELF: not little-endian");
102 }
103
104 let e_type = read_u16(data, 16);
105 if e_type != ET_EXEC {
106 return Err("ELF: not executable");
107 }
108
109 let e_machine = read_u16(data, 18);
110 if e_machine != EM_RISCV {
111 return Err("ELF: not RISC-V");
112 }
113
114 let entry = read_u64(data, 24) as usize;
115 let phoff = read_u64(data, 32) as usize;
116 let phentsize = read_u16(data, 54) as usize;
117 let phnum = read_u16(data, 56) as usize;
118
119 println!(
120 "[ELF] entry={:#x} phoff={} phentsize={} phnum={}",
121 entry, phoff, phentsize, phnum
122 );
123
124 if phentsize < 56 {
125 return Err("ELF: program header entry too small");
126 }
127 let ph_table_size = phentsize
128 .checked_mul(phnum)
129 .ok_or("ELF: program header table overflow")?;
130 let ph_table_end = phoff
131 .checked_add(ph_table_size)
132 .ok_or("ELF: program header table overflow")?;
133 if ph_table_end > data.len() {
134 return Err("ELF: program header table out of bounds");
135 }
136
137 let mut segments = alloc::vec::Vec::new();
139
140 for i in 0..phnum {
141 let offset = phoff
142 .checked_add(
143 i.checked_mul(phentsize)
144 .ok_or("ELF: program header offset overflow")?,
145 )
146 .ok_or("ELF: program header offset overflow")?;
147 let header_end = offset
148 .checked_add(56)
149 .ok_or("ELF: program header offset overflow")?;
150 if header_end > data.len() {
151 return Err("ELF: program header out of bounds");
152 }
153
154 let p_type = read_u32(data, offset);
155 let p_flags = read_u32(data, offset + 4);
156 let p_offset = read_u64(data, offset + 8) as usize;
157 let p_vaddr = read_u64(data, offset + 16) as usize;
158 let p_filesz = read_u64(data, offset + 32) as usize;
159 let p_memsz = read_u64(data, offset + 40) as usize;
160
161 if p_type == PT_LOAD {
162 println!(
163 "[ELF] LOAD seg: vaddr={:#x} offset={:#x} filesz={} memsz={} flags={}",
164 p_vaddr, p_offset, p_filesz, p_memsz, p_flags
165 );
166
167 if p_filesz > p_memsz {
168 return Err("ELF: segment file size exceeds memory size");
169 }
170 let file_end = p_offset
171 .checked_add(p_filesz)
172 .ok_or("ELF: segment file range overflow")?;
173 if file_end > data.len() {
174 return Err("ELF: segment data out of bounds");
175 }
176 p_vaddr
177 .checked_add(p_memsz)
178 .ok_or("ELF: segment memory range overflow")?;
179
180 segments.push(ElfSegment {
181 offset: p_offset,
182 vaddr: p_vaddr,
183 filesz: p_filesz,
184 memsz: p_memsz,
185 flags: p_flags,
186 });
187 }
188 }
189
190 if segments.is_empty() {
191 return Err("ELF: no LOAD segments");
192 }
193 let entry_is_loadable = segments.iter().any(|seg| {
194 seg.vaddr <= entry && entry < seg.vaddr.checked_add(seg.memsz).unwrap_or(seg.vaddr)
195 });
196 if !entry_is_loadable {
197 return Err("ELF: entry outside LOAD segments");
198 }
199
200 Ok(Elf { entry, segments })
201 }
202
203 pub fn segment_data<'a>(&self, seg: &ElfSegment, raw: &'a [u8]) -> &'a [u8] {
205 &raw[seg.offset..seg.offset + seg.filesz]
206 }
207}
208
209#[cfg(test)]
210mod tests {
211 use super::*;
212 use crate::process::user_elf::build_user_elf;
213
214 #[test_case]
215 fn elf_parser_accepts_embedded_user_elf_contract() {
216 let (elf, entry) = build_user_elf();
217 let parsed = Elf::parse(&elf).expect("embedded user ELF should parse");
218 assert_eq!(parsed.entry, entry);
219 assert_eq!(parsed.segments.len(), 1);
220 }
221
222 #[test_case]
223 fn elf_parser_rejects_non_executable_type() {
224 let (mut elf, _) = build_user_elf();
225 elf[16..18].copy_from_slice(&3u16.to_le_bytes()); assert!(matches!(Elf::parse(&elf), Err("ELF: not executable")));
227 }
228
229 #[test_case]
230 fn elf_parser_rejects_entry_outside_load_segments() {
231 let (mut elf, _) = build_user_elf();
232 elf[24..32].copy_from_slice(&0x9000_0000u64.to_le_bytes());
233 assert!(matches!(
234 Elf::parse(&elf),
235 Err("ELF: entry outside LOAD segments")
236 ));
237 }
238}