linux下的三种可执行文件格式的比较

[font=Times New][size=2][color=#000000]本文讨论了 UNIX/LINUX 平台下三种主要的可执行文件格式：a.out（assembler and link editor output 汇编器和链接编辑器的输出）、COFF（Common Object File Format 通用对象文件格式）、ELF（Executable and Linking Format 可执行和链接格式）。首先是对可执行文件格式的一个综述，并通过描述 ELF 文件加载过程以揭示可执行文件内容与加载运行操作之间的关系。随后依此讨论了此三种文件格式，并着重讨论 ELF 文件的动态连接机制，其间也穿插了对各种文件格式优缺点的评价。最后对三种可执行文件格式有一个简单总结，并提出作者对可文件格式评价的一些感想。 [/color][/size][/font]!I|5d9C4{7DN
[font=Times New][size=2][color=#000000][b]可执行文件格式综述[/b] [/color][/size][/font]
;Wg9[ ^2GY"Q [font=Times New][size=2][color=#000000]相对于其它文件类型，可执行文件可能是一个操作系统中最重要的文件类型，因为它们是完成操作的真正执行者。可执行文件的大小、运行速度、资源占用情况以及可扩展性、可移植性等与文件格式的定义和文件加载过程紧密相关。研究可执行文件的格式对编写高性能程序和一些黑客技术的运用都是非常有意义的。 [/color][/size][/font]
#w v ?o'aqc [font=Times New][size=2][color=#000000]不管何种可执行文件格式，一些基本的要素是必须的，显而易见的，文件中应包含代码和数据。因为文件可能引用外部文件定义的符号（变量和函数），因此重定位信息和符号信息也是需要的。一些辅助信息是可选的，如调试信息、硬件信息等。基本上任意一种可执行文件格式都是按区间保存上述信息，称为段（Segment）或节（Section）。不同的文件格式中段和节的含义可能有细微区别，但根据上下文关系可以很清楚的理解，这不是关键问题。最后，可执行文件通常都有一个文件头部以描述本文件的总体结构。 [/color][/size][/font]:gJ5gw%aD[-D*]
[font=Times New][size=2][color=#000000]相对可执行文件有三个重要的概念：编译（compile）、连接（link，也可称为链接、联接）、加载（load）。源程序文件被编译成目标文件，多个目标文件被连接成一个最终的可执行文件，可执行文件被加载到内存中运行。因为本文重点是讨论可执行文件格式，因此加载过程也相对重点讨论。下面是LINUX 平台下ELF文件加载过程的一个简单描述。 [/color][/size][/font]"w$l7_8T!Q8mv j?
[font=Times New][size=2][color=#000000]1：内核首先读ELF文件的头部，然后根据头部的数据指示分别读入各种数据结构，找到标记为可加载（loadable）的段，并调用函数 mmap()把段内容加载到内存中。在加载之前，内核把段的标记直接传递给 mmap()，段的标记指示该段在内存中是否可读、可写，可执行。显然，文本段是只读可执行，而数据段是可读可写。这种方式是利用了现代操作系统和处理器对内存的保护功能。著名的Shellcode（参考资料 17）的编写技巧则是突破此保护功能的一个实际例子。 [/color][/size][/font]
6]al,pUJD [font=Times New][size=2][color=#000000]2：内核分析出ELF文件标记为 PT_INTERP 的段中所对应的动态连接器名称，并加载动态连接器。现代 LINUX 系统的动态连接器通常是 /lib/ld-linux.so.2，相关细节在后面有详细描述。 [/color][/size][/font]'B-`kv3O3Rf
[font=Times New][size=2][color=#000000]3：内核在新进程的堆栈中设置一些标记-值对，以指示动态连接器的相关操作。 [/color][/size][/font]
(@O ^'~t;yv ]?e [font=Times New][size=2][color=#000000]4：内核把控制传递给动态连接器。 [/color][/size][/font]
oeE]M [font=Times New][size=2][color=#000000]5：动态连接器检查程序对外部文件（共享库）的依赖性，并在需要时对其进行加载。 [/color][/size][/font]
H7Xv G1S_6_0f [font=Times New][size=2][color=#000000]6：动态连接器对程序的外部引用进行重定位，通俗的讲，就是告诉程序其引用的外部变量/函数的地址，此地址位于共享库被加载在内存的区间内。动态连接还有一个延迟（Lazy）定位的特性，即只在"真正"需要引用符号时才重定位，这对提高程序运行效率有极大帮助。 [/color][/size][/font]
%Ry[Nml%s8W*z [font=Times New][size=2][color=#000000]7：动态连接器执行在ELF文件中标记为 .init 的节的代码，进行程序运行的初始化。在早期系统中，初始化代码对应函数 _init(void)(函数名强制固定)，在现代系统中，则对应形式为 [/color][/size][/font]
C/|;eac%H&c [size=2][table=400][tr][td]void
F-nS P9G __attribute((constructor))
!\ f*n3I4s0[L,[C init_function(void)
GU3?sV5i {6`gL@*`$@|
……H)K"s-kW%A l
xn
}[/td][/tr][/table][/size][font=Times New][size=2][color=#000000]其中函数名为任意。 [/color][/size][/font]

8：动态连接器把控制传递给程序，从 ELF 文件头部中定义的程序进入点开始执行。在 a.out 格式和ELF格式中，程序进入点的值是显式存在的，在 COFF 格式中则是由规范隐含定义。
pg m|};c1_:g+];o
D(^M%Kq3e~P"~ 从上面的描述可以看出，加载文件最重要的是完成两件事情：加载程序段和数据段到内存；进行外部定义符号的重定位。重定位是程序连接中一个重要概念。我们知道，一个可执行程序通常是由一个含有 main() 的主程序文件、若干目标文件、若干共享库（Shared Libraries）组成。（注：采用一些特别的技巧，也可编写没有 main 函数的程序，请参阅参考资料 2）一个 C 程序可能引用共享库定义的变量或函数，换句话说就是程序运行时必须知道这些变量/函数的地址。在静态连接中，程序所有需要使用的外部定义都完全包含在可执行程序中，而动态连接则只在可执行文件中设置相关外部定义的一些引用信息，真正的重定位是在程序运行之时。静态连接方式有两个大问题：如果库中变量或函数有任何变化都必须重新编译连接程序；如果多个程序引用同样的变量/函数，则此变量/函数会在文件/内存中出现多次，浪费硬盘/内存空间。比较两种连接方式生成的可执行文件的大小，可以看出有明显的区别。
x5y tj;e[&r0c _ dAJot,h$UR
a.out 文件格式分析

I9X ]S&qax L1dVrX/Rn
a.out 格式在不同的机器平台和不同的 UNIX 操作系统上有轻微的不同，例如在 MC680x0 平台上有 6 个 section。下面我们讨论的是最"标准"的格式。
]o{sJ#E8v rcH ~Y.|h1O'D+f
a.out 文件包含 7 个 section，格式如下： @0I_}2y(\N5`]

@,DOX*\|*V)?4T exec header（执行头部，也可理解为文件头部）Xu2nT kL,a\:t
2|+q%~F2h-bY$u/Q
text segment（文本段）*y \(x9y^4A
,P,SM?T-g0N3`a
data segment(数据段)B` s|_
p'y)FC4c i {y'J&|1N2O#q(}
text relocations(文本重定位段)$j8aCd_
hD1g{w(a}
data relocations（数据重定位段）
M&cx6U"h Hlj)H:P"F-e (s[/n#U`6U_
symbol table（符号表）
[}9G:pw%P qo
S`jS}C1E string table（字符串表）
oxy}-^px']
dhdaqe~
F"] 执行头部的数据结构：
-w0XhEi*vx 9R#r9A
T&K E
struct exec {
&qz n#Pow         unsigned long   a_midmag;    /* 魔数和其它信息 */(v6cch"Ac
        unsigned long   a_text;      /* 文本段的长度 */ K o1]/pJ!_;h`
        unsigned long   a_data;      /* 数据段的长度 */
O'Z!hz1U `&G:W         unsigned long   a_bss;       /* BSS段的长度 */Q:k~#|Q;EL
        unsigned long   a_syms;      /* 符号表的长度 */?9C px8C:pT9?,v0HF
        unsigned long   a_entry;     /* 程序进入点 */NRgg;o@A~
        unsigned long   a_trsize;    /* 文本重定位表的长度 */
]P|[dicx)OXgT         unsigned long   a_drsize;    /* 数据重定位表的长度 */|6x.g^F
KgR
};
q"m'{-b#T;tj
EnT.Zu$MU 文件头部主要描述了各个 section 的长度，比较重要的字段是 a_entry（程序进入点），代表了系统在加载程序并初试化各种环境后开始执行程序代码的入口。这个字段在后面讨论的 ELF 文件头部中也有出现。由 a.out 格式和头部数据结构我们可以看出，a.out 的格式非常紧凑，只包含了程序运行所必须的信息（文本、数据、BSS），而且每个 section 的顺序是固定的。这种结构缺乏扩展性，如不能包含"现代"可执行文件中常见的调试信息，最初的 UNIX 黑客对 a.out 文件调试使用的工具是 adb，而 adb 是一种机器语言调试器！ LdeLinux联盟
&|dI@h5T
wf"?3WS+X a.out 文件中包含符号表和两个重定位表，这三个表的内容在连接目标文件以生成可执行文件时起作用。在最终可执行的 a.out 文件中，这三个表的长度都为 0。a.out 文件在连接时就把所有外部定义包含在可执行程序中，如果从程序设计的角度来看，这是一种硬编码方式，或者可称为模块之间是强藕和的。在后面的讨论中，我们将会具体看到ELF格式和动态连接机制是如何对此进行改进的。
+W(kDV6q
0f?KL]"t,_"~5i a.out 是早期UNIX系统使用的可执行文件格式，由 AT&T 设计，现在基本上已被 ELF 文件格式代替。a.out 的设计比较简单，但其设计思想明显的被后续的可执行文件格式所继承和发扬。可以参阅参考资料 16 和阅读参考资料 15 源代码加深对 a.out 格式的理解。参考资料 12 讨论了如何在"现代"的红帽LINUX运行 a.out 格式文件。9_ Y.`w wMc

3Z3_'[#hC\j COFF 文件格式分析"Uy
}h0n?]
'X'YBs2V4g
COFF 格式比 a.out 格式要复杂一些，最重要的是包含一个节段表(section table)，因此除了 .text，.data，和 .bss 区段以外，还可以包含其它的区段。另外也多了一个可选的头部，不同的操作系统可一对此头部做特定的定义。
`/d!?_bM cBl9b/G#iqr5g%}
COFF 文件格式如下：
B U7e{mSx
H*bD;LTbY1hN&A e File Header(文件头部)`{%umt@%SBg@
Optional Header(可选文件头部)2Fd bWL WL8kz
Section 1 Header(节头部)
9X"Q8T:Z Z ………
([yWz~!^V#u)o0R|5fz Section n Header(节头部)
"YLe mdyRi H Raw Data for Section 1(节数据)
,B\Q yBVr5s Raw Data for Section n(节数据)
y2o2y.H&J0bk:Yr Relocation Info for Sect. 1(节重定位数据)
'{2tDq{"g-F#o? Relocation Info for Sect. n(节重定位数据)
K i0V1g7S%n t Line Numbers for Sect. 1(节行号数据)
*D b n?$gp\ Line Numbers for Sect. n(节行号数据)
?$SW$i7P]9Zk4T Symbol table(符号表)@u7vcvU7o E)W
String table(字符串表)
K gGXB)b4goh Z8uK@h$D
文件头部的数据结构：
e&OT8Ov
d;UZ,n-Fzs^
struct filehdr2o2XE&RK W.cSV
   {H3s:]K{~
     unsigned short  f_magic;    /* 魔数 */
.}6RR#kd-SD        unsigned short  f_nscns;    /* 节个数 */fdJ_mA$t5x h
       long            f_timdat;   /* 文件建立时间 */^+zc9@6o:n s/pzO7S
       long            f_symptr;   /* 符号表相对文件的偏移量 */Uxk7Fv0G:V1L
       long            f_nsyms;    /* 符号表条目个数 */
lq`!f2?.f        unsigned short  f_opthdr;   /* 可选头部长度 */
J1`x? _n        unsigned short  f_flags;    /* 标志 */
H&W]bO7zM    };
7Ywn
^*G
4c Md E#sgR`Y9v COFF 文件头部中魔数与其它两种格式的意义不太一样，它是表示针对的机器类型，例如 0x014c 相对于 I386 平台，而 0x268 相对于 Motorola 68000系列等。当 COFF 文件为可执行文件时，字段 f_flags 的值为 F_EXEC（0X00002），同时也表示此文件没有未解析的符号，换句话说，也就是重定位在连接时就已经完成。由此也可以看出，原始的 COFF 格式不支持动态连接。为了解决这个问题以及增加一些新的特性，一些操作系统对 COFF 格式进行了扩展。Microsoft 设计了名为 PE（Portable Executable）的文件格式，主要扩展是在 COFF 文件头部之上增加了一些专用头部，具体细节请参阅参考资料 18，某些 UNIX 系统也对 COFF 格式进行了扩展，如 XCOFF（extended common object file format）格式，支持动态连接，请参阅参考资料 5。

紧接文件头部的是可选头部，COFF 文件格式规范中规定可选头部的长度可以为 0，但在 LINUX 系统下可选头部是必须存在的。下面是 LINUX 下可选头部的数据结构：fc V)_p y*|
e1_3B6I\wR2z
typedef struct {hnk
cji;m
{ S W6a ~7|(Zf^
    char   magic[2];    /* 魔数 */mUf^5CA
    char   vstamp[2];    /* 版本号 */
]op"m'arr~     char   tsize[4];    /* 文本段长度 */
K7U*GD;b(x%H     char   dsize[4];    /* 已初始化数据段长度 */
/[0Z%St)uY Mh     char   bsize[4];    /* 未初始化数据段长度 */
m)Z*f\u5F     char   entry[4];    /* 程序进入点 */&Qa4Pn:_n zt'SA5~
    char   text_start[4];       /* 文本段基地址 */(E,C(\mv9L%d3U(pgR
    char   data_start[4];       /* 数据段基地址 */
^mg NJ(t }
R&i7Br2oU(c COFF_AOUTHDR;
I.x"ZL3J$G 2^!~]p.n2{N/k
字段 magic 为 0413 时表示 COFF 文件是可执行的，注意到可选头部中显式定义了程序进入点，标准的 COFF 文件没有明确的定义程序进入点的值，通常是从 .text 节开始执行，但这种设计并不好。
\Kx N*|'v6R
,HS ZYgZ 前面我们提到，COFF 格式比 a.out 格式多了一个节段表，一个节头条目描述一个节数据的细节，因此 COFF 格式能包含更多的节，或者说可以根据实际需要，增加特定的节，具体表现在 COFF 格式本身的定义以及稍早提及的 COFF 格式扩展。我个人认为，节段表的出现可能是 COFF 格式相对 a.out 格式最大的进步。下面我们将简单描述 COFF 文件中节的数据结构，因为节的意义更多体现在程序的编译和连接上，所以本文不对其做更多的描述。此外，ELF 格式和 COFF格式对节的定义非常相似，在随后的 ELF 格式分析中，我们将省略相关讨论。
1f&]0C#P,j0s^$b#t-~Q y:vp|'JF,k
struct COFF_scnhdr 4|3s?1iP8GDX{
{r,D4F6O;k\g
    char s_name[8];     /* 节名称 */
-Df}]d     char s_paddr[4];    /* 物理地址 */3b BjI$R2Q4mP4U$|
   char s_vaddr[4];    /* 虚拟地址 */u/j2[6jjJ
    char s_size[4];     /* 节长度 */j)|GoRlN,vO
   char s_scnptr[4];    /* 节数据相对文件的偏移量 */
FqYebu
    char s_relptr[4];    /* 节重定位信息偏移量 */
A8bE0R}_8ob8D;[     char s_lnnoptr[4];    /* 节行信息偏移量 */
.Eui5o0G     char s_nreloc[2];    /* 节重定位条目数 */
/]t#V ? uf#}     char s_nlnno[2];    /* 节行信息条目数 */
3@#mZ&]#T     char s_flags[4];    /* 段标记 */%H*Kd6g Hxj!F0i
};
+Su:X/a(mq ^F &X8iAD!]D%r[3s
有一点需要注意：LINUX系统中头文件coff.h中对字段 s_paddr的注释是"physical address"，但似乎应该理解为"节被加载到内存中所占用的空间长度"。字段s_flags标记该节的类型，如文本段、数据段、BSS段等。在 COFF的节中也出现了行信息，行信息描述了二进制代码与源代码的行号之间的对映关系，在调试时很有用。
(D"mk^0|$_ _ BF(Zo {N$Z8^7B
参考资料 19是一份对COFF格式详细描述的中文资料，更详细的内容请参阅参考资料 20。CKA$t"m$@8{
+@y*I W\:M F4ee
ELF文件格式分析#r$Z!J8G]N+G
zx!dUw3D
S$q
ELF 文件有三种类型：可重定位文件：也就是通常称的目标文件，后缀为.o。共享文件：也就是通常称的库文件，后缀为.so。可执行文件：本文主要讨论的文件格式，总的来说，可执行文件的格式与上述两种文件的格式之间的区别主要在于观察的角度不同：一种称为连接视图（Linking View），一种称为执行视图（Execution View）。l&gyU.L6P(C o
9l"d.R0u cJ5a Y
首先看看ELF文件的总体布局：'HQI%X9BT*S/I

l;ggA.Hj0gg ELF header(ELF头部):izh)z+]#b$nC4s
Program header table(程序头表)
dp~-[7SXC ~6z Segment1（段1）bGjz1\b8o
Segment2（段2）
&Tu,a]V1H^#vf1cY ………M9F%qt_
Sengmentn（段n）
(? Lp)h"P#N Setion header table(节头表，可选)
1_ N}c7A$DyF
JO)o-K h.j7Z|dt[W#_ 段由若干个节(Section)构成,节头表对每一个节的信息有相关描述。对可执行程序而言，节头表是可选的。参考资料 1中作者谈到把节头表的所有数据全部设置为0，程序也能正确运行！ELF头部是一个关于本文件的路线图（road map），从总体上描述文件的结构。下面是ELF头部的数据结构：
%J~#vb-o ;{s,NX4s!T!o-V$KI
typedef structx#}+E-XYUs3OqU0G
{$z~I.wz*I0[
g/qH
    unsigned char e_ident[EI_NIDENT];     /* 魔数和相关信息 */
&W0AGf!oI?;{(S     Elf32_Half    e_type;                 /* 目标文件类型 */ MX^9z1n"b
    Elf32_Half    e_machine;              /* 硬件体系 */$O `'mWc
    Elf32_Word    e_version;              /* 目标文件版本 */
7[9y$h7H+[/e&R     Elf32_Addr    e_entry;                /* 程序进入点 */
Z!FU0D;GVy     Elf32_Off     e_phoff;                /* 程序头部偏移量 */
[!R#\8n6w5C |     Elf32_Off     e_shoff;                /* 节头部偏移量 */9FydX/}q$D
    Elf32_Word    e_flags;                /* 处理器特定标志 */7j ?/O UQ ss
    Elf32_Half    e_ehsize;               /* ELF头部长度 */(j4jp1VV5rM"Yu
    Elf32_Half    e_phentsize;            /* 程序头部中一个条目的长度 */u&\ ET2w0b!X|?
    Elf32_Half    e_phnum;                /* 程序头部条目个数  */ _7~o(]6m/Z/h
    Elf32_Half    e_shentsize;            /* 节头部中一个条目的长度 */!WJ`a(U4Y#AT [
    Elf32_Half    e_shnum;                /* 节头部条目个数 */ZC:m"r)U
    Elf32_Half    e_shstrndx;             /* 节头部字符表索引 */w-NqQFh.b@
} Elf32_Ehdr;z2_(vy^u
sGoL7]
下面我们对ELF头表中一些重要的字段作出相关说明，完整的ELF定义请参阅参考资料 6和参考资料7。

EH(tbV#F3X 6oD&Sa&Ru*fZ2L
e_ident[0]-e_ident[3] 包含了ELF文件的魔数，依次是0x7f、'E'、'L'、'F'。注意，任何一个ELF文件必须包含此魔数。参考资料 3中讨论了利用程序、工具、/Proc文件系统等多种查看ELF魔数的方法。e_ident[4]表示硬件系统的位数，1代表32位，2代表64位。 e_ident[5]表示数据编码方式，1代表小印第安排序（最大有意义的字节占有最低的地址），2代表大印第安排序（最大有意义的字节占有最高的地址）。e_ident[6]指定ELF头部的版本，当前必须为1。e_ident[7]到e_ident[14]是填充符，通常是0。ELF格式规范中定义这几个字节是被忽略的，但实际上是这几个字节完全可以可被利用。如病毒Lin/Glaurung.676/666（参考资料 1）设置e_ident[7]为0x21,表示本文件已被感染；或者存放可执行代码（参考资料 2）。ELF头部中大多数字段都是对子头部数据的描述，其意义相对比较简单。值得注意的是某些病毒可能修改字段e_entry（程序进入点）的值，以指向病毒代码，例如上面提到的病毒Lin/Glaurung.676/666。dne+f2xanh b

7{xS4l.bq;R 一个实际可执行文件的文件头部形式如下：（利用命令readelf）:m9G'ci!v K
yt"f1c\
M
ELF Header:([d+^d^
H)K#H
   Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 6]:s'Q5s w4d'~tHb
   Class:                             ELF32
/QB2O
j$Hg    Data:                              2's complement, little endian!LqI|&tW
   Version:                           1 (current)
E~FD'FpJ5vi6q    OS/ABI:                            UNIX - System V
M L#C n:m}E    ABI Version:                       0
Nz M Cl2z0B,q!Us    Type:                              EXEC (Executable file)
K)n&L1D2^1a \-}    Machine:                           Intel 80386
U"Bzu3Q%_+b&V    Version:                           0x11dnw)E8P3\W@U
   Entry point address:               0x80483cc
\%Q W'{Q
vnR    Start of program headers:          52 (bytes into file)
zq8ig%K0te
   Start of section headers:          14936 (bytes into file) }(mHy3Sy/a9n
   Flags:                             0x08N,Pd]Y^yOG2B
   Size of this header:               52 (bytes)m)A0v#E | n
   Size of program headers:           32 (bytes)r.l8_'\P:_\t&_ v)r
   Number of program headers:         6
_"T]x4[F    Size of section headers:           40 (bytes)
-ERJU6j-Y |/[    Number of section headers:         34xXk4Q3mQ/C)F
   Section header string table index: 31kw+Wt:m{*Ap

h#A,pH.Y#YU 紧接ELF头部的是程序头表，它是一个结构数组，包含了ELF头表中字段e_phnum定义的条目，结构描述一个段或其他系统准备执行该程序所需要的信息。

typedef struct {
*\G%} |2Y/b J*B       Elf32_Word  p_type;    /* 段类型 */6r$G f"S.ti$Jj
      Elf32_Off   p_offset;        /* 段位置相对于文件开始处的偏移量 */p}3H%h8P/B}L;cR#W
      Elf32_Addr  p_vaddr;      /* 段在内存中的地址 */
\cm Pd&C5Sb2b!qje.BW       Elf32_Addr  p_paddr;      /* 段的物理地址 */NI}$a!d
      Elf32_Word  p_filesz;    /* 段在文件中的长度 */*n h0r lT SM
      Elf32_Word  p_memsz;    /* 段在内存中的长度 */]S i,MO`-]/\
oq;H
      Elf32_Word  p_flags;    /* 段的标记 *//_aNW(S']6Y^
      Elf32_Word  p_align;    /* 段在内存中对齐标记 */
}"oXfX8~   } Elf32_Phdr;
+FnTY:kFB
7V^7A2X+oJ;@rZ@ 在详细讨论可执行文件程序头表之前，首先查看一个实际文件的输出：
/s*N%Uvda:?7z0al
C0C-IuR$WD Program Headers:S:Nr2lND8Q+^7f7QF
Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  **** Align9V3VfrV Nl
PHDR           0x000034 0x08048034 0x08048034 0x000c0 0x000c0 R E 0x4
-SF)NV5s/cZc INTERP         0x0000f4 0x080480f4 0x080480f4 0x00013 0x00013 R   0x1HC]
I b~'JR}f
      [Requesting program interpreter: /lib/ld-linux.so.2]z/On].W8yq9Q(i L
   LOAD           0x000000 0x08048000 0x08048000 0x00684 0x00684 R E 0x1000
'GG(ZW\$q
]7G    LOAD           0x000684 0x08049684 0x08049684 0x00118 0x00130 RW  0x1000-?#R2J,ps
   DYNAMIC        0x000690 0x08049690 0x08049690 0x000c8 0x000c8 RW  0x4,o#gJ t-p b%fa^R
   NOTE           0x000108 0x08048108 0x08048108 0x00020 0x00020 R   0x4
.bM/e!R%fy/T7s
C3B0vuY*O.TIU   Section to Segment mapping:nm[7u1T
  Segment Sections... z]f7~&A_
   00     ]+Q9RK1WJwX
   01     .interp
6}0he-h#`*H I)P    02     .interp .note.ABI-tag .hash .dynsym .dynstr .gnu.version .gnu. gb2RIS/~v}@
version_r .rel.dyn .rel.plt
g+wJ"{6k"Cj .init .plt .text .fini .rodata .eh_frame
d ]"pz?    03     .data .dynamic .ctors .dtors .jcr .got .bss
f#E uEq)ki-@
   04     .dynamic *n;@2bI8c Xc+D4{!_x
05     .note.ABI-tag
:|.eq!t&^

};Yc/T2LJ)hZ Section Headers:
;K4Z&l$Bi-w6i   [Nr] Name              Type            Addr     Off    Size   ES **** Lk Inf Al1U)q2A[Oh^
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0 H2c0V x!va
a$j
  [ 1] .interp           PROGBITS        080480f4 0000f4 000013 00   A  0   0  1
\C+@i
`   [ 2] .note.ABI-tag     NOTE            08048108 000108 000020 00   A  0   0  4t7TC4Z`K/ZoK,[
  [ 3] .hash             HASH            08048128 000128 000040 04   A  4   0  43TL^g @%j
  [ 4] .dynsym           DYNSYM          08048168 000168 0000b0 10   A  5   1  45Yn8rSm_'s-jJ
  [ 5] .dynstr           STRTAB          08048218 000218 00007b 00   A  0   0  1
H?8{Um$S.S#Vae   [ 6] .gnu.version      VERSYM          08048294 000294 000016 02   A  4   0  2
&G](} V6]"|"Ltx   [ 7] .gnu.version_r    VERNEED         080482ac 0002ac 000030 00   A  5   1  4
yFk7|(C_)mR   [ 8] .rel.dyn          REL             080482dc 0002dc 000008 08   A  4   0  48PRCQUr:Dr.V
  [ 9] .rel.plt          REL             080482e4 0002e4 000040 08   A  4   b  4
^,N{9vU%`d;X   [10] .init             PROGBITS        08048324 000324 000017 00  AX  0   0  4L HT(mE
  [11] .plt              PROGBITS        0804833c 00033c 000090 04  AX  0   0  4
&S%g,f5QI/W M}   [12] .text             PROGBITS        080483cc 0003cc 0001f8 00  AX  0   0  4
9kTmUwk b|:` s   [13] .fini             PROGBITS        080485c4 0005c4 00001b 00  AX  0   0  4
5\8FG&LXsAf   [14] .rodata           PROGBITS        080485e0 0005e0 00009f 00   A  0   0 32?!l4Vu}
h#r
  [15] .eh_frame         PROGBITS        08048680 000680 000004 00   A  0   0  4cQ3ft9R9V${"~\
  [16] .data             PROGBITS        08049684 000684 00000c 00  WA  0   0  4
%zMe'^a~6xZ%V   [17] .dynamic          DYNAMIC         08049690 000690 0000c8 08  WA  5   0  4
(V}^.i;C4z:R lRJ   [18] .ctors            PROGBITS        08049758 000758 000008 00  WA  0   0  4~\7{ VH7^E3m
  [19] .dtors            PROGBITS        08049760 000760 000008 00  WA  0   0  4
5[IH_?_\   [20] .jcr              PROGBITS        08049768 000768 000004 00  WA  0   0  4aZ$nXU^
  [21] .got              PROGBITS        0804976c 00076c 000030 04  WA  0   0  4O5`&I#B'_n%F
  [22] .bss              NOBITS          0804979c 00079c 000018 00  WA  0   0  4
i|&_cCD&D M   [23] .comment          PROGBITS        00000000 00079c 000132 00      0   0  1,HKyV~v'vxo
  [24] .debug_aranges    PROGBITS        00000000 0008d0 000098 00      0   0  8'G{*o`)X%w+v9v,k"@
  [25] .debug_pubnames   PROGBITS        00000000 000968 000040 00      0   0  1
3^#D:V&KV@F`   [26] .debug_info       PROGBITS        00000000 0009a8 001cc6 00      0   0  1
c)O-}7FS.ah*yJI   [27] .debug_abbrev     PROGBITS        00000000 00266e 0002cc 00      0   0  1
ULh n2g6Q.i
D!w   [28] .debug_line       PROGBITS        00000000 00293a 0003dc 00      0   0  1
]'HQ6D5rb!Nc   [29] .debug_frame      PROGBITS        00000000 002d18 000048 00      0   0  47V4F3A K4[8R(NP
  [30] .debug_str        PROGBITS        00000000 002d60 000bcd 01  MS  0   0  1
&H!p"rjN   [31] .shstrtab         STRTAB          00000000 00392d 00012b 00      0   0  1D3Uh%U d%j0]
  [32] .symtab           SYMTAB          00000000 003fa8 000740 10     33  56  42JY4EDbb8Se
  [33] .strtab           STRTAB          00000000 0046e8 000467 00      0   0  1Nj `$o H-E?O

)v9k8k{RWS~ 对一个ELF可执行程序而言，一个基本的段是标记p_type为PT_INTERP的段，它表明了运行此程序所需要的程序解释器（/lib/ld- linux.so.2），实际上也就是动态连接器（dynamic linker）。最重要的段是标记p_type为PT_LOAD的段，它表明了为运行程序而需要加载到内存的数据。查看上面实际输入，可以看见有两个可 LOAD段，第一个为只读可执行（****为R E）,第二个为可读可写（****为RW）。段1包含了文本节.text，注意到ELF文件头部中程序进入点的值为0x80483cc，正好是指向节. text在内存中的地址。段二包含了数据节.data，此数据节中数据是可读可写的，相对的只读数据节.rodata包含在段1中。ELF格式可以比 COFF格式包含更多的调试信息，如上面所列出的形式为.debug_xxx的节。在I386平台LINUX系统下，用命令file查看一个ELF可执行程序的可能输出是：a.out: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux 2.2.5, dynamically linked (uses shared libs), not stripped。
4M6Y
hnyS5{
?axU*y1FnO ELF文件中包含了动态连接器的全路径，内核定位"正确"的动态连接器在内存中的地址是"正确"运行可执行文件的保证，参考资料 13讨论了如何通过查找动态连接器在内存中的地址以达到颠覆（Subversiver）动态连接机制的方法。 \YAi g1]'\#U
K2Kb*Ta0O@
最后我们讨论ELF文件的动态连接机制。每一个外部定义的符号在全局偏移表(Global Offset Table GOT)中有相应的条目,如果符号是函数则在过程连接表(Procedure Linkage Table PLT)中也有相应的条目，且一个PLT条目对应一个GOT条目。对外部定义函数解析可能是整个ELF文件规范中最复杂的，下面是函数符号解析过程的一个描述。
]:@2`6gdhU2n s
9kuA'YWI_^CmU 1：代码中调用外部函数func,语句形式为call 0xaabbccdd,地址0xaabbccdd实际上就是符号func在PLT表中对应的条目地址（假设地址为标号.PLT2）。+IL7I `0LzG5C C
/r[PZF#I-Hv
2：PLT表的形式如下
;lry7nVvM 9Tgje-X C
.PLT0: pushl   4(%ebx)   
6f V ~zm /* GOT表的地址保存在寄存器ebx中 */
Ec O#B*@D jmp     *8(%ebx)og6K,yJ A;Cb
          nop; nopo}Fu.B
          nop; nop*?q1nS4B%U)`:yf+N#_
   .PLT1: jmp     *name1@GOT(%ebx)&dMah(`4Xhi%j;MY
          pushl   $offset

[Jv{mB           jmp     .PLT0@PC
2JJaP$k?9C    .PLT2: jmp     *func@GOT(%ebx)xH:\s:R:n,k
y$AdMB
          pushl   $offset
H%\+a v`T K0S~ O           jmp     .PLT0@PC
R%s)G/On}q1mqeB
4{Gi;r'['`q9{]I6UoW 3：查看标号.PLT2的语句,实际上是跳转到符号func在GOT表中对应的条目。
A3A ^ _
GD_SRZY }#gi6K"g)I1[$L+t*M n
4：在符号没有重定位前，GOT表中此符号对应的地址为标号.PLT2的下一条语句，即是pushl $offset，其中$offset是符号func的重定位偏移量。注意到这是一个二次跳转。 yv@D7N
q5L[o,o
5：在符号func的重定位偏移量压栈后,控制跳到PLT表的第一条目，把GOT[1]的内容压栈，并跳转到GOT[2]对应的地址。 LdeLinux联盟,jfj/C
G6I6ET

HE(om(?;~(C 6：GOT[2]对应的实际上是动态符号解析函数的代码，在对符号func的地址解析后，会把func在内存中的地址设置到GOT表中此符号对应的条目中。
'u;NnP/LWTE4q
vKq.y{4nz 7：当第二次调用此符号时，GOT表中对应的条目已经包含了此符号的地址，就可直接调用而不需要利用PLT表进行跳转。
Ew/?_ISj 7~7Yd!VG@
动态连接是比较复杂的，但为了获得灵活性的代价通常就是复杂性。其最终目的是把GOT表中条目的值修改为符号的真实地址，这也可解释节.got包含在可读可写段中。
~cq&SF g$@ E.i;xT0F?
动态连接是一个非常重要的进步，这意味着库文件可以被升级、移动到其他目录等等而不需要重新编译程序（当然，这不意味库可以任意修改，如函数入参的个数、数据类型应保持兼容性）。从很大程度上说，动态连接机制是ELF格式代替a.out格式的决定性原因。如果说面对对象的编程本质是面对接口（interface）的编程，那么动态连接机制则是这种思想的地一个非常典型的应用，具体的讲，动态连接机制与设计模式中的桥接（BRIDGE）方法比较类似，而它的LAZY特性则与代理（PROXY）方法非常相似。动态连接操作的细节描述请参阅参考资料 8，9，10，11。通过阅读命令readelf、objdump 的源代码以及参考资料 14中所提及的相关软件源代码，可以对ELF文件的格式有更彻底的了解。
&mm'b*}O
b
`e.wvA9y:J 总结#~@N!}}
k8EX(h~
不同时期的可执行文件格式深刻的反映了技术进步的过程，技术进步通常是针对解决存在的问题和适应新的环境。早期的UNIX系统使用a.out格式，随着操作系统和硬件系统的进步，a.out格式的局限性越来越明显。新的可执行文件格式COFF在UNIX System VR3中出现，COFF格式相对a.out格式最大变化是多了一个节头表（section head table），能够在包含基础的文本段、数据段、BSS段之外包含更多的段，但是COFF对动态连接和C++程序的支持仍然比较困难。为了解决上述问题， UNIX系统实验室(UNIX SYSTEM Laboratories USL) 开发出ELF文件格式，它被作为应用程序二进制接口（Application binary Interface ABI）的一部分，其目的是替代传统的a.out格式。例如，ELF文件格式中引入初始化段.init和结束段.fini（分别对应构造函数和析构函数）则主要是为了支持C++程序。1994年6月ELF格式出现在LINUX系统上，现在ELF格式作为UNIX/LINUX最主要的可执行文件格式。当然我们完全有理由相信，在将来还会有新的可执行文件格式出现。
)^7q
y
IR` 8ty%IY%B(`
上述三种可执行文件格式都很好的体现了设计思想中分层的概念，由一个总的头部刻画了文件的基本要素，再由若干子头部/条目刻画了文件的若干细节。比较一下可执行文件格式和以太数据包中以太头、IP头、TCP头的设计，我想我们能很好的感受分层这一重要的设计思想。参考资料 21从全局的角度讨论了各种文件的格式，并提出一个比较夸张的结论：Everything Is Byte!
_,P_3i4xz,V
gWd.K)F;E%kA 最后的题外话：大多数资料中对a.out格式的评价较低，常见的词语有黑暗年代（dark ages）、丑陋（ugly）等等，当然，从现代的观点来看，的确是比较简单，但是如果没有曾经的简单何来今天的精巧？正如我们今天可以评价石器时代的技术是ugly,那么将来的人们也可以嘲讽今天的技术是非常ugly。我想我们也许应该用更平和的心态来对曾经的技术有一个公正的评价。