Harden BusyBox usermode startup diagnostics

Author: pradosh-arduino

source/includes/executables/elf.h

@@ -163,6 +163,15 @@ typedef struct {
     int64_t  r_addend; // Addend
 } Elf64_Rela;
 
+typedef struct {
+    uint64_t entry;
+    uint64_t phdr_addr;
+    uint16_t phentsize;
+    uint16_t phnum;
+} elf_image_info_t;
+
 void* elf_load_from_memory(void* file_base_address, uint64_t file_size);
 void* elf_load_from_vfs(const char* path);
+void* elf_load_from_memory_ex(void* file_base_address, uint64_t file_size, elf_image_info_t* info);
+void* elf_load_from_vfs_ex(const char* path, elf_image_info_t* info);
 #endif

source/includes/filesystems/fat32.h

@@ -140,6 +140,7 @@ typedef struct {
     uint8_t is_dir;
 } fat32_file_t;
 
+uint32_t fat32_read_fat(fat32_fs_t* fs, uint32_t cluster);
 int fat32_find_path(fat32_fs_t* fs, const char* path, fat32_dir_entry_t* out);
 void fat32_list_root(fat32_fs_t* fs);
 void fat32_list_dir_cluster(fat32_fs_t* fs, uint32_t cluster);

source/includes/paging.h

@@ -46,7 +46,7 @@ void paging_set_hhdm_offset(uint64_t offset);
 uintptr_t allocate_page(void);
 uintptr_t allocate_pages(size_t count);
 uint64_t virtual_to_physical(uint64_t virt);
-
+uint64_t fast_virt_to_phys(void* v);
 uint64_t virt_to_phys(void* v);
 
 #endif

source/includes/userland.h

@@ -21,9 +21,12 @@
 #define USER_CODE_VADDR  0x0000400000000000ULL // canonical user space, isolated PML4 slot
 #define USER_HEAP_VADDR  0x0000400010000000ULL // user heap right above code region
 #define USER_MMAP_VADDR  (USER_HEAP_VADDR + USER_HEAP_SIZE)
+#define USER_TLS_VADDR   (USER_MMAP_VADDR + USER_MMAP_SIZE)
+#define USER_PHDR_VADDR  (USER_TLS_VADDR + 0x1000ULL)
 #define USER_STACK_TOP   0x00007FFFFFFFF000ULL // near top of canonical lower half
 
 void enter_userland_at(uint64_t entry_point);
+int userland_exec(const char* path, int argc, const char* const* argv, const char* const* envp);
 void userland_heap_init(void);
 uint64_t userland_brk(uint64_t requested_break);
 uint64_t userland_mmap_anon(uint64_t length);

source/kernel/C/executables/elf.c

@@ -15,6 +15,121 @@
 #include <heap.h>
 #include <filesystems/vfs.h>
 #include <paging.h>
