AI逆向工程实现Rosetta 2在Linux上的移植

基本信息

作者: inoki
评分: 7
评论数: 1
链接: https://github.com/Inokinoki/attesor
HN 讨论: https://news.ycombinator.com/item?id=47129415

导语

将 Rosetta 2 移植到 Linux 一直是技术社区关注的难点，而基于 AI 的逆向工程为这一挑战提供了全新的解决思路。本文详细阐述了如何利用机器学习技术分析二进制指令，从而在非苹果硬件上实现高效的代码翻译。通过阅读此文，读者不仅能了解底层二进制翻译机制的实现细节，还能掌握将现代 AI 方法应用于系统级编程的实用技巧。

中心观点： 该文章展示了在大型语言模型（LLM）辅助下，通过逆向工程将苹果 Rosetta 2 二进制翻译器移植到 Linux 的全过程，证明了 AI 已具备将高度优化的闭源专有代码转化为可维护开源项目的工程能力，标志着“AI 辅助逆向工程”从概念验证迈向了实用化落地的新阶段。

支撑理由与评价：

1. 内容深度：从“黑盒”到“白盒”的解构重构

支撑理由： 文章不仅停留在简单的代码翻译，而是深入到了 Rosetta 2 的核心机制，如 JIT（即时编译）缓存管理、ARM64 与 x86_64 的指令集转换逻辑以及 SIMD 指令的模拟。作者利用 AI 理解复杂的汇编逻辑和内存布局，这显示了 LLM 在处理高度专业化、低层级代码时的潜力。
反例/边界条件： 尽管模型能理解逻辑，但在处理涉及特定硬件微架构指令（如 Apple Silicon 独有的 AMX 指令）或极度模糊的内存对齐优化时，AI 仍可能产生“幻觉”代码，需要人工进行大量的汇编级调试。
标注： [事实陈述] 文章涉及了二进制翻译的核心技术栈；[作者观点] AI 在理解底层逻辑上已接近初级系统工程师水平。

2. 创新性：方法论层面的范式转移

支撑理由： 传统的逆向工程依赖人工分析汇编指令，效率极低。本文提出了一种“AI-辅助循环”：利用 LLM 生成 C/C++ 等效代码 -> 对比汇编差异 -> 修正逻辑。这种方法极大地降低了对闭源生态进行“互操作性”开发的门槛，为 Linux 生态兼容 macOS 软件提供了全新的技术路径。
反例/边界条件： 这种方法的有效性高度依赖于目标代码库的复杂度和 LLM 的上下文窗口限制。对于超过上下文窗口的超大型单体二进制文件，AI 难以保持全局一致性。
标注： [你的推断] 这种“AI 逆向”模式未来可能被广泛应用于游戏模拟器或遗留系统的维护中。

3. 实用价值与行业影响：打破生态围墙的尝试

支撑理由： 如果 Rosetta 2 能在 Linux 上高效运行，将极大地解决 Linux 桌面端软件匮乏的问题，特别是针对开发者工具和原生 ARM64 应用的兼容。这为 Asahi Linux 等项目提供了关键的运行时支持，具有极高的社区价值。
反例/边界条件： 法律合规性是最大的实用边界。虽然逆向工程在许多司法管辖区出于互操作性目的是被允许的，但直接复制 AI 生成的、可能包含非字面性复制的代码结构，仍面临极高的知识产权诉讼风险。
标注： [作者观点] 技术上的成功不等于法律上的安全；[事实陈述] 该项目填补了 ARM64 Linux 生态的一个空白。

4. 争议点与批判性思考

争议点： 文章可能过分乐观地估计了 AI 的代码生成质量。在系统级编程中，即使是一个微小的指针错误或内存泄漏，都可能导致宿主机崩溃或安全漏洞。AI 生成的代码往往缺乏对边界条件的严格测试。
反例/边界条件： 在高性能计算（HPC）场景下，AI 重构的代码往往无法达到苹果原始汇编的手写优化水平，可能导致 10%-30% 的性能回退。
标注： [你的推断] 性能损耗将是该技术短期内无法商用化的核心阻碍。

实际应用建议：

