diff options
| -rw-r--r-- | elfreader.c | 727 | ||||
| -rw-r--r-- | elfreader.h | 158 |
2 files changed, 885 insertions, 0 deletions
diff --git a/elfreader.c b/elfreader.c new file mode 100644 index 0000000..b514da3 --- /dev/null +++ b/elfreader.c @@ -0,0 +1,727 @@ +#include "elfreader.h" + + +/******************************************************************************/ +Elf_Ident* elf_ident( FILE *f ) +{ + Elf_Ident *ret = NULL; + size_t read_bytes = 0; + + if ( f == NULL ) + { + return NULL; + } + + ret = malloc( sizeof(Elf_Ident) ); + if ( ret == NULL ) + { + return NULL; + } + + fseek( f, 0, SEEK_SET ); + read_bytes = fread( ret->ident, 1, EI_NIDENT, f ); + if ( read_bytes != EI_NIDENT ) + { + free( ret ); + return NULL; + } + + return ret; +} + + +/******************************************************************************/ +int ident_check( Elf_Ident *ident ) +{ + int ret=0; + /* check if its elf file */ + if ( (ident->ident[EI_MAG0] != ELFMAG0) || + (ident->ident[EI_MAG1] != ELFMAG1) || + (ident->ident[EI_MAG2] != ELFMAG2) || + (ident->ident[EI_MAG3] != ELFMAG3) ) + { + printf("Elf header magic is wrong\n"); + ret = -1; + } + + /* check file class */ + switch ( ident->ident[EI_CLASS] ) + { + case ELFCLASS32: + case ELFCLASS64: + break; + default: + printf("EI_CLASS not supported\n"); + return -1; + } + + return ret; +} + + +/******************************************************************************/ +void ident_info( Elf_Ident *ident ) +{ + printf("ELF IDENT:\n"); + printf("ELFCLASS :0x%02x\n", ident->ident[EI_CLASS]); + printf("ELFDATA :0x%02x\n", ident->ident[EI_DATA]); +} + + +/******************************************************************************/ +int elf_ehdr_32( Elf_Ehdr *ehdr, Elf32_Ehdr *ehdr32, int byteorder ) +{ + if ( byteorder == ELF_MLSB ) + { + /* working with MIPS on INTEL */ + elf_ehdr32_bele( ehdr32 ); + /* input was in MSB output now in LSB */ + } else if ( (byteorder == ELF_MMSB) || (byteorder == ELF_LLSB) ) + { + /* no need to do something */ + } else + { + /* is someone compile stuff on MIPS for Intel or so? */ + ERROR("Not yet implemented\n"); + /* Should be ok for now */ + exit(0); + } + + ehdr->e_type = ehdr32->e_type; + ehdr->e_machine = ehdr32->e_machine; + ehdr->e_version = ehdr32->e_version; + ehdr->e_entry = ehdr32->e_entry; + ehdr->e_phoff = ehdr32->e_phoff; + ehdr->e_shoff = ehdr32->e_shoff; + ehdr->e_flags = ehdr32->e_flags; + ehdr->e_ehsize = ehdr32->e_ehsize; + ehdr->e_phentsize = ehdr32->e_phentsize; + ehdr->e_phnum = ehdr32->e_phnum; + ehdr->e_shentsize = ehdr32->e_shentsize; + ehdr->e_shnum = ehdr32->e_shnum; + ehdr->e_shstrndx = ehdr32->e_shstrndx; + + return 0; +} + + +/******************************************************************************/ +int elf_ehdr_64( Elf_Ehdr *ehdr, Elf64_Ehdr *ehdr64, int byteorder ) +{ + ENL(); + + ehdr->e_type = ehdr64->e_type; + ehdr->e_machine = ehdr64->e_machine; + ehdr->e_version = ehdr64->e_version; + ehdr->e_entry = ehdr64->e_entry; + ehdr->e_phoff = ehdr64->e_phoff; + ehdr->e_shoff = ehdr64->e_shoff; + ehdr->e_flags = ehdr64->e_flags; + ehdr->e_ehsize = ehdr64->e_ehsize; + ehdr->e_phentsize = ehdr64->e_phentsize; + ehdr->e_phnum = ehdr64->e_phnum; + ehdr->e_shentsize = ehdr64->e_shentsize; + ehdr->e_shnum = ehdr64->e_shnum; + ehdr->e_shstrndx = ehdr64->e_shstrndx; + + return 0; +} + + +/******************************************************************************/ +int elf_32_ehdr( Elf32_Ehdr *ehdr32, Elf_Ehdr *ehdr ) +{ + + ehdr32->e_type = ehdr->e_type; + ehdr32->e_machine = ehdr->e_machine; + ehdr32->e_version = ehdr->e_version; + ehdr32->e_entry = ehdr->e_entry; + ehdr32->e_phoff = ehdr->e_phoff; + ehdr32->e_shoff = ehdr->e_shoff; + ehdr32->e_flags = ehdr->e_flags; + ehdr32->e_ehsize = ehdr->e_ehsize; + ehdr32->e_phentsize = ehdr->e_phentsize; + ehdr32->e_phnum = ehdr->e_phnum; + ehdr32->e_shentsize = ehdr->e_shentsize; + ehdr32->e_shnum = ehdr->e_shnum; + ehdr32->e_shstrndx = ehdr->e_shstrndx; + + if ( ehdr->byteorder == ELF_MLSB ) + { + elf_ehdr32_bele( ehdr32 ); + } else if ( (ehdr->byteorder == ELF_MMSB) || + ( ehdr->byteorder == ELF_LLSB)) + { + /* No need to do anything */ + } else + { + ERROR("Note implemtented\n"); + } + + + return 0; +} + + +/******************************************************************************/ +int elf_64_ehdr( Elf64_Ehdr *ehdr64, Elf_Ehdr *ehdr ) +{ + ehdr64->e_type = ehdr->e_type; + ehdr64->e_machine = ehdr->e_machine; + ehdr64->e_version = ehdr->e_version; + ehdr64->e_entry = ehdr->e_entry; + ehdr64->e_phoff = ehdr->e_phoff; + ehdr64->e_shoff = ehdr->e_shoff; + ehdr64->e_flags = ehdr->e_flags; + ehdr64->e_ehsize = ehdr->e_ehsize; + ehdr64->e_phentsize = ehdr->e_phentsize; + ehdr64->e_phnum = ehdr->e_phnum; + ehdr64->e_shentsize = ehdr->e_shentsize; + ehdr64->e_shnum = ehdr->e_shnum; + ehdr64->e_shstrndx = ehdr->e_shstrndx; + + return 0; +} + +/******************************************************************************/ +int elf_ehdr32_bele( Elf32_Ehdr *ehdr32 ) +{ + int ret = 0; + + ehdr32->e_type = SWP16(ehdr32->e_type); + ehdr32->e_machine = SWP16(ehdr32->e_machine); + ehdr32->e_version = SWP32(ehdr32->e_version); + ehdr32->e_entry = SWP32(ehdr32->e_entry); + ehdr32->e_phoff = SWP32(ehdr32->e_phoff ); + ehdr32->e_shoff = SWP32(ehdr32->e_shoff); + ehdr32->e_flags = SWP32(ehdr32->e_flags); + ehdr32->e_ehsize = SWP16(ehdr32->e_ehsize); + ehdr32->e_phentsize = SWP16(ehdr32->e_phentsize); + ehdr32->e_phnum = SWP16(ehdr32->e_phnum); + ehdr32->e_shentsize = SWP16(ehdr32->e_shentsize); + ehdr32->e_shnum = SWP16(ehdr32->e_shnum); + ehdr32->e_shstrndx = SWP16(ehdr32->e_shstrndx); + + return ret; +} + +/******************************************************************************/ +int elf_ehdr32_lebe( Elf32_Ehdr *ehdr32 ) +{ + int ret = 0; + uint16_t u16; + + PNL(); + /* + ehdr32->e_type = SWP16(ehdr32->e_type); + ehdr32->e_machine = SWP16(ehdr32->e_machine); + ehdr32->e_version = SWP32(ehdr32->e_version); + ehdr32->e_entry = SWP32(ehdr32->e_entry); + ehdr32->e_phoff = SWP32(ehdr32->e_phoff ); + ehdr32->e_shoff = SWP32(ehdr32->e_shoff); + ehdr32->e_flags = SWP32(ehdr32->e_flags); + ehdr32->e_ehsize = SWP16(ehdr32->e_ehsize); + ehdr32->e_phentsize = SWP16(ehdr32->e_phentsize); + ehdr32->e_phnum = SWP16(ehdr32->e_phnum); + ehdr32->e_shentsize = SWP16(ehdr32->e_shentsize); + ehdr32->e_shnum = SWP16(ehdr32->e_shnum); + ehdr32->e_shstrndx = SWP16(ehdr32->e_shstrndx); + */ + return ret; +} + + +/******************************************************************************/ +int elf_ehdr2mem( Elf_Ident *ident, Elf_Ehdr *ehdr, uint8_t *buf, int size ) +{ + int ret = 0; + + int i,j; + uint8_t *head = NULL; + int sz_head = -1; + + if ( ehdr->type == ELF_TYPE_32 ) + { + sz_head = sizeof(Elf32_Ehdr); + head = malloc( sz_head ); + elf_32_ehdr( (Elf32_Ehdr *)head, ehdr ); + } else if ( ehdr->type == ELF_TYPE_64 ) + { + sz_head = sizeof(Elf64_Ehdr); + head = malloc( sz_head ); + elf_64_ehdr( (Elf64_Ehdr *)head, ehdr ); + } else + { + printf("Unknown ELF header type\n"); + return -1; + } + + memcpy( head, ident->ident, EI_NIDENT); + + for (i=0,j=0; (i<size)&&(j<sz_head); i++,j++ ) + { + buf[i] = head[j]; + } + + return ret; +} + + +/******************************************************************************/ +Elf_Ehdr* elf_header( FILE *f, Elf_Ident *ident, int sysorder ) +{ + Elf_Ehdr *ret = NULL; + uint8_t *buf = NULL; + int sz_buf = -1; + int class = ELF_TYPE_UNKNOWN; + int byteorder = ELF_ENONE; + + + /* check elf header class */ + switch ( ident->ident[EI_CLASS] ) + { + case ELFCLASS32: + class = ELF_TYPE_32; + sz_buf = sizeof(Elf32_Ehdr); + break; + case ELFCLASS64: + class = ELF_TYPE_64; + sz_buf = sizeof(Elf64_Ehdr); + break; + default: + printf("Unknown ELFCLASS class\n"); + } + + /* check file endianess */ + switch ( ident->ident[EI_DATA] ) + { + case ELFDATA2LSB: + if ( sysorder == __ORDER_LITTLE_ENDIAN__ ) + { + byteorder = ELF_LLSB; + } else if ( sysorder == __ORDER_BIG_ENDIAN__ ) + { + byteorder = ELF_LMSB; + } else + { + ENL(); + } + break; + case ELFDATA2MSB: + if ( sysorder == __ORDER_LITTLE_ENDIAN__ ) + { + byteorder = ELF_MLSB; + } else if ( sysorder == __ORDER_BIG_ENDIAN__ ) + { + byteorder = ELF_MMSB; + } else + { + ENL(); + } + break; + case ELFDATANONE: + default: + printf("Unknown\n"); + } + + /* create buffer for elf header */ + buf = malloc( sz_buf ); + if ( buf == NULL ) + { + printf("alloc NULL\n"); + return NULL; + } + fseek( f, 0, SEEK_SET ); + if ( fread( buf, 1, sz_buf, f) != sz_buf ) + { + free( buf ); + printf("Cannot read ELF header\n"); + return NULL; + } + + //dont chk mmalc =P + ret = malloc( sizeof(Elf_Ehdr) ); + if ( class == ELF_TYPE_32 ) + { + PNL(); + elf_ehdr_32( ret, (Elf32_Ehdr *)buf, byteorder ); + ret->type = ELF_TYPE_32; + ret->byteorder = byteorder; + } else if ( class == ELF_TYPE_64 ) + { + PNL(); + elf_ehdr_64( ret, (Elf64_Ehdr *)buf, byteorder ); + ret->type = ELF_TYPE_64; + ret->byteorder = byteorder; + } else + { + printf("Unknown elf class\n"); + return NULL; + } + + return ret; +} + +/******************************************************************************/ +void header_info( Elf_Ehdr *ehdr ) +{ + printf("ELF EXCUTABLE HEADER\n"); + printf("TYPE : 0x%04x\n", ehdr->e_type ); + printf("ENTRY : 0x%08x\n", ehdr->e_entry ); + printf("PHOFF : 0x%04x\n", ehdr->e_phoff ); + printf("SHOFF : 0x%04x\n", ehdr->e_shoff ); + printf("EHSIZE : 0x%04x(%u bytes)\n", ehdr->e_ehsize, ehdr->e_ehsize ); + printf("PHENTSIZE : 0x%04x(%u bytes)\n", ehdr->e_phentsize, ehdr->e_phentsize ); + printf("PHNUM : 0x%04x(%u bytes)\n", ehdr->e_phnum, ehdr->e_phnum ); + printf("SHENTSIZE : 0x%04x(%u bytes)\n", ehdr->e_shentsize, ehdr->e_shentsize ); + printf("SHNUM : 0x%04x(%u bytes)\n", ehdr->e_shnum, ehdr->e_shnum ); +} + +/******************************************************************************/ +int elf_phdr_32( Elf_Phdr *phdr, Elf32_Phdr *phdr32 ) +{ + return -1; +} + + +/******************************************************************************/ +int elf_phdr_64( Elf_Phdr *phdr, Elf64_Phdr *phdr64 ) +{ + return -1; +} + + +/******************************************************************************/ +int elf_32_phdr( Elf32_Phdr *phdr32, Elf_Phdr *phdr ) +{ + return -1; +} + + +/******************************************************************************/ +int elf_64_phdr( Elf64_Phdr *phdr64, Elf_Phdr *phdr ) +{ + return -1; +} + + +/******************************************************************************/ +Elf_Phdr* elf_phdr( FILE *f, Elf_Ehdr *ehdr ) +{ + Elf_Phdr *ret = NULL; + + return ret; +} + + +/******************************************************************************/ +int elf_shdr_32( Elf_Shdr *shdr, Elf32_Shdr *shdr32 ) +{ + shdr->sh_name = shdr32->sh_name; + shdr->sh_type = shdr32->sh_type; + shdr->sh_flags = shdr32->sh_flags; + shdr->sh_addr = shdr32->sh_addr; + shdr->sh_offset = shdr32->sh_offset; + shdr->sh_size = shdr32->sh_size; + shdr->sh_link = shdr32->sh_link; + shdr->sh_info = shdr32->sh_info; + shdr->sh_addralign = shdr32->sh_addralign; + shdr->sh_entsize = shdr32->sh_entsize; + + return 0; +} + + +/******************************************************************************/ +int elf_shdr_64( Elf_Shdr *shdr, Elf64_Shdr *shdr64 ) +{ + shdr->sh_name = shdr64->sh_name; + shdr->sh_type = shdr64->sh_type; + shdr->sh_flags = shdr64->sh_flags; + shdr->sh_addr = shdr64->sh_addr; + shdr->sh_offset = shdr64->sh_offset; + shdr->sh_size = shdr64->sh_size; + shdr->sh_link = shdr64->sh_link; + shdr->sh_info = shdr64->sh_info; + shdr->sh_addralign = shdr64->sh_addralign; + shdr->sh_entsize = shdr64->sh_entsize; + + return 0; +} + + +/******************************************************************************/ +int elf_32_shdr( Elf32_Shdr *shdr32, Elf_Shdr *shdr ) +{ + shdr32->sh_name = shdr->sh_name; + shdr32->sh_type = shdr->sh_type; + shdr32->sh_flags = shdr->sh_flags; + shdr32->sh_addr = shdr->sh_addr; + shdr32->sh_offset = shdr->sh_offset; + shdr32->sh_size = shdr->sh_size; + shdr32->sh_link = shdr->sh_link; + shdr32->sh_info = shdr->sh_info; + shdr32->sh_addralign = shdr->sh_addralign; + shdr32->sh_entsize = shdr->sh_entsize; + + return 0; +} + + +/******************************************************************************/ +int elf_64_shdr( Elf64_Shdr *shdr64, Elf_Shdr *shdr ) +{ + shdr64->sh_name = shdr->sh_name; + shdr64->sh_type = shdr->sh_type; + shdr64->sh_flags = shdr->sh_flags; + shdr64->sh_addr = shdr->sh_addr; + shdr64->sh_offset = shdr->sh_offset; + shdr64->sh_size = shdr->sh_size; + shdr64->sh_link = shdr->sh_link; + shdr64->sh_info = shdr->sh_info; + shdr64->sh_addralign = shdr->sh_addralign; + shdr64->sh_entsize = shdr->sh_entsize; + + return 0; +} + + +/******************************************************************************/ +int elf_shdr64_lebe( Elf64_Shdr *shdr64 ) +{ + int ret = 0; + + ERROR("Not implemented\n"); + + return ret; +} + + +/******************************************************************************/ +int elf_shdr32_lebe( Elf32_Shdr *shdr32 ) +{ + int ret = 0; + + shdr32->sh_name = SWP32(shdr32->sh_name); + shdr32->sh_type = SWP32(shdr32->sh_type); + shdr32->sh_flags = SWP32(shdr32->sh_flags); + shdr32->sh_addr = SWP32(shdr32->sh_addr); + shdr32->sh_offset = SWP32(shdr32->sh_offset); + shdr32->sh_size = SWP32(shdr32->sh_size); + shdr32->sh_link = SWP32(shdr32->sh_link); + shdr32->sh_info = SWP32(shdr32->sh_info); + shdr32->sh_addralign = SWP32(shdr32->sh_addralign); + shdr32->sh_entsize = SWP32(shdr32->sh_entsize); + + return ret; +} + + +/******************************************************************************/ +int elf_shdr2mem( Elf_Shdr *shdr, uint8_t *buf, int size, int offset ) +{ + int ret = 0; + + int i,j; + uint8_t *sec_head = NULL; + int sz_sec_head = -1; + + if ( shdr->type == ELF_TYPE_32 ) + { + sz_sec_head = sizeof(Elf32_Shdr); + sec_head = malloc(sz_sec_head); + elf_32_shdr( (Elf32_Shdr *)sec_head, shdr ); + if (shdr->byteorder == ELF_MLSB) + { + elf_shdr32_lebe( (Elf32_Shdr *)sec_head ); + } else if ( (shdr->byteorder == ELF_MMSB) || + (shdr->byteorder == ELF_LLSB) ) + { + + } else + { + ENL(); + } + } else if ( shdr->type == ELF_TYPE_64 ) + { + sz_sec_head = sizeof(Elf64_Shdr); + sec_head = malloc( sz_sec_head ); + elf_64_shdr( (Elf64_Shdr *)sec_head, shdr ); + if (shdr->byteorder == ELF_MLSB) + { + elf_shdr64_lebe( (Elf64_Shdr *)sec_head ); + } else if ( (shdr->byteorder == ELF_MMSB) || + (shdr->byteorder == ELF_LLSB) ) + { + + } else + { + ENL(); + } + } else + { + printf("Unknown type\n"); + return -1; + } + + for (i=offset,j=0; (j<sz_sec_head)&&(i<size); i++,j++) + { + buf[i] = sec_head[j]; + } + + return ret; +} + +/******************************************************************************/ +Elf_Shdr** elf_shdr( FILE *f, Elf_Ehdr *ehdr ) +{ + Elf_Shdr **ret = NULL; + Elf_Shdr *sh = NULL; + uint8_t **buf = NULL; + int sz_buf = -1; + int sh_num = -1; + int i = 0; + + /* Binary probably sstriped */ + if (ehdr->e_shoff == 0) + { + printf("No section headers\n"); + return NULL; + } + + + /* set section header size according of file class */ + switch ( ehdr->type ) + { + case ELF_TYPE_32: + sz_buf = sizeof(Elf32_Shdr); + break; + case ELF_TYPE_64: + sz_buf = sizeof(Elf64_Shdr); + break; + default: + printf("Unknown ELFCLASS\n"); + return NULL; + } + + /* Read/convert data accroding to elf class */ + sh_num = ehdr->e_shnum; + ret = malloc( sizeof(Elf_Shdr*)*(sh_num+1)); + memset( ret, 0, sizeof(Elf_Shdr*)*(sh_num+1) ); // last value should be null + + buf = malloc( sz_buf ); //no check =P + fseek( f, ehdr->e_shoff, SEEK_SET ); + for (i=0; i<sh_num; i++) + { + if ( fread( buf, 1, sz_buf, f ) != sz_buf ) + { + free( buf ); + printf("Cannot read section headers\n"); + return NULL; + } + + sh = malloc(sizeof(Elf_Shdr)); + memset( sh, 0, sizeof(Elf_Shdr)); + switch (ehdr->type) + { + case ELF_TYPE_32: + elf_shdr_32( sh, (Elf32_Shdr *)buf ); + break; + case ELF_TYPE_64: + elf_shdr_64( sh, (Elf64_Shdr *)buf ); + break; + default: + printf("Unknown class/ unknown state\n"); + return NULL; + } + + /* Remember section header type */ + sh->type = ehdr->type; + + ret[i] = sh; + } + + return ret; +} + + +void section_info( Elf_Shdr* shdr, Elf_Shdr_strtab *strtab ) +{ + printf("ELF SECTION HEADER:\n"); + if ( strtab != NULL ) + { + char *s = NULL; + s = strtab_name( strtab, shdr->sh_name); + if ( s != NULL ) + { + printf("NAME :%s\n", s); + //free( s ); + //s = NULL; + } + } + printf("TYPE : 0x%02x\n", shdr->sh_type); + printf("OFFSET: 0x%08x\n", shdr->sh_offset); + printf("SIZE : 0x%08x\n", shdr->sh_size); +} + +Elf_Shdr_strtab* strtab_search( FILE *f, Elf_Shdr **shdr ) +{ + Elf_Shdr_strtab *ret = NULL; + Elf_Shdr *iter = NULL; + + if ( shdr == NULL ) + { + return NULL; + } + + iter = shdr[0]; + while ( iter != NULL ) + { + if ( iter->sh_type == SHT_STRTAB ) + { + ret = malloc( sizeof(Elf_Shdr_strtab) ); + ret->offset = iter->sh_offset; + ret->sz_tab = iter->sh_size; + ret->strtab = malloc(ret->sz_tab); + fseek( f, ret->offset, SEEK_SET ); + if ( fread( ret->strtab, 1, ret->sz_tab, f ) != ret->sz_tab ) + { + free( ret->strtab ); + free( ret ); + printf("Cannot read strtab\n"); + return NULL; + } + return ret; + } + iter++; + } + + return ret; +} + +/* no need to free return value */ +unsigned char* strtab_name( Elf_Shdr_strtab *strtab, long offset ) +{ + unsigned char *ret = NULL; + + if ( strtab == NULL ) + { + return NULL; + } + + if ( offset > strtab->sz_tab ) + { + printf("strtab offset > then header size\n"); + return NULL; + } + + if ( offset < 0 ) + { + printf("strtab offset <0\n"); + return NULL; + } + + ret = &strtab->strtab[offset]; + + return ret; +}
\ No newline at end of file diff --git a/elfreader.h b/elfreader.h new file mode 100644 index 0000000..50e08a7 --- /dev/null +++ b/elfreader.h @@ -0,0 +1,158 @@ +#ifndef __ELFREADER_H +#define __ELFREADER_H + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <elf.h> + +#include "debug.h" +#include "assert.h" + +#define SWP16(X) (((X)&0x00FF)<<8)|(((X)&0xFF00)>>8) +#define SWP32(X) ((((X)&0x00FF)<<24)|(((X)&0xFF00)<<8)|(((X)&0xFF0000)>>8)|(((X)&0xFF000000)>>24)) + + +#define ELF_TYPE_UNKNOWN 0 +#define ELF_TYPE_32 1 +#define ELF_TYPE_64 2 + +/* if you add header on Intel(LE) on MIPS(be) arch + then you going to have troubles. Lets prepare for this troubles + */ +#define ELF_ENONE 0 +#define ELF_LLSB 1 +#define ELF_LMSB 2 +#define ELF_MLSB 3 +#define ELF_MMSB 4 + +typedef struct Elf_Ident { + unsigned char ident[EI_NIDENT]; +} Elf_Ident; + + +/* +++++++++++++++++++++++++++++++++++++ ++ Type + ELF32 + ELF64 + +++++++++++++++++++++++++++++++++++++ ++Half + uint16_t + uint16_t + ++Word + uint32_t + uint32_t + ++Sword + int32_t + int32_t + ++Xword + uint64_t + uint64_t + ++Sxword + int64_t + int64_t + ++Addr + uint32_t + uint64_t + ++Off + uint32_t + uint64_t + ++Section + uint16_t + uint16_t + ++Versym + uint16_t + uint16_t + +++++++++++++++++++++++++++++++++++++ +*/ + + +typedef struct Elf_Ehdr { + int type; /* to distinguish 32 or its 64 bits */ + int byteorder; + + /* generic elf header information */ + uint16_t e_type; + uint16_t e_machine; + uint32_t e_version; + uint64_t e_entry; + uint64_t e_phoff; + uint64_t e_shoff; + uint32_t e_flags; + uint16_t e_ehsize; + uint16_t e_phentsize; + uint16_t e_phnum; + uint16_t e_shentsize; + uint16_t e_shnum; + uint16_t e_shstrndx; +} Elf_Ehdr; + + +typedef struct Elf_Phdr { + int type; + uint32_t offset; /* Offset in file */ + int byteorder; + + /* generic progeam heaer information */ + uint32_t p_type; /* Segment type */ + uint64_t p_offset; /* Segment file offset */ + uint64_t p_vaddr; /* Segment virtual address */ + uint64_t p_paddr; /* Segment physical address */ + uint32_t p_filesz; /* Segment size in file */ + uint32_t p_memsz; /* Segment size in memory */ + uint32_t p_flags; /* Segment flags */ + uint32_t p_align; /* Segment alignment */ +} Elf_Phdr; + + +typedef struct Elf_Shdr { + int type; + uint32_t offset; /* Offset inside file */ + int byteorder; + + /* generic section header information */ + uint32_t sh_name; /* Section name (string tbl index) */ + uint32_t sh_type; /* Section type */ + uint64_t sh_flags; /* Section flags */ + uint64_t sh_addr; /* Section virtual addr at execution */ + uint64_t sh_offset; /* Section file offset */ + uint64_t sh_size; /* Section size in bytes */ + uint32_t sh_link; /* Link to another section */ + uint32_t sh_info; /* Additional section information */ + uint64_t sh_addralign; /* Section alignment */ + uint64_t sh_entsize; +} Elf_Shdr; + +typedef struct Elf_Shdr_strtab { + long offset; + int sz_tab; + uint8_t *strtab; +} Elf_Shdr_strtab; + +Elf_Ident* elf_ident( FILE *f ); +int ident_check( Elf_Ident *ident ); +void ident_info( Elf_Ident *ident ); + +/* +All headers can have different types or different offsets inside structure +should we write each function 2 times for 32/64? or just one generic function +and type convos in between? +*/ +/* ehdr := mapping ehdr32 */ +int elf_ehdr_32( Elf_Ehdr *ehdr, Elf32_Ehdr *ehdr32, int byteorder ); +/* ehdr := mapping ehdr64 */ +int elf_ehdr_64( Elf_Ehdr *ehdr, Elf64_Ehdr *ehdr64, int byteorder ); +/* ehdr32 := mapping ehdr */ +int elf_32_ehdr( Elf32_Ehdr *ehdr32, Elf_Ehdr *ehdr ); +/* ehdr64 := mapping ehdr */ +int elf_64_ehdr( Elf64_Ehdr *ehdr64, Elf_Ehdr *ehdr ); +int elf_ehdr32_bele( Elf32_Ehdr *ehdr32 ); +int elf_ehdr32_lebe( Elf32_Ehdr *ehdr32 ); +int elf_ehdr2mem( Elf_Ident *ident, Elf_Ehdr *ehdr, uint8_t *buf, int size ); +Elf_Ehdr* elf_header( FILE *f, Elf_Ident *ident, int sysorder ); +void header_info( Elf_Ehdr *ehdr ); + + +int elf_phdr_32( Elf_Phdr *phdr, Elf32_Phdr *phdr32 ); +int elf_phdr_64( Elf_Phdr *phdr, Elf64_Phdr *phdr64 ); +int elf_32_phdr( Elf32_Phdr *phdr32, Elf_Phdr *phdr ); +int elf_64_phdr( Elf64_Phdr *phdr64, Elf_Phdr *phdr ); +Elf_Phdr* elf_phdr( FILE *f, Elf_Ehdr *ehdr ); + + +int elf_shdr_32( Elf_Shdr *shdr, Elf32_Shdr *shdr32 ); +int elf_shdr_64( Elf_Shdr *shdr, Elf64_Shdr *shdr64 ); +int elf_32_shdr( Elf32_Shdr *shdr32, Elf_Shdr *shdr ); +int elf_64_shdr( Elf64_Shdr *shdr64, Elf_Shdr *shdr ); +int elf_shdr64_lebe( Elf64_Shdr *shdr64 ); +int elf_shdr32_lebe( Elf32_Shdr *shdr32 ); +int elf_shdr2mem( Elf_Shdr *shdr, uint8_t *buf, int size, int offset ); +Elf_Shdr** elf_shdr( FILE *f, Elf_Ehdr *ehdr ); +void section_info( Elf_Shdr* shdr, Elf_Shdr_strtab *strtab ); + +/* Search for strtab section */ +Elf_Shdr_strtab* strtab_search( FILE *f, Elf_Shdr **shdr ); +unsigned char* strtab_name( Elf_Shdr_strtab *strtab, long offset ); + +#endif
\ No newline at end of file |