Mach-O

YVTU
  2025-05-16 12:18:34 2025-05-16 12:18:34 Created   2025-05-16 12:23:43 2025-05-16 12:23:43 Updated  

Mach-O 是 macOS 和 iOS 平台上使用的可执行文件格式。

Mach-O 文件格式用于 macOS 和 iOS 中的可执行文件、动态库和核心转储等。Mach-O 文件包含多个部分，每个部分都具有特定的结构和功能。

Mach-O 文件头

Mach-O 文件的开始部分是文件头（MachHeader），它包含了文件的基本信息。文件头分为两种类型：32位（mach_header）和 64位（mach_header_64）。下面是一个 64 位 Mach-O 文件头的结构示例：

1
2
3
4
5
6
7
8
9
10
struct mach_header_64 {
    uint32_t    magic;      // 文件的魔数，标识 Mach-O 文件格式
    cpu_type_t  cputype;    // 架构类型
    cpu_subtype_t cpusubtype; // 架构子类型
    uint32_t    filetype;   // 文件类型（例如，可执行文件、动态库）
    uint32_t    ncmds;      // 命令数
    uint32_t    sizeofcmds; // 命令总大小
    uint32_t    flags;      // 标志
    uint32_t    reserved;   // 保留字段
};
  • magic: 用于识别文件格式的标识符，如 MH_MAGIC_64。
  • cputype 和 cpusubtype: 描述 CPU 架构。
  • filetype: 文件类型，如 MH_EXECUTE（可执行文件）。
  • ncmds 和 sizeofcmds: 描述了文件中的加载命令数量和大小。

以下示例展示了如何使用 C 语言读取 Mach-O 文件的头部信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdlib.h>
#include <mach-o/loader.h>

void printMachHeader(const char *filename) {
    FILE *file = fopen(filename, "rb");
    if (!file) {
        perror("fopen");
        return;
    }

    struct mach_header_64 header;
    fread(&header, sizeof(header), 1, file);

    printf("Magic: 0x%x\n", header.magic);
    printf("CPU Type: 0x%x\n", header.cputype);
    printf("CPU Subtype: 0x%x\n", header.cpusubtype);
    printf("File Type: 0x%x\n", header.filetype);
    printf("Number of Commands: %u\n", header.ncmds);
    printf("Size of Commands: %u\n", header.sizeofcmds);
    printf("Flags: 0x%x\n", header.flags);

    fclose(file);
}

int main() {
    printMachHeader("example.macho");
    return 0;
}

加载命令

Mach-O 文件的加载命令（load_command）用于描述文件的各个部分，例如段（segment）和节（section）。每个加载命令都有一个类型字段（cmd），表示命令的具体类型。下面是一个 segment_command_64 的结构示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
struct segment_command_64 {
    uint32_t    cmd;        // 命令类型，指示这是一个段命令
    uint32_t    cmdsize;    // 命令大小
    char        segname[16];// 段名称
    uint64_t    vmaddr;     // 段在内存中的地址
    uint64_t    vmsize;     // 段在内存中的大小
    uint64_t    fileoff;    // 段在文件中的偏移
    uint64_t    filesize;   // 段在文件中的大小
    uint32_t    maxprot;    // 最大保护属性
    uint32_t    initprot;   // 初始化保护属性
    uint32_t    nsects;     // 段中节的数量
    uint32_t    flags;      // 段标志
};
  • cmd: 加载命令的类型，例如 LC_SEGMENT_64。
  • segname: 段的名称，如 __TEXT 或 __DATA。
  • vmaddr 和 vmsize: 描述段在内存中的位置和大小。
  • fileoff 和 filesize: 描述段在文件中的位置和大小。

节（Section）