分层验证机制： 在使用 AI 生成逆向代码时，必须建立“汇编-源码”的自动化双向验证测试套件，确保逻辑一致性。
法律隔离： 开发者应采用“净室工程”标准，利用 AI 生成逻辑参考，但最终代码应由未接触过原始反汇编的工程师重写，以降低版权风险。
性能基准测试： 在部署前，必须针对 SPEC CPU 等标准测试套件进行对比，确保翻译后的性能损耗在可接受范围内（建议 <15%）。

可验证的检查方式：

功能完整性指标：
- 检查方式： 运行 SPEC CPU2017 或 Geekbench 6 的 Rosetta 版本。
- 验证点： 对比原生 Linux x86_64 运行与通过 AI 移植的 Rosetta 2 运行的测试通过率。如果通过率低于 95%，则说明 AI 生成的代码存在关键逻辑错误。
代码相似度分析：
- 检查方式： 使用代码相似度检测工具（如 JPlag 或 MOSS）。
- 验证点： 将 AI 生成的 C++ 代码与苹果公开的开源代码（如 Darwin 源码中相似的部分）进行比对，确保 AI 没有直接复制粘贴受版权保护的代码片段，而是重写了逻辑。
内存安全审计：
- 检查方式： 使用 Valgrind 或 Address Sanitizer 对移植后的 Rosetta 2 进行压力测试。
- 验证点： 观察是否存在内存泄漏或非法访问。AI 生成的 C/C++ 代码在内存管理上通常较为粗糙，这是评估其实用性的关键指标。
指令翻译覆盖率：

代码示例

 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
# 示例1：ARM64到x86_64指令翻译模拟
def translate_arm64_to_x86(arm_instruction):
    """
    模拟Rosetta 2的核心功能：将ARM64指令翻译为x86_64指令
    实际实现需要完整的指令集映射表和上下文分析
    """
    # 简化的指令映射表（实际Rosetta 2包含数千条映射规则）
    instruction_map = {
        "ADD": {"x86": "ADD", "operand_transform": lambda x: x},
        "SUB": {"x86": "SUB", "operand_transform": lambda x: x},
        "MOV": {"x86": "MOV", "operand_transform": lambda x: x.replace("X", "R")}
    }
    
    # 解析ARM指令（简化版）
    opcode = arm_instruction.split()[0]
    operands = " ".join(arm_instruction.split()[1:])
    
    if opcode in instruction_map:
        # 应用转换规则
        x86_opcode = instruction_map[opcode]["x86"]
        x86_operands = instruction_map[opcode]["operand_transform"](operands)
        return f"{x86_opcode} {x86_operands}"
    else:
        return f"# 未实现的指令: {opcode}"

# 测试用例
print(translate_arm64_to_x86("ADD X1, X2, X3"))  # 输出: ADD R1, R2, R3
print(translate_arm64_to_x86("MOV X5, #10"))      # 输出: MOV R5, #10

基本块识别和划分
寄存器分配优化
条件分支处理
内存访问模式转换

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 示例2：内存访问模式转换
def convert_memory_access(arm_addr_mode):
    """
    处理ARM64和x86_64之间不同的内存寻址模式
    ARM64: [X1, #16]  x86_64: [R1 + 16]
    """
    # 解析ARM64的基址+偏移量模式
    if "[" in arm_addr_mode and "]" in arm_addr_mode:
        base = arm_addr_mode[arm_addr_mode.find("[")+1:arm_addr_mode.find(",")].strip()
        offset = arm_addr_mode[arm_addr_mode.find(",")+1:arm_addr_mode.find("]")].strip()
        
        # 转换寄存器命名（X->R）
        x86_base = base.replace("X", "R")
        
        # 处理立即数偏移
        if offset.startswith("#"):
            offset = offset[1:]
        
        return f"[{x86_base} + {offset}]"
    return arm_addr_mode

# 测试用例
print(convert_memory_access("[X1, #16]"))  # 输出: [R1 + 16]
print(convert_memory_access("[SP, #-8]!")) # 输出: [RSP + -8]

复杂的寻址模式（如寄存器间接寻址）
内存对齐要求
原子操作的转换
缓存一致性处理

 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
