PE 与 ELF 二进制文件完全指南

← 返回指南列表

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 是理解操作系统与可执行程序之间关系的关键。掌握这两种格式的结构,意味着能读懂编译器的输出、猜出程序的功能(通过导入表)、定位关键代码(通过入口点和节表)、提取隐藏的资源。


参考