俺写的分析elf文件的程序

xueyan

俺这几天正在学习elf文件格式,顺便写了个小程序分析文件格式,总感觉按书上说的不太直观,尽管有一些分析elf文件的工具,比如objdump和readelf,但是自己写个程序分析一下更能理解.这个程序格式可能不太符合标准,俺没有开发过正规的项目所以还请见谅.只是希望能够对学习elf文件格式的sir们有些帮助..
现在只能分析程序头表,节表,串表,和符号表,俺正在学习动态联结的过程(借助理解elf文件的相应结构),还希望懂得这个的sir们给点儿帮助------

1. 
   
2. /**********************************************************************
   
3. * file：elf_file.c
   
4. * date:   T六  6月 10 10:19:13 CST 2005
   
5. * Author: l1u6uddy
   
6. * Last Modified: 6月14 日
   
7. *
   
8. * Description: 这个程序简单的分析了elf文件的格式;
   
9. *
   
10. *   
    
11. *   
    
12. *   
    
13. *
    
14. * Compile with:
    
15. * gcc elf_file.c -o elf_file
    
16. * Usage:
    
17. *./elf_file a_elf_file_name
    
18. ***********************************************************************/
    
19. #include <stdio.h>
    
20. #include <unistd.h>
    
21. #include <sys/mman.h>
    
22. #include <sys/stat.h>
    
23. #include <sys/types.h>
    
24. #include <fcntl.h>
    
25. #include <stdio.h>
    
26. 
    
27. #define EI_NIDENT 16
    
28. #define Elf32_Addr unsigned int
    
29. #define Elf32_Half unsigned short
    
30. #define Elf32_Off unsigned int
    
31. #define Elf32_SWord unsigned int
    
32. #define Elf32_Word unsigned int
    
33. 
    
34. #define ELF_ST_BIND(x)                ((x) >> 4)
    
35. #define ELF_ST_TYPE(x)                (((unsigned int) x) & 0xf)
    
36. #define ELF32_ST_BIND(x)        ELF_ST_BIND(x)
    
37. #define ELF32_ST_TYPE(x)        ELF_ST_TYPE(x)
    
38. #define ELF64_ST_BIND(x)        ELF_ST_BIND(x)
    
39. #define ELF64_ST_TYPE(x)        ELF_ST_TYPE(x)
    
40. 
    
41. struct  Elf32_Ehd{
    
42. unsigned char e_ident[EI_NIDENT];
    
43. Elf32_Half e_type;
    
44. Elf32_Half e_machine;
    
45. Elf32_Word e_version;
    
46. Elf32_Addr e_entry;
    
47. Elf32_Off e_phoff;
    
48. Elf32_Off e_shoff;
    
49. Elf32_Word e_flags;
    
50. Elf32_Half e_ehsize;
    
51. Elf32_Half e_phentsize;
    
52. Elf32_Half e_phnum;
    
53. Elf32_Half e_shentsize;
    
54. Elf32_Half e_shnum;
    
55. Elf32_Half e_shstrndx;
    
56. };
    
57. 
    
58. struct Elf32_Phdr{
    
59.   Elf32_Word p_type;
    
60.   Elf32_Off p_offset;
    
61.   Elf32_Addr p_vaddr;
    
62.   Elf32_Addr p_paddr;
    
63.   Elf32_Word p_filesz;
    
64.   Elf32_Word p_memsz;
    
65.   Elf32_Word p_flags;
    
66.   Elf32_Word p_align;
    
67. };
    
68. 
    
69. struct Elf32_Shdr{
    
70.   Elf32_Word sh_name;
    
71.   Elf32_Word sh_type;
    
72.   Elf32_Word sh_flags;
    
73.   Elf32_Addr sh_addr;
    
74.   Elf32_Off sh_offset;
    
75.   Elf32_Word sh_size;
    
76.   Elf32_Word sh_link;
    
77.   Elf32_Word sh_info;
    
78.   Elf32_Word sh_addralign;
    
79.   Elf32_Word sh_entsize;
    
80. };
    
81. 
    