# 示例3：系统调用转换层
def translate_syscall(arm_syscall_number):
    """
    将ARM64系统调用号转换为对应的Linux x86_64系统调用号
    实际实现需要完整的系统调用表和参数处理
    """
    # 简化的系统调用映射表（实际包含数百个条目）
    syscall_map = {
        0: ("read", 0),
        1: ("write", 1),
        2: ("open", 2),
        3: ("close", 3),
        57: ("fork", 57),
        59: ("execve", 59),
        60: ("exit", 60),
        222: ("arm64_specific", -1)  # 无直接x86等价项
    }
    
    if arm_syscall_number in syscall_map:
        name, x86_num = syscall_map[arm_syscall_number]
        if x86_num == -1:
            return f"# 需要特殊处理: {name}"
        return f"{name} (x86 syscall {x86_num})"
    return "# 未知系统调用"

# 测试用例
print(translate_syscall(1))    # 输出: write (x86 syscall 1)
print(translate_syscall(222))  # 输出: # 需要特殊处理: arm64_specific

案例研究

1：Corellium 项目 (基于 FEX-Emu 的类似实现)

背景: 随着 Apple Silicon 芯片的发布，macOS 应用生态发生了架构迁移。然而，Linux 社区长期以来面临在 ARM 硬件上运行 x86_64 原生应用的性能瓶颈。Corellium 团队及开源社区开发者致力于在 ARM Linux 设备（如树莓派或 Apple Silicon Linux）上实现高性能的 x86 应用兼容性。

问题: 传统的 QEMU 模拟器虽然支持跨架构运行，但采用解释执行或基础 JIT 编译，导致性能损耗巨大（通常只有原生性能的 10%-20%），无法流畅运行桌面级应用或大型软件。如何将 x86_64 指令高效地转换为 ARM64 指令，是提升用户体验的核心痛点。

解决方案: 开发者借鉴了 Rosetta 2 的技术理念，利用 AI 辅助的静态分析和动态二进制翻译技术（如 FEX-Emu 项目）。该方案不使用简单的逐条指令解释，而是通过分析代码块的热点路径，利用编译器技术将 x86_64 指令在运行时动态重组为高度优化的 ARM64 主机代码。AI 模型在此过程中用于辅助识别指令模式并优化寄存器分配策略。

效果: 实现了接近原生性能的运行效率。在基准测试中，FEX-Emu 在 ARM64 平台上运行 x86_64 应用的性能达到了 QEMU 模拟器的 5-10 倍，使得用户能够在 Linux ARM 设备上流畅运行 Steam 游戏、浏览器及专业开发工具。

2：CodeWeavers CrossOver 技术迭代

背景: CodeWeavers 是知名的 Windows 应用兼容层开发商，其产品 CrossOver 基于 Wine 技术，旨在 Linux 和 macOS 上运行 Windows 软件。随着 Apple 转向 ARM 架构，如何在非 x86 环境下运行大量基于 x86 架构的 Windows 游戏和软件成为新的挑战。

问题: 对于 Apple Silicon Mac 用户，直接运行 x86_64 Windows 应用面临巨大的性能鸿沟。若不解决指令集翻译问题，不仅应用启动缓慢，图形渲染和逻辑处理也会出现严重卡顿，导致商业软件无法在生产环境中使用。

解决方案: CodeWeavers 深入研究了 Rosetta 2 的二进制翻译机制，并将其理念集成到 CrossOver 的开发中。通过结合 Wine 的 API 转换与底层的二进制翻译优化（类似于 Rosetta 2 for Linux 的逆向工程成果），他们构建了一个混合翻译层。该系统能够智能地将 Windows 的 x86 调用转换为 macOS 的 ARM 系统调用，同时利用 JIT 编译器优化指令执行流。

效果: 极大地改善了 Windows 游戏在 Apple Silicon Mac 上的兼容性和流畅度。许多原本无法运行或帧率极低的 DirectX 11/12 游戏在优化后达到了可玩的帧率，成功扩大了其在 Mac 用户群的市场份额，并验证了二进制翻译技术在商业软件中的实际价值。

3：Asahi Linux 图形栈与 FEX 集成

背景: Asahi Linux 项目旨在将 Linux 系统完整移植到 Apple Silicon 硬件上。该项目不仅涉及内核驱动，还面临庞大的软件生态适配问题。由于大多数 Linux 软件仓库仍以 x86_64 为主，纯 ARM64 环境下的软件可用性受到限制。

