精华内容
下载资源
问答
  • ELF文件头结构

    千次阅读 2018-05-16 11:04:24
    转自 https://blog.csdn.net/tangyuesb/article/details/54630787ELF文件头结构定义在“/usr/include/elf.h”头文件下,ELF文件有32位版本和64位版本,故其头文件结构也有32位结构和64位结构,分别定义为Elf32_Ehdr...

    转自 https://blog.csdn.net/tangyuesb/article/details/54630787

    ELF文件头结构定义在“/usr/include/elf.h”头文件下,ELF文件有32位版本和64位版本,故其头文件结构也有32位结构和64位结构,分别定义为Elf32_Ehdr和Elf64_Ehdr。两种版本文件内容一样,只是有些成员的大小不一样。以下是32位版本的文件头结构Elf32_Ehdr。

    typedef struct{
        unsigned char e_ident[EI_NIDENT];
        Elf32_Half e_type;
        Elf32_Half e_machine;
        Elf32_Word e_version;
        Elf32_Addr e_entry;
        Elf32_Off  e_phoff;
        Elf32_Off  e_shoff;
        Elf32_Word e_flags;
        Elf32_Half e_ehsize;
        Elf32_Half e_phentsize;
        Elf32_Half e_phnum;
        Elf32_Half e_shentsize;
        Elf32_Half e_shnum;
        Elf32_Half e_shstrndx;
    }Elf32_Ehdr;

    readelf -h test.o 可得如下输出:

    ELF 头:
      Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
      类别:                              ELF32
      数据:                              2 补码,小端序 (little endian)
      版本:                              1 (current)
      OS/ABI:                            UNIX - System V
      ABI 版本:                          0
      类型:                              REL (可重定位文件)
      系统架构:                          Intel 80386
      版本:                              0x1
      入口点地址:               0x0
      程序头起点:          0 (bytes into file)
      Start of section headers:          916 (bytes into file)
      标志:             0x0
      本头的大小:       52 (字节)
      程序头大小:       0 (字节)
      Number of program headers:         0
      节头大小:         40 (字节)
      节头数量:         14
      字符串表索引节头: 11
    
    • 我们将Elf32_Ehdr结构与readelf命令输出的信息对比可得如下对应关系:
    成员readelf输出结果
    e_identMagic,类别,数据,版本,OS/ABI,ABI
    e_type类型
    e_machine系统架构
    e_version版本
    e_entry入口点地址
    e_phoffstart of program headers
    e_shoffstart of section headers
    e_flags标志
    e_ehsize文件头的大小
    e_phentsize程序头大小
    e_phnumnumber of program headers
    e_shentsize节头大小
    e_shnumnumber of program headers
    e_shstrndx字符串表段索引

    下面我们依次分析各个部分。

    魔数: 
    Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
    7f 、45、4c、46分别对应ascii码的Del(删除)、字母E、字母L、字母F。这四个字节被称为ELF文件的魔数,操作系统在加载可执行文件时会确认魔数是否正确,如果不正确则拒绝加载。 
    第五个字节标识ELF文件是32位(01)还是64位(02)的。 
    第六个字节标识该ELF文件字节序是小端(01)还是大端(02)的。 
    第七个字节指示ELF文件的版本号,一般是01。 
    后九个字节ELF标准未做定义。一般为00.

    文件类型: 
    类型: REL (可重定位文件) 
    e_type成员标识文件类型,ELF文件有三种类型,如下表所示。

    常量标识类型
    ET_REL1可重定位文件,一般位.o文件
    ET_EXEC2可执行文件
    ET_DYN3共享目标文件,一般位.so文件

    系统架构: 
    系统架构: Intel 80386 
    e_machine成员标识系统架构(机器类型),ELF定义了以下多种系统架构。可在“/usr/include/elf.h”头文件中查看,以下是其中的几种

    常量标识系统架构
    EM_M321AT&T WE 32100
    EM_SPARC2SPARC
    EM_3863Intel 80386
    EM_68K4Motorola m68k family
    EM_88K5Motorola m88k family
    EM_8606Intel 80860
    展开全文
  • ELF文件头更详细结构

    千次阅读 2017-08-03 14:37:58
    ELF文件头结构定义在“/usr/include/elf.h”头文件下,ELF文件有32位版本和64位版本,故其头文件结构也有32位结构和64位结构,分别定义为Elf32_Ehdr和Elf64_Ehdr。两种版本文件内容一样,只是有些成员的大小不一样。...

    ELF文件头结构定义在“/usr/include/elf.h”头文件下,ELF文件有32位版本和64位版本,故其头文件结构也有32位结构和64位结构,分别定义为Elf32_Ehdr和Elf64_Ehdr。两种版本文件内容一样,只是有些成员的大小不一样。以下是32位版本的文件头结构Elf32_Ehdr。

    ELF header/格式代码如下:
    #define EI_NIDENT 16
      typedef struct{
      unsigned char e_ident[EI_NIDENT];
      Elf32_Half e_type;     //它标识的是该文件的类型。
      Elf32_Half e_machine;  //表明运行该程序需要的体系结构。
      Elf32_Word e_version;  // 表示文件的版本。
      Elf32_Addr e_entry;    //程序的入口地址。
      Elf32_Off e_phoff;   //表示Program header table 在文件中的偏移量
      Elf32_Off e_shoff;   //表示Section header table 在文件中的偏移量
      Elf32_Word e_flags;   // 对IA32而言,此项为0。
      Elf32_Half e_ehsize;  //表示ELF header大小
      Elf32_Half e_phentsize;  //表示Program header table中每一个条目的大小。
      Elf32_Half e_phnum;   //表示Program header table中有多少个条目。
      Elf32_Half e_shentsize; // 表示Section header table中的每一个条目的大小
      Elf32_Half e_shnum;   //表示Section header table中有多少个条目。
      Elf32_Half e_shstrndx;  //包含节名称的字符串是第几个节(从零开始计数
      }Elf32_Ehdr;


    readelf -h libelf.o 可得如下输出:

      ELF 头:

    1. Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
    2. 类别: ELF32
    3. 数据:     2 补码,小端序 (little endian)
    4. 版本:1 (current)
    5.  OS/ABI: UNIX - System V
    6. .版本:0
    7. 类型: DYN (Share object file)
    8. 系统架构: ARM
    9. 版本:0x1
    10. 入口点地址:0x0
    11. 段头起点:52 (bytesintofile)
    12. 头起点:12616 (bytesintofile)
    13. 标志:0x5000000 ,Version5 EABI
    14. 本头的大小:52 (字节)
    15. 段头大小(每条):32(字节)
    16. 段头数量: 8
    17. 节头大小(每条)40(字节)
    18. 节头数量:22
    19. 字符串表索引节头:21





    魔数: 
    Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
    7f 、45、4c、46分别对应ascii码的Del(删除)、字母E、字母L、字母F。这四个字节被称为ELF文件的魔数,操作系统在加载可执行文件时会确认魔数是否正确,如果不正确则拒绝加载。 
    第五个字节标识ELF文件是32位(01)还是64位(02)的。 
    第六个字节标识该ELF文件字节序是小端(01)还是大端(02)的。 
    第七个字节指示ELF文件的版本号,一般是01。 
    后九个字节ELF标准未做定义。一般为00.

    文件类型: 

    e_type成员标识文件类型,ELF文件有三种类型,如下表所示。

    常量标识 类型
    ET_REL 1 可重定位文件,一般位.o文件
    ET_EXEC 2 可执行文件
    ET_DYN 3 共享目标文件,一般位.so文件

    系统架构 

      系统架构: Intel 80386、ARM等。


      


    展开全文
  • ELF文件格式(一)--ELF文件头

    千次阅读 2011-12-11 23:22:49
    ELF文件格式(一)--ELF文件头 1.ELF文件  ELF文件有三种类型:relocatable file、executable file和shared object file。  relocatable file:可重定位的目标文件,可以和其他目标文件链接成可执行的目标...

    ELF文件格式(一)--ELF文件头


    1.ELF文件
        ELF文件有三种类型:relocatable file、executable file和shared object file。
        relocatable file:可重定位的目标文件,可以和其他目标文件链接成可执行的目标文件或共享目标文件。
        executable file:可执行的目标文件,通过exec函数执行该目标文件。

        shared object file:共享目标文件,在执行可执行目标文件时动态链接器可以动态链接该文件。


    2.ELF文件格式
        ELF文件在链接和执行时具有不同的意义。
           link view        
    |-----------------------|
    |     ELF header        
    |-----------------------|
    | program header         
    |-----------------------|
    |       section1        
    |-----------------------|
    |       section2        
    |-----------------------|
    |             ...        
    |-----------------------|
    |  section header       
    |-----------------------|

       execution view
    |-----------------------|
    |     ELF header     
    |-----------------------|
    | program header
    |-----------------------|
    |       segment1
    |-----------------------|
    |       segment2
    |-----------------------|
    |            ...         
    |-----------------------|
    |  section header     
    |-----------------------|

        ELF文件包含以下几个部分:ELF header、program header、section或segment和section header。

        ELF header中记录了program header、section header的位置及大小等信息;是整个ELF文件的地图。

        program header告诉系统怎样为可执行的目标文件创建进程,可执行的ELF文件必须有program header。

        section中包含链接需要的指令、数据、符号表和重定位信息等。

        section header中记录了每个section的地址入口、名字、大小等信息,可重定位的ELF文件必须有section header。


    3.ELF文件头的格式

             ELF header
    |--------------------------|
    | 16 |   e_ident 
    |--------------------------|
    | 2   |    e_type
    |--------------------------|
    | 2   |    e_machine
    |--------------------------|
    | 4   |    e_version
    |--------------------------|
    | 4   |    e_entry
    |--------------------------|
    | 4   |    e_phoff
    |--------------------------|
    | 4   |    e_shoff
    |--------------------------|
    | 4   |    e_flags
    |--------------------------|
    | 2   |    e_ehsize
    |--------------------------|
    | 2   |    e_phentsize
    |--------------------------|
    | 2   |    e_phnum
    |--------------------------|
    | 2   |    e_shentsize
    |--------------------------|
    | 2   |    e_shnum
    |--------------------------|
    | 2   |    e_shstrndx
    |--------------------------|

    3.1 e_ident
        e_ident一共有16个字节。
        1(BYTE)    1             1              1               1             1               1                 9
        | MAG0  |  MAG1  |  MAG2  |  MAG3  |  CLASS  |  DATA  |  VERSION  |  PAD ...  |
        第一个字节为0x7f,第二个字节为'E'的十六进制的ASCII码,第三个字节为'L',第四个字节为'F'。
        CLASS字节表示文件的类型:1表示32位、2表示64位。
        DATA字节表示大小端:1表示小端、2表示大端。
        PAD共9个字节:用0填充。
    3.2 e_type
        e_type表示该目标文件的类型:1表示可重定位文件、2表示可执行文件、3表示共享目标文件、4表示Core文件。
    3.3 e_machine
        e_machine表示机器的体系结构。
        1表示AT&T WE 32100
        2表示SPARC
        3表示Intel 80386
        4表示Motorola 68000
        5表示Motorola 88000
        7表示Intel 80860
        8表示MIPS RS3000
    3.4 e_entry
        e_entry表示可执行文件的地址入口。
    3.5 e_phoff
        e_phoff表示program header在ELF文件中的偏移量。
    3.6 e_shoff
        e_shoff表示section header在ELF文件中的偏移量。
    3.7 e_ehsize
        e_ehsize表示ELF header的大小。
    3.8 e_phensize
        e_phensize表示program header中每个表项的大小。
    3.9 e_phnum
        e_phnum表示program header中表项的个数。
    3.10 e_shensize
        e_shensize表示section header中每个表项的大小。
    3.11 e_shnum
        e_shnum表示section header中表项的个数。
    3.12 e_shstrndx
        e_shstrndx表示字符串节在section header中的索引。


    附件:(读取ELF文件头,并解析)

    #ifndef READ_ELF_H
    #define READ_ELF_H
    
    /* DEBUG */
    //#define _DEBUG
    
    #ifdef _DEBUG
    #define PRINT printf
    #else
    #define PRINT
    #endif
    
    /* elf32_head: define the ELF header */
    #define EI_NIDENT   (16)
    
    struct elf32_head {
        unsigned char e_ident[EI_NIDENT];   /* the magic number  */
        unsigned short e_type;              /* identify the object file type */
        unsigned short e_machine;           /* specify the machine architechture */
        unsigned int e_version;             /* identify the object file version*/
        unsigned int e_entry;               /* entry point address of the process */
        unsigned int e_phoff;               /* start of program header */
        unsigned int e_shoff;               /* start of section header */
        unsigned int e_flags;               /* flags */
        unsigned short e_ehsize;            /* size of the ELF header */
        unsigned short e_phentsize;         /* size of program header */
        unsigned short e_phnum;             /* number of program header */
        unsigned short e_shentsize;         /* size of section header */
        unsigned short e_shnum;             /* number of section header */
        unsigned short e_shstrndx;          /* section header string table index */
    };
    
    #define ELF_HEAD_SIZE   sizeof(struct elf32_head)
    
    /* e_ident: define the magic number
     *   1(BYTE) 1     1      1       1      1        1       9
     * |MAG0| |MAG1| |MAG2| |MAG3| |CLASS| |DATA| |VERSION| |PAD ...|
     */
    #define EI_MAG0     (0)     /* 0Xf7 */
    #define EI_MAG1     (1)     /* 'E' */
    #define EI_MAG2     (2)     /* 'L' */
    #define EI_MAG3     (3)     /* 'F' */
    #define EI_CLASS    (4)
    #define EI_DATA     (5)
    #define EI_VERSION  (6)
    #define EI_PAD      (7)
    
    /* CLASS: identify the file's class */
    #define ELF_CLASS_NONE      (0)     /* Invalid class*/
    #define ELF_CLASS_32        (1)     /* 32-bit objects */
    #define ELF_CLASS_64        (2)     /* 64-bit objects */
    
    /* DATA: little or big endian */
    #define ELF_DATA_NONE       (0)     /* Invalid data encoding */
    #define ELF_DATA_LSB        (1)     /* little endian */
    #define ELF_DATA_MSB        (2)     /* big endian */
    
    /* VERSION: must be EV_CURRENT */
    #define ELF_VERSION_CURRENT (1)     /* must be EV_CURRENT */
    
    /* PAD: set to zero */
    #define ELF_PAD_VALUE       (0)     /* set to zero */
    
    /* e_type: identify the object file type */
    #define ET_NONE     (0)       /* No file type */
    #define ET_REL      (1)       /* Relocatable file */
    #define ET_EXEC     (2)       /* Executable file */
    #define ET_DYN      (3)       /* Shared object file */
    #define ET_CORE     (4)       /* Core file */
    #define ET_LOPROC   (0Xff00)  /* Processor-specific */
    #define ET_HIPROC   (0Xffff)  /* Processor-specific */
    
    /* e_machine: specify the machine architecture */
    #define EM_NONE     (0)     /* No machine */
    #define EM_M32      (1)     /* AT&T WE 32100 */
    #define EM_SPARC    (2)     /* SPARC */
    #define EM_386      (3)     /* Intel 80386 */
    #define EM_68K      (4)     /* Motorola 68000 */
    #define EM_88K      (5)     /* Motorola 88000 */
    #define EM_860      (6)     /* Intel 80860 */
    #define EM_MIPS     (7)     /* MIPS RS3000 */
    
    /* e_version: identify the object file version */
    #define EV_NONE     (0)     /* Invalid version */
    #define EV_CURRENT  (1)     /* Current version */
    
    #endif

    #include <stdio.h>
    #include <fcntl.h>
    #include "read_elf.h"
    
    #define ARGC_NUM    2
    
    static void read_elf_help(void)
    {
        printf("Usage: read_elf filename\n");
    }
    
    static void print_elf_head(struct elf32_head * elf_head)
    {
        int i = 0;
        struct elf32_head *p_elf_head = NULL;
    
        if (NULL != elf_head) {
            p_elf_head = elf_head;
        } else {
            PRINT("P_ELF_HEAD is NULL\n");
            return;
        }
    
        printf("ELF Header:\n");
    
        /* the Magic */
        printf("  Magic:");
        for (i = 0; i < EI_NIDENT; i++) {
            printf("  %02x", (p_elf_head->e_ident)[i]);
        }
        printf("\n");
    
        /* the class */
        printf("%-40s", "  Class:");
        switch ((p_elf_head->e_ident)[EI_CLASS]) {
            case ELF_CLASS_NONE:
                printf("Invalid class\n");
                break;
            case ELF_CLASS_32:
                printf("ELF32\n");
                break;
            case ELF_CLASS_64:
                printf("ELF64\n");
                break;
            default:
                printf("0X%x (Unknown)\n", (p_elf_head->e_ident)[EI_CLASS]);
                break;
        }
    
        /* the data */
        printf("%-40s", "  Data:");
        switch ((p_elf_head->e_ident)[EI_DATA]) {
            case ELF_DATA_NONE:
                printf("Invalid data encoding\n");
                break;
            case ELF_DATA_LSB:
                printf("little endian\n");
                break;
            case ELF_DATA_MSB:
                printf("big endian\n");
                break;
            default:
                printf("0X%x (Unknown)\n", (p_elf_head->e_ident)[EI_DATA]);
                break;
        }
    
        /* the version */
        printf("%-40s", "  Version:");
        if (ELF_VERSION_CURRENT == (p_elf_head->e_ident)[EI_VERSION]) {
            printf("1 (current)\n");
        } else {
            printf("0X%x (Unknown)\n", (p_elf_head->e_ident)[EI_VERSION]);
        }
    
        /* the Type */
        printf("%-40s", "  Type:");
        switch(p_elf_head->e_type) {
            case ET_NONE:
                printf("NONE\n");
                break;
            case ET_REL:
                printf("REL\n");
                break;
            case ET_EXEC:
                printf("EXEC\n");
                break;
            case ET_DYN:
                printf("DYN\n");
                break;
            case ET_CORE:
                printf("CORE\n");
                break;
            case ET_LOPROC:
                printf("LOPROC\n");
                break;
            case ET_HIPROC:
                printf("HIPROC\n");
                break;
            default:
                printf("0X%x (Unknown)\n", p_elf_head->e_type);
                break;
        }
    
        /* the Machine */
        printf("%-40s", "  Machine:");
        switch (p_elf_head->e_machine) {
            case EM_NONE:
                printf("No machine\n");
                break;
            case EM_M32:
                printf("AT&T WE 32100\n");
                break;
            case EM_SPARC:
                printf("SPARC\n");
                break;
            case EM_386:
                printf("Intel 80386\n");
                break;
            case EM_68K:
                printf("Motorola 68000\n");
                break;
            case EM_88K:
                printf("Motorola 88000\n");
                break;
            case EM_860:
                printf("Intek 80860\n");
                break;
            case EM_MIPS:
                printf("MIPS RS3000\n");
                break;
            default:
                printf("0X%x (Unknown)\n", p_elf_head->e_machine);
                break;
        }
    
        /* the Version */
        printf("%-40s", "  Version:");
        switch (p_elf_head->e_version) {
            case EV_NONE:
                printf("Invalid version\n", p_elf_head->e_version);
                break;
            case EV_CURRENT:
                printf("Current version\n", p_elf_head->e_version);
                break;
            default:
                printf("0X%x (Unknown)\n", p_elf_head->e_version);
                break;
        }
    
        /* the entry point of process */
        printf("%-40s", "  Entry point address:");
        printf("0X%x\n", p_elf_head->e_entry);
    
        /* the start of program headers */
        printf("%-40s", "  Start of program headers:");
        printf("%d (bytes)\n", p_elf_head->e_phoff);
    
        /* the start of section headers */
        printf("%-40s", "  Start of section headers:");
        printf("%d (bytes)\n", p_elf_head->e_shoff);
    
        /* the flags */
        printf("%-40s", "  Flags: ");
        printf("0X%x\n", p_elf_head->e_flags);
    
        /* the size of this header */
        printf("%-40s", "  Size of this header:");
        printf("%d (bytes)\n", p_elf_head->e_ehsize);
    
        /* the size of program headers */
        printf("%-40s", "  Size of program headers:");
        printf("%d (bytes)\n", p_elf_head->e_phentsize);
    
        /* the number of program headers */
        printf("%-40s", "  Number of program headers:");
        printf("%d\n", p_elf_head->e_phnum);
    
        /* the size of section headers */
        printf("%-40s", "  Size of section headers:");
        printf("%d (bytes)\n", p_elf_head->e_shentsize);
    
        /* the number of section headers */
        printf("%-40s", "  Number of section headers:");
        printf("%d\n", p_elf_head->e_shnum);
    
        /* the section header string table index */
        printf("%-40s", "  Section header string table index:");
        printf("%d\n", p_elf_head->e_shstrndx);
    }
    
    int main(int argc, const char *argv[])
    {
        int fd = 0;
        char buf[ELF_HEAD_SIZE] = {0};
        struct elf32_head *p_elf_head = NULL;
    
        if (ARGC_NUM != argc) {
            read_elf_help();
            return(0);
        }
    
        if (-1 == (fd = open(argv[1], O_RDONLY))) {
            printf("open %s ERR!\n", argv[1]);
        }
    
        if (ELF_HEAD_SIZE != read(fd, buf, ELF_HEAD_SIZE)) {
            printf("ELF head length is incorrect!\n");
            return(0);
        }
    
        p_elf_head = (struct elf32_head *) buf;
        print_elf_head(p_elf_head);
    
        return(0);
    }
    



    展开全文
  • 编程读取ELF文件头

    千次阅读 2016-05-29 10:54:03
    一个C语言源程序(.c文件)经过汇编以后生成目标文件(.o文件),目标文件再经过链接生成...ELF文件的格式如下图所示,以文件头(ELF Header)开始,后面跟着代码段(.text)、数据段(.data)等。   ELF Header

        一个C语言源程序(.c文件)经过汇编以后生成目标文件(.o文件),目标文件再经过链接生成可执行文件。在linux系统中,目标文件和可执行文件都是ELF格式的,了解ELF文件的结构对于理解程序的编译、链接和装载运行至关重要。ELF文件的格式如下图所示,以文件头(ELF Header)开始,后面跟着代码段(.text)、数据段(.data)等。

     

    ELF Header

    .text

    .data

    .bss

    .rodata

    Other sections

    Section header table

    String Tables

    Symbol Tables

     

        文件头中保存着文件的基本属性,要解析整个ELF文件,必须从文件头开始。下面自己编写一个小程序来读取ELF文件头,它的功能等价于Linux提供的命令readelf  -h  xxx.o。自己写代码实现这些命令能加深对ELF文件结构的理解。

     

        ELF文件头的结构定义在/usr/include/elf.h文件中,分32位和64位两种:

    32位:

    typedef struct

    {

        unsigned char     e_ident[EI_NIDENT];      /* Magic number and other info */

        Elf32_Half        e_type;                  /* Object file type */

        Elf32_Half        e_machine;               /* Architecture */

        Elf32_Word        e_version;               /* Object file version */

        Elf32_Addr        e_entry;                 /* Entry point virtual address */

        Elf32_Off         e_phoff;                 /* Program header table file offset */

        Elf32_Off         e_shoff;                 /* Section header table file offset */

        Elf32_Word        e_flags;                 /* Processor-specific flags */

        Elf32_Half        e_ehsize;                /* ELF header size in bytes */

        Elf32_Half        e_phentsize;             /* Program header table entry size*/

        Elf32_Half        e_phnum;                 /* Program header table entrycount */

        Elf32_Half        e_shentsize;             /* Section header table entry size*/

        Elf32_Half        e_shnum;                 /* Section header table entrycount */

        Elf32_Half        e_shstrndx;              /* Section header string tableindex */

    } Elf32_Ehdr;

     

    64位:

    typedef struct

    {

        unsigned char     e_ident[EI_NIDENT];      /* Magic number and other info */

        Elf64_Half        e_type;                  /*Object file type */

        Elf64_Half        e_machine;               /*Architecture */

        Elf64_Word        e_version;               /* Object file version */

        Elf64_Addr        e_entry;                 /* Entry point virtual address */

        Elf64_Off         e_phoff;                 /* Programheader table file offset */

        Elf64_Off         e_shoff;                 /* Sectionheader table file offset */

        Elf64_Word        e_flags;                 /*Processor-specific flags */

        Elf64_Half        e_ehsize;                /* ELF header sizein bytes */

        Elf64_Half        e_phentsize;             /* Program header table entry size */

        Elf64_Half        e_phnum;                 /* Program header table entry count */

        Elf64_Half        e_shentsize;             /* Section header table entry size */

        Elf64_Half        e_shnum;                 /* Section header table entry count */

        Elf64_Half        e_shstrndx;              /* Section header string table index */

    } Elf64_Ehdr;

     

        因为我的ubuntulinux是64位的操作系统,所以下面的程序中,我用的是Elf64_Ehdr类型的结构体elfheader来存储文件头。其中,Elf64_Half是unsigned short int类型(2字节),Elf64_Word是unsigned int类型(4字节),Elf64_Addr是unsigned long int类型(8字节),Elf64_Off是unsigned long int类型(8字节)。程序以只读方式(r或者rb模式)打开目标文件elftest2.o,然后用fread函数从文件中读出一块大小为sizeof(Elf64_Ehdr)(64字节)的内容到elfheader中,最后把文件头中每一部分打印输出。

     

    //read_ELFheader.c (ubuntu)

     

    #include "stdio.h"

    #include "/usr/include/elf.h"

    int main()

    {

             FILE * fp;

             int i;

             Elf64_Ehdr elfheader;

             fp= fopen("elftest2.o","r");

             fread(&elfheader,sizeof(Elf64_Ehdr),1,fp);

             for(i=0;i<16; i++)

                      printf("%x",elfheader.e_ident[i]);

             printf("\n");

             printf("%hx\n", elfheader.e_type);

             printf("%hx\n", elfheader.e_machine);

             printf("%x\n",  elfheader.e_version);

             printf("%lx\n", elfheader.e_entry);

             printf("%lx\n", elfheader.e_phoff);

             printf("%lx\n", elfheader.e_shoff);

             printf("%x\n",  elfheader.e_flags);

             printf("%hx\n", elfheader.e_ehsize);

             printf("%hx\n", elfheader.e_phentsize);

             printf("%hx\n", elfheader.e_phnum);

             printf("%hx\n", elfheader.e_shentsize);

             printf("%hx\n", elfheader.e_shnum);

             printf("%hx\n", elfheader.e_shstrndx);

             return 0;

    } 

        

        读取了文件头以后,就可以利用elfheader.e_shoff (段表的偏移)来进一步读取段表,从而对各个段进行解析。

    展开全文
  • ELF目标文件格式的最前部是ELF文件头(ELF Header),它包含了描述整个文件的基本属性,比如ELF文件版本、目标机器类型、程序入口地址等,紧接着是ELF文件各个段。ELF文件中与段最有关的数据结构就是段表(Section ...
  • ELF文件头分析

    千次阅读 2014-12-20 15:24:07
    ELF Header Some object file control structures can grow, because the ELF header contains their actual sizes. If the object file format changes, a program may encounter control structures that are lar...
  • ELF文件头读取修改

    千次阅读 2012-03-12 10:30:04
    ELF = Executable and Linkable Format,可执行连接格式,是UNIX...ELF 文件有三种类型:可重定位文件:也就是通常称的目标文件,后缀为.o。共享文件:也就是通常称的库文件,后缀为.so。可执行文件:本文主要讨论的
  • ART世界探险(11) - OAT文件格式分析(1) - ELF文件头(上) 既然是要探险,咱们就保持一定的深度,起码将来可以做个基于ART的黑客之类的。所以我们针对细节多下一些工夫,先仔细分析一下OAT文件的格式。ART的本质上是...
  • Bfd对elf文件头的处理

    千次阅读 2008-11-27 10:23:00
    快乐虾http://blog.csdn.net/lights_joy/lights@hb165.com 本文适用于bfinutils-2.19vs2008 欢迎转载,但请保留作者信息 1.1 数值转换在elf文件中,最开始的就是文件头,用结构体表示就是:typedef struct { ...
  • ELF中的section和segment
  • ELF 文件有三种类型:可重定位文件:也就是通常称的目标文件,后缀为.o。共享文件:也就是通常称的库文件,后缀为.so。可执行文件:本文主要讨论的文件格 ...一个典型的ELF文件有两种描述视图:progra...
  • ELF文件头表示 文件头中含有整个文件的结构信息,包括一些控制单元的大小。可以用以下这个数据结构体来描述文件头: #define EI_NIDENT 16 typedef struct { unsigned char e_ident[EI_NIDENT]; Elf32_Half e_...
  • ELF文件类型 首先ELF文件可以被标记为以下几个类型: ET_NONE:未知类型。 ET_REL:重定位文件,类型标记为relocatable意为着该文件被标记为了一段可重定位的代码段,有时也称为目标文件。可重定位目标文件通常是还...
  • 前面章节我们了解了ELF文件的头部结构,这次我们深入了解另一个非常重要的数据结构,那就是程序表头。操作系统严重依赖该结构来加载ELF文件或是实现动态链接。程序表头反映的是当ELF加载到内存后所形成的“视图”或...
  • ELF文件

    2013-12-14 19:50:00
     图中显示了ELF可重定位文件的构成,ELF文件头的开始16个字节描述了文件中字的大小和字节序(大端模式还是小端模式)。文件头还包含了ELF头的大小,文件类型(可重定位,可执行和共享),机器类型,节头表的位置和...
  • ELF文件格式头部

    2018-03-08 18:58:38
    ELF格式文件格式头部
  • Linux ELF文件

    2021-02-20 13:55:52
    ELF全称:可执行链接格式,是UNIX系统实验室(USL)作为应用程序二进制接口(Application Binary Interface,ABI)而开发和发布的。ELF文件有三种不同类型: 可重定位文件:包含...文件最前部为ELF文件头,描述了整
  • ELF文件结构

    2020-08-10 23:30:39
     图中显示了ELF可重定位文件的构成,ELF文件头的开始16个字节描述了文件中字的大小和字节序(大端模式还是小端模式)。文件头还包含了ELF头的大小,文件类型(可重定位,可执行和共享),机器类型,节头表的位置和...
  • elf文件结构解析

    2019-08-02 21:52:28
    elf文件解析1、ELF文件结构格式:2、ELF头文件解析:3、ELF段表: 1、ELF文件结构格式: ELF Header ...elf文件头包含了整个文件的基本属性,如文件版本,入口地址等,接着就是ELF文件的各个...
  • ELF文件结构描述

    2019-10-24 16:20:31
    ELF目标文件格式最前部ELF文件头(ELF Header),它包含了描述了整个文件的基本属性,比如ELF文件版本、目标机器型号、程序入口地址等。其中ELF文件与段有关的重要结构就是段表(Section Header Tab...
  • ELF文件中可以包含很多“节”(section),所有这些“节”都记录在一张称为“节头表”(section header table)的数组里。节头表的每一个表项是一个 Elf32_Shdr 结构,通过每一个表项可以定位到对应的节。 在 ELF 文件...
  • ELF文件与链接

    2019-06-22 15:31:36
    什么是ELF文件 ELF文件头部格式 ELF在计算机科学中,是一种用于二进制文件、可执行文件、目标代码、共享库和核心转储格式文件。是UNIX系统实验室(USL)作为应用程序二进制接口(Application Binary Interface,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,544
精华内容 6,617
关键字:

elf文件头