导入 /usr/include/elf.h
main.cpp
#include <iostream>
#include <cstring>
#include "elf.h"
#include "stdio.h"
#include "ELF_process.h"
#define file_name "libhello-jni.so"
#define SARMAG 8
int
main() {
FILE *file = fopen(file_name,"rb");
char armag[SARMAG];
printf("Input file ‘%s‘.\n", file_name);
if (file == NULL)
{
printf("Input file ‘%s‘ is not readable.\n", file_name);
return 0;
}
if (fread (armag, SARMAG, 1, file) != 1)
{
printf("%s: Failed to read file‘s magic number\n", file_name);
fclose (file);
return 0;
}
rewind(file);
ELF_process *pro;
pro->Process_object(file);
fclose (file);
delete(pro);
return 0;
}
ELF_process.h
#include <iostream>
/* ELF Header (32-bit implementations) */
typedef struct {
unsigned char e_ident[16]; /* ELF "magic number" */
unsigned char e_type[2]; /* Identifies object file type */
unsigned char e_machine[2]; /* Specifies required architecture */
unsigned char e_version[4]; /* Identifies object file version */
unsigned char e_entry[4]; /* Entry point virtual address */
unsigned char e_phoff[4]; /* Program header table file offset */
unsigned char e_shoff[4]; /* Section header table file offset */
unsigned char e_flags[4]; /* Processor-specific flags */
unsigned char e_ehsize[2]; /* ELF header size in bytes */
unsigned char e_phentsize[2]; /* Program header table entry size */
unsigned char e_phnum[2]; /* Program header table entry count */
unsigned char e_shentsize[2]; /* Section header table entry size */
unsigned char e_shnum[2]; /* Section header table entry count */
unsigned char e_shstrndx[2]; /* Section header string table index */
} Elf32_External_Ehdr;
typedef struct {
unsigned char e_ident[16]; /* ELF "magic number" */
unsigned char e_type[2]; /* Identifies object file type */
unsigned char e_machine[2]; /* Specifies required architecture */
unsigned char e_version[4]; /* Identifies object file version */
unsigned char e_entry[8]; /* Entry point virtual address */
unsigned char e_phoff[8]; /* Program header table file offset */
unsigned char e_shoff[8]; /* Section header table file offset */
unsigned char e_flags[4]; /* Processor-specific flags */
unsigned char e_ehsize[2]; /* ELF header size in bytes */
unsigned char e_phentsize[2]; /* Program header table entry size */
unsigned char e_phnum[2]; /* Program header table entry count */
unsigned char e_shentsize[2]; /* Section header table entry size */
unsigned char e_shnum[2]; /* Section header table entry count */
unsigned char e_shstrndx[2]; /* Section header string table index */
} Elf64_External_Ehdr;
/* Section header */
typedef struct {
unsigned char sh_name[4]; /* Section name, index in string tbl */
unsigned char sh_type[4]; /* Type of section */
unsigned char sh_flags[4]; /* Miscellaneous section attributes */
unsigned char sh_addr[4]; /* Section virtual addr at execution */
unsigned char sh_offset[4]; /* Section file offset */
unsigned char sh_size[4]; /* Size of section in bytes */
unsigned char sh_link[4]; /* Index of another section */
unsigned char sh_info[4]; /* Additional section information */
unsigned char sh_addralign[4]; /* Section alignment */
unsigned char sh_entsize[4]; /* Entry size if section holds table */
} Elf32_External_Shdr;
typedef struct {
unsigned char sh_name[4]; /* Section name, index in string tbl */
unsigned char sh_type[4]; /* Type of section */
unsigned char sh_flags[8]; /* Miscellaneous section attributes */
unsigned char sh_addr[8]; /* Section virtual addr at execution */
unsigned char sh_offset[8]; /* Section file offset */
unsigned char sh_size[8]; /* Size of section in bytes */
unsigned char sh_link[4]; /* Index of another section */
unsigned char sh_info[4]; /* Additional section information */
unsigned char sh_addralign[8]; /* Section alignment */
unsigned char sh_entsize[8]; /* Entry size if section holds table */
} Elf64_External_Shdr;
/* Program header */
typedef struct {
unsigned char p_type[4]; /* Identifies program segment type */
unsigned char p_offset[4]; /* Segment file offset */
unsigned char p_vaddr[4]; /* Segment virtual address */
unsigned char p_paddr[4]; /* Segment physical address */
unsigned char p_filesz[4]; /* Segment size in file */
unsigned char p_memsz[4]; /* Segment size in memory */
unsigned char p_flags[4]; /* Segment flags */
unsigned char p_align[4]; /* Segment alignment, file & memory */
} Elf32_External_Phdr;
typedef struct {
unsigned char p_type[4]; /* Identifies program segment type */
unsigned char p_flags[4]; /* Segment flags */
unsigned char p_offset[8]; /* Segment file offset */
unsigned char p_vaddr[8]; /* Segment virtual address */
unsigned char p_paddr[8]; /* Segment physical address */
unsigned char p_filesz[8]; /* Segment size in file */
unsigned char p_memsz[8]; /* Segment size in memory */
unsigned char p_align[8]; /* Segment alignment, file & memory */
} Elf64_External_Phdr;
/* dynamic section structure */
typedef struct {
unsigned char d_tag[4]; /* entry tag value */
union {
unsigned char d_val[4];
unsigned char d_ptr[4];
} d_un;
} Elf32_External_Dyn;
typedef struct {
unsigned char d_tag[8]; /* entry tag value */
union {
unsigned char d_val[8];
unsigned char d_ptr[8];
} d_un;
} Elf64_External_Dyn;
/* Relocation Entries */
typedef struct {
unsigned char r_offset[4]; /* Location at which to apply the action */
unsigned char r_info[4]; /* index and type of relocation */
} Elf32_External_Rel;
typedef struct {
unsigned char r_offset[4]; /* Location at which to apply the action */
unsigned char r_info[4]; /* index and type of relocation */
unsigned char r_addend[4]; /* Constant addend used to compute value */
} Elf32_External_Rela;
typedef struct {
unsigned char r_offset[8]; /* Location at which to apply the action */
unsigned char r_info[8]; /* index and type of relocation */
} Elf64_External_Rel;
typedef struct {
unsigned char r_offset[8]; /* Location at which to apply the action */
unsigned char r_info[8]; /* index and type of relocation */
unsigned char r_addend[8]; /* Constant addend used to compute value */
} Elf64_External_Rela;
/* Symbol table entry */
typedef struct {
unsigned char st_name[4]; /* Symbol name, index in string tbl */
unsigned char st_value[4]; /* Value of the symbol */
unsigned char st_size[4]; /* Associated symbol size */
unsigned char st_info[1]; /* Type and binding attributes */
unsigned char st_other[1]; /* No defined meaning, 0 */
unsigned char st_shndx[2]; /* Associated section index */
} Elf32_External_Sym;
typedef struct {
unsigned char st_name[4]; /* Symbol name, index in string tbl */
unsigned char st_info[1]; /* Type and binding attributes */
unsigned char st_other[1]; /* No defined meaning, 0 */
unsigned char st_shndx[2]; /* Associated section index */
unsigned char st_value[8]; /* Value of the symbol */
unsigned char st_size[8]; /* Associated symbol size */
} Elf64_External_Sym;
class ELF_process {
ELF_process();
void* get_data(void * var, FILE * file, long offset, size_t size, size_t nmemb,
const char * reason);
void *cmalloc (size_t nmemb, size_t size);
int get_32bit_section_headers (FILE * file, unsigned int num);
int get_file_header(FILE *file);
int process_file_header();
const char* get_elf_class (unsigned int elf_class);
const char * get_data_encoding (unsigned int encoding);
const char * get_osabi_name (unsigned int osabi);
const char *get_file_type (unsigned e_type);
const char *get_machine_name (unsigned e_machine);
int process_section_headers (FILE * file);
const char *get_section_type_name (unsigned int sh_type);
const char *get_mips_section_type_name (unsigned int sh_type);
const char *get_parisc_section_type_name (unsigned int sh_type);
const char *get_ia64_section_type_name (unsigned int sh_type);
const char *get_x86_64_section_type_name (unsigned int sh_type);
const char *get_aarch64_section_type_name (unsigned int sh_type);
const char *get_arm_section_type_name (unsigned int sh_type);
const char *get_tic6x_section_type_name (unsigned int sh_type);
const char *get_msp430x_section_type_name (unsigned int sh_type);
int process_program_headers (FILE * file);
const char *get_segment_type (unsigned int p_type);
const char *get_aarch64_segment_type (unsigned long type);
const char *get_arm_segment_type (unsigned long type);
const char *get_mips_segment_type (unsigned long type);
const char *get_parisc_segment_type (unsigned long type);
const char *get_ia64_segment_type (unsigned long type);
const char *get_tic6x_segment_type (unsigned long type);
int get_program_headers (FILE * file);
int get_32bit_program_headers (FILE * file, Elf32_Phdr * pheaders);
int get_64bit_program_headers (FILE * file, Elf64_Phdr * pheaders);
int process_dynamic_section (FILE * file);
int get_32bit_dynamic_section (FILE * file);
int get_64bit_dynamic_section(FILE * file);
void print_dynamic_flags (Elf32_Word flags);
const char *get_dynamic_type (unsigned long type);
int process_relocs (FILE * file);
void get_32bit_rel(FILE *pFILE, unsigned int offset);
public:
int Process_object(FILE *file);
void process_symbol_table(FILE *pFILE);
void get_32bit_symbol(FILE *pFILE);
void get_32bit_strdyn(FILE *pFILE, Elf32_Word name);
};
ELF_process.cpp
#include <elf.h>
#include <cstring>
#include "ELF_process.h"
#define file_name "/home/hx/cProgram/Process/libhello-jni.so"
#define BYTE_GET(field) byte_get_little_endian (field,sizeof(field))
static int is_32bit_elf;
Elf32_Ehdr elf_header;
Elf32_Shdr* section_headers;
Elf32_Phdr* program_headers;
Elf32_Sym* sym_dyn;
static unsigned int dynamic_addr;
static unsigned int dynamic_offset;
unsigned int dynamic_strings;
unsigned int dynamic_size;
static unsigned int rel_nent;
static unsigned int rel_dyn_offset;
static unsigned int rel_dyn_size;
static unsigned int sym_dyn_offset;
static unsigned int sym_dyn_size;
static unsigned int str_dyn_offset;
static unsigned int str_dyn_size;
unsigned int sym_nent;
Elf32_Dyn* dynamic_section;
static unsigned int dynamic_nent;
#define SHT_PARISC_ANNOT 0x70000003
#define SHT_PARISC_SYMEXTN SHT_LOPROC + 8
#define SHT_PARISC_STUBS SHT_LOPROC + 9
#define SHT_PARISC_DLKM 0x70000004
#define PT_PARISC_WEAKORDER 0x70000002
#define PT_HP_CORE_UTSNAME (PT_LOOS + 0x15)
#define SHT_IA_64_PRIORITY_INIT (SHT_LOPROC + 0x9000000)
#define SHT_IA_64_VMS_TRACE 0x60000000
#define SHT_IA_64_VMS_TIE_SIGNATURES 0x60000001
#define SHT_IA_64_VMS_DEBUG 0x60000002
#define SHT_IA_64_VMS_DEBUG_STR 0x60000003
#define SHT_IA_64_VMS_LINKAGES 0x60000004
#define SHT_IA_64_VMS_SYMBOL_VECTOR 0x60000005
#define SHT_IA_64_VMS_FIXUP 0x60000006
#define SHT_IA_64_LOPSREG (SHT_LOPROC + 0x8000000)
#define EM_L1OM 180 /* Intel L1OM */
#define EM_K1OM 181 /* Intel K1OM */
#define EM_TI_C6000 140 /* Texas Instruments TMS320C6000 DSP family */
#define EM_MSP430 105 /* TI msp430 micro controller */
#define SHT_ARM_DEBUGOVERLAY 0x70000004 /* Section holds overlay debug info. */
#define SHT_ARM_OVERLAYSECTION 0x70000005 /* Section holds GDB and overlay integration info. */
#define SHT_X86_64_UNWIND 0x70000001 /* unwind information */
#define SHT_AARCH64_ATTRIBUTES 0x70000003 /* Section holds attributes. */
#define SHT_C6000_UNWIND 0x70000001
#define SHT_C6000_PREEMPTMAP 0x70000002
#define SHT_C6000_ATTRIBUTES 0x70000003
#define SHT_TI_ICODE 0x7F000000
#define SHT_TI_XREF 0x7F000001
#define SHT_TI_HANDLER 0x7F000002
#define SHT_TI_INITINFO 0x7F000003
#define SHT_TI_PHATTRS 0x7F000004
#define SHT_MSP430_ATTRIBUTES 0x70000003 /* Section holds ABI attributes. */
#define SHT_MSP430_SEC_FLAGS 0x7f000005 /* Holds TI compiler‘s section flags. */
#define SHT_MSP430_SYM_ALIASES 0x7f000006 /* Holds TI compiler‘s symbol aliases. */
#define PT_AARCH64_ARCHEXT (PT_LOPROC + 0)
int byte_get_little_endian (unsigned char *field, int size){
switch (size){
case 1:
return *field;
case 2:
return ((unsigned int)(field[0]))
| (((unsigned int)(field[1])) << 8);
case 3:
return ((unsigned long) (field[0]))
| (((unsigned long) (field[1])) << 8)
| (((unsigned long) (field[2])) << 16);
case 4:
return ((unsigned long) (field[0]))
| (((unsigned long) (field[1])) << 8)
| (((unsigned long) (field[2])) << 16)
| (((unsigned long) (field[3])) << 24);
}
}
ELF_process::ELF_process() {
}
int ELF_process::Process_object(FILE *file) {
if (!get_file_header(file)){
printf("gei file header Failed");
return 0;
}
/********* start process ***********/
if (!process_file_header()){
return 0;
}
if(!process_section_headers(file)){
return 0;
}
if(!process_program_headers(file)){
process_dynamic_section(file);
}
process_relocs(file);
process_symbol_table(file);
}
int ELF_process::get_file_header(FILE *file) {
/* Read in the identity array. */
if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
return 0;
/* For now we only support 32 bit and 64 bit ELF files. */
is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
/* Read in the rest of the header. */
if (is_32bit_elf){
Elf32_External_Ehdr ehdr32;
if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
return 0;
elf_header.e_type = BYTE_GET (ehdr32.e_type);
elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
elf_header.e_version = BYTE_GET (ehdr32.e_version);
elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
if (elf_header.e_shoff){
if (is_32bit_elf)
get_32bit_section_headers(file,1);
else
{
//64位 ...
}
}
}
return 1;
}
int ELF_process::get_32bit_section_headers(FILE *file, unsigned int num) {
Elf32_External_Shdr * shdrs;
Elf32_Shdr* internal;
shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
elf_header.e_shentsize, num,
("section headers"));
if (!shdrs)
return 0;
section_headers = (Elf32_Shdr *) cmalloc (num,sizeof (Elf32_Shdr));
if (section_headers == NULL)
{
printf("Out of memory\n");
return 0;
}
internal = section_headers;
for (int i = 0;i < num;i++, internal++)
{
internal->sh_name = BYTE_GET (shdrs[i].sh_name);
internal->sh_type = BYTE_GET (shdrs[i].sh_type);
internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
internal->sh_size = BYTE_GET (shdrs[i].sh_size);
internal->sh_link = BYTE_GET (shdrs[i].sh_link);
internal->sh_info = BYTE_GET (shdrs[i].sh_info);
internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
}
free (shdrs);
return 1;
}
void *
ELF_process::get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,const char * reason)
{
void * mvar;
if (size == 0 || nmemb == 0)
return NULL;
if (fseek (file, offset, SEEK_SET))
{
//error (_("Unable to seek to 0x%lx for %s\n"),
// (unsigned long) archive_file_offset + offset, reason);
return NULL;
}
mvar = var;
if (mvar == NULL)
{
/* Check for overflow. */
if (nmemb < (~(size_t) 0 - 1) / size)
/* + 1 so that we can ‘\0‘ terminate invalid string table sections. */
mvar = malloc (size * nmemb + 1);
if (mvar == NULL)
{
//error (_("Out of memory allocating 0x%lx bytes for %s\n"),
//(unsigned long)(size * nmemb), reason);
return NULL;
}
((char *) mvar)[size * nmemb] = ‘\0‘;
}
if (fread (mvar, size, nmemb, file) != nmemb)
{
//error (_("Unable to read in 0x%lx bytes of %s\n"),
// (unsigned long)(size * nmemb), reason);
if (mvar != var)
free (mvar);
return NULL;
}
return mvar;
}
void *ELF_process::cmalloc (size_t nmemb, size_t size)
{
/* Check for overflow. */
if (nmemb >= ~(size_t) 0 / size)
return NULL;
else
return malloc (nmemb * size);
}
int ELF_process::process_file_header(void) {
if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
|| elf_header.e_ident[EI_MAG1] != ELFMAG1
|| elf_header.e_ident[EI_MAG2] != ELFMAG2
|| elf_header.e_ident[EI_MAG3] != ELFMAG3)
{
printf("Not an ELF file - it has the wrong magic bytes at the start\n");
return 0;
}
printf("ELF Header:\n");
printf(" Magic: ");
for (int i = 0; i <EI_NIDENT ; ++i)
printf ("%2.2x ", elf_header.e_ident[i]);
printf("\n");
printf(" Class: %s\n",
get_elf_class(elf_header.e_ident[EI_CLASS]));
printf (" Data: %s\n",
get_data_encoding (elf_header.e_ident[EI_DATA]));
printf (" Version: %d %s\n",
elf_header.e_ident[EI_VERSION],
(elf_header.e_ident[EI_VERSION] == EV_CURRENT
? "(current)"
: (elf_header.e_ident[EI_VERSION] != EV_NONE
? ("<unknown: %lx>")
: "")));
printf (" OS/ABI: %s\n",
get_osabi_name (elf_header.e_ident[EI_OSABI]));
printf (" ABI Version: %d\n",
elf_header.e_ident[EI_ABIVERSION]);
printf (" Type: %s\n",
get_file_type (elf_header.e_type));
printf (" Machine: %s\n",
get_machine_name (elf_header.e_machine));
printf (" Version: 0x%lx\n",
(unsigned long) elf_header.e_version);
printf (" Entry point address: 0x%x",elf_header.e_entry);
printf ("\n Start of program headers: %d",elf_header.e_phoff);
printf (" (bytes into file)\n Start of section headers: %d",elf_header.e_shoff);
printf (" (bytes into file)\n");
printf (" Flags: 0x%lx\n",(unsigned long)elf_header.e_flags);
printf (" Size of this header: %ld (bytes)\n",(long)elf_header.e_ehsize);
printf (" Size of program headers: %ld (bytes)\n",(long)elf_header.e_phentsize);
printf (" Number of program headers: %ld\n",(long)elf_header.e_phnum);
if (section_headers != NULL
&& elf_header.e_phnum == PN_XNUM
&& section_headers[0].sh_info != 0)
printf (" (%ld)", (long) section_headers[0].sh_info);
printf (" Size of section headers: %ld (bytes)\n",
(long) elf_header.e_shentsize);
printf (" Number of section headers: %ld\n",
(long) elf_header.e_shnum);
if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
printf (" (%ld)", (long) section_headers[0].sh_size);
printf (" Section header string table index: %ld\n",
(long) elf_header.e_shstrndx);
if (section_headers != NULL
&& elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
printf (" (%u)", section_headers[0].sh_link);
else if (elf_header.e_shstrndx != SHN_UNDEF
&& elf_header.e_shstrndx >= elf_header.e_shnum)
printf (" <corrupt: out of range>");
return 1;
}
const char *
ELF_process::get_elf_class (unsigned int elf_class)
{
static char buff[32];
switch (elf_class)
{
case ELFCLASSNONE: return ("none");
case ELFCLASS32: return "ELF32";
case ELFCLASS64: return "ELF64";
default:
snprintf (buff, sizeof (buff), ("<unknown: %x>"), elf_class);
return buff;
}
}
const char *
ELF_process::get_data_encoding (unsigned int encoding)
{
static char buff[32];
switch (encoding)
{
case ELFDATANONE: return ("none");
case ELFDATA2LSB: return ("2‘s complement, little endian");
case ELFDATA2MSB: return ("2‘s complement, big endian");
default:
snprintf (buff, sizeof (buff), ("<unknown: %x>"), encoding);
return buff;
}
}
const char *
ELF_process::get_osabi_name (unsigned int osabi){
static char buff[32];
switch (osabi){
case ELFOSABI_NONE: return "UNIX System V ABI";
case ELFOSABI_HPUX: return "HP-UX";
case ELFOSABI_NETBSD: return "NetBSD";
case ELFOSABI_GNU: return "Object uses GNU ELF extensions";
case ELFOSABI_SOLARIS: return "Sun Solaris";
case ELFOSABI_AIX: return "IBM AIX";
case ELFOSABI_IRIX: return "SGI Irix";
case ELFOSABI_FREEBSD: return "FreeBSD";
case ELFOSABI_TRU64: return "Compaq TRU64 UNIX";
case ELFOSABI_MODESTO: return "Novell Modesto";
case ELFOSABI_OPENBSD: return "OpenBSD";
case ELFOSABI_ARM_AEABI: return "ARM EABI";
case ELFOSABI_ARM: return "ARM";
case ELFOSABI_STANDALONE: return "Standalone (embedded) application";
default:
break;
}
snprintf (buff, sizeof (buff), ("<unknown: %x>"), osabi);
return buff;
}
const char *ELF_process::get_file_type(unsigned e_type) {
static char buff[32];
switch (e_type) {
case ET_NONE:
return "NONE (None)";
case ET_REL:
return "REL (Relocatable file)";
case ET_EXEC:
return "EXEC (Executable file)";
case ET_DYN:
return "DYN (Shared object file)";
case ET_CORE:
return "CORE (Core file)";
default:
if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
snprintf(buff, sizeof(buff), ("Processor Specific: (%x)"), e_type);
else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
snprintf(buff, sizeof(buff), ("OS Specific: (%x)"), e_type);
else
snprintf(buff, sizeof(buff), ("<unknown>: %x"), e_type);
return buff;
}
}
const char *ELF_process::get_machine_name(unsigned e_machine) {
static char buff[64];
switch (e_machine){
case EM_NONE: return ("None");
case EM_AARCH64: return "AArch64";
case EM_M32: return "WE32100";
case EM_SPARC: return "Sparc";
case EM_386: return "Intel 80386";
case EM_68K: return "MC68000";
case EM_88K: return "MC88000";
case EM_860: return "Intel 80860";
case EM_MIPS: return "MIPS R3000";
case EM_S370: return "IBM System/370";
case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
case EM_PARISC: return "HPPA";
case EM_SPARC32PLUS: return "Sparc v8+" ;
case EM_960: return "Intel 90860";
case EM_PPC: return "PowerPC";
case EM_PPC64: return "PowerPC64";
case EM_FR20: return "Fujitsu FR20";
case EM_RH32: return "TRW RH32";
case EM_ARM: return "ARM";
case EM_SH: return "Renesas / SuperH SH";
case EM_SPARCV9: return "Sparc v9";
case EM_TRICORE: return "Siemens Tricore";
case EM_ARC: return "ARC";
case EM_H8_300: return "Renesas H8/300";
case EM_H8_300H: return "Renesas H8/300H";
case EM_H8S: return "Renesas H8S";
case EM_H8_500: return "Renesas H8/500";
case EM_IA_64: return "Intel IA-64";
case EM_MIPS_X: return "Stanford MIPS-X";
case EM_COLDFIRE: return "Motorola Coldfire";
case EM_ALPHA: return "Alpha";
case EM_D10V: return "d10v";
case EM_D30V: return "d30v";
case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
case EM_V800: return "Renesas V850 (using RH850 ABI)";
case EM_V850: return "Renesas V850";
case EM_MN10300: return "mn10300";
case EM_MN10200: return "mn10200";
case EM_FR30: return "Fujitsu FR30";
case EM_PJ: return "picoJava";
case EM_MMA: return "Fujitsu Multimedia Accelerator";
case EM_PCP: return "Siemens PCP";
case EM_NCPU: return "Sony nCPU embedded RISC processor";
case EM_NDR1: return "Denso NDR1 microprocesspr";
case EM_STARCORE: return "Motorola Star*Core processor";
case EM_ME16: return "Toyota ME16 processor";
case EM_ST100: return "STMicroelectronics ST100 processor";
case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
case EM_PDSP: return "Sony DSP processor";
case EM_FX66: return "Siemens FX66 microcontroller";
case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
case EM_SVX: return "Silicon Graphics SVx";
case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
case EM_VAX: return "Digital VAX";
case EM_AVR: return "Atmel AVR 8-bit microcontroller";
case EM_CRIS: return "Axis Communications 32-bit embedded processor";
case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
case EM_FIREPATH: return "Element 14 64-bit DSP processor";
case EM_ZSP: return "LSI Logic‘s 16-bit DSP processor";
case EM_MMIX: return "Donald Knuth‘s educational 64-bit processor";
case EM_HUANY: return "Harvard Universitys‘s machine-independent object format";
case EM_PRISM: return "Vitesse Prism";
case EM_X86_64: return "Advanced Micro Devices X86-64";
case EM_S390: return "IBM S/390";
case EM_OPENRISC:
case EM_ARC_A5: return "ARC International ARCompact processor";
case EM_XTENSA: return "Tensilica Xtensa Processor";
case EM_MICROBLAZE:
case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
default:
snprintf (buff, sizeof (buff), ("<unknown>: 0x%x"), e_machine);
}
return buff;
}
int ELF_process::process_section_headers(FILE *file) {
Elf32_Shdr * section;
section = NULL;
char * string_table;
unsigned int flag_shoff;
if (elf_header.e_shnum == 0){
if (elf_header.e_shoff!=0)
printf("possibly corrupt ELF file header - it has a non-zero section header offset, but no section headers\n");
else
printf ("\nThere are no sections in this file.\n");
return 1;
}
printf (" There are %d section headers, starting at offset 0x%lx:\n",
elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
if (is_32bit_elf)
{
if (! get_32bit_section_headers (file, elf_header.e_shnum))
return 0;
}
/* Read in the string table, so that we have names to display. */
if (elf_header.e_shstrndx != SHN_UNDEF
&& elf_header.e_shstrndx < elf_header.e_shnum)
{
section = section_headers + elf_header.e_shstrndx;
flag_shoff = section->sh_offset;
}
if (elf_header.e_shnum > 1)
printf ("\nSection Headers:\n");
else
printf ("\nSection Header:\n");
section = section_headers;
unsigned int countC;
if (is_32bit_elf){
printf(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n");
for (int i = 0;
i < elf_header.e_shnum;
i++, section++)
{
printf (" [%2u] ", i);
countC = flag_shoff + section->sh_name;
fseek(file,countC,SEEK_SET);
char string_name[20];
fread(string_name,20,1,file);
printf("%-16s ",string_name);
printf ( " %-15.15s ",
get_section_type_name (section->sh_type));
printf("%6.8lx",(unsigned long) section->sh_addr);
printf ( " %6.6lx %6.6lx %2.2lx",
(unsigned long) section->sh_offset,
(unsigned long) section->sh_size,
(unsigned long) section->sh_entsize);
if (section->sh_flags)
printf (" %2.2x ", section->sh_flags);
else
printf("%4c",32);
printf ("%2u ", section->sh_link);
printf ("%3u %3lu", section->sh_info,
(unsigned long) section->sh_addralign);
if (strcmp(string_name,".dynamic")==0)
{
dynamic_addr = section->sh_offset;
dynamic_size = section->sh_size;
}
if (strcmp(string_name,".rel.dyn")==0){
rel_dyn_offset = section->sh_offset;
rel_dyn_size = section->sh_size;
}
if(strcmp(string_name,".dynsym")==0){
sym_dyn_offset = section->sh_offset;
sym_dyn_size = section->sh_size;
}
if(strcmp(string_name,".dynstr")==0){
str_dyn_offset = section->sh_offset;
str_dyn_size = section->sh_size;
}
printf("\n");
}
}
return 1;
}
const char *ELF_process::get_section_type_name(unsigned int sh_type) {
static char buff[32];
switch (sh_type){
case SHT_NULL: return "NULL";
case SHT_PROGBITS: return "PROGBITS";
case SHT_SYMTAB: return "SYMTAB";
case SHT_STRTAB: return "STRTAB";
case SHT_RELA: return "RELA";
case SHT_HASH: return "HASH";
case SHT_DYNAMIC: return "DYNAMIC";
case SHT_NOTE: return "NOTE";
case SHT_NOBITS: return "NOBITS";
case SHT_REL: return "REL";
case SHT_SHLIB: return "SHLIB";
case SHT_DYNSYM: return "DYNSYM";
case SHT_INIT_ARRAY: return "INIT_ARRAY";
case SHT_FINI_ARRAY: return "FINI_ARRAY";
case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
case SHT_GNU_HASH: return "GNU_HASH";
case SHT_GROUP: return "GROUP";
case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
case SHT_GNU_verdef: return "VERDEF";
case SHT_GNU_verneed: return "VERNEED";
case SHT_GNU_versym: return "VERSYM";
case 0x6ffffff0: return "VERSYM";
case 0x6ffffffc: return "VERDEF";
case 0x7ffffffd: return "AUXILIARY";
case 0x7fffffff: return "FILTER";
case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
default:
if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC)){
const char * result;
switch (elf_header.e_machine){
case EM_MIPS:
case EM_MIPS_RS3_LE:
result = get_mips_section_type_name (sh_type);
break;
case EM_PARISC:
result = get_parisc_section_type_name (sh_type);
break;
case EM_IA_64:
result = get_ia64_section_type_name (sh_type);
break;
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
result = get_x86_64_section_type_name (sh_type);
break;
case EM_AARCH64:
result = get_aarch64_section_type_name (sh_type);
break;
case EM_ARM:
result = get_arm_section_type_name (sh_type);
break;
case EM_TI_C6000:
result = get_tic6x_section_type_name (sh_type);
break;
case EM_MSP430:
result = get_msp430x_section_type_name (sh_type);
break;
default:
result = NULL;
break;
}
if (result != NULL)
return result;
sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
}
else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
{
const char * result;
switch (elf_header.e_machine)
{
case EM_IA_64:
result = get_ia64_section_type_name (sh_type);
break;
default:
result = NULL;
break;
}
if (result != NULL)
return result;
sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
}
else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
else
/* This message is probably going to be displayed in a 15
character wide field, so put the hex value first. */
snprintf (buff, sizeof (buff), ("%08x: <unknown>"), sh_type);
return buff;
}
}
const char *ELF_process::get_mips_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
case SHT_MIPS_MSYM: return "MIPS_MSYM";
case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
case SHT_MIPS_UCODE: return "MIPS_UCODE";
case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
case SHT_MIPS_RELD: return "MIPS_RELD";
case SHT_MIPS_IFACE: return "MIPS_IFACE";
case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
case SHT_MIPS_SHDR: return "MIPS_SHDR";
case SHT_MIPS_FDESC: return "MIPS_FDESC";
case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
case SHT_MIPS_DENSE: return "MIPS_DENSE";
case SHT_MIPS_PDESC: return "MIPS_PDESC";
case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
case SHT_MIPS_LINE: return "MIPS_LINE";
case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
case SHT_MIPS_DWARF: return "MIPS_DWARF";
case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
case SHT_MIPS_XLATE: return "MIPS_XLATE";
case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
default:
break;
}
return NULL;
}
const char *ELF_process::get_parisc_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_PARISC_EXT: return "PARISC_EXT";
case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
case SHT_PARISC_DOC: return "PARISC_DOC";
case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
case SHT_PARISC_STUBS: return "PARISC_STUBS";
case SHT_PARISC_DLKM: return "PARISC_DLKM";
default:
break;
}
return NULL;
}
const char *ELF_process::get_ia64_section_type_name(unsigned int sh_type) {
/* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
switch (sh_type)
{
case SHT_IA_64_EXT: return "IA_64_EXT";
case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
default:
break;
}
return NULL;
}
const char *ELF_process::get_x86_64_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
default:
break;
}
return NULL;
}
const char *ELF_process::get_aarch64_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_AARCH64_ATTRIBUTES:
return "AARCH64_ATTRIBUTES";
default:
break;
}
return NULL;
}
const char *ELF_process::get_arm_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_ARM_EXIDX: return "ARM_EXIDX";
case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
default:
break;
}
return NULL;
}
const char *ELF_process::get_tic6x_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_C6000_UNWIND:
return "C6000_UNWIND";
case SHT_C6000_PREEMPTMAP:
return "C6000_PREEMPTMAP";
case SHT_C6000_ATTRIBUTES:
return "C6000_ATTRIBUTES";
case SHT_TI_ICODE:
return "TI_ICODE";
case SHT_TI_XREF:
return "TI_XREF";
case SHT_TI_HANDLER:
return "TI_HANDLER";
case SHT_TI_INITINFO:
return "TI_INITINFO";
case SHT_TI_PHATTRS:
return "TI_PHATTRS";
default:
break;
}
return NULL;
}
const char *ELF_process::get_msp430x_section_type_name(unsigned int sh_type) {
switch (sh_type)
{
case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
default: return NULL;
}
}
const char *ELF_process::get_segment_type(unsigned int p_type) {
static char buff[32];
switch (p_type)
{
case PT_NULL: return "NULL";
case PT_LOAD: return "LOAD";
case PT_DYNAMIC: return "DYNAMIC";
case PT_INTERP: return "INTERP";
case PT_NOTE: return "NOTE";
case PT_SHLIB: return "SHLIB";
case PT_PHDR: return "PHDR";
case PT_TLS: return "TLS";
case PT_GNU_EH_FRAME:
return "GNU_EH_FRAME";
case PT_GNU_STACK: return "GNU_STACK";
case PT_GNU_RELRO: return "GNU_RELRO";
default:
if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
{
const char * result;
switch (elf_header.e_machine)
{
case EM_AARCH64:
result = get_aarch64_segment_type (p_type);
break;
case EM_ARM:
result = get_arm_segment_type (p_type);
break;
case EM_MIPS:
case EM_MIPS_RS3_LE:
result = get_mips_segment_type (p_type);
break;
case EM_PARISC:
result = get_parisc_segment_type (p_type);
break;
case EM_IA_64:
result = get_ia64_segment_type (p_type);
break;
case EM_TI_C6000:
result = get_tic6x_segment_type (p_type);
break;
default:
result = NULL;
break;
}
if (result != NULL)
return result;
sprintf (buff, "LOPROC+%x", p_type - PT_LOPROC);
}
else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
{
const char * result;
switch (elf_header.e_machine)
{
case EM_PARISC:
result = get_parisc_segment_type (p_type);
break;
case EM_IA_64:
result = get_ia64_segment_type (p_type);
break;
default:
result = NULL;
break;
}
if (result != NULL)
return result;
sprintf (buff, "LOOS+%x", p_type - PT_LOOS);
}
else
snprintf (buff, sizeof (buff), ("<unknown>: %x"), p_type);
return buff;
}
}
int ELF_process::process_program_headers(FILE *file) {
Elf32_Phdr* segment;
unsigned long dynamic_addr;
if(elf_header.e_phnum == 0){
if(elf_header.e_phoff!=0){
printf ("possibly corrupt ELF header - it has a non-zero program"
" header offset, but no program headers");
} else
{
printf ("\nThere are no program headers in this file.\n");
return 0;
}
}else{
printf ("\nProgram Headers:\n");
if(is_32bit_elf)
printf(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n");
else
printf(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n");
}
if (! get_program_headers (file))
return 0;
unsigned int i;
for (i = 0, segment = program_headers;
i < elf_header.e_phnum;
i++, segment++){
printf (" %-14.14s ", get_segment_type (segment->p_type));
if(is_32bit_elf){
printf ("0x%6.6x ", (unsigned int) segment->p_offset);
printf ("0x%8.8x ", (unsigned int) segment->p_vaddr);
printf ("0x%8.8x ", (unsigned int) segment->p_paddr);
printf ("0x%5.5x ", (unsigned int) segment->p_filesz);
printf ("0x%5.5x ", (unsigned int) segment->p_memsz);
printf ("%c%c%c ",
(segment->p_flags & PF_R ? ‘R‘ : ‘ ‘),
(segment->p_flags & PF_W ? ‘W‘ : ‘ ‘),
(segment->p_flags & PF_X ? ‘E‘ : ‘ ‘));
printf ("%#x", (unsigned int) segment->p_align);
}
printf("\n");
}
return 0;
}
const char *ELF_process::get_aarch64_segment_type(unsigned long type) {
switch (type)
{
case PT_AARCH64_ARCHEXT:
return "AARCH64_ARCHEXT";
default:
break;
}
return NULL;
}
const char *ELF_process::get_arm_segment_type(unsigned long type) {
switch (type)
{
case PT_ARM_EXIDX:
return "EXIDX";
default:
break;
}
return NULL;
}
const char *ELF_process::get_mips_segment_type(unsigned long type) {
switch (type)
{
case PT_MIPS_REGINFO:
return "REGINFO";
case PT_MIPS_RTPROC:
return "RTPROC";
case PT_MIPS_OPTIONS:
return "OPTIONS";
default:
break;
}
return NULL;
}
const char *ELF_process::get_parisc_segment_type(unsigned long type) {
switch (type)
{
case PT_HP_TLS: return "HP_TLS";
case PT_HP_CORE_NONE: return "HP_CORE_NONE";
case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
case PT_HP_CORE_COMM: return "HP_CORE_COMM";
case PT_HP_CORE_PROC: return "HP_CORE_PROC";
case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
case PT_HP_CORE_STACK: return "HP_CORE_STACK";
case PT_HP_CORE_SHM: return "HP_CORE_SHM";
case PT_HP_CORE_MMF: return "HP_CORE_MMF";
case PT_HP_PARALLEL: return "HP_PARALLEL";
case PT_HP_FASTBIND: return "HP_FASTBIND";
case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
case PT_HP_STACK: return "HP_STACK";
case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
case PT_PARISC_UNWIND: return "PARISC_UNWIND";
case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
default:
break;
}
return NULL;
}
const char *ELF_process::get_ia64_segment_type(unsigned long type) {
switch (type)
{
case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
case PT_IA_64_UNWIND: return "IA_64_UNWIND";
case PT_HP_TLS: return "HP_TLS";
case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
case PT_IA_64_HP_STACK: return "HP_STACK";
default:
break;
}
return NULL;
}
#define PT_C6000_PHATTR 0x70000000
const char *ELF_process::get_tic6x_segment_type(unsigned long type) {
switch (type)
{
case PT_C6000_PHATTR: return "C6000_PHATTR";
default:
break;
}
return NULL;
}
int ELF_process::get_program_headers(FILE *file) {
Elf32_Phdr* phdrs;
Elf64_Phdr* phdrs64;
/* Check cache of prior read. */
if (program_headers != NULL)
return 1;
phdrs = (Elf32_Phdr *) cmalloc (elf_header.e_phnum,
sizeof (Elf32_Phdr));
if (phdrs == NULL)
{
printf("Out of memory\n");
return 0;
}
if (is_32bit_elf
? get_32bit_program_headers (file, phdrs)
: get_64bit_program_headers (file, phdrs64))
{
program_headers = phdrs;
return 1;
}
free (phdrs);
return 0;
}
int ELF_process::get_32bit_program_headers(FILE *file, Elf32_Phdr *pheaders) {
Elf32_External_Phdr* phdrs;
Elf32_External_Phdr* external;
Elf32_Phdr* internal;
unsigned int i;
phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
elf_header.e_phentsize,
elf_header.e_phnum,
("program headers"));
if (!phdrs)
return 0;
for (i = 0, internal = pheaders, external = phdrs;
i < elf_header.e_phnum;
i++, internal++, external++){
internal->p_type = BYTE_GET (external->p_type);
internal->p_offset = BYTE_GET (external->p_offset);
internal->p_vaddr = BYTE_GET (external->p_vaddr);
internal->p_paddr = BYTE_GET (external->p_paddr);
internal->p_filesz = BYTE_GET (external->p_filesz);
internal->p_memsz = BYTE_GET (external->p_memsz);
internal->p_flags = BYTE_GET (external->p_flags);
internal->p_align = BYTE_GET (external->p_align);
}
free (phdrs);
return 1;
}
int ELF_process::get_64bit_program_headers(FILE *file, Elf64_Phdr *pheaders) {
return 0;
}
int ELF_process::process_dynamic_section(FILE *file) {
Elf32_Dyn * entry;
if (is_32bit_elf){
if (! get_32bit_dynamic_section (file))
return 0;
} else if (! get_64bit_dynamic_section (file))
return 0;
if(dynamic_addr){
printf ("\nDynamic section at offset 0x%x contains %u entries:\n",
dynamic_addr, dynamic_nent);
printf (" Tag Type Name/Value\n");
}
for (entry = dynamic_section;
entry < dynamic_section + dynamic_nent;
entry++){
const char * dtype;
putchar (‘ ‘);
printf("0x%2.8x ",entry->d_tag);
dtype = get_dynamic_type(entry->d_tag);
printf("(%s)%*s",dtype,(27-strlen(dtype))," ");
switch (entry->d_tag){
case DT_FLAGS:
print_dynamic_flags (entry->d_un.d_val);
break;
case DT_AUXILIARY:
case DT_FILTER:
case DT_CONFIG:
case DT_DEPAUDIT:
case DT_AUDIT:
switch (entry->d_tag)
{
case DT_AUXILIARY:
printf ("Auxiliary library");
break;
case DT_FILTER:
printf ("Filter library");
break;
case DT_CONFIG:
printf ("Configuration file");
break;
case DT_DEPAUDIT:
printf ("Dependency audit library");
break;
case DT_AUDIT:
printf ("Audit library");
break;
}
break;
default:
printf("0x%x",entry->d_un.d_val);
}
printf("\n");
}
}
int ELF_process::get_32bit_dynamic_section(FILE *file) {
Elf32_External_Dyn * edyn = (Elf32_External_Dyn *) malloc(dynamic_size);
Elf32_External_Dyn * ext;
Elf32_Dyn * entry;
fseek(file,dynamic_addr,SEEK_SET);
fread(edyn,dynamic_size,1,file);
if(edyn==NULL)
return 0;
for (ext = edyn, dynamic_nent = 0;
(char *) ext < (char *) edyn + dynamic_size;
ext++)
{
dynamic_nent++;
if (BYTE_GET (ext->d_tag) == DT_NULL)
break;
}
dynamic_section = (Elf32_Dyn *) cmalloc (dynamic_nent,
sizeof (* entry));
if (dynamic_section == NULL)
{
printf("Out of memory\n");
free (edyn);
return 0;
}
for (ext = edyn, entry = dynamic_section;
entry < dynamic_section + dynamic_nent;
ext++, entry++)
{
entry->d_tag = BYTE_GET (ext->d_tag);
entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
}
free(edyn);
return 1;
}
int ELF_process::get_64bit_dynamic_section(FILE *file) {
return 0;
}
void ELF_process::print_dynamic_flags(Elf32_Word flags) {
int first = 1;
while (flags)
{
Elf32_Word flag;
flag = flags & - flags;
flags &= ~ flag;
if (first)
first = 0;
else
putc (‘ ‘, stdout);
switch (flag)
{
case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
default: fputs (("unknown"), stdout); break;
}
}
}
#define DT_FEATURE 0x6ffffdfc
#define DT_USED 0x7ffffffe
const char *ELF_process::get_dynamic_type(unsigned long type) {
static char buff[64];
switch (type){
case DT_NULL: return "NULL";
case DT_NEEDED: return "NEEDED";
case DT_PLTRELSZ: return "PLTRELSZ";
case DT_PLTGOT: return "PLTGOT";
case DT_HASH: return "HASH";
case DT_STRTAB: return "STRTAB";
case DT_SYMTAB: return "SYMTAB";
case DT_RELA: return "RELA";
case DT_RELASZ: return "RELASZ";
case DT_RELAENT: return "RELAENT";
case DT_STRSZ: return "STRSZ";
case DT_SYMENT: return "SYMENT";
case DT_INIT: return "INIT";
case DT_FINI: return "FINI";
case DT_SONAME: return "SONAME";
case DT_RPATH: return "RPATH";
case DT_SYMBOLIC: return "SYMBOLIC";
case DT_REL: return "REL";
case DT_RELSZ: return "RELSZ";
case DT_RELENT: return "RELENT";
case DT_PLTREL: return "PLTREL";
case DT_DEBUG: return "DEBUG";
case DT_TEXTREL: return "TEXTREL";
case DT_JMPREL: return "JMPREL";
case DT_BIND_NOW: return "BIND_NOW";
case DT_INIT_ARRAY: return "INIT_ARRAY";
case DT_FINI_ARRAY: return "FINI_ARRAY";
case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
case DT_RUNPATH: return "RUNPATH";
case DT_FLAGS: return "FLAGS";
case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
case DT_CHECKSUM: return "CHECKSUM";
case DT_PLTPADSZ: return "PLTPADSZ";
case DT_MOVEENT: return "MOVEENT";
case DT_MOVESZ: return "MOVESZ";
case DT_FEATURE: return "FEATURE";
case DT_POSFLAG_1: return "POSFLAG_1";
case DT_SYMINSZ: return "SYMINSZ";
case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
case DT_ADDRRNGLO: return "ADDRRNGLO";
case DT_CONFIG: return "CONFIG";
case DT_DEPAUDIT: return "DEPAUDIT";
case DT_AUDIT: return "AUDIT";
case DT_PLTPAD: return "PLTPAD";
case DT_MOVETAB: return "MOVETAB";
case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
case DT_VERSYM: return "VERSYM";
case DT_TLSDESC_GOT: return "TLSDESC_GOT";
case DT_TLSDESC_PLT: return "TLSDESC_PLT";
case DT_RELACOUNT: return "RELACOUNT";
case DT_RELCOUNT: return "RELCOUNT";
case DT_FLAGS_1: return "FLAGS_1";
case DT_VERDEF: return "VERDEF";
case DT_VERDEFNUM: return "VERDEFNUM";
case DT_VERNEED: return "VERNEED";
case DT_VERNEEDNUM: return "VERNEEDNUM";
case DT_AUXILIARY: return "AUXILIARY";
case DT_USED: return "USED";
case DT_FILTER: return "FILTER";
case DT_GNU_PRELINKED: return "GNU_PRELINKED";
case DT_GNU_CONFLICT: return "GNU_CONFLICT";
case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
case DT_GNU_LIBLIST: return "GNU_LIBLIST";
case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
case DT_GNU_HASH: return "GNU_HASH";
}
return nullptr;
}
#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
#define FALSE 0
#define TRUE 1
#define UNKNOWN -1
static struct
{
const char * name;
int reloc;
int size;
int rela;
} dynamic_relocations [] =
{
{ "REL", DT_REL, DT_RELSZ, FALSE },
{ "RELA", DT_RELA, DT_RELASZ, TRUE },
{ "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
};
Elf32_Rel* elf32_rel;
int ELF_process::process_relocs(FILE *file) {
Elf32_Rel* entry_rel;
if(is_32bit_elf){
get_32bit_rel(file,rel_dyn_offset);
}
else{
//64位...
}
printf (" \nat offset 0x%2.2x contains %u entries:\n",
rel_dyn_offset, rel_nent);
printf (" Offset Info Type Sym. Value Sym. Name\n");
for (entry_rel = elf32_rel;
entry_rel < elf32_rel + rel_nent;
entry_rel++)
{
printf("%10.8x ",entry_rel->r_offset);
printf("%15.8x\n",entry_rel->r_info);
}
return 0;
}
void ELF_process::get_32bit_rel(FILE *pFILE, unsigned int offset) {
Elf32_External_Rel* rel= (Elf32_External_Rel *) malloc(rel_dyn_size);
Elf32_External_Rel* ext;
Elf32_Rel* relt;
fseek(pFILE,offset,SEEK_SET);
fread(rel,rel_dyn_size,1,pFILE);
if(rel==NULL)
return;
for (ext = rel, rel_nent = 0;
(char *) ext < (char *) rel + rel_dyn_size;
ext++)
{
rel_nent++;
if (BYTE_GET (rel->r_offset) == DT_NULL)
break;
}
elf32_rel = (Elf32_Rel *) cmalloc (dynamic_nent,
sizeof (* relt));
for (ext = rel, relt = elf32_rel;
relt < elf32_rel + rel_nent;
ext++, relt++)
{
relt->r_offset = BYTE_GET (ext->r_offset);
relt->r_info = BYTE_GET (ext->r_info);
}
free(rel);
return;
}
void ELF_process::process_symbol_table(FILE *pFILE) {
Elf32_Sym* sym;
get_32bit_symbol(pFILE);
printf("\n");
unsigned int i;
for ( i=0, sym = sym_dyn;sym<sym_dyn+sym_nent;sym++,i++)
{
printf("%2d: ",i);
printf("%2.8x ",sym->st_value);
printf("%-2.2x",sym->st_shndx);
printf("%-12.2x ",sym->st_other);
printf("%-12.2x ",sym->st_info);
printf("%-12.2x ",sym->st_size);
get_32bit_strdyn(pFILE,sym->st_name);
}
}
void ELF_process::get_32bit_symbol(FILE *pFILE) {
Elf32_External_Sym* exty = (Elf32_External_Sym *) malloc(sym_dyn_size);
Elf32_External_Sym* ext;
Elf32_Sym* symbool;
fseek(pFILE,sym_dyn_offset,SEEK_SET);
fread(exty,sym_dyn_size,1,pFILE);
if (!exty)
return;
for (ext = exty, sym_nent = 0;
(char *) ext < (char *) exty + sym_dyn_size;
ext++)
{
sym_nent++;
}
sym_dyn = (Elf32_Sym *) cmalloc (sym_nent,
sizeof (* exty));
for (ext = exty, symbool = sym_dyn ;
symbool < sym_dyn + sym_nent;
ext++, symbool++)
{
symbool->st_name = BYTE_GET(ext->st_name);
symbool->st_info = BYTE_GET(ext->st_info);
symbool->st_other = BYTE_GET(ext->st_other);
symbool->st_shndx = BYTE_GET(ext->st_shndx);
symbool->st_size = BYTE_GET(ext->st_size);
symbool->st_value = BYTE_GET(ext->st_value);
//printf("%2.2x ",sym_dyn->st_name);
}
free(exty);
return;
}
void ELF_process::get_32bit_strdyn(FILE *pFILE, Elf32_Word name) {
unsigned char sym_name[1024];
fseek(pFILE,(str_dyn_offset+name),SEEK_SET);
fread(sym_name,1024,1,pFILE);
printf("%s\n",sym_name);
}
时间： 2024-10-09 22:37:09