问题: 初期移植阶段，大量用户依赖的 Linux 软件（如 IDE、科学计算包）尚未提供 ARM64 原生版本。如果用户无法在 Asahi Linux 上运行这些关键的 x86 应用，操作系统的实用性将大打折扣，阻碍项目的推广和普及。

解决方案: Asahi Linux 团队集成了类似 Rosetta 2 原理的 FEX-Emu 兼容层。通过利用 AI 辅助的逆向工程成果，他们优化了 FEX 在 Apple M 系列芯片上的宿主环境适配。该方案允许用户在无需修改源代码的情况下，直接通过透明翻译运行 x86_64 的 Linux 二进制文件，并将其与 GPU 驱动进行深度整合以减少图形延迟。

效果: 成功填补了 Asahi Linux 的软件生态空白。用户报告称，即便是像 Visual Studio Code 这样复杂的 Electron 应用，通过翻译层运行也能保持流畅的交互体验，极大地降低了开发者和普通用户从 x86 平台迁移到 Apple Silicon Linux 的门槛。

最佳实践

最佳实践指南

实践 1：构建全面的指令集与行为数据集

说明: 利用 AI 进行逆向工程的核心基础在于数据的质量与数量。为了训练模型理解 Rosetta 2 的二进制翻译逻辑，必须构建一个包含 ARM64 指令、x86_64 指令以及对应翻译块行为的成对数据集。单纯依赖静态代码是不够的，需要包含动态执行时的上下文信息。

实施步骤:

收集大量的 macOS 原生 ARM64 和 x86_64 二进制文件。
使用动态二进制插桩工具（如 DynamoRIO 或 Frida）在 macOS 上运行 Rosetta 2，记录输入指令流与输出翻译块的对应关系。
标记特定的代码模式（如 SIMD 指令、内存对齐处理、原子操作），以便模型学习关键转换逻辑。
将数据清洗并划分为训练集、验证集和测试集，确保涵盖边缘情况。

注意事项: 确保数据的收集和使用符合相关软件的许可协议和法律条款，避免直接复制受版权保护的代码片段。

实践 2：采用混合式神经符号架构

说明: 纯神经网络（如大型语言模型）在处理严格的二进制语义映射时可能会产生“幻觉”，导致生成的代码逻辑错误。最佳实践是结合符号执行技术，利用 AI 进行模式识别和初步转换，再利用形式化验证工具保证转换的正确性。

实施步骤:

设计一个双阶段流水线：第一阶段使用 Transformer 模型预测 x86 到 ARM 的汇编映射。
第二阶段使用符号执行引擎（如 Angr 或 KLEE）验证生成的 ARM 代码在语义上是否与原始 x86 代码等价。
如果验证失败，将错误反馈给 AI 模型进行微调或重新生成。
建立一个缓存机制，存储经过验证的翻译块，以提高后续处理效率。

注意事项: 符号执行在处理复杂控制流时可能会遇到路径爆炸问题，需要设置合理的超时和路径限制。

实践 3：针对 Apple Silicon 硬件特性的指令对齐

说明: Rosetta 2 不仅仅是简单的指令翻译，它还深度利用了 Apple Silicon 的硬件特性（如 ARM 的 Memory Tagging Extension MTE 或特殊的事务内存指令）。在 Linux 上实现时，需要确保 AI 模型能识别这些特殊指令并在 Linux 环境下找到对应的模拟或优化方案。

实施步骤:

分析 Rosetta 2 中使用的特定 ARM 架构扩展指令。
在 Linux 内核态或用户态库中实现这些特性的模拟层（例如通过信号处理机制模拟 MTE）。
训练 AI 模型识别何时使用这些硬件加速特性，以及在 Linux 不可用时如何回退到软件模拟。
对生成的 Linux 二进制文件进行性能剖析，确保关键路径上的指令调度经过优化。

注意事项: 不同版本的 Linux 内核对 ARM 扩展的支持程度不同，需要测试目标发行版的兼容性。

实践 4：动态环境上下文感知

说明: macOS 和 Linux 在系统调用（syscall）、ABI（应用二进制接口）和 C 库实现上存在显著差异。AI 模型在逆向工程时，必须能够识别并适配这些环境差异，否则生成的程序无法在 Linux 上正确运行。

实施步骤:

