elf-parser.c

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <elf.h>

#include "elf-parser.h"

#define sanitize(x, y) do { \
	if (x < y) { \
		fprintf(stderr, "error: %zu avaliable %zu required\n", x, y); \
		exit(1); \
	} \
} while(0)

void *mapfile(const char *filename, size_t *len)
{
	void *ret = MAP_FAILED;
	struct stat st;
	int fd;

	if ((fd = open(filename, O_RDONLY)) == -1)
		goto end;

	if (fstat(fd, &st) == -1)
		goto end;

	ret = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
	*len = (size_t)st.st_size;

 end:
	if (fd != -1)
		close(fd);

	return ret;
}

section_t *getsectionbyname(elf_t * elf, const char *name)
{
	section_t *ret = NULL;
	char *strings;
	size_t len;

	uint32_t sh_name;
	uint16_t shstrndx;
	size_t i, slen;

	/* get section string index */
	shstrndx = elf->header->e_shstrndx;
	if (shstrndx == SHN_UNDEF || shstrndx >= elf->nsections) {
		goto end;
	}

	strings = elf->sections[shstrndx].data;
	len = elf->sections[shstrndx].len;

	slen = strlen(name) + 1;

	for (i = 0; i < elf->nsections; i++) {
		sh_name = elf->sections[i].header->sh_name;
		if (sh_name == 0)
			continue;

		if (sh_name >= len || len - sh_name < slen)
			continue;

		if (memcmp(strings + sh_name, name, slen) == 0x0) {
			ret = elf->sections + i;
			break;
		}
	}

 end:
	return ret;
}

int getrelabyname(elf_t * elf, rela_t * rel, char *section_name,
		  const char *name)
{
	section_t *dynstr, *dynsym, *sec;
	Elf64_Sym *symbols;
	Elf64_Rela *rela;
	size_t i, j;

	int ret = 1;

	rel->rel = NULL;
	rel->sym = NULL;

	if ((sec = getsectionbyname(elf, section_name)) == NULL)
		goto end;

	dynstr = getsectionbyname(elf, ".dynstr");
	if (dynstr == NULL)
		goto end;

	dynsym = getsectionbyname(elf, ".dynsym");
	if (dynsym == NULL)
		goto end;

	rela = sec->data;
	symbols = dynsym->data;

	size_t nsym = dynsym->len / sizeof(Elf64_Sym);
	size_t nplt = sec->len / sizeof(Elf64_Rela);

	size_t slen = strlen(name) + 1;

	for (i = 0; i < nplt; i++) {
		j = ELF64_R_SYM(rela[i].r_info);

		/* check overflow */
		if (j >= nsym)
			continue;

		if (symbols[j].st_name == 0)
			continue;

		if (symbols[j].st_name >= dynstr->len ||
		    dynstr->len - symbols[j].st_name < slen) {
			continue;
		}

		if (memcmp(dynstr->data + symbols[j].st_name, name, slen) ==
		    0x0) {
			rel->rel = rela + i;
			rel->sym = symbols + j;
			ret = 0;
			break;
		}
	}

 end:
	return ret;
}

Elf64_Sym *dynsym_name_lookup(elf_t * elf, const char *name)
{
	section_t *strtab, *symtab;
	Elf64_Sym *ret = NULL, *symbols;

	size_t slen, i;

	strtab = getsectionbyname(elf, ".dynstr");
	symtab = getsectionbyname(elf, ".dynsym");

	if (!strtab || !symtab) {
		goto end;
	}

	slen = strlen(name) + 1;

	symbols = symtab->data;
	for (i = 0; i < symtab->len / sizeof(Elf64_Sym); i++) {
		if (symbols[i].st_name == 0)
			continue;

		if (symbols[i].st_name >= strtab->len ||
		    strtab->len - symbols[i].st_name < slen) {
			continue;
		}

		if (memcmp(strtab->data + symbols[i].st_name, name, slen) ==
		    0x0) {
			ret = symbols + i;
			break;
		}
	}

 end:
	return ret;
}

void elf_parser(elf_t * elf, const char *filename)
{
	Elf64_Ehdr *header;
	Elf64_Phdr *phdr;
	Elf64_Shdr *shdr;

	void *ptr;
	size_t i, len;

	memset(elf, 0x0, sizeof(elf_t));

	ptr = mapfile(filename, &len);
	if (ptr == MAP_FAILED) {
		perror("map_file() failed");
		exit(1);
	}

	/* sanity check */
	sanitize(len, sizeof(Elf64_Ehdr));

	elf->nbytes = len;
	elf->header = header = ptr;

	elf->nsegments = header->e_phnum;
	if (elf->nsegments) {
		elf->segments = malloc(elf->nsegments * sizeof(segment_t));
		if (elf->segments == NULL) {
			perror("malloc()");
			exit(1);
		}
	}

	for (i = 0; i < header->e_phnum; i++) {
		/* +1 for ensure that contains the size for the element */
		sanitize(len, header->e_phoff + sizeof(Elf64_Phdr) * (i + 1));

		phdr = ptr + header->e_phoff + sizeof(Elf64_Phdr) * i;

		sanitize(len, phdr->p_offset + phdr->p_filesz);

		elf->segments[i].header = phdr;
		elf->segments[i].len = phdr->p_filesz;
		elf->segments[i].data =
		    (phdr->p_filesz) ? ptr + phdr->p_offset : NULL;
	}

	elf->nsections = header->e_shnum;
	if (elf->nsections) {
		elf->sections = malloc(elf->nsections * sizeof(section_t));
		if (elf->sections == NULL) {
			perror("malloc()");
			exit(1);
		}
	}

	for (i = 0; i < header->e_shnum; i++) {
		sanitize(len, header->e_shoff + sizeof(Elf64_Shdr) * (i + 1));

		shdr = ptr + header->e_shoff + sizeof(Elf64_Shdr) * i;

		if (shdr->sh_type == SHT_NOBITS) {
			elf->sections[i].data = NULL;
			elf->sections[i].len = 0;
		} else {
			sanitize(len, shdr->sh_offset + shdr->sh_size);
			elf->sections[i].data = ptr + shdr->sh_offset;
			elf->sections[i].len = shdr->sh_size;
		}

		elf->sections[i].header = shdr;
	}
}

void free_elf(elf_t * elf)
{
	free(elf->segments);
	free(elf->sections);
	munmap(elf->header, elf->nbytes);
}