82. typedef struct elf32_sym{
    
83.   Elf32_Word        st_name;
    
84.   Elf32_Addr        st_value;
    
85.   Elf32_Word        st_size;
    
86.   unsigned char        st_info;
    
87.   unsigned char        st_other;
    
88.   Elf32_Half        st_shndx;
    
89. } Elf32_Sym;
    
90. 
    
91. 
    
92. 
    
93. void print_Phdr_list(FILE* file,Elf32_Half phentsize,Elf32_Half phnum);
    
94. void print_Phdr(struct Elf32_Phdr * phdr);
    
95. void print_Shdr_list(FILE* file,Elf32_Half shentsize,Elf32_Half shnum);
    
96. void print_Shdr(struct Elf32_Shdr * shdr);
    
97. void * read_shname_table();
    
98. void print_shname( Elf32_Word offset);
    
99. void print_Sym( Elf32_Off sym_off,Elf32_Word sym_size );
    
100. void print_Sym_element( Elf32_Sym * sym_element);
     
101. void print_Sym_element_name( Elf32_Word offset);
     
102. struct Elf32_Ehd * ehd;
     
103.   void *mapf;
     
104.    void * shname_table;
     
105.   FILE *fp;
     
106. int main(int argc,char* argv[])
     
107. {
     
108. 
     
109.   int fd;
     
110.   void *start;
     
111.   int len;
     
112. 
     
113.   // struct  Elf32_Ehdr *ehdr;
     
114. 
     
115. 
     
116.   
     
117.   ehd=(struct Elf32_Ehd *)malloc(sizeof(struct Elf32_Ehd));
     
118. 
     
119. fp = fopen(argv[1],"rb");         //// 打开elf格式文件，文件名为file
     
120. if(fp == NULL)
     
121.   return ;
     
122. fseek(fp, 0, SEEK_END);
     
123. len = ftell(fp);                  //// 得到文件的大小
     
124. if(len <(sizeof(struct Elf32_Ehd)))
     
125. {                                 
     
126.   printf("File Size too Samll!\n");
     
127.   return 0;
     
128. }
     
129. 
     
130. mapf=mmap(NULL,len,PROT_READ,MAP_PRIVATE,fp,0);
     
131. 
     
132. rewind(fp);
     
133.   fread(ehd,sizeof(struct Elf32_Ehd) , 1, fp);                  ////* 读取ELF文件头 */
     
134. 
     
135. if( (ehd->e_ident[0]== 0x7f)&&( ehd->e_ident[1]== 'E') && (ehd->e_ident[2]== 'L') && (ehd->e_ident[3]== 'F'))
     
136. {
     
137.    printf("the file is a elf file\n");
     
138.    if(ehd->e_type==1)
     
139.      printf("可重定位文件\n");
     
140.    else
     
141.      if(ehd->e_type=2)
     
142.        printf("可执行文件\n");
     
143.      else
     
144.        if(ehd->e_type==3)
     
145.          printf("共享目标文件\n");
     
146.    
     
147. 
     
148.    if(ehd->e_machine==3)
     
149.      printf("Intel 80386\n");
     
150.    if(ehd->e_version==1)
     
151.      printf("当前版本\n");
     
152.    
     
153.    printf("程序起动的虚拟地址为:%u\n",ehd->e_entry);
     
154. 
     
155.    printf("程序头表的以字节为单位的文件偏移为:%u\n",ehd->e_phoff);
     
156.    
     
157.    printf("e_flags=%x\n",ehd->e_flags);
     
158. 
     
159.    printf("该elf文件头字节的长度为:%d\n",ehd->e_ehsize);
     
160. 
     
161.    printf("程序头表中一个表项的字节长度为:%d\n",ehd->e_phentsize);
     
162. 
     
163.    printf("程序头表中表项的数目为:%d\n",ehd->e_phnum);
     
164. 
     
165.    printf("节头的字节长度为:%d\n",ehd->e_shentsize);
     
166. 
     
167.    printf("节头表中的表项数目:%d\n",ehd->e_shnum);
     
168. 
     
169.    printf("节名串表的索引是%u\n",ehd->e_shstrndx);
     
170. 
     
171.    if(ehd->e_phnum!=0)
     
172.      {
     
173.        //分析程序头表
     
174.        fseek(fp,ehd->e_phoff,SEEK_SET);
     
175.        print_Phdr_list(fp,ehd->e_phentsize,ehd->e_phnum);   
     
176.      }
     
177.    
     
178.    if(ehd->e_shnum!=0)
     
179.      {
     
180.        shname_table=read_shname_table();
     
181.       //分析节头表
     
182. 
     
183.        fseek(fp,ehd->e_shoff,SEEK_SET);
     
184.        print_Shdr_list(fp,ehd->e_shentsize,ehd->e_shnum);
     
185.      }
     
186.    
     
187.    
     
188. 
     
189. }else
     
190.    {
     
191.      printf("this file is not a elf file\n");
     
192.    }
     
193. 
     
194. }
     
