Linux下分析bin文件的10种方法

以你之姓@ 2022-12-16 13:25 95阅读 0赞

忍不住要把这个文章给转载了：[http://www.embeddedlinux.org.cn/emb-linux/entry-level/202005/17-9147.html][http_www.embeddedlinux.org.cn_emb-linux_entry-level_202005_17-9147.html]

二进制文件是我们几乎每天都需要打交道的文件类型，但很少人知道他们的工作原理。这里所讲的二进制文件，是指一些可执行文件，包括你天天要使用的 Linux 命令，也是二进制文件的一种。

Linux 系统给我们提供了非常多用于分析二进制文件的工具，不管你在 Linux 下从事的是何种工作，知道这些工具也会让你对你的系统更加了解。

在本文中，将介绍几种最常用的用于分析二进制文件的工具及命令，这些工具在大部分发行版里可以直接使用，如果不能直接用的话，可以自行安装。

**file**

file 命令用于分析文件的类型。

如果你需要分析二进制文件，可以首先使用 file 命令来切入。我们知道，在 Linux 下，一切皆文件，但并不是所有的文件都具有可执行性，我们还有各种各样的文件，比如：文本文件，管道文件，链接文件，socket文件，等等。

在对一个文件进行分析之前，我们可以首先使用 file 命令来分析它们的类型。当然除此之外，我们还可以看到一些其它信息。

1.  $ file /bin/pwd 
2.  /bin/pwd: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID\[sha1\]=0d264bacf2adc568f0e21cbcc9576df434c44380, stripped

**ldd**

ldd 命令可以用于分析可执行文件的依赖。

我们使用 file 命令来分析一个可执行文件的时候，有时候可以看到输出中有 dynamically linked 这样的字眼。这个是啥意思呢?

大部分程序，都会使用到第三方库，这样就可以不用重复造轮子，节约大量时间。最简单的，我们写C程序代码的话，肯定会使用到 libc 或者 glibc 库。当然，除此之外，还可能使用其它的库。

那我们在什么情况下需要分析程序的依赖库呢?有一个场景大家肯定经历过。你去你同事那边拷备他写好的程序放到自己的环境下运行，有时候可能会跑不起来。当然跑不起来的原因可能很多，但其中一个原因可能就是缺少对应的依赖库。

这时候，ldd 就派上用场了。它可以分析程序需要一些什么依赖库，你只要把对应的库放在对应的位置就可以了。

1.  $ ldd /bin/pwd 
2.          linux-vdso.so.1 =>  (0x00007ffeb73e5000) 
3.          libc.so.6 => /lib64/libc.so.6 (0x00007f908b321000) 
4.          /lib64/ld-linux-x86-64.so.2 (0x00007f908b6ef000)

**ltrace**

ltrace的功能是能够跟踪进程的库函数调用。

我们可以使用 ldd 命令来找到程序的依赖库，但是，一个库里少则几个，多则几千个函数，怎么知道现在程序调用的是什么函数呢?

ltrace 命令就是用来做这个事的。在下面的例子里，我们可以看到程序调用的函数，以及传递进去的参数，同时你也可以看到函数调用的输出。

1.  $ ltrace /bin/pwd 
2.  \_\_libc\_start\_main(0x401760, 1, 0x7ffff6524cc8, 0x404a00 <unfinished ...> 
3.  getenv("POSIXLY\_CORRECT")                        = nil 
4.  strrchr("/bin/pwd", '/')                         = "/pwd" 
5.  setlocale(LC\_ALL, "")                            = "en\_US.utf8" 
6.  bindtextdomain("coreutils", "/usr/share/locale") = "/usr/share/locale" 
7.  textdomain("coreutils")                          = "coreutils" 
8.  \_\_cxa\_atexit(0x4022f0, 0, 0, 0x736c6974756572)   = 0 
9.  getopt\_long(1, 0x7ffff6524cc8, "LP", 0x606d00, nil) = -1 
10. getcwd(nil, 0)                                   = "" 
11. puts("/home/alvin"/home/alvin 
12. )                              = 12 
13. free(0x22bc030)                                  = <void> 
14. exit(0 <unfinished ...> 
15. \_\_fpending(0x7f3048865400, 0, 64, 0x7f3048865eb0) = 0 
16. fileno(0x7f3048865400)                           = 1 
17. \_\_freading(0x7f3048865400, 0, 64, 0x7f3048865eb0) = 0 
18. \_\_freading(0x7f3048865400, 0, 2052, 0x7f3048865eb0) = 0 
19. fflush(0x7f3048865400)                           = 0 
20. fclose(0x7f3048865400)                           = 0 
21. \_\_fpending(0x7f30488651c0, 0, 3328, 0xfbad000c)  = 0 
22. fileno(0x7f30488651c0)                           = 2 
23. \_\_freading(0x7f30488651c0, 0, 3328, 0xfbad000c)  = 0 
24. \_\_freading(0x7f30488651c0, 0, 4, 0xfbad000c)     = 0 
25. fflush(0x7f30488651c0)                           = 0 
26. fclose(0x7f30488651c0)                           = 0 
27. \+++ exited (status 0) +++

**strace**

strace 命令可以用于追踪程序运行过程中的系统调用及信号。

通过上面的介绍，我们知道 ltrace 命令是用来追踪函数调用的。strace 命令类似，但它追踪的是系统调用。何为系统调用?简单说就是我们可以通过系统调用与内核进行交互，完成我们想要的任务。

例如，如果我们想在屏幕上打印某些字符，可以使用 printf 或 puts 函数，而这两个都是 libc 的库函数，在更底层，他们都是调用 write 这个系统调用。

1.  $ strace -f /bin/pwd 
2.  execve("/bin/pwd", \["/bin/pwd"\], \[/\* 24 vars \*/\]) = 0 
3.  brk(NULL)                               = 0xbc9000 
4.  mmap(NULL, 4096, PROT\_READ|PROT\_WRITE, MAP\_PRIVATE|MAP\_ANONYMOUS, -1, 0) = 0x7f918ba69000 
5.  access("/etc/ld.so.preload", R\_OK)      = -1 ENOENT (No such file or directory) 
6.  open("/etc/ld.so.cache", O\_RDONLY|O\_CLOEXEC) = 3 
7.  fstat(3, \{st\_mode=S\_IFREG|0644, st\_size=38684, ...\}) = 0 
8.  mmap(NULL, 38684, PROT\_READ, MAP\_PRIVATE, 3, 0) = 0x7f918ba5f000 
9.  close(3)                                = 0 
10. open("/lib64/libc.so.6", O\_RDONLY|O\_CLOEXEC) = 3 
11. read(3, "\\177ELF\\2\\1\\1\\3\\0\\0\\0\\0\\0\\0\\0\\0\\3\\0>\\0\\1\\0\\0\\0\\20&\\2\\0\\0\\0\\0\\0"..., 832) = 832 
12. fstat(3, \{st\_mode=S\_IFREG|0755, st\_size=2156160, ...\}) = 0 
13. mmap(NULL, 3985888, PROT\_READ|PROT\_EXEC, MAP\_PRIVATE|MAP\_DENYWRITE, 3, 0) = 0x7f918b47b000 
14. mprotect(0x7f918b63e000, 2097152, PROT\_NONE) = 0 
15. mmap(0x7f918b83e000, 24576, PROT\_READ|PROT\_WRITE, MAP\_PRIVATE|MAP\_FIXED|MAP\_DENYWRITE, 3, 0x1c3000) = 0x7f918b83e000 
16. mmap(0x7f918b844000, 16864, PROT\_READ|PROT\_WRITE, MAP\_PRIVATE|MAP\_FIXED|MAP\_ANONYMOUS, -1, 0) = 0x7f918b844000 
17. close(3)  
18. ………… 
19. \+++ exited with 0 +++

**hexdump**

hexdump 命令用来查看二进制文件的 16 进制编码，但实际它能查看任何文件，而不限于二进制文件。

一个二进制文件，如果你直接使用文本编辑器打开的话，将看到一堆乱码。这时候，你就可以使用 hexdump 命令来查看它的内容了。

hexdump 的显示格式是：左边是字节序号，中间是文件的 16 进制编码，如果是可打印字符的话就会显示在右边。

通过使用这个命令，我们就可以大概知道这个二进制文件里面有什么内容，后面要做什么处理就比较方便了。

1.  $ hexdump -C /bin/pwd | head 
2.  00000000  7f 45 4c 46 02 01 01 00  00 00 00 00 00 00 00 00  |.ELF............| 
3.  00000010  02 00 3e 00 01 00 00 00  17 19 40 00 00 00 00 00  |..>.......@.....| 
4.  00000020  40 00 00 00 00 00 00 00  50 7a 00 00 00 00 00 00  |@.......Pz......| 
5.  00000030  00 00 00 00 40 00 38 00  09 00 40 00 1e 00 1d 00  |....@.8...@.....| 
6.  00000040  06 00 00 00 05 00 00 00  40 00 00 00 00 00 00 00  |........@.......| 
7.  00000050  40 00 40 00 00 00 00 00  40 00 40 00 00 00 00 00  |@.@.....@.@.....| 
8.  00000060  f8 01 00 00 00 00 00 00  f8 01 00 00 00 00 00 00  |................| 
9.  00000070  08 00 00 00 00 00 00 00  03 00 00 00 04 00 00 00  |................| 
10. 00000080  38 02 00 00 00 00 00 00  38 02 40 00 00 00 00 00  |8.......8.@.....| 
11. 00000090  38 02 40 00 00 00 00 00  1c 00 00 00 00 00 00 00  |8.@.............|

**strings**

strings 命令可以用来打印二进制文件中可显示的字符。

什么是可显示字符?简单说你在显示器上看到的字符都是可显示字符，比如：abcABC,.:。

我们知道，一个二进制文件里面的内容很多是非显示字符，所以无法直接用文本处理器打开。程序在被开发的时候，我们经常会加一些调试信息，比如：debug log, warn log, error log，等等。这些信息我们就可以使用 strings 命令看得到。

1.  $ strings /bin/pwd | head 
2.  /lib64/ld-linux-x86-64.so.2 
3.  libc.so.6 
4.  fflush 
5.  strcpy 
6.  \_\_printf\_chk 
7.  readdir 
8.  setlocale 
9.  mbrtowc 
10. strncmp 
11. optind

**readelf**

readelf 一般用于查看 ELF 格式的文件信息。

ELF(Executable and Linkable Format)即可执行连接文件格式，是一种比较复杂的文件格式，但其应用广泛。当你使用 file 命令发现某个文件是 ELF 文件时，你就可以使用 readelf 命令来读取这个文件的信息。

1.  $ readelf -h /bin/pwd 
2.  ELF Header: 
3.    Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
4.    Class:                             ELF64 
5.    Data:                              2's complement, little endian 
6.    Version:                           1 (current) 
7.    OS/ABI:                            UNIX - System V 
8.    ABI Version:                       0 
9.    Type:                              EXEC (Executable file) 
10.   Machine:                           Advanced Micro Devices X86-64 
11.   Version:                           0x1 
12.   Entry point address:               0x401917 
13.   Start of program headers:          64 (bytes into file) 
14.   Start of section headers:          31312 (bytes into file) 
15.   Flags:                             0x0 
16.   Size of this header:               64 (bytes) 
17.   Size of program headers:           56 (bytes) 
18.   Number of program headers:         9 
19.   Size of section headers:           64 (bytes) 
20.   Number of section headers:         30 
21.   Section header string table index: 29

**objdump**

objdump是用查看目标文件或者可执行的目标文件的构成的GCC工具。

我们知道，程序在开发完成之后，需要经过编译，才可以生成计算机可以识别的二进制文件。我们写的代码计算机不能直接执行，需要编译成汇编程序，计算机才能依次执行。

objdump 命令可以读取可执行文件，然后将汇编指令打印出来。所以如果你想看懂 objdump 的结果，你就需要有一些汇编基础才可以。

1.  $ objdump -d /bin/pwd | head 
2.   
3.  /bin/pwd:     file format elf64-x86-64 
4.   
5.   
6.  Disassembly of section .init: 
7.   
8.  0000000000401350 <.init>: 
9.    401350:       48 83 ec 08             sub    $0x8,%rsp 
10.   401354:       48 8b 05 6d 5c 20 00    mov    0x205c6d(%rip),%rax        \# 606fc8 <\_\_ctype\_b\_loc@plt+0x205878> 
11.   40135b:       48 85 c0                test   %rax,%rax

**nm**

nm命令主要是列出目标文件的符号(说白了就是一些函数和全局变量等)。

如果你编译出来的程序没有经过 strip ，那么 nm 命令可以挖掘出隐含在可执行文件中的重大秘密。它可以帮你列出文件中的变量及函数，这对于我们进行反向操作具有重大意义。

下面我们通过一小段简单的程序来讲解 nm 命令的用途。在编译这个程序时，我们加上了 -g 选项，这个选项可以使编译出来的文件包含更多有效信息。

1.  $ cat hello.c  
2.  \#include <stdio.h> 
3.   
4.  int main() \{ 
5.      printf("Hello world!"); 
6.      return 0; 
7.  \} 
8.  $  
9.  $ gcc -g hello.c -o hello 
10. $  
11. $ file hello 
12. hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID\[sha1\]=3de46c8efb98bce4ad525d3328121568ba3d8a5d, not stripped 
13. $  
14. $ ./hello  
15. Hello world!$  
16. $  
17.  
18.  
19. $ nm hello | tail 
20. 0000000000600e20 d \_\_JCR\_END\_\_ 
21. 0000000000600e20 d \_\_JCR\_LIST\_\_ 
22. 00000000004005b0 T \_\_libc\_csu\_fini 
23. 0000000000400540 T \_\_libc\_csu\_init 
24.                  U \_\_libc\_start\_main@@GLIBC\_2.2.5 
25. 000000000040051d T main 
26.                  U printf@@GLIBC\_2.2.5 
27. 0000000000400490 t register\_tm\_clones 
28. 0000000000400430 T \_start 
29. 0000000000601030 D \_\_TMC\_END\_\_ 
30. $

**gdb**

gdb 就是所谓的 GNU debugger。

gdb 大家或多或少都有听说过。我们在使用一些 IDE 写代码的时候，可以进行打断点、步进、查看变量值等方式调试，其实这些 IDE 底层调用的也是 gdb 。

对于 gdb 的用法，可以写很多，本文就暂且不深入了。下面先演示一小段 gdb 最基础的功能。

1.  $ gdb -q ./hello 
2.  Reading symbols from /home/flash/hello...done. 
3.  (gdb) break main 
4.  Breakpoint 1 at 0x400521: file hello.c, line 4. 
5.  (gdb) info break 
6.  Num     Type           Disp Enb Address            What 
7.  1       breakpoint     keep y   0x0000000000400521 in main at hello.c:4 
8.  (gdb) run 
9.  Starting program: /home/flash/./hello  
10.  
11. Breakpoint 1, main () at hello.c:4 
12. 4           printf("Hello world!"); 
13. Missing separate debuginfos, use: debuginfo-install glibc-2.17-260.el7\_6.6.x86\_64 
14. (gdb) bt 
15. \#0  main () at hello.c:4 
16. (gdb) c 
17. Continuing. 
18. Hello world!\[Inferior 1 (process 29620) exited normally\] 
19. (gdb) q 
20. $

**小结**

如果你在 Linux 下进行程序开发的时候，那么你免不了跟二进制文件打交道。熟练使用以上介绍的 10 个命令，将会对你的工作产生很大的帮助。

[http_www.embeddedlinux.org.cn_emb-linux_entry-level_202005_17-9147.html]: http://www.embeddedlinux.org.cn/emb-linux/entry-level/202005/17-9147.html