读取ELF文件

/* elfparse.c - gcc elfparse.c -o elfparse */

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main(int argc, char **argv)
{
    int fd, i;
    uint8_t *mem;
    struct stat st;
    char *StringTable, *interp;

    Elf64_Ehdr *ehdr;//ELF file header
    Elf64_Phdr *phdr;//program header
    Elf64_Shdr *shdr;//section header

    if(argc < 2){
        printf("Usage: %s \n", argv[0]);
        exit(0);
    }

    printf("Elf64_Ehdr size: %d\n", sizeof(Elf64_Ehdr));

    if((fd = open(argv[1], O_RDONLY)) < 0){
        perror("open");
        exit(-1);
    }

    if(fstat(fd, &st) < 0){
        perror("fstat");
        exit(-1);
    }

    /* Map the executable into memory */
    mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if(mem == MAP_FAILED){/*mmap may have many fuctions. I read*/
        perror("mmap");/*a blog, share memory, Changing disk to*/
        exit(-1);/*memory when memory is not enough may all use*/
    }/*mmap(). This is real mapping. This is the blog address: */
    /*https://blog.csdn.net/yanerhao/article/details/77829191  */

    /**
     * The initial ELF Header starts at offset 0
     * of our mapped memory
     */
    ehdr = (Elf64_Ehdr*)mem;

    /**
     * The shdr table and phdr table offsets are
     * given by e_shoff and e_phoff members of the
     * Elf64_Ehdr
     */
    phdr = (Elf64_Phdr*)&mem[ehdr->e_phoff];
    shdr = (Elf64_Shdr*)&mem[ehdr->e_shoff];

    /**
     * Check to see if the ELF magic (The first 4 bytes)
     * match up as 0x7f E L F (0x7f 45 4c 46)
     */
    if(mem[0] != 0x7f && strcmp(&mem[1], "ELF")){
        fprintf(stderr, "%s is not an ELF file\n", argv[1]);
        exit(-1);
    }

    /**
     * We are only parsing executables with this code
     * so ET_EXEC marks an executables.
     */
//    if(ehdr->e_type != ET_EXEC){
//        fprintf(stderr, "%s is not an executable\n", argv[1]);
//        exit(-1);
//    }

    printf("Program Entry point: 0x%x\n", ehdr->e_entry);

    /**
     * We find the string table for the section header
     * names with e_shstrndx which gives the index of
     * which section holds the string table.
     * e_shstrndx is the index of section .shstrtab
     * .shstrtab holds all sections's name, just a strings
     * ending with /0.
     */
    StringTable = &mem[shdr[ehdr->e_shstrndx].sh_offset];
    /**
      * Print each section header name and address.
      * Notice we get the index into the string table
      * that contains each section header name with
      * the shdr.sh_name member.
      */
    printf("Section header total:%d list:\n\n", ehdr->e_shnum);
    for(i = 0; i < ehdr->e_shnum; i++)
        printf("[%d]%s: 0x%x\n", i, &StringTable[shdr[i].sh_name], shdr[i].sh_addr);

    /**
      * Print out each segment name, and address.
      * Except for PT_INTERP we print the path to
      * the dynamic linker (Interpreter).
      */
    printf("\nProgram header total:%d list:\n\n", ehdr->e_phnum);
    for(i = 0; i < ehdr->e_phnum; i++){
        //         printf("phdr[%d].p_type=%d\n", i, phdr[i].p_type);
        switch(phdr[i].p_type){
        case PT_LOAD:
            /**
                  * We know that text segment starts
                  * at offset 0. And only one other
                  * possible loadable segment exists
                  * which is the data segment.
                  */
            // if(phdr[i].p_offset == 0)
            if (0 != (phdr[i].p_flags == (PF_X | PF_R))) {
                char *pp = &mem[phdr[i].p_offset];
                printf("Text segment: 0x%x  flag:%d\n", phdr[i].p_vaddr, phdr[i].p_flags);
            }
            else
                printf("Data segment: 0x%x  flag:%d\n",phdr[i].p_vaddr, phdr[i].p_flags);
            break;
        case PT_INTERP:
            interp = strdup((char*)&mem[phdr[i].p_offset]);
            printf("Interpreter: %s\n", interp);
            break;
        case PT_NOTE:
            printf("Note segment: 0x%x\n", phdr[i].p_vaddr);
            break;
        case PT_DYNAMIC:
            printf("Dynamic segment: 0x%x\n", phdr[i].p_vaddr);
            break;
        case PT_PHDR:
            printf("Phdr segment: 0x%x\n", phdr[i].p_vaddr);
            break;
        case PT_GNU_EH_FRAME:
            printf("GCC .eh_frame_hdr segment: 0x%x\n", phdr[i].p_vaddr);
            break;
        case PT_GNU_STACK:
            printf("Indicates stack executability: 0x%x\n", phdr[i].p_vaddr);
            break;
        case PT_GNU_RELRO:
            printf("Read-only after relocation: 0x%x\n", phdr[i].p_vaddr);
            break;
        case PT_TLS:
            printf("Thread-local storage segment: 0x%x\n", phdr[i].p_vaddr);
            break;
        default:
            printf("type:%d, %x\n", phdr[i].p_type, phdr[i].p_type);
            break;
        }
    }

    exit(0);
}