PE 与 ELF 二进制文件完全指南
PE(Portable Executable)和 ELF(Executable and Linkable Format)分别是 Windows 和 Linux 系统中最核心的可执行文件格式。理解这两种格式是逆向分析、病毒分析、免杀技术、软件安全的基石。
一、为什么需要理解 PE 和 ELF
1.1 操作系统与二进制格式
| 操作系统 | 可执行格式 | 动态库格式 | 目标文件格式 |
|---|---|---|---|
| Windows | PE (.exe) | PE (.dll) | COFF (.obj) |
| Linux | ELF | ELF (.so) | ELF (.o) |
| macOS | Mach-O | Mach-O (.dylib) | Mach-O (.o) |
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
1.2 二进制文件的核心作用
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
二、PE 文件格式
2.1 PE 文件结构总览
| 偏移 | 结构 | 大小 | 内容 |
|---|---|---|---|
| 0x00 | DOS MZ 头 | 64 字节 | e_magic = "MZ" |
| 0x40 | DOS Stub | 可变 | "This program cannot be run in DOS" |
e_lfanew |
PE 签名 | 4 字节 | "PE\0\0" |
| +4 | FILE 头 (COFF) | 20 字节 | Machine / NumberOfSections / … |
| +24 | OPTIONAL 头 | 96-128 字节 | EntryPoint / ImageBase / … |
| 之后 | DATA DIRECTORY 数组 | 16 字节 × 16 | Import / Export / Resource / … |
| 之后 | SECTION 表 | 40 字节 × N | .text / .data / .rdata / .rsrc |
| 之后 | SECTION 1: .text | 可变 | 代码段(可执行) |
| 之后 | SECTION 2: .data | 可变 | 初始化的全局变量 |
| 之后 | SECTION 3: .rdata | 可变 | 只读数据 / 导入表 / 导出表 |
| 之后 | SECTION 4: .rsrc | 可变 | 图标 / 版本 / 对话框 |
2.2 DOS 头与 DOS Stub
每个 PE 文件以 DOS MZ 头开头,确保在 DOS 下运行时显示提示信息:
C
typedef struct _IMAGE_DOS_HEADER {
WORD e_magic; // 0x5A4D = "MZ"(标识这是一个 DOS 可执行)
WORD e_cblp; // 字节数
WORD e_cp; // 页数
WORD e_crlc; // 重定位项数
WORD e_cparhdr; // 头部大小
WORD e_minalloc; // 最小额外段数
WORD e_maxalloc; // 最大额外段数
WORD e_ss; // 初始 SS 值
WORD e_sp; // 初始 SP 值
WORD e_csum; // 校验和
WORD e_ip; // 初始 IP 值
WORD e_cs; // 初始 CS 值
WORD e_lfarlc; // 重定位表偏移
WORD e_ovno; // 覆盖号
WORD e_res[4]; // 保留
WORD e_oemid; // OEM ID
WORD e_oeminfo; // OEM 信息
WORD e_res2[10]; // 保留
LONG e_lfanew; // 指向 PE 头的偏移(关键字段!)
} IMAGE_DOS_HEADER;
// e_lfanew 字段指向真正的 PE 头
// 解析 PE 文件的第一步:
// 1. 读取文件前 64 字节(DOS 头)
// 2. 验证 e_magic == "MZ"
// 3. 读取 e_lfanew 获取 PE 头偏移
// 4. 跳转到 e_lfanew 处读取 PE 头
2.3 PE 签名与 FILE 头
C
// PE 签名(4 字节)
// 位于 DOS 头 e_lfanew 指向的位置
// 值为 "PE\0\0" (0x00004550)
typedef struct _IMAGE_FILE_HEADER {
WORD Machine; // 目标 CPU 架构
WORD NumberOfSections; // 节的数量
DWORD TimeDateStamp; // 编译时间戳
DWORD PointerToSymbolTable; // COFF 符号表偏移(调试用)
DWORD NumberOfSymbols; // 符号数量
WORD SizeOfOptionalHeader; // OPTIONAL 头大小
WORD Characteristics; // 文件属性标志
} IMAGE_FILE_HEADER;
Machine 字段常见值:
| 值 | 架构 | 说明 |
|---|---|---|
| 0x014C | x86 (I386) | 32 位 PE |
| 0x8664 | x86-64 (AMD64) | 64 位 PE |
| 0x01C4 | ARM | ARM 32 位 |
| 0xAA64 | ARM64 | ARM 64 位 |
Characteristics 重要标志:
| 标志 | 值 | 含义 |
|---|---|---|
| IMAGE_FILE_EXECUTABLE_IMAGE | 0x0002 | 该文件是可执行的 |
| IMAGE_FILE_DLL | 0x2000 | 该文件是 DLL |
| IMAGE_FILE_32BIT_MACHINE | 0x0100 | 32 位程序 |
| IMAGE_FILE_LARGE_ADDRESS_AWARE | 0x0020 | 可访问大于 2GB 地址空间 |
| IMAGE_FILE_RELOCS_STRIPPED | 0x0001 | 重定位信息被移除(不能 ASLR) |
2.4 OPTIONAL 头
尽管名字叫 Optional,但对于 PE 可执行文件这是必需的。
C
typedef struct _IMAGE_OPTIONAL_HEADER64 {
// 标准字段
WORD Magic; // 0x10B = PE32, 0x20B = PE32+
BYTE MajorLinkerVersion; // 链接器版本
BYTE MinorLinkerVersion;
DWORD SizeOfCode; // 代码段大小
DWORD SizeOfInitializedData; // 已初始化数据大小
DWORD SizeOfUninitializedData;// 未初始化数据大小
DWORD AddressOfEntryPoint; // 入口点 RVA(程序开始执行的位置)
DWORD BaseOfCode; // 代码基址
// Windows 特定字段
ULONGLONG ImageBase; // 首选加载基址(如 0x00400000)
DWORD SectionAlignment; // 内存中对齐(通常 0x1000 = 4KB)
DWORD FileAlignment; // 文件中对齐(通常 0x200 = 512 字节)
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion; // 子系统版本(如 5.02 = XP x64)
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage; // 内存中映像大小
DWORD SizeOfHeaders; // 所有头的大小
DWORD CheckSum; // 校验和
WORD Subsystem; // 子系统(GUI/CUI/EFI)
WORD DllCharacteristics; // DLL 特性标志
ULONGLONG SizeOfStackReserve; // 栈保留大小
ULONGLONG SizeOfStackCommit; // 栈提交大小
ULONGLONG SizeOfHeapReserve; // 堆保留大小
ULONGLONG SizeOfHeapCommit; // 堆提交大小
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes; // DATA DIRECTORY 数组大小(通常为 16)
IMAGE_DATA_DIRECTORY DataDirectory[16];
} IMAGE_OPTIONAL_HEADER64;
关键字段详解:
| 字段 | 典型值 | 作用 |
|---|---|---|
| Magic | 0x10B/0x20B | 区分 32/64 位 |
| AddressOfEntryPoint | 0x1000 | 程序入口(OEP) |
| ImageBase | 0x00400000 | 默认加载基址(EXE) |
| Subsystem | 2(GUI)/3(CUI) | 控制台还是窗口程序 |
| SizeOfImage | 0x12000 | 整个内存映像大小 |
| DllCharacteristics | 0x0140 | ASLR/DEP/SafeSEH |
2.5 DATA DIRECTORY(数据目录)
C
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress; // 目录的 RVA
DWORD Size; // 大小
} IMAGE_DATA_DIRECTORY;
// 索引含义
#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // 导出表
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // 导入表
#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // 资源
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // 异常处理
#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // 安全证书
#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // 基址重定位
#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // 调试信息
#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 // 体系结构
#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // 全局指针
#define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS 回调
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // 加载配置
#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 // 绑定导入
#define IMAGE_DIRECTORY_ENTRY_IAT 12 // IAT(导入地址表)
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 // 延迟导入
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 // COM 描述符
2.6 SECTION 表
C
typedef struct _IMAGE_SECTION_HEADER {
BYTE Name[8]; // 节名称(如 ".text")
DWORD VirtualSize; // 内存中大小
DWORD VirtualAddress; // 内存中 RVA
DWORD SizeOfRawData; // 文件中大小
DWORD PointerToRawData; // 文件中的偏移
DWORD PointerToRelocations; // 重定位偏移
DWORD PointerToLinenumbers; // 行号偏移
WORD NumberOfRelocations; // 重定位数量
WORD NumberOfLinenumbers; // 行号数量
DWORD Characteristics; // 属性标志
} IMAGE_SECTION_HEADER;
常见节表:
| 节名称 | 内容 | Characteristics | 权限 |
|---|---|---|---|
.text |
可执行代码(CPU 指令) | 0x60000020 | 读 + 执行 |
.data |
初始化的全局/静态变量 | 0xC0000040 | 读 + 写 |
.rdata |
只读数据(导入表/导出表/常量) | 0x40000040 | 只读 |
.idata |
导入表(通常合并在 .rdata 中) | 0x40000040 | 只读 |
.edata |
导出表(DLL 导出函数列表) | 0x40000040 | 只读 |
.pdata |
异常处理函数表(64 位) | 0x40000040 | 只读 |
.reloc |
基址重定位表 | 0x42000040 | 可丢弃 |
.rsrc |
资源(图标/版本信息/对话框) | 0x40000040 | 只读 |
.tls |
线程局部存储 | 0xC0000040 | 读 + 写 |
.bss |
未初始化的数据(文件中不占空间) | 0xC0000080 | 读 + 写 |
2.7 导入表(IAT)
导入表是 PE 文件中最重要的数据结构之一,记录了程序用到的所有外部 DLL 和函数。逆向分析的第一步就是看导入表。
C
// 导入表结构(每个导入的 DLL 对应一个)
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union { DWORD Characteristics; DWORD OriginalFirstThunk; }; // INT 数组 RVA
DWORD TimeDateStamp;
DWORD ForwarderChain;
DWORD Name; // DLL 名称字符串的 RVA
DWORD FirstThunk; // IAT 数组 RVA
} IMAGE_IMPORT_DESCRIPTOR;
// 每个导入函数对应一个 IMAGE_THUNK_DATA
typedef struct _IMAGE_THUNK_DATA64 {
union {
ULONGLONG ForwarderString;
ULONGLONG Function; // 函数地址(加载后填充)
ULONGLONG Ordinal; // 序号(如果最高位为 1)
ULONGLONG AddressOfData; // IMAGE_IMPORT_BY_NAME 的 RVA
} u1;
} IMAGE_THUNK_DATA64;
// 按名称导入时的结构
typedef struct _IMAGE_IMPORT_BY_NAME {
WORD Hint; // 提示序号(可选)
BYTE Name[1]; // 函数名(以 0 结尾的可变长度字符串)
} IMAGE_IMPORT_BY_NAME;
导入表解析流程:
CODE
1. 从 DATA DIRECTORY[1] 获取导入表 RVA 和大小
2. 转换为文件偏移
3. 读取 IMAGE_IMPORT_DESCRIPTOR 数组(以全 0 条目结束)
4. 对每个条目:
a. 从 Name 字段获取 DLL 名称
b. 从 OriginalFirstThunk 获取 INT 数组
c. 遍历 INT 数组中的每个 IMAGE_THUNK_DATA:
- 如果最高位为 1 → 按序号导入
- 否则 → IMAGE_IMPORT_BY_NAME 结构获取函数名
2.8 导出表
DLL 文件通过导出表暴露函数给其他程序调用:
C
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
DWORD Name; // DLL 名称
DWORD Base; // 起始序号
DWORD NumberOfFunctions; // 函数数量
DWORD NumberOfNames; // 有名函数数量
DWORD AddressOfFunctions; // 函数地址数组 RVA
DWORD AddressOfNames; // 函数名称数组 RVA
DWORD AddressOfNameOrdinals;// 序号数组 RVA
} IMAGE_EXPORT_DIRECTORY;
2.9 资源段(.rsrc)
PE 资源采用三层树形结构:
CODE
资源目录结构:
.resource
├── Type ID (如 RT_ICON = 1, RT_VERSION = 16)
│ ├── Name ID (如 101, 或字符串 ID)
│ │ └── Language ID (如 0x0804 = 中文)
│ │ └── 实际资源数据
│ ├── Name ID (102)
│ │ └── Language ID (0x0409 = 英文)
│ │ └── 实际资源数据
│ └── ...
├── 图标 (RT_GROUP_ICON, RT_ICON)
├── 版本信息 (RT_VERSION)
├── 清单文件 (RT_MANIFEST)
└── 对话框 (RT_DIALOG)
常见资源类型:
| 资源类型 | 含义 | 二进制分析价值 |
|---|---|---|
| RT_ICON / RT_GROUP_ICON | 程序图标 | 可用来识别恶意软件家族 |
| RT_VERSION | 版本信息 | 包含原始文件名、公司名等信息 |
| RT_MANIFEST | UAC 权限请求 | Vista+ 程序的提权请求级别 |
| RT_DIALOG | 对话框布局 | 复现程序界面 |
| RT_STRING | 字符串表 | 程序中的提示信息 |
| RT_MENU | 菜单定义 | 功能结构 |
| RT_RCDATA | 自定义资源 | 可能包含加密/打包数据 |
2.10 PE 文件分析工具
BASH
# dumpbin(VS 自带)
dumpbin /headers program.exe # 查看文件头
dumpbin /imports program.exe # 查看导入表
dumpbin /exports program.exe # 查看 DLL 导出
dumpbin /disasm program.exe # 反汇编
# CFF Explorer(Windows GUI)
# 可视化查看和编辑 PE 文件各个部分
# PE-bear
# 跨平台 PE 分析工具
# readpe / pev
readpe program.exe
pedump program.exe
# LordPE / Stud_PE(旧但好用)
# 查看 PE 头、节表、导入导出表
# UPX / PECompact(脱壳工具)
# 脱壳后分析原始 PE 结构
三、ELF 文件格式
3.1 ELF 文件结构总览
| 偏移 | 结构 | 大小 | 视图 | 内容 |
|---|---|---|---|---|
| 0x00 | ELF 头 | 64/52 字节 | 全部 | e_ident / e_type / e_entry / … |
e_phoff |
程序头表(Program Headers) | 56 字节 × e_phnum |
执行视图 | PT_LOAD / PT_DYNAMIC / PT_INTERP |
e_shoff |
节头表(Section Headers) | 64 字节 × e_shnum |
链接视图 | .text / .data / .bss / .symtab |
| 之后 | 各个节(Sections) | 可变 | 链接视图 | .text(代码段) |
| 之后 | .data(数据段) | |||
| 之后 | .rodata(只读数据) | |||
| 之后 | .bss(未初始化数据) | |||
| 之后 | .symtab / .strtab(符号表) |
ELF 有两种视图:
- 链接视图(Linking View):编译器/链接器使用,通过节头表组织
- 执行视图(Execution View):加载器使用,通过程序头表组织
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
3.2 ELF 头
C
typedef struct {
unsigned char e_ident[16]; // ELF 标识魔数
uint16_t e_type; // 文件类型
uint16_t e_machine; // 目标架构
uint32_t e_version; // 版本
uint64_t e_entry; // 入口点(虚拟地址)
uint64_t e_phoff; // 程序头表偏移
uint64_t e_shoff; // 节头表偏移
uint32_t e_flags; // 标志
uint16_t e_ehsize; // ELF 头大小
uint16_t e_phentsize; // 程序头表条目大小
uint16_t e_phnum; // 程序头表条目数
uint16_t e_shentsize; // 节头表条目大小
uint16_t e_shnum; // 节头表条目数
uint16_t e_shstrndx; // 节名字符串表索引
} Elf64_Ehdr;
e_ident 魔数详解:
CODE
e_ident[0] = 0x7F → 固定魔数
e_ident[1] = 'E' (0x45) → ELF
e_ident[2] = 'L' (0x4C)
e_ident[3] = 'F' (0x46)
e_ident[4] = 1 (32位) / 2 (64位) → Class
e_ident[5] = 1 (小端) / 2 (大端) → Data
e_ident[6] = 1 (当前版本) → Version
e_ident[7-15] = 0 (填充) → Padding
e_type 文件类型:
| 值 | 名称 | 说明 |
|---|---|---|
| 0 | ET_NONE | 未知类型 |
| 1 | ET_REL | 可重定位文件 (.o) |
| 2 | ET_EXEC | 可执行文件 |
| 3 | ET_DYN | 共享目标文件 (.so) |
| 4 | ET_CORE | 核心转储文件 |
e_machine 架构:
| 值 | 架构 |
|---|---|
| 3 | i386 (x86) |
| 62 | x86-64 (AMD64) |
| 40 | ARM |
| 183 | AArch64 (ARM64) |
3.3 程序头表(Program Headers)
程序头表是 ELF 执行视图的核心,告诉加载器如何将文件映射到内存:
C
typedef struct {
uint32_t p_type; // 段类型
uint32_t p_flags; // 权限(读/写/执行)
uint64_t p_offset; // 文件中的偏移
uint64_t p_vaddr; // 虚拟地址
uint64_t p_paddr; // 物理地址(通常不用)
uint64_t p_filesz; // 文件中大小
uint64_t p_memsz; // 内存中大小
uint64_t p_align; // 对齐
} Elf64_Phdr;
p_type 段类型:
| 类型 | 值 | 说明 |
|---|---|---|
| PT_NULL | 0 | 未使用的条目 |
| PT_LOAD | 1 | 可加载段(最重要,加载到内存) |
| PT_DYNAMIC | 2 | 动态链接信息 |
| PT_INTERP | 3 | 解释器路径(如 /lib64/ld-linux-x86-64.so.2) |
| PT_NOTE | 4 | 注释信息 |
| PT_PHDR | 6 | 程序头表自身 |
| PT_TLS | 7 | 线程局部存储 |
| PT_GNU_EH_FRAME | 0x6474e550 | 异常处理帧 |
| PT_GNU_STACK | 0x6474e551 | 栈权限标志 |
| PT_GNU_RELRO | 0x6474e552 | 重定位只读 |
典型 ELF 可执行文件的程序头:
CODE
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x0005d8 0x0005d8 R E 0x1000
LOAD 0x000e20 0x0000000000001e20 0x0000000000001e20 0x000240 0x000248 RW 0x1000
DYNAMIC 0x000e38 0x0000000000001e38 0x0000000000001e38 0x0001c0 0x0001c0 RW 0x8
INTERP 0x000238 0x0000000000000238 0x0000000000000238 0x00001c 0x00001c R 0x1
GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW 0x10
GNU_RELRO 0x000e38 0x0000000000001e38 0x0000000000001e38 0x0001c8 0x0001c8 R 0x1
- 第一个 LOAD 段:代码段(R E),包含 .text
- 第二个 LOAD 段:数据段(RW),包含 .data / .bss
- INTERP:指定动态链接器路径
- GNU_STACK:栈权限(RW 表示可执行栈,仅 RW 表示 NX 栈)
3.4 节头表(Section Headers)
节头表是 ELF 链接视图的核心,记录每个节的信息:
C
typedef struct {
uint32_t sh_name; // 节名称在 .shstrtab 中的偏移
uint32_t sh_type; // 节类型
uint64_t sh_flags; // 标志
uint64_t sh_addr; // 内存地址(如果加载)
uint64_t sh_offset; // 文件偏移
uint64_t sh_size; // 大小
uint32_t sh_link; // 关联的节索引
uint32_t sh_info; // 附加信息
uint64_t sh_addralign; // 对齐
uint64_t sh_entsize; // 条目标条目大小
} Elf64_Shdr;
常见节类型:
| 类型 | 值 | 说明 |
|---|---|---|
| SHT_NULL | 0 | 未使用 |
| SHT_PROGBITS | 1 | 程序数据(.text, .data, .rodata) |
| SHT_SYMTAB | 2 | 符号表(.symtab) |
| SHT_STRTAB | 3 | 字符串表(.strtab, .shstrtab) |
| SHT_RELA | 4 | 重定位表(.rela.text) |
| SHT_HASH | 5 | 符号哈希表 |
| SHT_DYNAMIC | 6 | 动态链接信息(.dynamic) |
| SHT_NOTE | 7 | 注释 |
| SHT_NOBITS | 8 | 文件中不占空间(.bss) |
| SHT_REL | 9 | 重定位表 |
| SHT_DYNSYM | 11 | 动态符号表(.dynsym) |
| SHT_INIT_ARRAY | 14 | 初始化函数数组(.init_array) |
| SHT_FINI_ARRAY | 15 | 结束函数数组(.fini_array) |
常见节表:
| 节名称 | 类型 | 用途 |
|---|---|---|
| .text | SHT_PROGBITS | 代码段,CPU 指令 |
| .data | SHT_PROGBITS | 已初始化的全局变量 |
| .rodata | SHT_PROGBITS | 只读数据(字符串常量) |
| .bss | SHT_NOBITS | 未初始化全局变量(文件中 0 大小) |
| .plt | SHT_PROGBITS | 过程链接表(动态链接跳转) |
| .got | SHT_PROGBITS | 全局偏移表(动态链接地址) |
| .got.plt | SHT_PROGBITS | GOT 中 PLT 部分 |
| .dynsym | SHT_DYNSYM | 动态符号表 |
| .dynstr | SHT_STRTAB | 动态符号字符串表 |
| .rela.plt | SHT_RELA | PLT 重定位表 |
| .init | SHT_PROGBITS | 构造函数 |
| .fini | SHT_PROGBITS | 析构函数 |
| .init_array | SHT_INIT_ARRAY | 构造函数数组(顺序执行) |
| .fini_array | SHT_FINI_ARRAY | 析构函数数组 |
| .dynamic | SHT_DYNAMIC | 动态链接信息 |
| .symtab | SHT_SYMTAB | 符号表(调试/链接用) |
| .strtab | SHT_STRTAB | 符号表字符串 |
| .shstrtab | SHT_STRTAB | 节名表 |
| .comment | SHT_PROGBITS | 编译器版本信息 |
| .note.ABI-tag | SHT_NOTE | ABI 兼容性标识 |
3.5 动态链接(.dynamic / .plt / .got)
ELF 的动态链接机制使得程序可以在运行时加载共享库:
C
// .dynamic 节中的条目
typedef struct {
uint64_t d_tag; // 类型
union {
uint64_t d_val; // 整数值
uint64_t d_ptr; // 指针值
} d_un;
} Elf64_Dyn;
常见 d_tag:
| 标签 | 值 | 说明 |
|---|---|---|
| DT_NEEDED | 1 | 依赖的共享库名(在 .dynstr 中的偏移) |
| DT_INIT | 12 | .init 函数地址 |
| DT_FINI | 13 | .fini 函数地址 |
| DT_INIT_ARRAY | 25 | .init_array 地址 |
| DT_INIT_ARRAYSZ | 27 | .init_array 大小 |
| DT_FINI_ARRAY | 26 | .fini_array 地址 |
| DT_FINI_ARRAYSZ | 28 | .fini_array 大小 |
| DT_RPATH | 15 | 库搜索路径 |
| DT_RUNPATH | 29 | 库搜索路径(优先) |
| DT_SYMBOLIC | 16 | 优先使用本库符号 |
| DT_FLAGS | 30 | 动态链接标志 |
PLT/GOT 工作机制:
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
延迟绑定(Lazy Binding):
- 函数地址在第一次被调用时才解析,而非程序启动时
- 减少启动时间和无用的函数解析
- 通过 PLT 第一次跳转时触发解析器
- 后续调用直接跳转到 GOT 中已解析的地址
3.6 符号表
C
typedef struct {
uint32_t st_name; // 符号名称在字符串表中的偏移
unsigned char st_info; // 符号类型和绑定信息
unsigned char st_other; // 可见性
uint16_t st_shndx; // 关联的节索引
uint64_t st_value; // 符号值(地址或偏移)
uint64_t st_size; // 符号大小
} Elf64_Sym;
st_info 编码:
CODE
高位 4 位 = 绑定(Binding)
0 = STB_LOCAL(局部符号,带 static 的变量/函数)
1 = STB_GLOBAL(全局符号)
2 = STB_WEAK(弱符号)
低位 4 位 = 类型(Type)
0 = STT_NOTYPE(未指定)
1 = STT_OBJECT(数据对象)
2 = STT_FUNC(函数)
3 = STT_SECTION(节)
4 = STT_FILE(文件名)
3.7 ELF 分析工具
BASH
# readelf(最核心的 ELF 分析工具)
readelf -h program # ELF 头
readelf -l program # 程序头表
readelf -S program # 节头表
readelf -d program # 动态链接信息
readelf -s program # 符号表
readelf -r program # 重定位表
readelf -n program # NOTE 段
readelf --notes program # 注释信息
# objdump
objdump -d program # 反汇编
objdump -t program # 符号表
objdump -R program # 动态重定位
objdump -x program # 全部信息
# nm(列出符号)
nm program # 所有符号
nm -D program # 动态符号
nm -C program # C++ 符号还原(demangle)
# strings(提取字符串)
strings program
strings program | grep -i "version\|compile\|gcc\|glibc"
# strip(去除符号)
strip program # 移除符号表(减小文件,增加分析难度)
四、PE 与 ELF 对比
4.1 结构对比
| 特性 | PE | ELF |
|---|---|---|
| 魔数 | “MZ” (4D 5A) | 0x7F “ELF” |
| 头结构 | DOS 头 + PE 头 + 节表 | ELF 头 + 程序头表 + 节头表 |
| 节/段命名 | 固定名称 (.text/.data/.rsrc) | 自由命名(但约定一致) |
| 导入机制 | 导入表(IDT/IAT) | PLT/GOT + .dynamic |
| 导出机制 | 导出表(EDT) | .dynsym + .dynstr |
| 资源管理 | 内置 .rsrc 段(树形结构) | 无标准资源段(通常用 .rodata) |
| 重定位 | .reloc 段 | .rela.text / .rela.plt |
| TLS | .tls 段 + TLS 目录 | PT_TLS 段 |
| 异常处理 | .pdata + SEH | .eh_frame / .gcc_except_table |
| 调试信息 | .debug 段 / PDB 文件 | DWARF (.debug_*) |
| ASLR 支持 | DLL Characteristics 标志位 | PIE (Position Independent Executable) |
| NX 支持 | IMAGE_DLLCHARACTERISTICS_NX_COMPAT | PT_GNU_STACK |
4.2 加载过程对比
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
4.3 文件扩展与工具链
| 扩展名 | 格式 | 系统 | 用途 |
|---|---|---|---|
| .exe | PE | Windows | 可执行程序 |
| .dll | PE | Windows | 动态链接库 |
| .sys | PE | Windows | 驱动程序 |
| .obj | COFF | Windows | 目标文件 |
| .lib | COFF/PE | Windows | 静态库/导入库 |
| - | ELF | Linux | 可执行程序(无扩展名) |
| .so | ELF | Linux | 共享对象(动态库) |
| .o | ELF | Linux | 目标文件 |
| .a | AR | Linux | 静态库 |
| .ko | ELF | Linux | 内核模块 |
五、二进制文件在安全领域的应用
5.1 恶意软件分析
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
5.2 导入表与恶意行为关联
C
// 通过导入表可以推测程序的功能
// 常见恶意行为的 API 组合:
// 进程注入
OpenProcess + VirtualAllocEx + WriteProcessMemory + CreateRemoteThread
// 键盘记录
SetWindowsHookEx / GetAsyncKeyState + GetForegroundWindow
// 持久化
RegSetValueEx(SOFTWARE\Microsoft\Windows\CurrentVersion\Run)
CreateService
// 网络通信
socket + connect + send + recv
InternetOpen + InternetOpenUrl
// 文件操作(病毒传播)
CopyFile + CreateFile + WriteFile + DeleteFile
// 加密/解密(勒索病毒)
CryptAcquireContext + CryptEncrypt + CryptDecrypt
// 反调试
IsDebuggerPresent + NtQueryInformationProcess + OutputDebugString
5.3 PE/ELF 与免杀
二进制文件的结构特征被用于恶意软件检测:
BASH
# 静态检测指标(AV/EDR 检查的 PE 特征)
# 1. 节名称异常
# .text 改名为 .upx / .themida / .vmp0 = 可能加壳
# 罕见节名 = 可疑
# 2. 节权限异常
# .data 段有执行权限 = 可疑(代码和数据混在一起)
# .text 段有写权限 = 可疑(自修改代码)
# 3. 入口点异常
# 入口点在 .text 外的段 = 加壳特征
# EntryPoint 指向 .rsrc 或最后段 = 可疑
# 4. 导入表异常
# 正常程序导入少数 DLL(通常 10-30 个)
# 恶意程序常使用 LoadLibrary + GetProcAddress 动态解析
# 5. PE 头异常
# SizeOfHeaders 与节表偏移不一致
# 节表的 VirtualAddress 不符合对齐
5.4 逆向工程中的二进制分析
PYTHON
# Python 解析 PE 文件示例
import struct
def parse_pe(filepath):
with open(filepath, 'rb') as f:
# 读取 DOS 头
dos_header = f.read(64)
e_magic = struct.unpack('<H', dos_header[0:2])[0]
e_lfanew = struct.unpack('<I', dos_header[0x3C:0x40])[0]
if e_magic != 0x5A4D: # "MZ"
print("Not a PE file")
return
# 跳转到 PE 头
f.seek(e_lfanew)
pe_signature = f.read(4)
if pe_signature != b'PE\0\0':
print("Invalid PE signature")
return
# 读取 FILE 头
file_header = f.read(20)
machine = struct.unpack('<H', file_header[0:2])[0]
sections = struct.unpack('<H', file_header[2:4])[0]
# 读取 OPTIONAL 头
magic = struct.unpack('<H', f.read(2))[0]
is_64bit = (magic == 0x20B)
print(f"架构: {'x64' if is_64bit else 'x86'}")
print(f"节数量: {sections}")
print(f"Machine: 0x{machine:04X}")
# 读取节表(OPTIONAL 头之后)
opt_header_size = 112 if is_64bit else 96
f.read(opt_header_size - 2) # 已读了 magic
for i in range(sections):
section = f.read(40)
name = section[0:8].rstrip(b'\0').decode('ascii', errors='ignore')
virtual_size = struct.unpack('<I', section[8:12])[0]
virtual_addr = struct.unpack('<I', section[12:16])[0]
raw_size = struct.unpack('<I', section[16:20])[0]
raw_offset = struct.unpack('<I', section[20:24])[0]
print(f" 节 {name}: VA=0x{virtual_addr:08X} Size=0x{virtual_size:X}")
PYTHON
# Python 解析 ELF 文件示例
def parse_elf(filepath):
with open(filepath, 'rb') as f:
ident = f.read(16)
if ident[0:4] != b'\x7fELF':
print("Not an ELF file")
return
is_64bit = ident[4] == 2
is_le = ident[5] == 1
# ELF 头基本字段(64 位)
if is_64bit:
f.seek(16)
e_type, e_machine = struct.unpack('<HH', f.read(4))
f.read(4) # e_version
e_entry = struct.unpack('<Q', f.read(8))[0]
e_phoff = struct.unpack('<Q', f.read(8))[0]
e_shoff = struct.unpack('<Q', f.read(8))[0]
f.read(4) # e_flags
e_ehsize = struct.unpack('<H', f.read(2))[0]
e_phentsize = struct.unpack('<H', f.read(2))[0]
e_phnum = struct.unpack('<H', f.read(2))[0]
else:
# 32 位处理省略
pass
type_names = {0: "NONE", 1: "REL (.o)", 2: "EXEC", 3: "DYN (.so)", 4: "CORE"}
machine_names = {3: "x86", 62: "x86-64", 40: "ARM", 183: "AArch64"}
print(f"类型: {type_names.get(e_type, 'UNKNOWN')}")
print(f"架构: {machine_names.get(e_machine, 'UNKNOWN')}")
print(f"入口点: 0x{e_entry:016X}")
print(f"程序头: {e_phnum} 个条目 @ 0x{e_phoff:X}")
六、总结
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
PE 和 ELF 是理解操作系统与可执行程序之间关系的关键。掌握这两种格式的结构,意味着能读懂编译器的输出、猜出程序的功能(通过导入表)、定位关键代码(通过入口点和节表)、提取隐藏的资源。