每个段可以包含多个节（section）。节是 Mach-O 文件中的基本数据单位，包含实际的数据或代码。下面是一个 section_64 的结构示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct section_64 {
    char        sectname[16]; // 节名称
    char        segname[16];  // 段名称
    uint32_t    addr;         // 节的地址
    uint32_t    size;         // 节的大小
    uint32_t    offset;       // 节在文件中的偏移
    uint32_t    align;        // 对齐
    uint32_t    reloff;       // 重定位信息的偏移
    uint32_t    nreloc;       // 重定位条目数量
    uint32_t    flags;        // 节标志
    uint32_t    reserved1;    // 保留字段
    uint32_t    reserved2;    // 保留字段
    uint32_t    reserved3;    // 保留字段
};
  • sectname 和 segname: 描述节和段的名称。
  • addr 和 size: 节在内存中的地址和大小。
  • offset: 节在文件中的偏移。
  • flags: 描述节的属性，如是否可写、可执行等。

Mach-O 文件可能包含重定位信息，用于在加载时调整代码或数据的地址。重定位信息存储在 segment_command 的 reloff 和 nreloc 字段中。

MachOView 3.0版本

MachOView 是一个开源项目，用于解析和可视化 Mach-O 文件，这是 macOS 和 iOS 系统上的二进制文件格式。这个工具可以帮助开发者查看和分析 Mach-O 文件的结构和内容。

MachOKit

MachOKit 是一个用 Swift 编写的开源项目，用于解析和操作 Mach-O 文件格式。它能够利用 Swift 的类型安全和内存管理特性。例如，Swift 的类型系统可以用于定义 Mach-O 文件的各种结构。

MachOKit 解析 Mach-O 文件头部。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import Foundation

struct MachOHeader {
    let magic: UInt32
    let cputype: UInt32
    let cpusubtype: UInt32
    let filetype: UInt32
    let ncmds: UInt32
    let sizeofcmds: UInt32
    let flags: UInt32
}

func parseMachOHeader(data: Data) -> MachOHeader? {
    guard data.count >= 28 else { return nil }
    let magic = data.withUnsafeBytes { $0.load(as: UInt32.self) }
    let cputype = data.withUnsafeBytes { $0.load(fromByteOffset: 4, as: UInt32.self) }
    let cpusubtype = data.withUnsafeBytes { $0.load(fromByteOffset: 8, as: UInt32.self) }
    let filetype = data.withUnsafeBytes { $0.load(fromByteOffset: 12, as: UInt32.self) }
    let ncmds = data.withUnsafeBytes { $0.load(fromByteOffset: 16, as: UInt32.self) }
    let sizeofcmds = data.withUnsafeBytes { $0.load(fromByteOffset: 20, as: UInt32.self) }
    let flags = data.withUnsafeBytes { $0.load(fromByteOffset: 24, as: UInt32.self) }
    
    return MachOHeader(magic: magic, cputype: cputype, cpusubtype: cpusubtype, filetype: filetype, ncmds: ncmds, sizeofcmds: sizeofcmds, flags: flags)
}

MachOKit 使用 Swift 的文件系统 API 来读取 Mach-O 文件的二进制数据。这包括从文件中读取数据并将其解析成 Mach-O 格式的结构体。

1
2
3
func readMachOFile(atPath path: String) -> Data? {
    return FileManager.default.contents(atPath: path)
}

使用 Swift 的结构体和类来映射 Mach-O 文件的各种数据结构。这些数据结构包括 Mach-O 头部、加载命令、段和节等。

1
2
3
4
5
6
7
8
9
10
11
12
struct MachOLoadCommand {
    let cmd: UInt32
    let cmdsize: UInt32
}

func parseLoadCommand(data: Data, offset: Int) -> MachOLoadCommand? {
    guard data.count >= offset + 8 else { return nil }
    let cmd = data.withUnsafeBytes { $0.load(fromByteOffset: offset, as: UInt32.self) }
    let cmdsize = data.withUnsafeBytes { $0.load(fromByteOffset: offset + 4, as: UInt32.self) }
    
    return MachOLoadCommand(cmd: cmd, cmdsize: cmdsize)
}

MachOKit 利用 Swift 的类型安全和内存管理特性，结合对 Mach-O 文件格式的深入理解，来实现对 Mach-O 文件的解析。通过读取二进制数据、映射数据结构、内存映射和错误处理，它能够有效地解析 Mach-O 文件并提供相关信息。

On this page
Mach-O
  1. Mach-O 文件头
  2. 加载命令
  3. 节（Section）
  4. MachOView 3.0版本
  5. MachOKit