195. 
     
196. void print_Phdr_list(FILE* file,Elf32_Half phentsize,Elf32_Half phnum)
     
197. {
     
198.   int i=0;
     
199. 
     
200. struct Elf32_Phdr * e_Phdr;
     
201.   e_Phdr=(struct Elf32_Phdr *) malloc(sizeof(struct Elf32_Phdr));
     
202.   if(phentsize!=sizeof(struct Elf32_Phdr))
     
203.       {
     
204.      printf("phentsize!=sizeof(struct Elf32_Phdr)\n");
     
205.      exit(0);
     
206.       }
     
207.   for(i=0;i<phnum;i++)
     
208.     {
     
209.       printf("第%d个段的信息:\n",i);
     
210.       fread(e_Phdr,phentsize,1,file);
     
211.       print_Phdr(e_Phdr);
     
212.       printf("\n");
     
213.     }
     
214. 
     
215. }
     
216. 
     
217. void print_Phdr(struct Elf32_Phdr * phdr)
     
218. {
     
219.   switch(phdr->p_type)
     
220.     {
     
221.     case 0:
     
222.       printf("空,该数组元素没有使用\n");
     
223.       break;
     
224.     case 1:
     
225.       printf("该段为可装入段\n");
     
226.       break;
     
227.     case 2:
     
228.       printf("该数组元素说明了动态联接信息\n");
     
229.       break;
     
230.     case 3:
     
231.       printf("该元素说明调用解释程序的位置和长度,该路径位置以空结尾\n");
     
232.       break;
     
233.     case 4:
     
234.       printf("该元素说明辅助信息的位置和长度\n");
     
235.       break;
     
236.     case 5:
     
237.       printf("保留.未使用\n");
     
238.       break;
     
239.     case 6:
     
240.       printf("该元素说明在程序的文件映象和其内存映象中的程序头表头本身的位置和长度\n");
     
241.       break;
     
242.     default :
     
243.       printf("处理机专用语义:%x\n",phdr->p_type);
     
244.     }
     
245.   
     
246.   printf("该段在文件中的位移为:0x%x\n",phdr->p_offset);
     
247.   
     
248.   printf("该段的虚存地址为:%u\n",phdr->p_vaddr);
     
249. 
     
250.   printf("p_paddr=%u\n",phdr->p_paddr);
     
251.   
     
252.   printf("该段的文件映象中字节的数目:0x%x\n",phdr->p_filesz);
     
253. 
     
254.   printf("该段的内存映象的字节的数目:0x%x\n",phdr->p_memsz);
     
255. 
     
256.   printf("该段段权限:");
     
257. 
     
258.   Elf32_Word flag1,flag2,flag3;
     
259.   flag1=phdr->p_flags&0x1;
     
260.   flag2=phdr->p_flags&0x2;
     
261.   flag3=phdr->p_flags&0x4;
     
262.   if(flag1==1)
     
263.     {
     
264.       printf("执行 ");
     
265.     }
     
266.   if(flag2==2)
     
267.     {
     
268.       printf("写 ");
     
269.     }
     
270.   if(flag3==4)
     
271.     {
     
272.       printf("读 ");
     
273.     }
     
274.   printf("\n");
     
275. }
     
276. void print_Shdr_list(FILE* file,Elf32_Half shentsize,Elf32_Half shnum)
     