+#include <userland.h>
+
+static uint32_t* elf_vfs_pos_ptr(vfs_file_t* file)
+{
+    if (!file || !file->mnt)
+        return NULL;
+
+    switch (file->mnt->type) {
+        case FS_FAT16:
+            return &file->f.fat16.pos;
+        case FS_FAT32:
+            return &file->f.fat32.pos;
+        case FS_ISO9660:
+            return &file->f.iso9660.pos;
+        default:
+            return NULL;
+    }
+}
+
+static int elf_vfs_seek(vfs_file_t* file, uint32_t offset)
+{
+    uint32_t* pos = elf_vfs_pos_ptr(file);
+    if (!pos)
+        return -1;
+
+    if (file->mnt->type == FS_FAT32) {
+        fat32_file_t* fat32 = &file->f.fat32;
+        uint32_t cluster_size = fat32->fs->sectors_per_cluster * FAT32_SECTOR_SIZE;
+        uint32_t cluster = fat32->start_cluster;
+        uint32_t steps = cluster_size ? (offset / cluster_size) : 0;
+
+        while (steps > 0 && cluster < FAT32_CLUSTER_EOC) {
+            cluster = fat32_read_fat(fat32->fs, cluster);
+            steps--;
+        }
+
+        fat32->current_cluster = cluster;
+    }
+
+    *pos = offset;
+    return 0;
+}
+
+static int elf_vfs_read_exact(vfs_file_t* file, uint32_t offset, void* buf, uint32_t size)
+{
+    if (elf_vfs_seek(file, offset) != 0)
+        return -1;
+
+    int rd = vfs_read(file, (uint8_t*)buf, size);
+    return (rd >= 0 && (uint32_t)rd == size) ? 0 : -1;
+}
+
+static int elf_vfs_read_exact_path(const char* path, uint32_t offset, void* buf, uint32_t size)
+{
+    vfs_file_t file;
+    if (vfs_open(path, VFS_RDONLY, &file) != 0)
+        return -1;
+
+    int rc = elf_vfs_read_exact(&file, offset, buf, size);
+    vfs_close(&file);
+    return rc;
+}
+
+static uint64_t elf_runtime_addr_for_offset(Elf64_Phdr* headers, uint16_t phnum, uint64_t file_offset)
+{
+    for (uint16_t i = 0; i < phnum; ++i) {
+        Elf64_Phdr* ph = &headers[i];
+        if (ph->p_type != PT_LOAD || ph->p_filesz == 0)
+            continue;
+
+        uint64_t seg_start = ph->p_offset;
+        uint64_t seg_end = ph->p_offset + ph->p_filesz;
+        if (file_offset >= seg_start && file_offset < seg_end)
+            return ph->p_vaddr + (file_offset - ph->p_offset);
+    }
+
+    return 0;
+}
+
+static uint64_t elf_stage_phdrs_for_user(Elf64_Phdr* headers, uint64_t phdr_bytes)
+{
+    if (!headers || phdr_bytes == 0)
+        return 0;
+
+    uint64_t base = USER_PHDR_VADDR;
+    uint64_t aligned = (phdr_bytes + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+
+    for (uint64_t off = 0; off < aligned; off += PAGE_SIZE) {
+        uint64_t phys = allocate_page();
+        map_user_page(base + off, phys, USER_DATA_FLAGS);
+    }
+
+    memset((void*)base, 0, aligned);
+    memcpy((void*)base, headers, phdr_bytes);
+    return base;
+}
+
+static int elf_validate_header(const Elf64_Ehdr* header, uint64_t file_size)
+{
+    if (memcmp(&header->e_ident[EI_MAG0], ELFMAG, SELFMAG) != 0 || header->e_ident[EI_CLASS] != ELFCLASS64 ||
+        header->e_ident[EI_DATA] != ELFDATA2LSB || header->e_type != ET_EXEC ||
+        header->e_machine != EM_X86_64 || header->e_version != EV_CURRENT)
+    {
+        error("Not a valid ELF file to load!", __FILE__);
+        return -1;
+    }
+
+    if (header->e_phoff + ((uint64_t)header->e_phnum * header->e_phentsize) > file_size ||
+        header->e_phentsize != sizeof(Elf64_Phdr)) {
+        eprintf("elf: invalid program header table");
+        return -1;
+    }
+
+    return 0;
+}
 
 static int elf_map_program_header(Elf64_Phdr* ph, void* file_base, uint64_t file_size)
 {
@@ -52,7 +167,89 @@ static int elf_map_program_header(Elf64_Phdr* ph, void* file_base, uint64_t file
     return 0;
 }
 
-void* elf_load_from_memory(void* file_base_address, uint64_t file_size)
+static int elf_map_program_header_from_vfs(Elf64_Phdr* ph, const char* path, uint64_t file_size, uint16_t seg_index)
+{
+    if (ph->p_type != PT_LOAD)
+        return 0;
+
+    if (ph->p_offset + ph->p_filesz > file_size || ph->p_memsz < ph->p_filesz) {
+        eprintf("elf: invalid PT_LOAD bounds");
+        return -1;
+    }
+
+    uint64_t seg_start = ph->p_vaddr & ~0xFFFULL;
+    uint64_t seg_end = (ph->p_vaddr + ph->p_memsz + 0xFFFULL) & ~0xFFFULL;
+
+    uint64_t page_flags = PAGE_PRESENT | PAGE_USER;
+    if (ph->p_flags & PF_W)
+        page_flags |= PAGE_RW;
+    if (!(ph->p_flags & PF_X))
+        page_flags |= PAGE_NX;
+
+    for (uint64_t page = seg_start; page < seg_end; page += PAGE_SIZE) {
+        uint64_t phys = allocate_page();
+        map_user_page(page, phys, page_flags);
+    }
+
+    printf("elf: seg %u off=%x vaddr=%x filesz=%u memsz=%u",
+           seg_index,
+           ph->p_offset,
+           ph->p_vaddr,
+           ph->p_filesz,
+           ph->p_memsz);
+
+    if (ph->p_filesz != 0) {
+        vfs_file_t file;
+        if (vfs_open(path, VFS_RDONLY, &file) != 0) {
+            eprintf("elf: seg %u reopen failed", seg_index);
+            return -1;
+        }
+
+        if (elf_vfs_seek(&file, (uint32_t)ph->p_offset) != 0) {
+            vfs_close(&file);
+            eprintf("elf: seg %u seek failed", seg_index);
+            return -1;
+        }
+
+        uint8_t chunk[4096];
+        uint64_t copied = 0;
+        while (copied < ph->p_filesz) {
+            uint32_t remaining = (uint32_t)(ph->p_filesz - copied);
+            uint32_t want = remaining > sizeof(chunk) ? sizeof(chunk) : remaining;
+            int rd = vfs_read(&file, chunk, want);
+            if (rd < 0 || (uint32_t)rd != want) {
+                vfs_close(&file);
+                eprintf("elf: seg %u short read off=%x want=%u got=%d copied=%u/%u",
+                        seg_index,
+                        ph->p_offset + copied,
+                        want,
+                        rd,
+                        copied,
+                        ph->p_filesz);
+                return -1;
+            }
+
+            memcpy((void*)(ph->p_vaddr + copied), chunk, want);
+            copied += want;
+        }
+
+        vfs_close(&file);
+        if (copied != ph->p_filesz) {
+            eprintf("elf: seg %u copy mismatch copied=%u expected=%u",
+                    seg_index,
+                    copied,
+                    ph->p_filesz);
+            return -1;
+        }
+    }
+
+    if (ph->p_memsz > ph->p_filesz)
+        memset((uint8_t*)ph->p_vaddr + ph->p_filesz, 0, ph->p_memsz - ph->p_filesz);
+
+    return 0;
+}
+
+void* elf_load_from_memory_ex(void* file_base_address, uint64_t file_size, elf_image_info_t* info)
 {
     if (file_base_address == NULL || file_size < sizeof(Elf64_Ehdr))
         return NULL;
@@ -61,19 +258,8 @@ void* elf_load_from_memory(void* file_base_address, uint64_t file_size)
     Elf64_Ehdr header = {};
     memcpy(&header, file_ptr, sizeof(Elf64_Ehdr));
 
-    if (memcmp(&header.e_ident[EI_MAG0], ELFMAG, SELFMAG) != 0 || header.e_ident[EI_CLASS] != ELFCLASS64 ||
-        header.e_ident[EI_DATA] != ELFDATA2LSB || header.e_type != ET_EXEC ||
-        header.e_machine != EM_X86_64 || header.e_version != EV_CURRENT)
-    {
-        error("Not a valid ELF file to load!", __FILE__);
-        return NULL;
-    }
-
-    if (header.e_phoff + ((uint64_t)header.e_phnum * header.e_phentsize) > file_size ||
-        header.e_phentsize != sizeof(Elf64_Phdr)) {
-        eprintf("elf: invalid program header table");
+    if (elf_validate_header(&header, file_size) != 0)
         return NULL;
-    }
 
     // printf("Parsing ELF64 file with %d PHDRs\n", header.e_phnum);
 
@@ -86,10 +272,25 @@ void* elf_load_from_memory(void* file_base_address, uint64_t file_size)
         }
     }
 
+    if (info) {
+        info->entry = header.e_entry;
+        info->phdr_addr = elf_stage_phdrs_for_user(program_headers_start,
+                                                   (uint64_t)header.e_phnum * header.e_phentsize);
+        if (info->phdr_addr == 0)
+            info->phdr_addr = elf_runtime_addr_for_offset(program_headers_start, header.e_phnum, header.e_phoff);
+        info->phentsize = header.e_phentsize;
+        info->phnum = header.e_phnum;
+    }
+
     return (void*)header.e_entry;
 }
 
