nganhkhoa/CTF-All-In-One
1
0
Fork 0
mirror of https://github.com/nganhkhoa/CTF-All-In-One.git synced 2024-12-25 11:41:16 +07:00
Code Issues Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
firmianay 2017-07-21 18:01:25 +08:00
parent 82a479a6c4
commit d59bda9f0b
5 changed files with 435 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -26,6 +26,7 @@
- [2.6 pwntools](doc/2.7_pwntools.md) - [2.6 pwntools](doc/2.7_pwntools.md)
- [2.8 zio](doc/2.8_zio.md) - [2.8 zio](doc/2.8_zio.md)
- [2.9 metasploit](doc/2.9_metasploit.md) - [2.9 metasploit](doc/2.9_metasploit.md)
- [2.10 binwalk](doc/2.10_binwalk.md)
- [三、分类专题篇](doc/3_topics.md) - [三、分类专题篇](doc/3_topics.md)
- [3.1 Reverse](doc/3.1_reverse.md) - [3.1 Reverse](doc/3.1_reverse.md)

396
doc/1.5.3_elf.md
View File

@ -1,12 +1,13 @@
# Linux ELF # Linux ELF
- [一个实例](#elfdemo) - [一个实例](#一个实例)
- [目标文件](#object) - [elfdemo.o](#elfdemo.o)
- [ELF 文件结构](#elf-文件结构)
## <span id="elfdemo">一个实例</span> ## 一个实例
在 *1.5.1节 C语言基础* 中我们看到了从源代码到可执行文件的全过程，现在我们来看一个更复杂的例子。 在 *1.5.1节 C语言基础* 中我们看到了从源代码到可执行文件的全过程，现在我们来看一个更复杂的例子。
```text ```c
#include<stdio.h> #include<stdio.h>
int global_init_var = 10; int global_init_var = 10;
@ -30,9 +31,9 @@ void main(void) {
然后分别执行下列命令生成两个文件： 然后分别执行下列命令生成两个文件：
```text ```text
gcc -c elfDemo.c -o elfDemo.o $ gcc -c elfDemo.c -o elfDemo.o
gcc elfDemo.c -o elfDemo $ gcc elfDemo.c -o elfDemo
``` ```
使用 ldd 命令打印所依赖的共享库： 使用 ldd 命令打印所依赖的共享库：
```text ```text
@ -42,14 +43,17 @@ $ ldd elfDemo
/lib/ld-linux.so.2 (0xf76e5000) /lib/ld-linux.so.2 (0xf76e5000)
``` ```
此时他们的结构如图： 使用 file 命令查看相应的文件格式：
![](../pic/1.5.3_elfdemo.png) ```text
$ file elfDemo.o
elfDemo.o: ELF 32-bit LSB relocatable, Intel 80386, version 1 (SYSV), not stripped
$ file elfDemo
elfDemo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=355f04de44bc77b1d0b98f98e80282f8daad2340, not stripped
$ file -L /usr/lib32/libc.so.6
/usr/lib32/libc.so.6: ELF 32-bit LSB shared object, Intel 80386, version 1 (GNU/Linux), dynamically linked, interpreter /usr/lib32/ld-linux.so.2, BuildID[sha1]=449cba91635c01f9cbc303b1c962b38aff6a4431, for GNU/Linux 2.6.32, not stripped
```
可以看到，ELF 文件的开头是一个“文件头”，之后分别是代码段、数据段和.bss段。程序源代码编译后，执行语句变成机器指令，保存在.text段；已初始化的全局变量和局部静态变量都保存在.data段；未初始化的全局变量和局部静态变量则放在.bss段。 于是我们得到了 Linux 可执行文件格式 ELF （Executable Linkable Format）文件的三种类型：
## <span id="object">目标文件</span>
ELF（Executable Linkable Format）是 Linux 的可执行文件格式，是 COFF （Common file format）格式的变种。目标文件主要分为三种类型：
- 可重定位文件（Relocatable file） - 可重定位文件（Relocatable file）
- 包含了代码和数据，可以和其他目标文件链接生成一个可执行文件或共享目标文件。 - 包含了代码和数据，可以和其他目标文件链接生成一个可执行文件或共享目标文件。
- elfDemo.o - elfDemo.o
@ -58,4 +62,368 @@ ELF（Executable Linkable Format）是 Linux 的可执行文件格式，是 COFF
- elfDemo - elfDemo
- 共享目标文件（Shared Object File） - 共享目标文件（Shared Object File）
- 包含了用于链接的代码和数据，分两种情况。一种是链接器将其与其他的可重定位文件和共享目标文件链接起来，生产新的目标文件。另一种是动态链接器将多个共享目标文件与可执行文件结合，作为进程映像的一部分。 - 包含了用于链接的代码和数据，分两种情况。一种是链接器将其与其他的可重定位文件和共享目标文件链接起来，生产新的目标文件。另一种是动态链接器将多个共享目标文件与可执行文件结合，作为进程映像的一部分。
- libc.so.6 - libc-2.25.so
此时他们的结构如图：
![](../pic/1.5.3_elfdemo.png)
可以看到，在这个简化的 ELF 文件中，开头是一个“文件头”，之后分别是代码段、数据段和.bss段。程序源代码编译后，执行语句变成机器指令，保存在`.text`段；已初始化的全局变量和局部静态变量都保存在`.data`段；未初始化的全局变量和局部静态变量则放在`.bss`段。
把程序指令和程序数据分开存放有许多好处，从安全的角度讲，当程序被加载后，数据和指令分别被映射到两个虚拟区域。由于数据区域对于进程来说是可读写的，而指令区域对于进程来说是只读的，所以这两个虚存区域的权限可以被分别设置成可读写和只读，可以防止程序的指令被改写和利用。
### elfDemo.o
接下来，我们更深入地探索目标文件，使用 objdump 来查看目标文件的内部结构:
```text
[firmy@manjaro elfDemo.c_dir]$ objdump -h elfDemo.o
elfDemo.o: file format elf32-i386
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 0000005b 00000000 00000000 00000034 2**0
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1 .data 00000008 00000000 00000000 00000090 2**2
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000004 00000000 00000000 00000098 2**2
ALLOC
3 .rodata 00000004 00000000 00000000 00000098 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .comment 0000001b 00000000 00000000 0000009c 2**0
CONTENTS, READONLY
5 .note.GNU-stack 00000000 00000000 00000000 000000b7 2**0
CONTENTS, READONLY
6 .eh_frame 00000064 00000000 00000000 000000b8 2**2
CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA
```
可以看到目标文件中除了最基本的代码段、数据段和BSS段以外，还有一些别的段。注意到 .bss 段没有 `CONTENTS` 属性，表示它实际上并不存在，.bss 段只是为为未初始化的全局变量和局部静态变量预留了位置而已。
#### 代码段
```text
$ objdump -x -s -d elfDemo.o
......
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 0000005b 00000000 00000000 00000034 2**0
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
......
Contents of section .text:
0000 5589e583 ec0883ec 08ff7508 68000000 U.........u.h...
0010 00e8fcff ffff83c4 1090c9c3 8d4c2404 .............L$.
0020 83e4f0ff 71fc5589 e55183ec 14c745f4 ....q.U..Q....E.
0030 1e000000 8b150000 0000a104 00000001 ................
0040 c28b45f4 01d083ec 0c50e8fc ffffff83 ..E......P......
0050 c410908b 4dfcc98d 61fcc3 ....M...a..
......
Disassembly of section .text:
00000000 <func>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 08 sub $0x8,%esp
6: 83 ec 08 sub $0x8,%esp
9: ff 75 08 pushl 0x8(%ebp)
c: 68 00 00 00 00 push $0x0
11: e8 fc ff ff ff call 12 <func+0x12>
16: 83 c4 10 add $0x10,%esp
19: 90 nop
1a: c9 leave
1b: c3 ret
0000001c <main>:
1c: 8d 4c 24 04 lea 0x4(%esp),%ecx
20: 83 e4 f0 and $0xfffffff0,%esp
23: ff 71 fc pushl -0x4(%ecx)
26: 55 push %ebp
27: 89 e5 mov %esp,%ebp
29: 51 push %ecx
2a: 83 ec 14 sub $0x14,%esp
2d: c7 45 f4 1e 00 00 00 movl $0x1e,-0xc(%ebp)
34: 8b 15 00 00 00 00 mov 0x0,%edx
3a: a1 04 00 00 00 mov 0x4,%eax
3f: 01 c2 add %eax,%edx
41: 8b 45 f4 mov -0xc(%ebp),%eax
44: 01 d0 add %edx,%eax
46: 83 ec 0c sub $0xc,%esp
49: 50 push %eax
4a: e8 fc ff ff ff call 4b <main+0x2f>
4f: 83 c4 10 add $0x10,%esp
52: 90 nop
53: 8b 4d fc mov -0x4(%ebp),%ecx
56: c9 leave
57: 8d 61 fc lea -0x4(%ecx),%esp
5a: c3 ret
```
`Contents of section .text` 是 `.text` 的数据的十六进制形式，总共 0x5b 个字节，最左边一列是偏移量，中间4列是内容，最右边一列是 ASCII 码形式。下面的 `Disassembly of section .text` 是反汇编结果。
#### 数据段和只读数据段
```text
......
Sections:
Idx Name Size VMA LMA File off Algn
1 .data 00000008 00000000 00000000 00000090 2**2
CONTENTS, ALLOC, LOAD, DATA
3 .rodata 00000004 00000000 00000000 00000098 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
......
Contents of section .data:
0000 0a000000 14000000 ........
Contents of section .rodata:
0000 25640a00 %d..
.......
```
`.data` 段保存已经初始化了的全局变量和局部静态变量。`elfDemo.c` 中共有两个这样的变量，`global_init_var` 和 `local_static_init_var`，每个变量4个字节，一共8个字节。由于小端序的原因，`0a000000` 表示 `global_init_var` 值（`10`）的十六进制 `0x0a`，`14000000` 表示 `local_static_init_var` 值（`20`）的十六进制 `0x14`。
`.rodata` 段保存只读数据，包括只读变量和字符串常量。`elfDemo.c` 中调用 `printf` 的时候，用到了一个字符串变量 `%d\n`，它是一种只读数据，保存在 `.rodata` 段中，可以从输出结果看到字符串常量的 ASCII 形式，以 `\0` 结尾。
#### BSS段
```text
Sections:
Idx Name Size VMA LMA File off Algn
2 .bss 00000004 00000000 00000000 00000098 2**2
ALLOC
```
`.bss` 段保存未初始化的全局变量和局部静态变量。
##### objcopy
如果我们要将一个二进制文件，比如图片、MP3音乐等东西作为目标文件中的一个段，可以使用 objcopy 工具，比如我们有一个图片文件 “image.jpg”：
```text
$ objcopy -I binary -O elf32-i386 -B i386 image.jpg image.o
$ objdump -ht image.o
image.o: file format elf32-i386
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 0000642f 00000000 00000000 00000034 2**0
CONTENTS, ALLOC, LOAD, DATA
SYMBOL TABLE:
00000000 l d .data 00000000 .data
00000000 g .data 00000000 _binary_image_jpg_start
0000642f g .data 00000000 _binary_image_jpg_end
0000642f g *ABS* 00000000 _binary_image_jpg_size
```
这一技巧可能出现在 CTF 隐写题中，使用 foremost 工具可以将图片提取出来：
```text
$ foremost image.o
```
## ELF 文件结构
对象文件参与程序链接（构建程序）和程序执行（运行程序）。ELF 结构几相关信息在 `/usr/include/elf.h`　文件中。
![](../pic/1.5.3_format.png)
- **ELF 文件头（ELF Header）** 在目标文件格式的最前面，包含了描述整个文件的基本属性。
- **程序头表（Program Header Table）** 是可选的，它告诉系统怎样创建一个进程映像。可执行文件必须有程序头表，而重定位文件不需要。
- **段（Section）** 包含了链接视图中大量的目标文件信息。
- **段表（Section Header Table）** 包含了描述文件中所有段的信息。
### 32位数据类型
名称 | 长度 | 对其 | 描述 | 原始类型
----|----|----|----|----
Elf32_Addr | 4 | 4 | 无符号程序地址 | uint32_t
Elf32_Half | 2 | 2 | 无符号短整型 | uint16_t
Elf32_Off | 4 | 4 | 无符号偏移地址 | uint32_t
Elf32_Sword | 4 | 4 | 有符号整型 | int32_t
Elf32_Word | 4 | 4 | 无符号整型 | uint32_t
### 文件头
32位 ELF 文件头定义如下：
```text
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 entry count */
Elf32_Half e_shentsize; /* Section header table entry size */
Elf32_Half e_shnum; /* Section header table entry count */
Elf32_Half e_shstrndx; /* Section header string table index */
} Elf32_Ehdr;
```
现在我们使用 readelf 命令来查看 elfDome 的文件头：
```text
$ readelf -h elfDemo
ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Intel 80386
Version: 0x1
Entry point address: 0x8048310
Start of program headers: 52 (bytes into file)
Start of section headers: 6092 (bytes into file)
Flags: 0x0
Size of this header: 52 (bytes)
Size of program headers: 32 (bytes)
Number of program headers: 9
Size of section headers: 40 (bytes)
Number of section headers: 30
Section header string table index: 29
```
### 段
段表（Section Header Table）是一个以 `Elf32_Shdr`　结构体为元素的数组，每个结构体对应一个段，它描述了各个段的信息。ELF 文件头的 `e_shoff`　成员给出了段表在 ELF 中的偏移，`e_shnum` 成员给出了段描述符的数量，`e_shentsize` 给出了每个段描述符的大小。
```text
typedef struct
{
Elf32_Word sh_name; /* Section name (string tbl index) */
Elf32_Word sh_type; /* Section type */
Elf32_Word sh_flags; /* Section flags */
Elf32_Addr sh_addr; /* Section virtual addr at execution */
Elf32_Off sh_offset; /* Section file offset */
Elf32_Word sh_size; /* Section size in bytes */
Elf32_Word sh_link; /* Link to another section */
Elf32_Word sh_info; /* Additional section information */
Elf32_Word sh_addralign; /* Section alignment */
Elf32_Word sh_entsize; /* Entry size if section holds table */
} Elf32_Shdr;
```
使用 readelf 命令查看目标文件中完整的段：
```text
$ readelf -S elfDemo.o
There are 15 section headers, starting at offset 0x424:
Section Headers:
[Nr] Name Type Addr Off Size ES Flg Lk Inf Al
[ 0] NULL 00000000 000000 000000 00 0 0 0
[ 1] .group GROUP 00000000 000034 000008 04 12 16 4
[ 2] .text PROGBITS 00000000 00003c 000078 00 AX 0 0 1
[ 3] .rel.text REL 00000000 000340 000048 08 I 12 2 4
[ 4] .data PROGBITS 00000000 0000b4 000008 00 WA 0 0 4
[ 5] .bss NOBITS 00000000 0000bc 000004 00 WA 0 0 4
[ 6] .rodata PROGBITS 00000000 0000bc 000004 00 A 0 0 1
[ 7] .text.__x86.get_p PROGBITS 00000000 0000c0 000004 00 AXG 0 0 1
[ 8] .comment PROGBITS 00000000 0000c4 00001b 01 MS 0 0 1
[ 9] .note.GNU-stack PROGBITS 00000000 0000df 000000 00 0 0 1
[10] .eh_frame PROGBITS 00000000 0000e0 00007c 00 A 0 0 4
[11] .rel.eh_frame REL 00000000 000388 000018 08 I 12 10 4
[12] .symtab SYMTAB 00000000 00015c 000140 10 13 13 4
[13] .strtab STRTAB 00000000 00029c 0000a2 00 0 0 1
[14] .shstrtab STRTAB 00000000 0003a0 000082 00 0 0 1
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
L (link order), O (extra OS processing required), G (group), T (TLS),
C (compressed), x (unknown), o (OS specific), E (exclude),
p (processor specific)
```
注意，ELF 段表的第一个元素是被保留的，类型为 NULL。
### 字符串表
字符串表以段的形式存在，包含了以 null　结尾的字符序列。对象文件使用这些字符串来表示符号和段名称，引用字符串时只需给出在表中的偏移即可。字符串表的第一个字符和最后一个字符为空字符，以确保所有字符串的开始和终止。通常段名为 `.strtab` 的字符串表是 **字符串表（Strings Table）**，段名为 `.shstrtab` 的是段表字符串表（Section Header String Table）。
偏移 | +0 | +1 | +2 | +3 | +4 | +5 | +6 | +7 | +8 | +9
----|----|----|----|----|----|----|----|----|----|----
**+0** | \0 | h | e | l | l | o | \0 | w | o | r
**+10** | l | d | \0 | h | e | l | l | o | w | o
**+20** | r | l | d | \0
偏移 | 字符串
----|----
0 | 空字符串
1 | hello
7 | world
13 | helloworld
18 | world
### 符号表
目标文件的符号表保存了定位和重定位程序的符号定义和引用所需的信息。符号表索引是这个数组的下标。索引０指向表中的第一个条目，作为未定义的符号索引。
```text
typedef struct
{
Elf32_Word st_name; /* Symbol name (string tbl index) */
Elf32_Addr st_value; /* Symbol value */
Elf32_Word st_size; /* Symbol size */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* Symbol visibility */
Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;
```
查看符号表：
```text
$ readelf -s elfDemo.o
Symbol table '.symtab' contains 20 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 FILE LOCAL DEFAULT ABS elfDemo.c
2: 00000000 0 SECTION LOCAL DEFAULT 2
3: 00000000 0 SECTION LOCAL DEFAULT 4
4: 00000000 0 SECTION LOCAL DEFAULT 5
5: 00000000 0 SECTION LOCAL DEFAULT 6
6: 00000004 4 OBJECT LOCAL DEFAULT 4 local_static_init_var.219
7: 00000000 4 OBJECT LOCAL DEFAULT 5 local_static_uninit_var.2
8: 00000000 0 SECTION LOCAL DEFAULT 7
9: 00000000 0 SECTION LOCAL DEFAULT 9
10: 00000000 0 SECTION LOCAL DEFAULT 10
11: 00000000 0 SECTION LOCAL DEFAULT 8
12: 00000000 0 SECTION LOCAL DEFAULT 1
13: 00000000 4 OBJECT GLOBAL DEFAULT 4 global_init_var
14: 00000004 4 OBJECT GLOBAL DEFAULT COM global_uninit_var
15: 00000000 46 FUNC GLOBAL DEFAULT 2 func
16: 00000000 0 FUNC GLOBAL HIDDEN 7 __x86.get_pc_thunk.ax
17: 00000000 0 NOTYPE GLOBAL DEFAULT UND _GLOBAL_OFFSET_TABLE_
18: 00000000 0 NOTYPE GLOBAL DEFAULT UND printf
19: 0000002e 74 FUNC GLOBAL DEFAULT 2 main
```
### 重定位
重定位是连接符号定义与符号引用的过程。可重定位文件必须具有描述如何修改段内容的信息，从而运行可执行文件和共享对象文件保存进程程序映像的正确信息。
```text
/* Relocation table entry without addend (in section of type SHT_REL). */
typedef struct
{
Elf32_Addr r_offset; /* Address */
Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;
/* Relocation table entry with addend (in section of type SHT_RELA). */
typedef struct
{
Elf32_Addr r_offset; /* Address */
Elf32_Word r_info; /* Relocation type and symbol index */
Elf32_Sword r_addend; /* Addend */
} Elf32_Rela;
```
查看重定位表：
```text
$ readelf -r elfDemo.o
Relocation section '.rel.text' at offset 0x340 contains 9 entries:
Offset Info Type Sym.Value Sym. Name
00000008 00001002 R_386_PC32 00000000 __x86.get_pc_thunk.ax
0000000d 0000110a R_386_GOTPC 00000000 _GLOBAL_OFFSET_TABLE_
00000019 00000509 R_386_GOTOFF 00000000 .rodata
00000021 00001204 R_386_PLT32 00000000 printf
00000040 00001002 R_386_PC32 00000000 __x86.get_pc_thunk.ax
00000045 0000110a R_386_GOTPC 00000000 _GLOBAL_OFFSET_TABLE_
00000052 00000d09 R_386_GOTOFF 00000000 global_init_var
00000058 00000309 R_386_GOTOFF 00000000 .data
00000068 00000f02 R_386_PC32 00000000 func
Relocation section '.rel.eh_frame' at offset 0x388 contains 3 entries:
Offset Info Type Sym.Value Sym. Name
00000020 00000202 R_386_PC32 00000000 .text
00000044 00000202 R_386_PC32 00000000 .text
00000070 00000802 R_386_PC32 00000000 .text.__x86.get_pc_thu
```

1
doc/2.10_binwalk.md Normal file
View File

@ -0,0 +1 @@
# binwalk

50
doc/6.1_Linuxtools.md
View File

@ -1,7 +1,9 @@
# 6.1 更多 Linux 工具 # 6.1 更多 Linux 工具
- [dd](#dd)
- [file](#file) - [file](#file)
- [edb](#edb) - [edb](#edb)
- [foremost](#foremost)
- [ldd](#ldd) - [ldd](#ldd)
- [ltrace](#ltrace) - [ltrace](#ltrace)
- [md5sum](#md5sum) - [md5sum](#md5sum)
@ -12,19 +14,45 @@
- [strings](#strings) - [strings](#strings)
- [xxd](#xxd) - [xxd](#xxd)
## <span id="file">file</span>
## dd
用于复制文件并对原文件的内容进行转换和格式化处理。
#### 重要参数
```text
if=FILE read from FILE instead of stdin
of=FILE write to FILE instead of stdout
skip=N skip N ibs-sized blocks at start of input
bs=BYTES read and write up to BYTES bytes at a time
```
#### 常见用法
```text
$ dd if=[file1] of=[file2] skip=[size] bs=[bytes]
```
## file
**file** 命令用来探测给定文件的类型。 **file** 命令用来探测给定文件的类型。
## <span id="edb">edb</span> ## edb
**edb** 是一个同时支持x86、x86-64的调试器。它主要向 OllyDbg 工具看齐，并可通过插件体系进行功能的扩充。 **edb** 是一个同时支持x86、x86-64的调试器。它主要向 OllyDbg 工具看齐，并可通过插件体系进行功能的扩充。
## <span id="ldd">ldd</span> ## foremost
foremost是一个基于文件文件头和尾部信息以及文件的内建数据结构恢复文件的命令行工具。
#### 安装
```text
$ yaourt -S foremost
```
## ldd
用于打印程序或者库文件所依赖的共享库列表。 用于打印程序或者库文件所依赖的共享库列表。
## <span id="ltrace">ltrace</span> ## ltrace
**ltrace** 命令用于跟踪进程调用库函数的情况。 **ltrace** 命令用于跟踪进程调用库函数的情况。
#### 重要参数 #### 重要参数
@ -35,7 +63,7 @@
``` ```
## <span id="md5sum">md5sum</span> ## md5sum
**md5sum** 命令采用MD5报文摘要算法（128位）计算和检查文件的校验和。 **md5sum** 命令采用MD5报文摘要算法（128位）计算和检查文件的校验和。
#### 重要参数 #### 重要参数
@ -45,7 +73,7 @@
``` ```
## <span id="objdump">objdump</span> ## objdump
**objdump** 命令是用查看目标文件或者可执行的目标文件的构成的gcc工具。 **objdump** 命令是用查看目标文件或者可执行的目标文件的构成的gcc工具。
#### 重要参数 #### 重要参数
@ -71,7 +99,7 @@ for i in `objdump -d print_flag | tr '\t' ' ' | tr ' ' '\n' | egrep '^[0-9a-f]{2
``` ```
## <span id="readelf">readelf</span> ## readelf
**readelf** 命令用来显示一个或者多个 elf 格式的目标文件的信息，可以通过它的选项来控制显示哪些信息。 **readelf** 命令用来显示一个或者多个 elf 格式的目标文件的信息，可以通过它的选项来控制显示哪些信息。
#### 重要参数 #### 重要参数
@ -89,7 +117,7 @@ readelf -s [path/to/library.so] | grep [function_name]
``` ```
## <span id="ssdeep">ssdeep</span> ## ssdeep
模糊哈希算法又叫基于内容分割的分片分片哈希算法（context triggered piecewise hashing, CTPH），主要用于文件的相似性比较。 模糊哈希算法又叫基于内容分割的分片分片哈希算法（context triggered piecewise hashing, CTPH），主要用于文件的相似性比较。
#### 重要参数 #### 重要参数
@ -105,7 +133,7 @@ ssdeep -bm hash.txt modified.elf
``` ```
## <span id="strace">strace</span> ## strace
**strace** 命令对应用的系统调用和信号传递的跟踪结果进行分析，以达到解决问题或者是了解应用工作过程的目的。 **strace** 命令对应用的系统调用和信号传递的跟踪结果进行分析，以达到解决问题或者是了解应用工作过程的目的。
#### 重要参数 #### 重要参数
@ -118,7 +146,7 @@ ssdeep -bm hash.txt modified.elf
``` ```
## <span id="strings">strings</span> ## strings
**strings** 命令在对象文件或二进制文件中查找可打印的字符串。字符串是4个或更多可打印字符的任意序列，以换行符或空字符结束。strings命令对识别随机对象文件很有用。 **strings** 命令在对象文件或二进制文件中查找可打印的字符串。字符串是4个或更多可打印字符的任意序列，以换行符或空字符结束。strings命令对识别随机对象文件很有用。
#### 重要参数 #### 重要参数
@ -148,7 +176,7 @@ strings [executable] | grep -i upx
[flag_pwnablekr](../source/Reverse/flag_pwnablekr) [flag_pwnablekr](../source/Reverse/flag_pwnablekr)
## <span id="xxd">xxd</span> ## xxd
**xxd** 的作用就是将一个文件以十六进制的形式显示出来。 **xxd** 的作用就是将一个文件以十六进制的形式显示出来。
#### 重要参数： #### 重要参数：

BIN
pic/1.5.3_format.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB