summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.gitignore2
-rwxr-xr-xloader.c298
2 files changed, 300 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..079dcb8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+# testing samples
+Library*
diff --git a/loader.c b/loader.c
new file mode 100755
index 0000000..f2d54bf
--- /dev/null
+++ b/loader.c
@@ -0,0 +1,298 @@
+#!/usr/bin/env -S tcc -run
+
+#include <elf.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+// ELF is defined assuming 8-bit bytes
+#include <stdint.h>
+
+int main64(int fd, char endianness);
+
+int main(void) {
+ int fd = open("./Library.so", O_RDONLY);
+
+ unsigned char e_ident[EI_NIDENT];
+ if (read(fd, e_ident, EI_NIDENT) != EI_NIDENT)
+ return 1;
+
+ if (e_ident[EI_MAG0] != ELFMAG0 || e_ident[EI_MAG1] != ELFMAG1 || e_ident[EI_MAG2] != ELFMAG2 || e_ident[EI_MAG3] != ELFMAG3) {
+ puts("This doesn't seem to be an ELF file.");
+ return 1;
+ }
+
+ char endianness;
+ switch (e_ident[EI_DATA]) {
+ case ELFDATA2LSB:
+ endianness = 0;
+ break;
+ case ELFDATA2MSB:
+ endianness = 1;
+ break;
+ default:
+ puts("Your ELF file seems invalid.");
+ return 1;
+ }
+
+ switch (e_ident[EI_CLASS]) {
+ case ELFCLASS32:
+ puts("32-bit ELF loading not yet implemented.");
+ return 1;
+ case ELFCLASS64:
+ return main64(fd, endianness);
+ default:
+ puts("Your ELF file seems invalid.");
+ return 1;
+ }
+
+ return 2;
+}
+
+void * real_addr64(Elf64_Phdr *program_headers, Elf64_Addr address) {
+ return 0;
+}
+
+int main64(int fd, char endianness) {
+ Elf64_Ehdr elf_header;
+ if (pread(fd, &elf_header, sizeof(elf_header), 0) != sizeof(elf_header))
+ return 1;
+
+ if (elf_header.e_type != ET_DYN) {
+ puts("This is not a shared library.");
+ return 1;
+ }
+
+ if (elf_header.e_version != EV_CURRENT) {
+ puts("Well... at the very least, the naming here is poor.");
+ return 1;
+ }
+
+
+
+ Elf64_Shdr *section_headers;
+ section_headers = calloc(sizeof(*section_headers), elf_header.e_shnum);
+ if (!section_headers && elf_header.e_shnum != 0) {
+ puts("OOM.");
+ return 1;
+ }
+
+ if (elf_header.e_shentsize != sizeof(*section_headers)) {
+ puts("Your ELF file seems wrong.");
+ return 1;
+ }
+
+ size_t shnum = elf_header.e_shnum;
+ for (size_t i = 0; i < shnum; i++) {
+ size_t remaining = elf_header.e_shentsize;
+ size_t got = 0;
+ ssize_t res;
+ do {
+ res = pread(fd, ((char*)&(section_headers[i]))+got, remaining, elf_header.e_shoff + (elf_header.e_shentsize * i) + got);
+ if (res < 0) {
+ puts("Failed to read ELF section headers");
+ return 1;
+ }
+ got += res;
+ remaining -= res;
+ } while (remaining != 0);
+ }
+
+
+ size_t shstrtab_index = elf_header.e_shstrndx;
+ if (shstrtab_index == 0xFFFF) {
+ if (shnum > 0)
+ shstrtab_index = section_headers[0].sh_link;
+ else
+ shstrtab_index = SHN_UNDEF;
+ }
+ if (shstrtab_index == SHN_UNDEF || shstrtab_index >= shnum) {
+ puts("Failed to find .shstrtab");
+ return 1;
+ }
+
+ char *shstrtab = malloc(section_headers[shstrtab_index].sh_size);
+ if (!shstrtab) {
+ puts("OOM.");
+ return 1;
+ }
+ {
+ size_t remaining = section_headers[shstrtab_index].sh_size;
+ size_t got = 0;
+ ssize_t res;
+ do {
+ res = pread(fd, shstrtab + got, remaining, section_headers[shstrtab_index].sh_offset + got);
+ if (res < 0) {
+ puts("Failed to real shstrtab");
+ return 1;
+ }
+ got += res;
+ remaining -= res;
+ } while (remaining != 0);
+ }
+ printf("shstrtab size: %d\n", section_headers[shstrtab_index].sh_size);
+
+
+
+ Elf64_Phdr *program_headers;
+ program_headers = calloc(sizeof(*program_headers), elf_header.e_phnum);
+ if (!program_headers && elf_header.e_phnum != 0) {
+ puts("OOM.");
+ return 1;
+ }
+
+ if (elf_header.e_phentsize != sizeof(*program_headers)) {
+ puts("Your ELF file seems wrong.");
+ return 1;
+ }
+
+ size_t phnum = elf_header.e_phnum;
+ if (phnum >= PN_XNUM) {
+ if (shnum == 0) {
+ puts("Your ELF file is broken.");
+ return 1;
+ }
+ }
+
+ for (size_t i = 0; i < phnum; i++) {
+ size_t remaining = elf_header.e_phentsize;
+ size_t got = 0;
+ ssize_t res;
+ do {
+ res = pread(fd, ((char*)&(program_headers[i]))+got, remaining, elf_header.e_phoff + (elf_header.e_phentsize * i) + got);
+ if (res < 0) {
+ puts("Failed to read ELF section headers");
+ return 1;
+ }
+ got += res;
+ remaining -= res;
+ } while (remaining != 0);
+
+ printf("loaded phent at %lu\n", elf_header.e_phoff + (elf_header.e_phentsize * i));
+ }
+
+
+
+ unsigned char __attribute__((__may_alias__)) **loaded_segments;
+ loaded_segments = malloc(phnum * sizeof(*loaded_segments));
+ if (!loaded_segments && phnum != 0) {
+ puts("OOM!");
+ return 1;
+ }
+
+ size_t dynamic_library_needed_entries = 0;
+
+ for (size_t i = 0; i < phnum; i++) {
+ switch (program_headers[i].p_type) {
+ case PT_DYNAMIC:
+ if (program_headers[i].p_memsz % sizeof(Elf64_Dyn) != 0) {
+ puts("Broken PT_DYNAMIC section");
+ return 1;
+ }
+ case PT_LOAD:
+ size_t;
+ size_t pre_padding;
+ if (program_headers[i].p_align == 0)
+ pre_padding = 0;
+ else
+ pre_padding = program_headers[i].p_offset % program_headers[i].p_align;
+
+ loaded_segments[i] = mmap(0, pre_padding + program_headers[i].p_memsz, PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (!loaded_segments[i]) {
+ puts("OOM!");
+ return 1;
+ }
+ printf("Mapped new segment of %lu length at %p\n", pre_padding + program_headers[i].p_memsz, loaded_segments[i]);
+ size_t offset = 0;
+ size_t remaining = program_headers[i].p_filesz;
+ do {
+ ssize_t res = pread(fd, &(loaded_segments[i][offset + pre_padding]), remaining, program_headers[i].p_offset + offset);
+ if (res < 0) {
+ puts("pread failed");
+ printf("errno: %d\n", errno);
+ return 1;
+ }
+ offset += res;
+ remaining -= res;
+ } while (remaining != 0);
+
+ if (program_headers[i].p_type == PT_DYNAMIC) {
+ Elf64_Dyn __attribute__((__may_alias__)) *dynamic = (Elf64_Dyn*)loaded_segments[i];
+ for (size_t x = 0; x < program_headers[i].p_memsz / sizeof(*dynamic); x++) {
+ if (dynamic[x].d_tag == DT_NEEDED) {
+ dynamic_library_needed_entries++;
+ }
+ }
+ }
+
+ break;
+ default:
+ break;
+ }
+ }
+
+ char *dynstr;
+ char dynstr_found = 0;
+
+ Elf64_Dyn *dynsym;
+ char dynsym_found = 0;
+
+ for (size_t i = 0; i < shnum; i++) {
+ switch (section_headers[i].sh_type) {
+ case SHT_STRTAB:
+ if (strcmp(&(shstrtab[section_headers[i].sh_name]), ".dynstr") == 0) {
+ if (dynstr_found) {
+ puts("Extra .dynstr found!");
+ return 1;
+ }
+ dynstr_found = 1;
+ // TODO: Translate offset to actual address
+ printf(".dynstr: %p\n", section_headers[i].sh_addr);
+ }
+ printf("STRTAB: %p\n", section_headers[i].sh_addr);
+ break;
+ case SHT_RELA:
+ printf("RELA: %p\n", section_headers[i].sh_addr);
+ break;
+ case SHT_DYNSYM:
+ if (dynsym_found) {
+ puts("Extra DYNSYM found!");
+ return 1;
+ }
+ dynsym_found = 1;
+ // TODO: Translate offset to actual address
+ printf("DYNSYM: %p\n", section_headers[i].sh_addr);
+ break;
+ default:
+ break;
+ }
+ }
+ if (!dynstr_found) {
+ puts("No .dynstr found!");
+ return 1;
+ }
+
+ printf("Got %lu dynamic libraries required\n", dynamic_library_needed_entries);
+
+ void ** dls;
+ dls = malloc(dynamic_library_needed_entries * sizeof(*dls));
+
+ {
+ size_t dls_done = 0;
+ for (size_t i = 0; i < phnum; i++) {
+ if (program_headers[i].p_type == PT_DYNAMIC) {
+ Elf64_Dyn __attribute__((__may_alias__)) *dynamic = (Elf64_Dyn*)loaded_segments[i];
+ for (size_t x = 0; x < program_headers[i].p_memsz / sizeof(*dynamic); x++) {
+ if (dynamic[x].d_tag == DT_NEEDED) {
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-21 08:39:36 +0000