Adjusts the e_type, e_machine and program headers.

Author: Lichtso

src/elf.rs

@@ -407,7 +407,7 @@ impl<C: ContextObject> Executable<C> {
         loader: Arc<BuiltinProgram<C>>,
     ) -> Result<Self, ElfParserError> {
         use crate::elf_parser::{
-            consts::{ELFMAG, EV_CURRENT, PF_R, PF_W, PF_X, PT_LOAD, SHN_UNDEF, STT_FUNC},
+            consts::{ELFMAG, EV_CURRENT, PF_R, PF_X, PT_LOAD, SHN_UNDEF, STT_FUNC},
             types::{Elf64Ehdr, Elf64Shdr, Elf64Sym},
         };
 
@@ -426,8 +426,8 @@ impl<C: ContextObject> Executable<C> {
             || file_header.e_ident.ei_osabi != ELFOSABI_NONE
             || file_header.e_ident.ei_abiversion != 0x00
             || file_header.e_ident.ei_pad != [0x00; 7]
-            || file_header.e_type != ET_DYN
-            || file_header.e_machine != EM_SBPF
+            // file_header.e_type
+            || file_header.e_machine != EM_BPF
             || file_header.e_version != EV_CURRENT
             // file_header.e_entry
             || file_header.e_phoff != mem::size_of::<Elf64Ehdr>() as u64
@@ -444,31 +444,25 @@ impl<C: ContextObject> Executable<C> {
             return Err(ElfParserError::InvalidFileHeader);
         }
 
-        const EXPECTED_PROGRAM_HEADERS: [(u32, u64); 4] = [
-            (PF_X, ebpf::MM_BYTECODE_START),     // byte code
-            (PF_R, ebpf::MM_RODATA_START),       // read only data
-            (PF_R | PF_W, ebpf::MM_STACK_START), // stack
-            (PF_R | PF_W, ebpf::MM_HEAP_START),  // heap
+        const EXPECTED_PROGRAM_HEADERS: [(u32, u64); 2] = [
+            (PF_R, 0), // read only data
+            (PF_X, 1), // byte code
         ];
         let program_header_table =
             Elf64::slice_from_bytes::<Elf64Phdr>(elf_bytes, program_header_table_range.clone())?;
-        for (program_header, (p_flags, p_vaddr)) in program_header_table
+        for (program_header, (p_flags, p_index)) in program_header_table
             .iter()
             .zip(EXPECTED_PROGRAM_HEADERS.iter())
         {
-            let p_filesz = if (*p_flags & PF_W) != 0 {
-                0
-            } else {
-                program_header.p_memsz
-            };
+            let p_vaddr = p_index * ebpf::MM_REGION_SIZE;
             if program_header.p_type != PT_LOAD
                 || program_header.p_flags != *p_flags
                 || program_header.p_offset < program_header_table_range.end as u64
                 || program_header.p_offset >= elf_bytes.len() as u64
                 || program_header.p_offset.checked_rem(ebpf::INSN_SIZE as u64) != Some(0)
-                || program_header.p_vaddr != *p_vaddr
-                || program_header.p_paddr != *p_vaddr
-                || program_header.p_filesz != p_filesz
+                || program_header.p_vaddr != p_vaddr
+                || program_header.p_paddr != p_vaddr
+                || program_header.p_filesz != program_header.p_memsz
                 || program_header.p_filesz
                     > (elf_bytes.len() as u64).saturating_sub(program_header.p_offset)
                 || program_header.p_filesz.checked_rem(ebpf::INSN_SIZE as u64) != Some(0)
@@ -478,8 +472,8 @@ impl<C: ContextObject> Executable<C> {
             }
         }
 
-        let bytecode_header = &program_header_table[0];
-        let rodata_header = &program_header_table[1];
+        let rodata_header = &program_header_table[0];
+        let bytecode_header = &program_header_table[1];
         let text_section_vaddr = bytecode_header.p_vaddr;
         let text_section_range = bytecode_header.file_range().unwrap_or_default();
         let ro_section = Section::Borrowed(
@@ -501,10 +495,6 @@ impl<C: ContextObject> Executable<C> {
             .saturating_sub(bytecode_header.p_vaddr)
             .checked_div(ebpf::INSN_SIZE as u64)
             .unwrap_or_default() as usize;
-        let entry_insn = ebpf::get_insn(&elf_bytes[text_section_range.clone()], entry_pc);
-        if !entry_insn.is_function_start_marker() {
-            return Err(ElfParserError::InvalidFileHeader);
-        }
 
         let mut function_registry = FunctionRegistry::<usize>::default();
         let config = loader.get_config();

tests/elf.rs

@@ -58,7 +58,12 @@ fn test_strict_header() {
     assert_eq!(err, ElfParserError::OutOfBounds);
 
     // Break the file header one byte at a time
-    let expected_results = std::iter::repeat_n(&Err(ElfParserError::InvalidFileHeader), 40)
+    let expected_results = std::iter::repeat_n(&Err(ElfParserError::InvalidFileHeader), 16)
+        .chain(std::iter::repeat_n(&Ok(()), 2))
+        .chain(std::iter::repeat_n(
+            &Err(ElfParserError::InvalidFileHeader),
+            22,
+        ))
         .chain(std::iter::repeat_n(&Ok(()), 12))
         .chain(std::iter::repeat_n(
             &Err(ElfParserError::InvalidFileHeader),
@@ -81,20 +86,9 @@ fn test_strict_header() {
         std::iter::repeat_n(&Err(ElfParserError::InvalidProgramHeader), 48)
             .chain(std::iter::repeat_n(&Ok(()), 8))
             .collect::<Vec<_>>();
-    let expected_results_writable =
-        std::iter::repeat_n(&Err(ElfParserError::InvalidProgramHeader), 40)
-            .chain(std::iter::repeat_n(&Ok(()), 4))
-            .chain(std::iter::repeat_n(
-                &Err(ElfParserError::InvalidProgramHeader),
-                4,
-            ))
-            .chain(std::iter::repeat_n(&Ok(()), 8))
-            .collect::<Vec<_>>();
     let expected_results = vec![
         expected_results_readonly.iter(),
         expected_results_readonly.iter(),
-        expected_results_writable.iter(),
-        expected_results_writable.iter(),
     ];
     for (header_index, expected_results) in expected_results.into_iter().enumerate() {
         for (offset, expected) in (std::mem::size_of::<Elf64Ehdr>()
@@ -114,19 +108,11 @@ fn test_strict_header() {
     // Check that an unaligned program header length fails
     {
         let mut elf_bytes = elf_bytes.clone();
-        elf_bytes[0x60] = 0x29;
-        elf_bytes[0x68] = 0x29;
+        elf_bytes[0x98] = 0x29;
+        elf_bytes[0xA0] = 0x29;
         let err = ElfExecutable::load_with_strict_parser(&elf_bytes, loader.clone()).unwrap_err();
         assert_eq!(err, ElfParserError::InvalidProgramHeader);
     }
-
-    // Check that an entrypoint missing a function start marker fails
-    {
-        let mut elf_bytes = elf_bytes.clone();
-        elf_bytes[0x1B8] = 0x00;
-        let err = ElfExecutable::load_with_strict_parser(&elf_bytes, loader.clone()).unwrap_err();
-        assert_eq!(err, ElfParserError::InvalidFileHeader);
-    }
 }
 
 #[test]

tests/elfs/elf.ld

@@ -1,14 +1,14 @@
 SECTIONS
 {
-  .text 0x000000000 : {
-     *(.text*)
-  } :text
-  .rodata 0x100000000 : {
+  .rodata 0x000000000 : {
     *(.rodata*)
     *(.data.rel.ro*)
     BYTE(0);
     . = ALIGN(8);
   } :rodata
+  .text 0x100000000 : {
+     *(.text*)
+  } :text
   .bss.stack 0x200000000 (NOLOAD) : {
       _stack_start = .;
       . = . + 0x1000;
@@ -37,8 +37,8 @@ SECTIONS
 
 PHDRS
 {
-  text PT_LOAD FLAGS(1);
   rodata PT_LOAD FLAGS(4);
+  text PT_LOAD FLAGS(1);
   stack PT_LOAD FLAGS(6);
   heap PT_LOAD FLAGS(6);
   dynsym PT_NULL FLAGS(0);