LIEF 修改 PE 导入表(Import Table):新增、删除导入与 IAT 重定位实战

原创2026-10-12 13:12:261,957 阅读
文章标签:逆向工程开发工具

LIEF 修改 PE 导入表(Import Table):新增、删除导入与 IAT 重定位实战

PE 导入表(Import Table)是 Windows 可执行文件中连接程序与外部 DLL 函数的关键结构,修改它远比增删一个节复杂:表布局随链接器而异、IAT 与汇编指令紧密耦合,任何轻率的原地改写都可能导致二进制损坏。本文以 LIEF(Library to Instrument Executable Formats)官方文档 doc/sphinx/formats/pe/modifications/imports.md 为核心,结合 src/PE/Builder.tcc 的构建器实现与 tests/pe/test_builder.py 的测试用例,系统讲解 LIEF 支持的四种导入表修改操作——移除整个导入库、移除单个导入函数、新建导入、为既有导入追加函数,以及支撑这些操作的核心机制:导入表整体搬迁与"保留原始 IAT"策略。读完本文,你将掌握用 Python、C++、Rust 三种语言安全修改 PE 导入表的完整方案,并理解其背后的布局约束与规避原理。

导入表修改:支持哪些操作?

LIEF 对导入表的修改能力有明确边界。官方文档给出了一张操作支持矩阵,凡未列入该表的操作一律视为不受支持,强行使用可能生成损坏的二进制:

操作 是否支持
新增一个导入(Add new import) ✅ 支持
新增一个导入函数(Add an imported function) ✅ 支持
移除一个导入(Remove an import) ✅ 支持
移除一个导入函数(Remove an imported function) ✅ 支持
扩展原始 IAT(Extend original IAT) ❌ 不支持
扩展原始 ILT(Extend original ILT) ✅ 支持

实现更新提示:与 LIEF 早期版本相比,导入表修改逻辑已被完全重设计,在修改或重建 PE 二进制时更加可靠。核心 API 定义可参见 include/LIEF/PE/Binary.hpp(add_import / remove_import / remove_all_imports)与 include/LIEF/PE/Import.hpp(add_entry / remove_entry)。

为什么要重定位导入表:从 MSVC 与 LLVM 的布局差异说起

对 PE 导入表进行通用而可靠的修改之所以困难,根源在于其布局极其灵活、且与汇编代码强耦合。理解这一点,先要看清 MSVC 链接器 link.exe 生成的典型布局:

导入表由数据目录中 IMPORT_TABLE 索引项引用:其 RVA 指向描述导入表的原始结构起点,Size 字段给出该表长度。对每个被导入的库(如 kernel32.dll),导入头(Import Header)引用三个位置:

  1. 导入查找表(ILT,Import Lookup Table)的 RVA;
  2. 导入库名称字符串(如 kernel32.dll)的 RVA;
  3. 导入地址表(IAT,Import Address Table)的 RVA。

IAT 与 ILT 都指向一个以 0 结尾的整数数组(元素宽度等于指针宽度)。在磁盘上的 PE 文件中,两表中每个槽位存放的都是指向导入函数名称字符串(或序号)的 RVA。例如二进制导入了 kernel32.dll!GetCurrentProcess 与 kernel32.dll!TerminateProcess,则 ILT/IAT 内容为:

uintptr_t IAT[3] = {
   RVA("GetCurrentProcess"),
   RVA("TerminateProcess"),
   0
};

uintptr_t ILT[3] = {
   RVA("GetCurrentProcess"),
   RVA("TerminateProcess"),
   0
};

Windows 加载并解析导入时,会把解析出的真实函数地址回填进 IAT:

  uintptr_t IAT[3] = {
-   RVA("GetCurrentProcess"),
-   RVA("TerminateProcess"),
+   0x7ff7bfdb3f00, // GetCurrentProcess resolved address
+   0x7ff7ceab4f00, // TerminateProcess resolved address
    0
  };

