path: root/loader.c

#!/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;
}