277. {
     
278. int j=0;
     
279. 
     
280. struct Elf32_Shdr * e_Shdr;
     
281.   e_Shdr=(struct Elf32_Shdr *) malloc(sizeof(struct Elf32_Shdr));
     
282.   if(shentsize!=sizeof(struct Elf32_Shdr))
     
283.       {
     
284.      printf("shentsize!=sizeof(struct Elf32_Shdr)\n");
     
285.      exit(0);
     
286.       }
     
287.   for(j=0;j<shnum;j++)
     
288.     {
     
289.       
     
290.       printf("第%d个节的信息:\n",j);
     
291.       /*  
     
292.       if(j==ehd->e_shstrndx)
     
293.         {
     
294.           long temp;
     
295. 
     
296.           temp=ftell(file);
     
297.           
     
298.           printf("%x\n",(Elf32_Off)temp);
     
299.      
     
300.         }
     
301.       */
     
302.       fread(e_Shdr,shentsize,1,file);
     
303.       print_Shdr(e_Shdr);
     
304.       printf("\n");
     
305.     }
     
306. }
     
307. void print_Shdr(struct Elf32_Shdr * shdr)
     
308. {
     
309.   printf("节名在节头串表节的索引为:%u\n",shdr->sh_name);
     
310. 
     
311.   //打印节名
     
312.     print_shname(shdr->sh_name);
     
313. /*
     
314.   Elf32_Off Shdr_offset,S_offset;
     
315.   //  Elf32_
     
316.   Shdr_offset=ehd->e_shoff+ehd->e_shentsize*ehd->e_shstrndx;
     
317.   printf("%x\n",Shdr_offset);
     
318.   rewind(fp);
     
319.   fseek(fp,Shdr_offset,SEEK_SET);
     
320.   fread(ehd,sizeof(struct Elf32_Ehd) , 1, fp);   
     
321.   // printf("sh_offset=%u",temp->sh_offset);
     
322.   //  printf("节名表的偏移是:%x\n",((struct Elf32_Shdr *)(ehd->e_shoff+ehd->e_shentsize*ehd->e_shstrndx))->sh_offset);
     
323.   //   printf("节名为:%s",(char *)(((struct Elf32_Shdr *)(ehd->e_shoff+ehd->e_shentsize*ehd->e_shstrndx))->sh_offset+shdr->sh_name+mapf));
     
324.   */
     
325.   //type
     
326.   switch(shdr->sh_type)
     
327.     {
     
328.     case 0:
     
329.       printf("该节头不活动,没有与其相应的节.节头中其它成员的值没有定义\n");
     
330.       break;
     
331.     case 1:
     
332.       printf("该节保存有程序定义的信息.\n");
     
333.       break;
     
334.     case 2:
     
335.       printf("该节存放符号表.\n");
     
336.       print_Sym(shdr->sh_offset,shdr->sh_size);
     
337.       break;
     
338.     case 3:
     
339.       printf("该节存放串表.\n");
     
340.       break;
     
341.     case 4:
     
342.       printf("该节存放带有显式加数的重定位表项.\n");
     
343.       break;
     
344.     case 5:
     
345.       printf("该节存放符号散列表.\n");
     
346.       break;
     
347.     case 6:
     
348.       printf("该节存放动态联接的信息.\n");
     
349.       break;
     
350.     case 7:
     
351.       printf("该节存放以某种方式标记的文件的信息.\n");
     
352.       break;
     
353.     case 8:
     
354.       printf("该类型的节不占文件空间\n");
     
355.       break;
     
356.     case 9:
     
357.       printf("该节存放不带显式加数的重定位表项.\n");
     
358.       break;
     
359.     case 10:
     
360.       printf("类型被保留,没有指定语义\n");
     
361.       break;
     
362.     case 11:
     
363.       printf("该节存放符号表.\n");
     
364.       print_Sym(shdr->sh_offset,shdr->sh_size);
     
365.       break;
     
366.       
     
367.     default:
     
368.       printf("%x\n",shdr->sh_type);
     
369.     }
     
370.   
     
371.   printf("标志为:%x--->",shdr->sh_flags);
     
372.   Elf32_Word flag1,flag2,flag3;
     
373.   flag1=shdr->sh_flags&0x1;
     
374.   flag2=shdr->sh_flags&0x2;
     
375.   flag3=shdr->sh_flags&0x4;
     
376.   if(flag1==1)
     
377.     {
     
378.       printf("包含进程执行时可以写的数据 ");
     
379.     }
     
380.   if(flag2==2)
     
381.     {
     
382.       printf("该节在进程执行其间占用内存  ");
     
383.     }
     
384.   if(flag3==4)
     
385.     {
     
386.       printf("该节包含可执行的程序指令  ");
     
387.     }
     
388.   printf("\n");
     
389. 
     
390.   printf("该节的第一个字节将存放在内存映象中的:0x%x\n",shdr->sh_addr);
     
391. 
     
392.   printf("该节的位移为:0x%x\n",shdr->sh_offset);
     
393. 
     
394.   printf("该节的字节长度为:0x%x\n",shdr->sh_size);
     
395. 
     
396. 
     
397. 
     
398. }
     