而按照微软文档,ILT 在加载后保持不变。需要特别强调的是:虽然导入头引用了三个 RVA,但 PE 格式与 Windows 加载器并不强制它们之间的排列顺序——ILT 可以出现在 IAT 之前,反之亦然。MSVC link.exe 的典型布局是:IAT 在最前,接着是导入头,然后是 ILT,最后才是字符串区(DLL 名与函数名);而 LLVM ld-link.exe 生成的 PE 则默认把 IAT 排在 ILT 之后,两者布局截然不同。构建器源码 src/PE/Builder.tcc 中的注释也印证了这一点——它还额外指出 MinGW 生成的布局同样不同。

既然无法假设任何预定义的布局或顺序,就不能安全地在原位置重建一张新表,否则极可能覆盖原有重要数据;而且一旦新增导入或导入函数,修改后的导入表也不再能塞进原来的位置。因此,LIEF 的通用方案是把导入表整体搬迁到二进制内的其他位置。

⚠️ Builder 配置警告:由于该修改不是"保守型"操作(即使导入表内容未变,它也会影响二进制布局),必须通过构建器配置属性 config.imports = True 显式启用,参见 include/LIEF/PE/Builder.hpp 中 config_t 的注释:imports 默认值为 false,只有在修改导入时才应打开。

核心策略:保留原始 IAT,只搬走其余部分

导入头、ILT 以及字符串(DLL 名、函数名)都可以自由搬迁,但 IAT 不能随意挪动。原因是导入表告知 Windows 加载器程序需要哪些函数;加载器解析后把地址写入 IAT,汇编代码则通过桩指令(stub)访问该表,典型形式有:

jmp [rip + #IAT_FIXUP];  // e.g. jmp *IAT[3];

或

mov rax, [rip + #IAT_FIXUP];
call rax;

若在不考虑这些指令的情况下把 IAT 搬到别处,所有引用 IAT 的指令都会失效。

业界常见解法之一是在原 IAT 与新 IAT 之间创建蹦床(trampoline),这正是 LIEF 早期版本采用的做法;而 LIEF 当前采用的新方案是:搬迁导入表的大部分元素(头、ILT、字符串),但把原始 IAT 留在原位置不动。构建器源码 src/PE/Builder.tcc 中的 build_imports 注释完整记录了这一设计:汇编侧 jmp [rip + IAT_OFF] 或 mov rax, [rip + IAT_OFF]; call rax 的指令模式决定了 IAT 不可移动,而导入头、ILT、Hint Names、DLL Names 均可搬到别处,最终新布局为"Import Headers + ILT + Names + 用户新增导入专用的新 IAT"。

保留原始 IAT 的收益是无需生成任何汇编、不需要蹦床;代价则是修改导入的方式受约束——必须保证未被触碰的 IAT 与使用它的汇编代码保持一致性,这直接催生了下面几种操作各自的工作方式。

移除一个导入库(Remove Import)

使用 Binary.remove_import(name) 移除指定库,或用 remove_all_imports() 清空全部导入(对应 C++ 声明见 include/LIEF/PE/Binary.hpp 中的 bool remove_import(const std::string& name) 与 void remove_all_imports())。修改后必须用 config.imports = True 重建并写出文件:

::::{tabs} :::{tab} Python

import lief

pe: lief.PE.Binary

pe.remove_import("kernel32.dll")

config = lief.PE.Builder.config_t()
config.imports = True

pe.write("new.exe", config)

::: :::{tab} C++

#include <LIEF/PE.hpp>

std::unique_ptr<LIEF::PE::Binary> pe;

pe->remove_import("kernel32.dll");

LIEF::PE::Builder::config_t config;
config.imports = true;

pe->write("new.exe", config);

::: :::{tab} Rust

let pe: &mut lief::pe::Binary = some_pe;

pe.remove_import("kernel32.dll");

let mut config = lief::pe::builder::Config::default();
config.imports = true;

pe.write_with_config("new.exe", config);

::: ::::

完整可运行示例参见 doc/code/python/pe_imports.py、doc/code/cpp/pe_imports.cpp 与 doc/code/rust/src/pe_imports.rs。测试用例 tests/pe/test_builder.py 的 test_build_remove_imports 演示了"清空全部导入后重建"的完整流程:解析样本 → remove_all_imports() → config.imports = True → 写出 → 重新解析并断言 len(new.imports) == 0,同时通过 check_layout 校验新二进制布局合法。在 src/PE/Builder.tcc 中可以看到对应的底层行为:若 binary_->imports_.empty(),构建器会把 IMPORT_TABLE 数据目录的 RVA 与 Size 都清零。

移除单个导入函数(Remove an Imported Function)

使用 Import.remove_entry(name) 或 Import.remove_entry(ordinal) 删除某个具体函数(API 见 include/LIEF/PE/Import.hpp):

::::{tabs} :::{tab} Python

kernel32 = pe.get_import("kernel32.dll")
assert kernel32 is not None
kernel32.remove_entry("IsDebuggerPresent")

config = lief.PE.Builder.config_t()
config.imports = True

pe.write("new.exe", config)

::: :::{tab} C++

LIEF::PE::Import* kernel32 = pe->get_import("kernel32.dll");
kernel32->remove_entry("IsDebuggerPresent");

LIEF::PE::Builder::config_t config;
config.imports = true;

pe->write("new.exe", config);

::: :::{tab} Rust

if let Some(mut kernel32) = pe.import_by_name("kernel32.dll") {
    kernel32.remove_entry_by_name("IsDebuggerPresent");
}

let mut config = lief::pe::builder::Config::default();
config.imports = true;

pe.write_with_config("new.exe", config);

::: ::::

这里存在一个关键约束:删除操作会从 IAT 中移除一个槽位,而没有汇编补丁(或蹦床)就无法收缩该表。因此 LIEF 的变通方案是:用另一个已存在的条目填充被删除的条目位置。例如从 Kernel32.dll 移除 IsDebuggerPresent 后,IAT 的变化为:

// Before: Import Address Table of Kernel32.dll
uintptr_t IAT[] = {
   RVA("GetCurrentProcess"),
   RVA("IsDebuggerPresent"),
   RVA("TerminateProcess"),
   0
};

// After: Import Address Table of Kernel32.dll
uintptr_t IAT[] = {
   RVA("GetCurrentProcess"),
   RVA("GetCurrentProcess"),
   RVA("TerminateProcess"),
   0
};

💡 隐式操作提示:LIEF 会在构建过程中隐式地完成这种占位填充。它的合法性建立在两点之上:其一,被删除函数腾出的 IAT 槽位可被复用作任意其他导入函数的占位符;其二,Windows 允许同一导入存在重复符号,因此复制一个导入条目完全合法,且维持了 IAT 的原始长度。构建器在 src/PE/Builder.tcc 中通过"计算已删除条目与当前位置的槽位差、用当前条目补齐"的 Padding count 逻辑实现这一点。

新建一个导入(Creating a New Import)

用 Binary.add_import(name) 新建导入库,再用 Import.add_entry(name) 添加函数(声明见 include/LIEF/PE/Binary.hpp 与 include/LIEF/PE/Import.hpp)。add_import 还支持可选参数 pos 指定插入位置,负数(默认 -1)表示追加到列表末尾:

::::{tabs} :::{tab} Python

stdio = pe.add_import("api-ms-win-crt-stdio-l1-1-0.dll")
stdio.add_entry("puts")

config = lief.PE.Builder.config_t()
config.imports = True

pe.write("new.exe", config)

::: :::{tab} C++

LIEF::PE::Import& stdio = pe->add_import("api-ms-win-crt-stdio-l1-1-0.dll");
LIEF::PE::ImportEntry& _puts = stdio.add_entry("puts");

LIEF::PE::Builder::config_t config;
config.imports = true;

pe->write("new.exe", config);

::: :::{tab} Rust

let mut stdio = pe.add_import("api-ms-win-crt-stdio-l1-1-0.dll");
let _puts = stdio.add_entry_by_name("puts");

let mut config = lief::pe::builder::Config::default();
config.imports = true;

pe.write_with_config("new.exe", config);

::: ::::

当 LIEF 重写二进制时,会在搬迁后的导入表附近生成一张新的 IAT,其中存放新导入函数(上例中的 puts)的条目,由 Windows 加载器负责解析。这里需要注意一个 API 细节:新导入函数的 IAT 地址(即 include/LIEF/PE/ImportEntry.hpp 中 iat_address() 所返回的原始 IAT 地址)在 write 操作之前没有任何可靠手段可以获知——新 IAT 的位置是在 LIEF 写出过程中才确定的。

用 resolved_iat_cbk 回调捕获新 IAT 地址

为了解决上述限制、并允许在新 IAT 创建后做后续修改,Builder.config_t 提供了 resolved_iat_cbk 回调属性(类型定义为 std::function<void(Binary*, const Import*, const ImportEntry*, uint32_t)>,见 include/LIEF/PE/Builder.hpp):

::::{tabs} :::{tab} Python

def iat_resolution_cbk(
    pe: lief.PE.Binary, imp: lief.PE.Import, entry: lief.PE.ImportEntry, rva: int
):
    # Process
    return

stdio = pe.add_import("api-ms-win-crt-stdio-l1-1-0.dll")
stdio.add_entry("puts")

config = lief.PE.Builder.config_t()
config.imports = True
config.resolved_iat_cbk = iat_resolution_cbk

pe.write("new.exe", config)

::: :::{tab} C++

LIEF::PE::Import& stdio = pe->add_import("api-ms-win-crt-stdio-l1-1-0.dll");
LIEF::PE::ImportEntry& _puts = stdio.add_entry("puts");

LIEF::PE::Builder::config_t config;
config.imports = true;
config.resolved_iat_cbk = [](LIEF::PE::Binary* pe, const LIEF::PE::Import* imp,
                             const LIEF::PE::ImportEntry* entry,
                             uint32_t RVA) -> void {
  // Process
  return;
};

pe->write("new.exe", config);

::: ::::

⚠️ Rust 绑定限制:该回调目前在 Rust 绑定中尚未提供。

⚠️ Nanobind 泄漏警告:由于 Python 引用计数的原因,使用该回调时可能遇到 Nanobind 关于泄漏对象的警告,可用 lief.disable_leak_warning()(声明于 api/python/lief/init.pyi)关闭。

回调的第四个参数 uint32_t RVA,就是加载器写入被解析函数(ImportEntry)地址的 IAT 槽位地址。例如跟踪一组新增的 CRT 导入:

def iat_resolution_cbk(pe: lief.PE.Binary, imp: lief.PE.Import,
                       entry: lief.PE.ImportEntry, rva: int):
    print(f"{imp.name}!{entry.name}: 0x{rva:010x}")

# [...]
stdio = dll.add_import("api-ms-win-crt-stdio-l1-1-0.dll")

stdio.add_entry("puts")
stdio.add_entry("__p__commode")
stdio.add_entry("_set_fmode")

# [...]

可得到类似输出:

api-ms-win-crt-stdio-l1-1-0.dll!puts:         0x000046c9e2
api-ms-win-crt-stdio-l1-1-0.dll!__p__commode: 0x000046c9ea
api-ms-win-crt-stdio-l1-1-0.dll!_set_fmode:   0x000046c9f2

据此,puts 的 IAT 地址为 RVA 0x000046c9e2,可用来修补需要该地址的代码段:

def iat_resolution_cbk(pe: lief.PE.Binary, imp: lief.PE.Import,
                       entry: lief.PE.ImportEntry, rva: int):
  code = pe.get_section(".injected")
  patch(code, rva)

从实现上看,src/PE/Builder.tcc 会在导入表构建完成后遍历所有导入条目,凡是 iat_address() 标记为已搬迁(RELOCATED_IAT 标志位)的条目,都以 import_dir->RVA() 为基址计算最终 RVA 并回调;构建器同时为新 .idata 节设置 CNT_INITIALIZED_DATA | MEM_READ | MEM_WRITE | CNT_CODE 等特征,确保加载器向自定义 IAT 写入解析地址时不会触发访问违规(这部分设计动机在 src/PE/Builder.tcc 注释中有详细说明)。端到端验证可参考 tests/pe/test_builder.py:该测试新增 api-ms-win-crt-stdio-l1-1-0.dll!puts,注入调用 puts 的 .lief 代码节,利用回调把 jmp [rip + fixup] 中的相对位移改写为指向新 IAT,最终在 Windows x64 上实际加载输出 Hello World。

为既有导入追加函数(Adding a New Imported Function)

向已存在的导入中追加函数同样可行,但必须谨慎以免损坏二进制。由于无法扩展某个导入的原始 IAT,变通方案是:新建一个与现有导入同名的导入,并把函数加到这个"重复导入"上。示意如下:

// Original Import
* kernel32.dll
  │
  ├── GetCurrentProcessId    IAT[0]
  │
  ├── GetCurrentThreadId     IAT[1]
  │
  └── GetModuleHandleW       IAT[2]

// Duplicated import
* kernel32.dll
  │
  └── GetStartupInfoW        NEW IAT[0]
       │
       └────────-> New Import

代码与"新建导入"一节几乎一致——区别仅在于传入的库名改为已有的 kernel32.dll,LIEF 会自动创建该库的重复导入并为其分配新的 IAT:

::::{tabs} :::{tab} Python

kernel32 = pe.add_import("kernel32.dll")
kernel32.add_entry("GetStartupInfoW")

config = lief.PE.Builder.config_t()
config.imports = True

pe.write("new.exe", config)

::: :::{tab} C++

LIEF::PE::Import& kernel32 = pe->add_import("kernel32.dll");
LIEF::PE::ImportEntry& _GetStartupInfoW = kernel32.add_entry("GetStartupInfoW");

LIEF::PE::Builder::config_t config;
config.imports = true;

pe->write("new.exe", config);

::: :::{tab} Rust

let mut kernel32 = pe.add_import("kernel32.dll");
let _get_startup_info = kernel32.add_entry_by_name("GetStartupInfoW");

let mut config = lief::pe::builder::Config::default();
config.imports = true;

pe.write_with_config("new.exe", config);

::: ::::

小结与实践建议

围绕 LIEF 的导入表修改,可以归纳出几条核心结论:

  • 操作边界清晰:新增导入/导入函数、移除导入/导入函数是官方支持的操作;扩展原始 IAT 不受支持,扩展原始 ILT 受支持。超出支持范围的操作可能导致二进制损坏。
  • 布局与代码耦合是根本约束:IAT 被汇编桩指令直接引用,不能随意搬迁;LIEF 的策略是保留原始 IAT 原地不动,仅搬迁导入头、ILT 与字符串,从而避免生成蹦床汇编。
  • 显式启用构建:所有导入修改都必须通过 config.imports = True(C++/Rust 为 config.imports = true)显式打开,因为导入表重建本质上是非保守的布局修改。
  • 删除与追加都靠"复用/重复"规避 IAT 限制:删除函数用其他条目填充占位以保持 IAT 长度;追加函数则创建同名重复导入承载新条目。
  • 新 IAT 地址在写出后才可知:需要精确地址做代码修补时,务必使用 resolved_iat_cbk 回调(Python/C++ 可用,Rust 暂未提供),结合 lief.disable_leak_warning() 消除 Nanobind 泄漏告警。

实操时建议参照 doc/code/python/pe_imports.py、doc/code/cpp/pe_imports.cpp、doc/code/rust/src/pe_imports.rs 中的完整示例,并用 lief.PE.parse 重新解析写出产物、配合 lief.PE.check_layout 校验布局,再结合 tests/pe/test_builder.py 中导入注入与移除的测试流程进行验证。

登录后查看全文
LIEF