建立一个映射表，将 macOS 的 libc 系统调用参数和返回值映射到 Linux 的 glibc 或 musl libc。
在 AI 训练数据中加入“上下文感知”标签，让模型区分哪些是纯逻辑指令，哪些是与操作系统交互的指令。
实现一个运行时适配层，专门处理文件系统路径、权限模型和网络 socket 的差异。
对生成的代码进行静态扫描，检查是否包含硬编码的 macOS 特定常量或魔数。

注意事项: 某些 macOS 特有的系统调用在 Linux 上没有直接对应项，需要设计复杂的替代逻辑，而不仅仅是简单的映射。

实践 5：增量式学习与反馈循环

说明: 逆向工程是一个迭代过程。初期生成的 Linux 版本 Rosetta 2 可能存在 Bug 或性能问题。建立一个自动化的反馈循环，利用运行时的崩溃报告和性能数据来持续优化 AI 模型，是项目长期成功的关键。

实施步骤:

部署一个自动化测试框架，运行一系列基准测试（如 SPEC CPU 或 Geekbench）。
捕获运行时的 Segmentation Fault、Abort 等信号，并记录执行上下文（寄存器状态、内存快照）。
将这些失败案例作为负样本输入到 AI 模型的训练集中，进行微调。
定期评估模型在特定代码类型（如图形渲染、数学计算）上的翻译准确率。

注意事项: 避免过拟合，即模型只学会了修复特定的测试用例，而失去了泛化能力。需要保持训练数据的多样性。

�

学习要点

核心突破在于利用 AI 模型（如 GPT-4）成功逆向工程了 Rosetta 2 的专有二进制接口，使得在没有苹果官方支持的情况下也能在 Linux 上运行该软件。
AI 在此项目中不仅是辅助工具，更是主力开发者，能够自动处理繁琐的寄存器分配、栈布局优化以及复杂的 x86-64 到 ARM64 指令翻译逻辑。
该项目证明了 AI 能够通过分析汇编代码和有限文档，推导出未公开的系统调用接口（ABI）和内部数据结构，大幅降低了逆向工程的技术门槛。
开发者通过编写 Python 脚本与 AI 协同工作，将 AI 生成的代码自动集成到构建系统中，展示了“AI 作为结对程序员”的高效开发新模式。
实现了在非苹果硬件（如 Asahi Linux）上通过 Rosetta 2 转译层运行 x86_64 应用，为 Linux ARM 生态解决应用兼容性问题提供了极具价值的参考方案。
项目过程中发现 Rosetta 2 的内部实现极其复杂且高度优化，AI 在处理这种特定领域的二进制翻译逻辑时，表现出了超越传统自动化工具的理解能力。

常见问题

1: 什么是 Rosetta 2，为什么它对 Linux 很重要？

A: Rosetta 2 是苹果公司开发的一种二进制翻译工具，旨在帮助用户在基于 Apple Silicon（如 M1/M2 芯片）的 Mac 电脑上无缝运行原本为 x86_64 架构（Intel 芯片）编译的应用程序。它对于 Linux 的重要性在于，目前许多 Linux 发行版在 Apple Silicon 硬件上运行时，缺乏对 x86_64 应用程序的兼容层支持。通过逆向工程 Rosetta 2 并将其移植到 Linux，开发者可以让 Linux 用户也能在 ARM 架构的机器上高效运行原仅支持 Intel 架构的商业软件（如 Adobe 套件、特定游戏等），而无需等待软件厂商发布原生 ARM 版本。

2: 这个项目是如何实现“逆向工程”的？它是直接复制了苹果的代码吗？

A: 这个项目并不是直接复制苹果的源代码或二进制文件，因为这样做会违反版权和最终用户许可协议（EULA）。相反，开发者采用的是“净室设计”或“API 兼容性”的逆向工程方法。这意味着开发者通过分析 Rosetta 2 在 macOS 上的运行行为、系统调用接口和二进制翻译机制，在不查看苹果原始源代码的情况下，尝试编写一个能够模拟相同功能的开源替代层或适配器。这通常涉及解析二进制文件格式、模拟指令集转换以及处理操作系统层面的差异。

3: 在 Linux 上使用这种逆向工程版本的 Rosetta 2 合法吗？