399. 
     
400. void print_shname( Elf32_Word offset)
     
401. {
     
402.   // void * name_table;
     
403.   // printf("now,read the table\n");
     
404.   // name_table=read_shname_table();
     
405.   printf("该节的节名为:%s\n",shname_table+offset);
     
406. }
     
407. void * read_shname_table()
     
408. {
     
409. Elf32_Off Shdr_offset,S_offset;
     
410. 
     
411.    struct   Elf32_Shdr *shname_shdr;
     
412.   shname_shdr=(struct Elf32_Shdr*)malloc(sizeof(struct Elf32_Shdr));
     
413. Shdr_offset=ehd->e_shoff+ehd->e_shentsize*ehd->e_shstrndx;
     
414. 
     
415.      rewind(fp);
     
416.    
     
417.   fseek(fp,Shdr_offset,SEEK_SET);
     
418.   fread(shname_shdr,sizeof(struct Elf32_Shdr) , 1, fp);
     
419.   S_offset=shname_shdr->sh_offset;
     
420.   shname_table=malloc(shname_shdr->sh_size);
     
421. 
     
422.   rewind(fp);
     
423.   fseek(fp,S_offset,SEEK_SET);
     
424.    fread(shname_table,shname_shdr->sh_size,1,fp);
     
425.   return shname_table;
     
426. }
     
427. 
     
428. void print_Sym( Elf32_Off sym_off,Elf32_Word sym_size)
     
429. {
     
430.   //首先应该保存文件指针
     
431.   long file_point;
     
432.   file_point=ftell(fp);
     
433.   //重定位文件指针
     
434.   fseek(fp,sym_off,SEEK_SET);
     
435.   //获得存储空间,读取符号表
     
436.   void * sym_table;
     
437.   sym_table=malloc(sym_size);
     
438.   fread( sym_table,sym_size,1,fp);
     
439.   int n,i;
     
440.   n=sym_size/sizeof( Elf32_Sym );
     
441.   printf("现在打印符号表信息:\n");
     
442.   for( i=0;i<n;i++ )
     
443.     {
     
444.       printf( "  符号%d的信息:\n",i);
     
445.       print_Sym_element( (Elf32_Sym *)(sym_table+i*sizeof( Elf32_Sym )) );
     
446.     }
     
447. 
     
448. //恢复文件指针
     
449.   fseek(fp,file_point,SEEK_SET);
     
450.   
     
451. }
     
452. void print_Sym_element( Elf32_Sym * sym_element )
     