-void* elf_load_from_vfs(const char* path)
+void* elf_load_from_memory(void* file_base_address, uint64_t file_size)
+{
+    return elf_load_from_memory_ex(file_base_address, file_size, NULL);
+}
+
+void* elf_load_from_vfs_ex(const char* path, elf_image_info_t* info)
 {
     if (!path)
         return NULL;
@@ -121,21 +322,57 @@ void* elf_load_from_vfs(const char* path)
         return NULL;
     }
 
-    void* image = kmalloc(size);
-    if (!image) {
+    Elf64_Ehdr header = {};
+    if (elf_vfs_read_exact(&file, 0, &header, sizeof(header)) != 0) {
+        eprintf("elf: failed to read header");
         vfs_close(&file);
         return NULL;
     }
 
-    int rd = vfs_read(&file, (uint8_t*)image, size);
-    vfs_close(&file);
+    if (elf_validate_header(&header, size) != 0) {
+        vfs_close(&file);
+        return NULL;
+    }
 
-    if (rd < 0 || (uint32_t)rd != size) {
-        kfree(image);
+    uint64_t phdr_bytes = (uint64_t)header.e_phnum * header.e_phentsize;
+    Elf64_Phdr* program_headers = kmalloc(phdr_bytes);
+    if (!program_headers) {
+        eprintf("elf: failed to allocate program header table");
+        vfs_close(&file);
+        return NULL;
+    }
+
+    if (elf_vfs_read_exact_path(path, (uint32_t)header.e_phoff, program_headers, (uint32_t)phdr_bytes) != 0) {
+        eprintf("elf: failed to read program headers");
+        kfree(program_headers);
+        vfs_close(&file);
         return NULL;
     }
 
-    void* entry = elf_load_from_memory(image, size);
-    kfree(image);
+    vfs_close(&file);
+
+    for (uint16_t i = 0; i < header.e_phnum; ++i) {
+        if (elf_map_program_header_from_vfs(&program_headers[i], path, size, i) != 0) {
+            kfree(program_headers);
+            return NULL;
+        }
+    }
+
+    if (info) {
+        info->entry = header.e_entry;
+        info->phdr_addr = elf_stage_phdrs_for_user(program_headers, phdr_bytes);
+        if (info->phdr_addr == 0)
+            info->phdr_addr = elf_runtime_addr_for_offset(program_headers, header.e_phnum, header.e_phoff);
+        info->phentsize = header.e_phentsize;
+        info->phnum = header.e_phnum;
+    }
+
+    kfree(program_headers);
+    void* entry = (void*)header.e_entry;
     return entry;
 }
+
+void* elf_load_from_vfs(const char* path)
+{
+    return elf_load_from_vfs_ex(path, NULL);
+}