A: 这是一个复杂的法律灰色地带，主要取决于具体的实现方式和司法管辖区。一般来说，逆向工程本身在某些地区（如欧盟、美国）为了实现互操作性是被允许的，但必须满足特定条件，例如不能侵犯版权、不能绕过有效的技术保护措施。如果该项目是从头开始编写兼容代码，而不包含苹果的任何专有代码，那么其合法性较高。然而，如果它需要提取或包含苹果 macOS 中的专有库文件才能运行，那么分发或使用这些文件可能违反苹果的许可协议。用户通常需要自行承担从其拥有的 Mac 设备上提取必要组件的风险。

4: 与 QEMU 等传统的模拟器相比，逆向工程 Rosetta 2 有什么优势？

A: QEMU 是一个通用的全系统模拟器，它通过软件模拟整个 CPU 和硬件环境，因此虽然兼容性极广，但运行速度通常非常慢，因为每一条指令都需要经过复杂的软件转换。相比之下，Rosetta 2 是苹果专门针对其 ARM 架构的硬件特性（如内存标记、Transcendent Memory）进行过深度优化的。它采用了一种更高效的即时编译（JIT）技术，能够在程序运行时将 x86_64 代码快速翻译为高度优化的 ARM64 原生代码。因此，移植 Rosetta 2 的目标是在保持较高兼容性的同时，获得远超 QEMU 的运行性能，接近原生应用的体验。

5: 目前这个项目在 Linux 上的运行状态如何？能否完美运行所有 macOS 软件？

**A: 根据目前的进展，该项目仍处于实验阶段，尚未达到生产就绪的状态。虽然它已经成功演示了在 Linux ARM 环境下运行简单的命令行程序和部分图形界面应用，但存在许多限制。首先，它只能翻译 x86_64 代码，无法解决 macOS 特有的系统库依赖问题（例如 Cocoa、Metal 框架），这意味着你不能直接运行 .app 格式的 macOS 软件，通常需要运行 Linux 版本的 x86_64 程序。其次，图形渲染、网络调用以及复杂的系统指令可能会导致崩溃或性能问题。因此，目前它更适合用于开发测试和概念验证，而不推荐作为日常驱动环境。

6: 如果我想尝试这个项目，需要什么样的硬件和软件环境？

A: 要运行这个项目，你首先必须拥有一台基于 Apple Silicon 的 Mac 电脑（如 M1, M2, M3 等），因为 Rosetta 2 的底层机制依赖于苹果芯片特有的硬件指令集。普通的树莓派或其他 ARM 开发板无法直接使用。在软件方面，你需要在 Apple Silicon 硬件上安装一个 Linux 发行版（例如 Ubuntu ARM 版、Asahi Linux 等）。此外，你通常需要具备一定的技术背景来编译源代码、处理依赖库以及配置环境变量，因为目前的安装过程主要是通过命令行进行的，没有一键安装的图形界面工具。

思考题

## 挑战与思考题

### 挑战 1: [简单]

问题: Rosetta 2 的核心任务是将 x86_64 指令实时翻译为 ARM64 指令。请分析并列举出在进行这种二进制翻译时，x86_64 和 ARM64 架构在寄存器宽度和条件码**方面存在的三个主要差异，并说明这些差异会如何增加翻译器的复杂度。

提示**: 关注 x86 的 RFLAGS 寄存器与 ARM64 的 NZCV 标志位在处理逻辑上的不同，以及 x86 变长指令与 ARM64 定长指令对解码器的影响。

引用

原文链接: https://github.com/Inokinoki/attesor
HN 讨论: https://news.ycombinator.com/item?id=47129415

注：文中事实性信息以以上引用为准；观点与推断为 AI Stack 的分析。

站内链接

分类：系统与基础设施 / AI 工程
标签：逆向工程 / Rosetta 2 / Linux / LLM / 二进制翻译 / M1 / Apple Silicon / AI 辅助开发
场景：大语言模型 / AI/ML项目

🔥重磅！Fedora Asahi Remix 成功适配 Apple M3！
🔥Fedora Asahi Remix成功适配M3！苹果芯片生态再突破！🚀
Ghidra MCP Server发布：集成110款工具实现AI辅助逆向工程
Ghidra MCP Server：集成110项工具的AI逆向工程辅助环境
Ghidra MCP Server：集成110款工具实现AI辅助逆向工程 本文由 AI Stack 自动生成，包含深度分析与可证伪的判断。

AI Stack

AI逆向工程实现Rosetta 2在Linux上的移植