453. {
     
454.   print_Sym_element_name( sym_element->st_name );
     
455.   printf("    该符号的值为:0x%x\n",sym_element->st_value );
     
456.   printf("    该符号的字节大小为:0x%x\n",sym_element->st_size);
     
457.   unsigned char temp;
     
458.   temp=sym_element->st_info;
     
459.   switch( ELF32_ST_BIND( temp ) )
     
460.     {
     
461.     case 0:
     
462.       printf("    该符号为局部符号(STB_LOCAL)\n");
     
463.       break;
     
464.     case 1:
     
465.       printf("    该符号为全局符号(STB_GLOBAL)\n");
     
466.       break;
     
467.     case 2:
     
468.       printf("    该符号为弱符号(STB_WEAK)\n");
     
469.       break;
     
470.     default:
     
471.       printf("    该符号为处理机专用\n");
     
472.     }
     
473.   temp=sym_element->st_info;
     
474.   switch( ELF32_ST_TYPE( temp ) )
     
475.     {
     
476.     case 0:
     
477.       printf( "    该符号类型没有定义\n");
     
478.       break;
     
479.     case 1:
     
480.       printf( "    该符号与变量数组等有关\n");
     
481.       break;
     
482.     case 2:
     
483.       printf( "    该符号与函数和可执行代码有关\n");
     
484.       break;
     
485.     case 3:
     
486.       printf( "    该符号与一个节有关\n");
     
487.       break;
     
488.     case 4:
     
489.       printf( "    该符号的名称给出了对应于目标文件的源文件的名字\n");
     
490.       break;
     
491.     default:
     
492.       printf( "    该符号的值为处理机专用\n");
     
493.     }
     
494. }
     
495. 
     
496. void print_Sym_element_name( Elf32_Word offset)
     
497. {
     
498.   printf("    该符号的名称为:%s\n",shname_table+offset);
     
499. }
     
500. 
     

复制代码

kj501

自己定个程序来了解elf的结构是不错的。
ps：可以不需要定义那么多宏吧。linux系统上就有elf.h，直接使用它不是更省事吗？
同时建议不要用#define类型定义成宏。用typedef。

xueyan

Post by kj501
自己定个程序来了解elf的结构是不错的。
ps：可以不需要定义那么多宏吧。linux系统上就有elf.h，直接使用它不是更省事吗？
同时建议不要用#define类型定义成宏。用typedef。

谢谢kj501的建议,我原先不知道elf.h这个头文件,所以,呵呵-----
等我知道的时候程序已经写的差不多了,所以也没有改,本来就是一个自己写着玩儿的程序...所以没有那样严格....
不过俺以后会注意的,谢谢了-----

wide288

不去调用也有好处呀，不是学习吗？
不过不知道分析这个有什么用啊？
难道想写病毒？

xueyan

不是了,只是想了解一下而已----

leyyer

这么长的程序，我还从来没有写过！





/*我是菜鸟*/

Tetris

这个东西很有用的！不错。
但有个建议，不要在main函数之外的任何函数里调用输出(printf)，而是把elf格式里的信息分析到结构体里，然后返回。在main里再把信息打印出来。
当然了，最好是连main也不要，做成一个elf格式分析的库。

rickxbx

有篇文章可以参考:http://www.muppetlabs.com/~breadbox/software/ELF.txt

kj 读 linkers & loaders 读的怎么样了?
什么时候写个心得啊?

xueyan

Post by Tetris
这个东西很有用的！不错。
但有个建议，不要在main函数之外的任何函数里调用输出(printf)，而是把elf格式里的信息分析到结构体里，然后返回。在main里再把信息打印出来。
当然了，最好是连main也不要，做成一个elf格式分析的库。

分析elf文件格式的工具已经很多了，比如bjdump和readelf，，这些已经足够了。我写这个程序的目的只是想更好的学习了解elf而已，没想那么多了。。。
如果把按照Tetris的这样做，是不是很麻烦？？？我不知道为什么不建议在main函数之外调用printf???

xueyan

Post by rickxbx
有篇文章可以参考:http://www.muppetlabs.com/~breadbox/software/ELF.txt

kj 读 linkers & loaders 读的怎么样了?
什么时候写个心得啊?

感谢提供的这份资料，我大体看了一下，好像我看的这份资料就是它的中文翻译，书名为：<<UNIX系统V第4版 程序员指南：ANSI C 和编程支持工具>>,后边有一章第13章：目标文件 就是这篇文章的中文翻译，另外这篇文章好像网上有人翻译过http：//elfhack.whitecell.org/mydocs/ELF_chinese.txt，，，，
我也在学习linkers&loaders，刚开始看第一章----